Index: uspace/lib/softfloat/generic/mul.c =================================================================== --- uspace/lib/softfloat/generic/mul.c (revision c67aff2b73c9636ea0c229cdbf3bfc48af966545) +++ uspace/lib/softfloat/generic/mul.c (revision 9094c0f2b96cb7212fb3fbf06eaeffff70792f26) @@ -39,27 +39,28 @@ #include -/** - * Multiply two single-precision floats. +/** Multiply two single-precision floats. * * @param a First input operand. * @param b Second input operand. + * * @return Result of multiplication. - */ -float32 mulFloat32(float32 a, float32 b) + * + */ +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 (isFloat32NaN(a) || isFloat32NaN(b)) { + if (is_float32_nan(a) || is_float32_nan(b)) { /* TODO: fix SigNaNs */ - if (isFloat32SigNaN(a)) { + if (is_float32_signan(a)) { result.parts.fraction = a.parts.fraction; result.parts.exp = a.parts.exp; return result; } - if (isFloat32SigNaN(b)) { /* TODO: fix SigNaN */ + if (is_float32_signan(b)) { /* TODO: fix SigNaN */ result.parts.fraction = b.parts.fraction; result.parts.exp = b.parts.exp; @@ -67,12 +68,12 @@ } /* set NaN as result */ - result.binary = FLOAT32_NAN; - return result; - } - - if (isFloat32Infinity(a)) { - if (isFloat32Zero(b)) { - /* FIXME: zero * infinity */ - result.binary = FLOAT32_NAN; + 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; } @@ -81,9 +82,9 @@ return result; } - - if (isFloat32Infinity(b)) { - if (isFloat32Zero(a)) { - /* FIXME: zero * infinity */ - result.binary = FLOAT32_NAN; + + if (is_float32_infinity(b)) { + if (is_float32_zero(a)) { + /* FIXME: zero * infinity */ + result.bin = FLOAT32_NAN; return result; } @@ -92,5 +93,5 @@ return result; } - + /* exp is signed so we can easy detect underflow */ exp = a.parts.exp + b.parts.exp; @@ -100,5 +101,5 @@ /* FIXME: overflow */ /* set infinity as result */ - result.binary = FLOAT32_INF; + result.bin = FLOAT32_INF; result.parts.sign = a.parts.sign ^ b.parts.sign; return result; @@ -121,5 +122,5 @@ frac2 = b.parts.fraction; - + if (b.parts.exp > 0) { frac2 |= FLOAT32_HIDDEN_BIT_MASK; @@ -127,26 +128,28 @@ ++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)))) { + 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)))) { + if ((exp < FLOAT32_MAX_EXPONENT) && + (frac1 >= (1 << (FLOAT32_FRACTION_SIZE + 1)))) { ++exp; frac1 >>= 1; } - - if (exp >= FLOAT32_MAX_EXPONENT) { + + if (exp >= FLOAT32_MAX_EXPONENT) { /* TODO: fix overflow */ /* return infinity*/ @@ -157,6 +160,6 @@ exp -= FLOAT32_FRACTION_SIZE; - - if (exp <= FLOAT32_FRACTION_SIZE) { + + if (exp <= FLOAT32_FRACTION_SIZE) { /* denormalized number */ frac1 >>= 1; /* denormalize */ @@ -175,30 +178,31 @@ result.parts.fraction = frac1 & ((1 << FLOAT32_FRACTION_SIZE) - 1); - return result; + return result; } -/** - * Multiply two double-precision floats. +/** Multiply two double-precision floats. * * @param a First input operand. * @param b Second input operand. + * * @return Result of multiplication. - */ -float64 mulFloat64(float64 a, float64 b) + * + */ +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 (isFloat64NaN(a) || isFloat64NaN(b)) { + if (is_float64_nan(a) || is_float64_nan(b)) { /* TODO: fix SigNaNs */ - if (isFloat64SigNaN(a)) { + if (is_float64_signan(a)) { result.parts.fraction = a.parts.fraction; result.parts.exp = a.parts.exp; return result; } - if (isFloat64SigNaN(b)) { /* TODO: fix SigNaN */ + if (is_float64_signan(b)) { /* TODO: fix SigNaN */ result.parts.fraction = b.parts.fraction; result.parts.exp = b.parts.exp; @@ -206,12 +210,12 @@ } /* set NaN as result */ - result.binary = FLOAT64_NAN; - return result; - } - - if (isFloat64Infinity(a)) { - if (isFloat64Zero(b)) { - /* FIXME: zero * infinity */ - result.binary = FLOAT64_NAN; + 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; } @@ -220,9 +224,9 @@ return result; } - - if (isFloat64Infinity(b)) { - if (isFloat64Zero(a)) { - /* FIXME: zero * infinity */ - result.binary = FLOAT64_NAN; + + if (is_float64_infinity(b)) { + if (is_float64_zero(a)) { + /* FIXME: zero * infinity */ + result.bin = FLOAT64_NAN; return result; } @@ -231,10 +235,10 @@ 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; @@ -244,5 +248,5 @@ frac2 = b.parts.fraction; - + if (b.parts.exp > 0) { frac2 |= FLOAT64_HIDDEN_BIT_MASK; @@ -250,10 +254,10 @@ ++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)) { @@ -261,27 +265,28 @@ exp--; } - - result = finishFloat64(exp, frac1, result.parts.sign); + + result = finish_float64(exp, frac1, result.parts.sign); return result; } -/** - * Multiply two quadruple-precision floats. +/** Multiply two quadruple-precision floats. * * @param a First input operand. * @param b Second input operand. + * * @return Result of multiplication. - */ -float128 mulFloat128(float128 a, float128 b) + * + */ +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 (isFloat128NaN(a) || isFloat128NaN(b)) { + + if (is_float128_nan(a) || is_float128_nan(b)) { /* TODO: fix SigNaNs */ - if (isFloat128SigNaN(a)) { + if (is_float128_signan(a)) { result.parts.frac_hi = a.parts.frac_hi; result.parts.frac_lo = a.parts.frac_lo; @@ -289,5 +294,5 @@ return result; } - if (isFloat128SigNaN(b)) { /* TODO: fix SigNaN */ + if (is_float128_signan(b)) { /* TODO: fix SigNaN */ result.parts.frac_hi = b.parts.frac_hi; result.parts.frac_lo = b.parts.frac_lo; @@ -296,14 +301,14 @@ } /* set NaN as result */ - result.binary.hi = FLOAT128_NAN_HI; - result.binary.lo = FLOAT128_NAN_LO; - return result; - } - - if (isFloat128Infinity(a)) { - if (isFloat128Zero(b)) { - /* FIXME: zero * infinity */ - result.binary.hi = FLOAT128_NAN_HI; - result.binary.lo = FLOAT128_NAN_LO; + 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; } @@ -313,10 +318,10 @@ return result; } - - if (isFloat128Infinity(b)) { - if (isFloat128Zero(a)) { - /* FIXME: zero * infinity */ - result.binary.hi = FLOAT128_NAN_HI; - result.binary.lo = FLOAT128_NAN_LO; + + 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; } @@ -326,22 +331,22 @@ 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; - } - + 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, @@ -351,8 +356,8 @@ ++exp; } - + lshift128(frac2_hi, frac2_lo, 128 - FLOAT128_FRACTION_SIZE, &frac2_hi, &frac2_lo); - + tmp_hi = frac1_hi; tmp_lo = frac1_lo; @@ -361,5 +366,5 @@ 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; @@ -370,6 +375,6 @@ ++exp; } - - result = finishFloat128(exp, frac1_hi, frac1_lo, result.parts.sign, frac2_hi); + + result = finish_float128(exp, frac1_hi, frac1_lo, result.parts.sign, frac2_hi); return result; }