Index: uspace/lib/softfloat/generic/conversion.c =================================================================== --- uspace/lib/softfloat/generic/conversion.c (revision c67aff2b73c9636ea0c229cdbf3bfc48af966545) +++ uspace/lib/softfloat/generic/conversion.c (revision 4d194beedbc53e41134a652c4e3d8be31fecff2b) @@ -39,5 +39,5 @@ #include -float64 convertFloat32ToFloat64(float32 a) +float64 float32_to_float64(float32 a) { float64 result; @@ -48,7 +48,7 @@ result.parts.fraction <<= (FLOAT64_FRACTION_SIZE - FLOAT32_FRACTION_SIZE); - if ((isFloat32Infinity(a)) || (isFloat32NaN(a))) { + if ((is_float32_infinity(a)) || (is_float32_nan(a))) { result.parts.exp = FLOAT64_MAX_EXPONENT; - /* TODO; check if its correct for SigNaNs*/ + // TODO; check if its correct for SigNaNs return result; } @@ -57,5 +57,5 @@ if (a.parts.exp == 0) { /* normalize denormalized numbers */ - + if (result.parts.fraction == 0) { /* fix zero */ result.parts.exp = 0; @@ -77,10 +77,10 @@ } -float128 convertFloat32ToFloat128(float32 a) +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; @@ -91,15 +91,15 @@ result.parts.frac_hi = frac_hi; result.parts.frac_lo = frac_lo; - - if ((isFloat32Infinity(a)) || (isFloat32NaN(a))) { + + if ((is_float32_infinity(a)) || (is_float32_nan(a))) { result.parts.exp = FLOAT128_MAX_EXPONENT; - /* TODO; check if its correct for SigNaNs*/ - return result; - } - + // 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 */ @@ -107,8 +107,8 @@ 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, @@ -118,19 +118,19 @@ --result.parts.exp; } - + ++result.parts.exp; result.parts.frac_hi = frac_hi; result.parts.frac_lo = frac_lo; } - - return result; -} - -float128 convertFloat64ToFloat128(float64 a) + + 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; @@ -141,15 +141,15 @@ result.parts.frac_hi = frac_hi; result.parts.frac_lo = frac_lo; - - if ((isFloat64Infinity(a)) || (isFloat64NaN(a))) { + + if ((is_float64_infinity(a)) || (is_float64_nan(a))) { result.parts.exp = FLOAT128_MAX_EXPONENT; - /* TODO; check if its correct for SigNaNs*/ - return result; - } - + // 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 */ @@ -157,8 +157,8 @@ 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, @@ -168,14 +168,14 @@ --result.parts.exp; } - + ++result.parts.exp; result.parts.frac_hi = frac_hi; result.parts.frac_lo = frac_lo; } - - return result; -} - -float32 convertFloat64ToFloat32(float64 a) + + return result; +} + +float32 float64_to_float32(float64 a) { float32 result; @@ -185,24 +185,24 @@ result.parts.sign = a.parts.sign; - if (isFloat64NaN(a)) { + if (is_float64_nan(a)) { result.parts.exp = FLOAT32_MAX_EXPONENT; - if (isFloat64SigNaN(a)) { + 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 (isFloat64Infinity(a)) { + + 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; @@ -239,5 +239,5 @@ return result; } - + result.parts.exp = exp; result.parts.fraction = @@ -246,34 +246,34 @@ } -float32 convertFloat128ToFloat32(float128 a) +float32 float128_to_float32(float128 a) { float32 result; int32_t exp; uint64_t frac_hi, frac_lo; - + result.parts.sign = a.parts.sign; - - if (isFloat128NaN(a)) { + + if (is_float128_nan(a)) { result.parts.exp = FLOAT32_MAX_EXPONENT; - - if (isFloat128SigNaN(a)) { + + 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 (isFloat128Infinity(a)) { + + 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 */ @@ -283,7 +283,7 @@ } else if (exp <= 0) { /* underflow or denormalized */ - + result.parts.exp = 0; - + exp *= -1; if (exp > FLOAT32_FRACTION_SIZE) { @@ -292,17 +292,17 @@ 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; @@ -310,8 +310,8 @@ } result.parts.fraction = frac_lo; - - return result; - } - + + return result; + } + result.parts.exp = exp; frac_hi = a.parts.frac_hi; @@ -324,34 +324,34 @@ } -float64 convertFloat128ToFloat64(float128 a) +float64 float128_to_float64(float128 a) { float64 result; int32_t exp; uint64_t frac_hi, frac_lo; - + result.parts.sign = a.parts.sign; - - if (isFloat128NaN(a)) { + + if (is_float128_nan(a)) { result.parts.exp = FLOAT64_MAX_EXPONENT; - - if (isFloat128SigNaN(a)) { + + 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 (isFloat128Infinity(a)) { + + 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 */ @@ -361,7 +361,7 @@ } else if (exp <= 0) { /* underflow or denormalized */ - + result.parts.exp = 0; - + exp *= -1; if (exp > FLOAT64_FRACTION_SIZE) { @@ -370,17 +370,17 @@ 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; @@ -388,8 +388,8 @@ } result.parts.fraction = frac_lo; - - return result; - } - + + return result; + } + result.parts.exp = exp; frac_hi = a.parts.frac_hi; @@ -402,7 +402,5 @@ } - -/** - * Helping procedure for converting float32 to uint32. +/** Helper procedure for converting float32 to uint32. * * @param a Floating point number in normalized form @@ -424,5 +422,5 @@ /* 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)) { @@ -434,14 +432,14 @@ } -/* - * FIXME: Im not sure what to return if overflow/underflow happens - * - now its the biggest or the smallest int - */ +/* + * 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 (isFloat32NaN(a)) + if (is_float32_nan(a)) return UINT32_MAX; - if (isFloat32Infinity(a) || (a.parts.exp >= (32 + FLOAT32_BIAS))) { + if (is_float32_infinity(a) || (a.parts.exp >= (32 + FLOAT32_BIAS))) { if (a.parts.sign) return UINT32_MIN; @@ -453,14 +451,14 @@ } -/* - * FIXME: Im not sure what to return if overflow/underflow happens - * - now its the biggest or the smallest int - */ +/* + * 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 (isFloat32NaN(a)) + if (is_float32_nan(a)) return INT32_MAX; - if (isFloat32Infinity(a) || (a.parts.exp >= (32 + FLOAT32_BIAS))) { + if (is_float32_infinity(a) || (a.parts.exp >= (32 + FLOAT32_BIAS))) { if (a.parts.sign) return INT32_MIN; @@ -472,7 +470,5 @@ } - -/** - * Helping procedure for converting float32 to uint64. +/** Helper procedure for converting float32 to uint64. * * @param a Floating point number in normalized form @@ -483,16 +479,16 @@ { uint64_t frac; - + if (a.parts.exp < FLOAT32_BIAS) { - /*TODO: rounding*/ + // 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)) { @@ -500,50 +496,47 @@ ++frac; } - + return frac; } -/* +/* * FIXME: Im not sure what to return if overflow/underflow happens - * - now its the biggest or the smallest int + * - now its the biggest or the smallest int */ uint64_t float32_to_uint64(float32 a) { - if (isFloat32NaN(a)) + if (is_float32_nan(a)) return UINT64_MAX; - - - if (isFloat32Infinity(a) || (a.parts.exp >= (64 + FLOAT32_BIAS))) { + + 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 + * - now its the biggest or the smallest int */ int64_t float32_to_int64(float32 a) { - if (isFloat32NaN(a)) + if (is_float32_nan(a)) return INT64_MAX; - - if (isFloat32Infinity(a) || (a.parts.exp >= (64 + FLOAT32_BIAS))) { + + 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); } - -/** - * Helping procedure for converting float64 to uint64. +/** Helper procedure for converting float64 to uint64. * * @param a Floating point number in normalized form @@ -554,16 +547,16 @@ { uint64_t frac; - + if (a.parts.exp < FLOAT64_BIAS) { - /*TODO: rounding*/ + // 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)) { @@ -571,5 +564,5 @@ ++frac; } - + return frac; } @@ -577,18 +570,18 @@ /* * FIXME: Im not sure what to return if overflow/underflow happens - * - now its the biggest or the smallest int + * - now its the biggest or the smallest int */ uint32_t float64_to_uint32(float64 a) { - if (isFloat64NaN(a)) + if (is_float64_nan(a)) return UINT32_MAX; - - if (isFloat64Infinity(a) || (a.parts.exp >= (32 + FLOAT64_BIAS))) { + + 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); } @@ -596,32 +589,31 @@ /* * FIXME: Im not sure what to return if overflow/underflow happens - * - now its the biggest or the smallest int + * - now its the biggest or the smallest int */ int32_t float64_to_int32(float64 a) { - if (isFloat64NaN(a)) + if (is_float64_nan(a)) return INT32_MAX; - - if (isFloat64Infinity(a) || (a.parts.exp >= (32 + FLOAT64_BIAS))) { + + 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 - */ + * - now its the biggest or the smallest int + */ uint64_t float64_to_uint64(float64 a) { - if (isFloat64NaN(a)) + if (is_float64_nan(a)) return UINT64_MAX; - if (isFloat64Infinity(a) || (a.parts.exp >= (64 + FLOAT64_BIAS))) { + if (is_float64_infinity(a) || (a.parts.exp >= (64 + FLOAT64_BIAS))) { if (a.parts.sign) return UINT64_MIN; @@ -633,14 +625,14 @@ } -/* +/* * FIXME: Im not sure what to return if overflow/underflow happens - * - now its the biggest or the smallest int - */ + * - now its the biggest or the smallest int + */ int64_t float64_to_int64(float64 a) { - if (isFloat64NaN(a)) + if (is_float64_nan(a)) return INT64_MAX; - if (isFloat64Infinity(a) || (a.parts.exp >= (64 + FLOAT64_BIAS))) { + if (is_float64_infinity(a) || (a.parts.exp >= (64 + FLOAT64_BIAS))) { if (a.parts.sign) return INT64_MIN; @@ -652,7 +644,5 @@ } - -/** - * Helping procedure for converting float128 to uint64. +/** Helper procedure for converting float128 to uint64. * * @param a Floating point number in normalized form @@ -663,18 +653,18 @@ { uint64_t frac_hi, frac_lo; - + if (a.parts.exp < FLOAT128_BIAS) { - /*TODO: rounding*/ + // 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); @@ -683,5 +673,5 @@ add128(frac_hi, frac_lo, 0x0ll, 0x1ll, &frac_hi, &frac_lo); } - + return frac_lo; } @@ -689,18 +679,18 @@ /* * FIXME: Im not sure what to return if overflow/underflow happens - * - now its the biggest or the smallest int + * - now its the biggest or the smallest int */ uint32_t float128_to_uint32(float128 a) { - if (isFloat128NaN(a)) + if (is_float128_nan(a)) return UINT32_MAX; - - if (isFloat128Infinity(a) || (a.parts.exp >= (32 + FLOAT128_BIAS))) { + + 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); } @@ -708,38 +698,37 @@ /* * FIXME: Im not sure what to return if overflow/underflow happens - * - now its the biggest or the smallest int + * - now its the biggest or the smallest int */ int32_t float128_to_int32(float128 a) { - if (isFloat128NaN(a)) + if (is_float128_nan(a)) return INT32_MAX; - - if (isFloat128Infinity(a) || (a.parts.exp >= (32 + FLOAT128_BIAS))) { + + 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 + * - now its the biggest or the smallest int */ uint64_t float128_to_uint64(float128 a) { - if (isFloat128NaN(a)) + if (is_float128_nan(a)) return UINT64_MAX; - - if (isFloat128Infinity(a) || (a.parts.exp >= (64 + FLOAT128_BIAS))) { + + 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); } @@ -747,21 +736,20 @@ /* * FIXME: Im not sure what to return if overflow/underflow happens - * - now its the biggest or the smallest int + * - now its the biggest or the smallest int */ int64_t float128_to_int64(float128 a) { - if (isFloat128NaN(a)) + if (is_float128_nan(a)) return INT64_MAX; - - if (isFloat128Infinity(a) || (a.parts.exp >= (64 + FLOAT128_BIAS))) { + + 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) @@ -773,11 +761,11 @@ result.parts.sign = 0; result.parts.fraction = 0; - - counter = countZeroes32(i); - + + counter = count_zeroes32(i); + exp = FLOAT32_BIAS + 32 - counter - 1; if (counter == 32) { - result.binary = 0; + result.bin = 0; return result; } @@ -788,30 +776,28 @@ i >>= 1; } - - roundFloat32(&exp, &i); - + + 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) + + return result; +} + +float32 int32_to_float32(int32_t i) { float32 result; - - if (i < 0) { + + if (i < 0) result = uint32_to_float32((uint32_t) (-i)); - } else { + else result = uint32_to_float32((uint32_t) i); - } result.parts.sign = i < 0; - - return result; -} - - -float32 uint64_to_float32(uint64_t i) + + return result; +} + +float32 uint64_to_float32(uint64_t i) { int counter; @@ -822,11 +808,11 @@ result.parts.sign = 0; result.parts.fraction = 0; - - counter = countZeroes64(i); - + + counter = count_zeroes64(i); + exp = FLOAT32_BIAS + 64 - counter - 1; if (counter == 64) { - result.binary = 0; + result.bin = 0; return result; } @@ -840,6 +826,6 @@ j = (uint32_t) i; - roundFloat32(&exp, &j); - + round_float32(&exp, &j); + result.parts.fraction = j >> (32 - FLOAT32_FRACTION_SIZE - 2); result.parts.exp = exp; @@ -847,17 +833,16 @@ } -float32 int64_to_float32(int64_t i) +float32 int64_to_float32(int64_t i) { float32 result; - - if (i < 0) { + + if (i < 0) result = uint64_to_float32((uint64_t) (-i)); - } else { + else result = uint64_to_float32((uint64_t) i); - } result.parts.sign = i < 0; - - return result; + + return result; } @@ -871,42 +856,41 @@ result.parts.sign = 0; result.parts.fraction = 0; - - counter = countZeroes32(i); - + + counter = count_zeroes32(i); + exp = FLOAT64_BIAS + 32 - counter - 1; if (counter == 32) { - result.binary = 0; + result.bin = 0; return result; } frac = i; - frac <<= counter + 32 - 1; - - roundFloat64(&exp, &frac); - + 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) + + return result; +} + +float64 int32_to_float64(int32_t i) { float64 result; - - if (i < 0) { + + if (i < 0) result = uint32_to_float64((uint32_t) (-i)); - } else { + else result = uint32_to_float64((uint32_t) i); - } result.parts.sign = i < 0; - - return result; -} - - -float64 uint64_to_float64(uint64_t i) + + return result; +} + + +float64 uint64_to_float64(uint64_t i) { int counter; @@ -916,11 +900,11 @@ result.parts.sign = 0; result.parts.fraction = 0; - - counter = countZeroes64(i); - + + counter = count_zeroes64(i); + exp = FLOAT64_BIAS + 64 - counter - 1; if (counter == 64) { - result.binary = 0; + result.bin = 0; return result; } @@ -931,7 +915,7 @@ i >>= 1; } - - roundFloat64(&exp, &i); - + + round_float64(&exp, &i); + result.parts.fraction = i >> (64 - FLOAT64_FRACTION_SIZE - 2); result.parts.exp = exp; @@ -939,19 +923,17 @@ } -float64 int64_to_float64(int64_t i) +float64 int64_to_float64(int64_t i) { float64 result; - - if (i < 0) { + + if (i < 0) result = uint64_to_float64((uint64_t) (-i)); - } else { + else result = uint64_to_float64((uint64_t) i); - } result.parts.sign = i < 0; - - return result; -} - + + return result; +} float128 uint32_to_float128(uint32_t i) @@ -961,25 +943,25 @@ float128 result; uint64_t frac_hi, frac_lo; - + result.parts.sign = 0; result.parts.frac_hi = 0; result.parts.frac_lo = 0; - - counter = countZeroes32(i); - + + counter = count_zeroes32(i); + exp = FLOAT128_BIAS + 32 - counter - 1; - + if (counter == 32) { - result.binary.hi = 0; - result.binary.lo = 0; - return result; - } - + 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); - - roundFloat128(&exp, &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); @@ -987,5 +969,5 @@ result.parts.frac_lo = frac_lo; result.parts.exp = exp; - + return result; } @@ -994,14 +976,13 @@ { float128 result; - - if (i < 0) { + + if (i < 0) result = uint32_to_float128((uint32_t) (-i)); - } else { + else result = uint32_to_float128((uint32_t) i); - } - + result.parts.sign = i < 0; - - return result; + + return result; } @@ -1013,25 +994,25 @@ float128 result; uint64_t frac_hi, frac_lo; - + result.parts.sign = 0; result.parts.frac_hi = 0; result.parts.frac_lo = 0; - - counter = countZeroes64(i); - + + counter = count_zeroes64(i); + exp = FLOAT128_BIAS + 64 - counter - 1; - + if (counter == 64) { - result.binary.hi = 0; - result.binary.lo = 0; - return result; - } - + 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); - - roundFloat128(&exp, &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); @@ -1039,5 +1020,5 @@ result.parts.frac_lo = frac_lo; result.parts.exp = exp; - + return result; } @@ -1046,14 +1027,13 @@ { float128 result; - - if (i < 0) { + + if (i < 0) result = uint64_to_float128((uint64_t) (-i)); - } else { + else result = uint64_to_float128((uint64_t) i); - } - + result.parts.sign = i < 0; - - return result; + + return result; }