Index: uspace/lib/softfloat/Makefile =================================================================== --- uspace/lib/softfloat/Makefile (revision 7aa6b99d7bd8a569a8bc3394901a26702aa2a5a9) +++ uspace/lib/softfloat/Makefile (revision 1dbd189b0e98a0f835bd872d52126bb32e841feb) @@ -29,17 +29,16 @@ USPACE_PREFIX = ../.. -EXTRA_CFLAGS = -Iinclude LIBRARY = libsoftfloat SOURCES = \ - generic/add.c \ - generic/common.c \ - generic/comparison.c \ - generic/conversion.c \ - generic/div.c \ - generic/mul.c \ - generic/other.c \ - generic/softfloat.c \ - generic/sub.c + softfloat.c \ + common.c \ + add.c \ + sub.c \ + div.c \ + mul.c \ + comparison.c \ + conversion.c \ + other.c include $(USPACE_PREFIX)/Makefile.common Index: uspace/lib/softfloat/add.c =================================================================== --- uspace/lib/softfloat/add.c (revision 1dbd189b0e98a0f835bd872d52126bb32e841feb) +++ uspace/lib/softfloat/add.c (revision 1dbd189b0e98a0f835bd872d52126bb32e841feb) @@ -0,0 +1,416 @@ +/* + * Copyright (c) 2005 Josef Cejka + * Copyright (c) 2011 Petr Koupy + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup softfloat + * @{ + */ +/** @file Addition functions. + */ + +#include "sftypes.h" +#include "add.h" +#include "comparison.h" +#include "common.h" + +/** Add two single-precision floats with the same sign. + * + * @param a First input operand. + * @param b Second input operand. + * @return Result of addition. + */ +float32 add_float32(float32 a, float32 b) +{ + int expdiff; + uint32_t exp1, exp2, frac1, frac2; + + expdiff = a.parts.exp - b.parts.exp; + if (expdiff < 0) { + if (is_float32_nan(b)) { + /* TODO: fix SigNaN */ + if (is_float32_signan(b)) { + } + + return b; + } + + if (b.parts.exp == FLOAT32_MAX_EXPONENT) { + return b; + } + + frac1 = b.parts.fraction; + exp1 = b.parts.exp; + frac2 = a.parts.fraction; + exp2 = a.parts.exp; + expdiff *= -1; + } else { + if ((is_float32_nan(a)) || (is_float32_nan(b))) { + /* TODO: fix SigNaN */ + if (is_float32_signan(a) || is_float32_signan(b)) { + } + return (is_float32_nan(a) ? a : b); + } + + if (a.parts.exp == FLOAT32_MAX_EXPONENT) { + return a; + } + + frac1 = a.parts.fraction; + exp1 = a.parts.exp; + frac2 = b.parts.fraction; + exp2 = b.parts.exp; + } + + if (exp1 == 0) { + /* both are denormalized */ + frac1 += frac2; + if (frac1 & FLOAT32_HIDDEN_BIT_MASK ) { + /* result is not denormalized */ + a.parts.exp = 1; + } + a.parts.fraction = frac1; + return a; + } + + frac1 |= FLOAT32_HIDDEN_BIT_MASK; /* add hidden bit */ + + if (exp2 == 0) { + /* second operand is denormalized */ + --expdiff; + } else { + /* add hidden bit to second operand */ + frac2 |= FLOAT32_HIDDEN_BIT_MASK; + } + + /* create some space for rounding */ + frac1 <<= 6; + frac2 <<= 6; + + if (expdiff < (FLOAT32_FRACTION_SIZE + 2) ) { + frac2 >>= expdiff; + frac1 += frac2; + } else { + a.parts.exp = exp1; + a.parts.fraction = (frac1 >> 6) & (~(FLOAT32_HIDDEN_BIT_MASK)); + return a; + } + + if (frac1 & (FLOAT32_HIDDEN_BIT_MASK << 7) ) { + ++exp1; + frac1 >>= 1; + } + + /* rounding - if first bit after fraction is set then round up */ + frac1 += (0x1 << 5); + + if (frac1 & (FLOAT32_HIDDEN_BIT_MASK << 7)) { + /* rounding overflow */ + ++exp1; + frac1 >>= 1; + } + + if ((exp1 == FLOAT32_MAX_EXPONENT ) || (exp2 > exp1)) { + /* overflow - set infinity as result */ + a.parts.exp = FLOAT32_MAX_EXPONENT; + a.parts.fraction = 0; + return a; + } + + a.parts.exp = exp1; + + /* Clear hidden bit and shift */ + a.parts.fraction = ((frac1 >> 6) & (~FLOAT32_HIDDEN_BIT_MASK)); + return a; +} + +/** Add two double-precision floats with the same sign. + * + * @param a First input operand. + * @param b Second input operand. + * @return Result of addition. + */ +float64 add_float64(float64 a, float64 b) +{ + int expdiff; + uint32_t exp1, exp2; + uint64_t frac1, frac2; + + expdiff = ((int) a.parts.exp) - b.parts.exp; + if (expdiff < 0) { + if (is_float64_nan(b)) { + /* TODO: fix SigNaN */ + if (is_float64_signan(b)) { + } + + return b; + } + + /* b is infinity and a not */ + if (b.parts.exp == FLOAT64_MAX_EXPONENT) { + return b; + } + + frac1 = b.parts.fraction; + exp1 = b.parts.exp; + frac2 = a.parts.fraction; + exp2 = a.parts.exp; + expdiff *= -1; + } else { + if (is_float64_nan(a)) { + /* TODO: fix SigNaN */ + if (is_float64_signan(a) || is_float64_signan(b)) { + } + return a; + } + + /* a is infinity and b not */ + if (a.parts.exp == FLOAT64_MAX_EXPONENT) { + return a; + } + + frac1 = a.parts.fraction; + exp1 = a.parts.exp; + frac2 = b.parts.fraction; + exp2 = b.parts.exp; + } + + if (exp1 == 0) { + /* both are denormalized */ + frac1 += frac2; + if (frac1 & FLOAT64_HIDDEN_BIT_MASK) { + /* result is not denormalized */ + a.parts.exp = 1; + } + a.parts.fraction = frac1; + return a; + } + + /* add hidden bit - frac1 is sure not denormalized */ + frac1 |= FLOAT64_HIDDEN_BIT_MASK; + + /* second operand ... */ + if (exp2 == 0) { + /* ... is denormalized */ + --expdiff; + } else { + /* is not denormalized */ + frac2 |= FLOAT64_HIDDEN_BIT_MASK; + } + + /* create some space for rounding */ + frac1 <<= 6; + frac2 <<= 6; + + if (expdiff < (FLOAT64_FRACTION_SIZE + 2)) { + frac2 >>= expdiff; + frac1 += frac2; + } else { + a.parts.exp = exp1; + a.parts.fraction = (frac1 >> 6) & (~(FLOAT64_HIDDEN_BIT_MASK)); + return a; + } + + if (frac1 & (FLOAT64_HIDDEN_BIT_MASK << 7)) { + ++exp1; + frac1 >>= 1; + } + + /* rounding - if first bit after fraction is set then round up */ + frac1 += (0x1 << 5); + + if (frac1 & (FLOAT64_HIDDEN_BIT_MASK << 7)) { + /* rounding overflow */ + ++exp1; + frac1 >>= 1; + } + + if ((exp1 == FLOAT64_MAX_EXPONENT ) || (exp2 > exp1)) { + /* overflow - set infinity as result */ + a.parts.exp = FLOAT64_MAX_EXPONENT; + a.parts.fraction = 0; + return a; + } + + a.parts.exp = exp1; + /* Clear hidden bit and shift */ + a.parts.fraction = ((frac1 >> 6 ) & (~FLOAT64_HIDDEN_BIT_MASK)); + return a; +} + +/** Add two quadruple-precision floats with the same sign. + * + * @param a First input operand. + * @param b Second input operand. + * @return Result of addition. + */ +float128 add_float128(float128 a, float128 b) +{ + int expdiff; + uint32_t exp1, exp2; + uint64_t frac1_hi, frac1_lo, frac2_hi, frac2_lo, tmp_hi, tmp_lo; + + expdiff = ((int) a.parts.exp) - b.parts.exp; + if (expdiff < 0) { + if (is_float128_nan(b)) { + /* TODO: fix SigNaN */ + if (is_float128_signan(b)) { + } + + return b; + } + + /* b is infinity and a not */ + if (b.parts.exp == FLOAT128_MAX_EXPONENT) { + return b; + } + + frac1_hi = b.parts.frac_hi; + frac1_lo = b.parts.frac_lo; + exp1 = b.parts.exp; + frac2_hi = a.parts.frac_hi; + frac2_lo = a.parts.frac_lo; + exp2 = a.parts.exp; + expdiff *= -1; + } else { + if (is_float128_nan(a)) { + /* TODO: fix SigNaN */ + if (is_float128_signan(a) || is_float128_signan(b)) { + } + return a; + } + + /* a is infinity and b not */ + if (a.parts.exp == FLOAT128_MAX_EXPONENT) { + return a; + } + + frac1_hi = a.parts.frac_hi; + frac1_lo = a.parts.frac_lo; + exp1 = a.parts.exp; + frac2_hi = b.parts.frac_hi; + frac2_lo = b.parts.frac_lo; + exp2 = b.parts.exp; + } + + if (exp1 == 0) { + /* both are denormalized */ + add128(frac1_hi, frac1_lo, frac2_hi, frac2_lo, &frac1_hi, &frac1_lo); + + and128(frac1_hi, frac1_lo, + FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO, + &tmp_hi, &tmp_lo); + if (lt128(0x0ll, 0x0ll, tmp_hi, tmp_lo)) { + /* result is not denormalized */ + a.parts.exp = 1; + } + + a.parts.frac_hi = frac1_hi; + a.parts.frac_lo = frac1_lo; + return a; + } + + /* add hidden bit - frac1 is sure not denormalized */ + or128(frac1_hi, frac1_lo, + FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO, + &frac1_hi, &frac1_lo); + + /* second operand ... */ + if (exp2 == 0) { + /* ... is denormalized */ + --expdiff; + } else { + /* is not denormalized */ + or128(frac2_hi, frac2_lo, + FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO, + &frac2_hi, &frac2_lo); + } + + /* create some space for rounding */ + lshift128(frac1_hi, frac1_lo, 6, &frac1_hi, &frac1_lo); + lshift128(frac2_hi, frac2_lo, 6, &frac2_hi, &frac2_lo); + + if (expdiff < (FLOAT128_FRACTION_SIZE + 2)) { + rshift128(frac2_hi, frac2_lo, expdiff, &frac2_hi, &frac2_lo); + add128(frac1_hi, frac1_lo, frac2_hi, frac2_lo, &frac1_hi, &frac1_lo); + } else { + a.parts.exp = exp1; + + rshift128(frac1_hi, frac1_lo, 6, &frac1_hi, &frac1_lo); + not128(FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO, + &tmp_hi, &tmp_lo); + and128(frac1_hi, frac1_lo, tmp_hi, tmp_lo, &tmp_hi, &tmp_lo); + + a.parts.frac_hi = tmp_hi; + a.parts.frac_lo = tmp_lo; + return a; + } + + lshift128(FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO, 7, + &tmp_hi, &tmp_lo); + and128(frac1_hi, frac1_lo, tmp_hi, tmp_lo, &tmp_hi, &tmp_lo); + if (lt128(0x0ll, 0x0ll, tmp_hi, tmp_lo)) { + ++exp1; + rshift128(frac1_hi, frac1_lo, 1, &frac1_hi, &frac1_lo); + } + + /* rounding - if first bit after fraction is set then round up */ + add128(frac1_hi, frac1_lo, 0x0ll, 0x1ll << 5, &frac1_hi, &frac1_lo); + + lshift128(FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO, 7, + &tmp_hi, &tmp_lo); + and128(frac1_hi, frac1_lo, tmp_hi, tmp_lo, &tmp_hi, &tmp_lo); + if (lt128(0x0ll, 0x0ll, tmp_hi, tmp_lo)) { + /* rounding overflow */ + ++exp1; + rshift128(frac1_hi, frac1_lo, 1, &frac1_hi, &frac1_lo); + } + + if ((exp1 == FLOAT128_MAX_EXPONENT ) || (exp2 > exp1)) { + /* overflow - set infinity as result */ + a.parts.exp = FLOAT64_MAX_EXPONENT; + a.parts.frac_hi = 0; + a.parts.frac_lo = 0; + return a; + } + + a.parts.exp = exp1; + + /* Clear hidden bit and shift */ + rshift128(frac1_hi, frac1_lo, 6, &frac1_hi, &frac1_lo); + not128(FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO, + &tmp_hi, &tmp_lo); + and128(frac1_hi, frac1_lo, tmp_hi, tmp_lo, &tmp_hi, &tmp_lo); + + a.parts.frac_hi = tmp_hi; + a.parts.frac_lo = tmp_lo; + + return a; +} + +/** @} + */ Index: uspace/lib/softfloat/add.h =================================================================== --- uspace/lib/softfloat/add.h (revision 1dbd189b0e98a0f835bd872d52126bb32e841feb) +++ uspace/lib/softfloat/add.h (revision 1dbd189b0e98a0f835bd872d52126bb32e841feb) @@ -0,0 +1,47 @@ +/* + * Copyright (c) 2005 Josef Cejka + * Copyright (c) 2011 Petr Koupy + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup softfloat + * @{ + */ +/** @file Addition functions. + */ + +#ifndef __ADD_H__ +#define __ADD_H__ + +extern float32 add_float32(float32, float32); +extern float64 add_float64(float64, float64); +extern float96 add_float96(float96, float96); +extern float128 add_float128(float128, float128); + +#endif + +/** @} + */ Index: uspace/lib/softfloat/common.c =================================================================== --- uspace/lib/softfloat/common.c (revision 1dbd189b0e98a0f835bd872d52126bb32e841feb) +++ uspace/lib/softfloat/common.c (revision 1dbd189b0e98a0f835bd872d52126bb32e841feb) @@ -0,0 +1,690 @@ +/* + * Copyright (c) 2005 Josef Cejka + * Copyright (c) 2011 Petr Koupy + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup softfloat + * @{ + */ +/** @file Common helper operations. + */ + +#include "sftypes.h" +#include "common.h" + +/* Table for fast leading zeroes counting. */ +char zeroTable[256] = { + 8, 7, 7, 6, 6, 6, 6, 4, 4, 4, 4, 4, 4, 4, 4, \ + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, \ + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, \ + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, \ + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \ + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \ + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \ + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 +}; + +/** + * Take fraction shifted by 10 bits to the left, round it, normalize it + * and detect exceptions + * + * @param cexp Exponent with bias. + * @param cfrac Fraction shifted 10 bits to the left with added hidden bit. + * @param sign Resulting sign. + * @return Finished double-precision float. + */ +float64 finish_float64(int32_t cexp, uint64_t cfrac, char sign) +{ + float64 result; + + result.parts.sign = sign; + + /* find first nonzero digit and shift result and detect possibly underflow */ + while ((cexp > 0) && (cfrac) && + (!(cfrac & (FLOAT64_HIDDEN_BIT_MASK << (64 - FLOAT64_FRACTION_SIZE - 1))))) { + cexp--; + cfrac <<= 1; + /* TODO: fix underflow */ + } + + if ((cexp < 0) || (cexp == 0 && + (!(cfrac & (FLOAT64_HIDDEN_BIT_MASK << (64 - FLOAT64_FRACTION_SIZE - 1)))))) { + /* FIXME: underflow */ + result.parts.exp = 0; + if ((cexp + FLOAT64_FRACTION_SIZE + 1) < 0) { /* +1 is place for rounding */ + result.parts.fraction = 0; + return result; + } + + while (cexp < 0) { + cexp++; + cfrac >>= 1; + } + + cfrac += (0x1 << (64 - FLOAT64_FRACTION_SIZE - 3)); + + if (!(cfrac & (FLOAT64_HIDDEN_BIT_MASK << (64 - FLOAT64_FRACTION_SIZE - 1)))) { + result.parts.fraction = + ((cfrac >> (64 - FLOAT64_FRACTION_SIZE - 2)) & (~FLOAT64_HIDDEN_BIT_MASK)); + return result; + } + } else { + cfrac += (0x1 << (64 - FLOAT64_FRACTION_SIZE - 3)); + } + + ++cexp; + + if (cfrac & (FLOAT64_HIDDEN_BIT_MASK << (64 - FLOAT64_FRACTION_SIZE - 1))) { + ++cexp; + cfrac >>= 1; + } + + /* check overflow */ + if (cexp >= FLOAT64_MAX_EXPONENT) { + /* FIXME: overflow, return infinity */ + result.parts.exp = FLOAT64_MAX_EXPONENT; + result.parts.fraction = 0; + return result; + } + + result.parts.exp = (uint32_t) cexp; + + result.parts.fraction = + ((cfrac >> (64 - FLOAT64_FRACTION_SIZE - 2)) & (~FLOAT64_HIDDEN_BIT_MASK)); + + return result; +} + +/** + * Take fraction, round it, normalize it and detect exceptions + * + * @param cexp Exponent with bias. + * @param cfrac_hi High part of the fraction shifted 14 bits to the left + * with added hidden bit. + * @param cfrac_lo Low part of the fraction shifted 14 bits to the left + * with added hidden bit. + * @param sign Resulting sign. + * @param shift_out Bits right-shifted out from fraction by the caller. + * @return Finished quadruple-precision float. + */ +float128 finish_float128(int32_t cexp, uint64_t cfrac_hi, uint64_t cfrac_lo, + char sign, uint64_t shift_out) +{ + float128 result; + uint64_t tmp_hi, tmp_lo; + + result.parts.sign = sign; + + /* find first nonzero digit and shift result and detect possibly underflow */ + lshift128(FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO, + 1, &tmp_hi, &tmp_lo); + and128(cfrac_hi, cfrac_lo, tmp_hi, tmp_lo, &tmp_hi, &tmp_lo); + while ((cexp > 0) && (lt128(0x0ll, 0x0ll, cfrac_hi, cfrac_lo)) && + (!lt128(0x0ll, 0x0ll, tmp_hi, tmp_lo))) { + cexp--; + lshift128(cfrac_hi, cfrac_lo, 1, &cfrac_hi, &cfrac_lo); + /* TODO: fix underflow */ + + lshift128(FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO, + 1, &tmp_hi, &tmp_lo); + and128(cfrac_hi, cfrac_lo, tmp_hi, tmp_lo, &tmp_hi, &tmp_lo); + } + + lshift128(FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO, + 1, &tmp_hi, &tmp_lo); + and128(cfrac_hi, cfrac_lo, tmp_hi, tmp_lo, &tmp_hi, &tmp_lo); + if ((cexp < 0) || (cexp == 0 && + (!lt128(0x0ll, 0x0ll, tmp_hi, tmp_lo)))) { + /* FIXME: underflow */ + result.parts.exp = 0; + if ((cexp + FLOAT128_FRACTION_SIZE + 1) < 0) { /* +1 is place for rounding */ + result.parts.frac_hi = 0x0ll; + result.parts.frac_lo = 0x0ll; + return result; + } + + while (cexp < 0) { + cexp++; + rshift128(cfrac_hi, cfrac_lo, 1, &cfrac_hi, &cfrac_lo); + } + + if (shift_out & (0x1ull < 64)) { + add128(cfrac_hi, cfrac_lo, 0x0ll, 0x1ll, &cfrac_hi, &cfrac_lo); + } + + lshift128(FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO, + 1, &tmp_hi, &tmp_lo); + and128(cfrac_hi, cfrac_lo, tmp_hi, tmp_lo, &tmp_hi, &tmp_lo); + if (!lt128(0x0ll, 0x0ll, tmp_hi, tmp_lo)) { + not128(FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO, + &tmp_hi, &tmp_lo); + and128(cfrac_hi, cfrac_lo, tmp_hi, tmp_lo, &tmp_hi, &tmp_lo); + result.parts.frac_hi = tmp_hi; + result.parts.frac_lo = tmp_lo; + return result; + } + } else { + if (shift_out & (0x1ull < 64)) { + add128(cfrac_hi, cfrac_lo, 0x0ll, 0x1ll, &cfrac_hi, &cfrac_lo); + } + } + + ++cexp; + + lshift128(FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO, + 1, &tmp_hi, &tmp_lo); + and128(cfrac_hi, cfrac_lo, tmp_hi, tmp_lo, &tmp_hi, &tmp_lo); + if (lt128(0x0ll, 0x0ll, tmp_hi, tmp_lo)) { + ++cexp; + rshift128(cfrac_hi, cfrac_lo, 1, &cfrac_hi, &cfrac_lo); + } + + /* check overflow */ + if (cexp >= FLOAT128_MAX_EXPONENT) { + /* FIXME: overflow, return infinity */ + result.parts.exp = FLOAT128_MAX_EXPONENT; + result.parts.frac_hi = 0x0ll; + result.parts.frac_lo = 0x0ll; + return result; + } + + result.parts.exp = (uint32_t) cexp; + + not128(FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO, + &tmp_hi, &tmp_lo); + and128(cfrac_hi, cfrac_lo, tmp_hi, tmp_lo, &tmp_hi, &tmp_lo); + result.parts.frac_hi = tmp_hi; + result.parts.frac_lo = tmp_lo; + + return result; +} + +/** + * Counts leading zeroes in byte. + * + * @param i Byte for which to count leading zeroes. + * @return Number of detected leading zeroes. + */ +int count_zeroes8(uint8_t i) +{ + return zeroTable[i]; +} + +/** + * Counts leading zeroes in 32bit unsigned integer. + * + * @param i Integer for which to count leading zeroes. + * @return Number of detected leading zeroes. + */ +int count_zeroes32(uint32_t i) +{ + int j; + for (j = 0; j < 32; j += 8) { + if (i & (0xFF << (24 - j))) { + return (j + count_zeroes8(i >> (24 - j))); + } + } + + return 32; +} + +/** + * Counts leading zeroes in 64bit unsigned integer. + * + * @param i Integer for which to count leading zeroes. + * @return Number of detected leading zeroes. + */ +int count_zeroes64(uint64_t i) +{ + int j; + for (j = 0; j < 64; j += 8) { + if (i & (0xFFll << (56 - j))) { + return (j + count_zeroes8(i >> (56 - j))); + } + } + + return 64; +} + +/** + * Round and normalize number expressed by exponent and fraction with + * first bit (equal to hidden bit) at 30th bit. + * + * @param exp Exponent part. + * @param fraction Fraction with hidden bit shifted to 30th bit. + */ +void round_float32(int32_t *exp, uint32_t *fraction) +{ + /* rounding - if first bit after fraction is set then round up */ + (*fraction) += (0x1 << (32 - FLOAT32_FRACTION_SIZE - 3)); + + if ((*fraction) & + (FLOAT32_HIDDEN_BIT_MASK << (32 - FLOAT32_FRACTION_SIZE - 1))) { + /* rounding overflow */ + ++(*exp); + (*fraction) >>= 1; + } + + if (((*exp) >= FLOAT32_MAX_EXPONENT) || ((*exp) < 0)) { + /* overflow - set infinity as result */ + (*exp) = FLOAT32_MAX_EXPONENT; + (*fraction) = 0; + } +} + +/** + * Round and normalize number expressed by exponent and fraction with + * first bit (equal to hidden bit) at 62nd bit. + * + * @param exp Exponent part. + * @param fraction Fraction with hidden bit shifted to 62nd bit. + */ +void round_float64(int32_t *exp, uint64_t *fraction) +{ + /* rounding - if first bit after fraction is set then round up */ + (*fraction) += (0x1 << (64 - FLOAT64_FRACTION_SIZE - 3)); + + if ((*fraction) & + (FLOAT64_HIDDEN_BIT_MASK << (64 - FLOAT64_FRACTION_SIZE - 3))) { + /* rounding overflow */ + ++(*exp); + (*fraction) >>= 1; + } + + if (((*exp) >= FLOAT64_MAX_EXPONENT) || ((*exp) < 0)) { + /* overflow - set infinity as result */ + (*exp) = FLOAT64_MAX_EXPONENT; + (*fraction) = 0; + } +} + +/** + * Round and normalize number expressed by exponent and fraction with + * first bit (equal to hidden bit) at 126th bit. + * + * @param exp Exponent part. + * @param frac_hi High part of fraction part with hidden bit shifted to 126th bit. + * @param frac_lo Low part of fraction part with hidden bit shifted to 126th bit. + */ +void round_float128(int32_t *exp, uint64_t *frac_hi, uint64_t *frac_lo) +{ + uint64_t tmp_hi, tmp_lo; + + /* rounding - if first bit after fraction is set then round up */ + lshift128(0x0ll, 0x1ll, (128 - FLOAT128_FRACTION_SIZE - 3), &tmp_hi, &tmp_lo); + add128(*frac_hi, *frac_lo, tmp_hi, tmp_lo, frac_hi, frac_lo); + + lshift128(FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO, + (128 - FLOAT128_FRACTION_SIZE - 3), &tmp_hi, &tmp_lo); + and128(*frac_hi, *frac_lo, tmp_hi, tmp_lo, &tmp_hi, &tmp_lo); + if (lt128(0x0ll, 0x0ll, tmp_hi, tmp_lo)) { + /* rounding overflow */ + ++(*exp); + rshift128(*frac_hi, *frac_lo, 1, frac_hi, frac_lo); + } + + if (((*exp) >= FLOAT128_MAX_EXPONENT) || ((*exp) < 0)) { + /* overflow - set infinity as result */ + (*exp) = FLOAT128_MAX_EXPONENT; + (*frac_hi) = 0; + (*frac_lo) = 0; + } +} + +/** + * Logical shift left on the 128-bit operand. + * + * @param a_hi High part of the input operand. + * @param a_lo Low part of the input operand. + * @param shift Number of bits by witch to shift. + * @param r_hi Address to store high part of the result. + * @param r_lo Address to store low part of the result. + */ +void lshift128( + uint64_t a_hi, uint64_t a_lo, int shift, + uint64_t *r_hi, uint64_t *r_lo) +{ + if (shift <= 0) { + /* do nothing */ + } else if (shift >= 128) { + a_hi = 0; + a_lo = 0; + } else if (shift >= 64) { + a_hi = a_lo << (shift - 64); + a_lo = 0; + } else { + a_hi <<= shift; + a_hi |= a_lo >> (64 - shift); + a_lo <<= shift; + } + + *r_hi = a_hi; + *r_lo = a_lo; +} + +/** + * Logical shift right on the 128-bit operand. + * + * @param a_hi High part of the input operand. + * @param a_lo Low part of the input operand. + * @param shift Number of bits by witch to shift. + * @param r_hi Address to store high part of the result. + * @param r_lo Address to store low part of the result. + */ +void rshift128( + uint64_t a_hi, uint64_t a_lo, int shift, + uint64_t *r_hi, uint64_t *r_lo) +{ + if (shift <= 0) { + /* do nothing */ + } else if (shift >= 128) { + a_hi = 0; + a_lo = 0; + } else if (shift >= 64) { + a_lo = a_hi >> (shift - 64); + a_hi = 0; + } else { + a_lo >>= shift; + a_lo |= a_hi << (64 - shift); + a_hi >>= shift; + } + + *r_hi = a_hi; + *r_lo = a_lo; +} + +/** + * Bitwise AND on 128-bit operands. + * + * @param a_hi High part of the first input operand. + * @param a_lo Low part of the first input operand. + * @param b_hi High part of the second input operand. + * @param b_lo Low part of the second input operand. + * @param r_hi Address to store high part of the result. + * @param r_lo Address to store low part of the result. + */ +void and128( + uint64_t a_hi, uint64_t a_lo, + uint64_t b_hi, uint64_t b_lo, + uint64_t *r_hi, uint64_t *r_lo) +{ + *r_hi = a_hi & b_hi; + *r_lo = a_lo & b_lo; +} + +/** + * Bitwise inclusive OR on 128-bit operands. + * + * @param a_hi High part of the first input operand. + * @param a_lo Low part of the first input operand. + * @param b_hi High part of the second input operand. + * @param b_lo Low part of the second input operand. + * @param r_hi Address to store high part of the result. + * @param r_lo Address to store low part of the result. + */ +void or128( + uint64_t a_hi, uint64_t a_lo, + uint64_t b_hi, uint64_t b_lo, + uint64_t *r_hi, uint64_t *r_lo) +{ + *r_hi = a_hi | b_hi; + *r_lo = a_lo | b_lo; +} + +/** + * Bitwise exclusive OR on 128-bit operands. + * + * @param a_hi High part of the first input operand. + * @param a_lo Low part of the first input operand. + * @param b_hi High part of the second input operand. + * @param b_lo Low part of the second input operand. + * @param r_hi Address to store high part of the result. + * @param r_lo Address to store low part of the result. + */ +void xor128( + uint64_t a_hi, uint64_t a_lo, + uint64_t b_hi, uint64_t b_lo, + uint64_t *r_hi, uint64_t *r_lo) +{ + *r_hi = a_hi ^ b_hi; + *r_lo = a_lo ^ b_lo; +} + +/** + * Bitwise NOT on the 128-bit operand. + * + * @param a_hi High part of the input operand. + * @param a_lo Low part of the input operand. + * @param r_hi Address to store high part of the result. + * @param r_lo Address to store low part of the result. + */ +void not128( + uint64_t a_hi, uint64_t a_lo, + uint64_t *r_hi, uint64_t *r_lo) +{ + *r_hi = ~a_hi; + *r_lo = ~a_lo; +} + +/** + * Equality comparison of 128-bit operands. + * + * @param a_hi High part of the first input operand. + * @param a_lo Low part of the first input operand. + * @param b_hi High part of the second input operand. + * @param b_lo Low part of the second input operand. + * @return 1 if operands are equal, 0 otherwise. + */ +int eq128(uint64_t a_hi, uint64_t a_lo, uint64_t b_hi, uint64_t b_lo) +{ + return (a_hi == b_hi) && (a_lo == b_lo); +} + +/** + * Lower-or-equal comparison of 128-bit operands. + * + * @param a_hi High part of the first input operand. + * @param a_lo Low part of the first input operand. + * @param b_hi High part of the second input operand. + * @param b_lo Low part of the second input operand. + * @return 1 if a is lower or equal to b, 0 otherwise. + */ +int le128(uint64_t a_hi, uint64_t a_lo, uint64_t b_hi, uint64_t b_lo) +{ + return (a_hi < b_hi) || ((a_hi == b_hi) && (a_lo <= b_lo)); +} + +/** + * Lower-than comparison of 128-bit operands. + * + * @param a_hi High part of the first input operand. + * @param a_lo Low part of the first input operand. + * @param b_hi High part of the second input operand. + * @param b_lo Low part of the second input operand. + * @return 1 if a is lower than b, 0 otherwise. + */ +int lt128(uint64_t a_hi, uint64_t a_lo, uint64_t b_hi, uint64_t b_lo) +{ + return (a_hi < b_hi) || ((a_hi == b_hi) && (a_lo < b_lo)); +} + +/** + * Addition of two 128-bit unsigned integers. + * + * @param a_hi High part of the first input operand. + * @param a_lo Low part of the first input operand. + * @param b_hi High part of the second input operand. + * @param b_lo Low part of the second input operand. + * @param r_hi Address to store high part of the result. + * @param r_lo Address to store low part of the result. + */ +void add128(uint64_t a_hi, uint64_t a_lo, + uint64_t b_hi, uint64_t b_lo, + uint64_t *r_hi, uint64_t *r_lo) +{ + uint64_t low = a_lo + b_lo; + *r_lo = low; + /* detect overflow to add a carry */ + *r_hi = a_hi + b_hi + (low < a_lo); +} + +/** + * Substraction of two 128-bit unsigned integers. + * + * @param a_hi High part of the first input operand. + * @param a_lo Low part of the first input operand. + * @param b_hi High part of the second input operand. + * @param b_lo Low part of the second input operand. + * @param r_hi Address to store high part of the result. + * @param r_lo Address to store low part of the result. + */ +void sub128(uint64_t a_hi, uint64_t a_lo, + uint64_t b_hi, uint64_t b_lo, + uint64_t *r_hi, uint64_t *r_lo) +{ + *r_lo = a_lo - b_lo; + /* detect underflow to substract a carry */ + *r_hi = a_hi - b_hi - (a_lo < b_lo); +} + +/** + * Multiplication of two 64-bit unsigned integers. + * + * @param a First input operand. + * @param b Second input operand. + * @param r_hi Address to store high part of the result. + * @param r_lo Address to store low part of the result. + */ +void mul64(uint64_t a, uint64_t b, uint64_t *r_hi, uint64_t *r_lo) +{ + uint64_t low, high, middle1, middle2; + uint32_t alow, blow; + + alow = a & 0xFFFFFFFF; + blow = b & 0xFFFFFFFF; + + a >>= 32; + b >>= 32; + + low = ((uint64_t) alow) * blow; + middle1 = a * blow; + middle2 = alow * b; + high = a * b; + + middle1 += middle2; + high += (((uint64_t) (middle1 < middle2)) << 32) + (middle1 >> 32); + middle1 <<= 32; + low += middle1; + high += (low < middle1); + *r_lo = low; + *r_hi = high; +} + +/** + * Multiplication of two 128-bit unsigned integers. + * + * @param a_hi High part of the first input operand. + * @param a_lo Low part of the first input operand. + * @param b_hi High part of the second input operand. + * @param b_lo Low part of the second input operand. + * @param r_hihi Address to store first (highest) quarter of the result. + * @param r_hilo Address to store second quarter of the result. + * @param r_lohi Address to store third quarter of the result. + * @param r_lolo Address to store fourth (lowest) quarter of the result. + */ +void mul128(uint64_t a_hi, uint64_t a_lo, uint64_t b_hi, uint64_t b_lo, + uint64_t *r_hihi, uint64_t *r_hilo, uint64_t *r_lohi, uint64_t *r_lolo) +{ + uint64_t hihi, hilo, lohi, lolo; + uint64_t tmp1, tmp2; + + mul64(a_lo, b_lo, &lohi, &lolo); + mul64(a_lo, b_hi, &hilo, &tmp2); + add128(hilo, tmp2, 0x0ll, lohi, &hilo, &lohi); + mul64(a_hi, b_hi, &hihi, &tmp1); + add128(hihi, tmp1, 0x0ll, hilo, &hihi, &hilo); + mul64(a_hi, b_lo, &tmp1, &tmp2); + add128(tmp1, tmp2, 0x0ll, lohi, &tmp1, &lohi); + add128(hihi, hilo, 0x0ll, tmp1, &hihi, &hilo); + + *r_hihi = hihi; + *r_hilo = hilo; + *r_lohi = lohi; + *r_lolo = lolo; +} + +/** + * Estimate the quotient of 128-bit unsigned divident and 64-bit unsigned + * divisor. + * + * @param a_hi High part of the divident. + * @param a_lo Low part of the divident. + * @param b Divisor. + * @return Quotient approximation. + */ +uint64_t div128est(uint64_t a_hi, uint64_t a_lo, uint64_t b) +{ + uint64_t b_hi, b_lo; + uint64_t rem_hi, rem_lo; + uint64_t tmp_hi, tmp_lo; + uint64_t result; + + if (b <= a_hi) { + return 0xFFFFFFFFFFFFFFFFull; + } + + b_hi = b >> 32; + result = ((b_hi << 32) <= a_hi) ? (0xFFFFFFFFull << 32) : (a_hi / b_hi) << 32; + mul64(b, result, &tmp_hi, &tmp_lo); + sub128(a_hi, a_lo, tmp_hi, tmp_lo, &rem_hi, &rem_lo); + + while ((int64_t) rem_hi < 0) { + result -= 0x1ll << 32; + b_lo = b << 32; + add128(rem_hi, rem_lo, b_hi, b_lo, &rem_hi, &rem_lo); + } + + rem_hi = (rem_hi << 32) | (rem_lo >> 32); + if ((b_hi << 32) <= rem_hi) { + result |= 0xFFFFFFFF; + } else { + result |= rem_hi / b_hi; + } + + return result; +} + +/** @} + */ Index: uspace/lib/softfloat/common.h =================================================================== --- uspace/lib/softfloat/common.h (revision 1dbd189b0e98a0f835bd872d52126bb32e841feb) +++ uspace/lib/softfloat/common.h (revision 1dbd189b0e98a0f835bd872d52126bb32e841feb) @@ -0,0 +1,76 @@ +/* + * Copyright (c) 2005 Josef Cejka + * Copyright (c) 2011 Petr Koupy + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup softfloat + * @{ + */ +/** @file Common helper operations. + */ + +#ifndef __COMMON_H__ +#define __COMMON_H__ + +#include "sftypes.h" + +extern float64 finish_float64(int32_t, uint64_t, char); +extern float128 finish_float128(int32_t, uint64_t, uint64_t, char, uint64_t); + +extern int count_zeroes8(uint8_t); +extern int count_zeroes32(uint32_t); +extern int count_zeroes64(uint64_t); + +extern void round_float32(int32_t *, uint32_t *); +extern void round_float64(int32_t *, uint64_t *); +extern void round_float128(int32_t *, uint64_t *, uint64_t *); + +extern void lshift128(uint64_t, uint64_t, int, uint64_t *, uint64_t *); +extern void rshift128(uint64_t, uint64_t, int, uint64_t *, uint64_t *); + +extern void and128(uint64_t, uint64_t, uint64_t, uint64_t, uint64_t *, uint64_t *); +extern void or128(uint64_t, uint64_t, uint64_t, uint64_t, uint64_t *, uint64_t *); +extern void xor128(uint64_t, uint64_t, uint64_t, uint64_t, uint64_t *, uint64_t *); +extern void not128(uint64_t, uint64_t, uint64_t *, uint64_t *); + +extern int eq128(uint64_t, uint64_t, uint64_t, uint64_t); +extern int le128(uint64_t, uint64_t, uint64_t, uint64_t); +extern int lt128(uint64_t, uint64_t, uint64_t, uint64_t); + +extern void add128(uint64_t, uint64_t, uint64_t, uint64_t, uint64_t *, uint64_t *); +extern void sub128(uint64_t, uint64_t, uint64_t, uint64_t, uint64_t *, uint64_t *); + +extern void mul64(uint64_t, uint64_t, uint64_t *, uint64_t *); +extern void mul128(uint64_t, uint64_t, uint64_t, uint64_t, + uint64_t *, uint64_t *, uint64_t *, uint64_t *); + +extern uint64_t div128est(uint64_t, uint64_t, uint64_t); + +#endif + +/** @} + */ Index: uspace/lib/softfloat/comparison.c =================================================================== --- uspace/lib/softfloat/comparison.c (revision 1dbd189b0e98a0f835bd872d52126bb32e841feb) +++ uspace/lib/softfloat/comparison.c (revision 1dbd189b0e98a0f835bd872d52126bb32e841feb) @@ -0,0 +1,442 @@ +/* + * Copyright (c) 2005 Josef Cejka + * Copyright (c) 2011 Petr Koupy + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup softfloat + * @{ + */ +/** @file Comparison functions. + */ + +#include "sftypes.h" +#include "comparison.h" +#include "common.h" + +/** + * Determines whether the given float represents NaN (either signalling NaN or + * quiet NaN). + * + * @param f Single-precision float. + * @return 1 if float is NaN, 0 otherwise. + */ +int is_float32_nan(float32 f) +{ + /* NaN : exp = 0xff and nonzero fraction */ + return ((f.parts.exp == 0xFF) && (f.parts.fraction)); +} + +/** + * Determines whether the given float represents NaN (either signalling NaN or + * quiet NaN). + * + * @param d Double-precision float. + * @return 1 if float is NaN, 0 otherwise. + */ +int is_float64_nan(float64 d) +{ + /* NaN : exp = 0x7ff and nonzero fraction */ + return ((d.parts.exp == 0x7FF) && (d.parts.fraction)); +} + +/** + * Determines whether the given float represents NaN (either signalling NaN or + * quiet NaN). + * + * @param ld Quadruple-precision float. + * @return 1 if float is NaN, 0 otherwise. + */ +int is_float128_nan(float128 ld) +{ + /* NaN : exp = 0x7fff and nonzero fraction */ + return ((ld.parts.exp == 0x7FF) && + !eq128(ld.parts.frac_hi, ld.parts.frac_lo, 0x0ll, 0x0ll)); +} + +/** + * Determines whether the given float represents signalling NaN. + * + * @param f Single-precision float. + * @return 1 if float is signalling NaN, 0 otherwise. + */ +int is_float32_signan(float32 f) +{ + /* SigNaN : exp = 0xff and fraction = 0xxxxx..x (binary), + * where at least one x is nonzero */ + return ((f.parts.exp == 0xFF) && + (f.parts.fraction < 0x400000) && (f.parts.fraction)); +} + +/** + * Determines whether the given float represents signalling NaN. + * + * @param d Double-precision float. + * @return 1 if float is signalling NaN, 0 otherwise. + */ +int is_float64_signan(float64 d) +{ + /* SigNaN : exp = 0x7ff and fraction = 0xxxxx..x (binary), + * where at least one x is nonzero */ + return ((d.parts.exp == 0x7FF) && + (d.parts.fraction) && (d.parts.fraction < 0x8000000000000ll)); +} + +/** + * Determines whether the given float represents signalling NaN. + * + * @param ld Quadruple-precision float. + * @return 1 if float is signalling NaN, 0 otherwise. + */ +int is_float128_signan(float128 ld) +{ + /* SigNaN : exp = 0x7fff and fraction = 0xxxxx..x (binary), + * where at least one x is nonzero */ + return ((ld.parts.exp == 0x7FFF) && + (ld.parts.frac_hi || ld.parts.frac_lo) && + lt128(ld.parts.frac_hi, ld.parts.frac_lo, 0x800000000000ll, 0x0ll)); + +} + +/** + * Determines whether the given float represents positive or negative infinity. + * + * @param f Single-precision float. + * @return 1 if float is infinite, 0 otherwise. + */ +int is_float32_infinity(float32 f) +{ + /* NaN : exp = 0x7ff and zero fraction */ + return ((f.parts.exp == 0xFF) && (f.parts.fraction == 0x0)); +} + +/** + * Determines whether the given float represents positive or negative infinity. + * + * @param d Double-precision float. + * @return 1 if float is infinite, 0 otherwise. + */ +int is_float64_infinity(float64 d) +{ + /* NaN : exp = 0x7ff and zero fraction */ + return ((d.parts.exp == 0x7FF) && (d.parts.fraction == 0x0)); +} + +/** + * Determines whether the given float represents positive or negative infinity. + * + * @param ld Quadruple-precision float. + * @return 1 if float is infinite, 0 otherwise. + */ +int is_float128_infinity(float128 ld) +{ + /* NaN : exp = 0x7fff and zero fraction */ + return ((ld.parts.exp == 0x7FFF) && + eq128(ld.parts.frac_hi, ld.parts.frac_lo, 0x0ll, 0x0ll)); +} + +/** + * Determines whether the given float represents positive or negative zero. + * + * @param f Single-precision float. + * @return 1 if float is zero, 0 otherwise. + */ +int is_float32_zero(float32 f) +{ + return (((f.bin) & 0x7FFFFFFF) == 0); +} + +/** + * Determines whether the given float represents positive or negative zero. + * + * @param d Double-precision float. + * @return 1 if float is zero, 0 otherwise. + */ +int is_float64_zero(float64 d) +{ + return (((d.bin) & 0x7FFFFFFFFFFFFFFFll) == 0); +} + +/** + * Determines whether the given float represents positive or negative zero. + * + * @param ld Quadruple-precision float. + * @return 1 if float is zero, 0 otherwise. + */ +int is_float128_zero(float128 ld) +{ + uint64_t tmp_hi; + uint64_t tmp_lo; + + and128(ld.bin.hi, ld.bin.lo, + 0x7FFFFFFFFFFFFFFFll, 0xFFFFFFFFFFFFFFFFll, &tmp_hi, &tmp_lo); + + return eq128(tmp_hi, tmp_lo, 0x0ll, 0x0ll); +} + +/** + * Determine whether two floats are equal. NaNs are not recognized. + * + * @a First single-precision operand. + * @b Second single-precision operand. + * @return 1 if both floats are equal, 0 otherwise. + */ +int is_float32_eq(float32 a, float32 b) +{ + /* a equals to b or both are zeros (with any sign) */ + return ((a.bin == b.bin) || + (((a.bin | b.bin) & 0x7FFFFFFF) == 0)); +} + +/** + * Determine whether two floats are equal. NaNs are not recognized. + * + * @a First double-precision operand. + * @b Second double-precision operand. + * @return 1 if both floats are equal, 0 otherwise. + */ +int is_float64_eq(float64 a, float64 b) +{ + /* a equals to b or both are zeros (with any sign) */ + return ((a.bin == b.bin) || + (((a.bin | b.bin) & 0x7FFFFFFFFFFFFFFFll) == 0)); +} + +/** + * Determine whether two floats are equal. NaNs are not recognized. + * + * @a First quadruple-precision operand. + * @b Second quadruple-precision operand. + * @return 1 if both floats are equal, 0 otherwise. + */ +int is_float128_eq(float128 a, float128 b) +{ + uint64_t tmp_hi; + uint64_t tmp_lo; + + /* both are zeros (with any sign) */ + or128(a.bin.hi, a.bin.lo, + b.bin.hi, b.bin.lo, &tmp_hi, &tmp_lo); + and128(tmp_hi, tmp_lo, + 0x7FFFFFFFFFFFFFFFll, 0xFFFFFFFFFFFFFFFFll, &tmp_hi, &tmp_lo); + int both_zero = eq128(tmp_hi, tmp_lo, 0x0ll, 0x0ll); + + /* a equals to b */ + int are_equal = eq128(a.bin.hi, a.bin.lo, b.bin.hi, b.bin.lo); + + return are_equal || both_zero; +} + +/** + * Lower-than comparison between two floats. NaNs are not recognized. + * + * @a First single-precision operand. + * @b Second single-precision operand. + * @return 1 if a is lower than b, 0 otherwise. + */ +int is_float32_lt(float32 a, float32 b) +{ + if (((a.bin | b.bin) & 0x7FFFFFFF) == 0) { + /* +- zeroes */ + return 0; + } + + if ((a.parts.sign) && (b.parts.sign)) { + /* if both are negative, smaller is that with greater binary value */ + return (a.bin > b.bin); + } + + /* + * lets negate signs - now will be positive numbers always + * bigger than negative (first bit will be set for unsigned + * integer comparison) + */ + a.parts.sign = !a.parts.sign; + b.parts.sign = !b.parts.sign; + return (a.bin < b.bin); +} + +/** + * Lower-than comparison between two floats. NaNs are not recognized. + * + * @a First double-precision operand. + * @b Second double-precision operand. + * @return 1 if a is lower than b, 0 otherwise. + */ +int is_float64_lt(float64 a, float64 b) +{ + if (((a.bin | b.bin) & 0x7FFFFFFFFFFFFFFFll) == 0) { + /* +- zeroes */ + return 0; + } + + if ((a.parts.sign) && (b.parts.sign)) { + /* if both are negative, smaller is that with greater binary value */ + return (a.bin > b.bin); + } + + /* + * lets negate signs - now will be positive numbers always + * bigger than negative (first bit will be set for unsigned + * integer comparison) + */ + a.parts.sign = !a.parts.sign; + b.parts.sign = !b.parts.sign; + return (a.bin < b.bin); +} + +/** + * Lower-than comparison between two floats. NaNs are not recognized. + * + * @a First quadruple-precision operand. + * @b Second quadruple-precision operand. + * @return 1 if a is lower than b, 0 otherwise. + */ +int is_float128_lt(float128 a, float128 b) +{ + uint64_t tmp_hi; + uint64_t tmp_lo; + + or128(a.bin.hi, a.bin.lo, + b.bin.hi, b.bin.lo, &tmp_hi, &tmp_lo); + and128(tmp_hi, tmp_lo, + 0x7FFFFFFFFFFFFFFFll, 0xFFFFFFFFFFFFFFFFll, &tmp_hi, &tmp_lo); + if (eq128(tmp_hi, tmp_lo, 0x0ll, 0x0ll)) { + /* +- zeroes */ + return 0; + } + + if ((a.parts.sign) && (b.parts.sign)) { + /* if both are negative, smaller is that with greater binary value */ + return lt128(b.bin.hi, b.bin.lo, a.bin.hi, a.bin.lo); + } + + /* + * lets negate signs - now will be positive numbers always + * bigger than negative (first bit will be set for unsigned + * integer comparison) + */ + a.parts.sign = !a.parts.sign; + b.parts.sign = !b.parts.sign; + return lt128(a.bin.hi, a.bin.lo, b.bin.hi, b.bin.lo); +} + +/** + * Greater-than comparison between two floats. NaNs are not recognized. + * + * @a First single-precision operand. + * @b Second single-precision operand. + * @return 1 if a is greater than b, 0 otherwise. + */ +int is_float32_gt(float32 a, float32 b) +{ + if (((a.bin | b.bin) & 0x7FFFFFFF) == 0) { + /* zeroes are equal with any sign */ + return 0; + } + + if ((a.parts.sign) && (b.parts.sign)) { + /* if both are negative, greater is that with smaller binary value */ + return (a.bin < b.bin); + } + + /* + * lets negate signs - now will be positive numbers always + * bigger than negative (first bit will be set for unsigned + * integer comparison) + */ + a.parts.sign = !a.parts.sign; + b.parts.sign = !b.parts.sign; + return (a.bin > b.bin); +} + +/** + * Greater-than comparison between two floats. NaNs are not recognized. + * + * @a First double-precision operand. + * @b Second double-precision operand. + * @return 1 if a is greater than b, 0 otherwise. + */ +int is_float64_gt(float64 a, float64 b) +{ + if (((a.bin | b.bin) & 0x7FFFFFFFFFFFFFFFll) == 0) { + /* zeroes are equal with any sign */ + return 0; + } + + if ((a.parts.sign) && (b.parts.sign)) { + /* if both are negative, greater is that with smaller binary value */ + return (a.bin < b.bin); + } + + /* + * lets negate signs - now will be positive numbers always + * bigger than negative (first bit will be set for unsigned + * integer comparison) + */ + a.parts.sign = !a.parts.sign; + b.parts.sign = !b.parts.sign; + return (a.bin > b.bin); +} + +/** + * Greater-than comparison between two floats. NaNs are not recognized. + * + * @a First quadruple-precision operand. + * @b Second quadruple-precision operand. + * @return 1 if a is greater than b, 0 otherwise. + */ +int is_float128_gt(float128 a, float128 b) +{ + uint64_t tmp_hi; + uint64_t tmp_lo; + + or128(a.bin.hi, a.bin.lo, + b.bin.hi, b.bin.lo, &tmp_hi, &tmp_lo); + and128(tmp_hi, tmp_lo, + 0x7FFFFFFFFFFFFFFFll, 0xFFFFFFFFFFFFFFFFll, &tmp_hi, &tmp_lo); + if (eq128(tmp_hi, tmp_lo, 0x0ll, 0x0ll)) { + /* zeroes are equal with any sign */ + return 0; + } + + if ((a.parts.sign) && (b.parts.sign)) { + /* if both are negative, greater is that with smaller binary value */ + return lt128(a.bin.hi, a.bin.lo, b.bin.hi, b.bin.lo); + } + + /* + * lets negate signs - now will be positive numbers always + * bigger than negative (first bit will be set for unsigned + * integer comparison) + */ + a.parts.sign = !a.parts.sign; + b.parts.sign = !b.parts.sign; + return lt128(b.bin.hi, b.bin.lo, a.bin.hi, a.bin.lo); +} + +/** @} + */ Index: uspace/lib/softfloat/comparison.h =================================================================== --- uspace/lib/softfloat/comparison.h (revision 1dbd189b0e98a0f835bd872d52126bb32e841feb) +++ uspace/lib/softfloat/comparison.h (revision 1dbd189b0e98a0f835bd872d52126bb32e841feb) @@ -0,0 +1,82 @@ +/* + * Copyright (c) 2005 Josef Cejka + * Copyright (c) 2011 Petr Koupy + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup softfloat + * @{ + */ +/** @file Comparison functions. + */ + +#ifndef __COMPARISON_H__ +#define __COMPARISON_H__ + +extern int is_float32_nan(float32); +extern int is_float32_signan(float32); + +extern int is_float32_infinity(float32); +extern int is_float32_zero(float32); + +extern int is_float32_eq(float32, float32); +extern int is_float32_lt(float32, float32); +extern int is_float32_gt(float32, float32); + +extern int is_float64_nan(float64); +extern int is_float64_signan(float64); + +extern int is_float64_infinity(float64); +extern int is_float64_zero(float64); + +extern int is_float64_eq(float64, float64); +extern int is_float64_lt(float64, float64); +extern int is_float64_gt(float64, float64); + +extern int is_float96_nan(float96); +extern int is_float96_signan(float96); + +extern int is_float96_infinity(float96); +extern int is_float96_zero(float96); + +extern int is_float96_eq(float96, float96); +extern int is_float96_lt(float96, float96); +extern int is_float96_gt(float96, float96); + +extern int is_float128_nan(float128); +extern int is_float128_signan(float128); + +extern int is_float128_infinity(float128); +extern int is_float128_zero(float128); + +extern int is_float128_eq(float128, float128); +extern int is_float128_lt(float128, float128); +extern int is_float128_gt(float128, float128); + +#endif + +/** @} + */ Index: uspace/lib/softfloat/conversion.c =================================================================== --- uspace/lib/softfloat/conversion.c (revision 1dbd189b0e98a0f835bd872d52126bb32e841feb) +++ uspace/lib/softfloat/conversion.c (revision 1dbd189b0e98a0f835bd872d52126bb32e841feb) @@ -0,0 +1,1041 @@ +/* + * Copyright (c) 2005 Josef Cejka + * Copyright (c) 2011 Petr Koupy + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup softfloat + * @{ + */ +/** @file Conversion of precision and conversion between integers and floats. + */ + +#include "sftypes.h" +#include "conversion.h" +#include "comparison.h" +#include "common.h" + +float64 float32_to_float64(float32 a) +{ + float64 result; + uint64_t frac; + + result.parts.sign = a.parts.sign; + result.parts.fraction = a.parts.fraction; + result.parts.fraction <<= (FLOAT64_FRACTION_SIZE - FLOAT32_FRACTION_SIZE); + + if ((is_float32_infinity(a)) || (is_float32_nan(a))) { + result.parts.exp = FLOAT64_MAX_EXPONENT; + // TODO; check if its correct for SigNaNs + return result; + } + + result.parts.exp = a.parts.exp + ((int) FLOAT64_BIAS - FLOAT32_BIAS); + if (a.parts.exp == 0) { + /* normalize denormalized numbers */ + + if (result.parts.fraction == 0) { /* fix zero */ + result.parts.exp = 0; + return result; + } + + frac = result.parts.fraction; + + while (!(frac & FLOAT64_HIDDEN_BIT_MASK)) { + frac <<= 1; + --result.parts.exp; + } + + ++result.parts.exp; + result.parts.fraction = frac; + } + + return result; +} + +float128 float32_to_float128(float32 a) +{ + float128 result; + uint64_t frac_hi, frac_lo; + uint64_t tmp_hi, tmp_lo; + + result.parts.sign = a.parts.sign; + result.parts.frac_hi = 0; + result.parts.frac_lo = a.parts.fraction; + lshift128(result.parts.frac_hi, result.parts.frac_lo, + (FLOAT128_FRACTION_SIZE - FLOAT32_FRACTION_SIZE), + &frac_hi, &frac_lo); + result.parts.frac_hi = frac_hi; + result.parts.frac_lo = frac_lo; + + if ((is_float32_infinity(a)) || (is_float32_nan(a))) { + result.parts.exp = FLOAT128_MAX_EXPONENT; + // TODO; check if its correct for SigNaNs + return result; + } + + result.parts.exp = a.parts.exp + ((int) FLOAT128_BIAS - FLOAT32_BIAS); + if (a.parts.exp == 0) { + /* normalize denormalized numbers */ + + if (eq128(result.parts.frac_hi, + result.parts.frac_lo, 0x0ll, 0x0ll)) { /* fix zero */ + result.parts.exp = 0; + return result; + } + + frac_hi = result.parts.frac_hi; + frac_lo = result.parts.frac_lo; + + and128(frac_hi, frac_lo, + FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO, + &tmp_hi, &tmp_lo); + while (!lt128(0x0ll, 0x0ll, tmp_hi, tmp_lo)) { + lshift128(frac_hi, frac_lo, 1, &frac_hi, &frac_lo); + --result.parts.exp; + } + + ++result.parts.exp; + result.parts.frac_hi = frac_hi; + result.parts.frac_lo = frac_lo; + } + + return result; +} + +float128 float64_to_float128(float64 a) +{ + float128 result; + uint64_t frac_hi, frac_lo; + uint64_t tmp_hi, tmp_lo; + + result.parts.sign = a.parts.sign; + result.parts.frac_hi = 0; + result.parts.frac_lo = a.parts.fraction; + lshift128(result.parts.frac_hi, result.parts.frac_lo, + (FLOAT128_FRACTION_SIZE - FLOAT64_FRACTION_SIZE), + &frac_hi, &frac_lo); + result.parts.frac_hi = frac_hi; + result.parts.frac_lo = frac_lo; + + if ((is_float64_infinity(a)) || (is_float64_nan(a))) { + result.parts.exp = FLOAT128_MAX_EXPONENT; + // TODO; check if its correct for SigNaNs + return result; + } + + result.parts.exp = a.parts.exp + ((int) FLOAT128_BIAS - FLOAT64_BIAS); + if (a.parts.exp == 0) { + /* normalize denormalized numbers */ + + if (eq128(result.parts.frac_hi, + result.parts.frac_lo, 0x0ll, 0x0ll)) { /* fix zero */ + result.parts.exp = 0; + return result; + } + + frac_hi = result.parts.frac_hi; + frac_lo = result.parts.frac_lo; + + and128(frac_hi, frac_lo, + FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO, + &tmp_hi, &tmp_lo); + while (!lt128(0x0ll, 0x0ll, tmp_hi, tmp_lo)) { + lshift128(frac_hi, frac_lo, 1, &frac_hi, &frac_lo); + --result.parts.exp; + } + + ++result.parts.exp; + result.parts.frac_hi = frac_hi; + result.parts.frac_lo = frac_lo; + } + + return result; +} + +float32 float64_to_float32(float64 a) +{ + float32 result; + int32_t exp; + uint64_t frac; + + result.parts.sign = a.parts.sign; + + if (is_float64_nan(a)) { + result.parts.exp = FLOAT32_MAX_EXPONENT; + + if (is_float64_signan(a)) { + /* set first bit of fraction nonzero */ + result.parts.fraction = FLOAT32_HIDDEN_BIT_MASK >> 1; + return result; + } + + /* fraction nonzero but its first bit is zero */ + result.parts.fraction = 0x1; + return result; + } + + if (is_float64_infinity(a)) { + result.parts.fraction = 0; + result.parts.exp = FLOAT32_MAX_EXPONENT; + return result; + } + + exp = (int) a.parts.exp - FLOAT64_BIAS + FLOAT32_BIAS; + + if (exp >= FLOAT32_MAX_EXPONENT) { + /* FIXME: overflow */ + result.parts.fraction = 0; + result.parts.exp = FLOAT32_MAX_EXPONENT; + return result; + } else if (exp <= 0) { + /* underflow or denormalized */ + + result.parts.exp = 0; + + exp *= -1; + if (exp > FLOAT32_FRACTION_SIZE) { + /* FIXME: underflow */ + result.parts.fraction = 0; + return result; + } + + /* denormalized */ + + frac = a.parts.fraction; + frac |= FLOAT64_HIDDEN_BIT_MASK; /* denormalize and set hidden bit */ + + frac >>= (FLOAT64_FRACTION_SIZE - FLOAT32_FRACTION_SIZE + 1); + + while (exp > 0) { + --exp; + frac >>= 1; + } + result.parts.fraction = frac; + + return result; + } + + result.parts.exp = exp; + result.parts.fraction = + a.parts.fraction >> (FLOAT64_FRACTION_SIZE - FLOAT32_FRACTION_SIZE); + return result; +} + +float32 float128_to_float32(float128 a) +{ + float32 result; + int32_t exp; + uint64_t frac_hi, frac_lo; + + result.parts.sign = a.parts.sign; + + if (is_float128_nan(a)) { + result.parts.exp = FLOAT32_MAX_EXPONENT; + + if (is_float128_signan(a)) { + /* set first bit of fraction nonzero */ + result.parts.fraction = FLOAT32_HIDDEN_BIT_MASK >> 1; + return result; + } + + /* fraction nonzero but its first bit is zero */ + result.parts.fraction = 0x1; + return result; + } + + if (is_float128_infinity(a)) { + result.parts.fraction = 0; + result.parts.exp = FLOAT32_MAX_EXPONENT; + return result; + } + + exp = (int) a.parts.exp - FLOAT128_BIAS + FLOAT32_BIAS; + + if (exp >= FLOAT32_MAX_EXPONENT) { + /* FIXME: overflow */ + result.parts.fraction = 0; + result.parts.exp = FLOAT32_MAX_EXPONENT; + return result; + } else if (exp <= 0) { + /* underflow or denormalized */ + + result.parts.exp = 0; + + exp *= -1; + if (exp > FLOAT32_FRACTION_SIZE) { + /* FIXME: underflow */ + result.parts.fraction = 0; + return result; + } + + /* denormalized */ + + frac_hi = a.parts.frac_hi; + frac_lo = a.parts.frac_lo; + + /* denormalize and set hidden bit */ + frac_hi |= FLOAT128_HIDDEN_BIT_MASK_HI; + + rshift128(frac_hi, frac_lo, + (FLOAT128_FRACTION_SIZE - FLOAT32_FRACTION_SIZE + 1), + &frac_hi, &frac_lo); + + while (exp > 0) { + --exp; + rshift128(frac_hi, frac_lo, 1, &frac_hi, &frac_lo); + } + result.parts.fraction = frac_lo; + + return result; + } + + result.parts.exp = exp; + frac_hi = a.parts.frac_hi; + frac_lo = a.parts.frac_lo; + rshift128(frac_hi, frac_lo, + (FLOAT128_FRACTION_SIZE - FLOAT32_FRACTION_SIZE + 1), + &frac_hi, &frac_lo); + result.parts.fraction = frac_lo; + return result; +} + +float64 float128_to_float64(float128 a) +{ + float64 result; + int32_t exp; + uint64_t frac_hi, frac_lo; + + result.parts.sign = a.parts.sign; + + if (is_float128_nan(a)) { + result.parts.exp = FLOAT64_MAX_EXPONENT; + + if (is_float128_signan(a)) { + /* set first bit of fraction nonzero */ + result.parts.fraction = FLOAT64_HIDDEN_BIT_MASK >> 1; + return result; + } + + /* fraction nonzero but its first bit is zero */ + result.parts.fraction = 0x1; + return result; + } + + if (is_float128_infinity(a)) { + result.parts.fraction = 0; + result.parts.exp = FLOAT64_MAX_EXPONENT; + return result; + } + + exp = (int) a.parts.exp - FLOAT128_BIAS + FLOAT64_BIAS; + + if (exp >= FLOAT64_MAX_EXPONENT) { + /* FIXME: overflow */ + result.parts.fraction = 0; + result.parts.exp = FLOAT64_MAX_EXPONENT; + return result; + } else if (exp <= 0) { + /* underflow or denormalized */ + + result.parts.exp = 0; + + exp *= -1; + if (exp > FLOAT64_FRACTION_SIZE) { + /* FIXME: underflow */ + result.parts.fraction = 0; + return result; + } + + /* denormalized */ + + frac_hi = a.parts.frac_hi; + frac_lo = a.parts.frac_lo; + + /* denormalize and set hidden bit */ + frac_hi |= FLOAT128_HIDDEN_BIT_MASK_HI; + + rshift128(frac_hi, frac_lo, + (FLOAT128_FRACTION_SIZE - FLOAT64_FRACTION_SIZE + 1), + &frac_hi, &frac_lo); + + while (exp > 0) { + --exp; + rshift128(frac_hi, frac_lo, 1, &frac_hi, &frac_lo); + } + result.parts.fraction = frac_lo; + + return result; + } + + result.parts.exp = exp; + frac_hi = a.parts.frac_hi; + frac_lo = a.parts.frac_lo; + rshift128(frac_hi, frac_lo, + (FLOAT128_FRACTION_SIZE - FLOAT64_FRACTION_SIZE + 1), + &frac_hi, &frac_lo); + result.parts.fraction = frac_lo; + return result; +} + +/** Helper procedure for converting float32 to uint32. + * + * @param a Floating point number in normalized form + * (NaNs or Inf are not checked). + * @return Converted unsigned integer. + */ +static uint32_t _float32_to_uint32_helper(float32 a) +{ + uint32_t frac; + + if (a.parts.exp < FLOAT32_BIAS) { + /* TODO: rounding */ + return 0; + } + + frac = a.parts.fraction; + + frac |= FLOAT32_HIDDEN_BIT_MASK; + /* shift fraction to left so hidden bit will be the most significant bit */ + frac <<= 32 - FLOAT32_FRACTION_SIZE - 1; + + frac >>= 32 - (a.parts.exp - FLOAT32_BIAS) - 1; + if ((a.parts.sign == 1) && (frac != 0)) { + frac = ~frac; + ++frac; + } + + return frac; +} + +/* + * FIXME: Im not sure what to return if overflow/underflow happens + * - now its the biggest or the smallest int + */ +uint32_t float32_to_uint32(float32 a) +{ + if (is_float32_nan(a)) + return UINT32_MAX; + + if (is_float32_infinity(a) || (a.parts.exp >= (32 + FLOAT32_BIAS))) { + if (a.parts.sign) + return UINT32_MIN; + + return UINT32_MAX; + } + + return _float32_to_uint32_helper(a); +} + +/* + * FIXME: Im not sure what to return if overflow/underflow happens + * - now its the biggest or the smallest int + */ +int32_t float32_to_int32(float32 a) +{ + if (is_float32_nan(a)) + return INT32_MAX; + + if (is_float32_infinity(a) || (a.parts.exp >= (32 + FLOAT32_BIAS))) { + if (a.parts.sign) + return INT32_MIN; + + return INT32_MAX; + } + + return _float32_to_uint32_helper(a); +} + +/** Helper procedure for converting float32 to uint64. + * + * @param a Floating point number in normalized form + * (NaNs or Inf are not checked). + * @return Converted unsigned integer. + */ +static uint64_t _float32_to_uint64_helper(float32 a) +{ + uint64_t frac; + + if (a.parts.exp < FLOAT32_BIAS) { + // TODO: rounding + return 0; + } + + frac = a.parts.fraction; + + frac |= FLOAT32_HIDDEN_BIT_MASK; + /* shift fraction to left so hidden bit will be the most significant bit */ + frac <<= 64 - FLOAT32_FRACTION_SIZE - 1; + + frac >>= 64 - (a.parts.exp - FLOAT32_BIAS) - 1; + if ((a.parts.sign == 1) && (frac != 0)) { + frac = ~frac; + ++frac; + } + + return frac; +} + +/* + * FIXME: Im not sure what to return if overflow/underflow happens + * - now its the biggest or the smallest int + */ +uint64_t float32_to_uint64(float32 a) +{ + if (is_float32_nan(a)) + return UINT64_MAX; + + if (is_float32_infinity(a) || (a.parts.exp >= (64 + FLOAT32_BIAS))) { + if (a.parts.sign) + return UINT64_MIN; + + return UINT64_MAX; + } + + return _float32_to_uint64_helper(a); +} + +/* + * FIXME: Im not sure what to return if overflow/underflow happens + * - now its the biggest or the smallest int + */ +int64_t float32_to_int64(float32 a) +{ + if (is_float32_nan(a)) + return INT64_MAX; + + if (is_float32_infinity(a) || (a.parts.exp >= (64 + FLOAT32_BIAS))) { + if (a.parts.sign) + return INT64_MIN; + + return INT64_MAX; + } + + return _float32_to_uint64_helper(a); +} + +/** Helper procedure for converting float64 to uint64. + * + * @param a Floating point number in normalized form + * (NaNs or Inf are not checked). + * @return Converted unsigned integer. + */ +static uint64_t _float64_to_uint64_helper(float64 a) +{ + uint64_t frac; + + if (a.parts.exp < FLOAT64_BIAS) { + // TODO: rounding + return 0; + } + + frac = a.parts.fraction; + + frac |= FLOAT64_HIDDEN_BIT_MASK; + /* shift fraction to left so hidden bit will be the most significant bit */ + frac <<= 64 - FLOAT64_FRACTION_SIZE - 1; + + frac >>= 64 - (a.parts.exp - FLOAT64_BIAS) - 1; + if ((a.parts.sign == 1) && (frac != 0)) { + frac = ~frac; + ++frac; + } + + return frac; +} + +/* + * FIXME: Im not sure what to return if overflow/underflow happens + * - now its the biggest or the smallest int + */ +uint32_t float64_to_uint32(float64 a) +{ + if (is_float64_nan(a)) + return UINT32_MAX; + + if (is_float64_infinity(a) || (a.parts.exp >= (32 + FLOAT64_BIAS))) { + if (a.parts.sign) + return UINT32_MIN; + + return UINT32_MAX; + } + + return (uint32_t) _float64_to_uint64_helper(a); +} + +/* + * FIXME: Im not sure what to return if overflow/underflow happens + * - now its the biggest or the smallest int + */ +int32_t float64_to_int32(float64 a) +{ + if (is_float64_nan(a)) + return INT32_MAX; + + if (is_float64_infinity(a) || (a.parts.exp >= (32 + FLOAT64_BIAS))) { + if (a.parts.sign) + return INT32_MIN; + + return INT32_MAX; + } + + return (int32_t) _float64_to_uint64_helper(a); +} + +/* + * FIXME: Im not sure what to return if overflow/underflow happens + * - now its the biggest or the smallest int + */ +uint64_t float64_to_uint64(float64 a) +{ + if (is_float64_nan(a)) + return UINT64_MAX; + + if (is_float64_infinity(a) || (a.parts.exp >= (64 + FLOAT64_BIAS))) { + if (a.parts.sign) + return UINT64_MIN; + + return UINT64_MAX; + } + + return _float64_to_uint64_helper(a); +} + +/* + * FIXME: Im not sure what to return if overflow/underflow happens + * - now its the biggest or the smallest int + */ +int64_t float64_to_int64(float64 a) +{ + if (is_float64_nan(a)) + return INT64_MAX; + + if (is_float64_infinity(a) || (a.parts.exp >= (64 + FLOAT64_BIAS))) { + if (a.parts.sign) + return INT64_MIN; + + return INT64_MAX; + } + + return _float64_to_uint64_helper(a); +} + +/** Helper procedure for converting float128 to uint64. + * + * @param a Floating point number in normalized form + * (NaNs or Inf are not checked). + * @return Converted unsigned integer. + */ +static uint64_t _float128_to_uint64_helper(float128 a) +{ + uint64_t frac_hi, frac_lo; + + if (a.parts.exp < FLOAT128_BIAS) { + // TODO: rounding + return 0; + } + + frac_hi = a.parts.frac_hi; + frac_lo = a.parts.frac_lo; + + frac_hi |= FLOAT128_HIDDEN_BIT_MASK_HI; + /* shift fraction to left so hidden bit will be the most significant bit */ + lshift128(frac_hi, frac_lo, + (128 - FLOAT128_FRACTION_SIZE - 1), &frac_hi, &frac_lo); + + rshift128(frac_hi, frac_lo, + (128 - (a.parts.exp - FLOAT128_BIAS) - 1), &frac_hi, &frac_lo); + if ((a.parts.sign == 1) && !eq128(frac_hi, frac_lo, 0x0ll, 0x0ll)) { + not128(frac_hi, frac_lo, &frac_hi, &frac_lo); + add128(frac_hi, frac_lo, 0x0ll, 0x1ll, &frac_hi, &frac_lo); + } + + return frac_lo; +} + +/* + * FIXME: Im not sure what to return if overflow/underflow happens + * - now its the biggest or the smallest int + */ +uint32_t float128_to_uint32(float128 a) +{ + if (is_float128_nan(a)) + return UINT32_MAX; + + if (is_float128_infinity(a) || (a.parts.exp >= (32 + FLOAT128_BIAS))) { + if (a.parts.sign) + return UINT32_MIN; + + return UINT32_MAX; + } + + return (uint32_t) _float128_to_uint64_helper(a); +} + +/* + * FIXME: Im not sure what to return if overflow/underflow happens + * - now its the biggest or the smallest int + */ +int32_t float128_to_int32(float128 a) +{ + if (is_float128_nan(a)) + return INT32_MAX; + + if (is_float128_infinity(a) || (a.parts.exp >= (32 + FLOAT128_BIAS))) { + if (a.parts.sign) + return INT32_MIN; + + return INT32_MAX; + } + + return (int32_t) _float128_to_uint64_helper(a); +} + +/* + * FIXME: Im not sure what to return if overflow/underflow happens + * - now its the biggest or the smallest int + */ +uint64_t float128_to_uint64(float128 a) +{ + if (is_float128_nan(a)) + return UINT64_MAX; + + if (is_float128_infinity(a) || (a.parts.exp >= (64 + FLOAT128_BIAS))) { + if (a.parts.sign) + return UINT64_MIN; + + return UINT64_MAX; + } + + return _float128_to_uint64_helper(a); +} + +/* + * FIXME: Im not sure what to return if overflow/underflow happens + * - now its the biggest or the smallest int + */ +int64_t float128_to_int64(float128 a) +{ + if (is_float128_nan(a)) + return INT64_MAX; + + if (is_float128_infinity(a) || (a.parts.exp >= (64 + FLOAT128_BIAS))) { + if (a.parts.sign) + return INT64_MIN; + + return INT64_MAX; + } + + return _float128_to_uint64_helper(a); +} + +float32 uint32_to_float32(uint32_t i) +{ + int counter; + int32_t exp; + float32 result; + + result.parts.sign = 0; + result.parts.fraction = 0; + + counter = count_zeroes32(i); + + exp = FLOAT32_BIAS + 32 - counter - 1; + + if (counter == 32) { + result.bin = 0; + return result; + } + + if (counter > 0) { + i <<= counter - 1; + } else { + i >>= 1; + } + + round_float32(&exp, &i); + + result.parts.fraction = i >> (32 - FLOAT32_FRACTION_SIZE - 2); + result.parts.exp = exp; + + return result; +} + +float32 int32_to_float32(int32_t i) +{ + float32 result; + + if (i < 0) + result = uint32_to_float32((uint32_t) (-i)); + else + result = uint32_to_float32((uint32_t) i); + + result.parts.sign = i < 0; + + return result; +} + +float32 uint64_to_float32(uint64_t i) +{ + int counter; + int32_t exp; + uint32_t j; + float32 result; + + result.parts.sign = 0; + result.parts.fraction = 0; + + counter = count_zeroes64(i); + + exp = FLOAT32_BIAS + 64 - counter - 1; + + if (counter == 64) { + result.bin = 0; + return result; + } + + /* Shift all to the first 31 bits (31st will be hidden 1) */ + if (counter > 33) { + i <<= counter - 1 - 32; + } else { + i >>= 1 + 32 - counter; + } + + j = (uint32_t) i; + round_float32(&exp, &j); + + result.parts.fraction = j >> (32 - FLOAT32_FRACTION_SIZE - 2); + result.parts.exp = exp; + return result; +} + +float32 int64_to_float32(int64_t i) +{ + float32 result; + + if (i < 0) + result = uint64_to_float32((uint64_t) (-i)); + else + result = uint64_to_float32((uint64_t) i); + + result.parts.sign = i < 0; + + return result; +} + +float64 uint32_to_float64(uint32_t i) +{ + int counter; + int32_t exp; + float64 result; + uint64_t frac; + + result.parts.sign = 0; + result.parts.fraction = 0; + + counter = count_zeroes32(i); + + exp = FLOAT64_BIAS + 32 - counter - 1; + + if (counter == 32) { + result.bin = 0; + return result; + } + + frac = i; + frac <<= counter + 32 - 1; + + round_float64(&exp, &frac); + + result.parts.fraction = frac >> (64 - FLOAT64_FRACTION_SIZE - 2); + result.parts.exp = exp; + + return result; +} + +float64 int32_to_float64(int32_t i) +{ + float64 result; + + if (i < 0) + result = uint32_to_float64((uint32_t) (-i)); + else + result = uint32_to_float64((uint32_t) i); + + result.parts.sign = i < 0; + + return result; +} + + +float64 uint64_to_float64(uint64_t i) +{ + int counter; + int32_t exp; + float64 result; + + result.parts.sign = 0; + result.parts.fraction = 0; + + counter = count_zeroes64(i); + + exp = FLOAT64_BIAS + 64 - counter - 1; + + if (counter == 64) { + result.bin = 0; + return result; + } + + if (counter > 0) { + i <<= counter - 1; + } else { + i >>= 1; + } + + round_float64(&exp, &i); + + result.parts.fraction = i >> (64 - FLOAT64_FRACTION_SIZE - 2); + result.parts.exp = exp; + return result; +} + +float64 int64_to_float64(int64_t i) +{ + float64 result; + + if (i < 0) + result = uint64_to_float64((uint64_t) (-i)); + else + result = uint64_to_float64((uint64_t) i); + + result.parts.sign = i < 0; + + return result; +} + +float128 uint32_to_float128(uint32_t i) +{ + int counter; + int32_t exp; + float128 result; + uint64_t frac_hi, frac_lo; + + result.parts.sign = 0; + result.parts.frac_hi = 0; + result.parts.frac_lo = 0; + + counter = count_zeroes32(i); + + exp = FLOAT128_BIAS + 32 - counter - 1; + + if (counter == 32) { + result.bin.hi = 0; + result.bin.lo = 0; + return result; + } + + frac_hi = 0; + frac_lo = i; + lshift128(frac_hi, frac_lo, (counter + 96 - 1), &frac_hi, &frac_lo); + + round_float128(&exp, &frac_hi, &frac_lo); + + rshift128(frac_hi, frac_lo, + (128 - FLOAT128_FRACTION_SIZE - 2), &frac_hi, &frac_lo); + result.parts.frac_hi = frac_hi; + result.parts.frac_lo = frac_lo; + result.parts.exp = exp; + + return result; +} + +float128 int32_to_float128(int32_t i) +{ + float128 result; + + if (i < 0) + result = uint32_to_float128((uint32_t) (-i)); + else + result = uint32_to_float128((uint32_t) i); + + result.parts.sign = i < 0; + + return result; +} + + +float128 uint64_to_float128(uint64_t i) +{ + int counter; + int32_t exp; + float128 result; + uint64_t frac_hi, frac_lo; + + result.parts.sign = 0; + result.parts.frac_hi = 0; + result.parts.frac_lo = 0; + + counter = count_zeroes64(i); + + exp = FLOAT128_BIAS + 64 - counter - 1; + + if (counter == 64) { + result.bin.hi = 0; + result.bin.lo = 0; + return result; + } + + frac_hi = 0; + frac_lo = i; + lshift128(frac_hi, frac_lo, (counter + 64 - 1), &frac_hi, &frac_lo); + + round_float128(&exp, &frac_hi, &frac_lo); + + rshift128(frac_hi, frac_lo, + (128 - FLOAT128_FRACTION_SIZE - 2), &frac_hi, &frac_lo); + result.parts.frac_hi = frac_hi; + result.parts.frac_lo = frac_lo; + result.parts.exp = exp; + + return result; +} + +float128 int64_to_float128(int64_t i) +{ + float128 result; + + if (i < 0) + result = uint64_to_float128((uint64_t) (-i)); + else + result = uint64_to_float128((uint64_t) i); + + result.parts.sign = i < 0; + + return result; +} + +/** @} + */ Index: uspace/lib/softfloat/conversion.h =================================================================== --- uspace/lib/softfloat/conversion.h (revision 1dbd189b0e98a0f835bd872d52126bb32e841feb) +++ uspace/lib/softfloat/conversion.h (revision 1dbd189b0e98a0f835bd872d52126bb32e841feb) @@ -0,0 +1,104 @@ +/* + * Copyright (c) 2005 Josef Cejka + * Copyright (c) 2011 Petr Koupy + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + + /** @addtogroup softfloat + * @{ + */ +/** @file Conversion of precision and conversion between integers and floats. + */ + +#ifndef __CONVERSION_H__ +#define __CONVERSION_H__ + +extern float64 float32_to_float64(float32); +extern float96 float32_to_float96(float32); +extern float128 float32_to_float128(float32); +extern float96 float64_to_float96(float64); +extern float128 float64_to_float128(float64); +extern float128 float96_to_float128(float96); + +extern float32 float64_to_float32(float64); +extern float32 float96_to_float32(float96); +extern float64 float96_to_float64(float96); +extern float32 float128_to_float32(float128); +extern float64 float128_to_float64(float128); +extern float96 float128_to_float96(float128); + +extern uint32_t float32_to_uint32(float32); +extern int32_t float32_to_int32(float32); + +extern uint64_t float32_to_uint64(float32); +extern int64_t float32_to_int64(float32); + +extern uint32_t float64_to_uint32(float64); +extern int32_t float64_to_int32(float64); + +extern uint64_t float64_to_uint64(float64); +extern int64_t float64_to_int64(float64); + +extern uint32_t float96_to_uint32(float96); +extern int32_t float96_to_int32(float96); + +extern uint64_t float96_to_uint64(float96); +extern int64_t float96_to_int64(float96); + +extern uint32_t float128_to_uint32(float128); +extern int32_t float128_to_int32(float128); + +extern uint64_t float128_to_uint64(float128); +extern int64_t float128_to_int64(float128); + +extern float32 uint32_to_float32(uint32_t); +extern float32 int32_to_float32(int32_t); + +extern float32 uint64_to_float32(uint64_t); +extern float32 int64_to_float32(int64_t); + +extern float64 uint32_to_float64(uint32_t); +extern float64 int32_to_float64(int32_t); + +extern float64 uint64_to_float64(uint64_t); +extern float64 int64_to_float64(int64_t); + +extern float96 uint32_to_float96(uint32_t); +extern float96 int32_to_float96(int32_t); + +extern float96 uint64_to_float96(uint64_t); +extern float96 int64_to_float96(int64_t); + +extern float128 uint32_to_float128(uint32_t); +extern float128 int32_to_float128(int32_t); + +extern float128 uint64_to_float128(uint64_t); +extern float128 int64_to_float128(int64_t); + +#endif + +/** @} + */ Index: uspace/lib/softfloat/div.c =================================================================== --- uspace/lib/softfloat/div.c (revision 1dbd189b0e98a0f835bd872d52126bb32e841feb) +++ uspace/lib/softfloat/div.c (revision 1dbd189b0e98a0f835bd872d52126bb32e841feb) @@ -0,0 +1,542 @@ +/* + * Copyright (c) 2005 Josef Cejka + * Copyright (c) 2011 Petr Koupy + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup softfloat + * @{ + */ +/** @file Division functions. + */ + +#include "sftypes.h" +#include "add.h" +#include "div.h" +#include "comparison.h" +#include "mul.h" +#include "common.h" + +/** Divide two single-precision floats. + * + * @param a Nominator. + * @param b Denominator. + * + * @return Result of division. + * + */ +float32 div_float32(float32 a, float32 b) +{ + float32 result; + int32_t aexp, bexp, cexp; + uint64_t afrac, bfrac, cfrac; + + result.parts.sign = a.parts.sign ^ b.parts.sign; + + if (is_float32_nan(a)) { + if (is_float32_signan(a)) { + // FIXME: SigNaN + } + /* NaN */ + return a; + } + + if (is_float32_nan(b)) { + if (is_float32_signan(b)) { + // FIXME: SigNaN + } + /* NaN */ + return b; + } + + if (is_float32_infinity(a)) { + if (is_float32_infinity(b)) { + /*FIXME: inf / inf */ + result.bin = FLOAT32_NAN; + return result; + } + /* inf / num */ + result.parts.exp = a.parts.exp; + result.parts.fraction = a.parts.fraction; + return result; + } + + if (is_float32_infinity(b)) { + if (is_float32_zero(a)) { + /* FIXME 0 / inf */ + result.parts.exp = 0; + result.parts.fraction = 0; + return result; + } + /* FIXME: num / inf*/ + result.parts.exp = 0; + result.parts.fraction = 0; + return result; + } + + if (is_float32_zero(b)) { + if (is_float32_zero(a)) { + /*FIXME: 0 / 0*/ + result.bin = FLOAT32_NAN; + return result; + } + /* FIXME: division by zero */ + result.parts.exp = 0; + result.parts.fraction = 0; + return result; + } + + afrac = a.parts.fraction; + aexp = a.parts.exp; + bfrac = b.parts.fraction; + bexp = b.parts.exp; + + /* denormalized numbers */ + if (aexp == 0) { + if (afrac == 0) { + result.parts.exp = 0; + result.parts.fraction = 0; + return result; + } + + /* normalize it*/ + afrac <<= 1; + /* afrac is nonzero => it must stop */ + while (!(afrac & FLOAT32_HIDDEN_BIT_MASK)) { + afrac <<= 1; + aexp--; + } + } + + if (bexp == 0) { + bfrac <<= 1; + /* bfrac is nonzero => it must stop */ + while (!(bfrac & FLOAT32_HIDDEN_BIT_MASK)) { + bfrac <<= 1; + bexp--; + } + } + + afrac = (afrac | FLOAT32_HIDDEN_BIT_MASK) << (32 - FLOAT32_FRACTION_SIZE - 1); + bfrac = (bfrac | FLOAT32_HIDDEN_BIT_MASK) << (32 - FLOAT32_FRACTION_SIZE); + + if (bfrac <= (afrac << 1)) { + afrac >>= 1; + aexp++; + } + + cexp = aexp - bexp + FLOAT32_BIAS - 2; + + cfrac = (afrac << 32) / bfrac; + if ((cfrac & 0x3F) == 0) { + cfrac |= (bfrac * cfrac != afrac << 32); + } + + /* pack and round */ + + /* find first nonzero digit and shift result and detect possibly underflow */ + while ((cexp > 0) && (cfrac) && (!(cfrac & (FLOAT32_HIDDEN_BIT_MASK << 7)))) { + cexp--; + cfrac <<= 1; + /* TODO: fix underflow */ + } + + cfrac += (0x1 << 6); /* FIXME: 7 is not sure*/ + + if (cfrac & (FLOAT32_HIDDEN_BIT_MASK << 7)) { + ++cexp; + cfrac >>= 1; + } + + /* check overflow */ + if (cexp >= FLOAT32_MAX_EXPONENT) { + /* FIXME: overflow, return infinity */ + result.parts.exp = FLOAT32_MAX_EXPONENT; + result.parts.fraction = 0; + return result; + } + + if (cexp < 0) { + /* FIXME: underflow */ + result.parts.exp = 0; + if ((cexp + FLOAT32_FRACTION_SIZE) < 0) { + result.parts.fraction = 0; + return result; + } + cfrac >>= 1; + while (cexp < 0) { + cexp++; + cfrac >>= 1; + } + } else { + result.parts.exp = (uint32_t) cexp; + } + + result.parts.fraction = ((cfrac >> 6) & (~FLOAT32_HIDDEN_BIT_MASK)); + + return result; +} + +/** Divide two double-precision floats. + * + * @param a Nominator. + * @param b Denominator. + * + * @return Result of division. + * + */ +float64 div_float64(float64 a, float64 b) +{ + float64 result; + int64_t aexp, bexp, cexp; + uint64_t afrac, bfrac, cfrac; + uint64_t remlo, remhi; + uint64_t tmplo, tmphi; + + result.parts.sign = a.parts.sign ^ b.parts.sign; + + if (is_float64_nan(a)) { + if (is_float64_signan(b)) { + // FIXME: SigNaN + return b; + } + + if (is_float64_signan(a)) { + // FIXME: SigNaN + } + /* NaN */ + return a; + } + + if (is_float64_nan(b)) { + if (is_float64_signan(b)) { + // FIXME: SigNaN + } + /* NaN */ + return b; + } + + if (is_float64_infinity(a)) { + if (is_float64_infinity(b) || is_float64_zero(b)) { + // FIXME: inf / inf + result.bin = FLOAT64_NAN; + return result; + } + /* inf / num */ + result.parts.exp = a.parts.exp; + result.parts.fraction = a.parts.fraction; + return result; + } + + if (is_float64_infinity(b)) { + if (is_float64_zero(a)) { + /* FIXME 0 / inf */ + result.parts.exp = 0; + result.parts.fraction = 0; + return result; + } + /* FIXME: num / inf*/ + result.parts.exp = 0; + result.parts.fraction = 0; + return result; + } + + if (is_float64_zero(b)) { + if (is_float64_zero(a)) { + /*FIXME: 0 / 0*/ + result.bin = FLOAT64_NAN; + return result; + } + /* FIXME: division by zero */ + result.parts.exp = 0; + result.parts.fraction = 0; + return result; + } + + afrac = a.parts.fraction; + aexp = a.parts.exp; + bfrac = b.parts.fraction; + bexp = b.parts.exp; + + /* denormalized numbers */ + if (aexp == 0) { + if (afrac == 0) { + result.parts.exp = 0; + result.parts.fraction = 0; + return result; + } + + /* normalize it*/ + aexp++; + /* afrac is nonzero => it must stop */ + while (!(afrac & FLOAT64_HIDDEN_BIT_MASK)) { + afrac <<= 1; + aexp--; + } + } + + if (bexp == 0) { + bexp++; + /* bfrac is nonzero => it must stop */ + while (!(bfrac & FLOAT64_HIDDEN_BIT_MASK)) { + bfrac <<= 1; + bexp--; + } + } + + afrac = (afrac | FLOAT64_HIDDEN_BIT_MASK) << (64 - FLOAT64_FRACTION_SIZE - 2); + bfrac = (bfrac | FLOAT64_HIDDEN_BIT_MASK) << (64 - FLOAT64_FRACTION_SIZE - 1); + + if (bfrac <= (afrac << 1)) { + afrac >>= 1; + aexp++; + } + + cexp = aexp - bexp + FLOAT64_BIAS - 2; + + cfrac = div128est(afrac, 0x0ll, bfrac); + + if ((cfrac & 0x1FF) <= 2) { + mul64(bfrac, cfrac, &tmphi, &tmplo); + sub128(afrac, 0x0ll, tmphi, tmplo, &remhi, &remlo); + + while ((int64_t) remhi < 0) { + cfrac--; + add128(remhi, remlo, 0x0ll, bfrac, &remhi, &remlo); + } + cfrac |= (remlo != 0); + } + + /* round and shift */ + result = finish_float64(cexp, cfrac, result.parts.sign); + return result; +} + +/** Divide two quadruple-precision floats. + * + * @param a Nominator. + * @param b Denominator. + * + * @return Result of division. + * + */ +float128 div_float128(float128 a, float128 b) +{ + float128 result; + int64_t aexp, bexp, cexp; + uint64_t afrac_hi, afrac_lo, bfrac_hi, bfrac_lo, cfrac_hi, cfrac_lo; + uint64_t shift_out; + uint64_t rem_hihi, rem_hilo, rem_lohi, rem_lolo; + uint64_t tmp_hihi, tmp_hilo, tmp_lohi, tmp_lolo; + + result.parts.sign = a.parts.sign ^ b.parts.sign; + + if (is_float128_nan(a)) { + if (is_float128_signan(b)) { + // FIXME: SigNaN + return b; + } + + if (is_float128_signan(a)) { + // FIXME: SigNaN + } + /* NaN */ + return a; + } + + if (is_float128_nan(b)) { + if (is_float128_signan(b)) { + // FIXME: SigNaN + } + /* NaN */ + return b; + } + + if (is_float128_infinity(a)) { + if (is_float128_infinity(b) || is_float128_zero(b)) { + // FIXME: inf / inf + result.bin.hi = FLOAT128_NAN_HI; + result.bin.lo = FLOAT128_NAN_LO; + return result; + } + /* inf / num */ + result.parts.exp = a.parts.exp; + result.parts.frac_hi = a.parts.frac_hi; + result.parts.frac_lo = a.parts.frac_lo; + return result; + } + + if (is_float128_infinity(b)) { + if (is_float128_zero(a)) { + // FIXME 0 / inf + result.parts.exp = 0; + result.parts.frac_hi = 0; + result.parts.frac_lo = 0; + return result; + } + // FIXME: num / inf + result.parts.exp = 0; + result.parts.frac_hi = 0; + result.parts.frac_lo = 0; + return result; + } + + if (is_float128_zero(b)) { + if (is_float128_zero(a)) { + // FIXME: 0 / 0 + result.bin.hi = FLOAT128_NAN_HI; + result.bin.lo = FLOAT128_NAN_LO; + return result; + } + // FIXME: division by zero + result.parts.exp = 0; + result.parts.frac_hi = 0; + result.parts.frac_lo = 0; + return result; + } + + afrac_hi = a.parts.frac_hi; + afrac_lo = a.parts.frac_lo; + aexp = a.parts.exp; + bfrac_hi = b.parts.frac_hi; + bfrac_lo = b.parts.frac_lo; + bexp = b.parts.exp; + + /* denormalized numbers */ + if (aexp == 0) { + if (eq128(afrac_hi, afrac_lo, 0x0ll, 0x0ll)) { + result.parts.exp = 0; + result.parts.frac_hi = 0; + result.parts.frac_lo = 0; + return result; + } + + /* normalize it*/ + aexp++; + /* afrac is nonzero => it must stop */ + and128(afrac_hi, afrac_lo, + FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO, + &tmp_hihi, &tmp_lolo); + while (!lt128(0x0ll, 0x0ll, tmp_hihi, tmp_lolo)) { + lshift128(afrac_hi, afrac_lo, 1, &afrac_hi, &afrac_lo); + aexp--; + } + } + + if (bexp == 0) { + bexp++; + /* bfrac is nonzero => it must stop */ + and128(bfrac_hi, bfrac_lo, + FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO, + &tmp_hihi, &tmp_lolo); + while (!lt128(0x0ll, 0x0ll, tmp_hihi, tmp_lolo)) { + lshift128(bfrac_hi, bfrac_lo, 1, &bfrac_hi, &bfrac_lo); + bexp--; + } + } + + or128(afrac_hi, afrac_lo, + FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO, + &afrac_hi, &afrac_lo); + lshift128(afrac_hi, afrac_lo, + (128 - FLOAT128_FRACTION_SIZE - 1), &afrac_hi, &afrac_lo); + or128(bfrac_hi, bfrac_lo, + FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO, + &bfrac_hi, &bfrac_lo); + lshift128(bfrac_hi, bfrac_lo, + (128 - FLOAT128_FRACTION_SIZE - 1), &bfrac_hi, &bfrac_lo); + + if (le128(bfrac_hi, bfrac_lo, afrac_hi, afrac_lo)) { + rshift128(afrac_hi, afrac_lo, 1, &afrac_hi, &afrac_lo); + aexp++; + } + + cexp = aexp - bexp + FLOAT128_BIAS - 2; + + cfrac_hi = div128est(afrac_hi, afrac_lo, bfrac_hi); + + mul128(bfrac_hi, bfrac_lo, 0x0ll, cfrac_hi, + &tmp_lolo /* dummy */, &tmp_hihi, &tmp_hilo, &tmp_lohi); + + /* sub192(afrac_hi, afrac_lo, 0, + * tmp_hihi, tmp_hilo, tmp_lohi + * &rem_hihi, &rem_hilo, &rem_lohi); */ + sub128(afrac_hi, afrac_lo, tmp_hihi, tmp_hilo, &rem_hihi, &rem_hilo); + if (tmp_lohi > 0) { + sub128(rem_hihi, rem_hilo, 0x0ll, 0x1ll, &rem_hihi, &rem_hilo); + } + rem_lohi = -tmp_lohi; + + while ((int64_t) rem_hihi < 0) { + --cfrac_hi; + /* add192(rem_hihi, rem_hilo, rem_lohi, + * 0, bfrac_hi, bfrac_lo, + * &rem_hihi, &rem_hilo, &rem_lohi); */ + add128(rem_hilo, rem_lohi, bfrac_hi, bfrac_lo, &rem_hilo, &rem_lohi); + if (lt128(rem_hilo, rem_lohi, bfrac_hi, bfrac_lo)) { + ++rem_hihi; + } + } + + cfrac_lo = div128est(rem_hilo, rem_lohi, bfrac_lo); + + if ((cfrac_lo & 0x3FFF) <= 4) { + mul128(bfrac_hi, bfrac_lo, 0x0ll, cfrac_lo, + &tmp_hihi /* dummy */, &tmp_hilo, &tmp_lohi, &tmp_lolo); + + /* sub192(rem_hilo, rem_lohi, 0, + * tmp_hilo, tmp_lohi, tmp_lolo, + * &rem_hilo, &rem_lohi, &rem_lolo); */ + sub128(rem_hilo, rem_lohi, tmp_hilo, tmp_lohi, &rem_hilo, &rem_lohi); + if (tmp_lolo > 0) { + sub128(rem_hilo, rem_lohi, 0x0ll, 0x1ll, &rem_hilo, &rem_lohi); + } + rem_lolo = -tmp_lolo; + + while ((int64_t) rem_hilo < 0) { + --cfrac_lo; + /* add192(rem_hilo, rem_lohi, rem_lolo, + * 0, bfrac_hi, bfrac_lo, + * &rem_hilo, &rem_lohi, &rem_lolo); */ + add128(rem_lohi, rem_lolo, bfrac_hi, bfrac_lo, &rem_lohi, &rem_lolo); + if (lt128(rem_lohi, rem_lolo, bfrac_hi, bfrac_lo)) { + ++rem_hilo; + } + } + + cfrac_lo |= ((rem_hilo | rem_lohi | rem_lolo) != 0 ); + } + + shift_out = cfrac_lo << (64 - (128 - FLOAT128_FRACTION_SIZE - 1)); + rshift128(cfrac_hi, cfrac_lo, (128 - FLOAT128_FRACTION_SIZE - 1), + &cfrac_hi, &cfrac_lo); + + result = finish_float128(cexp, cfrac_hi, cfrac_lo, result.parts.sign, shift_out); + return result; +} + +/** @} + */ Index: uspace/lib/softfloat/div.h =================================================================== --- uspace/lib/softfloat/div.h (revision 1dbd189b0e98a0f835bd872d52126bb32e841feb) +++ uspace/lib/softfloat/div.h (revision 1dbd189b0e98a0f835bd872d52126bb32e841feb) @@ -0,0 +1,47 @@ +/* + * Copyright (c) 2005 Josef Cejka + * Copyright (c) 2011 Petr Koupy + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup softfloat + * @{ + */ +/** @file Division functions. + */ + +#ifndef __DIV_H__ +#define __DIV_H__ + +extern float32 div_float32(float32, float32); +extern float64 div_float64(float64, float64); +extern float96 div_float96(float96, float96); +extern float128 div_float128(float128, float128); + +#endif + +/** @} + */ Index: uspace/lib/softfloat/generic/add.c =================================================================== --- uspace/lib/softfloat/generic/add.c (revision 7aa6b99d7bd8a569a8bc3394901a26702aa2a5a9) +++ (revision ) @@ -1,416 +1,0 @@ -/* - * Copyright (c) 2005 Josef Cejka - * Copyright (c) 2011 Petr Koupy - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * - Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR - * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES - * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, - * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF - * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -/** @addtogroup softfloat - * @{ - */ -/** @file Addition functions. - */ - -#include -#include -#include -#include - -/** Add two single-precision floats with the same sign. - * - * @param a First input operand. - * @param b Second input operand. - * @return Result of addition. - */ -float32 add_float32(float32 a, float32 b) -{ - int expdiff; - uint32_t exp1, exp2, frac1, frac2; - - expdiff = a.parts.exp - b.parts.exp; - if (expdiff < 0) { - if (is_float32_nan(b)) { - /* TODO: fix SigNaN */ - if (is_float32_signan(b)) { - } - - return b; - } - - if (b.parts.exp == FLOAT32_MAX_EXPONENT) { - return b; - } - - frac1 = b.parts.fraction; - exp1 = b.parts.exp; - frac2 = a.parts.fraction; - exp2 = a.parts.exp; - expdiff *= -1; - } else { - if ((is_float32_nan(a)) || (is_float32_nan(b))) { - /* TODO: fix SigNaN */ - if (is_float32_signan(a) || is_float32_signan(b)) { - } - return (is_float32_nan(a) ? a : b); - } - - if (a.parts.exp == FLOAT32_MAX_EXPONENT) { - return a; - } - - frac1 = a.parts.fraction; - exp1 = a.parts.exp; - frac2 = b.parts.fraction; - exp2 = b.parts.exp; - } - - if (exp1 == 0) { - /* both are denormalized */ - frac1 += frac2; - if (frac1 & FLOAT32_HIDDEN_BIT_MASK ) { - /* result is not denormalized */ - a.parts.exp = 1; - } - a.parts.fraction = frac1; - return a; - } - - frac1 |= FLOAT32_HIDDEN_BIT_MASK; /* add hidden bit */ - - if (exp2 == 0) { - /* second operand is denormalized */ - --expdiff; - } else { - /* add hidden bit to second operand */ - frac2 |= FLOAT32_HIDDEN_BIT_MASK; - } - - /* create some space for rounding */ - frac1 <<= 6; - frac2 <<= 6; - - if (expdiff < (FLOAT32_FRACTION_SIZE + 2) ) { - frac2 >>= expdiff; - frac1 += frac2; - } else { - a.parts.exp = exp1; - a.parts.fraction = (frac1 >> 6) & (~(FLOAT32_HIDDEN_BIT_MASK)); - return a; - } - - if (frac1 & (FLOAT32_HIDDEN_BIT_MASK << 7) ) { - ++exp1; - frac1 >>= 1; - } - - /* rounding - if first bit after fraction is set then round up */ - frac1 += (0x1 << 5); - - if (frac1 & (FLOAT32_HIDDEN_BIT_MASK << 7)) { - /* rounding overflow */ - ++exp1; - frac1 >>= 1; - } - - if ((exp1 == FLOAT32_MAX_EXPONENT ) || (exp2 > exp1)) { - /* overflow - set infinity as result */ - a.parts.exp = FLOAT32_MAX_EXPONENT; - a.parts.fraction = 0; - return a; - } - - a.parts.exp = exp1; - - /* Clear hidden bit and shift */ - a.parts.fraction = ((frac1 >> 6) & (~FLOAT32_HIDDEN_BIT_MASK)); - return a; -} - -/** Add two double-precision floats with the same sign. - * - * @param a First input operand. - * @param b Second input operand. - * @return Result of addition. - */ -float64 add_float64(float64 a, float64 b) -{ - int expdiff; - uint32_t exp1, exp2; - uint64_t frac1, frac2; - - expdiff = ((int) a.parts.exp) - b.parts.exp; - if (expdiff < 0) { - if (is_float64_nan(b)) { - /* TODO: fix SigNaN */ - if (is_float64_signan(b)) { - } - - return b; - } - - /* b is infinity and a not */ - if (b.parts.exp == FLOAT64_MAX_EXPONENT) { - return b; - } - - frac1 = b.parts.fraction; - exp1 = b.parts.exp; - frac2 = a.parts.fraction; - exp2 = a.parts.exp; - expdiff *= -1; - } else { - if (is_float64_nan(a)) { - /* TODO: fix SigNaN */ - if (is_float64_signan(a) || is_float64_signan(b)) { - } - return a; - } - - /* a is infinity and b not */ - if (a.parts.exp == FLOAT64_MAX_EXPONENT) { - return a; - } - - frac1 = a.parts.fraction; - exp1 = a.parts.exp; - frac2 = b.parts.fraction; - exp2 = b.parts.exp; - } - - if (exp1 == 0) { - /* both are denormalized */ - frac1 += frac2; - if (frac1 & FLOAT64_HIDDEN_BIT_MASK) { - /* result is not denormalized */ - a.parts.exp = 1; - } - a.parts.fraction = frac1; - return a; - } - - /* add hidden bit - frac1 is sure not denormalized */ - frac1 |= FLOAT64_HIDDEN_BIT_MASK; - - /* second operand ... */ - if (exp2 == 0) { - /* ... is denormalized */ - --expdiff; - } else { - /* is not denormalized */ - frac2 |= FLOAT64_HIDDEN_BIT_MASK; - } - - /* create some space for rounding */ - frac1 <<= 6; - frac2 <<= 6; - - if (expdiff < (FLOAT64_FRACTION_SIZE + 2)) { - frac2 >>= expdiff; - frac1 += frac2; - } else { - a.parts.exp = exp1; - a.parts.fraction = (frac1 >> 6) & (~(FLOAT64_HIDDEN_BIT_MASK)); - return a; - } - - if (frac1 & (FLOAT64_HIDDEN_BIT_MASK << 7)) { - ++exp1; - frac1 >>= 1; - } - - /* rounding - if first bit after fraction is set then round up */ - frac1 += (0x1 << 5); - - if (frac1 & (FLOAT64_HIDDEN_BIT_MASK << 7)) { - /* rounding overflow */ - ++exp1; - frac1 >>= 1; - } - - if ((exp1 == FLOAT64_MAX_EXPONENT ) || (exp2 > exp1)) { - /* overflow - set infinity as result */ - a.parts.exp = FLOAT64_MAX_EXPONENT; - a.parts.fraction = 0; - return a; - } - - a.parts.exp = exp1; - /* Clear hidden bit and shift */ - a.parts.fraction = ((frac1 >> 6 ) & (~FLOAT64_HIDDEN_BIT_MASK)); - return a; -} - -/** Add two quadruple-precision floats with the same sign. - * - * @param a First input operand. - * @param b Second input operand. - * @return Result of addition. - */ -float128 add_float128(float128 a, float128 b) -{ - int expdiff; - uint32_t exp1, exp2; - uint64_t frac1_hi, frac1_lo, frac2_hi, frac2_lo, tmp_hi, tmp_lo; - - expdiff = ((int) a.parts.exp) - b.parts.exp; - if (expdiff < 0) { - if (is_float128_nan(b)) { - /* TODO: fix SigNaN */ - if (is_float128_signan(b)) { - } - - return b; - } - - /* b is infinity and a not */ - if (b.parts.exp == FLOAT128_MAX_EXPONENT) { - return b; - } - - frac1_hi = b.parts.frac_hi; - frac1_lo = b.parts.frac_lo; - exp1 = b.parts.exp; - frac2_hi = a.parts.frac_hi; - frac2_lo = a.parts.frac_lo; - exp2 = a.parts.exp; - expdiff *= -1; - } else { - if (is_float128_nan(a)) { - /* TODO: fix SigNaN */ - if (is_float128_signan(a) || is_float128_signan(b)) { - } - return a; - } - - /* a is infinity and b not */ - if (a.parts.exp == FLOAT128_MAX_EXPONENT) { - return a; - } - - frac1_hi = a.parts.frac_hi; - frac1_lo = a.parts.frac_lo; - exp1 = a.parts.exp; - frac2_hi = b.parts.frac_hi; - frac2_lo = b.parts.frac_lo; - exp2 = b.parts.exp; - } - - if (exp1 == 0) { - /* both are denormalized */ - add128(frac1_hi, frac1_lo, frac2_hi, frac2_lo, &frac1_hi, &frac1_lo); - - and128(frac1_hi, frac1_lo, - FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO, - &tmp_hi, &tmp_lo); - if (lt128(0x0ll, 0x0ll, tmp_hi, tmp_lo)) { - /* result is not denormalized */ - a.parts.exp = 1; - } - - a.parts.frac_hi = frac1_hi; - a.parts.frac_lo = frac1_lo; - return a; - } - - /* add hidden bit - frac1 is sure not denormalized */ - or128(frac1_hi, frac1_lo, - FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO, - &frac1_hi, &frac1_lo); - - /* second operand ... */ - if (exp2 == 0) { - /* ... is denormalized */ - --expdiff; - } else { - /* is not denormalized */ - or128(frac2_hi, frac2_lo, - FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO, - &frac2_hi, &frac2_lo); - } - - /* create some space for rounding */ - lshift128(frac1_hi, frac1_lo, 6, &frac1_hi, &frac1_lo); - lshift128(frac2_hi, frac2_lo, 6, &frac2_hi, &frac2_lo); - - if (expdiff < (FLOAT128_FRACTION_SIZE + 2)) { - rshift128(frac2_hi, frac2_lo, expdiff, &frac2_hi, &frac2_lo); - add128(frac1_hi, frac1_lo, frac2_hi, frac2_lo, &frac1_hi, &frac1_lo); - } else { - a.parts.exp = exp1; - - rshift128(frac1_hi, frac1_lo, 6, &frac1_hi, &frac1_lo); - not128(FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO, - &tmp_hi, &tmp_lo); - and128(frac1_hi, frac1_lo, tmp_hi, tmp_lo, &tmp_hi, &tmp_lo); - - a.parts.frac_hi = tmp_hi; - a.parts.frac_lo = tmp_lo; - return a; - } - - lshift128(FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO, 7, - &tmp_hi, &tmp_lo); - and128(frac1_hi, frac1_lo, tmp_hi, tmp_lo, &tmp_hi, &tmp_lo); - if (lt128(0x0ll, 0x0ll, tmp_hi, tmp_lo)) { - ++exp1; - rshift128(frac1_hi, frac1_lo, 1, &frac1_hi, &frac1_lo); - } - - /* rounding - if first bit after fraction is set then round up */ - add128(frac1_hi, frac1_lo, 0x0ll, 0x1ll << 5, &frac1_hi, &frac1_lo); - - lshift128(FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO, 7, - &tmp_hi, &tmp_lo); - and128(frac1_hi, frac1_lo, tmp_hi, tmp_lo, &tmp_hi, &tmp_lo); - if (lt128(0x0ll, 0x0ll, tmp_hi, tmp_lo)) { - /* rounding overflow */ - ++exp1; - rshift128(frac1_hi, frac1_lo, 1, &frac1_hi, &frac1_lo); - } - - if ((exp1 == FLOAT128_MAX_EXPONENT ) || (exp2 > exp1)) { - /* overflow - set infinity as result */ - a.parts.exp = FLOAT64_MAX_EXPONENT; - a.parts.frac_hi = 0; - a.parts.frac_lo = 0; - return a; - } - - a.parts.exp = exp1; - - /* Clear hidden bit and shift */ - rshift128(frac1_hi, frac1_lo, 6, &frac1_hi, &frac1_lo); - not128(FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO, - &tmp_hi, &tmp_lo); - and128(frac1_hi, frac1_lo, tmp_hi, tmp_lo, &tmp_hi, &tmp_lo); - - a.parts.frac_hi = tmp_hi; - a.parts.frac_lo = tmp_lo; - - return a; -} - -/** @} - */ Index: uspace/lib/softfloat/generic/common.c =================================================================== --- uspace/lib/softfloat/generic/common.c (revision 7aa6b99d7bd8a569a8bc3394901a26702aa2a5a9) +++ (revision ) @@ -1,690 +1,0 @@ -/* - * Copyright (c) 2005 Josef Cejka - * Copyright (c) 2011 Petr Koupy - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * - Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR - * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES - * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, - * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF - * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -/** @addtogroup softfloat - * @{ - */ -/** @file Common helper operations. - */ - -#include -#include - -/* Table for fast leading zeroes counting. */ -char zeroTable[256] = { - 8, 7, 7, 6, 6, 6, 6, 4, 4, 4, 4, 4, 4, 4, 4, \ - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, \ - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, \ - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, \ - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \ - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \ - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \ - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \ - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \ - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \ - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \ - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \ - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \ - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \ - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \ - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 -}; - -/** - * Take fraction shifted by 10 bits to the left, round it, normalize it - * and detect exceptions - * - * @param cexp Exponent with bias. - * @param cfrac Fraction shifted 10 bits to the left with added hidden bit. - * @param sign Resulting sign. - * @return Finished double-precision float. - */ -float64 finish_float64(int32_t cexp, uint64_t cfrac, char sign) -{ - float64 result; - - result.parts.sign = sign; - - /* find first nonzero digit and shift result and detect possibly underflow */ - while ((cexp > 0) && (cfrac) && - (!(cfrac & (FLOAT64_HIDDEN_BIT_MASK << (64 - FLOAT64_FRACTION_SIZE - 1))))) { - cexp--; - cfrac <<= 1; - /* TODO: fix underflow */ - } - - if ((cexp < 0) || (cexp == 0 && - (!(cfrac & (FLOAT64_HIDDEN_BIT_MASK << (64 - FLOAT64_FRACTION_SIZE - 1)))))) { - /* FIXME: underflow */ - result.parts.exp = 0; - if ((cexp + FLOAT64_FRACTION_SIZE + 1) < 0) { /* +1 is place for rounding */ - result.parts.fraction = 0; - return result; - } - - while (cexp < 0) { - cexp++; - cfrac >>= 1; - } - - cfrac += (0x1 << (64 - FLOAT64_FRACTION_SIZE - 3)); - - if (!(cfrac & (FLOAT64_HIDDEN_BIT_MASK << (64 - FLOAT64_FRACTION_SIZE - 1)))) { - result.parts.fraction = - ((cfrac >> (64 - FLOAT64_FRACTION_SIZE - 2)) & (~FLOAT64_HIDDEN_BIT_MASK)); - return result; - } - } else { - cfrac += (0x1 << (64 - FLOAT64_FRACTION_SIZE - 3)); - } - - ++cexp; - - if (cfrac & (FLOAT64_HIDDEN_BIT_MASK << (64 - FLOAT64_FRACTION_SIZE - 1))) { - ++cexp; - cfrac >>= 1; - } - - /* check overflow */ - if (cexp >= FLOAT64_MAX_EXPONENT) { - /* FIXME: overflow, return infinity */ - result.parts.exp = FLOAT64_MAX_EXPONENT; - result.parts.fraction = 0; - return result; - } - - result.parts.exp = (uint32_t) cexp; - - result.parts.fraction = - ((cfrac >> (64 - FLOAT64_FRACTION_SIZE - 2)) & (~FLOAT64_HIDDEN_BIT_MASK)); - - return result; -} - -/** - * Take fraction, round it, normalize it and detect exceptions - * - * @param cexp Exponent with bias. - * @param cfrac_hi High part of the fraction shifted 14 bits to the left - * with added hidden bit. - * @param cfrac_lo Low part of the fraction shifted 14 bits to the left - * with added hidden bit. - * @param sign Resulting sign. - * @param shift_out Bits right-shifted out from fraction by the caller. - * @return Finished quadruple-precision float. - */ -float128 finish_float128(int32_t cexp, uint64_t cfrac_hi, uint64_t cfrac_lo, - char sign, uint64_t shift_out) -{ - float128 result; - uint64_t tmp_hi, tmp_lo; - - result.parts.sign = sign; - - /* find first nonzero digit and shift result and detect possibly underflow */ - lshift128(FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO, - 1, &tmp_hi, &tmp_lo); - and128(cfrac_hi, cfrac_lo, tmp_hi, tmp_lo, &tmp_hi, &tmp_lo); - while ((cexp > 0) && (lt128(0x0ll, 0x0ll, cfrac_hi, cfrac_lo)) && - (!lt128(0x0ll, 0x0ll, tmp_hi, tmp_lo))) { - cexp--; - lshift128(cfrac_hi, cfrac_lo, 1, &cfrac_hi, &cfrac_lo); - /* TODO: fix underflow */ - - lshift128(FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO, - 1, &tmp_hi, &tmp_lo); - and128(cfrac_hi, cfrac_lo, tmp_hi, tmp_lo, &tmp_hi, &tmp_lo); - } - - lshift128(FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO, - 1, &tmp_hi, &tmp_lo); - and128(cfrac_hi, cfrac_lo, tmp_hi, tmp_lo, &tmp_hi, &tmp_lo); - if ((cexp < 0) || (cexp == 0 && - (!lt128(0x0ll, 0x0ll, tmp_hi, tmp_lo)))) { - /* FIXME: underflow */ - result.parts.exp = 0; - if ((cexp + FLOAT128_FRACTION_SIZE + 1) < 0) { /* +1 is place for rounding */ - result.parts.frac_hi = 0x0ll; - result.parts.frac_lo = 0x0ll; - return result; - } - - while (cexp < 0) { - cexp++; - rshift128(cfrac_hi, cfrac_lo, 1, &cfrac_hi, &cfrac_lo); - } - - if (shift_out & (0x1ull < 64)) { - add128(cfrac_hi, cfrac_lo, 0x0ll, 0x1ll, &cfrac_hi, &cfrac_lo); - } - - lshift128(FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO, - 1, &tmp_hi, &tmp_lo); - and128(cfrac_hi, cfrac_lo, tmp_hi, tmp_lo, &tmp_hi, &tmp_lo); - if (!lt128(0x0ll, 0x0ll, tmp_hi, tmp_lo)) { - not128(FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO, - &tmp_hi, &tmp_lo); - and128(cfrac_hi, cfrac_lo, tmp_hi, tmp_lo, &tmp_hi, &tmp_lo); - result.parts.frac_hi = tmp_hi; - result.parts.frac_lo = tmp_lo; - return result; - } - } else { - if (shift_out & (0x1ull < 64)) { - add128(cfrac_hi, cfrac_lo, 0x0ll, 0x1ll, &cfrac_hi, &cfrac_lo); - } - } - - ++cexp; - - lshift128(FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO, - 1, &tmp_hi, &tmp_lo); - and128(cfrac_hi, cfrac_lo, tmp_hi, tmp_lo, &tmp_hi, &tmp_lo); - if (lt128(0x0ll, 0x0ll, tmp_hi, tmp_lo)) { - ++cexp; - rshift128(cfrac_hi, cfrac_lo, 1, &cfrac_hi, &cfrac_lo); - } - - /* check overflow */ - if (cexp >= FLOAT128_MAX_EXPONENT) { - /* FIXME: overflow, return infinity */ - result.parts.exp = FLOAT128_MAX_EXPONENT; - result.parts.frac_hi = 0x0ll; - result.parts.frac_lo = 0x0ll; - return result; - } - - result.parts.exp = (uint32_t) cexp; - - not128(FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO, - &tmp_hi, &tmp_lo); - and128(cfrac_hi, cfrac_lo, tmp_hi, tmp_lo, &tmp_hi, &tmp_lo); - result.parts.frac_hi = tmp_hi; - result.parts.frac_lo = tmp_lo; - - return result; -} - -/** - * Counts leading zeroes in byte. - * - * @param i Byte for which to count leading zeroes. - * @return Number of detected leading zeroes. - */ -int count_zeroes8(uint8_t i) -{ - return zeroTable[i]; -} - -/** - * Counts leading zeroes in 32bit unsigned integer. - * - * @param i Integer for which to count leading zeroes. - * @return Number of detected leading zeroes. - */ -int count_zeroes32(uint32_t i) -{ - int j; - for (j = 0; j < 32; j += 8) { - if (i & (0xFF << (24 - j))) { - return (j + count_zeroes8(i >> (24 - j))); - } - } - - return 32; -} - -/** - * Counts leading zeroes in 64bit unsigned integer. - * - * @param i Integer for which to count leading zeroes. - * @return Number of detected leading zeroes. - */ -int count_zeroes64(uint64_t i) -{ - int j; - for (j = 0; j < 64; j += 8) { - if (i & (0xFFll << (56 - j))) { - return (j + count_zeroes8(i >> (56 - j))); - } - } - - return 64; -} - -/** - * Round and normalize number expressed by exponent and fraction with - * first bit (equal to hidden bit) at 30th bit. - * - * @param exp Exponent part. - * @param fraction Fraction with hidden bit shifted to 30th bit. - */ -void round_float32(int32_t *exp, uint32_t *fraction) -{ - /* rounding - if first bit after fraction is set then round up */ - (*fraction) += (0x1 << (32 - FLOAT32_FRACTION_SIZE - 3)); - - if ((*fraction) & - (FLOAT32_HIDDEN_BIT_MASK << (32 - FLOAT32_FRACTION_SIZE - 1))) { - /* rounding overflow */ - ++(*exp); - (*fraction) >>= 1; - } - - if (((*exp) >= FLOAT32_MAX_EXPONENT) || ((*exp) < 0)) { - /* overflow - set infinity as result */ - (*exp) = FLOAT32_MAX_EXPONENT; - (*fraction) = 0; - } -} - -/** - * Round and normalize number expressed by exponent and fraction with - * first bit (equal to hidden bit) at 62nd bit. - * - * @param exp Exponent part. - * @param fraction Fraction with hidden bit shifted to 62nd bit. - */ -void round_float64(int32_t *exp, uint64_t *fraction) -{ - /* rounding - if first bit after fraction is set then round up */ - (*fraction) += (0x1 << (64 - FLOAT64_FRACTION_SIZE - 3)); - - if ((*fraction) & - (FLOAT64_HIDDEN_BIT_MASK << (64 - FLOAT64_FRACTION_SIZE - 3))) { - /* rounding overflow */ - ++(*exp); - (*fraction) >>= 1; - } - - if (((*exp) >= FLOAT64_MAX_EXPONENT) || ((*exp) < 0)) { - /* overflow - set infinity as result */ - (*exp) = FLOAT64_MAX_EXPONENT; - (*fraction) = 0; - } -} - -/** - * Round and normalize number expressed by exponent and fraction with - * first bit (equal to hidden bit) at 126th bit. - * - * @param exp Exponent part. - * @param frac_hi High part of fraction part with hidden bit shifted to 126th bit. - * @param frac_lo Low part of fraction part with hidden bit shifted to 126th bit. - */ -void round_float128(int32_t *exp, uint64_t *frac_hi, uint64_t *frac_lo) -{ - uint64_t tmp_hi, tmp_lo; - - /* rounding - if first bit after fraction is set then round up */ - lshift128(0x0ll, 0x1ll, (128 - FLOAT128_FRACTION_SIZE - 3), &tmp_hi, &tmp_lo); - add128(*frac_hi, *frac_lo, tmp_hi, tmp_lo, frac_hi, frac_lo); - - lshift128(FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO, - (128 - FLOAT128_FRACTION_SIZE - 3), &tmp_hi, &tmp_lo); - and128(*frac_hi, *frac_lo, tmp_hi, tmp_lo, &tmp_hi, &tmp_lo); - if (lt128(0x0ll, 0x0ll, tmp_hi, tmp_lo)) { - /* rounding overflow */ - ++(*exp); - rshift128(*frac_hi, *frac_lo, 1, frac_hi, frac_lo); - } - - if (((*exp) >= FLOAT128_MAX_EXPONENT) || ((*exp) < 0)) { - /* overflow - set infinity as result */ - (*exp) = FLOAT128_MAX_EXPONENT; - (*frac_hi) = 0; - (*frac_lo) = 0; - } -} - -/** - * Logical shift left on the 128-bit operand. - * - * @param a_hi High part of the input operand. - * @param a_lo Low part of the input operand. - * @param shift Number of bits by witch to shift. - * @param r_hi Address to store high part of the result. - * @param r_lo Address to store low part of the result. - */ -void lshift128( - uint64_t a_hi, uint64_t a_lo, int shift, - uint64_t *r_hi, uint64_t *r_lo) -{ - if (shift <= 0) { - /* do nothing */ - } else if (shift >= 128) { - a_hi = 0; - a_lo = 0; - } else if (shift >= 64) { - a_hi = a_lo << (shift - 64); - a_lo = 0; - } else { - a_hi <<= shift; - a_hi |= a_lo >> (64 - shift); - a_lo <<= shift; - } - - *r_hi = a_hi; - *r_lo = a_lo; -} - -/** - * Logical shift right on the 128-bit operand. - * - * @param a_hi High part of the input operand. - * @param a_lo Low part of the input operand. - * @param shift Number of bits by witch to shift. - * @param r_hi Address to store high part of the result. - * @param r_lo Address to store low part of the result. - */ -void rshift128( - uint64_t a_hi, uint64_t a_lo, int shift, - uint64_t *r_hi, uint64_t *r_lo) -{ - if (shift <= 0) { - /* do nothing */ - } else if (shift >= 128) { - a_hi = 0; - a_lo = 0; - } else if (shift >= 64) { - a_lo = a_hi >> (shift - 64); - a_hi = 0; - } else { - a_lo >>= shift; - a_lo |= a_hi << (64 - shift); - a_hi >>= shift; - } - - *r_hi = a_hi; - *r_lo = a_lo; -} - -/** - * Bitwise AND on 128-bit operands. - * - * @param a_hi High part of the first input operand. - * @param a_lo Low part of the first input operand. - * @param b_hi High part of the second input operand. - * @param b_lo Low part of the second input operand. - * @param r_hi Address to store high part of the result. - * @param r_lo Address to store low part of the result. - */ -void and128( - uint64_t a_hi, uint64_t a_lo, - uint64_t b_hi, uint64_t b_lo, - uint64_t *r_hi, uint64_t *r_lo) -{ - *r_hi = a_hi & b_hi; - *r_lo = a_lo & b_lo; -} - -/** - * Bitwise inclusive OR on 128-bit operands. - * - * @param a_hi High part of the first input operand. - * @param a_lo Low part of the first input operand. - * @param b_hi High part of the second input operand. - * @param b_lo Low part of the second input operand. - * @param r_hi Address to store high part of the result. - * @param r_lo Address to store low part of the result. - */ -void or128( - uint64_t a_hi, uint64_t a_lo, - uint64_t b_hi, uint64_t b_lo, - uint64_t *r_hi, uint64_t *r_lo) -{ - *r_hi = a_hi | b_hi; - *r_lo = a_lo | b_lo; -} - -/** - * Bitwise exclusive OR on 128-bit operands. - * - * @param a_hi High part of the first input operand. - * @param a_lo Low part of the first input operand. - * @param b_hi High part of the second input operand. - * @param b_lo Low part of the second input operand. - * @param r_hi Address to store high part of the result. - * @param r_lo Address to store low part of the result. - */ -void xor128( - uint64_t a_hi, uint64_t a_lo, - uint64_t b_hi, uint64_t b_lo, - uint64_t *r_hi, uint64_t *r_lo) -{ - *r_hi = a_hi ^ b_hi; - *r_lo = a_lo ^ b_lo; -} - -/** - * Bitwise NOT on the 128-bit operand. - * - * @param a_hi High part of the input operand. - * @param a_lo Low part of the input operand. - * @param r_hi Address to store high part of the result. - * @param r_lo Address to store low part of the result. - */ -void not128( - uint64_t a_hi, uint64_t a_lo, - uint64_t *r_hi, uint64_t *r_lo) -{ - *r_hi = ~a_hi; - *r_lo = ~a_lo; -} - -/** - * Equality comparison of 128-bit operands. - * - * @param a_hi High part of the first input operand. - * @param a_lo Low part of the first input operand. - * @param b_hi High part of the second input operand. - * @param b_lo Low part of the second input operand. - * @return 1 if operands are equal, 0 otherwise. - */ -int eq128(uint64_t a_hi, uint64_t a_lo, uint64_t b_hi, uint64_t b_lo) -{ - return (a_hi == b_hi) && (a_lo == b_lo); -} - -/** - * Lower-or-equal comparison of 128-bit operands. - * - * @param a_hi High part of the first input operand. - * @param a_lo Low part of the first input operand. - * @param b_hi High part of the second input operand. - * @param b_lo Low part of the second input operand. - * @return 1 if a is lower or equal to b, 0 otherwise. - */ -int le128(uint64_t a_hi, uint64_t a_lo, uint64_t b_hi, uint64_t b_lo) -{ - return (a_hi < b_hi) || ((a_hi == b_hi) && (a_lo <= b_lo)); -} - -/** - * Lower-than comparison of 128-bit operands. - * - * @param a_hi High part of the first input operand. - * @param a_lo Low part of the first input operand. - * @param b_hi High part of the second input operand. - * @param b_lo Low part of the second input operand. - * @return 1 if a is lower than b, 0 otherwise. - */ -int lt128(uint64_t a_hi, uint64_t a_lo, uint64_t b_hi, uint64_t b_lo) -{ - return (a_hi < b_hi) || ((a_hi == b_hi) && (a_lo < b_lo)); -} - -/** - * Addition of two 128-bit unsigned integers. - * - * @param a_hi High part of the first input operand. - * @param a_lo Low part of the first input operand. - * @param b_hi High part of the second input operand. - * @param b_lo Low part of the second input operand. - * @param r_hi Address to store high part of the result. - * @param r_lo Address to store low part of the result. - */ -void add128(uint64_t a_hi, uint64_t a_lo, - uint64_t b_hi, uint64_t b_lo, - uint64_t *r_hi, uint64_t *r_lo) -{ - uint64_t low = a_lo + b_lo; - *r_lo = low; - /* detect overflow to add a carry */ - *r_hi = a_hi + b_hi + (low < a_lo); -} - -/** - * Substraction of two 128-bit unsigned integers. - * - * @param a_hi High part of the first input operand. - * @param a_lo Low part of the first input operand. - * @param b_hi High part of the second input operand. - * @param b_lo Low part of the second input operand. - * @param r_hi Address to store high part of the result. - * @param r_lo Address to store low part of the result. - */ -void sub128(uint64_t a_hi, uint64_t a_lo, - uint64_t b_hi, uint64_t b_lo, - uint64_t *r_hi, uint64_t *r_lo) -{ - *r_lo = a_lo - b_lo; - /* detect underflow to substract a carry */ - *r_hi = a_hi - b_hi - (a_lo < b_lo); -} - -/** - * Multiplication of two 64-bit unsigned integers. - * - * @param a First input operand. - * @param b Second input operand. - * @param r_hi Address to store high part of the result. - * @param r_lo Address to store low part of the result. - */ -void mul64(uint64_t a, uint64_t b, uint64_t *r_hi, uint64_t *r_lo) -{ - uint64_t low, high, middle1, middle2; - uint32_t alow, blow; - - alow = a & 0xFFFFFFFF; - blow = b & 0xFFFFFFFF; - - a >>= 32; - b >>= 32; - - low = ((uint64_t) alow) * blow; - middle1 = a * blow; - middle2 = alow * b; - high = a * b; - - middle1 += middle2; - high += (((uint64_t) (middle1 < middle2)) << 32) + (middle1 >> 32); - middle1 <<= 32; - low += middle1; - high += (low < middle1); - *r_lo = low; - *r_hi = high; -} - -/** - * Multiplication of two 128-bit unsigned integers. - * - * @param a_hi High part of the first input operand. - * @param a_lo Low part of the first input operand. - * @param b_hi High part of the second input operand. - * @param b_lo Low part of the second input operand. - * @param r_hihi Address to store first (highest) quarter of the result. - * @param r_hilo Address to store second quarter of the result. - * @param r_lohi Address to store third quarter of the result. - * @param r_lolo Address to store fourth (lowest) quarter of the result. - */ -void mul128(uint64_t a_hi, uint64_t a_lo, uint64_t b_hi, uint64_t b_lo, - uint64_t *r_hihi, uint64_t *r_hilo, uint64_t *r_lohi, uint64_t *r_lolo) -{ - uint64_t hihi, hilo, lohi, lolo; - uint64_t tmp1, tmp2; - - mul64(a_lo, b_lo, &lohi, &lolo); - mul64(a_lo, b_hi, &hilo, &tmp2); - add128(hilo, tmp2, 0x0ll, lohi, &hilo, &lohi); - mul64(a_hi, b_hi, &hihi, &tmp1); - add128(hihi, tmp1, 0x0ll, hilo, &hihi, &hilo); - mul64(a_hi, b_lo, &tmp1, &tmp2); - add128(tmp1, tmp2, 0x0ll, lohi, &tmp1, &lohi); - add128(hihi, hilo, 0x0ll, tmp1, &hihi, &hilo); - - *r_hihi = hihi; - *r_hilo = hilo; - *r_lohi = lohi; - *r_lolo = lolo; -} - -/** - * Estimate the quotient of 128-bit unsigned divident and 64-bit unsigned - * divisor. - * - * @param a_hi High part of the divident. - * @param a_lo Low part of the divident. - * @param b Divisor. - * @return Quotient approximation. - */ -uint64_t div128est(uint64_t a_hi, uint64_t a_lo, uint64_t b) -{ - uint64_t b_hi, b_lo; - uint64_t rem_hi, rem_lo; - uint64_t tmp_hi, tmp_lo; - uint64_t result; - - if (b <= a_hi) { - return 0xFFFFFFFFFFFFFFFFull; - } - - b_hi = b >> 32; - result = ((b_hi << 32) <= a_hi) ? (0xFFFFFFFFull << 32) : (a_hi / b_hi) << 32; - mul64(b, result, &tmp_hi, &tmp_lo); - sub128(a_hi, a_lo, tmp_hi, tmp_lo, &rem_hi, &rem_lo); - - while ((int64_t) rem_hi < 0) { - result -= 0x1ll << 32; - b_lo = b << 32; - add128(rem_hi, rem_lo, b_hi, b_lo, &rem_hi, &rem_lo); - } - - rem_hi = (rem_hi << 32) | (rem_lo >> 32); - if ((b_hi << 32) <= rem_hi) { - result |= 0xFFFFFFFF; - } else { - result |= rem_hi / b_hi; - } - - return result; -} - -/** @} - */ Index: uspace/lib/softfloat/generic/comparison.c =================================================================== --- uspace/lib/softfloat/generic/comparison.c (revision 7aa6b99d7bd8a569a8bc3394901a26702aa2a5a9) +++ (revision ) @@ -1,442 +1,0 @@ -/* - * Copyright (c) 2005 Josef Cejka - * Copyright (c) 2011 Petr Koupy - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * - Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR - * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES - * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, - * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF - * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -/** @addtogroup softfloat - * @{ - */ -/** @file Comparison functions. - */ - -#include -#include -#include - -/** - * Determines whether the given float represents NaN (either signalling NaN or - * quiet NaN). - * - * @param f Single-precision float. - * @return 1 if float is NaN, 0 otherwise. - */ -int is_float32_nan(float32 f) -{ - /* NaN : exp = 0xff and nonzero fraction */ - return ((f.parts.exp == 0xFF) && (f.parts.fraction)); -} - -/** - * Determines whether the given float represents NaN (either signalling NaN or - * quiet NaN). - * - * @param d Double-precision float. - * @return 1 if float is NaN, 0 otherwise. - */ -int is_float64_nan(float64 d) -{ - /* NaN : exp = 0x7ff and nonzero fraction */ - return ((d.parts.exp == 0x7FF) && (d.parts.fraction)); -} - -/** - * Determines whether the given float represents NaN (either signalling NaN or - * quiet NaN). - * - * @param ld Quadruple-precision float. - * @return 1 if float is NaN, 0 otherwise. - */ -int is_float128_nan(float128 ld) -{ - /* NaN : exp = 0x7fff and nonzero fraction */ - return ((ld.parts.exp == 0x7FF) && - !eq128(ld.parts.frac_hi, ld.parts.frac_lo, 0x0ll, 0x0ll)); -} - -/** - * Determines whether the given float represents signalling NaN. - * - * @param f Single-precision float. - * @return 1 if float is signalling NaN, 0 otherwise. - */ -int is_float32_signan(float32 f) -{ - /* SigNaN : exp = 0xff and fraction = 0xxxxx..x (binary), - * where at least one x is nonzero */ - return ((f.parts.exp == 0xFF) && - (f.parts.fraction < 0x400000) && (f.parts.fraction)); -} - -/** - * Determines whether the given float represents signalling NaN. - * - * @param d Double-precision float. - * @return 1 if float is signalling NaN, 0 otherwise. - */ -int is_float64_signan(float64 d) -{ - /* SigNaN : exp = 0x7ff and fraction = 0xxxxx..x (binary), - * where at least one x is nonzero */ - return ((d.parts.exp == 0x7FF) && - (d.parts.fraction) && (d.parts.fraction < 0x8000000000000ll)); -} - -/** - * Determines whether the given float represents signalling NaN. - * - * @param ld Quadruple-precision float. - * @return 1 if float is signalling NaN, 0 otherwise. - */ -int is_float128_signan(float128 ld) -{ - /* SigNaN : exp = 0x7fff and fraction = 0xxxxx..x (binary), - * where at least one x is nonzero */ - return ((ld.parts.exp == 0x7FFF) && - (ld.parts.frac_hi || ld.parts.frac_lo) && - lt128(ld.parts.frac_hi, ld.parts.frac_lo, 0x800000000000ll, 0x0ll)); - -} - -/** - * Determines whether the given float represents positive or negative infinity. - * - * @param f Single-precision float. - * @return 1 if float is infinite, 0 otherwise. - */ -int is_float32_infinity(float32 f) -{ - /* NaN : exp = 0x7ff and zero fraction */ - return ((f.parts.exp == 0xFF) && (f.parts.fraction == 0x0)); -} - -/** - * Determines whether the given float represents positive or negative infinity. - * - * @param d Double-precision float. - * @return 1 if float is infinite, 0 otherwise. - */ -int is_float64_infinity(float64 d) -{ - /* NaN : exp = 0x7ff and zero fraction */ - return ((d.parts.exp == 0x7FF) && (d.parts.fraction == 0x0)); -} - -/** - * Determines whether the given float represents positive or negative infinity. - * - * @param ld Quadruple-precision float. - * @return 1 if float is infinite, 0 otherwise. - */ -int is_float128_infinity(float128 ld) -{ - /* NaN : exp = 0x7fff and zero fraction */ - return ((ld.parts.exp == 0x7FFF) && - eq128(ld.parts.frac_hi, ld.parts.frac_lo, 0x0ll, 0x0ll)); -} - -/** - * Determines whether the given float represents positive or negative zero. - * - * @param f Single-precision float. - * @return 1 if float is zero, 0 otherwise. - */ -int is_float32_zero(float32 f) -{ - return (((f.bin) & 0x7FFFFFFF) == 0); -} - -/** - * Determines whether the given float represents positive or negative zero. - * - * @param d Double-precision float. - * @return 1 if float is zero, 0 otherwise. - */ -int is_float64_zero(float64 d) -{ - return (((d.bin) & 0x7FFFFFFFFFFFFFFFll) == 0); -} - -/** - * Determines whether the given float represents positive or negative zero. - * - * @param ld Quadruple-precision float. - * @return 1 if float is zero, 0 otherwise. - */ -int is_float128_zero(float128 ld) -{ - uint64_t tmp_hi; - uint64_t tmp_lo; - - and128(ld.bin.hi, ld.bin.lo, - 0x7FFFFFFFFFFFFFFFll, 0xFFFFFFFFFFFFFFFFll, &tmp_hi, &tmp_lo); - - return eq128(tmp_hi, tmp_lo, 0x0ll, 0x0ll); -} - -/** - * Determine whether two floats are equal. NaNs are not recognized. - * - * @a First single-precision operand. - * @b Second single-precision operand. - * @return 1 if both floats are equal, 0 otherwise. - */ -int is_float32_eq(float32 a, float32 b) -{ - /* a equals to b or both are zeros (with any sign) */ - return ((a.bin == b.bin) || - (((a.bin | b.bin) & 0x7FFFFFFF) == 0)); -} - -/** - * Determine whether two floats are equal. NaNs are not recognized. - * - * @a First double-precision operand. - * @b Second double-precision operand. - * @return 1 if both floats are equal, 0 otherwise. - */ -int is_float64_eq(float64 a, float64 b) -{ - /* a equals to b or both are zeros (with any sign) */ - return ((a.bin == b.bin) || - (((a.bin | b.bin) & 0x7FFFFFFFFFFFFFFFll) == 0)); -} - -/** - * Determine whether two floats are equal. NaNs are not recognized. - * - * @a First quadruple-precision operand. - * @b Second quadruple-precision operand. - * @return 1 if both floats are equal, 0 otherwise. - */ -int is_float128_eq(float128 a, float128 b) -{ - uint64_t tmp_hi; - uint64_t tmp_lo; - - /* both are zeros (with any sign) */ - or128(a.bin.hi, a.bin.lo, - b.bin.hi, b.bin.lo, &tmp_hi, &tmp_lo); - and128(tmp_hi, tmp_lo, - 0x7FFFFFFFFFFFFFFFll, 0xFFFFFFFFFFFFFFFFll, &tmp_hi, &tmp_lo); - int both_zero = eq128(tmp_hi, tmp_lo, 0x0ll, 0x0ll); - - /* a equals to b */ - int are_equal = eq128(a.bin.hi, a.bin.lo, b.bin.hi, b.bin.lo); - - return are_equal || both_zero; -} - -/** - * Lower-than comparison between two floats. NaNs are not recognized. - * - * @a First single-precision operand. - * @b Second single-precision operand. - * @return 1 if a is lower than b, 0 otherwise. - */ -int is_float32_lt(float32 a, float32 b) -{ - if (((a.bin | b.bin) & 0x7FFFFFFF) == 0) { - /* +- zeroes */ - return 0; - } - - if ((a.parts.sign) && (b.parts.sign)) { - /* if both are negative, smaller is that with greater binary value */ - return (a.bin > b.bin); - } - - /* - * lets negate signs - now will be positive numbers always - * bigger than negative (first bit will be set for unsigned - * integer comparison) - */ - a.parts.sign = !a.parts.sign; - b.parts.sign = !b.parts.sign; - return (a.bin < b.bin); -} - -/** - * Lower-than comparison between two floats. NaNs are not recognized. - * - * @a First double-precision operand. - * @b Second double-precision operand. - * @return 1 if a is lower than b, 0 otherwise. - */ -int is_float64_lt(float64 a, float64 b) -{ - if (((a.bin | b.bin) & 0x7FFFFFFFFFFFFFFFll) == 0) { - /* +- zeroes */ - return 0; - } - - if ((a.parts.sign) && (b.parts.sign)) { - /* if both are negative, smaller is that with greater binary value */ - return (a.bin > b.bin); - } - - /* - * lets negate signs - now will be positive numbers always - * bigger than negative (first bit will be set for unsigned - * integer comparison) - */ - a.parts.sign = !a.parts.sign; - b.parts.sign = !b.parts.sign; - return (a.bin < b.bin); -} - -/** - * Lower-than comparison between two floats. NaNs are not recognized. - * - * @a First quadruple-precision operand. - * @b Second quadruple-precision operand. - * @return 1 if a is lower than b, 0 otherwise. - */ -int is_float128_lt(float128 a, float128 b) -{ - uint64_t tmp_hi; - uint64_t tmp_lo; - - or128(a.bin.hi, a.bin.lo, - b.bin.hi, b.bin.lo, &tmp_hi, &tmp_lo); - and128(tmp_hi, tmp_lo, - 0x7FFFFFFFFFFFFFFFll, 0xFFFFFFFFFFFFFFFFll, &tmp_hi, &tmp_lo); - if (eq128(tmp_hi, tmp_lo, 0x0ll, 0x0ll)) { - /* +- zeroes */ - return 0; - } - - if ((a.parts.sign) && (b.parts.sign)) { - /* if both are negative, smaller is that with greater binary value */ - return lt128(b.bin.hi, b.bin.lo, a.bin.hi, a.bin.lo); - } - - /* - * lets negate signs - now will be positive numbers always - * bigger than negative (first bit will be set for unsigned - * integer comparison) - */ - a.parts.sign = !a.parts.sign; - b.parts.sign = !b.parts.sign; - return lt128(a.bin.hi, a.bin.lo, b.bin.hi, b.bin.lo); -} - -/** - * Greater-than comparison between two floats. NaNs are not recognized. - * - * @a First single-precision operand. - * @b Second single-precision operand. - * @return 1 if a is greater than b, 0 otherwise. - */ -int is_float32_gt(float32 a, float32 b) -{ - if (((a.bin | b.bin) & 0x7FFFFFFF) == 0) { - /* zeroes are equal with any sign */ - return 0; - } - - if ((a.parts.sign) && (b.parts.sign)) { - /* if both are negative, greater is that with smaller binary value */ - return (a.bin < b.bin); - } - - /* - * lets negate signs - now will be positive numbers always - * bigger than negative (first bit will be set for unsigned - * integer comparison) - */ - a.parts.sign = !a.parts.sign; - b.parts.sign = !b.parts.sign; - return (a.bin > b.bin); -} - -/** - * Greater-than comparison between two floats. NaNs are not recognized. - * - * @a First double-precision operand. - * @b Second double-precision operand. - * @return 1 if a is greater than b, 0 otherwise. - */ -int is_float64_gt(float64 a, float64 b) -{ - if (((a.bin | b.bin) & 0x7FFFFFFFFFFFFFFFll) == 0) { - /* zeroes are equal with any sign */ - return 0; - } - - if ((a.parts.sign) && (b.parts.sign)) { - /* if both are negative, greater is that with smaller binary value */ - return (a.bin < b.bin); - } - - /* - * lets negate signs - now will be positive numbers always - * bigger than negative (first bit will be set for unsigned - * integer comparison) - */ - a.parts.sign = !a.parts.sign; - b.parts.sign = !b.parts.sign; - return (a.bin > b.bin); -} - -/** - * Greater-than comparison between two floats. NaNs are not recognized. - * - * @a First quadruple-precision operand. - * @b Second quadruple-precision operand. - * @return 1 if a is greater than b, 0 otherwise. - */ -int is_float128_gt(float128 a, float128 b) -{ - uint64_t tmp_hi; - uint64_t tmp_lo; - - or128(a.bin.hi, a.bin.lo, - b.bin.hi, b.bin.lo, &tmp_hi, &tmp_lo); - and128(tmp_hi, tmp_lo, - 0x7FFFFFFFFFFFFFFFll, 0xFFFFFFFFFFFFFFFFll, &tmp_hi, &tmp_lo); - if (eq128(tmp_hi, tmp_lo, 0x0ll, 0x0ll)) { - /* zeroes are equal with any sign */ - return 0; - } - - if ((a.parts.sign) && (b.parts.sign)) { - /* if both are negative, greater is that with smaller binary value */ - return lt128(a.bin.hi, a.bin.lo, b.bin.hi, b.bin.lo); - } - - /* - * lets negate signs - now will be positive numbers always - * bigger than negative (first bit will be set for unsigned - * integer comparison) - */ - a.parts.sign = !a.parts.sign; - b.parts.sign = !b.parts.sign; - return lt128(b.bin.hi, b.bin.lo, a.bin.hi, a.bin.lo); -} - -/** @} - */ Index: uspace/lib/softfloat/generic/conversion.c =================================================================== --- uspace/lib/softfloat/generic/conversion.c (revision 7aa6b99d7bd8a569a8bc3394901a26702aa2a5a9) +++ (revision ) @@ -1,1041 +1,0 @@ -/* - * Copyright (c) 2005 Josef Cejka - * Copyright (c) 2011 Petr Koupy - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * - Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR - * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES - * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, - * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF - * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -/** @addtogroup softfloat - * @{ - */ -/** @file Conversion of precision and conversion between integers and floats. - */ - -#include -#include -#include -#include - -float64 float32_to_float64(float32 a) -{ - float64 result; - uint64_t frac; - - result.parts.sign = a.parts.sign; - result.parts.fraction = a.parts.fraction; - result.parts.fraction <<= (FLOAT64_FRACTION_SIZE - FLOAT32_FRACTION_SIZE); - - if ((is_float32_infinity(a)) || (is_float32_nan(a))) { - result.parts.exp = FLOAT64_MAX_EXPONENT; - // TODO; check if its correct for SigNaNs - return result; - } - - result.parts.exp = a.parts.exp + ((int) FLOAT64_BIAS - FLOAT32_BIAS); - if (a.parts.exp == 0) { - /* normalize denormalized numbers */ - - if (result.parts.fraction == 0) { /* fix zero */ - result.parts.exp = 0; - return result; - } - - frac = result.parts.fraction; - - while (!(frac & FLOAT64_HIDDEN_BIT_MASK)) { - frac <<= 1; - --result.parts.exp; - } - - ++result.parts.exp; - result.parts.fraction = frac; - } - - return result; -} - -float128 float32_to_float128(float32 a) -{ - float128 result; - uint64_t frac_hi, frac_lo; - uint64_t tmp_hi, tmp_lo; - - result.parts.sign = a.parts.sign; - result.parts.frac_hi = 0; - result.parts.frac_lo = a.parts.fraction; - lshift128(result.parts.frac_hi, result.parts.frac_lo, - (FLOAT128_FRACTION_SIZE - FLOAT32_FRACTION_SIZE), - &frac_hi, &frac_lo); - result.parts.frac_hi = frac_hi; - result.parts.frac_lo = frac_lo; - - if ((is_float32_infinity(a)) || (is_float32_nan(a))) { - result.parts.exp = FLOAT128_MAX_EXPONENT; - // TODO; check if its correct for SigNaNs - return result; - } - - result.parts.exp = a.parts.exp + ((int) FLOAT128_BIAS - FLOAT32_BIAS); - if (a.parts.exp == 0) { - /* normalize denormalized numbers */ - - if (eq128(result.parts.frac_hi, - result.parts.frac_lo, 0x0ll, 0x0ll)) { /* fix zero */ - result.parts.exp = 0; - return result; - } - - frac_hi = result.parts.frac_hi; - frac_lo = result.parts.frac_lo; - - and128(frac_hi, frac_lo, - FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO, - &tmp_hi, &tmp_lo); - while (!lt128(0x0ll, 0x0ll, tmp_hi, tmp_lo)) { - lshift128(frac_hi, frac_lo, 1, &frac_hi, &frac_lo); - --result.parts.exp; - } - - ++result.parts.exp; - result.parts.frac_hi = frac_hi; - result.parts.frac_lo = frac_lo; - } - - return result; -} - -float128 float64_to_float128(float64 a) -{ - float128 result; - uint64_t frac_hi, frac_lo; - uint64_t tmp_hi, tmp_lo; - - result.parts.sign = a.parts.sign; - result.parts.frac_hi = 0; - result.parts.frac_lo = a.parts.fraction; - lshift128(result.parts.frac_hi, result.parts.frac_lo, - (FLOAT128_FRACTION_SIZE - FLOAT64_FRACTION_SIZE), - &frac_hi, &frac_lo); - result.parts.frac_hi = frac_hi; - result.parts.frac_lo = frac_lo; - - if ((is_float64_infinity(a)) || (is_float64_nan(a))) { - result.parts.exp = FLOAT128_MAX_EXPONENT; - // TODO; check if its correct for SigNaNs - return result; - } - - result.parts.exp = a.parts.exp + ((int) FLOAT128_BIAS - FLOAT64_BIAS); - if (a.parts.exp == 0) { - /* normalize denormalized numbers */ - - if (eq128(result.parts.frac_hi, - result.parts.frac_lo, 0x0ll, 0x0ll)) { /* fix zero */ - result.parts.exp = 0; - return result; - } - - frac_hi = result.parts.frac_hi; - frac_lo = result.parts.frac_lo; - - and128(frac_hi, frac_lo, - FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO, - &tmp_hi, &tmp_lo); - while (!lt128(0x0ll, 0x0ll, tmp_hi, tmp_lo)) { - lshift128(frac_hi, frac_lo, 1, &frac_hi, &frac_lo); - --result.parts.exp; - } - - ++result.parts.exp; - result.parts.frac_hi = frac_hi; - result.parts.frac_lo = frac_lo; - } - - return result; -} - -float32 float64_to_float32(float64 a) -{ - float32 result; - int32_t exp; - uint64_t frac; - - result.parts.sign = a.parts.sign; - - if (is_float64_nan(a)) { - result.parts.exp = FLOAT32_MAX_EXPONENT; - - if (is_float64_signan(a)) { - /* set first bit of fraction nonzero */ - result.parts.fraction = FLOAT32_HIDDEN_BIT_MASK >> 1; - return result; - } - - /* fraction nonzero but its first bit is zero */ - result.parts.fraction = 0x1; - return result; - } - - if (is_float64_infinity(a)) { - result.parts.fraction = 0; - result.parts.exp = FLOAT32_MAX_EXPONENT; - return result; - } - - exp = (int) a.parts.exp - FLOAT64_BIAS + FLOAT32_BIAS; - - if (exp >= FLOAT32_MAX_EXPONENT) { - /* FIXME: overflow */ - result.parts.fraction = 0; - result.parts.exp = FLOAT32_MAX_EXPONENT; - return result; - } else if (exp <= 0) { - /* underflow or denormalized */ - - result.parts.exp = 0; - - exp *= -1; - if (exp > FLOAT32_FRACTION_SIZE) { - /* FIXME: underflow */ - result.parts.fraction = 0; - return result; - } - - /* denormalized */ - - frac = a.parts.fraction; - frac |= FLOAT64_HIDDEN_BIT_MASK; /* denormalize and set hidden bit */ - - frac >>= (FLOAT64_FRACTION_SIZE - FLOAT32_FRACTION_SIZE + 1); - - while (exp > 0) { - --exp; - frac >>= 1; - } - result.parts.fraction = frac; - - return result; - } - - result.parts.exp = exp; - result.parts.fraction = - a.parts.fraction >> (FLOAT64_FRACTION_SIZE - FLOAT32_FRACTION_SIZE); - return result; -} - -float32 float128_to_float32(float128 a) -{ - float32 result; - int32_t exp; - uint64_t frac_hi, frac_lo; - - result.parts.sign = a.parts.sign; - - if (is_float128_nan(a)) { - result.parts.exp = FLOAT32_MAX_EXPONENT; - - if (is_float128_signan(a)) { - /* set first bit of fraction nonzero */ - result.parts.fraction = FLOAT32_HIDDEN_BIT_MASK >> 1; - return result; - } - - /* fraction nonzero but its first bit is zero */ - result.parts.fraction = 0x1; - return result; - } - - if (is_float128_infinity(a)) { - result.parts.fraction = 0; - result.parts.exp = FLOAT32_MAX_EXPONENT; - return result; - } - - exp = (int) a.parts.exp - FLOAT128_BIAS + FLOAT32_BIAS; - - if (exp >= FLOAT32_MAX_EXPONENT) { - /* FIXME: overflow */ - result.parts.fraction = 0; - result.parts.exp = FLOAT32_MAX_EXPONENT; - return result; - } else if (exp <= 0) { - /* underflow or denormalized */ - - result.parts.exp = 0; - - exp *= -1; - if (exp > FLOAT32_FRACTION_SIZE) { - /* FIXME: underflow */ - result.parts.fraction = 0; - return result; - } - - /* denormalized */ - - frac_hi = a.parts.frac_hi; - frac_lo = a.parts.frac_lo; - - /* denormalize and set hidden bit */ - frac_hi |= FLOAT128_HIDDEN_BIT_MASK_HI; - - rshift128(frac_hi, frac_lo, - (FLOAT128_FRACTION_SIZE - FLOAT32_FRACTION_SIZE + 1), - &frac_hi, &frac_lo); - - while (exp > 0) { - --exp; - rshift128(frac_hi, frac_lo, 1, &frac_hi, &frac_lo); - } - result.parts.fraction = frac_lo; - - return result; - } - - result.parts.exp = exp; - frac_hi = a.parts.frac_hi; - frac_lo = a.parts.frac_lo; - rshift128(frac_hi, frac_lo, - (FLOAT128_FRACTION_SIZE - FLOAT32_FRACTION_SIZE + 1), - &frac_hi, &frac_lo); - result.parts.fraction = frac_lo; - return result; -} - -float64 float128_to_float64(float128 a) -{ - float64 result; - int32_t exp; - uint64_t frac_hi, frac_lo; - - result.parts.sign = a.parts.sign; - - if (is_float128_nan(a)) { - result.parts.exp = FLOAT64_MAX_EXPONENT; - - if (is_float128_signan(a)) { - /* set first bit of fraction nonzero */ - result.parts.fraction = FLOAT64_HIDDEN_BIT_MASK >> 1; - return result; - } - - /* fraction nonzero but its first bit is zero */ - result.parts.fraction = 0x1; - return result; - } - - if (is_float128_infinity(a)) { - result.parts.fraction = 0; - result.parts.exp = FLOAT64_MAX_EXPONENT; - return result; - } - - exp = (int) a.parts.exp - FLOAT128_BIAS + FLOAT64_BIAS; - - if (exp >= FLOAT64_MAX_EXPONENT) { - /* FIXME: overflow */ - result.parts.fraction = 0; - result.parts.exp = FLOAT64_MAX_EXPONENT; - return result; - } else if (exp <= 0) { - /* underflow or denormalized */ - - result.parts.exp = 0; - - exp *= -1; - if (exp > FLOAT64_FRACTION_SIZE) { - /* FIXME: underflow */ - result.parts.fraction = 0; - return result; - } - - /* denormalized */ - - frac_hi = a.parts.frac_hi; - frac_lo = a.parts.frac_lo; - - /* denormalize and set hidden bit */ - frac_hi |= FLOAT128_HIDDEN_BIT_MASK_HI; - - rshift128(frac_hi, frac_lo, - (FLOAT128_FRACTION_SIZE - FLOAT64_FRACTION_SIZE + 1), - &frac_hi, &frac_lo); - - while (exp > 0) { - --exp; - rshift128(frac_hi, frac_lo, 1, &frac_hi, &frac_lo); - } - result.parts.fraction = frac_lo; - - return result; - } - - result.parts.exp = exp; - frac_hi = a.parts.frac_hi; - frac_lo = a.parts.frac_lo; - rshift128(frac_hi, frac_lo, - (FLOAT128_FRACTION_SIZE - FLOAT64_FRACTION_SIZE + 1), - &frac_hi, &frac_lo); - result.parts.fraction = frac_lo; - return result; -} - -/** Helper procedure for converting float32 to uint32. - * - * @param a Floating point number in normalized form - * (NaNs or Inf are not checked). - * @return Converted unsigned integer. - */ -static uint32_t _float32_to_uint32_helper(float32 a) -{ - uint32_t frac; - - if (a.parts.exp < FLOAT32_BIAS) { - /* TODO: rounding */ - return 0; - } - - frac = a.parts.fraction; - - frac |= FLOAT32_HIDDEN_BIT_MASK; - /* shift fraction to left so hidden bit will be the most significant bit */ - frac <<= 32 - FLOAT32_FRACTION_SIZE - 1; - - frac >>= 32 - (a.parts.exp - FLOAT32_BIAS) - 1; - if ((a.parts.sign == 1) && (frac != 0)) { - frac = ~frac; - ++frac; - } - - return frac; -} - -/* - * FIXME: Im not sure what to return if overflow/underflow happens - * - now its the biggest or the smallest int - */ -uint32_t float32_to_uint32(float32 a) -{ - if (is_float32_nan(a)) - return UINT32_MAX; - - if (is_float32_infinity(a) || (a.parts.exp >= (32 + FLOAT32_BIAS))) { - if (a.parts.sign) - return UINT32_MIN; - - return UINT32_MAX; - } - - return _float32_to_uint32_helper(a); -} - -/* - * FIXME: Im not sure what to return if overflow/underflow happens - * - now its the biggest or the smallest int - */ -int32_t float32_to_int32(float32 a) -{ - if (is_float32_nan(a)) - return INT32_MAX; - - if (is_float32_infinity(a) || (a.parts.exp >= (32 + FLOAT32_BIAS))) { - if (a.parts.sign) - return INT32_MIN; - - return INT32_MAX; - } - - return _float32_to_uint32_helper(a); -} - -/** Helper procedure for converting float32 to uint64. - * - * @param a Floating point number in normalized form - * (NaNs or Inf are not checked). - * @return Converted unsigned integer. - */ -static uint64_t _float32_to_uint64_helper(float32 a) -{ - uint64_t frac; - - if (a.parts.exp < FLOAT32_BIAS) { - // TODO: rounding - return 0; - } - - frac = a.parts.fraction; - - frac |= FLOAT32_HIDDEN_BIT_MASK; - /* shift fraction to left so hidden bit will be the most significant bit */ - frac <<= 64 - FLOAT32_FRACTION_SIZE - 1; - - frac >>= 64 - (a.parts.exp - FLOAT32_BIAS) - 1; - if ((a.parts.sign == 1) && (frac != 0)) { - frac = ~frac; - ++frac; - } - - return frac; -} - -/* - * FIXME: Im not sure what to return if overflow/underflow happens - * - now its the biggest or the smallest int - */ -uint64_t float32_to_uint64(float32 a) -{ - if (is_float32_nan(a)) - return UINT64_MAX; - - if (is_float32_infinity(a) || (a.parts.exp >= (64 + FLOAT32_BIAS))) { - if (a.parts.sign) - return UINT64_MIN; - - return UINT64_MAX; - } - - return _float32_to_uint64_helper(a); -} - -/* - * FIXME: Im not sure what to return if overflow/underflow happens - * - now its the biggest or the smallest int - */ -int64_t float32_to_int64(float32 a) -{ - if (is_float32_nan(a)) - return INT64_MAX; - - if (is_float32_infinity(a) || (a.parts.exp >= (64 + FLOAT32_BIAS))) { - if (a.parts.sign) - return INT64_MIN; - - return INT64_MAX; - } - - return _float32_to_uint64_helper(a); -} - -/** Helper procedure for converting float64 to uint64. - * - * @param a Floating point number in normalized form - * (NaNs or Inf are not checked). - * @return Converted unsigned integer. - */ -static uint64_t _float64_to_uint64_helper(float64 a) -{ - uint64_t frac; - - if (a.parts.exp < FLOAT64_BIAS) { - // TODO: rounding - return 0; - } - - frac = a.parts.fraction; - - frac |= FLOAT64_HIDDEN_BIT_MASK; - /* shift fraction to left so hidden bit will be the most significant bit */ - frac <<= 64 - FLOAT64_FRACTION_SIZE - 1; - - frac >>= 64 - (a.parts.exp - FLOAT64_BIAS) - 1; - if ((a.parts.sign == 1) && (frac != 0)) { - frac = ~frac; - ++frac; - } - - return frac; -} - -/* - * FIXME: Im not sure what to return if overflow/underflow happens - * - now its the biggest or the smallest int - */ -uint32_t float64_to_uint32(float64 a) -{ - if (is_float64_nan(a)) - return UINT32_MAX; - - if (is_float64_infinity(a) || (a.parts.exp >= (32 + FLOAT64_BIAS))) { - if (a.parts.sign) - return UINT32_MIN; - - return UINT32_MAX; - } - - return (uint32_t) _float64_to_uint64_helper(a); -} - -/* - * FIXME: Im not sure what to return if overflow/underflow happens - * - now its the biggest or the smallest int - */ -int32_t float64_to_int32(float64 a) -{ - if (is_float64_nan(a)) - return INT32_MAX; - - if (is_float64_infinity(a) || (a.parts.exp >= (32 + FLOAT64_BIAS))) { - if (a.parts.sign) - return INT32_MIN; - - return INT32_MAX; - } - - return (int32_t) _float64_to_uint64_helper(a); -} - -/* - * FIXME: Im not sure what to return if overflow/underflow happens - * - now its the biggest or the smallest int - */ -uint64_t float64_to_uint64(float64 a) -{ - if (is_float64_nan(a)) - return UINT64_MAX; - - if (is_float64_infinity(a) || (a.parts.exp >= (64 + FLOAT64_BIAS))) { - if (a.parts.sign) - return UINT64_MIN; - - return UINT64_MAX; - } - - return _float64_to_uint64_helper(a); -} - -/* - * FIXME: Im not sure what to return if overflow/underflow happens - * - now its the biggest or the smallest int - */ -int64_t float64_to_int64(float64 a) -{ - if (is_float64_nan(a)) - return INT64_MAX; - - if (is_float64_infinity(a) || (a.parts.exp >= (64 + FLOAT64_BIAS))) { - if (a.parts.sign) - return INT64_MIN; - - return INT64_MAX; - } - - return _float64_to_uint64_helper(a); -} - -/** Helper procedure for converting float128 to uint64. - * - * @param a Floating point number in normalized form - * (NaNs or Inf are not checked). - * @return Converted unsigned integer. - */ -static uint64_t _float128_to_uint64_helper(float128 a) -{ - uint64_t frac_hi, frac_lo; - - if (a.parts.exp < FLOAT128_BIAS) { - // TODO: rounding - return 0; - } - - frac_hi = a.parts.frac_hi; - frac_lo = a.parts.frac_lo; - - frac_hi |= FLOAT128_HIDDEN_BIT_MASK_HI; - /* shift fraction to left so hidden bit will be the most significant bit */ - lshift128(frac_hi, frac_lo, - (128 - FLOAT128_FRACTION_SIZE - 1), &frac_hi, &frac_lo); - - rshift128(frac_hi, frac_lo, - (128 - (a.parts.exp - FLOAT128_BIAS) - 1), &frac_hi, &frac_lo); - if ((a.parts.sign == 1) && !eq128(frac_hi, frac_lo, 0x0ll, 0x0ll)) { - not128(frac_hi, frac_lo, &frac_hi, &frac_lo); - add128(frac_hi, frac_lo, 0x0ll, 0x1ll, &frac_hi, &frac_lo); - } - - return frac_lo; -} - -/* - * FIXME: Im not sure what to return if overflow/underflow happens - * - now its the biggest or the smallest int - */ -uint32_t float128_to_uint32(float128 a) -{ - if (is_float128_nan(a)) - return UINT32_MAX; - - if (is_float128_infinity(a) || (a.parts.exp >= (32 + FLOAT128_BIAS))) { - if (a.parts.sign) - return UINT32_MIN; - - return UINT32_MAX; - } - - return (uint32_t) _float128_to_uint64_helper(a); -} - -/* - * FIXME: Im not sure what to return if overflow/underflow happens - * - now its the biggest or the smallest int - */ -int32_t float128_to_int32(float128 a) -{ - if (is_float128_nan(a)) - return INT32_MAX; - - if (is_float128_infinity(a) || (a.parts.exp >= (32 + FLOAT128_BIAS))) { - if (a.parts.sign) - return INT32_MIN; - - return INT32_MAX; - } - - return (int32_t) _float128_to_uint64_helper(a); -} - -/* - * FIXME: Im not sure what to return if overflow/underflow happens - * - now its the biggest or the smallest int - */ -uint64_t float128_to_uint64(float128 a) -{ - if (is_float128_nan(a)) - return UINT64_MAX; - - if (is_float128_infinity(a) || (a.parts.exp >= (64 + FLOAT128_BIAS))) { - if (a.parts.sign) - return UINT64_MIN; - - return UINT64_MAX; - } - - return _float128_to_uint64_helper(a); -} - -/* - * FIXME: Im not sure what to return if overflow/underflow happens - * - now its the biggest or the smallest int - */ -int64_t float128_to_int64(float128 a) -{ - if (is_float128_nan(a)) - return INT64_MAX; - - if (is_float128_infinity(a) || (a.parts.exp >= (64 + FLOAT128_BIAS))) { - if (a.parts.sign) - return INT64_MIN; - - return INT64_MAX; - } - - return _float128_to_uint64_helper(a); -} - -float32 uint32_to_float32(uint32_t i) -{ - int counter; - int32_t exp; - float32 result; - - result.parts.sign = 0; - result.parts.fraction = 0; - - counter = count_zeroes32(i); - - exp = FLOAT32_BIAS + 32 - counter - 1; - - if (counter == 32) { - result.bin = 0; - return result; - } - - if (counter > 0) { - i <<= counter - 1; - } else { - i >>= 1; - } - - round_float32(&exp, &i); - - result.parts.fraction = i >> (32 - FLOAT32_FRACTION_SIZE - 2); - result.parts.exp = exp; - - return result; -} - -float32 int32_to_float32(int32_t i) -{ - float32 result; - - if (i < 0) - result = uint32_to_float32((uint32_t) (-i)); - else - result = uint32_to_float32((uint32_t) i); - - result.parts.sign = i < 0; - - return result; -} - -float32 uint64_to_float32(uint64_t i) -{ - int counter; - int32_t exp; - uint32_t j; - float32 result; - - result.parts.sign = 0; - result.parts.fraction = 0; - - counter = count_zeroes64(i); - - exp = FLOAT32_BIAS + 64 - counter - 1; - - if (counter == 64) { - result.bin = 0; - return result; - } - - /* Shift all to the first 31 bits (31st will be hidden 1) */ - if (counter > 33) { - i <<= counter - 1 - 32; - } else { - i >>= 1 + 32 - counter; - } - - j = (uint32_t) i; - round_float32(&exp, &j); - - result.parts.fraction = j >> (32 - FLOAT32_FRACTION_SIZE - 2); - result.parts.exp = exp; - return result; -} - -float32 int64_to_float32(int64_t i) -{ - float32 result; - - if (i < 0) - result = uint64_to_float32((uint64_t) (-i)); - else - result = uint64_to_float32((uint64_t) i); - - result.parts.sign = i < 0; - - return result; -} - -float64 uint32_to_float64(uint32_t i) -{ - int counter; - int32_t exp; - float64 result; - uint64_t frac; - - result.parts.sign = 0; - result.parts.fraction = 0; - - counter = count_zeroes32(i); - - exp = FLOAT64_BIAS + 32 - counter - 1; - - if (counter == 32) { - result.bin = 0; - return result; - } - - frac = i; - frac <<= counter + 32 - 1; - - round_float64(&exp, &frac); - - result.parts.fraction = frac >> (64 - FLOAT64_FRACTION_SIZE - 2); - result.parts.exp = exp; - - return result; -} - -float64 int32_to_float64(int32_t i) -{ - float64 result; - - if (i < 0) - result = uint32_to_float64((uint32_t) (-i)); - else - result = uint32_to_float64((uint32_t) i); - - result.parts.sign = i < 0; - - return result; -} - - -float64 uint64_to_float64(uint64_t i) -{ - int counter; - int32_t exp; - float64 result; - - result.parts.sign = 0; - result.parts.fraction = 0; - - counter = count_zeroes64(i); - - exp = FLOAT64_BIAS + 64 - counter - 1; - - if (counter == 64) { - result.bin = 0; - return result; - } - - if (counter > 0) { - i <<= counter - 1; - } else { - i >>= 1; - } - - round_float64(&exp, &i); - - result.parts.fraction = i >> (64 - FLOAT64_FRACTION_SIZE - 2); - result.parts.exp = exp; - return result; -} - -float64 int64_to_float64(int64_t i) -{ - float64 result; - - if (i < 0) - result = uint64_to_float64((uint64_t) (-i)); - else - result = uint64_to_float64((uint64_t) i); - - result.parts.sign = i < 0; - - return result; -} - -float128 uint32_to_float128(uint32_t i) -{ - int counter; - int32_t exp; - float128 result; - uint64_t frac_hi, frac_lo; - - result.parts.sign = 0; - result.parts.frac_hi = 0; - result.parts.frac_lo = 0; - - counter = count_zeroes32(i); - - exp = FLOAT128_BIAS + 32 - counter - 1; - - if (counter == 32) { - result.bin.hi = 0; - result.bin.lo = 0; - return result; - } - - frac_hi = 0; - frac_lo = i; - lshift128(frac_hi, frac_lo, (counter + 96 - 1), &frac_hi, &frac_lo); - - round_float128(&exp, &frac_hi, &frac_lo); - - rshift128(frac_hi, frac_lo, - (128 - FLOAT128_FRACTION_SIZE - 2), &frac_hi, &frac_lo); - result.parts.frac_hi = frac_hi; - result.parts.frac_lo = frac_lo; - result.parts.exp = exp; - - return result; -} - -float128 int32_to_float128(int32_t i) -{ - float128 result; - - if (i < 0) - result = uint32_to_float128((uint32_t) (-i)); - else - result = uint32_to_float128((uint32_t) i); - - result.parts.sign = i < 0; - - return result; -} - - -float128 uint64_to_float128(uint64_t i) -{ - int counter; - int32_t exp; - float128 result; - uint64_t frac_hi, frac_lo; - - result.parts.sign = 0; - result.parts.frac_hi = 0; - result.parts.frac_lo = 0; - - counter = count_zeroes64(i); - - exp = FLOAT128_BIAS + 64 - counter - 1; - - if (counter == 64) { - result.bin.hi = 0; - result.bin.lo = 0; - return result; - } - - frac_hi = 0; - frac_lo = i; - lshift128(frac_hi, frac_lo, (counter + 64 - 1), &frac_hi, &frac_lo); - - round_float128(&exp, &frac_hi, &frac_lo); - - rshift128(frac_hi, frac_lo, - (128 - FLOAT128_FRACTION_SIZE - 2), &frac_hi, &frac_lo); - result.parts.frac_hi = frac_hi; - result.parts.frac_lo = frac_lo; - result.parts.exp = exp; - - return result; -} - -float128 int64_to_float128(int64_t i) -{ - float128 result; - - if (i < 0) - result = uint64_to_float128((uint64_t) (-i)); - else - result = uint64_to_float128((uint64_t) i); - - result.parts.sign = i < 0; - - return result; -} - -/** @} - */ Index: uspace/lib/softfloat/generic/div.c =================================================================== --- uspace/lib/softfloat/generic/div.c (revision 7aa6b99d7bd8a569a8bc3394901a26702aa2a5a9) +++ (revision ) @@ -1,542 +1,0 @@ -/* - * Copyright (c) 2005 Josef Cejka - * Copyright (c) 2011 Petr Koupy - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * - Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR - * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES - * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, - * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF - * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -/** @addtogroup softfloat - * @{ - */ -/** @file Division functions. - */ - -#include -#include -#include -#include -#include -#include - -/** Divide two single-precision floats. - * - * @param a Nominator. - * @param b Denominator. - * - * @return Result of division. - * - */ -float32 div_float32(float32 a, float32 b) -{ - float32 result; - int32_t aexp, bexp, cexp; - uint64_t afrac, bfrac, cfrac; - - result.parts.sign = a.parts.sign ^ b.parts.sign; - - if (is_float32_nan(a)) { - if (is_float32_signan(a)) { - // FIXME: SigNaN - } - /* NaN */ - return a; - } - - if (is_float32_nan(b)) { - if (is_float32_signan(b)) { - // FIXME: SigNaN - } - /* NaN */ - return b; - } - - if (is_float32_infinity(a)) { - if (is_float32_infinity(b)) { - /*FIXME: inf / inf */ - result.bin = FLOAT32_NAN; - return result; - } - /* inf / num */ - result.parts.exp = a.parts.exp; - result.parts.fraction = a.parts.fraction; - return result; - } - - if (is_float32_infinity(b)) { - if (is_float32_zero(a)) { - /* FIXME 0 / inf */ - result.parts.exp = 0; - result.parts.fraction = 0; - return result; - } - /* FIXME: num / inf*/ - result.parts.exp = 0; - result.parts.fraction = 0; - return result; - } - - if (is_float32_zero(b)) { - if (is_float32_zero(a)) { - /*FIXME: 0 / 0*/ - result.bin = FLOAT32_NAN; - return result; - } - /* FIXME: division by zero */ - result.parts.exp = 0; - result.parts.fraction = 0; - return result; - } - - afrac = a.parts.fraction; - aexp = a.parts.exp; - bfrac = b.parts.fraction; - bexp = b.parts.exp; - - /* denormalized numbers */ - if (aexp == 0) { - if (afrac == 0) { - result.parts.exp = 0; - result.parts.fraction = 0; - return result; - } - - /* normalize it*/ - afrac <<= 1; - /* afrac is nonzero => it must stop */ - while (!(afrac & FLOAT32_HIDDEN_BIT_MASK)) { - afrac <<= 1; - aexp--; - } - } - - if (bexp == 0) { - bfrac <<= 1; - /* bfrac is nonzero => it must stop */ - while (!(bfrac & FLOAT32_HIDDEN_BIT_MASK)) { - bfrac <<= 1; - bexp--; - } - } - - afrac = (afrac | FLOAT32_HIDDEN_BIT_MASK) << (32 - FLOAT32_FRACTION_SIZE - 1); - bfrac = (bfrac | FLOAT32_HIDDEN_BIT_MASK) << (32 - FLOAT32_FRACTION_SIZE); - - if (bfrac <= (afrac << 1)) { - afrac >>= 1; - aexp++; - } - - cexp = aexp - bexp + FLOAT32_BIAS - 2; - - cfrac = (afrac << 32) / bfrac; - if ((cfrac & 0x3F) == 0) { - cfrac |= (bfrac * cfrac != afrac << 32); - } - - /* pack and round */ - - /* find first nonzero digit and shift result and detect possibly underflow */ - while ((cexp > 0) && (cfrac) && (!(cfrac & (FLOAT32_HIDDEN_BIT_MASK << 7)))) { - cexp--; - cfrac <<= 1; - /* TODO: fix underflow */ - } - - cfrac += (0x1 << 6); /* FIXME: 7 is not sure*/ - - if (cfrac & (FLOAT32_HIDDEN_BIT_MASK << 7)) { - ++cexp; - cfrac >>= 1; - } - - /* check overflow */ - if (cexp >= FLOAT32_MAX_EXPONENT) { - /* FIXME: overflow, return infinity */ - result.parts.exp = FLOAT32_MAX_EXPONENT; - result.parts.fraction = 0; - return result; - } - - if (cexp < 0) { - /* FIXME: underflow */ - result.parts.exp = 0; - if ((cexp + FLOAT32_FRACTION_SIZE) < 0) { - result.parts.fraction = 0; - return result; - } - cfrac >>= 1; - while (cexp < 0) { - cexp++; - cfrac >>= 1; - } - } else { - result.parts.exp = (uint32_t) cexp; - } - - result.parts.fraction = ((cfrac >> 6) & (~FLOAT32_HIDDEN_BIT_MASK)); - - return result; -} - -/** Divide two double-precision floats. - * - * @param a Nominator. - * @param b Denominator. - * - * @return Result of division. - * - */ -float64 div_float64(float64 a, float64 b) -{ - float64 result; - int64_t aexp, bexp, cexp; - uint64_t afrac, bfrac, cfrac; - uint64_t remlo, remhi; - uint64_t tmplo, tmphi; - - result.parts.sign = a.parts.sign ^ b.parts.sign; - - if (is_float64_nan(a)) { - if (is_float64_signan(b)) { - // FIXME: SigNaN - return b; - } - - if (is_float64_signan(a)) { - // FIXME: SigNaN - } - /* NaN */ - return a; - } - - if (is_float64_nan(b)) { - if (is_float64_signan(b)) { - // FIXME: SigNaN - } - /* NaN */ - return b; - } - - if (is_float64_infinity(a)) { - if (is_float64_infinity(b) || is_float64_zero(b)) { - // FIXME: inf / inf - result.bin = FLOAT64_NAN; - return result; - } - /* inf / num */ - result.parts.exp = a.parts.exp; - result.parts.fraction = a.parts.fraction; - return result; - } - - if (is_float64_infinity(b)) { - if (is_float64_zero(a)) { - /* FIXME 0 / inf */ - result.parts.exp = 0; - result.parts.fraction = 0; - return result; - } - /* FIXME: num / inf*/ - result.parts.exp = 0; - result.parts.fraction = 0; - return result; - } - - if (is_float64_zero(b)) { - if (is_float64_zero(a)) { - /*FIXME: 0 / 0*/ - result.bin = FLOAT64_NAN; - return result; - } - /* FIXME: division by zero */ - result.parts.exp = 0; - result.parts.fraction = 0; - return result; - } - - afrac = a.parts.fraction; - aexp = a.parts.exp; - bfrac = b.parts.fraction; - bexp = b.parts.exp; - - /* denormalized numbers */ - if (aexp == 0) { - if (afrac == 0) { - result.parts.exp = 0; - result.parts.fraction = 0; - return result; - } - - /* normalize it*/ - aexp++; - /* afrac is nonzero => it must stop */ - while (!(afrac & FLOAT64_HIDDEN_BIT_MASK)) { - afrac <<= 1; - aexp--; - } - } - - if (bexp == 0) { - bexp++; - /* bfrac is nonzero => it must stop */ - while (!(bfrac & FLOAT64_HIDDEN_BIT_MASK)) { - bfrac <<= 1; - bexp--; - } - } - - afrac = (afrac | FLOAT64_HIDDEN_BIT_MASK) << (64 - FLOAT64_FRACTION_SIZE - 2); - bfrac = (bfrac | FLOAT64_HIDDEN_BIT_MASK) << (64 - FLOAT64_FRACTION_SIZE - 1); - - if (bfrac <= (afrac << 1)) { - afrac >>= 1; - aexp++; - } - - cexp = aexp - bexp + FLOAT64_BIAS - 2; - - cfrac = div128est(afrac, 0x0ll, bfrac); - - if ((cfrac & 0x1FF) <= 2) { - mul64(bfrac, cfrac, &tmphi, &tmplo); - sub128(afrac, 0x0ll, tmphi, tmplo, &remhi, &remlo); - - while ((int64_t) remhi < 0) { - cfrac--; - add128(remhi, remlo, 0x0ll, bfrac, &remhi, &remlo); - } - cfrac |= (remlo != 0); - } - - /* round and shift */ - result = finish_float64(cexp, cfrac, result.parts.sign); - return result; -} - -/** Divide two quadruple-precision floats. - * - * @param a Nominator. - * @param b Denominator. - * - * @return Result of division. - * - */ -float128 div_float128(float128 a, float128 b) -{ - float128 result; - int64_t aexp, bexp, cexp; - uint64_t afrac_hi, afrac_lo, bfrac_hi, bfrac_lo, cfrac_hi, cfrac_lo; - uint64_t shift_out; - uint64_t rem_hihi, rem_hilo, rem_lohi, rem_lolo; - uint64_t tmp_hihi, tmp_hilo, tmp_lohi, tmp_lolo; - - result.parts.sign = a.parts.sign ^ b.parts.sign; - - if (is_float128_nan(a)) { - if (is_float128_signan(b)) { - // FIXME: SigNaN - return b; - } - - if (is_float128_signan(a)) { - // FIXME: SigNaN - } - /* NaN */ - return a; - } - - if (is_float128_nan(b)) { - if (is_float128_signan(b)) { - // FIXME: SigNaN - } - /* NaN */ - return b; - } - - if (is_float128_infinity(a)) { - if (is_float128_infinity(b) || is_float128_zero(b)) { - // FIXME: inf / inf - result.bin.hi = FLOAT128_NAN_HI; - result.bin.lo = FLOAT128_NAN_LO; - return result; - } - /* inf / num */ - result.parts.exp = a.parts.exp; - result.parts.frac_hi = a.parts.frac_hi; - result.parts.frac_lo = a.parts.frac_lo; - return result; - } - - if (is_float128_infinity(b)) { - if (is_float128_zero(a)) { - // FIXME 0 / inf - result.parts.exp = 0; - result.parts.frac_hi = 0; - result.parts.frac_lo = 0; - return result; - } - // FIXME: num / inf - result.parts.exp = 0; - result.parts.frac_hi = 0; - result.parts.frac_lo = 0; - return result; - } - - if (is_float128_zero(b)) { - if (is_float128_zero(a)) { - // FIXME: 0 / 0 - result.bin.hi = FLOAT128_NAN_HI; - result.bin.lo = FLOAT128_NAN_LO; - return result; - } - // FIXME: division by zero - result.parts.exp = 0; - result.parts.frac_hi = 0; - result.parts.frac_lo = 0; - return result; - } - - afrac_hi = a.parts.frac_hi; - afrac_lo = a.parts.frac_lo; - aexp = a.parts.exp; - bfrac_hi = b.parts.frac_hi; - bfrac_lo = b.parts.frac_lo; - bexp = b.parts.exp; - - /* denormalized numbers */ - if (aexp == 0) { - if (eq128(afrac_hi, afrac_lo, 0x0ll, 0x0ll)) { - result.parts.exp = 0; - result.parts.frac_hi = 0; - result.parts.frac_lo = 0; - return result; - } - - /* normalize it*/ - aexp++; - /* afrac is nonzero => it must stop */ - and128(afrac_hi, afrac_lo, - FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO, - &tmp_hihi, &tmp_lolo); - while (!lt128(0x0ll, 0x0ll, tmp_hihi, tmp_lolo)) { - lshift128(afrac_hi, afrac_lo, 1, &afrac_hi, &afrac_lo); - aexp--; - } - } - - if (bexp == 0) { - bexp++; - /* bfrac is nonzero => it must stop */ - and128(bfrac_hi, bfrac_lo, - FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO, - &tmp_hihi, &tmp_lolo); - while (!lt128(0x0ll, 0x0ll, tmp_hihi, tmp_lolo)) { - lshift128(bfrac_hi, bfrac_lo, 1, &bfrac_hi, &bfrac_lo); - bexp--; - } - } - - or128(afrac_hi, afrac_lo, - FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO, - &afrac_hi, &afrac_lo); - lshift128(afrac_hi, afrac_lo, - (128 - FLOAT128_FRACTION_SIZE - 1), &afrac_hi, &afrac_lo); - or128(bfrac_hi, bfrac_lo, - FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO, - &bfrac_hi, &bfrac_lo); - lshift128(bfrac_hi, bfrac_lo, - (128 - FLOAT128_FRACTION_SIZE - 1), &bfrac_hi, &bfrac_lo); - - if (le128(bfrac_hi, bfrac_lo, afrac_hi, afrac_lo)) { - rshift128(afrac_hi, afrac_lo, 1, &afrac_hi, &afrac_lo); - aexp++; - } - - cexp = aexp - bexp + FLOAT128_BIAS - 2; - - cfrac_hi = div128est(afrac_hi, afrac_lo, bfrac_hi); - - mul128(bfrac_hi, bfrac_lo, 0x0ll, cfrac_hi, - &tmp_lolo /* dummy */, &tmp_hihi, &tmp_hilo, &tmp_lohi); - - /* sub192(afrac_hi, afrac_lo, 0, - * tmp_hihi, tmp_hilo, tmp_lohi - * &rem_hihi, &rem_hilo, &rem_lohi); */ - sub128(afrac_hi, afrac_lo, tmp_hihi, tmp_hilo, &rem_hihi, &rem_hilo); - if (tmp_lohi > 0) { - sub128(rem_hihi, rem_hilo, 0x0ll, 0x1ll, &rem_hihi, &rem_hilo); - } - rem_lohi = -tmp_lohi; - - while ((int64_t) rem_hihi < 0) { - --cfrac_hi; - /* add192(rem_hihi, rem_hilo, rem_lohi, - * 0, bfrac_hi, bfrac_lo, - * &rem_hihi, &rem_hilo, &rem_lohi); */ - add128(rem_hilo, rem_lohi, bfrac_hi, bfrac_lo, &rem_hilo, &rem_lohi); - if (lt128(rem_hilo, rem_lohi, bfrac_hi, bfrac_lo)) { - ++rem_hihi; - } - } - - cfrac_lo = div128est(rem_hilo, rem_lohi, bfrac_lo); - - if ((cfrac_lo & 0x3FFF) <= 4) { - mul128(bfrac_hi, bfrac_lo, 0x0ll, cfrac_lo, - &tmp_hihi /* dummy */, &tmp_hilo, &tmp_lohi, &tmp_lolo); - - /* sub192(rem_hilo, rem_lohi, 0, - * tmp_hilo, tmp_lohi, tmp_lolo, - * &rem_hilo, &rem_lohi, &rem_lolo); */ - sub128(rem_hilo, rem_lohi, tmp_hilo, tmp_lohi, &rem_hilo, &rem_lohi); - if (tmp_lolo > 0) { - sub128(rem_hilo, rem_lohi, 0x0ll, 0x1ll, &rem_hilo, &rem_lohi); - } - rem_lolo = -tmp_lolo; - - while ((int64_t) rem_hilo < 0) { - --cfrac_lo; - /* add192(rem_hilo, rem_lohi, rem_lolo, - * 0, bfrac_hi, bfrac_lo, - * &rem_hilo, &rem_lohi, &rem_lolo); */ - add128(rem_lohi, rem_lolo, bfrac_hi, bfrac_lo, &rem_lohi, &rem_lolo); - if (lt128(rem_lohi, rem_lolo, bfrac_hi, bfrac_lo)) { - ++rem_hilo; - } - } - - cfrac_lo |= ((rem_hilo | rem_lohi | rem_lolo) != 0 ); - } - - shift_out = cfrac_lo << (64 - (128 - FLOAT128_FRACTION_SIZE - 1)); - rshift128(cfrac_hi, cfrac_lo, (128 - FLOAT128_FRACTION_SIZE - 1), - &cfrac_hi, &cfrac_lo); - - result = finish_float128(cexp, cfrac_hi, cfrac_lo, result.parts.sign, shift_out); - return result; -} - -/** @} - */ Index: uspace/lib/softfloat/generic/mul.c =================================================================== --- uspace/lib/softfloat/generic/mul.c (revision 7aa6b99d7bd8a569a8bc3394901a26702aa2a5a9) +++ (revision ) @@ -1,383 +1,0 @@ -/* - * Copyright (c) 2005 Josef Cejka - * Copyright (c) 2011 Petr Koupy - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * - Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR - * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES - * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, - * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF - * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -/** @addtogroup softfloat - * @{ - */ -/** @file Multiplication functions. - */ - -#include -#include -#include -#include - -/** Multiply two single-precision floats. - * - * @param a First input operand. - * @param b Second input operand. - * - * @return Result of multiplication. - * - */ -float32 mul_float32(float32 a, float32 b) -{ - float32 result; - uint64_t frac1, frac2; - int32_t exp; - - result.parts.sign = a.parts.sign ^ b.parts.sign; - - if (is_float32_nan(a) || is_float32_nan(b)) { - /* TODO: fix SigNaNs */ - if (is_float32_signan(a)) { - result.parts.fraction = a.parts.fraction; - result.parts.exp = a.parts.exp; - return result; - } - if (is_float32_signan(b)) { /* TODO: fix SigNaN */ - result.parts.fraction = b.parts.fraction; - result.parts.exp = b.parts.exp; - return result; - } - /* set NaN as result */ - result.bin = FLOAT32_NAN; - return result; - } - - if (is_float32_infinity(a)) { - if (is_float32_zero(b)) { - /* FIXME: zero * infinity */ - result.bin = FLOAT32_NAN; - return result; - } - result.parts.fraction = a.parts.fraction; - result.parts.exp = a.parts.exp; - return result; - } - - if (is_float32_infinity(b)) { - if (is_float32_zero(a)) { - /* FIXME: zero * infinity */ - result.bin = FLOAT32_NAN; - return result; - } - result.parts.fraction = b.parts.fraction; - result.parts.exp = b.parts.exp; - return result; - } - - /* exp is signed so we can easy detect underflow */ - exp = a.parts.exp + b.parts.exp; - exp -= FLOAT32_BIAS; - - if (exp >= FLOAT32_MAX_EXPONENT) { - /* FIXME: overflow */ - /* set infinity as result */ - result.bin = FLOAT32_INF; - result.parts.sign = a.parts.sign ^ b.parts.sign; - return result; - } - - if (exp < 0) { - /* FIXME: underflow */ - /* return signed zero */ - result.parts.fraction = 0x0; - result.parts.exp = 0x0; - return result; - } - - frac1 = a.parts.fraction; - if (a.parts.exp > 0) { - frac1 |= FLOAT32_HIDDEN_BIT_MASK; - } else { - ++exp; - } - - frac2 = b.parts.fraction; - - if (b.parts.exp > 0) { - frac2 |= FLOAT32_HIDDEN_BIT_MASK; - } else { - ++exp; - } - - frac1 <<= 1; /* one bit space for rounding */ - - frac1 = frac1 * frac2; - - /* round and return */ - while ((exp < FLOAT32_MAX_EXPONENT) && - (frac1 >= (1 << (FLOAT32_FRACTION_SIZE + 2)))) { - /* 23 bits of fraction + one more for hidden bit (all shifted 1 bit left) */ - ++exp; - frac1 >>= 1; - } - - /* rounding */ - /* ++frac1; FIXME: not works - without it is ok */ - frac1 >>= 1; /* shift off rounding space */ - - if ((exp < FLOAT32_MAX_EXPONENT) && - (frac1 >= (1 << (FLOAT32_FRACTION_SIZE + 1)))) { - ++exp; - frac1 >>= 1; - } - - if (exp >= FLOAT32_MAX_EXPONENT) { - /* TODO: fix overflow */ - /* return infinity*/ - result.parts.exp = FLOAT32_MAX_EXPONENT; - result.parts.fraction = 0x0; - return result; - } - - exp -= FLOAT32_FRACTION_SIZE; - - if (exp <= FLOAT32_FRACTION_SIZE) { - /* denormalized number */ - frac1 >>= 1; /* denormalize */ - while ((frac1 > 0) && (exp < 0)) { - frac1 >>= 1; - ++exp; - } - if (frac1 == 0) { - /* FIXME : underflow */ - result.parts.exp = 0; - result.parts.fraction = 0; - return result; - } - } - result.parts.exp = exp; - result.parts.fraction = frac1 & ((1 << FLOAT32_FRACTION_SIZE) - 1); - - return result; -} - -/** Multiply two double-precision floats. - * - * @param a First input operand. - * @param b Second input operand. - * - * @return Result of multiplication. - * - */ -float64 mul_float64(float64 a, float64 b) -{ - float64 result; - uint64_t frac1, frac2; - int32_t exp; - - result.parts.sign = a.parts.sign ^ b.parts.sign; - - if (is_float64_nan(a) || is_float64_nan(b)) { - /* TODO: fix SigNaNs */ - if (is_float64_signan(a)) { - result.parts.fraction = a.parts.fraction; - result.parts.exp = a.parts.exp; - return result; - } - if (is_float64_signan(b)) { /* TODO: fix SigNaN */ - result.parts.fraction = b.parts.fraction; - result.parts.exp = b.parts.exp; - return result; - } - /* set NaN as result */ - result.bin = FLOAT64_NAN; - return result; - } - - if (is_float64_infinity(a)) { - if (is_float64_zero(b)) { - /* FIXME: zero * infinity */ - result.bin = FLOAT64_NAN; - return result; - } - result.parts.fraction = a.parts.fraction; - result.parts.exp = a.parts.exp; - return result; - } - - if (is_float64_infinity(b)) { - if (is_float64_zero(a)) { - /* FIXME: zero * infinity */ - result.bin = FLOAT64_NAN; - return result; - } - result.parts.fraction = b.parts.fraction; - result.parts.exp = b.parts.exp; - return result; - } - - /* exp is signed so we can easy detect underflow */ - exp = a.parts.exp + b.parts.exp - FLOAT64_BIAS; - - frac1 = a.parts.fraction; - - if (a.parts.exp > 0) { - frac1 |= FLOAT64_HIDDEN_BIT_MASK; - } else { - ++exp; - } - - frac2 = b.parts.fraction; - - if (b.parts.exp > 0) { - frac2 |= FLOAT64_HIDDEN_BIT_MASK; - } else { - ++exp; - } - - frac1 <<= (64 - FLOAT64_FRACTION_SIZE - 1); - frac2 <<= (64 - FLOAT64_FRACTION_SIZE - 2); - - mul64(frac1, frac2, &frac1, &frac2); - - frac1 |= (frac2 != 0); - if (frac1 & (0x1ll << 62)) { - frac1 <<= 1; - exp--; - } - - result = finish_float64(exp, frac1, result.parts.sign); - return result; -} - -/** Multiply two quadruple-precision floats. - * - * @param a First input operand. - * @param b Second input operand. - * - * @return Result of multiplication. - * - */ -float128 mul_float128(float128 a, float128 b) -{ - float128 result; - uint64_t frac1_hi, frac1_lo, frac2_hi, frac2_lo, tmp_hi, tmp_lo; - int32_t exp; - - result.parts.sign = a.parts.sign ^ b.parts.sign; - - if (is_float128_nan(a) || is_float128_nan(b)) { - /* TODO: fix SigNaNs */ - if (is_float128_signan(a)) { - result.parts.frac_hi = a.parts.frac_hi; - result.parts.frac_lo = a.parts.frac_lo; - result.parts.exp = a.parts.exp; - return result; - } - if (is_float128_signan(b)) { /* TODO: fix SigNaN */ - result.parts.frac_hi = b.parts.frac_hi; - result.parts.frac_lo = b.parts.frac_lo; - result.parts.exp = b.parts.exp; - return result; - } - /* set NaN as result */ - result.bin.hi = FLOAT128_NAN_HI; - result.bin.lo = FLOAT128_NAN_LO; - return result; - } - - if (is_float128_infinity(a)) { - if (is_float128_zero(b)) { - /* FIXME: zero * infinity */ - result.bin.hi = FLOAT128_NAN_HI; - result.bin.lo = FLOAT128_NAN_LO; - return result; - } - result.parts.frac_hi = a.parts.frac_hi; - result.parts.frac_lo = a.parts.frac_lo; - result.parts.exp = a.parts.exp; - return result; - } - - if (is_float128_infinity(b)) { - if (is_float128_zero(a)) { - /* FIXME: zero * infinity */ - result.bin.hi = FLOAT128_NAN_HI; - result.bin.lo = FLOAT128_NAN_LO; - return result; - } - result.parts.frac_hi = b.parts.frac_hi; - result.parts.frac_lo = b.parts.frac_lo; - result.parts.exp = b.parts.exp; - return result; - } - - /* exp is signed so we can easy detect underflow */ - exp = a.parts.exp + b.parts.exp - FLOAT128_BIAS - 1; - - frac1_hi = a.parts.frac_hi; - frac1_lo = a.parts.frac_lo; - - if (a.parts.exp > 0) { - or128(frac1_hi, frac1_lo, - FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO, - &frac1_hi, &frac1_lo); - } else { - ++exp; - } - - frac2_hi = b.parts.frac_hi; - frac2_lo = b.parts.frac_lo; - - if (b.parts.exp > 0) { - or128(frac2_hi, frac2_lo, - FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO, - &frac2_hi, &frac2_lo); - } else { - ++exp; - } - - lshift128(frac2_hi, frac2_lo, - 128 - FLOAT128_FRACTION_SIZE, &frac2_hi, &frac2_lo); - - tmp_hi = frac1_hi; - tmp_lo = frac1_lo; - mul128(frac1_hi, frac1_lo, frac2_hi, frac2_lo, - &frac1_hi, &frac1_lo, &frac2_hi, &frac2_lo); - add128(frac1_hi, frac1_lo, tmp_hi, tmp_lo, &frac1_hi, &frac1_lo); - frac2_hi |= (frac2_lo != 0x0ll); - - if ((FLOAT128_HIDDEN_BIT_MASK_HI << 1) <= frac1_hi) { - frac2_hi >>= 1; - if (frac1_lo & 0x1ll) { - frac2_hi |= (0x1ull < 64); - } - rshift128(frac1_hi, frac1_lo, 1, &frac1_hi, &frac1_lo); - ++exp; - } - - result = finish_float128(exp, frac1_hi, frac1_lo, result.parts.sign, frac2_hi); - return result; -} - -/** @} - */ Index: uspace/lib/softfloat/generic/other.c =================================================================== --- uspace/lib/softfloat/generic/other.c (revision 7aa6b99d7bd8a569a8bc3394901a26702aa2a5a9) +++ (revision ) @@ -1,37 +1,0 @@ -/* - * Copyright (c) 2005 Josef Cejka - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * - Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR - * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES - * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, - * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF - * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -/** @addtogroup softfloat - * @{ - */ -/** @file Other functions (power, complex). - */ - - -/** @} - */ Index: uspace/lib/softfloat/generic/softfloat.c =================================================================== --- uspace/lib/softfloat/generic/softfloat.c (revision 7aa6b99d7bd8a569a8bc3394901a26702aa2a5a9) +++ (revision ) @@ -1,1325 +1,0 @@ -/* - * Copyright (c) 2005 Josef Cejka - * Copyright (c) 2011 Petr Koupy - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * - Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR - * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES - * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, - * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF - * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -/** @addtogroup softfloat generic - * @ingroup sfl - * @brief Architecture independent parts of FPU software emulation library. - * @{ - */ -/** @file Softfloat API. - */ - -#include -#include - -#include -#include -#include -#include - -#include -#include -#include - -/* Arithmetic functions */ - -float __addsf3(float a, float b) -{ - float_t fa; - float_t fb; - float_t res; - - fa.val = a; - fb.val = b; - - if (fa.data.parts.sign != fb.data.parts.sign) { - if (fa.data.parts.sign) { - fa.data.parts.sign = 0; - res.data = sub_float(fb.data, fa.data); - - return res.val; - } - - fb.data.parts.sign = 0; - res.data = sub_float(fa.data, fb.data); - - return res.val; - } - - res.data = add_float(fa.data, fb.data); - return res.val; -} - -double __adddf3(double a, double b) -{ - double_t da; - double_t db; - double_t res; - - da.val = a; - db.val = b; - - if (da.data.parts.sign != db.data.parts.sign) { - if (da.data.parts.sign) { - da.data.parts.sign = 0; - res.data = sub_double(db.data, da.data); - - return res.val; - } - - db.data.parts.sign = 0; - res.data = sub_double(da.data, db.data); - - return res.val; - } - - res.data = add_double(da.data, db.data); - return res.val; -} - -long double __addtf3(long double a, long double b) -{ - long_double_t ta; - long_double_t tb; - long_double_t res; - - ta.val = a; - tb.val = b; - - if (ta.data.parts.sign != tb.data.parts.sign) { - if (ta.data.parts.sign) { - ta.data.parts.sign = 0; - res.data = sub_long_double(tb.data, ta.data); - - return res.val; - } - - tb.data.parts.sign = 0; - res.data = sub_long_double(ta.data, tb.data); - - return res.val; - } - - res.data = add_long_double(ta.data, tb.data); - return res.val; -} - -float __subsf3(float a, float b) -{ - float_t fa; - float_t fb; - float_t res; - - fa.val = a; - fb.val = b; - - if (fa.data.parts.sign != fb.data.parts.sign) { - fb.data.parts.sign = !fb.data.parts.sign; - res.data = add_float(fa.data, fb.data); - - return res.val; - } - - res.data = sub_float(fa.data, fb.data); - return res.val; -} - -double __subdf3(double a, double b) -{ - double_t da; - double_t db; - double_t res; - - da.val = a; - db.val = b; - - if (da.data.parts.sign != db.data.parts.sign) { - db.data.parts.sign = !db.data.parts.sign; - res.data = add_double(da.data, db.data); - - return res.val; - } - - res.data = sub_double(da.data, db.data); - return res.val; -} - -long double __subtf3(long double a, long double b) -{ - long_double_t ta; - long_double_t tb; - long_double_t res; - - ta.val = a; - tb.val = b; - - if (ta.data.parts.sign != tb.data.parts.sign) { - tb.data.parts.sign = !tb.data.parts.sign; - res.data = add_long_double(ta.data, tb.data); - - return res.val; - } - - res.data = sub_long_double(ta.data, tb.data); - return res.val; -} - -float __mulsf3(float a, float b) -{ - float_t fa; - float_t fb; - float_t res; - - fa.val = a; - fb.val = b; - - res.data = mul_float(fa.data, fb.data); - return res.val; -} - -double __muldf3(double a, double b) -{ - double_t da; - double_t db; - double_t res; - - da.val = a; - db.val = b; - - res.data = mul_double(da.data, db.data); - return res.val; -} - -long double __multf3(long double a, long double b) -{ - long_double_t ta; - long_double_t tb; - long_double_t res; - - ta.val = a; - tb.val = b; - - res.data = mul_long_double(ta.data, tb.data); - return res.val; -} - -float __divsf3(float a, float b) -{ - float_t fa; - float_t fb; - float_t res; - - fa.val = a; - fb.val = b; - - res.data = div_float(fa.data, fb.data); - return res.val; -} - -double __divdf3(double a, double b) -{ - double_t da; - double_t db; - double_t res; - - da.val = a; - db.val = b; - - res.data = div_double(da.data, db.data); - return res.val; -} - -long double __divtf3(long double a, long double b) -{ - long_double_t ta; - long_double_t tb; - long_double_t res; - - ta.val = a; - tb.val = b; - - res.data = div_long_double(ta.data, tb.data); - return res.val; -} - -float __negsf2(float a) -{ - float_t fa; - - fa.val = a; - fa.data.parts.sign = !fa.data.parts.sign; - - return fa.val; -} - -double __negdf2(double a) -{ - double_t da; - - da.val = a; - da.data.parts.sign = !da.data.parts.sign; - - return da.val; -} - -long double __negtf2(long double a) -{ - long_double_t ta; - - ta.val = a; - ta.data.parts.sign = !ta.data.parts.sign; - - return ta.val; -} - -/* Conversion functions */ - -double __extendsfdf2(float a) -{ - float_t fa; - double_t res; - - fa.val = a; - res.data = float_to_double(fa.data); - - return res.val; -} - -long double __extendsftf2(float a) -{ - float_t fa; - long_double_t res; - - fa.val = a; - res.data = float_to_long_double(fa.data); - - return res.val; -} - -long double __extenddftf2(double a) -{ - double_t da; - long_double_t res; - - da.val = a; - res.data = double_to_long_double(da.data); - - return res.val; -} - -float __truncdfsf2(double a) -{ - double_t da; - float_t res; - - da.val = a; - res.data = double_to_float(da.data); - - return res.val; -} - -float __trunctfsf2(long double a) -{ - long_double_t ta; - float_t res; - - ta.val = a; - res.data = long_double_to_float(ta.data); - - return res.val; -} - -double __trunctfdf2(long double a) -{ - long_double_t ta; - double_t res; - - ta.val = a; - res.data = long_double_to_double(ta.data); - - return res.val; -} - -int __fixsfsi(float a) -{ - float_t fa; - - fa.val = a; - return float_to_int(fa.data); -} - -int __fixdfsi(double a) -{ - double_t da; - - da.val = a; - return double_to_int(da.data); -} - -int __fixtfsi(long double a) -{ - long_double_t ta; - - ta.val = a; - return long_double_to_int(ta.data); -} - -long __fixsfdi(float a) -{ - float_t fa; - - fa.val = a; - return float_to_long(fa.data); -} - -long __fixdfdi(double a) -{ - double_t da; - - da.val = a; - return double_to_long(da.data); -} - -long __fixtfdi(long double a) -{ - long_double_t ta; - - ta.val = a; - return long_double_to_long(ta.data); -} - -long long __fixsfti(float a) -{ - float_t fa; - - fa.val = a; - return float_to_llong(fa.data); -} - -long long __fixdfti(double a) -{ - double_t da; - - da.val = a; - return double_to_llong(da.data); -} - -long long __fixtfti(long double a) -{ - long_double_t ta; - - ta.val = a; - return long_double_to_llong(ta.data); -} - -unsigned int __fixunssfsi(float a) -{ - float_t fa; - - fa.val = a; - return float_to_uint(fa.data); -} - -unsigned int __fixunsdfsi(double a) -{ - double_t da; - - da.val = a; - return double_to_uint(da.data); -} - -unsigned int __fixunstfsi(long double a) -{ - long_double_t ta; - - ta.val = a; - return long_double_to_uint(ta.data); -} - -unsigned long __fixunssfdi(float a) -{ - float_t fa; - - fa.val = a; - return float_to_ulong(fa.data); -} - -unsigned long __fixunsdfdi(double a) -{ - double_t da; - - da.val = a; - return double_to_ulong(da.data); -} - -unsigned long __fixunstfdi(long double a) -{ - long_double_t ta; - - ta.val = a; - return long_double_to_ulong(ta.data); -} - -unsigned long long __fixunssfti(float a) -{ - float_t fa; - - fa.val = a; - return float_to_ullong(fa.data); -} - -unsigned long long __fixunsdfti(double a) -{ - double_t da; - - da.val = a; - return double_to_ullong(da.data); -} - -unsigned long long __fixunstfti(long double a) -{ - long_double_t ta; - - ta.val = a; - return long_double_to_ullong(ta.data); -} - -float __floatsisf(int i) -{ - float_t res; - - res.data = int_to_float(i); - return res.val; -} - -double __floatsidf(int i) -{ - double_t res; - - res.data = int_to_double(i); - return res.val; -} - -long double __floatsitf(int i) -{ - long_double_t res; - - res.data = int_to_long_double(i); - return res.val; -} - -float __floatdisf(long i) -{ - float_t res; - - res.data = long_to_float(i); - return res.val; -} - -double __floatdidf(long i) -{ - double_t res; - - res.data = long_to_double(i); - return res.val; -} - -long double __floatditf(long i) -{ - long_double_t res; - - res.data = long_to_long_double(i); - return res.val; -} - -float __floattisf(long long i) -{ - float_t res; - - res.data = llong_to_float(i); - return res.val; -} - -double __floattidf(long long i) -{ - double_t res; - - res.data = llong_to_double(i); - return res.val; -} - -long double __floattitf(long long i) -{ - long_double_t res; - - res.data = llong_to_long_double(i); - return res.val; -} - -float __floatunsisf(unsigned int i) -{ - float_t res; - - res.data = uint_to_float(i); - return res.val; -} - -double __floatunsidf(unsigned int i) -{ - double_t res; - - res.data = uint_to_double(i); - return res.val; -} - -long double __floatunsitf(unsigned int i) -{ - long_double_t res; - - res.data = uint_to_long_double(i); - return res.val; -} - -float __floatundisf(unsigned long i) -{ - float_t res; - - res.data = ulong_to_float(i); - return res.val; -} - -double __floatundidf(unsigned long i) -{ - double_t res; - - res.data = ulong_to_double(i); - return res.val; -} - -long double __floatunditf(unsigned long i) -{ - long_double_t res; - - res.data = ulong_to_long_double(i); - return res.val; -} - -float __floatuntisf(unsigned long long i) -{ - float_t res; - - res.data = ullong_to_float(i); - return res.val; -} - -double __floatuntidf(unsigned long long i) -{ - double_t res; - - res.data = ullong_to_double(i); - return res.val; -} - -long double __floatuntitf(unsigned long long i) -{ - long_double_t res; - - res.data = ullong_to_long_double(i); - return res.val; -} - -/* Comparison functions */ - -int __cmpsf2(float a, float b) -{ - float_t fa; - float_t fb; - - fa.val = a; - fb.val = b; - - if ((is_float_nan(fa.data)) || (is_float_nan(fb.data))) { - /* no special constant for unordered - maybe signaled? */ - return 1; - } - - if (is_float_eq(fa.data, fb.data)) - return 0; - - if (is_float_lt(fa.data, fb.data)) - return -1; - - return 1; -} - -int __cmpdf2(double a, double b) -{ - double_t da; - double_t db; - - da.val = a; - db.val = b; - - if ((is_double_nan(da.data)) || (is_double_nan(db.data))) { - /* no special constant for unordered - maybe signaled? */ - return 1; - } - - if (is_double_eq(da.data, db.data)) - return 0; - - if (is_double_lt(da.data, db.data)) - return -1; - - return 1; -} - -int __cmptf2(long double a, long double b) -{ - long_double_t ta; - long_double_t tb; - - ta.val = a; - tb.val = b; - - if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data))) { - /* no special constant for unordered - maybe signaled? */ - return 1; - } - - if (is_long_double_eq(ta.data, tb.data)) - return 0; - - if (is_long_double_lt(ta.data, tb.data)) - return -1; - - return 1; -} - -int __unordsf2(float a, float b) -{ - float_t fa; - float_t fb; - - fa.val = a; - fb.val = b; - - return ((is_float_nan(fa.data)) || (is_float_nan(fb.data))); -} - -int __unorddf2(double a, double b) -{ - double_t da; - double_t db; - - da.val = a; - db.val = b; - - return ((is_double_nan(da.data)) || (is_double_nan(db.data))); -} - -int __unordtf2(long double a, long double b) -{ - long_double_t ta; - long_double_t tb; - - ta.val = a; - tb.val = b; - - return ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data))); -} - -int __eqsf2(float a, float b) -{ - float_t fa; - float_t fb; - - fa.val = a; - fb.val = b; - - if ((is_float_nan(fa.data)) || (is_float_nan(fb.data))) { - // TODO: sigNaNs - return 1; - } - - return is_float_eq(fa.data, fb.data) - 1; -} - -int __eqdf2(double a, double b) -{ - double_t da; - double_t db; - - da.val = a; - db.val = b; - - if ((is_double_nan(da.data)) || (is_double_nan(db.data))) { - // TODO: sigNaNs - return 1; - } - - return is_double_eq(da.data, db.data) - 1; -} - -int __eqtf2(long double a, long double b) -{ - long_double_t ta; - long_double_t tb; - - ta.val = a; - tb.val = b; - - if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data))) { - // TODO: sigNaNs - return 1; - } - - return is_long_double_eq(ta.data, tb.data) - 1; -} - -int __nesf2(float a, float b) -{ - /* strange behavior, but it was in gcc documentation */ - return __eqsf2(a, b); -} - -int __nedf2(double a, double b) -{ - /* strange behavior, but it was in gcc documentation */ - return __eqdf2(a, b); -} - -int __netf2(long double a, long double b) -{ - /* strange behavior, but it was in gcc documentation */ - return __eqtf2(a, b); -} - -int __gesf2(float a, float b) -{ - float_t fa; - float_t fb; - - fa.val = a; - fb.val = b; - - if ((is_float_nan(fa.data)) || (is_float_nan(fb.data))) { - // TODO: sigNaNs - return -1; - } - - if (is_float_eq(fa.data, fb.data)) - return 0; - - if (is_float_gt(fa.data, fb.data)) - return 1; - - return -1; -} - -int __gedf2(double a, double b) -{ - double_t da; - double_t db; - - da.val = a; - db.val = b; - - if ((is_double_nan(da.data)) || (is_double_nan(db.data))) { - // TODO: sigNaNs - return -1; - } - - if (is_double_eq(da.data, db.data)) - return 0; - - if (is_double_gt(da.data, db.data)) - return 1; - - return -1; -} - -int __getf2(long double a, long double b) -{ - long_double_t ta; - long_double_t tb; - - ta.val = a; - tb.val = b; - - if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data))) { - // TODO: sigNaNs - return -1; - } - - if (is_long_double_eq(ta.data, tb.data)) - return 0; - - if (is_long_double_gt(ta.data, tb.data)) - return 1; - - return -1; -} - -int __ltsf2(float a, float b) -{ - float_t fa; - float_t fb; - - fa.val = a; - fb.val = b; - - if ((is_float_nan(fa.data)) || (is_float_nan(fb.data))) { - // TODO: sigNaNs - return 1; - } - - if (is_float_lt(fa.data, fb.data)) - return -1; - - return 0; -} - -int __ltdf2(double a, double b) -{ - double_t da; - double_t db; - - da.val = a; - db.val = b; - - if ((is_double_nan(da.data)) || (is_double_nan(db.data))) { - // TODO: sigNaNs - return 1; - } - - if (is_double_lt(da.data, db.data)) - return -1; - - return 0; -} - -int __lttf2(long double a, long double b) -{ - long_double_t ta; - long_double_t tb; - - ta.val = a; - tb.val = b; - - if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data))) { - // TODO: sigNaNs - return 1; - } - - if (is_long_double_lt(ta.data, tb.data)) - return -1; - - return 0; -} - -int __lesf2(float a, float b) -{ - float_t fa; - float_t fb; - - fa.val = a; - fb.val = b; - - if ((is_float_nan(fa.data)) || (is_float_nan(fb.data))) { - // TODO: sigNaNs - return 1; - } - - if (is_float_eq(fa.data, fb.data)) - return 0; - - if (is_float_lt(fa.data, fb.data)) - return -1; - - return 1; -} - -int __ledf2(double a, double b) -{ - double_t da; - double_t db; - - da.val = a; - db.val = b; - - if ((is_double_nan(da.data)) || (is_double_nan(db.data))) { - // TODO: sigNaNs - return 1; - } - - if (is_double_eq(da.data, db.data)) - return 0; - - if (is_double_lt(da.data, db.data)) - return -1; - - return 1; -} - -int __letf2(long double a, long double b) -{ - long_double_t ta; - long_double_t tb; - - ta.val = a; - tb.val = b; - - if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data))) { - // TODO: sigNaNs - return 1; - } - - if (is_long_double_eq(ta.data, tb.data)) - return 0; - - if (is_long_double_lt(ta.data, tb.data)) - return -1; - - return 1; -} - -int __gtsf2(float a, float b) -{ - float_t fa; - float_t fb; - - fa.val = a; - fb.val = b; - - if ((is_float_nan(fa.data)) || (is_float_nan(fb.data))) { - // TODO: sigNaNs - return -1; - } - - if (is_float_gt(fa.data, fb.data)) - return 1; - - return 0; -} - -int __gtdf2(double a, double b) -{ - double_t da; - double_t db; - - da.val = a; - db.val = b; - - if ((is_double_nan(da.data)) || (is_double_nan(db.data))) { - // TODO: sigNaNs - return -1; - } - - if (is_double_gt(da.data, db.data)) - return 1; - - return 0; -} - -int __gttf2(long double a, long double b) -{ - long_double_t ta; - long_double_t tb; - - ta.val = a; - tb.val = b; - - if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data))) { - // TODO: sigNaNs - return -1; - } - - if (is_long_double_gt(ta.data, tb.data)) - return 1; - - return 0; -} - -/* SPARC quadruple-precision wrappers */ - -void _Qp_add(long double *c, long double *a, long double *b) -{ - *c = __addtf3(*a, *b); -} - -void _Qp_sub(long double *c, long double *a, long double *b) -{ - *c = __subtf3(*a, *b); -} - -void _Qp_mul(long double *c, long double *a, long double *b) -{ - *c = __multf3(*a, *b); -} - -void _Qp_div(long double *c, long double *a, long double *b) -{ - *c = __divtf3(*a, *b); -} - -void _Qp_neg(long double *c, long double *a) -{ - *c = __negtf2(*a); -} - -void _Qp_stoq(long double *c, float a) -{ - *c = __extendsftf2(a); -} - -void _Qp_dtoq(long double *c, double a) -{ - *c = __extenddftf2(a); -} - -float _Qp_qtos(long double *a) -{ - return __trunctfsf2(*a); -} - -double _Qp_qtod(long double *a) -{ - return __trunctfdf2(*a); -} - -int _Qp_qtoi(long double *a) -{ - return __fixtfsi(*a); -} - -unsigned int _Qp_qtoui(long double *a) -{ - return __fixunstfsi(*a); -} - -long _Qp_qtox(long double *a) -{ - return __fixtfdi(*a); -} - -unsigned long _Qp_qtoux(long double *a) -{ - return __fixunstfdi(*a); -} - -void _Qp_itoq(long double *c, int a) -{ - *c = __floatsitf(a); -} - -void _Qp_uitoq(long double *c, unsigned int a) -{ - *c = __floatunsitf(a); -} - -void _Qp_xtoq(long double *c, long a) -{ - *c = __floatditf(a); -} - -void _Qp_uxtoq(long double *c, unsigned long a) -{ - *c = __floatunditf(a); -} - -int _Qp_cmp(long double *a, long double *b) -{ - long_double_t ta; - long_double_t tb; - - ta.val = *a; - tb.val = *b; - - if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data))) - return 3; - - if (is_long_double_eq(ta.data, tb.data)) - return 0; - - if (is_long_double_lt(ta.data, tb.data)) - return 1; - - return 2; -} - -int _Qp_cmpe(long double *a, long double *b) -{ - /* strange, but is defined this way in SPARC Compliance Definition */ - return _Qp_cmp(a, b); -} - -int _Qp_feq(long double *a, long double *b) -{ - long_double_t ta; - long_double_t tb; - - ta.val = *a; - tb.val = *b; - - if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data))) - return 0; - - return is_long_double_eq(ta.data, tb.data); -} - -int _Qp_fge(long double *a, long double *b) -{ - long_double_t ta; - long_double_t tb; - - ta.val = *a; - tb.val = *b; - - if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data))) - return 0; - - return is_long_double_eq(ta.data, tb.data) || - is_long_double_gt(ta.data, tb.data); -} - -int _Qp_fgt(long double *a, long double *b) -{ - long_double_t ta; - long_double_t tb; - - ta.val = *a; - tb.val = *b; - - if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data))) - return 0; - - return is_long_double_gt(ta.data, tb.data); -} - -int _Qp_fle(long double*a, long double *b) -{ - long_double_t ta; - long_double_t tb; - - ta.val = *a; - tb.val = *b; - - if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data))) - return 0; - - return is_long_double_eq(ta.data, tb.data) || - is_long_double_lt(ta.data, tb.data); -} - -int _Qp_flt(long double *a, long double *b) -{ - long_double_t ta; - long_double_t tb; - - ta.val = *a; - tb.val = *b; - - if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data))) - return 0; - - return is_long_double_lt(ta.data, tb.data); -} - -int _Qp_fne(long double *a, long double *b) -{ - long_double_t ta; - long_double_t tb; - - ta.val = *a; - tb.val = *b; - - if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data))) - return 0; - - return !is_long_double_eq(ta.data, tb.data); -} - -double __aeabi_i2d(int i) -{ - return __floatsidf(i); -} - -double __aeabi_ui2d(unsigned int i) -{ - return __floatunsidf(i); -} - -int __aeabi_d2iz(double a) -{ - return __fixdfsi(a); -} - -unsigned int __aeabi_d2uiz(double a) -{ - return __fixunsdfsi(a); -} - -int __aeabi_dcmpge(double a, double b) -{ - return __gedf2(a, b); -} - -int __aeabi_dcmpgt(double a, double b) -{ - return __gtdf2(a, b); -} - -int __aeabi_dcmplt(double a, double b) -{ - return __ltdf2(a, b); -} - -double __aeabi_dadd(double a, double b) -{ - return __adddf3(a, b); -} - -double __aeabi_dsub(double a, double b) -{ - return __subdf3(a, b); -} - -double __aeabi_dmul(double a, double b) -{ - return __muldf3(a, b); -} - -double __aeabi_ddiv(double a, double b) -{ - return __divdf3(a, b); -} - -/** @} - */ Index: uspace/lib/softfloat/generic/sub.c =================================================================== --- uspace/lib/softfloat/generic/sub.c (revision 7aa6b99d7bd8a569a8bc3394901a26702aa2a5a9) +++ (revision ) @@ -1,441 +1,0 @@ -/* - * Copyright (c) 2005 Josef Cejka - * Copyright (c) 2011 Petr Koupy - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * - Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR - * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES - * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, - * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF - * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -/** @addtogroup softfloat - * @{ - */ -/** @file Substraction functions. - */ - -#include -#include -#include -#include - -/** Subtract two single-precision floats with the same sign. - * - * @param a First input operand. - * @param b Second input operand. - * - * @return Result of substraction. - * - */ -float32 sub_float32(float32 a, float32 b) -{ - int expdiff; - uint32_t exp1, exp2, frac1, frac2; - float32 result; - - result.bin = 0; - - expdiff = a.parts.exp - b.parts.exp; - if ((expdiff < 0 ) || ((expdiff == 0) && - (a.parts.fraction < b.parts.fraction))) { - if (is_float32_nan(b)) { - if (is_float32_signan(b)) { - // TODO: fix SigNaN - } - - return b; - } - - if (b.parts.exp == FLOAT32_MAX_EXPONENT) { - /* num -(+-inf) = -+inf */ - b.parts.sign = !b.parts.sign; - return b; - } - - result.parts.sign = !a.parts.sign; - - frac1 = b.parts.fraction; - exp1 = b.parts.exp; - frac2 = a.parts.fraction; - exp2 = a.parts.exp; - expdiff *= -1; - } else { - if (is_float32_nan(a)) { - if ((is_float32_signan(a)) || (is_float32_signan(b))) { - // TODO: fix SigNaN - } - - return a; - } - - if (a.parts.exp == FLOAT32_MAX_EXPONENT) { - if (b.parts.exp == FLOAT32_MAX_EXPONENT) { - /* inf - inf => nan */ - // TODO: fix exception - result.bin = FLOAT32_NAN; - return result; - } - - return a; - } - - result.parts.sign = a.parts.sign; - - frac1 = a.parts.fraction; - exp1 = a.parts.exp; - frac2 = b.parts.fraction; - exp2 = b.parts.exp; - } - - if (exp1 == 0) { - /* both are denormalized */ - result.parts.fraction = frac1 - frac2; - if (result.parts.fraction > frac1) { - // TODO: underflow exception - return result; - } - - result.parts.exp = 0; - return result; - } - - /* add hidden bit */ - frac1 |= FLOAT32_HIDDEN_BIT_MASK; - - if (exp2 == 0) { - /* denormalized */ - --expdiff; - } else { - /* normalized */ - frac2 |= FLOAT32_HIDDEN_BIT_MASK; - } - - /* create some space for rounding */ - frac1 <<= 6; - frac2 <<= 6; - - if (expdiff > FLOAT32_FRACTION_SIZE + 1) - goto done; - - frac1 = frac1 - (frac2 >> expdiff); - -done: - /* TODO: find first nonzero digit and shift result and detect possibly underflow */ - while ((exp1 > 0) && (!(frac1 & (FLOAT32_HIDDEN_BIT_MASK << 6 )))) { - --exp1; - frac1 <<= 1; - /* TODO: fix underflow - frac1 == 0 does not necessary means underflow... */ - } - - /* rounding - if first bit after fraction is set then round up */ - frac1 += 0x20; - - if (frac1 & (FLOAT32_HIDDEN_BIT_MASK << 7)) { - ++exp1; - frac1 >>= 1; - } - - /* Clear hidden bit and shift */ - result.parts.fraction = ((frac1 >> 6) & (~FLOAT32_HIDDEN_BIT_MASK)); - result.parts.exp = exp1; - - return result; -} - -/** Subtract two double-precision floats with the same sign. - * - * @param a First input operand. - * @param b Second input operand. - * - * @return Result of substraction. - * - */ -float64 sub_float64(float64 a, float64 b) -{ - int expdiff; - uint32_t exp1, exp2; - uint64_t frac1, frac2; - float64 result; - - result.bin = 0; - - expdiff = a.parts.exp - b.parts.exp; - if ((expdiff < 0 ) || - ((expdiff == 0) && (a.parts.fraction < b.parts.fraction))) { - if (is_float64_nan(b)) { - if (is_float64_signan(b)) { - // TODO: fix SigNaN - } - - return b; - } - - if (b.parts.exp == FLOAT64_MAX_EXPONENT) { - /* num -(+-inf) = -+inf */ - b.parts.sign = !b.parts.sign; - return b; - } - - result.parts.sign = !a.parts.sign; - - frac1 = b.parts.fraction; - exp1 = b.parts.exp; - frac2 = a.parts.fraction; - exp2 = a.parts.exp; - expdiff *= -1; - } else { - if (is_float64_nan(a)) { - if (is_float64_signan(a) || is_float64_signan(b)) { - // TODO: fix SigNaN - } - - return a; - } - - if (a.parts.exp == FLOAT64_MAX_EXPONENT) { - if (b.parts.exp == FLOAT64_MAX_EXPONENT) { - /* inf - inf => nan */ - // TODO: fix exception - result.bin = FLOAT64_NAN; - return result; - } - - return a; - } - - result.parts.sign = a.parts.sign; - - frac1 = a.parts.fraction; - exp1 = a.parts.exp; - frac2 = b.parts.fraction; - exp2 = b.parts.exp; - } - - if (exp1 == 0) { - /* both are denormalized */ - result.parts.fraction = frac1 - frac2; - if (result.parts.fraction > frac1) { - // TODO: underflow exception - return result; - } - - result.parts.exp = 0; - return result; - } - - /* add hidden bit */ - frac1 |= FLOAT64_HIDDEN_BIT_MASK; - - if (exp2 == 0) { - /* denormalized */ - --expdiff; - } else { - /* normalized */ - frac2 |= FLOAT64_HIDDEN_BIT_MASK; - } - - /* create some space for rounding */ - frac1 <<= 6; - frac2 <<= 6; - - if (expdiff > FLOAT64_FRACTION_SIZE + 1) - goto done; - - frac1 = frac1 - (frac2 >> expdiff); - -done: - /* TODO: find first nonzero digit and shift result and detect possibly underflow */ - while ((exp1 > 0) && (!(frac1 & (FLOAT64_HIDDEN_BIT_MASK << 6 )))) { - --exp1; - frac1 <<= 1; - /* TODO: fix underflow - frac1 == 0 does not necessary means underflow... */ - } - - /* rounding - if first bit after fraction is set then round up */ - frac1 += 0x20; - - if (frac1 & (FLOAT64_HIDDEN_BIT_MASK << 7)) { - ++exp1; - frac1 >>= 1; - } - - /* Clear hidden bit and shift */ - result.parts.fraction = ((frac1 >> 6) & (~FLOAT64_HIDDEN_BIT_MASK)); - result.parts.exp = exp1; - - return result; -} - -/** Subtract two quadruple-precision floats with the same sign. - * - * @param a First input operand. - * @param b Second input operand. - * - * @return Result of substraction. - * - */ -float128 sub_float128(float128 a, float128 b) -{ - int expdiff; - uint32_t exp1, exp2; - uint64_t frac1_hi, frac1_lo, frac2_hi, frac2_lo, tmp_hi, tmp_lo; - float128 result; - - result.bin.hi = 0; - result.bin.lo = 0; - - expdiff = a.parts.exp - b.parts.exp; - if ((expdiff < 0 ) || ((expdiff == 0) && - lt128(a.parts.frac_hi, a.parts.frac_lo, b.parts.frac_hi, b.parts.frac_lo))) { - if (is_float128_nan(b)) { - if (is_float128_signan(b)) { - // TODO: fix SigNaN - } - - return b; - } - - if (b.parts.exp == FLOAT128_MAX_EXPONENT) { - /* num -(+-inf) = -+inf */ - b.parts.sign = !b.parts.sign; - return b; - } - - result.parts.sign = !a.parts.sign; - - frac1_hi = b.parts.frac_hi; - frac1_lo = b.parts.frac_lo; - exp1 = b.parts.exp; - frac2_hi = a.parts.frac_hi; - frac2_lo = a.parts.frac_lo; - exp2 = a.parts.exp; - expdiff *= -1; - } else { - if (is_float128_nan(a)) { - if (is_float128_signan(a) || is_float128_signan(b)) { - // TODO: fix SigNaN - } - - return a; - } - - if (a.parts.exp == FLOAT128_MAX_EXPONENT) { - if (b.parts.exp == FLOAT128_MAX_EXPONENT) { - /* inf - inf => nan */ - // TODO: fix exception - result.bin.hi = FLOAT128_NAN_HI; - result.bin.lo = FLOAT128_NAN_LO; - return result; - } - return a; - } - - result.parts.sign = a.parts.sign; - - frac1_hi = a.parts.frac_hi; - frac1_lo = a.parts.frac_lo; - exp1 = a.parts.exp; - frac2_hi = b.parts.frac_hi; - frac2_lo = b.parts.frac_lo; - exp2 = b.parts.exp; - } - - if (exp1 == 0) { - /* both are denormalized */ - sub128(frac1_hi, frac1_lo, frac2_hi, frac2_lo, &tmp_hi, &tmp_lo); - result.parts.frac_hi = tmp_hi; - result.parts.frac_lo = tmp_lo; - if (lt128(frac1_hi, frac1_lo, result.parts.frac_hi, result.parts.frac_lo)) { - // TODO: underflow exception - return result; - } - - result.parts.exp = 0; - return result; - } - - /* add hidden bit */ - or128(frac1_hi, frac1_lo, - FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO, - &frac1_hi, &frac1_lo); - - if (exp2 == 0) { - /* denormalized */ - --expdiff; - } else { - /* normalized */ - or128(frac2_hi, frac2_lo, - FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO, - &frac2_hi, &frac2_lo); - } - - /* create some space for rounding */ - lshift128(frac1_hi, frac1_lo, 6, &frac1_hi, &frac1_lo); - lshift128(frac2_hi, frac2_lo, 6, &frac2_hi, &frac2_lo); - - if (expdiff > FLOAT128_FRACTION_SIZE + 1) - goto done; - - rshift128(frac2_hi, frac2_lo, expdiff, &tmp_hi, &tmp_lo); - sub128(frac1_hi, frac1_lo, tmp_hi, tmp_lo, &frac1_hi, &frac1_lo); - -done: - /* TODO: find first nonzero digit and shift result and detect possibly underflow */ - lshift128(FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO, 6, - &tmp_hi, &tmp_lo); - and128(frac1_hi, frac1_lo, tmp_hi, tmp_lo, &tmp_hi, &tmp_lo); - while ((exp1 > 0) && (!lt128(0x0ll, 0x0ll, tmp_hi, tmp_lo))) { - --exp1; - lshift128(frac1_hi, frac1_lo, 1, &frac1_hi, &frac1_lo); - /* TODO: fix underflow - frac1 == 0 does not necessary means underflow... */ - - lshift128(FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO, 6, - &tmp_hi, &tmp_lo); - and128(frac1_hi, frac1_lo, tmp_hi, tmp_lo, &tmp_hi, &tmp_lo); - } - - /* rounding - if first bit after fraction is set then round up */ - add128(frac1_hi, frac1_lo, 0x0ll, 0x20ll, &frac1_hi, &frac1_lo); - - lshift128(FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO, 7, - &tmp_hi, &tmp_lo); - and128(frac1_hi, frac1_lo, tmp_hi, tmp_lo, &tmp_hi, &tmp_lo); - if (lt128(0x0ll, 0x0ll, tmp_hi, tmp_lo)) { - ++exp1; - rshift128(frac1_hi, frac1_lo, 1, &frac1_hi, &frac1_lo); - } - - /* Clear hidden bit and shift */ - rshift128(frac1_hi, frac1_lo, 6, &frac1_hi, &frac1_lo); - not128(FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO, - &tmp_hi, &tmp_lo); - and128(frac1_hi, frac1_lo, tmp_hi, tmp_lo, &tmp_hi, &tmp_lo); - result.parts.frac_hi = tmp_hi; - result.parts.frac_lo = tmp_lo; - - result.parts.exp = exp1; - - return result; -} - -/** @} - */ Index: uspace/lib/softfloat/include/add.h =================================================================== --- uspace/lib/softfloat/include/add.h (revision 7aa6b99d7bd8a569a8bc3394901a26702aa2a5a9) +++ (revision ) @@ -1,47 +1,0 @@ -/* - * Copyright (c) 2005 Josef Cejka - * Copyright (c) 2011 Petr Koupy - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * - Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR - * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES - * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, - * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF - * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -/** @addtogroup softfloat - * @{ - */ -/** @file Addition functions. - */ - -#ifndef __ADD_H__ -#define __ADD_H__ - -extern float32 add_float32(float32, float32); -extern float64 add_float64(float64, float64); -extern float96 add_float96(float96, float96); -extern float128 add_float128(float128, float128); - -#endif - -/** @} - */ Index: uspace/lib/softfloat/include/common.h =================================================================== --- uspace/lib/softfloat/include/common.h (revision 7aa6b99d7bd8a569a8bc3394901a26702aa2a5a9) +++ (revision ) @@ -1,76 +1,0 @@ -/* - * Copyright (c) 2005 Josef Cejka - * Copyright (c) 2011 Petr Koupy - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * - Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR - * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES - * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, - * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF - * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -/** @addtogroup softfloat - * @{ - */ -/** @file Common helper operations. - */ - -#ifndef __COMMON_H__ -#define __COMMON_H__ - -#include - -extern float64 finish_float64(int32_t, uint64_t, char); -extern float128 finish_float128(int32_t, uint64_t, uint64_t, char, uint64_t); - -extern int count_zeroes8(uint8_t); -extern int count_zeroes32(uint32_t); -extern int count_zeroes64(uint64_t); - -extern void round_float32(int32_t *, uint32_t *); -extern void round_float64(int32_t *, uint64_t *); -extern void round_float128(int32_t *, uint64_t *, uint64_t *); - -extern void lshift128(uint64_t, uint64_t, int, uint64_t *, uint64_t *); -extern void rshift128(uint64_t, uint64_t, int, uint64_t *, uint64_t *); - -extern void and128(uint64_t, uint64_t, uint64_t, uint64_t, uint64_t *, uint64_t *); -extern void or128(uint64_t, uint64_t, uint64_t, uint64_t, uint64_t *, uint64_t *); -extern void xor128(uint64_t, uint64_t, uint64_t, uint64_t, uint64_t *, uint64_t *); -extern void not128(uint64_t, uint64_t, uint64_t *, uint64_t *); - -extern int eq128(uint64_t, uint64_t, uint64_t, uint64_t); -extern int le128(uint64_t, uint64_t, uint64_t, uint64_t); -extern int lt128(uint64_t, uint64_t, uint64_t, uint64_t); - -extern void add128(uint64_t, uint64_t, uint64_t, uint64_t, uint64_t *, uint64_t *); -extern void sub128(uint64_t, uint64_t, uint64_t, uint64_t, uint64_t *, uint64_t *); - -extern void mul64(uint64_t, uint64_t, uint64_t *, uint64_t *); -extern void mul128(uint64_t, uint64_t, uint64_t, uint64_t, - uint64_t *, uint64_t *, uint64_t *, uint64_t *); - -extern uint64_t div128est(uint64_t, uint64_t, uint64_t); - -#endif - -/** @} - */ Index: uspace/lib/softfloat/include/comparison.h =================================================================== --- uspace/lib/softfloat/include/comparison.h (revision 7aa6b99d7bd8a569a8bc3394901a26702aa2a5a9) +++ (revision ) @@ -1,82 +1,0 @@ -/* - * Copyright (c) 2005 Josef Cejka - * Copyright (c) 2011 Petr Koupy - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * - Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR - * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES - * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, - * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF - * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -/** @addtogroup softfloat - * @{ - */ -/** @file Comparison functions. - */ - -#ifndef __COMPARISON_H__ -#define __COMPARISON_H__ - -extern int is_float32_nan(float32); -extern int is_float32_signan(float32); - -extern int is_float32_infinity(float32); -extern int is_float32_zero(float32); - -extern int is_float32_eq(float32, float32); -extern int is_float32_lt(float32, float32); -extern int is_float32_gt(float32, float32); - -extern int is_float64_nan(float64); -extern int is_float64_signan(float64); - -extern int is_float64_infinity(float64); -extern int is_float64_zero(float64); - -extern int is_float64_eq(float64, float64); -extern int is_float64_lt(float64, float64); -extern int is_float64_gt(float64, float64); - -extern int is_float96_nan(float96); -extern int is_float96_signan(float96); - -extern int is_float96_infinity(float96); -extern int is_float96_zero(float96); - -extern int is_float96_eq(float96, float96); -extern int is_float96_lt(float96, float96); -extern int is_float96_gt(float96, float96); - -extern int is_float128_nan(float128); -extern int is_float128_signan(float128); - -extern int is_float128_infinity(float128); -extern int is_float128_zero(float128); - -extern int is_float128_eq(float128, float128); -extern int is_float128_lt(float128, float128); -extern int is_float128_gt(float128, float128); - -#endif - -/** @} - */ Index: uspace/lib/softfloat/include/conversion.h =================================================================== --- uspace/lib/softfloat/include/conversion.h (revision 7aa6b99d7bd8a569a8bc3394901a26702aa2a5a9) +++ (revision ) @@ -1,104 +1,0 @@ -/* - * Copyright (c) 2005 Josef Cejka - * Copyright (c) 2011 Petr Koupy - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * - Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR - * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES - * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, - * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF - * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - - /** @addtogroup softfloat - * @{ - */ -/** @file Conversion of precision and conversion between integers and floats. - */ - -#ifndef __CONVERSION_H__ -#define __CONVERSION_H__ - -extern float64 float32_to_float64(float32); -extern float96 float32_to_float96(float32); -extern float128 float32_to_float128(float32); -extern float96 float64_to_float96(float64); -extern float128 float64_to_float128(float64); -extern float128 float96_to_float128(float96); - -extern float32 float64_to_float32(float64); -extern float32 float96_to_float32(float96); -extern float64 float96_to_float64(float96); -extern float32 float128_to_float32(float128); -extern float64 float128_to_float64(float128); -extern float96 float128_to_float96(float128); - -extern uint32_t float32_to_uint32(float32); -extern int32_t float32_to_int32(float32); - -extern uint64_t float32_to_uint64(float32); -extern int64_t float32_to_int64(float32); - -extern uint32_t float64_to_uint32(float64); -extern int32_t float64_to_int32(float64); - -extern uint64_t float64_to_uint64(float64); -extern int64_t float64_to_int64(float64); - -extern uint32_t float96_to_uint32(float96); -extern int32_t float96_to_int32(float96); - -extern uint64_t float96_to_uint64(float96); -extern int64_t float96_to_int64(float96); - -extern uint32_t float128_to_uint32(float128); -extern int32_t float128_to_int32(float128); - -extern uint64_t float128_to_uint64(float128); -extern int64_t float128_to_int64(float128); - -extern float32 uint32_to_float32(uint32_t); -extern float32 int32_to_float32(int32_t); - -extern float32 uint64_to_float32(uint64_t); -extern float32 int64_to_float32(int64_t); - -extern float64 uint32_to_float64(uint32_t); -extern float64 int32_to_float64(int32_t); - -extern float64 uint64_to_float64(uint64_t); -extern float64 int64_to_float64(int64_t); - -extern float96 uint32_to_float96(uint32_t); -extern float96 int32_to_float96(int32_t); - -extern float96 uint64_to_float96(uint64_t); -extern float96 int64_to_float96(int64_t); - -extern float128 uint32_to_float128(uint32_t); -extern float128 int32_to_float128(int32_t); - -extern float128 uint64_to_float128(uint64_t); -extern float128 int64_to_float128(int64_t); - -#endif - -/** @} - */ Index: uspace/lib/softfloat/include/div.h =================================================================== --- uspace/lib/softfloat/include/div.h (revision 7aa6b99d7bd8a569a8bc3394901a26702aa2a5a9) +++ (revision ) @@ -1,47 +1,0 @@ -/* - * Copyright (c) 2005 Josef Cejka - * Copyright (c) 2011 Petr Koupy - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * - Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR - * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES - * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, - * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF - * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -/** @addtogroup softfloat - * @{ - */ -/** @file Division functions. - */ - -#ifndef __DIV_H__ -#define __DIV_H__ - -extern float32 div_float32(float32, float32); -extern float64 div_float64(float64, float64); -extern float96 div_float96(float96, float96); -extern float128 div_float128(float128, float128); - -#endif - -/** @} - */ Index: uspace/lib/softfloat/include/mul.h =================================================================== --- uspace/lib/softfloat/include/mul.h (revision 7aa6b99d7bd8a569a8bc3394901a26702aa2a5a9) +++ (revision ) @@ -1,47 +1,0 @@ -/* - * Copyright (c) 2005 Josef Cejka - * Copyright (c) 2011 Petr Koupy - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * - Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR - * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES - * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, - * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF - * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -/** @addtogroup softfloat - * @{ - */ -/** @file Multiplication functions. - */ - -#ifndef __MUL_H__ -#define __MUL_H__ - -extern float32 mul_float32(float32, float32); -extern float64 mul_float64(float64, float64); -extern float96 mul_float96(float96, float96); -extern float128 mul_float128(float128, float128); - -#endif - -/** @} - */ Index: uspace/lib/softfloat/include/other.h =================================================================== --- uspace/lib/softfloat/include/other.h (revision 7aa6b99d7bd8a569a8bc3394901a26702aa2a5a9) +++ (revision ) @@ -1,41 +1,0 @@ -/* - * Copyright (c) 2005 Josef Cejka - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * - Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR - * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES - * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, - * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF - * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -/** @addtogroup softfloat - * @{ - */ -/** @file Other functions (power, complex). - */ - -#ifndef __OTHER_H__ -#define __OTHER_H__ - -#endif - -/** @} - */ Index: uspace/lib/softfloat/include/sftypes.h =================================================================== --- uspace/lib/softfloat/include/sftypes.h (revision 7aa6b99d7bd8a569a8bc3394901a26702aa2a5a9) +++ (revision ) @@ -1,608 +1,0 @@ -/* - * Copyright (c) 2005 Josef Cejka - * Copyright (c) 2011 Petr Koupy - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * - Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR - * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES - * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, - * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF - * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -/** @addtogroup softfloat - * @{ - */ -/** @file Floating point types and constants. - */ - -#ifndef __SFTYPES_H__ -#define __SFTYPES_H__ - -#include -#include - -/* - * For recognizing NaNs or infinity use specialized comparison - * functions, comparing with these constants is not sufficient. - */ - -#define FLOAT32_NAN UINT32_C(0x7FC00001) -#define FLOAT32_SIGNAN UINT32_C(0x7F800001) -#define FLOAT32_INF UINT32_C(0x7F800000) - -#define FLOAT64_NAN UINT64_C(0x7FF8000000000001) -#define FLOAT64_SIGNAN UINT64_C(0x7FF0000000000001) -#define FLOAT64_INF UINT64_C(0x7FF0000000000000) - -#define FLOAT96_NAN_HI UINT64_C(0x7FFF80000000) -#define FLOAT96_NAN_LO UINT32_C(0x00010000) -#define FLOAT96_SIGNAN_HI UINT64_C(0x7FFF00000000) -#define FLOAT96_SIGNAN_LO UINT32_C(0x00010000) - -#define FLOAT128_NAN_HI UINT64_C(0x7FFF800000000000) -#define FLOAT128_NAN_LO UINT64_C(0x0000000000000001) -#define FLOAT128_SIGNAN_HI UINT64_C(0x7FFF000000000000) -#define FLOAT128_SIGNAN_LO UINT64_C(0x0000000000000001) -#define FLOAT128_INF_HI UINT64_C(0x7FFF000000000000) -#define FLOAT128_INF_LO UINT64_C(0x0000000000000000) - -#define FLOAT32_FRACTION_SIZE 23 -#define FLOAT64_FRACTION_SIZE 52 -#define FLOAT96_FRACTION_SIZE 64 -#define FLOAT128_FRACTION_SIZE 112 -#define FLOAT128_FRAC_HI_SIZE 48 -#define FLOAT128_FRAC_LO_SIZE 64 - -#define FLOAT32_HIDDEN_BIT_MASK UINT32_C(0x800000) -#define FLOAT64_HIDDEN_BIT_MASK UINT64_C(0x10000000000000) -#define FLOAT128_HIDDEN_BIT_MASK_HI UINT64_C(0x1000000000000) -#define FLOAT128_HIDDEN_BIT_MASK_LO UINT64_C(0x0000000000000000) - -#define FLOAT32_MAX_EXPONENT 0xFF -#define FLOAT64_MAX_EXPONENT 0x7FF -#define FLOAT96_MAX_EXPONENT 0x7FFF -#define FLOAT128_MAX_EXPONENT 0x7FFF - -#define FLOAT32_BIAS 0x7F -#define FLOAT64_BIAS 0x3FF -#define FLOAT96_BIAS 0x3FFF -#define FLOAT128_BIAS 0x3FFF - -#if defined(__BE__) - -typedef union { - uint32_t bin; - - struct { - uint32_t sign : 1; - uint32_t exp : 8; - uint32_t fraction : 23; - } parts __attribute__((packed)); -} float32; - -typedef union { - uint64_t bin; - - struct { - uint64_t sign : 1; - uint64_t exp : 11; - uint64_t fraction : 52; - } parts __attribute__((packed)); -} float64; - -typedef union { - struct { - uint64_t hi; - uint32_t lo; - } bin __attribute__((packed)); - - struct { - uint64_t padding : 16; - uint64_t sign : 1; - uint64_t exp : 15; - uint64_t fraction : 64; - } parts __attribute__((packed)); -} float96; - -typedef union { - struct { - uint64_t hi; - uint64_t lo; - } bin __attribute__((packed)); - - struct { - uint64_t sign : 1; - uint64_t exp : 15; - uint64_t frac_hi : 48; - uint64_t frac_lo : 64; - } parts __attribute__((packed)); -} float128; - -#elif defined(__LE__) - -typedef union { - uint32_t bin; - - struct { - uint32_t fraction : 23; - uint32_t exp : 8; - uint32_t sign : 1; - } parts __attribute__((packed)); -} float32; - -typedef union { - uint64_t bin; - - struct { - uint64_t fraction : 52; - uint64_t exp : 11; - uint64_t sign : 1; - } parts __attribute__((packed)); -} float64; - -typedef union { - struct { - uint32_t lo; - uint64_t hi; - } bin __attribute__((packed)); - - struct { - uint64_t fraction : 64; - uint64_t exp : 15; - uint64_t sign : 1; - uint64_t padding : 16; - } parts __attribute__((packed)); -} float96; - -typedef union { - struct { - uint64_t lo; - uint64_t hi; - } bin __attribute__((packed)); - - struct { - uint64_t frac_lo : 64; - uint64_t frac_hi : 48; - uint64_t exp : 15; - uint64_t sign : 1; - } parts __attribute__((packed)); -} float128; - -#else - #error Unknown endianess -#endif - -typedef union { - float val; - -#if defined(FLOAT_SIZE_32) - float32 data; -#elif defined(FLOAT_SIZE_64) - float64 data; -#elif defined(FLOAT_SIZE_96) - float96 data; -#elif defined(FLOAT_SIZE_128) - float128 data; -#else - #error Unsupported float size -#endif -} float_t; - -typedef union { - double val; - -#if defined(DOUBLE_SIZE_32) - float32 data; -#elif defined(DOUBLE_SIZE_64) - float64 data; -#elif defined(DOUBLE_SIZE_96) - float96 data; -#elif defined(DOUBLE_SIZE_128) - float128 data; -#else - #error Unsupported double size -#endif -} double_t; - -typedef union { - long double val; - -#if defined(LONG_DOUBLE_SIZE_32) - float32 data; -#elif defined(LONG_DOUBLE_SIZE_64) - float64 data; -#elif defined(LONG_DOUBLE_SIZE_96) - float96 data; -#elif defined(LONG_DOUBLE_SIZE_128) - float128 data; -#else - #error Unsupported long double size -#endif -} long_double_t; - - -#if defined(INT_SIZE_8) - -#define _to_int _to_int8 -#define from_int int8 - -#elif defined(INT_SIZE_16) - -#define _to_int _to_int16 -#define from_int int16 - -#elif defined(INT_SIZE_32) - -#define _to_int _to_int32 -#define from_int int32 - -#elif defined(INT_SIZE_64) - -#define _to_int _to_int64 -#define from_int int64 - -#endif - - -#if defined(UINT_SIZE_8) - -#define _to_uint _to_uint8 -#define from_uint uint8 - -#elif defined(UINT_SIZE_16) - -#define _to_uint _to_uint16 -#define from_uint uint16 - -#elif defined(UINT_SIZE_32) - -#define _to_uint _to_uint32 -#define from_uint uint32 - -#elif defined(UINT_SIZE_64) - -#define _to_uint _to_uint64 -#define from_uint uint64 - -#endif - - -#if defined(LONG_SIZE_8) - -#define _to_long _to_int8 -#define from_long int8 - -#elif defined(LONG_SIZE_16) - -#define _to_long _to_int16 -#define from_long int16 - -#elif defined(LONG_SIZE_32) - -#define _to_long _to_int32 -#define from_long int32 - -#elif defined(LONG_SIZE_64) - -#define _to_long _to_int64 -#define from_long int64 - -#endif - - -#if defined(ULONG_SIZE_8) - -#define _to_ulong _to_uint8 -#define from_ulong uint8 - -#elif defined(ULONG_SIZE_16) - -#define _to_ulong _to_uint16 -#define from_ulong uint16 - -#elif defined(ULONG_SIZE_32) - -#define _to_ulong _to_uint32 -#define from_ulong uint32 - -#elif defined(ULONG_SIZE_64) - -#define _to_ulong _to_uint64 -#define from_ulong uint64 - -#endif - - -#if defined(LLONG_SIZE_8) - -#define _to_llong _to_int8 -#define from_llong int8 - -#elif defined(LLONG_SIZE_16) - -#define _to_llong _to_int16 -#define from_llong int16 - -#elif defined(LLONG_SIZE_32) - -#define _to_llong _to_int32 -#define from_llong int32 - -#elif defined(LLONG_SIZE_64) - -#define _to_llong _to_int64 -#define from_llong int64 - -#endif - - -#if defined(ULLONG_SIZE_8) - -#define _to_ullong _to_uint8 -#define from_ullong uint8 - -#elif defined(ULLONG_SIZE_16) - -#define _to_ullong _to_uint16 -#define from_ullong uint16 - -#elif defined(ULLONG_SIZE_32) - -#define _to_ullong _to_uint32 -#define from_ullong uint32 - -#elif defined(ULLONG_SIZE_64) - -#define _to_ullong _to_uint64 -#define from_ullong uint64 - -#endif - - -#if defined(FLOAT_SIZE_32) - -#define add_float add_float32 -#define sub_float sub_float32 -#define mul_float mul_float32 -#define div_float div_float32 -#define _to_float _to_float32 -#define from_float float32 -#define is_float_nan is_float32_nan -#define is_float_eq is_float32_eq -#define is_float_lt is_float32_lt -#define is_float_gt is_float32_gt - -#elif defined(FLOAT_SIZE_64) - -#define add_float add_float64 -#define sub_float sub_float64 -#define mul_float mul_float64 -#define div_float div_float64 -#define _to_float _to_float64 -#define from_float float64 -#define is_float_nan is_float64_nan -#define is_float_eq is_float64_eq -#define is_float_lt is_float64_lt -#define is_float_gt is_float64_gt - -#elif defined(FLOAT_SIZE_96) - -#define add_float add_float96 -#define sub_float sub_float96 -#define mul_float mul_float96 -#define div_float div_float96 -#define _to_float _to_float96 -#define from_float float96 -#define is_float_nan is_float96_nan -#define is_float_eq is_float96_eq -#define is_float_lt is_float96_lt -#define is_float_gt is_float96_gt - -#elif defined(FLOAT_SIZE_128) - -#define add_float add_float128 -#define sub_float sub_float128 -#define mul_float mul_float128 -#define div_float div_float128 -#define _to_float _to_float128 -#define from_float float128 -#define is_float_nan is_float128_nan -#define is_float_eq is_float128_eq -#define is_float_lt is_float128_lt -#define is_float_gt is_float128_gt - -#endif - - -#if defined(DOUBLE_SIZE_32) - -#define add_double add_float32 -#define sub_double sub_float32 -#define mul_double mul_float32 -#define div_double div_float32 -#define _to_double _to_float32 -#define from_double float32 -#define is_double_nan is_float32_nan -#define is_double_eq is_float32_eq -#define is_double_lt is_float32_lt -#define is_double_gt is_float32_gt - -#elif defined(DOUBLE_SIZE_64) - -#define add_double add_float64 -#define sub_double sub_float64 -#define mul_double mul_float64 -#define div_double div_float64 -#define _to_double _to_float64 -#define from_double float64 -#define is_double_nan is_float64_nan -#define is_double_eq is_float64_eq -#define is_double_lt is_float64_lt -#define is_double_gt is_float64_gt - -#elif defined(DOUBLE_SIZE_96) - -#define add_double add_float96 -#define sub_double sub_float96 -#define mul_double mul_float96 -#define div_double div_float96 -#define _to_double _to_float96 -#define from_double float96 -#define is_double_nan is_float96_nan -#define is_double_eq is_float96_eq -#define is_double_lt is_float96_lt -#define is_double_gt is_float96_gt - -#elif defined(DOUBLE_SIZE_128) - -#define add_double add_float128 -#define sub_double sub_float128 -#define mul_double mul_float128 -#define div_double div_float128 -#define _to_double _to_float128 -#define from_double float128 -#define is_double_nan is_float128_nan -#define is_double_eq is_float128_eq -#define is_double_lt is_float128_lt -#define is_double_gt is_float128_gt - -#endif - - -#if defined(LONG_DOUBLE_SIZE_32) - -#define add_long_double add_float32 -#define sub_long_double sub_float32 -#define mul_long_double mul_float32 -#define div_long_double div_float32 -#define _to_long_double _to_float32 -#define from_long_double float32 -#define is_long_double_nan is_float32_nan -#define is_long_double_eq is_float32_eq -#define is_long_double_lt is_float32_lt -#define is_long_double_gt is_float32_gt - -#elif defined(LONG_DOUBLE_SIZE_64) - -#define add_long_double add_float64 -#define sub_long_double sub_float64 -#define mul_long_double mul_float64 -#define div_long_double div_float64 -#define _to_long_double _to_float64 -#define from_long_double float64 -#define is_long_double_nan is_float64_nan -#define is_long_double_eq is_float64_eq -#define is_long_double_lt is_float64_lt -#define is_long_double_gt is_float64_gt - -#elif defined(LONG_DOUBLE_SIZE_96) - -#define add_long_double add_float96 -#define sub_long_double sub_float96 -#define mul_long_double mul_float96 -#define div_long_double div_float96 -#define _to_long_double _to_float96 -#define from_long_double float96 -#define is_long_double_nan is_float96_nan -#define is_long_double_eq is_float96_eq -#define is_long_double_lt is_float96_lt -#define is_long_double_gt is_float96_gt - -#elif defined(LONG_DOUBLE_SIZE_128) - -#define add_long_double add_float128 -#define sub_long_double sub_float128 -#define mul_long_double mul_float128 -#define div_long_double div_float128 -#define _to_long_double _to_float128 -#define from_long_double float128 -#define is_long_double_nan is_float128_nan -#define is_long_double_eq is_float128_eq -#define is_long_double_lt is_float128_lt -#define is_long_double_gt is_float128_gt - -#endif - - -#define CONCAT(a, b) CONCAT_ARGS(a, b) -#define CONCAT_ARGS(a, b) a ## b - -#define float32_to_float32(arg) (arg) -#define float64_to_float64(arg) (arg) -#define float96_to_float96(arg) (arg) -#define float128_to_float128(arg) (arg) - -#define float_to_double CONCAT(from_float, _to_double) -#define float_to_long_double CONCAT(from_float, _to_long_double) -#define float_to_int CONCAT(from_float, _to_int) -#define float_to_uint CONCAT(from_float, _to_uint) -#define float_to_long CONCAT(from_float, _to_long) -#define float_to_ulong CONCAT(from_float, _to_ulong) -#define float_to_llong CONCAT(from_float, _to_llong) -#define float_to_ullong CONCAT(from_float, _to_ullong) - -#define double_to_float CONCAT(from_double, _to_float) -#define double_to_long_double CONCAT(from_double, _to_long_double) -#define double_to_int CONCAT(from_double, _to_int) -#define double_to_uint CONCAT(from_double, _to_uint) -#define double_to_long CONCAT(from_double, _to_long) -#define double_to_ulong CONCAT(from_double, _to_ulong) -#define double_to_llong CONCAT(from_double, _to_llong) -#define double_to_ullong CONCAT(from_double, _to_ullong) - -#define long_double_to_float CONCAT(from_long_double, _to_float) -#define long_double_to_double CONCAT(from_long_double, _to_double) -#define long_double_to_int CONCAT(from_long_double, _to_int) -#define long_double_to_uint CONCAT(from_long_double, _to_uint) -#define long_double_to_long CONCAT(from_long_double, _to_long) -#define long_double_to_ulong CONCAT(from_long_double, _to_ulong) -#define long_double_to_llong CONCAT(from_long_double, _to_llong) -#define long_double_to_ullong CONCAT(from_long_double, _to_ullong) - -#define int_to_float CONCAT(from_int, _to_float) -#define int_to_double CONCAT(from_int, _to_double) -#define int_to_long_double CONCAT(from_int, _to_long_double) - -#define uint_to_float CONCAT(from_uint, _to_float) -#define uint_to_double CONCAT(from_uint, _to_double) -#define uint_to_long_double CONCAT(from_uint, _to_long_double) - -#define long_to_float CONCAT(from_long, _to_float) -#define long_to_double CONCAT(from_long, _to_double) -#define long_to_long_double CONCAT(from_long, _to_long_double) - -#define ulong_to_float CONCAT(from_ulong, _to_float) -#define ulong_to_double CONCAT(from_ulong, _to_double) -#define ulong_to_long_double CONCAT(from_ulong, _to_long_double) - -#define llong_to_float CONCAT(from_llong, _to_float) -#define llong_to_double CONCAT(from_llong, _to_double) -#define llong_to_long_double CONCAT(from_llong, _to_long_double) - -#define ullong_to_float CONCAT(from_ullong, _to_float) -#define ullong_to_double CONCAT(from_ullong, _to_double) -#define ullong_to_long_double CONCAT(from_ullong, _to_long_double) - - -#endif - -/** @} - */ Index: uspace/lib/softfloat/include/softfloat.h =================================================================== --- uspace/lib/softfloat/include/softfloat.h (revision 7aa6b99d7bd8a569a8bc3394901a26702aa2a5a9) +++ (revision ) @@ -1,226 +1,0 @@ -/* - * Copyright (c) 2005 Josef Cejka - * Copyright (c) 2011 Petr Koupy - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * - Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR - * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES - * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, - * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF - * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -/** @addtogroup softfloat - * @{ - */ -/** @file Softfloat API. - */ - -#ifndef __SOFTFLOAT_H__ -#define __SOFTFLOAT_H__ - -extern float __addsf3(float, float); -extern double __adddf3(double, double); -extern long double __addtf3(long double, long double); -extern long double __addxf3(long double, long double); - -extern float __subsf3(float, float); -extern double __subdf3(double, double); -extern long double __subtf3(long double, long double); -extern long double __subxf3(long double, long double); - -extern float __mulsf3(float, float); -extern double __muldf3(double, double); -extern long double __multf3(long double, long double); -extern long double __mulxf3(long double, long double); - -extern float __divsf3(float, float); -extern double __divdf3(double, double); -extern long double __divtf3(long double, long double); -extern long double __divxf3(long double, long double); - -extern float __negsf2(float); -extern double __negdf2(double); -extern long double __negtf2(long double); -extern long double __negxf2(long double); - -extern double __extendsfdf2(float); -extern long double __extendsftf2(float); -extern long double __extendsfxf2(float); -extern long double __extenddftf2(double); -extern long double __extenddfxf2(double); - -extern double __truncxfdf2(long double); -extern double __trunctfdf2(long double); -extern float __truncxfsf2(long double); -extern float __trunctfsf2(long double); -extern float __truncdfsf2(double); - -extern int __fixsfsi(float); -extern int __fixdfsi(double); -extern int __fixtfsi(long double); -extern int __fixxfsi(long double); - -extern long __fixsfdi(float); -extern long __fixdfdi(double); -extern long __fixtfdi(long double); -extern long __fixxfdi(long double); - -extern long long __fixsfti(float); -extern long long __fixdfti(double); -extern long long __fixtfti(long double); -extern long long __fixxfti(long double); - -extern unsigned int __fixunssfsi(float); -extern unsigned int __fixunsdfsi(double); -extern unsigned int __fixunstfsi(long double); -extern unsigned int __fixunsxfsi(long double); - -extern unsigned long __fixunssfdi(float); -extern unsigned long __fixunsdfdi(double); -extern unsigned long __fixunstfdi(long double); -extern unsigned long __fixunsxfdi(long double); - -extern unsigned long long __fixunssfti(float); -extern unsigned long long __fixunsdfti(double); -extern unsigned long long __fixunstfti(long double); -extern unsigned long long __fixunsxfti(long double); - -extern float __floatsisf(int); -extern double __floatsidf(int); -extern long double __floatsitf(int); -extern long double __floatsixf(int); - -extern float __floatdisf(long); -extern double __floatdidf(long); -extern long double __floatditf(long); -extern long double __floatdixf(long); - -extern float __floattisf(long long); -extern double __floattidf(long long); -extern long double __floattitf(long long); -extern long double __floattixf(long long); - -extern float __floatunsisf(unsigned int); -extern double __floatunsidf(unsigned int); -extern long double __floatunsitf(unsigned int); -extern long double __floatunsixf(unsigned int); - -extern float __floatundisf(unsigned long); -extern double __floatundidf(unsigned long); -extern long double __floatunditf(unsigned long); -extern long double __floatundixf(unsigned long); - -extern float __floatuntisf(unsigned long long); -extern double __floatuntidf(unsigned long long); -extern long double __floatuntitf(unsigned long long); -extern long double __floatuntixf(unsigned long long); - -extern int __cmpsf2(float, float); -extern int __cmpdf2(double, double); -extern int __cmptf2(long double, long double); - -extern int __unordsf2(float, float); -extern int __unorddf2(double, double); -extern int __unordtf2(long double, long double); - -extern int __eqsf2(float, float); -extern int __eqdf2(double, double); -extern int __eqtf2(long double, long double); - -extern int __nesf2(float, float); -extern int __nedf2(double, double); -extern int __netf2(long double, long double); - -extern int __gesf2(float, float); -extern int __gedf2(double, double); -extern int __getf2(long double, long double); - -extern int __ltsf2(float, float); -extern int __ltdf2(double, double); -extern int __lttf2(long double, long double); - -extern int __lesf2(float, float); -extern int __ledf2(double, double); -extern int __letf2(long double, long double); - -extern int __gtsf2(float, float); -extern int __gtdf2(double, double); -extern int __gttf2(long double, long double); - -/* Not implemented yet */ -extern float __powisf2(float, int); -extern double __powidf2 (double, int); -extern long double __powitf2(long double, int); -extern long double __powixf2(long double, int); - -/* SPARC quadruple-precision wrappers */ -extern void _Qp_add(long double *, long double *, long double *); -extern void _Qp_sub(long double *, long double *, long double *); -extern void _Qp_mul(long double *, long double *, long double *); -extern void _Qp_div(long double *, long double *, long double *); -extern void _Qp_neg(long double *, long double *); - -extern void _Qp_stoq(long double *, float); -extern void _Qp_dtoq(long double *, double); -extern float _Qp_qtos(long double *); -extern double _Qp_qtod(long double *); - -extern int _Qp_qtoi(long double *); -extern unsigned int _Qp_qtoui(long double *); -extern long _Qp_qtox(long double *); -extern unsigned long _Qp_qtoux(long double *); - -extern void _Qp_itoq(long double *, int); -extern void _Qp_uitoq(long double *, unsigned int); -extern void _Qp_xtoq(long double *, long); -extern void _Qp_uxtoq(long double *, unsigned long); - -extern int _Qp_cmp(long double *, long double *); -extern int _Qp_cmpe(long double *, long double *); -extern int _Qp_feq(long double *, long double *); -extern int _Qp_fge(long double *, long double *); -extern int _Qp_fgt(long double *, long double *); -extern int _Qp_fle(long double*, long double *); -extern int _Qp_flt(long double *, long double *); -extern int _Qp_fne(long double *, long double *); - -/* ARM EABI */ -extern double __aeabi_i2d(int); -extern double __aeabi_ui2d(unsigned int); -extern unsigned int __aeabi_d2uiz(double); -extern int __aeabi_d2iz(double); - -extern int __aeabi_dcmpge(double, double); -extern int __aeabi_dcmpgt(double, double); -extern int __aeabi_dcmplt(double, double); - -extern double __aeabi_dadd(double, double); -extern double __aeabi_dsub(double, double); -extern double __aeabi_dmul(double, double); -extern double __aeabi_ddiv(double, double); - -/* Not implemented yet */ -extern void _Qp_sqrt(long double *, long double *); - -#endif - -/** @} - */ Index: uspace/lib/softfloat/include/sub.h =================================================================== --- uspace/lib/softfloat/include/sub.h (revision 7aa6b99d7bd8a569a8bc3394901a26702aa2a5a9) +++ (revision ) @@ -1,47 +1,0 @@ -/* - * Copyright (c) 2005 Josef Cejka - * Copyright (c) 2011 Petr Koupy - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * - Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR - * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES - * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, - * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF - * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -/** @addtogroup softfloat - * @{ - */ -/** @file Substraction functions. - */ - -#ifndef __SUB_H__ -#define __SUB_H__ - -extern float32 sub_float32(float32, float32); -extern float64 sub_float64(float64, float64); -extern float96 sub_float96(float96, float96); -extern float128 sub_float128(float128, float128); - -#endif - -/** @} - */ Index: uspace/lib/softfloat/mul.c =================================================================== --- uspace/lib/softfloat/mul.c (revision 1dbd189b0e98a0f835bd872d52126bb32e841feb) +++ uspace/lib/softfloat/mul.c (revision 1dbd189b0e98a0f835bd872d52126bb32e841feb) @@ -0,0 +1,383 @@ +/* + * Copyright (c) 2005 Josef Cejka + * Copyright (c) 2011 Petr Koupy + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup softfloat + * @{ + */ +/** @file Multiplication functions. + */ + +#include "sftypes.h" +#include "mul.h" +#include "comparison.h" +#include "common.h" + +/** Multiply two single-precision floats. + * + * @param a First input operand. + * @param b Second input operand. + * + * @return Result of multiplication. + * + */ +float32 mul_float32(float32 a, float32 b) +{ + float32 result; + uint64_t frac1, frac2; + int32_t exp; + + result.parts.sign = a.parts.sign ^ b.parts.sign; + + if (is_float32_nan(a) || is_float32_nan(b)) { + /* TODO: fix SigNaNs */ + if (is_float32_signan(a)) { + result.parts.fraction = a.parts.fraction; + result.parts.exp = a.parts.exp; + return result; + } + if (is_float32_signan(b)) { /* TODO: fix SigNaN */ + result.parts.fraction = b.parts.fraction; + result.parts.exp = b.parts.exp; + return result; + } + /* set NaN as result */ + result.bin = FLOAT32_NAN; + return result; + } + + if (is_float32_infinity(a)) { + if (is_float32_zero(b)) { + /* FIXME: zero * infinity */ + result.bin = FLOAT32_NAN; + return result; + } + result.parts.fraction = a.parts.fraction; + result.parts.exp = a.parts.exp; + return result; + } + + if (is_float32_infinity(b)) { + if (is_float32_zero(a)) { + /* FIXME: zero * infinity */ + result.bin = FLOAT32_NAN; + return result; + } + result.parts.fraction = b.parts.fraction; + result.parts.exp = b.parts.exp; + return result; + } + + /* exp is signed so we can easy detect underflow */ + exp = a.parts.exp + b.parts.exp; + exp -= FLOAT32_BIAS; + + if (exp >= FLOAT32_MAX_EXPONENT) { + /* FIXME: overflow */ + /* set infinity as result */ + result.bin = FLOAT32_INF; + result.parts.sign = a.parts.sign ^ b.parts.sign; + return result; + } + + if (exp < 0) { + /* FIXME: underflow */ + /* return signed zero */ + result.parts.fraction = 0x0; + result.parts.exp = 0x0; + return result; + } + + frac1 = a.parts.fraction; + if (a.parts.exp > 0) { + frac1 |= FLOAT32_HIDDEN_BIT_MASK; + } else { + ++exp; + } + + frac2 = b.parts.fraction; + + if (b.parts.exp > 0) { + frac2 |= FLOAT32_HIDDEN_BIT_MASK; + } else { + ++exp; + } + + frac1 <<= 1; /* one bit space for rounding */ + + frac1 = frac1 * frac2; + + /* round and return */ + while ((exp < FLOAT32_MAX_EXPONENT) && + (frac1 >= (1 << (FLOAT32_FRACTION_SIZE + 2)))) { + /* 23 bits of fraction + one more for hidden bit (all shifted 1 bit left) */ + ++exp; + frac1 >>= 1; + } + + /* rounding */ + /* ++frac1; FIXME: not works - without it is ok */ + frac1 >>= 1; /* shift off rounding space */ + + if ((exp < FLOAT32_MAX_EXPONENT) && + (frac1 >= (1 << (FLOAT32_FRACTION_SIZE + 1)))) { + ++exp; + frac1 >>= 1; + } + + if (exp >= FLOAT32_MAX_EXPONENT) { + /* TODO: fix overflow */ + /* return infinity*/ + result.parts.exp = FLOAT32_MAX_EXPONENT; + result.parts.fraction = 0x0; + return result; + } + + exp -= FLOAT32_FRACTION_SIZE; + + if (exp <= FLOAT32_FRACTION_SIZE) { + /* denormalized number */ + frac1 >>= 1; /* denormalize */ + while ((frac1 > 0) && (exp < 0)) { + frac1 >>= 1; + ++exp; + } + if (frac1 == 0) { + /* FIXME : underflow */ + result.parts.exp = 0; + result.parts.fraction = 0; + return result; + } + } + result.parts.exp = exp; + result.parts.fraction = frac1 & ((1 << FLOAT32_FRACTION_SIZE) - 1); + + return result; +} + +/** Multiply two double-precision floats. + * + * @param a First input operand. + * @param b Second input operand. + * + * @return Result of multiplication. + * + */ +float64 mul_float64(float64 a, float64 b) +{ + float64 result; + uint64_t frac1, frac2; + int32_t exp; + + result.parts.sign = a.parts.sign ^ b.parts.sign; + + if (is_float64_nan(a) || is_float64_nan(b)) { + /* TODO: fix SigNaNs */ + if (is_float64_signan(a)) { + result.parts.fraction = a.parts.fraction; + result.parts.exp = a.parts.exp; + return result; + } + if (is_float64_signan(b)) { /* TODO: fix SigNaN */ + result.parts.fraction = b.parts.fraction; + result.parts.exp = b.parts.exp; + return result; + } + /* set NaN as result */ + result.bin = FLOAT64_NAN; + return result; + } + + if (is_float64_infinity(a)) { + if (is_float64_zero(b)) { + /* FIXME: zero * infinity */ + result.bin = FLOAT64_NAN; + return result; + } + result.parts.fraction = a.parts.fraction; + result.parts.exp = a.parts.exp; + return result; + } + + if (is_float64_infinity(b)) { + if (is_float64_zero(a)) { + /* FIXME: zero * infinity */ + result.bin = FLOAT64_NAN; + return result; + } + result.parts.fraction = b.parts.fraction; + result.parts.exp = b.parts.exp; + return result; + } + + /* exp is signed so we can easy detect underflow */ + exp = a.parts.exp + b.parts.exp - FLOAT64_BIAS; + + frac1 = a.parts.fraction; + + if (a.parts.exp > 0) { + frac1 |= FLOAT64_HIDDEN_BIT_MASK; + } else { + ++exp; + } + + frac2 = b.parts.fraction; + + if (b.parts.exp > 0) { + frac2 |= FLOAT64_HIDDEN_BIT_MASK; + } else { + ++exp; + } + + frac1 <<= (64 - FLOAT64_FRACTION_SIZE - 1); + frac2 <<= (64 - FLOAT64_FRACTION_SIZE - 2); + + mul64(frac1, frac2, &frac1, &frac2); + + frac1 |= (frac2 != 0); + if (frac1 & (0x1ll << 62)) { + frac1 <<= 1; + exp--; + } + + result = finish_float64(exp, frac1, result.parts.sign); + return result; +} + +/** Multiply two quadruple-precision floats. + * + * @param a First input operand. + * @param b Second input operand. + * + * @return Result of multiplication. + * + */ +float128 mul_float128(float128 a, float128 b) +{ + float128 result; + uint64_t frac1_hi, frac1_lo, frac2_hi, frac2_lo, tmp_hi, tmp_lo; + int32_t exp; + + result.parts.sign = a.parts.sign ^ b.parts.sign; + + if (is_float128_nan(a) || is_float128_nan(b)) { + /* TODO: fix SigNaNs */ + if (is_float128_signan(a)) { + result.parts.frac_hi = a.parts.frac_hi; + result.parts.frac_lo = a.parts.frac_lo; + result.parts.exp = a.parts.exp; + return result; + } + if (is_float128_signan(b)) { /* TODO: fix SigNaN */ + result.parts.frac_hi = b.parts.frac_hi; + result.parts.frac_lo = b.parts.frac_lo; + result.parts.exp = b.parts.exp; + return result; + } + /* set NaN as result */ + result.bin.hi = FLOAT128_NAN_HI; + result.bin.lo = FLOAT128_NAN_LO; + return result; + } + + if (is_float128_infinity(a)) { + if (is_float128_zero(b)) { + /* FIXME: zero * infinity */ + result.bin.hi = FLOAT128_NAN_HI; + result.bin.lo = FLOAT128_NAN_LO; + return result; + } + result.parts.frac_hi = a.parts.frac_hi; + result.parts.frac_lo = a.parts.frac_lo; + result.parts.exp = a.parts.exp; + return result; + } + + if (is_float128_infinity(b)) { + if (is_float128_zero(a)) { + /* FIXME: zero * infinity */ + result.bin.hi = FLOAT128_NAN_HI; + result.bin.lo = FLOAT128_NAN_LO; + return result; + } + result.parts.frac_hi = b.parts.frac_hi; + result.parts.frac_lo = b.parts.frac_lo; + result.parts.exp = b.parts.exp; + return result; + } + + /* exp is signed so we can easy detect underflow */ + exp = a.parts.exp + b.parts.exp - FLOAT128_BIAS - 1; + + frac1_hi = a.parts.frac_hi; + frac1_lo = a.parts.frac_lo; + + if (a.parts.exp > 0) { + or128(frac1_hi, frac1_lo, + FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO, + &frac1_hi, &frac1_lo); + } else { + ++exp; + } + + frac2_hi = b.parts.frac_hi; + frac2_lo = b.parts.frac_lo; + + if (b.parts.exp > 0) { + or128(frac2_hi, frac2_lo, + FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO, + &frac2_hi, &frac2_lo); + } else { + ++exp; + } + + lshift128(frac2_hi, frac2_lo, + 128 - FLOAT128_FRACTION_SIZE, &frac2_hi, &frac2_lo); + + tmp_hi = frac1_hi; + tmp_lo = frac1_lo; + mul128(frac1_hi, frac1_lo, frac2_hi, frac2_lo, + &frac1_hi, &frac1_lo, &frac2_hi, &frac2_lo); + add128(frac1_hi, frac1_lo, tmp_hi, tmp_lo, &frac1_hi, &frac1_lo); + frac2_hi |= (frac2_lo != 0x0ll); + + if ((FLOAT128_HIDDEN_BIT_MASK_HI << 1) <= frac1_hi) { + frac2_hi >>= 1; + if (frac1_lo & 0x1ll) { + frac2_hi |= (0x1ull < 64); + } + rshift128(frac1_hi, frac1_lo, 1, &frac1_hi, &frac1_lo); + ++exp; + } + + result = finish_float128(exp, frac1_hi, frac1_lo, result.parts.sign, frac2_hi); + return result; +} + +/** @} + */ Index: uspace/lib/softfloat/mul.h =================================================================== --- uspace/lib/softfloat/mul.h (revision 1dbd189b0e98a0f835bd872d52126bb32e841feb) +++ uspace/lib/softfloat/mul.h (revision 1dbd189b0e98a0f835bd872d52126bb32e841feb) @@ -0,0 +1,47 @@ +/* + * Copyright (c) 2005 Josef Cejka + * Copyright (c) 2011 Petr Koupy + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup softfloat + * @{ + */ +/** @file Multiplication functions. + */ + +#ifndef __MUL_H__ +#define __MUL_H__ + +extern float32 mul_float32(float32, float32); +extern float64 mul_float64(float64, float64); +extern float96 mul_float96(float96, float96); +extern float128 mul_float128(float128, float128); + +#endif + +/** @} + */ Index: uspace/lib/softfloat/other.c =================================================================== --- uspace/lib/softfloat/other.c (revision 1dbd189b0e98a0f835bd872d52126bb32e841feb) +++ uspace/lib/softfloat/other.c (revision 1dbd189b0e98a0f835bd872d52126bb32e841feb) @@ -0,0 +1,37 @@ +/* + * Copyright (c) 2005 Josef Cejka + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup softfloat + * @{ + */ +/** @file Other functions (power, complex). + */ + + +/** @} + */ Index: uspace/lib/softfloat/other.h =================================================================== --- uspace/lib/softfloat/other.h (revision 1dbd189b0e98a0f835bd872d52126bb32e841feb) +++ uspace/lib/softfloat/other.h (revision 1dbd189b0e98a0f835bd872d52126bb32e841feb) @@ -0,0 +1,41 @@ +/* + * Copyright (c) 2005 Josef Cejka + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup softfloat + * @{ + */ +/** @file Other functions (power, complex). + */ + +#ifndef __OTHER_H__ +#define __OTHER_H__ + +#endif + +/** @} + */ Index: uspace/lib/softfloat/sftypes.h =================================================================== --- uspace/lib/softfloat/sftypes.h (revision 1dbd189b0e98a0f835bd872d52126bb32e841feb) +++ uspace/lib/softfloat/sftypes.h (revision 1dbd189b0e98a0f835bd872d52126bb32e841feb) @@ -0,0 +1,608 @@ +/* + * Copyright (c) 2005 Josef Cejka + * Copyright (c) 2011 Petr Koupy + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup softfloat + * @{ + */ +/** @file Floating point types and constants. + */ + +#ifndef __SFTYPES_H__ +#define __SFTYPES_H__ + +#include +#include + +/* + * For recognizing NaNs or infinity use specialized comparison + * functions, comparing with these constants is not sufficient. + */ + +#define FLOAT32_NAN UINT32_C(0x7FC00001) +#define FLOAT32_SIGNAN UINT32_C(0x7F800001) +#define FLOAT32_INF UINT32_C(0x7F800000) + +#define FLOAT64_NAN UINT64_C(0x7FF8000000000001) +#define FLOAT64_SIGNAN UINT64_C(0x7FF0000000000001) +#define FLOAT64_INF UINT64_C(0x7FF0000000000000) + +#define FLOAT96_NAN_HI UINT64_C(0x7FFF80000000) +#define FLOAT96_NAN_LO UINT32_C(0x00010000) +#define FLOAT96_SIGNAN_HI UINT64_C(0x7FFF00000000) +#define FLOAT96_SIGNAN_LO UINT32_C(0x00010000) + +#define FLOAT128_NAN_HI UINT64_C(0x7FFF800000000000) +#define FLOAT128_NAN_LO UINT64_C(0x0000000000000001) +#define FLOAT128_SIGNAN_HI UINT64_C(0x7FFF000000000000) +#define FLOAT128_SIGNAN_LO UINT64_C(0x0000000000000001) +#define FLOAT128_INF_HI UINT64_C(0x7FFF000000000000) +#define FLOAT128_INF_LO UINT64_C(0x0000000000000000) + +#define FLOAT32_FRACTION_SIZE 23 +#define FLOAT64_FRACTION_SIZE 52 +#define FLOAT96_FRACTION_SIZE 64 +#define FLOAT128_FRACTION_SIZE 112 +#define FLOAT128_FRAC_HI_SIZE 48 +#define FLOAT128_FRAC_LO_SIZE 64 + +#define FLOAT32_HIDDEN_BIT_MASK UINT32_C(0x800000) +#define FLOAT64_HIDDEN_BIT_MASK UINT64_C(0x10000000000000) +#define FLOAT128_HIDDEN_BIT_MASK_HI UINT64_C(0x1000000000000) +#define FLOAT128_HIDDEN_BIT_MASK_LO UINT64_C(0x0000000000000000) + +#define FLOAT32_MAX_EXPONENT 0xFF +#define FLOAT64_MAX_EXPONENT 0x7FF +#define FLOAT96_MAX_EXPONENT 0x7FFF +#define FLOAT128_MAX_EXPONENT 0x7FFF + +#define FLOAT32_BIAS 0x7F +#define FLOAT64_BIAS 0x3FF +#define FLOAT96_BIAS 0x3FFF +#define FLOAT128_BIAS 0x3FFF + +#if defined(__BE__) + +typedef union { + uint32_t bin; + + struct { + uint32_t sign : 1; + uint32_t exp : 8; + uint32_t fraction : 23; + } parts __attribute__((packed)); +} float32; + +typedef union { + uint64_t bin; + + struct { + uint64_t sign : 1; + uint64_t exp : 11; + uint64_t fraction : 52; + } parts __attribute__((packed)); +} float64; + +typedef union { + struct { + uint64_t hi; + uint32_t lo; + } bin __attribute__((packed)); + + struct { + uint64_t padding : 16; + uint64_t sign : 1; + uint64_t exp : 15; + uint64_t fraction : 64; + } parts __attribute__((packed)); +} float96; + +typedef union { + struct { + uint64_t hi; + uint64_t lo; + } bin __attribute__((packed)); + + struct { + uint64_t sign : 1; + uint64_t exp : 15; + uint64_t frac_hi : 48; + uint64_t frac_lo : 64; + } parts __attribute__((packed)); +} float128; + +#elif defined(__LE__) + +typedef union { + uint32_t bin; + + struct { + uint32_t fraction : 23; + uint32_t exp : 8; + uint32_t sign : 1; + } parts __attribute__((packed)); +} float32; + +typedef union { + uint64_t bin; + + struct { + uint64_t fraction : 52; + uint64_t exp : 11; + uint64_t sign : 1; + } parts __attribute__((packed)); +} float64; + +typedef union { + struct { + uint32_t lo; + uint64_t hi; + } bin __attribute__((packed)); + + struct { + uint64_t fraction : 64; + uint64_t exp : 15; + uint64_t sign : 1; + uint64_t padding : 16; + } parts __attribute__((packed)); +} float96; + +typedef union { + struct { + uint64_t lo; + uint64_t hi; + } bin __attribute__((packed)); + + struct { + uint64_t frac_lo : 64; + uint64_t frac_hi : 48; + uint64_t exp : 15; + uint64_t sign : 1; + } parts __attribute__((packed)); +} float128; + +#else + #error Unknown endianess +#endif + +typedef union { + float val; + +#if defined(FLOAT_SIZE_32) + float32 data; +#elif defined(FLOAT_SIZE_64) + float64 data; +#elif defined(FLOAT_SIZE_96) + float96 data; +#elif defined(FLOAT_SIZE_128) + float128 data; +#else + #error Unsupported float size +#endif +} float_t; + +typedef union { + double val; + +#if defined(DOUBLE_SIZE_32) + float32 data; +#elif defined(DOUBLE_SIZE_64) + float64 data; +#elif defined(DOUBLE_SIZE_96) + float96 data; +#elif defined(DOUBLE_SIZE_128) + float128 data; +#else + #error Unsupported double size +#endif +} double_t; + +typedef union { + long double val; + +#if defined(LONG_DOUBLE_SIZE_32) + float32 data; +#elif defined(LONG_DOUBLE_SIZE_64) + float64 data; +#elif defined(LONG_DOUBLE_SIZE_96) + float96 data; +#elif defined(LONG_DOUBLE_SIZE_128) + float128 data; +#else + #error Unsupported long double size +#endif +} long_double_t; + + +#if defined(INT_SIZE_8) + +#define _to_int _to_int8 +#define from_int int8 + +#elif defined(INT_SIZE_16) + +#define _to_int _to_int16 +#define from_int int16 + +#elif defined(INT_SIZE_32) + +#define _to_int _to_int32 +#define from_int int32 + +#elif defined(INT_SIZE_64) + +#define _to_int _to_int64 +#define from_int int64 + +#endif + + +#if defined(UINT_SIZE_8) + +#define _to_uint _to_uint8 +#define from_uint uint8 + +#elif defined(UINT_SIZE_16) + +#define _to_uint _to_uint16 +#define from_uint uint16 + +#elif defined(UINT_SIZE_32) + +#define _to_uint _to_uint32 +#define from_uint uint32 + +#elif defined(UINT_SIZE_64) + +#define _to_uint _to_uint64 +#define from_uint uint64 + +#endif + + +#if defined(LONG_SIZE_8) + +#define _to_long _to_int8 +#define from_long int8 + +#elif defined(LONG_SIZE_16) + +#define _to_long _to_int16 +#define from_long int16 + +#elif defined(LONG_SIZE_32) + +#define _to_long _to_int32 +#define from_long int32 + +#elif defined(LONG_SIZE_64) + +#define _to_long _to_int64 +#define from_long int64 + +#endif + + +#if defined(ULONG_SIZE_8) + +#define _to_ulong _to_uint8 +#define from_ulong uint8 + +#elif defined(ULONG_SIZE_16) + +#define _to_ulong _to_uint16 +#define from_ulong uint16 + +#elif defined(ULONG_SIZE_32) + +#define _to_ulong _to_uint32 +#define from_ulong uint32 + +#elif defined(ULONG_SIZE_64) + +#define _to_ulong _to_uint64 +#define from_ulong uint64 + +#endif + + +#if defined(LLONG_SIZE_8) + +#define _to_llong _to_int8 +#define from_llong int8 + +#elif defined(LLONG_SIZE_16) + +#define _to_llong _to_int16 +#define from_llong int16 + +#elif defined(LLONG_SIZE_32) + +#define _to_llong _to_int32 +#define from_llong int32 + +#elif defined(LLONG_SIZE_64) + +#define _to_llong _to_int64 +#define from_llong int64 + +#endif + + +#if defined(ULLONG_SIZE_8) + +#define _to_ullong _to_uint8 +#define from_ullong uint8 + +#elif defined(ULLONG_SIZE_16) + +#define _to_ullong _to_uint16 +#define from_ullong uint16 + +#elif defined(ULLONG_SIZE_32) + +#define _to_ullong _to_uint32 +#define from_ullong uint32 + +#elif defined(ULLONG_SIZE_64) + +#define _to_ullong _to_uint64 +#define from_ullong uint64 + +#endif + + +#if defined(FLOAT_SIZE_32) + +#define add_float add_float32 +#define sub_float sub_float32 +#define mul_float mul_float32 +#define div_float div_float32 +#define _to_float _to_float32 +#define from_float float32 +#define is_float_nan is_float32_nan +#define is_float_eq is_float32_eq +#define is_float_lt is_float32_lt +#define is_float_gt is_float32_gt + +#elif defined(FLOAT_SIZE_64) + +#define add_float add_float64 +#define sub_float sub_float64 +#define mul_float mul_float64 +#define div_float div_float64 +#define _to_float _to_float64 +#define from_float float64 +#define is_float_nan is_float64_nan +#define is_float_eq is_float64_eq +#define is_float_lt is_float64_lt +#define is_float_gt is_float64_gt + +#elif defined(FLOAT_SIZE_96) + +#define add_float add_float96 +#define sub_float sub_float96 +#define mul_float mul_float96 +#define div_float div_float96 +#define _to_float _to_float96 +#define from_float float96 +#define is_float_nan is_float96_nan +#define is_float_eq is_float96_eq +#define is_float_lt is_float96_lt +#define is_float_gt is_float96_gt + +#elif defined(FLOAT_SIZE_128) + +#define add_float add_float128 +#define sub_float sub_float128 +#define mul_float mul_float128 +#define div_float div_float128 +#define _to_float _to_float128 +#define from_float float128 +#define is_float_nan is_float128_nan +#define is_float_eq is_float128_eq +#define is_float_lt is_float128_lt +#define is_float_gt is_float128_gt + +#endif + + +#if defined(DOUBLE_SIZE_32) + +#define add_double add_float32 +#define sub_double sub_float32 +#define mul_double mul_float32 +#define div_double div_float32 +#define _to_double _to_float32 +#define from_double float32 +#define is_double_nan is_float32_nan +#define is_double_eq is_float32_eq +#define is_double_lt is_float32_lt +#define is_double_gt is_float32_gt + +#elif defined(DOUBLE_SIZE_64) + +#define add_double add_float64 +#define sub_double sub_float64 +#define mul_double mul_float64 +#define div_double div_float64 +#define _to_double _to_float64 +#define from_double float64 +#define is_double_nan is_float64_nan +#define is_double_eq is_float64_eq +#define is_double_lt is_float64_lt +#define is_double_gt is_float64_gt + +#elif defined(DOUBLE_SIZE_96) + +#define add_double add_float96 +#define sub_double sub_float96 +#define mul_double mul_float96 +#define div_double div_float96 +#define _to_double _to_float96 +#define from_double float96 +#define is_double_nan is_float96_nan +#define is_double_eq is_float96_eq +#define is_double_lt is_float96_lt +#define is_double_gt is_float96_gt + +#elif defined(DOUBLE_SIZE_128) + +#define add_double add_float128 +#define sub_double sub_float128 +#define mul_double mul_float128 +#define div_double div_float128 +#define _to_double _to_float128 +#define from_double float128 +#define is_double_nan is_float128_nan +#define is_double_eq is_float128_eq +#define is_double_lt is_float128_lt +#define is_double_gt is_float128_gt + +#endif + + +#if defined(LONG_DOUBLE_SIZE_32) + +#define add_long_double add_float32 +#define sub_long_double sub_float32 +#define mul_long_double mul_float32 +#define div_long_double div_float32 +#define _to_long_double _to_float32 +#define from_long_double float32 +#define is_long_double_nan is_float32_nan +#define is_long_double_eq is_float32_eq +#define is_long_double_lt is_float32_lt +#define is_long_double_gt is_float32_gt + +#elif defined(LONG_DOUBLE_SIZE_64) + +#define add_long_double add_float64 +#define sub_long_double sub_float64 +#define mul_long_double mul_float64 +#define div_long_double div_float64 +#define _to_long_double _to_float64 +#define from_long_double float64 +#define is_long_double_nan is_float64_nan +#define is_long_double_eq is_float64_eq +#define is_long_double_lt is_float64_lt +#define is_long_double_gt is_float64_gt + +#elif defined(LONG_DOUBLE_SIZE_96) + +#define add_long_double add_float96 +#define sub_long_double sub_float96 +#define mul_long_double mul_float96 +#define div_long_double div_float96 +#define _to_long_double _to_float96 +#define from_long_double float96 +#define is_long_double_nan is_float96_nan +#define is_long_double_eq is_float96_eq +#define is_long_double_lt is_float96_lt +#define is_long_double_gt is_float96_gt + +#elif defined(LONG_DOUBLE_SIZE_128) + +#define add_long_double add_float128 +#define sub_long_double sub_float128 +#define mul_long_double mul_float128 +#define div_long_double div_float128 +#define _to_long_double _to_float128 +#define from_long_double float128 +#define is_long_double_nan is_float128_nan +#define is_long_double_eq is_float128_eq +#define is_long_double_lt is_float128_lt +#define is_long_double_gt is_float128_gt + +#endif + + +#define CONCAT(a, b) CONCAT_ARGS(a, b) +#define CONCAT_ARGS(a, b) a ## b + +#define float32_to_float32(arg) (arg) +#define float64_to_float64(arg) (arg) +#define float96_to_float96(arg) (arg) +#define float128_to_float128(arg) (arg) + +#define float_to_double CONCAT(from_float, _to_double) +#define float_to_long_double CONCAT(from_float, _to_long_double) +#define float_to_int CONCAT(from_float, _to_int) +#define float_to_uint CONCAT(from_float, _to_uint) +#define float_to_long CONCAT(from_float, _to_long) +#define float_to_ulong CONCAT(from_float, _to_ulong) +#define float_to_llong CONCAT(from_float, _to_llong) +#define float_to_ullong CONCAT(from_float, _to_ullong) + +#define double_to_float CONCAT(from_double, _to_float) +#define double_to_long_double CONCAT(from_double, _to_long_double) +#define double_to_int CONCAT(from_double, _to_int) +#define double_to_uint CONCAT(from_double, _to_uint) +#define double_to_long CONCAT(from_double, _to_long) +#define double_to_ulong CONCAT(from_double, _to_ulong) +#define double_to_llong CONCAT(from_double, _to_llong) +#define double_to_ullong CONCAT(from_double, _to_ullong) + +#define long_double_to_float CONCAT(from_long_double, _to_float) +#define long_double_to_double CONCAT(from_long_double, _to_double) +#define long_double_to_int CONCAT(from_long_double, _to_int) +#define long_double_to_uint CONCAT(from_long_double, _to_uint) +#define long_double_to_long CONCAT(from_long_double, _to_long) +#define long_double_to_ulong CONCAT(from_long_double, _to_ulong) +#define long_double_to_llong CONCAT(from_long_double, _to_llong) +#define long_double_to_ullong CONCAT(from_long_double, _to_ullong) + +#define int_to_float CONCAT(from_int, _to_float) +#define int_to_double CONCAT(from_int, _to_double) +#define int_to_long_double CONCAT(from_int, _to_long_double) + +#define uint_to_float CONCAT(from_uint, _to_float) +#define uint_to_double CONCAT(from_uint, _to_double) +#define uint_to_long_double CONCAT(from_uint, _to_long_double) + +#define long_to_float CONCAT(from_long, _to_float) +#define long_to_double CONCAT(from_long, _to_double) +#define long_to_long_double CONCAT(from_long, _to_long_double) + +#define ulong_to_float CONCAT(from_ulong, _to_float) +#define ulong_to_double CONCAT(from_ulong, _to_double) +#define ulong_to_long_double CONCAT(from_ulong, _to_long_double) + +#define llong_to_float CONCAT(from_llong, _to_float) +#define llong_to_double CONCAT(from_llong, _to_double) +#define llong_to_long_double CONCAT(from_llong, _to_long_double) + +#define ullong_to_float CONCAT(from_ullong, _to_float) +#define ullong_to_double CONCAT(from_ullong, _to_double) +#define ullong_to_long_double CONCAT(from_ullong, _to_long_double) + + +#endif + +/** @} + */ Index: uspace/lib/softfloat/softfloat.c =================================================================== --- uspace/lib/softfloat/softfloat.c (revision 1dbd189b0e98a0f835bd872d52126bb32e841feb) +++ uspace/lib/softfloat/softfloat.c (revision 1dbd189b0e98a0f835bd872d52126bb32e841feb) @@ -0,0 +1,1353 @@ +/* + * Copyright (c) 2005 Josef Cejka + * Copyright (c) 2011 Petr Koupy + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup softfloat generic + * @ingroup sfl + * @brief Architecture independent parts of FPU software emulation library. + * @{ + */ +/** @file Softfloat API. + */ + +#include "softfloat.h" +#include "sftypes.h" +#include "add.h" +#include "sub.h" +#include "mul.h" +#include "div.h" +#include "conversion.h" +#include "comparison.h" +#include "other.h" + +/* Arithmetic functions */ + +float __addsf3(float a, float b) +{ + float_t fa; + float_t fb; + float_t res; + + fa.val = a; + fb.val = b; + + if (fa.data.parts.sign != fb.data.parts.sign) { + if (fa.data.parts.sign) { + fa.data.parts.sign = 0; + res.data = sub_float(fb.data, fa.data); + + return res.val; + } + + fb.data.parts.sign = 0; + res.data = sub_float(fa.data, fb.data); + + return res.val; + } + + res.data = add_float(fa.data, fb.data); + return res.val; +} + +double __adddf3(double a, double b) +{ + double_t da; + double_t db; + double_t res; + + da.val = a; + db.val = b; + + if (da.data.parts.sign != db.data.parts.sign) { + if (da.data.parts.sign) { + da.data.parts.sign = 0; + res.data = sub_double(db.data, da.data); + + return res.val; + } + + db.data.parts.sign = 0; + res.data = sub_double(da.data, db.data); + + return res.val; + } + + res.data = add_double(da.data, db.data); + return res.val; +} + +long double __addtf3(long double a, long double b) +{ + long_double_t ta; + long_double_t tb; + long_double_t res; + + ta.val = a; + tb.val = b; + + if (ta.data.parts.sign != tb.data.parts.sign) { + if (ta.data.parts.sign) { + ta.data.parts.sign = 0; + res.data = sub_long_double(tb.data, ta.data); + + return res.val; + } + + tb.data.parts.sign = 0; + res.data = sub_long_double(ta.data, tb.data); + + return res.val; + } + + res.data = add_long_double(ta.data, tb.data); + return res.val; +} + +float __subsf3(float a, float b) +{ + float_t fa; + float_t fb; + float_t res; + + fa.val = a; + fb.val = b; + + if (fa.data.parts.sign != fb.data.parts.sign) { + fb.data.parts.sign = !fb.data.parts.sign; + res.data = add_float(fa.data, fb.data); + + return res.val; + } + + res.data = sub_float(fa.data, fb.data); + return res.val; +} + +double __subdf3(double a, double b) +{ + double_t da; + double_t db; + double_t res; + + da.val = a; + db.val = b; + + if (da.data.parts.sign != db.data.parts.sign) { + db.data.parts.sign = !db.data.parts.sign; + res.data = add_double(da.data, db.data); + + return res.val; + } + + res.data = sub_double(da.data, db.data); + return res.val; +} + +long double __subtf3(long double a, long double b) +{ + long_double_t ta; + long_double_t tb; + long_double_t res; + + ta.val = a; + tb.val = b; + + if (ta.data.parts.sign != tb.data.parts.sign) { + tb.data.parts.sign = !tb.data.parts.sign; + res.data = add_long_double(ta.data, tb.data); + + return res.val; + } + + res.data = sub_long_double(ta.data, tb.data); + return res.val; +} + +float __mulsf3(float a, float b) +{ + float_t fa; + float_t fb; + float_t res; + + fa.val = a; + fb.val = b; + + res.data = mul_float(fa.data, fb.data); + return res.val; +} + +double __muldf3(double a, double b) +{ + double_t da; + double_t db; + double_t res; + + da.val = a; + db.val = b; + + res.data = mul_double(da.data, db.data); + return res.val; +} + +long double __multf3(long double a, long double b) +{ + long_double_t ta; + long_double_t tb; + long_double_t res; + + ta.val = a; + tb.val = b; + + res.data = mul_long_double(ta.data, tb.data); + return res.val; +} + +float __divsf3(float a, float b) +{ + float_t fa; + float_t fb; + float_t res; + + fa.val = a; + fb.val = b; + + res.data = div_float(fa.data, fb.data); + return res.val; +} + +double __divdf3(double a, double b) +{ + double_t da; + double_t db; + double_t res; + + da.val = a; + db.val = b; + + res.data = div_double(da.data, db.data); + return res.val; +} + +long double __divtf3(long double a, long double b) +{ + long_double_t ta; + long_double_t tb; + long_double_t res; + + ta.val = a; + tb.val = b; + + res.data = div_long_double(ta.data, tb.data); + return res.val; +} + +float __negsf2(float a) +{ + float_t fa; + + fa.val = a; + fa.data.parts.sign = !fa.data.parts.sign; + + return fa.val; +} + +double __negdf2(double a) +{ + double_t da; + + da.val = a; + da.data.parts.sign = !da.data.parts.sign; + + return da.val; +} + +long double __negtf2(long double a) +{ + long_double_t ta; + + ta.val = a; + ta.data.parts.sign = !ta.data.parts.sign; + + return ta.val; +} + +/* Conversion functions */ + +double __extendsfdf2(float a) +{ + float_t fa; + double_t res; + + fa.val = a; + res.data = float_to_double(fa.data); + + return res.val; +} + +long double __extendsftf2(float a) +{ + float_t fa; + long_double_t res; + + fa.val = a; + res.data = float_to_long_double(fa.data); + + return res.val; +} + +long double __extenddftf2(double a) +{ + double_t da; + long_double_t res; + + da.val = a; + res.data = double_to_long_double(da.data); + + return res.val; +} + +float __truncdfsf2(double a) +{ + double_t da; + float_t res; + + da.val = a; + res.data = double_to_float(da.data); + + return res.val; +} + +float __trunctfsf2(long double a) +{ + long_double_t ta; + float_t res; + + ta.val = a; + res.data = long_double_to_float(ta.data); + + return res.val; +} + +double __trunctfdf2(long double a) +{ + long_double_t ta; + double_t res; + + ta.val = a; + res.data = long_double_to_double(ta.data); + + return res.val; +} + +int __fixsfsi(float a) +{ + float_t fa; + + fa.val = a; + return float_to_int(fa.data); +} + +int __fixdfsi(double a) +{ + double_t da; + + da.val = a; + return double_to_int(da.data); +} + +int __fixtfsi(long double a) +{ + long_double_t ta; + + ta.val = a; + return long_double_to_int(ta.data); +} + +long __fixsfdi(float a) +{ + float_t fa; + + fa.val = a; + return float_to_long(fa.data); +} + +long __fixdfdi(double a) +{ + double_t da; + + da.val = a; + return double_to_long(da.data); +} + +long __fixtfdi(long double a) +{ + long_double_t ta; + + ta.val = a; + return long_double_to_long(ta.data); +} + +long long __fixsfti(float a) +{ + float_t fa; + + fa.val = a; + return float_to_llong(fa.data); +} + +long long __fixdfti(double a) +{ + double_t da; + + da.val = a; + return double_to_llong(da.data); +} + +long long __fixtfti(long double a) +{ + long_double_t ta; + + ta.val = a; + return long_double_to_llong(ta.data); +} + +unsigned int __fixunssfsi(float a) +{ + float_t fa; + + fa.val = a; + return float_to_uint(fa.data); +} + +unsigned int __fixunsdfsi(double a) +{ + double_t da; + + da.val = a; + return double_to_uint(da.data); +} + +unsigned int __fixunstfsi(long double a) +{ + long_double_t ta; + + ta.val = a; + return long_double_to_uint(ta.data); +} + +unsigned long __fixunssfdi(float a) +{ + float_t fa; + + fa.val = a; + return float_to_ulong(fa.data); +} + +unsigned long __fixunsdfdi(double a) +{ + double_t da; + + da.val = a; + return double_to_ulong(da.data); +} + +unsigned long __fixunstfdi(long double a) +{ + long_double_t ta; + + ta.val = a; + return long_double_to_ulong(ta.data); +} + +unsigned long long __fixunssfti(float a) +{ + float_t fa; + + fa.val = a; + return float_to_ullong(fa.data); +} + +unsigned long long __fixunsdfti(double a) +{ + double_t da; + + da.val = a; + return double_to_ullong(da.data); +} + +unsigned long long __fixunstfti(long double a) +{ + long_double_t ta; + + ta.val = a; + return long_double_to_ullong(ta.data); +} + +float __floatsisf(int i) +{ + float_t res; + + res.data = int_to_float(i); + return res.val; +} + +double __floatsidf(int i) +{ + double_t res; + + res.data = int_to_double(i); + return res.val; +} + +long double __floatsitf(int i) +{ + long_double_t res; + + res.data = int_to_long_double(i); + return res.val; +} + +float __floatdisf(long i) +{ + float_t res; + + res.data = long_to_float(i); + return res.val; +} + +double __floatdidf(long i) +{ + double_t res; + + res.data = long_to_double(i); + return res.val; +} + +long double __floatditf(long i) +{ + long_double_t res; + + res.data = long_to_long_double(i); + return res.val; +} + +float __floattisf(long long i) +{ + float_t res; + + res.data = llong_to_float(i); + return res.val; +} + +double __floattidf(long long i) +{ + double_t res; + + res.data = llong_to_double(i); + return res.val; +} + +long double __floattitf(long long i) +{ + long_double_t res; + + res.data = llong_to_long_double(i); + return res.val; +} + +float __floatunsisf(unsigned int i) +{ + float_t res; + + res.data = uint_to_float(i); + return res.val; +} + +double __floatunsidf(unsigned int i) +{ + double_t res; + + res.data = uint_to_double(i); + return res.val; +} + +long double __floatunsitf(unsigned int i) +{ + long_double_t res; + + res.data = uint_to_long_double(i); + return res.val; +} + +float __floatundisf(unsigned long i) +{ + float_t res; + + res.data = ulong_to_float(i); + return res.val; +} + +double __floatundidf(unsigned long i) +{ + double_t res; + + res.data = ulong_to_double(i); + return res.val; +} + +long double __floatunditf(unsigned long i) +{ + long_double_t res; + + res.data = ulong_to_long_double(i); + return res.val; +} + +float __floatuntisf(unsigned long long i) +{ + float_t res; + + res.data = ullong_to_float(i); + return res.val; +} + +double __floatuntidf(unsigned long long i) +{ + double_t res; + + res.data = ullong_to_double(i); + return res.val; +} + +long double __floatuntitf(unsigned long long i) +{ + long_double_t res; + + res.data = ullong_to_long_double(i); + return res.val; +} + +/* Comparison functions */ + +int __cmpsf2(float a, float b) +{ + float_t fa; + float_t fb; + + fa.val = a; + fb.val = b; + + if ((is_float_nan(fa.data)) || (is_float_nan(fb.data))) { + /* no special constant for unordered - maybe signaled? */ + return 1; + } + + if (is_float_eq(fa.data, fb.data)) + return 0; + + if (is_float_lt(fa.data, fb.data)) + return -1; + + return 1; +} + +int __cmpdf2(double a, double b) +{ + double_t da; + double_t db; + + da.val = a; + db.val = b; + + if ((is_double_nan(da.data)) || (is_double_nan(db.data))) { + /* no special constant for unordered - maybe signaled? */ + return 1; + } + + if (is_double_eq(da.data, db.data)) + return 0; + + if (is_double_lt(da.data, db.data)) + return -1; + + return 1; +} + +int __cmptf2(long double a, long double b) +{ + long_double_t ta; + long_double_t tb; + + ta.val = a; + tb.val = b; + + if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data))) { + /* no special constant for unordered - maybe signaled? */ + return 1; + } + + if (is_long_double_eq(ta.data, tb.data)) + return 0; + + if (is_long_double_lt(ta.data, tb.data)) + return -1; + + return 1; +} + +int __unordsf2(float a, float b) +{ + float_t fa; + float_t fb; + + fa.val = a; + fb.val = b; + + return ((is_float_nan(fa.data)) || (is_float_nan(fb.data))); +} + +int __unorddf2(double a, double b) +{ + double_t da; + double_t db; + + da.val = a; + db.val = b; + + return ((is_double_nan(da.data)) || (is_double_nan(db.data))); +} + +int __unordtf2(long double a, long double b) +{ + long_double_t ta; + long_double_t tb; + + ta.val = a; + tb.val = b; + + return ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data))); +} + +int __eqsf2(float a, float b) +{ + float_t fa; + float_t fb; + + fa.val = a; + fb.val = b; + + if ((is_float_nan(fa.data)) || (is_float_nan(fb.data))) { + // TODO: sigNaNs + return 1; + } + + return is_float_eq(fa.data, fb.data) - 1; +} + +int __eqdf2(double a, double b) +{ + double_t da; + double_t db; + + da.val = a; + db.val = b; + + if ((is_double_nan(da.data)) || (is_double_nan(db.data))) { + // TODO: sigNaNs + return 1; + } + + return is_double_eq(da.data, db.data) - 1; +} + +int __eqtf2(long double a, long double b) +{ + long_double_t ta; + long_double_t tb; + + ta.val = a; + tb.val = b; + + if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data))) { + // TODO: sigNaNs + return 1; + } + + return is_long_double_eq(ta.data, tb.data) - 1; +} + +int __nesf2(float a, float b) +{ + /* strange behavior, but it was in gcc documentation */ + return __eqsf2(a, b); +} + +int __nedf2(double a, double b) +{ + /* strange behavior, but it was in gcc documentation */ + return __eqdf2(a, b); +} + +int __netf2(long double a, long double b) +{ + /* strange behavior, but it was in gcc documentation */ + return __eqtf2(a, b); +} + +int __gesf2(float a, float b) +{ + float_t fa; + float_t fb; + + fa.val = a; + fb.val = b; + + if ((is_float_nan(fa.data)) || (is_float_nan(fb.data))) { + // TODO: sigNaNs + return -1; + } + + if (is_float_eq(fa.data, fb.data)) + return 0; + + if (is_float_gt(fa.data, fb.data)) + return 1; + + return -1; +} + +int __gedf2(double a, double b) +{ + double_t da; + double_t db; + + da.val = a; + db.val = b; + + if ((is_double_nan(da.data)) || (is_double_nan(db.data))) { + // TODO: sigNaNs + return -1; + } + + if (is_double_eq(da.data, db.data)) + return 0; + + if (is_double_gt(da.data, db.data)) + return 1; + + return -1; +} + +int __getf2(long double a, long double b) +{ + long_double_t ta; + long_double_t tb; + + ta.val = a; + tb.val = b; + + if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data))) { + // TODO: sigNaNs + return -1; + } + + if (is_long_double_eq(ta.data, tb.data)) + return 0; + + if (is_long_double_gt(ta.data, tb.data)) + return 1; + + return -1; +} + +int __ltsf2(float a, float b) +{ + float_t fa; + float_t fb; + + fa.val = a; + fb.val = b; + + if ((is_float_nan(fa.data)) || (is_float_nan(fb.data))) { + // TODO: sigNaNs + return 1; + } + + if (is_float_lt(fa.data, fb.data)) + return -1; + + return 0; +} + +int __ltdf2(double a, double b) +{ + double_t da; + double_t db; + + da.val = a; + db.val = b; + + if ((is_double_nan(da.data)) || (is_double_nan(db.data))) { + // TODO: sigNaNs + return 1; + } + + if (is_double_lt(da.data, db.data)) + return -1; + + return 0; +} + +int __lttf2(long double a, long double b) +{ + long_double_t ta; + long_double_t tb; + + ta.val = a; + tb.val = b; + + if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data))) { + // TODO: sigNaNs + return 1; + } + + if (is_long_double_lt(ta.data, tb.data)) + return -1; + + return 0; +} + +int __lesf2(float a, float b) +{ + float_t fa; + float_t fb; + + fa.val = a; + fb.val = b; + + if ((is_float_nan(fa.data)) || (is_float_nan(fb.data))) { + // TODO: sigNaNs + return 1; + } + + if (is_float_eq(fa.data, fb.data)) + return 0; + + if (is_float_lt(fa.data, fb.data)) + return -1; + + return 1; +} + +int __ledf2(double a, double b) +{ + double_t da; + double_t db; + + da.val = a; + db.val = b; + + if ((is_double_nan(da.data)) || (is_double_nan(db.data))) { + // TODO: sigNaNs + return 1; + } + + if (is_double_eq(da.data, db.data)) + return 0; + + if (is_double_lt(da.data, db.data)) + return -1; + + return 1; +} + +int __letf2(long double a, long double b) +{ + long_double_t ta; + long_double_t tb; + + ta.val = a; + tb.val = b; + + if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data))) { + // TODO: sigNaNs + return 1; + } + + if (is_long_double_eq(ta.data, tb.data)) + return 0; + + if (is_long_double_lt(ta.data, tb.data)) + return -1; + + return 1; +} + +int __gtsf2(float a, float b) +{ + float_t fa; + float_t fb; + + fa.val = a; + fb.val = b; + + if ((is_float_nan(fa.data)) || (is_float_nan(fb.data))) { + // TODO: sigNaNs + return -1; + } + + if (is_float_gt(fa.data, fb.data)) + return 1; + + return 0; +} + +int __gtdf2(double a, double b) +{ + double_t da; + double_t db; + + da.val = a; + db.val = b; + + if ((is_double_nan(da.data)) || (is_double_nan(db.data))) { + // TODO: sigNaNs + return -1; + } + + if (is_double_gt(da.data, db.data)) + return 1; + + return 0; +} + +int __gttf2(long double a, long double b) +{ + long_double_t ta; + long_double_t tb; + + ta.val = a; + tb.val = b; + + if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data))) { + // TODO: sigNaNs + return -1; + } + + if (is_long_double_gt(ta.data, tb.data)) + return 1; + + return 0; +} + +/* SPARC quadruple-precision wrappers */ + +void _Qp_add(long double *c, long double *a, long double *b) +{ + *c = __addtf3(*a, *b); +} + +void _Qp_sub(long double *c, long double *a, long double *b) +{ + *c = __subtf3(*a, *b); +} + +void _Qp_mul(long double *c, long double *a, long double *b) +{ + *c = __multf3(*a, *b); +} + +void _Qp_div(long double *c, long double *a, long double *b) +{ + *c = __divtf3(*a, *b); +} + +void _Qp_neg(long double *c, long double *a) +{ + *c = __negtf2(*a); +} + +void _Qp_stoq(long double *c, float a) +{ + *c = __extendsftf2(a); +} + +void _Qp_dtoq(long double *c, double a) +{ + *c = __extenddftf2(a); +} + +float _Qp_qtos(long double *a) +{ + return __trunctfsf2(*a); +} + +double _Qp_qtod(long double *a) +{ + return __trunctfdf2(*a); +} + +int _Qp_qtoi(long double *a) +{ + return __fixtfsi(*a); +} + +unsigned int _Qp_qtoui(long double *a) +{ + return __fixunstfsi(*a); +} + +long _Qp_qtox(long double *a) +{ + return __fixtfdi(*a); +} + +unsigned long _Qp_qtoux(long double *a) +{ + return __fixunstfdi(*a); +} + +void _Qp_itoq(long double *c, int a) +{ + *c = __floatsitf(a); +} + +void _Qp_uitoq(long double *c, unsigned int a) +{ + *c = __floatunsitf(a); +} + +void _Qp_xtoq(long double *c, long a) +{ + *c = __floatditf(a); +} + +void _Qp_uxtoq(long double *c, unsigned long a) +{ + *c = __floatunditf(a); +} + +int _Qp_cmp(long double *a, long double *b) +{ + long_double_t ta; + long_double_t tb; + + ta.val = *a; + tb.val = *b; + + if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data))) + return 3; + + if (is_long_double_eq(ta.data, tb.data)) + return 0; + + if (is_long_double_lt(ta.data, tb.data)) + return 1; + + return 2; +} + +int _Qp_cmpe(long double *a, long double *b) +{ + /* strange, but is defined this way in SPARC Compliance Definition */ + return _Qp_cmp(a, b); +} + +int _Qp_feq(long double *a, long double *b) +{ + long_double_t ta; + long_double_t tb; + + ta.val = *a; + tb.val = *b; + + if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data))) + return 0; + + return is_long_double_eq(ta.data, tb.data); +} + +int _Qp_fge(long double *a, long double *b) +{ + long_double_t ta; + long_double_t tb; + + ta.val = *a; + tb.val = *b; + + if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data))) + return 0; + + return is_long_double_eq(ta.data, tb.data) || + is_long_double_gt(ta.data, tb.data); +} + +int _Qp_fgt(long double *a, long double *b) +{ + long_double_t ta; + long_double_t tb; + + ta.val = *a; + tb.val = *b; + + if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data))) + return 0; + + return is_long_double_gt(ta.data, tb.data); +} + +int _Qp_fle(long double*a, long double *b) +{ + long_double_t ta; + long_double_t tb; + + ta.val = *a; + tb.val = *b; + + if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data))) + return 0; + + return is_long_double_eq(ta.data, tb.data) || + is_long_double_lt(ta.data, tb.data); +} + +int _Qp_flt(long double *a, long double *b) +{ + long_double_t ta; + long_double_t tb; + + ta.val = *a; + tb.val = *b; + + if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data))) + return 0; + + return is_long_double_lt(ta.data, tb.data); +} + +int _Qp_fne(long double *a, long double *b) +{ + long_double_t ta; + long_double_t tb; + + ta.val = *a; + tb.val = *b; + + if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data))) + return 0; + + return !is_long_double_eq(ta.data, tb.data); +} + +double __aeabi_i2d(int i) +{ + return __floatsidf(i); +} + +double __aeabi_ui2d(unsigned int i) +{ + return __floatunsidf(i); +} + +int __aeabi_f2iz(float a) +{ + return __fixsfsi(a); +} + +int __aeabi_d2iz(double a) +{ + return __fixdfsi(a); +} + +unsigned int __aeabi_d2uiz(double a) +{ + return __fixunsdfsi(a); +} + +int __aeabi_dcmpge(double a, double b) +{ + return __gedf2(a, b); +} + +int __aeabi_dcmpgt(double a, double b) +{ + return __gtdf2(a, b); +} + +int __aeabi_dcmplt(double a, double b) +{ + return __ltdf2(a, b); +} + +int __aeabi_dcmpeq(double a, double b) +{ + return __eqdf2(a, b); +} + +float __aeabi_fadd(float a, float b) +{ + return __addsf3(a, b); +} + +float __aeabi_fsub(float a, float b) +{ + return __subsf3(a, b); +} + +float __aeabi_fmul(float a, float b) +{ + return __mulsf3(a, b); +} + +float __aeabi_fdiv(float a, float b) +{ + return __divsf3(a, b); +} + +double __aeabi_dadd(double a, double b) +{ + return __adddf3(a, b); +} + +double __aeabi_dsub(double a, double b) +{ + return __subdf3(a, b); +} + +double __aeabi_dmul(double a, double b) +{ + return __muldf3(a, b); +} + +double __aeabi_ddiv(double a, double b) +{ + return __divdf3(a, b); +} + +/** @} + */ Index: uspace/lib/softfloat/softfloat.h =================================================================== --- uspace/lib/softfloat/softfloat.h (revision 1dbd189b0e98a0f835bd872d52126bb32e841feb) +++ uspace/lib/softfloat/softfloat.h (revision 1dbd189b0e98a0f835bd872d52126bb32e841feb) @@ -0,0 +1,234 @@ +/* + * Copyright (c) 2005 Josef Cejka + * Copyright (c) 2011 Petr Koupy + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup softfloat + * @{ + */ +/** @file Softfloat API. + */ + +#ifndef __SOFTFLOAT_H__ +#define __SOFTFLOAT_H__ + +extern float __addsf3(float, float); +extern double __adddf3(double, double); +extern long double __addtf3(long double, long double); +extern long double __addxf3(long double, long double); + +extern float __subsf3(float, float); +extern double __subdf3(double, double); +extern long double __subtf3(long double, long double); +extern long double __subxf3(long double, long double); + +extern float __mulsf3(float, float); +extern double __muldf3(double, double); +extern long double __multf3(long double, long double); +extern long double __mulxf3(long double, long double); + +extern float __divsf3(float, float); +extern double __divdf3(double, double); +extern long double __divtf3(long double, long double); +extern long double __divxf3(long double, long double); + +extern float __negsf2(float); +extern double __negdf2(double); +extern long double __negtf2(long double); +extern long double __negxf2(long double); + +extern double __extendsfdf2(float); +extern long double __extendsftf2(float); +extern long double __extendsfxf2(float); +extern long double __extenddftf2(double); +extern long double __extenddfxf2(double); + +extern double __truncxfdf2(long double); +extern double __trunctfdf2(long double); +extern float __truncxfsf2(long double); +extern float __trunctfsf2(long double); +extern float __truncdfsf2(double); + +extern int __fixsfsi(float); +extern int __fixdfsi(double); +extern int __fixtfsi(long double); +extern int __fixxfsi(long double); + +extern long __fixsfdi(float); +extern long __fixdfdi(double); +extern long __fixtfdi(long double); +extern long __fixxfdi(long double); + +extern long long __fixsfti(float); +extern long long __fixdfti(double); +extern long long __fixtfti(long double); +extern long long __fixxfti(long double); + +extern unsigned int __fixunssfsi(float); +extern unsigned int __fixunsdfsi(double); +extern unsigned int __fixunstfsi(long double); +extern unsigned int __fixunsxfsi(long double); + +extern unsigned long __fixunssfdi(float); +extern unsigned long __fixunsdfdi(double); +extern unsigned long __fixunstfdi(long double); +extern unsigned long __fixunsxfdi(long double); + +extern unsigned long long __fixunssfti(float); +extern unsigned long long __fixunsdfti(double); +extern unsigned long long __fixunstfti(long double); +extern unsigned long long __fixunsxfti(long double); + +extern float __floatsisf(int); +extern double __floatsidf(int); +extern long double __floatsitf(int); +extern long double __floatsixf(int); + +extern float __floatdisf(long); +extern double __floatdidf(long); +extern long double __floatditf(long); +extern long double __floatdixf(long); + +extern float __floattisf(long long); +extern double __floattidf(long long); +extern long double __floattitf(long long); +extern long double __floattixf(long long); + +extern float __floatunsisf(unsigned int); +extern double __floatunsidf(unsigned int); +extern long double __floatunsitf(unsigned int); +extern long double __floatunsixf(unsigned int); + +extern float __floatundisf(unsigned long); +extern double __floatundidf(unsigned long); +extern long double __floatunditf(unsigned long); +extern long double __floatundixf(unsigned long); + +extern float __floatuntisf(unsigned long long); +extern double __floatuntidf(unsigned long long); +extern long double __floatuntitf(unsigned long long); +extern long double __floatuntixf(unsigned long long); + +extern int __cmpsf2(float, float); +extern int __cmpdf2(double, double); +extern int __cmptf2(long double, long double); + +extern int __unordsf2(float, float); +extern int __unorddf2(double, double); +extern int __unordtf2(long double, long double); + +extern int __eqsf2(float, float); +extern int __eqdf2(double, double); +extern int __eqtf2(long double, long double); + +extern int __nesf2(float, float); +extern int __nedf2(double, double); +extern int __netf2(long double, long double); + +extern int __gesf2(float, float); +extern int __gedf2(double, double); +extern int __getf2(long double, long double); + +extern int __ltsf2(float, float); +extern int __ltdf2(double, double); +extern int __lttf2(long double, long double); + +extern int __lesf2(float, float); +extern int __ledf2(double, double); +extern int __letf2(long double, long double); + +extern int __gtsf2(float, float); +extern int __gtdf2(double, double); +extern int __gttf2(long double, long double); + +/* Not implemented yet */ +extern float __powisf2(float, int); +extern double __powidf2 (double, int); +extern long double __powitf2(long double, int); +extern long double __powixf2(long double, int); + +/* SPARC quadruple-precision wrappers */ +extern void _Qp_add(long double *, long double *, long double *); +extern void _Qp_sub(long double *, long double *, long double *); +extern void _Qp_mul(long double *, long double *, long double *); +extern void _Qp_div(long double *, long double *, long double *); +extern void _Qp_neg(long double *, long double *); + +extern void _Qp_stoq(long double *, float); +extern void _Qp_dtoq(long double *, double); +extern float _Qp_qtos(long double *); +extern double _Qp_qtod(long double *); + +extern int _Qp_qtoi(long double *); +extern unsigned int _Qp_qtoui(long double *); +extern long _Qp_qtox(long double *); +extern unsigned long _Qp_qtoux(long double *); + +extern void _Qp_itoq(long double *, int); +extern void _Qp_uitoq(long double *, unsigned int); +extern void _Qp_xtoq(long double *, long); +extern void _Qp_uxtoq(long double *, unsigned long); + +extern int _Qp_cmp(long double *, long double *); +extern int _Qp_cmpe(long double *, long double *); +extern int _Qp_feq(long double *, long double *); +extern int _Qp_fge(long double *, long double *); +extern int _Qp_fgt(long double *, long double *); +extern int _Qp_fle(long double*, long double *); +extern int _Qp_flt(long double *, long double *); +extern int _Qp_fne(long double *, long double *); + +/* ARM EABI */ +extern double __aeabi_i2d(int); +extern double __aeabi_ui2d(unsigned int); +extern unsigned int __aeabi_d2uiz(double); + +extern int __aeabi_f2iz(float); +extern int __aeabi_d2iz(double); + +extern int __aeabi_dcmpge(double, double); +extern int __aeabi_dcmpgt(double, double); +extern int __aeabi_dcmplt(double, double); +extern int __aeabi_dcmpeq(double, double); + +extern float __aeabi_fadd(float, float); +extern float __aeabi_fsub(float, float); +extern float __aeabi_fmul(float, float); +extern float __aeabi_fdiv(float, float); + +extern double __aeabi_dadd(double, double); +extern double __aeabi_dsub(double, double); +extern double __aeabi_dmul(double, double); +extern double __aeabi_ddiv(double, double); + +/* Not implemented yet */ +extern void _Qp_sqrt(long double *, long double *); + +#endif + +/** @} + */ Index: uspace/lib/softfloat/sub.c =================================================================== --- uspace/lib/softfloat/sub.c (revision 1dbd189b0e98a0f835bd872d52126bb32e841feb) +++ uspace/lib/softfloat/sub.c (revision 1dbd189b0e98a0f835bd872d52126bb32e841feb) @@ -0,0 +1,441 @@ +/* + * Copyright (c) 2005 Josef Cejka + * Copyright (c) 2011 Petr Koupy + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup softfloat + * @{ + */ +/** @file Substraction functions. + */ + +#include "sftypes.h" +#include "sub.h" +#include "comparison.h" +#include "common.h" + +/** Subtract two single-precision floats with the same sign. + * + * @param a First input operand. + * @param b Second input operand. + * + * @return Result of substraction. + * + */ +float32 sub_float32(float32 a, float32 b) +{ + int expdiff; + uint32_t exp1, exp2, frac1, frac2; + float32 result; + + result.bin = 0; + + expdiff = a.parts.exp - b.parts.exp; + if ((expdiff < 0 ) || ((expdiff == 0) && + (a.parts.fraction < b.parts.fraction))) { + if (is_float32_nan(b)) { + if (is_float32_signan(b)) { + // TODO: fix SigNaN + } + + return b; + } + + if (b.parts.exp == FLOAT32_MAX_EXPONENT) { + /* num -(+-inf) = -+inf */ + b.parts.sign = !b.parts.sign; + return b; + } + + result.parts.sign = !a.parts.sign; + + frac1 = b.parts.fraction; + exp1 = b.parts.exp; + frac2 = a.parts.fraction; + exp2 = a.parts.exp; + expdiff *= -1; + } else { + if (is_float32_nan(a)) { + if ((is_float32_signan(a)) || (is_float32_signan(b))) { + // TODO: fix SigNaN + } + + return a; + } + + if (a.parts.exp == FLOAT32_MAX_EXPONENT) { + if (b.parts.exp == FLOAT32_MAX_EXPONENT) { + /* inf - inf => nan */ + // TODO: fix exception + result.bin = FLOAT32_NAN; + return result; + } + + return a; + } + + result.parts.sign = a.parts.sign; + + frac1 = a.parts.fraction; + exp1 = a.parts.exp; + frac2 = b.parts.fraction; + exp2 = b.parts.exp; + } + + if (exp1 == 0) { + /* both are denormalized */ + result.parts.fraction = frac1 - frac2; + if (result.parts.fraction > frac1) { + // TODO: underflow exception + return result; + } + + result.parts.exp = 0; + return result; + } + + /* add hidden bit */ + frac1 |= FLOAT32_HIDDEN_BIT_MASK; + + if (exp2 == 0) { + /* denormalized */ + --expdiff; + } else { + /* normalized */ + frac2 |= FLOAT32_HIDDEN_BIT_MASK; + } + + /* create some space for rounding */ + frac1 <<= 6; + frac2 <<= 6; + + if (expdiff > FLOAT32_FRACTION_SIZE + 1) + goto done; + + frac1 = frac1 - (frac2 >> expdiff); + +done: + /* TODO: find first nonzero digit and shift result and detect possibly underflow */ + while ((exp1 > 0) && (!(frac1 & (FLOAT32_HIDDEN_BIT_MASK << 6 )))) { + --exp1; + frac1 <<= 1; + /* TODO: fix underflow - frac1 == 0 does not necessary means underflow... */ + } + + /* rounding - if first bit after fraction is set then round up */ + frac1 += 0x20; + + if (frac1 & (FLOAT32_HIDDEN_BIT_MASK << 7)) { + ++exp1; + frac1 >>= 1; + } + + /* Clear hidden bit and shift */ + result.parts.fraction = ((frac1 >> 6) & (~FLOAT32_HIDDEN_BIT_MASK)); + result.parts.exp = exp1; + + return result; +} + +/** Subtract two double-precision floats with the same sign. + * + * @param a First input operand. + * @param b Second input operand. + * + * @return Result of substraction. + * + */ +float64 sub_float64(float64 a, float64 b) +{ + int expdiff; + uint32_t exp1, exp2; + uint64_t frac1, frac2; + float64 result; + + result.bin = 0; + + expdiff = a.parts.exp - b.parts.exp; + if ((expdiff < 0 ) || + ((expdiff == 0) && (a.parts.fraction < b.parts.fraction))) { + if (is_float64_nan(b)) { + if (is_float64_signan(b)) { + // TODO: fix SigNaN + } + + return b; + } + + if (b.parts.exp == FLOAT64_MAX_EXPONENT) { + /* num -(+-inf) = -+inf */ + b.parts.sign = !b.parts.sign; + return b; + } + + result.parts.sign = !a.parts.sign; + + frac1 = b.parts.fraction; + exp1 = b.parts.exp; + frac2 = a.parts.fraction; + exp2 = a.parts.exp; + expdiff *= -1; + } else { + if (is_float64_nan(a)) { + if (is_float64_signan(a) || is_float64_signan(b)) { + // TODO: fix SigNaN + } + + return a; + } + + if (a.parts.exp == FLOAT64_MAX_EXPONENT) { + if (b.parts.exp == FLOAT64_MAX_EXPONENT) { + /* inf - inf => nan */ + // TODO: fix exception + result.bin = FLOAT64_NAN; + return result; + } + + return a; + } + + result.parts.sign = a.parts.sign; + + frac1 = a.parts.fraction; + exp1 = a.parts.exp; + frac2 = b.parts.fraction; + exp2 = b.parts.exp; + } + + if (exp1 == 0) { + /* both are denormalized */ + result.parts.fraction = frac1 - frac2; + if (result.parts.fraction > frac1) { + // TODO: underflow exception + return result; + } + + result.parts.exp = 0; + return result; + } + + /* add hidden bit */ + frac1 |= FLOAT64_HIDDEN_BIT_MASK; + + if (exp2 == 0) { + /* denormalized */ + --expdiff; + } else { + /* normalized */ + frac2 |= FLOAT64_HIDDEN_BIT_MASK; + } + + /* create some space for rounding */ + frac1 <<= 6; + frac2 <<= 6; + + if (expdiff > FLOAT64_FRACTION_SIZE + 1) + goto done; + + frac1 = frac1 - (frac2 >> expdiff); + +done: + /* TODO: find first nonzero digit and shift result and detect possibly underflow */ + while ((exp1 > 0) && (!(frac1 & (FLOAT64_HIDDEN_BIT_MASK << 6 )))) { + --exp1; + frac1 <<= 1; + /* TODO: fix underflow - frac1 == 0 does not necessary means underflow... */ + } + + /* rounding - if first bit after fraction is set then round up */ + frac1 += 0x20; + + if (frac1 & (FLOAT64_HIDDEN_BIT_MASK << 7)) { + ++exp1; + frac1 >>= 1; + } + + /* Clear hidden bit and shift */ + result.parts.fraction = ((frac1 >> 6) & (~FLOAT64_HIDDEN_BIT_MASK)); + result.parts.exp = exp1; + + return result; +} + +/** Subtract two quadruple-precision floats with the same sign. + * + * @param a First input operand. + * @param b Second input operand. + * + * @return Result of substraction. + * + */ +float128 sub_float128(float128 a, float128 b) +{ + int expdiff; + uint32_t exp1, exp2; + uint64_t frac1_hi, frac1_lo, frac2_hi, frac2_lo, tmp_hi, tmp_lo; + float128 result; + + result.bin.hi = 0; + result.bin.lo = 0; + + expdiff = a.parts.exp - b.parts.exp; + if ((expdiff < 0 ) || ((expdiff == 0) && + lt128(a.parts.frac_hi, a.parts.frac_lo, b.parts.frac_hi, b.parts.frac_lo))) { + if (is_float128_nan(b)) { + if (is_float128_signan(b)) { + // TODO: fix SigNaN + } + + return b; + } + + if (b.parts.exp == FLOAT128_MAX_EXPONENT) { + /* num -(+-inf) = -+inf */ + b.parts.sign = !b.parts.sign; + return b; + } + + result.parts.sign = !a.parts.sign; + + frac1_hi = b.parts.frac_hi; + frac1_lo = b.parts.frac_lo; + exp1 = b.parts.exp; + frac2_hi = a.parts.frac_hi; + frac2_lo = a.parts.frac_lo; + exp2 = a.parts.exp; + expdiff *= -1; + } else { + if (is_float128_nan(a)) { + if (is_float128_signan(a) || is_float128_signan(b)) { + // TODO: fix SigNaN + } + + return a; + } + + if (a.parts.exp == FLOAT128_MAX_EXPONENT) { + if (b.parts.exp == FLOAT128_MAX_EXPONENT) { + /* inf - inf => nan */ + // TODO: fix exception + result.bin.hi = FLOAT128_NAN_HI; + result.bin.lo = FLOAT128_NAN_LO; + return result; + } + return a; + } + + result.parts.sign = a.parts.sign; + + frac1_hi = a.parts.frac_hi; + frac1_lo = a.parts.frac_lo; + exp1 = a.parts.exp; + frac2_hi = b.parts.frac_hi; + frac2_lo = b.parts.frac_lo; + exp2 = b.parts.exp; + } + + if (exp1 == 0) { + /* both are denormalized */ + sub128(frac1_hi, frac1_lo, frac2_hi, frac2_lo, &tmp_hi, &tmp_lo); + result.parts.frac_hi = tmp_hi; + result.parts.frac_lo = tmp_lo; + if (lt128(frac1_hi, frac1_lo, result.parts.frac_hi, result.parts.frac_lo)) { + // TODO: underflow exception + return result; + } + + result.parts.exp = 0; + return result; + } + + /* add hidden bit */ + or128(frac1_hi, frac1_lo, + FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO, + &frac1_hi, &frac1_lo); + + if (exp2 == 0) { + /* denormalized */ + --expdiff; + } else { + /* normalized */ + or128(frac2_hi, frac2_lo, + FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO, + &frac2_hi, &frac2_lo); + } + + /* create some space for rounding */ + lshift128(frac1_hi, frac1_lo, 6, &frac1_hi, &frac1_lo); + lshift128(frac2_hi, frac2_lo, 6, &frac2_hi, &frac2_lo); + + if (expdiff > FLOAT128_FRACTION_SIZE + 1) + goto done; + + rshift128(frac2_hi, frac2_lo, expdiff, &tmp_hi, &tmp_lo); + sub128(frac1_hi, frac1_lo, tmp_hi, tmp_lo, &frac1_hi, &frac1_lo); + +done: + /* TODO: find first nonzero digit and shift result and detect possibly underflow */ + lshift128(FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO, 6, + &tmp_hi, &tmp_lo); + and128(frac1_hi, frac1_lo, tmp_hi, tmp_lo, &tmp_hi, &tmp_lo); + while ((exp1 > 0) && (!lt128(0x0ll, 0x0ll, tmp_hi, tmp_lo))) { + --exp1; + lshift128(frac1_hi, frac1_lo, 1, &frac1_hi, &frac1_lo); + /* TODO: fix underflow - frac1 == 0 does not necessary means underflow... */ + + lshift128(FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO, 6, + &tmp_hi, &tmp_lo); + and128(frac1_hi, frac1_lo, tmp_hi, tmp_lo, &tmp_hi, &tmp_lo); + } + + /* rounding - if first bit after fraction is set then round up */ + add128(frac1_hi, frac1_lo, 0x0ll, 0x20ll, &frac1_hi, &frac1_lo); + + lshift128(FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO, 7, + &tmp_hi, &tmp_lo); + and128(frac1_hi, frac1_lo, tmp_hi, tmp_lo, &tmp_hi, &tmp_lo); + if (lt128(0x0ll, 0x0ll, tmp_hi, tmp_lo)) { + ++exp1; + rshift128(frac1_hi, frac1_lo, 1, &frac1_hi, &frac1_lo); + } + + /* Clear hidden bit and shift */ + rshift128(frac1_hi, frac1_lo, 6, &frac1_hi, &frac1_lo); + not128(FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO, + &tmp_hi, &tmp_lo); + and128(frac1_hi, frac1_lo, tmp_hi, tmp_lo, &tmp_hi, &tmp_lo); + result.parts.frac_hi = tmp_hi; + result.parts.frac_lo = tmp_lo; + + result.parts.exp = exp1; + + return result; +} + +/** @} + */ Index: uspace/lib/softfloat/sub.h =================================================================== --- uspace/lib/softfloat/sub.h (revision 1dbd189b0e98a0f835bd872d52126bb32e841feb) +++ uspace/lib/softfloat/sub.h (revision 1dbd189b0e98a0f835bd872d52126bb32e841feb) @@ -0,0 +1,47 @@ +/* + * Copyright (c) 2005 Josef Cejka + * Copyright (c) 2011 Petr Koupy + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup softfloat + * @{ + */ +/** @file Substraction functions. + */ + +#ifndef __SUB_H__ +#define __SUB_H__ + +extern float32 sub_float32(float32, float32); +extern float64 sub_float64(float64, float64); +extern float96 sub_float96(float96, float96); +extern float128 sub_float128(float128, float128); + +#endif + +/** @} + */