Changeset a35b458 in mainline for uspace/lib/softfloat

Timestamp:

2018-03-02T20:10:49Z (7 years ago)

Author:

Jiří Zárevúcky <zarevucky.jiri@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

f1380b7

Parents:

3061bc1

git-author:

Jiří Zárevúcky <zarevucky.jiri@…> (2018-02-28 17:38:31)

git-committer:

Jiří Zárevúcky <zarevucky.jiri@…> (2018-03-02 20:10:49)

Message:

style: Remove trailing whitespace on _all_ lines, including empty ones, for particular file types.

Command used: tools/srepl '\s\+$' '' -- *.c *.h *.py *.sh *.s *.S *.ag

Currently, whitespace on empty lines is very inconsistent.
There are two basic choices: Either remove the whitespace, or keep empty lines
indented to the level of surrounding code. The former is AFAICT more common,
and also much easier to do automatically.

Alternatively, we could write script for automatic indentation, and use that
instead. However, if such a script exists, it's possible to use the indented
style locally, by having the editor apply relevant conversions on load/save,
without affecting remote repository. IMO, it makes more sense to adopt
the simpler rule.

Location:

uspace/lib/softfloat

Files:

• add.c (modified) (29 diffs)
• common.c (modified) (9 diffs)
• comparison.c (modified) (48 diffs)
• conversion.c (modified) (113 diffs)
• div.c (modified) (44 diffs)
• mul.c (modified) (33 diffs)
• neg.c (modified) (3 diffs)
• sub.c (modified) (39 diffs)

uspace/lib/softfloat/add.c

@@ -49 +49 @@
         int expdiff;
         uint32_t exp1, exp2, frac1, frac2;
-        
+
         expdiff = a.parts.exp - b.parts.exp;
         if (expdiff < 0) {
@@ -59 +59 @@
                         return b;
                 }
-                
+
                 if (b.parts.exp == FLOAT32_MAX_EXPONENT) {
                         return b;
                 }
-                
+
                 frac1 = b.parts.fraction;
                 exp1 = b.parts.exp;
@@ -76 +76 @@
                         return (is_float32_nan(a) ? a : b);
                 }
-                
+
                 if (a.parts.exp == FLOAT32_MAX_EXPONENT) {
                         return a;
                 }
-                
+
                 frac1 = a.parts.fraction;
                 exp1 = a.parts.exp;
@@ -86 +86 @@
                 exp2 = b.parts.exp;
         }
-        
+
         if (exp1 == 0) {
                 /* both are denormalized */
@@ -97 +97 @@
                 return a;
         }
-        
+
         frac1 |= FLOAT32_HIDDEN_BIT_MASK; /* add hidden bit */
 
@@ -107 +107 @@
                 frac2 |= FLOAT32_HIDDEN_BIT_MASK;
         }
-        
+
         /* create some space for rounding */
         frac1 <<= 6;
         frac2 <<= 6;
-        
+
         if (expdiff < (FLOAT32_FRACTION_SIZE + 2)) {
                 frac2 >>= expdiff;
@@ -120 +120 @@
                 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 */
@@ -134 +134 @@
                 frac1 >>= 1;
         }
-        
+
         if ((exp1 == FLOAT32_MAX_EXPONENT) || (exp2 > exp1)) {
                 /* overflow - set infinity as result */
@@ -141 +141 @@
                 return a;
         }
-        
+
         a.parts.exp = exp1;
-        
+
         /* Clear hidden bit and shift */
         a.parts.fraction = ((frac1 >> 6) & (~FLOAT32_HIDDEN_BIT_MASK));
@@ -160 +160 @@
         uint32_t exp1, exp2;
         uint64_t frac1, frac2;
-        
+
         expdiff = ((int) a.parts.exp) - b.parts.exp;
         if (expdiff < 0) {
@@ -170 +170 @@
                         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;
@@ -188 +188 @@
                         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;
@@ -199 +199 @@
                 exp2 = b.parts.exp;
         }
-        
+
         if (exp1 == 0) {
                 /* both are denormalized */
@@ -210 +210 @@
                 return a;
         }
-        
+
         /* add hidden bit - frac1 is sure not denormalized */
         frac1 |= FLOAT64_HIDDEN_BIT_MASK;
@@ -222 +222 @@
                 frac2 |= FLOAT64_HIDDEN_BIT_MASK;
         }
-        
+
         /* create some space for rounding */
         frac1 <<= 6;
         frac2 <<= 6;
-        
+
         if (expdiff < (FLOAT64_FRACTION_SIZE + 2)) {
                 frac2 >>= expdiff;
@@ -235 +235 @@
                 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 */
@@ -249 +249 @@
                 frac1 >>= 1;
         }
-        
+
         if ((exp1 == FLOAT64_MAX_EXPONENT) || (exp2 > exp1)) {
                 /* overflow - set infinity as result */
@@ -256 +256 @@
                 return a;
         }
-        
+
         a.parts.exp = exp1;
         /* Clear hidden bit and shift */
@@ -400 +400 @@
 
         a.parts.exp = exp1;
-        
+
         /* Clear hidden bit and shift */
         rshift128(frac1_hi, frac1_lo, 6, &frac1_hi, &frac1_lo);
@@ -419 +419 @@
         float32_u ua;
         ua.val = a;
-        
+
         float32_u ub;
         ub.val = b;
-        
+
         float32_u res;
-        
+
         if (ua.data.parts.sign != ub.data.parts.sign) {
                 if (ua.data.parts.sign) {
@@ -435 +435 @@
         } else
                 res.data = add_float32(ua.data, ub.data);
-        
+
         return res.val;
 }
@@ -443 +443 @@
         float32_u ua;
         ua.val = a;
-        
+
         float32_u ub;
         ub.val = b;
-        
+
         float32_u res;
-        
+
         if (ua.data.parts.sign != ub.data.parts.sign) {
                 if (ua.data.parts.sign) {
@@ -459 +459 @@
         } else
                 res.data = add_float32(ua.data, ub.data);
-        
+
         return res.val;
 }
@@ -471 +471 @@
         float64_u ua;
         ua.val = a;
-        
+
         float64_u ub;
         ub.val = b;
-        
+
         float64_u res;
-        
+
         if (ua.data.parts.sign != ub.data.parts.sign) {
                 if (ua.data.parts.sign) {
@@ -487 +487 @@
         } else
                 res.data = add_float64(ua.data, ub.data);
-        
+
         return res.val;
 }
@@ -495 +495 @@
         float64_u ua;
         ua.val = a;
-        
+
         float64_u ub;
         ub.val = b;
-        
+
         float64_u res;
-        
+
         if (ua.data.parts.sign != ub.data.parts.sign) {
                 if (ua.data.parts.sign) {
@@ -511 +511 @@
         } else
                 res.data = add_float64(ua.data, ub.data);
-        
+
         return res.val;
 }
@@ -523 +523 @@
         float128_u ua;
         ua.val = a;
-        
+
         float128_u ub;
         ub.val = b;
-        
+
         float128_u res;
-        
+
         if (ua.data.parts.sign != ub.data.parts.sign) {
                 if (ua.data.parts.sign) {
@@ -539 +539 @@
         } else
                 res.data = add_float128(ua.data, ub.data);
-        
+
         return res.val;
 }

uspace/lib/softfloat/common.c

@@ -78 +78 @@
                 /* TODO: fix underflow */
         }
-        
+
         if ((cexp < 0) || (cexp == 0 &&
             (!(cfrac & (FLOAT64_HIDDEN_BIT_MASK << (64 - FLOAT64_FRACTION_SIZE - 1)))))) {
@@ -87 +87 @@
                         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 =
@@ -103 +103 @@
                 cfrac += (0x1 << (64 - FLOAT64_FRACTION_SIZE - 3));
         }
-        
+
         ++cexp;
 
@@ -120 +120 @@
 
         result.parts.exp = (uint32_t) cexp;
-        
+
         result.parts.fraction =
             ((cfrac >> (64 - FLOAT64_FRACTION_SIZE - 2)) & (~FLOAT64_HIDDEN_BIT_MASK));
-        
+
         return result;
 }
@@ -289 +289 @@
         /* 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))) {
@@ -296 +296 @@
                 (*fraction) >>= 1;
         }
-        
+
         if (((*exp) >= FLOAT32_MAX_EXPONENT) || ((*exp) < 0)) {
                 /* overflow - set infinity as result */
@@ -322 +322 @@
          */
         (*fraction) += (0x1 << (64 - FLOAT64_FRACTION_SIZE - 3));
-        
+
         /* See if there was a carry to bit 63. */
         if ((*fraction) &
@@ -330 +330 @@
                 (*fraction) >>= 1;
         }
-        
+
         if (((*exp) >= FLOAT64_MAX_EXPONENT) || ((*exp) < 0)) {
                 /* overflow - set infinity as result */
@@ -677 +677 @@
         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;

uspace/lib/softfloat/comparison.c

@@ -190 +190 @@
         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);
 }
@@ -236 +236 @@
         uint64_t tmp_hi;
         uint64_t tmp_lo;
-        
+
         /* both are zeros (with any sign) */
         or128(a.bin.hi, a.bin.lo,
@@ -243 +243 @@
             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;
 }
@@ -263 +263 @@
                 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
@@ -292 +292 @@
                 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
@@ -319 +319 @@
         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);
@@ -328 +328 @@
                 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
@@ -357 +357 @@
                 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
@@ -386 +386 @@
                 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
@@ -413 +413 @@
         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);
@@ -422 +422 @@
                 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
@@ -444 +444 @@
         float32_u ua;
         ua.val = a;
-        
+
         float32_u ub;
         ub.val = b;
-        
+
         if ((is_float32_nan(ua.data)) || (is_float32_nan(ub.data))) {
                 // TODO: sigNaNs
                 return -1;
         }
-        
+
         if (is_float32_gt(ua.data, ub.data))
                 return 1;
-        
+
         return 0;
 }
@@ -463 +463 @@
         float32_u ua;
         ua.val = a;
-        
+
         float32_u ub;
         ub.val = b;
-        
+
         if ((is_float32_nan(ua.data)) || (is_float32_nan(ub.data))) {
                 // TODO: sigNaNs
                 return -1;
         }
-        
+
         if (is_float32_eq(ua.data, ub.data))
                 return 0;
-        
+
         if (is_float32_gt(ua.data, ub.data))
                 return 1;
-        
+
         return -1;
 }
@@ -485 +485 @@
         float32_u ua;
         ua.val = a;
-        
+
         float32_u ub;
         ub.val = b;
-        
+
         if ((is_float32_nan(ua.data)) || (is_float32_nan(ub.data))) {
                 // TODO: sigNaNs
                 return 1;
         }
-        
+
         if (is_float32_lt(ua.data, ub.data))
                 return -1;
-        
+
         return 0;
 }
@@ -504 +504 @@
         float32_u ua;
         ua.val = a;
-        
+
         float32_u ub;
         ub.val = b;
-        
+
         if ((is_float32_nan(ua.data)) || (is_float32_nan(ub.data))) {
                 // TODO: sigNaNs
                 return 1;
         }
-        
+
         if (is_float32_eq(ua.data, ub.data))
                 return 0;
-        
+
         if (is_float32_lt(ua.data, ub.data))
                 return -1;
-        
+
         return 1;
 }
@@ -526 +526 @@
         float32_u ua;
         ua.val = a;
-        
+
         float32_u ub;
         ub.val = b;
-        
+
         if ((is_float32_nan(ua.data)) || (is_float32_nan(ub.data))) {
                 // TODO: sigNaNs
                 return 1;
         }
-        
+
         return is_float32_eq(ua.data, ub.data) - 1;
 }
@@ -548 +548 @@
         float32_u ua;
         ua.val = a;
-        
+
         float32_u ub;
         ub.val = b;
-        
+
         if ((is_float32_nan(ua.data)) || (is_float32_nan(ub.data))) {
                 /* No special constant for unordered - maybe signaled? */
                 return 1;
         }
-        
+
         if (is_float32_eq(ua.data, ub.data))
                 return 0;
-        
+
         if (is_float32_lt(ua.data, ub.data))
                 return -1;
-        
+
         return 1;
 }
@@ -570 +570 @@
         float32_u ua;
         ua.val = a;
-        
+
         float32_u ub;
         ub.val = b;
-        
+
         return ((is_float32_nan(ua.data)) || (is_float32_nan(ub.data)));
 }
@@ -581 +581 @@
         float32_u ua;
         ua.val = a;
-        
+
         float32_u ub;
         ub.val = b;
-        
+
         if ((is_float32_nan(ua.data)) || (is_float32_nan(ub.data))) {
                 // TODO: sigNaNs
                 return -1;
         }
-        
+
         if (is_float32_gt(ua.data, ub.data))
                 return 1;
-        
+
         return 0;
 }
@@ -600 +600 @@
         float32_u ua;
         ua.val = a;
-        
+
         float32_u ub;
         ub.val = b;
-        
+
         if ((is_float32_nan(ua.data)) || (is_float32_nan(ub.data))) {
                 // TODO: sigNaNs
                 return 1;
         }
-        
+
         if (is_float32_lt(ua.data, ub.data))
                 return -1;
-        
+
         return 0;
 }
@@ -619 +619 @@
         float32_u ua;
         ua.val = a;
-        
+
         float32_u ub;
         ub.val = b;
-        
+
         if ((is_float32_nan(ua.data)) || (is_float32_nan(ub.data))) {
                 // TODO: sigNaNs
                 return -1;
         }
-        
+
         if (is_float32_eq(ua.data, ub.data))
                 return 0;
-        
+
         if (is_float32_gt(ua.data, ub.data))
                 return 1;
-        
+
         return -1;
 }
@@ -641 +641 @@
         float32_u ua;
         ua.val = a;
-        
+
         float32_u ub;
         ub.val = b;
-        
+
         if ((is_float32_nan(ua.data)) || (is_float32_nan(ub.data))) {
                 // TODO: sigNaNs
                 return 1;
         }
-        
+
         return is_float32_eq(ua.data, ub.data) - 1;
 }
@@ -661 +661 @@
         float64_u ua;
         ua.val = a;
-        
+
         float64_u ub;
         ub.val = b;
-        
+
         if ((is_float64_nan(ua.data)) || (is_float64_nan(ub.data))) {
                 // TODO: sigNaNs
                 return -1;
         }
-        
+
         if (is_float64_gt(ua.data, ub.data))
                 return 1;
-        
+
         return 0;
 }
@@ -680 +680 @@
         float64_u ua;
         ua.val = a;
-        
+
         float64_u ub;
         ub.val = b;
-        
+
         if ((is_float64_nan(ua.data)) || (is_float64_nan(ub.data))) {
                 // TODO: sigNaNs
                 return -1;
         }
-        
+
         if (is_float64_eq(ua.data, ub.data))
                 return 0;
-        
+
         if (is_float64_gt(ua.data, ub.data))
                 return 1;
-        
+
         return -1;
 }
@@ -702 +702 @@
         float64_u ua;
         ua.val = a;
-        
+
         float64_u ub;
         ub.val = b;
-        
+
         if ((is_float64_nan(ua.data)) || (is_float64_nan(ub.data))) {
                 // TODO: sigNaNs
                 return 1;
         }
-        
+
         if (is_float64_lt(ua.data, ub.data))
                 return -1;
-        
+
         return 0;
 }
@@ -721 +721 @@
         float64_u ua;
         ua.val = a;
-        
+
         float64_u ub;
         ub.val = b;
-        
+
         if ((is_float64_nan(ua.data)) || (is_float64_nan(ub.data))) {
                 // TODO: sigNaNs
                 return 1;
         }
-        
+
         if (is_float64_eq(ua.data, ub.data))
                 return 0;
-        
+
         if (is_float64_lt(ua.data, ub.data))
                 return -1;
-        
+
         return 1;
 }
@@ -743 +743 @@
         float64_u ua;
         ua.val = a;
-        
+
         float64_u ub;
         ub.val = b;
-        
+
         if ((is_float64_nan(ua.data)) || (is_float64_nan(ub.data))) {
                 // TODO: sigNaNs
                 return 1;
         }
-        
+
         return is_float64_eq(ua.data, ub.data) - 1;
 }
@@ -765 +765 @@
         float64_u ua;
         ua.val = a;
-        
+
         float64_u ub;
         ub.val = b;
-        
+
         if ((is_float64_nan(ua.data)) || (is_float64_nan(ub.data))) {
                 /* No special constant for unordered - maybe signaled? */
                 return 1;
         }
-        
+
         if (is_float64_eq(ua.data, ub.data))
                 return 0;
-        
+
         if (is_float64_lt(ua.data, ub.data))
                 return -1;
-        
+
         return 1;
 }
@@ -787 +787 @@
         float64_u ua;
         ua.val = a;
-        
+
         float64_u ub;
         ub.val = b;
-        
+
         return ((is_float64_nan(ua.data)) || (is_float64_nan(ub.data)));
 }
@@ -798 +798 @@
         float64_u ua;
         ua.val = a;
-        
+
         float64_u ub;
         ub.val = b;
-        
+
         if ((is_float64_nan(ua.data)) || (is_float64_nan(ub.data))) {
                 // TODO: sigNaNs
                 return 1;
         }
-        
+
         if (is_float64_lt(ua.data, ub.data))
                 return -1;
-        
+
         return 0;
 }
@@ -817 +817 @@
         float64_u ua;
         ua.val = a;
-        
+
         float64_u ub;
         ub.val = b;
-        
+
         if ((is_float64_nan(ua.data)) || (is_float64_nan(ub.data))) {
                 // TODO: sigNaNs
                 return 1;
         }
-        
+
         return is_float64_eq(ua.data, ub.data) - 1;
 }
@@ -833 +833 @@
         float64_u ua;
         ua.val = a;
-        
+
         float64_u ub;
         ub.val = b;
-        
+
         if ((is_float64_nan(ua.data)) || (is_float64_nan(ub.data))) {
                 // TODO: sigNaNs
                 return -1;
         }
-        
+
         if (is_float64_gt(ua.data, ub.data))
                 return 1;
-        
+
         return 0;
 }
@@ -852 +852 @@
         float64_u ua;
         ua.val = a;
-        
+
         float64_u ub;
         ub.val = b;
-        
+
         if ((is_float64_nan(ua.data)) || (is_float64_nan(ub.data))) {
                 // TODO: sigNaNs
                 return -1;
         }
-        
+
         if (is_float64_eq(ua.data, ub.data))
                 return 0;
-        
+
         if (is_float64_gt(ua.data, ub.data))
                 return 1;
-        
+
         return -1;
 }
@@ -874 +874 @@
         float64_u ua;
         ua.val = a;
-        
+
         float64_u ub;
         ub.val = b;
-        
+
         if ((is_float64_nan(ua.data)) || (is_float64_nan(ub.data))) {
                 // TODO: sigNaNs
                 return 1;
         }
-        
+
         if (is_float64_eq(ua.data, ub.data))
                 return 0;
-        
+
         if (is_float64_lt(ua.data, ub.data))
                 return -1;
-        
+
         return 1;
 }
@@ -900 +900 @@
         float128_u ua;
         ua.val = a;
-        
-        float128_u ub;
-        ub.val = b;
-        
+
+        float128_u ub;
+        ub.val = b;
+
         if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data))) {
                 // TODO: sigNaNs
                 return -1;
         }
-        
+
         if (is_float128_gt(ua.data, ub.data))
                 return 1;
-        
+
         return 0;
 }
@@ -919 +919 @@
         float128_u ua;
         ua.val = a;
-        
-        float128_u ub;
-        ub.val = b;
-        
+
+        float128_u ub;
+        ub.val = b;
+
         if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data))) {
                 // TODO: sigNaNs
                 return -1;
         }
-        
+
         if (is_float128_eq(ua.data, ub.data))
                 return 0;
-        
+
         if (is_float128_gt(ua.data, ub.data))
                 return 1;
-        
+
         return -1;
 }
@@ -941 +941 @@
         float128_u ua;
         ua.val = a;
-        
-        float128_u ub;
-        ub.val = b;
-        
+
+        float128_u ub;
+        ub.val = b;
+
         if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data))) {
                 // TODO: sigNaNs
                 return 1;
         }
-        
+
         if (is_float128_lt(ua.data, ub.data))
                 return -1;
-        
+
         return 0;
 }
@@ -960 +960 @@
         float128_u ua;
         ua.val = a;
-        
-        float128_u ub;
-        ub.val = b;
-        
+
+        float128_u ub;
+        ub.val = b;
+
         if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data))) {
                 // TODO: sigNaNs
                 return 1;
         }
-        
+
         if (is_float128_eq(ua.data, ub.data))
                 return 0;
-        
+
         if (is_float128_lt(ua.data, ub.data))
                 return -1;
-        
+
         return 1;
 }
@@ -982 +982 @@
         float128_u ua;
         ua.val = a;
-        
-        float128_u ub;
-        ub.val = b;
-        
+
+        float128_u ub;
+        ub.val = b;
+
         if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data))) {
                 // TODO: sigNaNs
                 return 1;
         }
-        
+
         return is_float128_eq(ua.data, ub.data) - 1;
 }
@@ -1004 +1004 @@
         float128_u ua;
         ua.val = a;
-        
-        float128_u ub;
-        ub.val = b;
-        
+
+        float128_u ub;
+        ub.val = b;
+
         if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data))) {
                 /* No special constant for unordered - maybe signaled? */
                 return 1;
         }
-        
+
         if (is_float128_eq(ua.data, ub.data))
                 return 0;
-        
+
         if (is_float128_lt(ua.data, ub.data))
                 return -1;
-        
+
         return 1;
 }
@@ -1026 +1026 @@
         float128_u ua;
         ua.val = a;
-        
-        float128_u ub;
-        ub.val = b;
-        
+
+        float128_u ub;
+        ub.val = b;
+
         return ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data)));
 }
@@ -1037 +1037 @@
         float128_u ua;
         ua.val = *a;
-        
+
         float128_u ub;
         ub.val = *b;
-        
+
         if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data)))
                 return 3;
-        
+
         if (is_float128_eq(ua.data, ub.data))
                 return 0;
-        
+
         if (is_float128_lt(ua.data, ub.data))
                 return 1;
-        
+
         return 2;
 }
@@ -1063 +1063 @@
         float128_u ua;
         ua.val = *a;
-        
+
         float128_u ub;
         ub.val = *b;
-        
+
         if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data)))
                 return 0;
-        
+
         return is_float128_gt(ua.data, ub.data);
 }
@@ -1077 +1077 @@
         float128_u ua;
         ua.val = *a;
-        
+
         float128_u ub;
         ub.val = *b;
-        
+
         if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data)))
                 return 0;
-        
+
         return is_float128_eq(ua.data, ub.data) ||
             is_float128_gt(ua.data, ub.data);
@@ -1092 +1092 @@
         float128_u ua;
         ua.val = *a;
-        
+
         float128_u ub;
         ub.val = *b;
-        
+
         if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data)))
                 return 0;
-        
+
         return is_float128_lt(ua.data, ub.data);
 }
@@ -1106 +1106 @@
         float128_u ua;
         ua.val = *a;
-        
+
         float128_u ub;
         ub.val = *b;
-        
+
         if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data)))
                 return 0;
-        
+
         return is_float128_eq(ua.data, ub.data) ||
             is_float128_lt(ua.data, ub.data);
@@ -1121 +1121 @@
         float128_u ua;
         ua.val = *a;
-        
+
         float128_u ub;
         ub.val = *b;
-        
+
         if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data)))
                 return 0;
-        
+
         return is_float128_eq(ua.data, ub.data);
 }
@@ -1135 +1135 @@
         float128_u ua;
         ua.val = *a;
-        
+
         float128_u ub;
         ub.val = *b;
-        
+
         if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data)))
                 return 0;
-        
+
         return !is_float128_eq(ua.data, ub.data);
 }

uspace/lib/softfloat/conversion.c

@@ -42 +42 @@
         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;
@@ -52 +52 @@
                 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;
 }
@@ -81 +81 @@
         uint64_t frac_hi, frac_lo;
         uint64_t tmp_hi, tmp_lo;
-        
+
         result.parts.sign = a.parts.sign;
         result.parts.frac_hi = 0;
@@ -90 +90 @@
         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;
@@ -96 +96 @@
                 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 */
@@ -106 +106 @@
                         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,
@@ -117 +117 @@
                         --result.parts.exp;
                 }
-                
+
                 ++result.parts.exp;
                 result.parts.frac_hi = frac_hi;
                 result.parts.frac_lo = frac_lo;
         }
-        
+
         return result;
 }
@@ -131 +131 @@
         uint64_t frac_hi, frac_lo;
         uint64_t tmp_hi, tmp_lo;
-        
+
         result.parts.sign = a.parts.sign;
         result.parts.frac_hi = 0;
@@ -140 +140 @@
         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;
@@ -146 +146 @@
                 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 */
@@ -156 +156 @@
                         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,
@@ -167 +167 @@
                         --result.parts.exp;
                 }
-                
+
                 ++result.parts.exp;
                 result.parts.frac_hi = frac_hi;
                 result.parts.frac_lo = frac_lo;
         }
-        
+
         return result;
 }
@@ -181 +181 @@
         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 */
@@ -192 +192 @@
                         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;
@@ -203 +203 @@
                 return result;
         }
-        
+
         exp = (int) a.parts.exp - FLOAT64_BIAS + FLOAT32_BIAS;
-        
+
         if (exp >= FLOAT32_MAX_EXPONENT) {
                 /* FIXME: overflow */
@@ -213 +213 @@
         } else if (exp <= 0) {
                 /* underflow or denormalized */
-                
+
                 result.parts.exp = 0;
-                
+
                 exp *= -1;
                 if (exp > FLOAT32_FRACTION_SIZE) {
@@ -222 +222 @@
                         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;
@@ -235 +235 @@
                 }
                 result.parts.fraction = frac;
-                
-                return result;
-        }
-        
+
+                return result;
+        }
+
         result.parts.exp = exp;
         result.parts.fraction =
@@ -250 +250 @@
         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 */
@@ -261 +261 @@
                         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;
@@ -272 +272 @@
                 return result;
         }
-        
+
         exp = (int) a.parts.exp - FLOAT128_BIAS + FLOAT32_BIAS;
-        
+
         if (exp >= FLOAT32_MAX_EXPONENT) {
                 /* FIXME: overflow */
@@ -282 +282 @@
         } else if (exp <= 0) {
                 /* underflow or denormalized */
-                
+
                 result.parts.exp = 0;
-                
+
                 exp *= -1;
                 if (exp > FLOAT32_FRACTION_SIZE) {
@@ -291 +291 @@
                         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;
@@ -309 +309 @@
                 }
                 result.parts.fraction = frac_lo;
-                
-                return result;
-        }
-        
+
+                return result;
+        }
+
         result.parts.exp = exp;
         frac_hi = a.parts.frac_hi;
@@ -328 +328 @@
         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 */
@@ -339 +339 @@
                         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;
@@ -350 +350 @@
                 return result;
         }
-        
+
         exp = (int) a.parts.exp - FLOAT128_BIAS + FLOAT64_BIAS;
-        
+
         if (exp >= FLOAT64_MAX_EXPONENT) {
                 /* FIXME: overflow */
@@ -360 +360 @@
         } else if (exp <= 0) {
                 /* underflow or denormalized */
-                
+
                 result.parts.exp = 0;
-                
+
                 exp *= -1;
                 if (exp > FLOAT64_FRACTION_SIZE) {
@@ -369 +369 @@
                         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;
@@ -387 +387 @@
                 }
                 result.parts.fraction = frac_lo;
-                
-                return result;
-        }
-        
+
+                return result;
+        }
+
         result.parts.exp = exp;
         frac_hi = a.parts.frac_hi;
@@ -410 +410 @@
 {
         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)) {
@@ -427 +427 @@
                 ++frac;
         }
-        
+
         return frac;
 }
@@ -439 +439 @@
         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);
 }
@@ -458 +458 @@
         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);
 }
@@ -478 +478 @@
 {
         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)) {
@@ -495 +495 @@
                 ++frac;
         }
-        
+
         return frac;
 }
@@ -507 +507 @@
         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);
 }
@@ -526 +526 @@
         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);
 }
@@ -546 +546 @@
 {
         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)) {
@@ -563 +563 @@
                 ++frac;
         }
-        
+
         return frac;
 }
@@ -575 +575 @@
         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);
 }
@@ -594 +594 @@
         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);
 }
@@ -613 +613 @@
         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);
 }
@@ -632 +632 @@
         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);
 }
@@ -652 +652 @@
 {
         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);
@@ -672 +672 @@
                 add128(frac_hi, frac_lo, 0x0ll, 0x1ll, &frac_hi, &frac_lo);
         }
-        
+
         return frac_lo;
 }
@@ -684 +684 @@
         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);
 }
@@ -703 +703 @@
         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);
 }
@@ -722 +722 @@
         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);
 }
@@ -741 +741 @@
         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);
 }
@@ -757 +757 @@
         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;
@@ -775 +775 @@
                 i >>= 1;
         }
-        
+
         round_float32(&exp, &i);
-        
+
         result.parts.fraction = i >> (32 - FLOAT32_FRACTION_SIZE - 2);
         result.parts.exp = exp;
-        
+
         return result;
 }
@@ -787 +787 @@
 {
         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;
 }
@@ -804 +804 @@
         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) {
@@ -823 +823 @@
                 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;
@@ -835 +835 @@
 {
         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;
 }
@@ -852 +852 @@
         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;
 }
@@ -879 +879 @@
 {
         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;
 }
@@ -895 +895 @@
         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;
@@ -913 +913 @@
                 i >>= 1;
         }
-        
+
         round_float64(&exp, &i);
-        
+
         result.parts.fraction = i >> (64 - FLOAT64_FRACTION_SIZE - 2);
         result.parts.exp = exp;
@@ -924 +924 @@
 {
         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;
 }
@@ -941 +941 @@
         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;
@@ -955 +955 @@
                 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);
@@ -967 +967 @@
         result.parts.frac_lo = frac_lo;
         result.parts.exp = exp;
-        
+
         return result;
 }
@@ -974 +974 @@
 {
         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;
 }
@@ -992 +992 @@
         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;
@@ -1006 +1006 @@
                 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);
@@ -1018 +1018 @@
         result.parts.frac_lo = frac_lo;
         result.parts.exp = exp;
-        
+
         return result;
 }
@@ -1025 +1025 @@
 {
         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;
 }
@@ -1042 +1042 @@
         float32_u res;
         res.data = int32_to_float32(i);
-        
+
         return res.val;
 }
@@ -1050 +1050 @@
         float32_u res;
         res.data = int64_to_float32(i);
-        
+
         return res.val;
 }
@@ -1058 +1058 @@
         float32_u res;
         res.data = uint32_to_float32(i);
-        
+
         return res.val;
 }
@@ -1066 +1066 @@
         float32_u res;
         res.data = uint64_to_float32(i);
-        
+
         return res.val;
 }
@@ -1074 +1074 @@
         float32_u ua;
         ua.val = a;
-        
+
         return float32_to_int32(ua.data);
 }
@@ -1082 +1082 @@
         float32_u ua;
         ua.val = a;
-        
+
         return float32_to_int64(ua.data);
 }
@@ -1090 +1090 @@
         float32_u ua;
         ua.val = a;
-        
+
         return float32_to_uint32(ua.data);
 }
@@ -1098 +1098 @@
         float32_u ua;
         ua.val = a;
-        
+
         return float32_to_uint64(ua.data);
 }
@@ -1106 +1106 @@
         float32_u ua;
         ua.val = a;
-        
+
         return float32_to_int32(ua.data);
 }
@@ -1114 +1114 @@
         float32_u ua;
         ua.val = a;
-        
+
         return float32_to_uint32(ua.data);
 }
@@ -1122 +1122 @@
         float32_u res;
         res.data = int32_to_float32(i);
-        
+
         return res.val;
 }
@@ -1130 +1130 @@
         float32_u res;
         res.data = int64_to_float32(i);
-        
+
         return res.val;
 }
@@ -1138 +1138 @@
         float32_u res;
         res.data = uint32_to_float32(i);
-        
+
         return res.val;
 }
@@ -1146 +1146 @@
         float32_u res;
         res.data = uint64_to_float32(i);
-        
+
         return res.val;
 }
@@ -1158 +1158 @@
         float64_u res;
         res.data = int32_to_float64(i);
-        
+
         return res.val;
 }
@@ -1166 +1166 @@
         float64_u res;
         res.data = int64_to_float64(i);
-        
+
         return res.val;
 }
@@ -1174 +1174 @@
         float64_u res;
         res.data = uint32_to_float64(i);
-        
+
         return res.val;
 }
@@ -1182 +1182 @@
         float64_u res;
         res.data = uint64_to_float64(i);
-        
+
         return res.val;
 }
@@ -1190 +1190 @@
         float64_u ua;
         ua.val = a;
-        
+
         return float64_to_uint32(ua.data);
 }
@@ -1198 +1198 @@
         float64_u ua;
         ua.val = a;
-        
+
         return float64_to_uint64(ua.data);
 }
@@ -1206 +1206 @@
         float64_u ua;
         ua.val = a;
-        
+
         return float64_to_int32(ua.data);
 }
@@ -1214 +1214 @@
         float64_u ua;
         ua.val = a;
-        
+
         return float64_to_int64(ua.data);
 }
@@ -1222 +1222 @@
         float64_u res;
         res.data = int32_to_float64(i);
-        
+
         return res.val;
 }
@@ -1230 +1230 @@
         float64_u res;
         res.data = uint32_to_float64(i);
-        
+
         return res.val;
 }
@@ -1238 +1238 @@
         float64_u res;
         res.data = int64_to_float64(i);
-        
+
         return res.val;
 }
@@ -1246 +1246 @@
         float64_u ua;
         ua.val = a;
-        
+
         return float64_to_int32(ua.data);
 }
@@ -1254 +1254 @@
         float64_u ua;
         ua.val = a;
-        
+
         return float64_to_int64(ua.data);
 }
@@ -1262 +1262 @@
         float64_u ua;
         ua.val = a;
-        
+
         return float64_to_uint32(ua.data);
 }
@@ -1274 +1274 @@
         float128_u res;
         res.data = int32_to_float128(i);
-        
+
         return res.val;
 }
@@ -1282 +1282 @@
         float128_u res;
         res.data = int64_to_float128(i);
-        
+
         return res.val;
 }
@@ -1290 +1290 @@
         float128_u res;
         res.data = uint32_to_float128(i);
-        
+
         return res.val;
 }
@@ -1298 +1298 @@
         float128_u res;
         res.data = uint64_to_float128(i);
-        
+
         return res.val;
 }
@@ -1306 +1306 @@
         float128_u ua;
         ua.val = a;
-        
+
         return float128_to_int32(ua.data);
 }
@@ -1314 +1314 @@
         float128_u ua;
         ua.val = a;
-        
+
         return float128_to_uint64(ua.data);
 }
@@ -1322 +1322 @@
         float128_u ua;
         ua.val = a;
-        
+
         return float128_to_uint32(ua.data);
 }
@@ -1330 +1330 @@
         float128_u ua;
         ua.val = a;
-        
+
         return float128_to_uint64(ua.data);
 }
@@ -1382 +1382 @@
         float64_u ua;
         ua.val = a;
-        
+
         float32_u res;
         res.data = float64_to_float32(ua.data);
-        
+
         return res.val;
 }
@@ -1393 +1393 @@
         float32_u ua;
         ua.val = a;
-        
+
         float64_u res;
         res.data = float32_to_float64(ua.data);
-        
+
         return res.val;
 }
@@ -1404 +1404 @@
         float32_u ua;
         ua.val = a;
-        
+
         float64_u res;
         res.data = float32_to_float64(ua.data);
-        
+
         return res.val;
 }
@@ -1415 +1415 @@
         float64_u ua;
         ua.val = a;
-        
+
         float32_u res;
         res.data = float64_to_float32(ua.data);
-        
+
         return res.val;
 }
@@ -1430 +1430 @@
         float128_u ua;
         ua.val = a;
-        
+
         float32_u res;
         res.data = float128_to_float32(ua.data);
-        
+
         return res.val;
 }
@@ -1441 +1441 @@
         float32_u ua;
         ua.val = a;
-        
+
         float128_u res;
         res.data = float32_to_float128(ua.data);
-        
+
         return res.val;
 }
@@ -1466 +1466 @@
         float128_u ua;
         ua.val = a;
-        
+
         float64_u res;
         res.data = float128_to_float64(ua.data);
-        
+
         return res.val;
 }
@@ -1477 +1477 @@
         float64_u ua;
         ua.val = a;
-        
+
         float128_u res;
         res.data = float64_to_float128(ua.data);
-        
+
         return res.val;
 }

uspace/lib/softfloat/div.c

@@ -53 +53 @@
         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)) {
@@ -63 +63 @@
                 return a;
         }
-        
+
         if (is_float32_nan(b)) {
                 if (is_float32_signan(b)) {
@@ -71 +71 @@
                 return b;
         }
-        
+
         if (is_float32_infinity(a)) {
                 if (is_float32_infinity(b)) {
@@ -83 +83 @@
                 return result;
         }
-        
+
         if (is_float32_infinity(b)) {
                 if (is_float32_zero(a)) {
@@ -96 +96 @@
                 return result;
         }
-        
+
         if (is_float32_zero(b)) {
                 if (is_float32_zero(a)) {
@@ -108 +108 @@
                 return result;
         }
-        
+
         afrac = a.parts.fraction;
         aexp = a.parts.exp;
         bfrac = b.parts.fraction;
         bexp = b.parts.exp;
-        
+
         /* denormalized numbers */
         if (aexp == 0) {
@@ -121 +121 @@
                         return result;
                 }
-                
+
                 /* normalize it*/
                 afrac <<= 1;
@@ -130 +130 @@
                 }
         }
-        
+
         if (bexp == 0) {
                 bfrac <<= 1;
@@ -139 +139 @@
                 }
         }
-        
+
         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)))) {
@@ -163 +163 @@
                 /* 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) {
@@ -178 +178 @@
                 return result;
         }
-        
+
         if (cexp < 0) {
                 /* FIXME: underflow */
@@ -194 +194 @@
                 result.parts.exp = (uint32_t) cexp;
         }
-        
+
         result.parts.fraction = ((cfrac >> 6) & (~FLOAT32_HIDDEN_BIT_MASK));
-        
+
         return result;
 }
@@ -215 +215 @@
         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)) {
@@ -223 +223 @@
                         return b;
                 }
-                
+
                 if (is_float64_signan(a)) {
                         // FIXME: SigNaN
@@ -230 +230 @@
                 return a;
         }
-        
+
         if (is_float64_nan(b)) {
                 if (is_float64_signan(b)) {
@@ -238 +238 @@
                 return b;
         }
-        
+
         if (is_float64_infinity(a)) {
                 if (is_float64_infinity(b) || is_float64_zero(b)) {
@@ -250 +250 @@
                 return result;
         }
-        
+
         if (is_float64_infinity(b)) {
                 if (is_float64_zero(a)) {
@@ -263 +263 @@
                 return result;
         }
-        
+
         if (is_float64_zero(b)) {
                 if (is_float64_zero(a)) {
@@ -275 +275 @@
                 return result;
         }
-        
+
         afrac = a.parts.fraction;
         aexp = a.parts.exp;
         bfrac = b.parts.fraction;
         bexp = b.parts.exp;
-        
+
         /* denormalized numbers */
         if (aexp == 0) {
@@ -288 +288 @@
                         return result;
                 }
-                
+
                 /* normalize it*/
                 aexp++;
@@ -297 +297 @@
                 }
         }
-        
+
         if (bexp == 0) {
                 bexp++;
@@ -306 +306 @@
                 }
         }
-        
+
         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--;
@@ -329 +329 @@
                 cfrac |= (remlo != 0);
         }
-        
+
         /* round and shift */
         result = finish_float64(cexp, cfrac, result.parts.sign);
@@ -351 +351 @@
         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)) {
@@ -359 +359 @@
                         return b;
                 }
-                
+
                 if (is_float128_signan(a)) {
                         // FIXME: SigNaN
@@ -366 +366 @@
                 return a;
         }
-        
+
         if (is_float128_nan(b)) {
                 if (is_float128_signan(b)) {
@@ -374 +374 @@
                 return b;
         }
-        
+
         if (is_float128_infinity(a)) {
                 if (is_float128_infinity(b) || is_float128_zero(b)) {
@@ -388 +388 @@
                 return result;
         }
-        
+
         if (is_float128_infinity(b)) {
                 if (is_float128_zero(a)) {
@@ -403 +403 @@
                 return result;
         }
-        
+
         if (is_float128_zero(b)) {
                 if (is_float128_zero(a)) {
@@ -417 +417 @@
                 return result;
         }
-        
+
         afrac_hi = a.parts.frac_hi;
         afrac_lo = a.parts.frac_lo;
@@ -424 +424 @@
         bfrac_lo = b.parts.frac_lo;
         bexp = b.parts.exp;
-        
+
         /* denormalized numbers */
         if (aexp == 0) {
@@ -433 +433 @@
                         return result;
                 }
-                
+
                 /* normalize it*/
                 aexp++;
@@ -445 +445 @@
                 }
         }
-        
+
         if (bexp == 0) {
                 bexp++;
@@ -457 +457 @@
                 }
         }
-        
+
         or128(afrac_hi, afrac_lo,
             FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO,
@@ -468 +468 @@
         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
@@ -489 +489 @@
         }
         rem_lohi = -tmp_lohi;
-        
+
         while ((int64_t) rem_hihi < 0) {
                 --cfrac_hi;
@@ -500 +500 @@
                 }
         }
-        
+
         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,
@@ -515 +515 @@
                 }
                 rem_lolo = -tmp_lolo;
-                
+
                 while ((int64_t) rem_hilo < 0) {
                         --cfrac_lo;
@@ -526 +526 @@
                         }
                 }
-                
+
                 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;
@@ -544 +544 @@
         float32_u ua;
         ua.val = a;
-        
+
         float32_u ub;
         ub.val = b;
-        
+
         float32_u res;
         res.data = div_float32(ua.data, ub.data);
-        
+
         return res.val;
 }
@@ -558 +558 @@
         float32_u ua;
         ua.val = a;
-        
+
         float32_u ub;
         ub.val = b;
-        
+
         float32_u res;
         res.data = div_float32(ua.data, ub.data);
-        
+
         return res.val;
 }
@@ -576 +576 @@
         float64_u ua;
         ua.val = a;
-        
+
         float64_u ub;
         ub.val = b;
-        
+
         float64_u res;
         res.data = div_float64(ua.data, ub.data);
-        
+
         return res.val;
 }
@@ -590 +590 @@
         float64_u ua;
         ua.val = a;
-        
+
         float64_u ub;
         ub.val = b;
-        
+
         float64_u res;
         res.data = div_float64(ua.data, ub.data);
-        
+
         return res.val;
 }
@@ -608 +608 @@
         float128_u ua;
         ua.val = a;
-        
+
         float128_u ub;
         ub.val = b;
-        
+
         float128_u res;
         res.data = div_float128(ua.data, ub.data);
-        
+
         return res.val;
 }

uspace/lib/softfloat/mul.c

@@ -51 +51 @@
         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 */
@@ -61 +61 @@
                         return result;
                 }
-                
+
                 if (is_float32_signan(b)) { /* TODO: fix SigNaN */
                         result.parts.fraction = b.parts.fraction;
@@ -67 +67 @@
                         return result;
                 }
-                
+
                 /* set NaN as result */
                 result.bin = FLOAT32_NAN;
                 return result;
         }
-        
+
         if (is_float32_infinity(a)) {
                 if (is_float32_zero(b)) {
@@ -79 +79 @@
                         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)) {
@@ -91 +91 @@
                         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 */
@@ -108 +108 @@
                 return result;
         }
-        
+
         if (exp < 0) {
                 /* FIXME: underflow */
@@ -116 +116 @@
                 return result;
         }
-        
+
         frac1 = a.parts.fraction;
         if (a.parts.exp > 0) {
@@ -123 +123 @@
                 ++exp;
         }
-        
+
         frac2 = b.parts.fraction;
-        
+
         if (b.parts.exp > 0) {
                 frac2 |= FLOAT32_HIDDEN_BIT_MASK;
@@ -131 +131 @@
                 ++exp;
         }
-        
+
         frac1 <<= 1; /* one bit space for rounding */
-        
+
         frac1 = frac1 * frac2;
-        
+
         /* round and return */
         while ((exp < FLOAT32_MAX_EXPONENT) &&
@@ -143 +143 @@
                 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)))) {
@@ -153 +153 @@
                 frac1 >>= 1;
         }
-        
+
         if (exp >= FLOAT32_MAX_EXPONENT) {
                 /* TODO: fix overflow */
@@ -161 +161 @@
                 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 */
@@ -180 +180 @@
                 }
         }
-        
+
         result.parts.exp = exp;
         result.parts.fraction = frac1 & ((1 << FLOAT32_FRACTION_SIZE) - 1);
-        
+
         return result;
 }
@@ -200 +200 @@
         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 */
@@ -219 +219 @@
                 return result;
         }
-        
+
         if (is_float64_infinity(a)) {
                 if (is_float64_zero(b)) {
@@ -230 +230 @@
                 return result;
         }
-        
+
         if (is_float64_infinity(b)) {
                 if (is_float64_zero(a)) {
@@ -241 +241 @@
                 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;
@@ -252 +252 @@
                 ++exp;
         }
-        
+
         frac2 = b.parts.fraction;
-        
+
         if (b.parts.exp > 0) {
                 frac2 |= FLOAT64_HIDDEN_BIT_MASK;
@@ -260 +260 @@
                 ++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)) {
@@ -271 +271 @@
                 exp--;
         }
-        
+
         result = finish_float64(exp, frac1, result.parts.sign);
         return result;
@@ -289 +289 @@
         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 */
@@ -311 +311 @@
                 return result;
         }
-        
+
         if (is_float128_infinity(a)) {
                 if (is_float128_zero(b)) {
@@ -324 +324 @@
                 return result;
         }
-        
+
         if (is_float128_infinity(b)) {
                 if (is_float128_zero(a)) {
@@ -337 +337 @@
                 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,
@@ -351 +351 @@
                 ++exp;
         }
-        
+
         frac2_hi = b.parts.frac_hi;
         frac2_lo = b.parts.frac_lo;
-        
+
         if (b.parts.exp > 0) {
                 or128(frac2_hi, frac2_lo,
@@ -362 +362 @@
                 ++exp;
         }
-        
+
         lshift128(frac2_hi, frac2_lo,
             128 - FLOAT128_FRACTION_SIZE, &frac2_hi, &frac2_lo);
-        
+
         tmp_hi = frac1_hi;
         tmp_lo = frac1_lo;
@@ -372 +372 @@
         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;
@@ -381 +381 @@
                 ++exp;
         }
-        
+
         result = finish_float128(exp, frac1_hi, frac1_lo, result.parts.sign, frac2_hi);
         return result;
@@ -392 +392 @@
         float32_u ua;
         ua.val = a;
-        
+
         float32_u ub;
         ub.val = b;
-        
+
         float32_u res;
         res.data = mul_float32(ua.data, ub.data);
-        
+
         return res.val;
 }
@@ -406 +406 @@
         float32_u ua;
         ua.val = a;
-        
+
         float32_u ub;
         ub.val = b;
-        
+
         float32_u res;
         res.data = mul_float32(ua.data, ub.data);
-        
+
         return res.val;
 }
@@ -424 +424 @@
         float64_u ua;
         ua.val = a;
-        
+
         float64_u ub;
         ub.val = b;
-        
+
         float64_u res;
         res.data = mul_float64(ua.data, ub.data);
-        
+
         return res.val;
 }
@@ -438 +438 @@
         float64_u ua;
         ua.val = a;
-        
+
         float64_u ub;
         ub.val = b;
-        
+
         float64_u res;
         res.data = mul_float64(ua.data, ub.data);
-        
+
         return res.val;
 }
@@ -456 +456 @@
         float128_u ua;
         ua.val = a;
-        
+
         float128_u ub;
         ub.val = b;
-        
+
         float128_u res;
         res.data = mul_float128(ua.data, ub.data);
-        
+
         return res.val;
 }

uspace/lib/softfloat/neg.c

@@ -43 +43 @@
         float32_u ua;
         ua.val = a;
-        
+
         ua.data.parts.sign = !ua.data.parts.sign;
-        
+
         return ua.val;
 }
@@ -57 +57 @@
         float64_u ua;
         ua.val = a;
-        
+
         ua.data.parts.sign = !ua.data.parts.sign;
-        
+
         return ua.val;
 }
@@ -71 +71 @@
         float128_u ua;
         ua.val = a;
-        
+
         ua.data.parts.sign = !ua.data.parts.sign;
-        
+
         return ua.val;
 }

uspace/lib/softfloat/sub.c

@@ -52 +52 @@
         uint32_t exp1, exp2, frac1, frac2;
         float32 result;
-        
+
         result.bin = 0;
-        
+
         expdiff = a.parts.exp - b.parts.exp;
         if ((expdiff < 0 ) || ((expdiff == 0) &&
@@ -62 +62 @@
                                 // TODO: fix SigNaN
                         }
-                        
+
                         return b;
                 }
-                
+
                 if (b.parts.exp == FLOAT32_MAX_EXPONENT) {
                         /* num -(+-inf) = -+inf */
@@ -71 +71 @@
                         return b;
                 }
-                
+
                 result.parts.sign = !a.parts.sign;
-                
+
                 frac1 = b.parts.fraction;
                 exp1 = b.parts.exp;
@@ -84 +84 @@
                                 // TODO: fix SigNaN
                         }
-                        
+
                         return a;
                 }
-                
+
                 if (a.parts.exp == FLOAT32_MAX_EXPONENT) {
                         if (b.parts.exp == FLOAT32_MAX_EXPONENT) {
@@ -95 +95 @@
                                 return result;
                         }
-                        
+
                         return a;
                 }
-                
+
                 result.parts.sign = a.parts.sign;
-                
+
                 frac1 = a.parts.fraction;
                 exp1 = a.parts.exp;
@@ -106 +106 @@
                 exp2 = b.parts.exp;
         }
-        
+
         if (exp1 == 0) {
                 /* both are denormalized */
@@ -114 +114 @@
                         return result;
                 }
-                
+
                 result.parts.exp = 0;
                 return result;
         }
-        
+
         /* add hidden bit */
         frac1 |= FLOAT32_HIDDEN_BIT_MASK;
-        
+
         if (exp2 == 0) {
                 /* denormalized */
@@ -129 +129 @@
                 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 */
@@ -146 +146 @@
                 /* 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;
 }
@@ -176 +176 @@
         uint64_t frac1, frac2;
         float64 result;
-        
+
         result.bin = 0;
-        
+
         expdiff = a.parts.exp - b.parts.exp;
         if ((expdiff < 0 ) ||
@@ -186 +186 @@
                                 // TODO: fix SigNaN
                         }
-                        
+
                         return b;
                 }
-                
+
                 if (b.parts.exp == FLOAT64_MAX_EXPONENT) {
                         /* num -(+-inf) = -+inf */
@@ -195 +195 @@
                         return b;
                 }
-                
+
                 result.parts.sign = !a.parts.sign;
-                
+
                 frac1 = b.parts.fraction;
                 exp1 = b.parts.exp;
@@ -208 +208 @@
                                 // TODO: fix SigNaN
                         }
-                        
+
                         return a;
                 }
-                
+
                 if (a.parts.exp == FLOAT64_MAX_EXPONENT) {
                         if (b.parts.exp == FLOAT64_MAX_EXPONENT) {
@@ -219 +219 @@
                                 return result;
                         }
-                        
+
                         return a;
                 }
-                
+
                 result.parts.sign = a.parts.sign;
-                
+
                 frac1 = a.parts.fraction;
                 exp1 = a.parts.exp;
@@ -230 +230 @@
                 exp2 = b.parts.exp;
         }
-        
+
         if (exp1 == 0) {
                 /* both are denormalized */
@@ -238 +238 @@
                         return result;
                 }
-                
+
                 result.parts.exp = 0;
                 return result;
         }
-        
+
         /* add hidden bit */
         frac1 |= FLOAT64_HIDDEN_BIT_MASK;
-        
+
         if (exp2 == 0) {
                 /* denormalized */
@@ -253 +253 @@
                 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 */
@@ -270 +270 @@
                 /* 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;
 }
@@ -300 +300 @@
         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) &&
@@ -311 +311 @@
                                 // TODO: fix SigNaN
                         }
-                        
+
                         return b;
                 }
-                
+
                 if (b.parts.exp == FLOAT128_MAX_EXPONENT) {
                         /* num -(+-inf) = -+inf */
@@ -320 +320 @@
                         return b;
                 }
-                
+
                 result.parts.sign = !a.parts.sign;
-                
+
                 frac1_hi = b.parts.frac_hi;
                 frac1_lo = b.parts.frac_lo;
@@ -335 +335 @@
                                 // TODO: fix SigNaN
                         }
-                        
+
                         return a;
                 }
-                
+
                 if (a.parts.exp == FLOAT128_MAX_EXPONENT) {
                         if (b.parts.exp == FLOAT128_MAX_EXPONENT) {
@@ -349 +349 @@
                         return a;
                 }
-                
+
                 result.parts.sign = a.parts.sign;
-                
+
                 frac1_hi = a.parts.frac_hi;
                 frac1_lo = a.parts.frac_lo;
@@ -359 +359 @@
                 exp2 = b.parts.exp;
         }
-        
+
         if (exp1 == 0) {
                 /* both are denormalized */
@@ -369 +369 @@
                         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 */
@@ -388 +388 @@
                     &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 */
@@ -408 +408 @@
                 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);
@@ -424 +424 @@
                 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);
@@ -432 +432 @@
         result.parts.frac_hi = tmp_hi;
         result.parts.frac_lo = tmp_lo;
-        
+
         result.parts.exp = exp1;
-        
+
         return result;
 }
@@ -444 +444 @@
         float32_u ua;
         ua.val = a;
-        
+
         float32_u ub;
         ub.val = b;
-        
+
         float32_u res;
-        
+
         if (ua.data.parts.sign != ub.data.parts.sign) {
                 ub.data.parts.sign = !ub.data.parts.sign;
@@ -455 +455 @@
         } else
                 res.data = sub_float32(ua.data, ub.data);
-        
+
         return res.val;
 }
@@ -463 +463 @@
         float32_u ua;
         ua.val = a;
-        
+
         float32_u ub;
         ub.val = b;
-        
+
         float32_u res;
-        
+
         if (ua.data.parts.sign != ub.data.parts.sign) {
                 ub.data.parts.sign = !ub.data.parts.sign;
@@ -474 +474 @@
         } else
                 res.data = sub_float32(ua.data, ub.data);
-        
+
         return res.val;
 }
@@ -486 +486 @@
         float64_u ua;
         ua.val = a;
-        
+
         float64_u ub;
         ub.val = b;
-        
+
         float64_u res;
-        
+
         if (ua.data.parts.sign != ub.data.parts.sign) {
                 ub.data.parts.sign = !ub.data.parts.sign;
@@ -497 +497 @@
         } else
                 res.data = sub_float64(ua.data, ub.data);
-        
+
         return res.val;
 }
@@ -505 +505 @@
         float64_u ua;
         ua.val = a;
-        
+
         float64_u ub;
         ub.val = b;
-        
+
         float64_u res;
-        
+
         if (ua.data.parts.sign != ub.data.parts.sign) {
                 ub.data.parts.sign = !ub.data.parts.sign;
@@ -516 +516 @@
         } else
                 res.data = sub_float64(ua.data, ub.data);
-        
+
         return res.val;
 }
@@ -528 +528 @@
         float128_u ua;
         ua.val = a;
-        
+
         float128_u ub;
         ub.val = b;
-        
+
         float128_u res;
-        
+
         if (ua.data.parts.sign != ub.data.parts.sign) {
                 ub.data.parts.sign = !ub.data.parts.sign;
@@ -539 +539 @@
         } else
                 res.data = sub_float128(ua.data, ub.data);
-        
+
         return res.val;
 }