Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset 88d5c1e in mainline


Ignore:
Timestamp:
2012-04-07T17:55:10Z (10 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master
Children:
41455a22
Parents:
8bcd727
Message:

softfloat redesign

  • avoid hardwired type sizes, actual sizes are determined at compile-time
  • add basic support for x87 extended-precision data types (stored as 96bit long double)
  • a lot of coding style changes (removal of CamelCase?, etc.)
Location:
uspace/lib
Files:
10 deleted
24 edited

Legend:

Unmodified
Added
Removed
  • uspace/lib/softfloat/Makefile

    r8bcd727 r88d5c1e  
    2929
    3030USPACE_PREFIX = ../..
    31 EXTRA_CFLAGS = -Iinclude -Iarch/$(UARCH)/include/
     31EXTRA_CFLAGS = -Iinclude
    3232LIBRARY = libsoftfloat
    3333
  • uspace/lib/softfloat/generic/add.c

    r8bcd727 r88d5c1e  
    3939#include <common.h>
    4040
    41 /**
    42  * Add two single-precision floats with the same signs.
     41/** Add two single-precision floats with the same sign.
    4342 *
    4443 * @param a First input operand.
     
    4645 * @return Result of addition.
    4746 */
    48 float32 addFloat32(float32 a, float32 b)
     47float32 add_float32(float32 a, float32 b)
    4948{
    5049        int expdiff;
     
    5352        expdiff = a.parts.exp - b.parts.exp;
    5453        if (expdiff < 0) {
    55                 if (isFloat32NaN(b)) {
    56                         /* TODO: fix SigNaN */
    57                         if (isFloat32SigNaN(b)) {
     54                if (is_float32_nan(b)) {
     55                        /* TODO: fix SigNaN */
     56                        if (is_float32_signan(b)) {
    5857                        }
    5958
     
    7170                expdiff *= -1;
    7271        } else {
    73                 if ((isFloat32NaN(a)) || (isFloat32NaN(b))) {
    74                         /* TODO: fix SigNaN */
    75                         if (isFloat32SigNaN(a) || isFloat32SigNaN(b)) {
    76                         }
    77                         return (isFloat32NaN(a) ? a : b);
     72                if ((is_float32_nan(a)) || (is_float32_nan(b))) {
     73                        /* TODO: fix SigNaN */
     74                        if (is_float32_signan(a) || is_float32_signan(b)) {
     75                        }
     76                        return (is_float32_nan(a) ? a : b);
    7877                }
    7978               
     
    150149}
    151150
    152 /**
    153  * Add two double-precision floats with the same signs.
     151/** Add two double-precision floats with the same sign.
    154152 *
    155153 * @param a First input operand.
     
    157155 * @return Result of addition.
    158156 */
    159 float64 addFloat64(float64 a, float64 b)
     157float64 add_float64(float64 a, float64 b)
    160158{
    161159        int expdiff;
     
    165163        expdiff = ((int) a.parts.exp) - b.parts.exp;
    166164        if (expdiff < 0) {
    167                 if (isFloat64NaN(b)) {
    168                         /* TODO: fix SigNaN */
    169                         if (isFloat64SigNaN(b)) {
    170                         }
    171 
    172                         return b;
    173                 }
    174                
    175                 /* b is infinity and a not */   
    176                 if (b.parts.exp == FLOAT64_MAX_EXPONENT) { 
     165                if (is_float64_nan(b)) {
     166                        /* TODO: fix SigNaN */
     167                        if (is_float64_signan(b)) {
     168                        }
     169
     170                        return b;
     171                }
     172               
     173                /* b is infinity and a not */
     174                if (b.parts.exp == FLOAT64_MAX_EXPONENT) {
    177175                        return b;
    178176                }
     
    184182                expdiff *= -1;
    185183        } else {
    186                 if (isFloat64NaN(a)) {
    187                         /* TODO: fix SigNaN */
    188                         if (isFloat64SigNaN(a) || isFloat64SigNaN(b)) {
     184                if (is_float64_nan(a)) {
     185                        /* TODO: fix SigNaN */
     186                        if (is_float64_signan(a) || is_float64_signan(b)) {
    189187                        }
    190188                        return a;
     
    265263}
    266264
    267 /**
    268  * Add two quadruple-precision floats with the same signs.
     265/** Add two quadruple-precision floats with the same sign.
    269266 *
    270267 * @param a First input operand.
     
    272269 * @return Result of addition.
    273270 */
    274 float128 addFloat128(float128 a, float128 b)
     271float128 add_float128(float128 a, float128 b)
    275272{
    276273        int expdiff;
     
    280277        expdiff = ((int) a.parts.exp) - b.parts.exp;
    281278        if (expdiff < 0) {
    282                 if (isFloat128NaN(b)) {
    283                         /* TODO: fix SigNaN */
    284                         if (isFloat128SigNaN(b)) {
     279                if (is_float128_nan(b)) {
     280                        /* TODO: fix SigNaN */
     281                        if (is_float128_signan(b)) {
    285282                        }
    286283
     
    301298                expdiff *= -1;
    302299        } else {
    303                 if (isFloat128NaN(a)) {
    304                         /* TODO: fix SigNaN */
    305                         if (isFloat128SigNaN(a) || isFloat128SigNaN(b)) {
     300                if (is_float128_nan(a)) {
     301                        /* TODO: fix SigNaN */
     302                        if (is_float128_signan(a) || is_float128_signan(b)) {
    306303                        }
    307304                        return a;
  • uspace/lib/softfloat/generic/common.c

    r8bcd727 r88d5c1e  
    6666 * @return Finished double-precision float.
    6767 */
    68 float64 finishFloat64(int32_t cexp, uint64_t cfrac, char sign)
     68float64 finish_float64(int32_t cexp, uint64_t cfrac, char sign)
    6969{
    7070        float64 result;
     
    140140 * @return Finished quadruple-precision float.
    141141 */
    142 float128 finishFloat128(int32_t cexp, uint64_t cfrac_hi, uint64_t cfrac_lo,
     142float128 finish_float128(int32_t cexp, uint64_t cfrac_hi, uint64_t cfrac_lo,
    143143    char sign, uint64_t shift_out)
    144144{
     
    238238 * @return Number of detected leading zeroes.
    239239 */
    240 int countZeroes8(uint8_t i)
     240int count_zeroes8(uint8_t i)
    241241{
    242242        return zeroTable[i];
     
    249249 * @return Number of detected leading zeroes.
    250250 */
    251 int countZeroes32(uint32_t i)
     251int count_zeroes32(uint32_t i)
    252252{
    253253        int j;
    254254        for (j = 0; j < 32; j += 8) {
    255255                if (i & (0xFF << (24 - j))) {
    256                         return (j + countZeroes8(i >> (24 - j)));
     256                        return (j + count_zeroes8(i >> (24 - j)));
    257257                }
    258258        }
     
    267267 * @return Number of detected leading zeroes.
    268268 */
    269 int countZeroes64(uint64_t i)
     269int count_zeroes64(uint64_t i)
    270270{
    271271        int j;
    272272        for (j = 0; j < 64; j += 8) {
    273273                if (i & (0xFFll << (56 - j))) {
    274                         return (j + countZeroes8(i >> (56 - j)));
     274                        return (j + count_zeroes8(i >> (56 - j)));
    275275                }
    276276        }
     
    286286 * @param fraction Fraction with hidden bit shifted to 30th bit.
    287287 */
    288 void roundFloat32(int32_t *exp, uint32_t *fraction)
     288void round_float32(int32_t *exp, uint32_t *fraction)
    289289{
    290290        /* rounding - if first bit after fraction is set then round up */
     
    312312 * @param fraction Fraction with hidden bit shifted to 62nd bit.
    313313 */
    314 void roundFloat64(int32_t *exp, uint64_t *fraction)
     314void round_float64(int32_t *exp, uint64_t *fraction)
    315315{
    316316        /* rounding - if first bit after fraction is set then round up */
     
    339339 * @param frac_lo Low part of fraction part with hidden bit shifted to 126th bit.
    340340 */
    341 void roundFloat128(int32_t *exp, uint64_t *frac_hi, uint64_t *frac_lo)
     341void round_float128(int32_t *exp, uint64_t *frac_hi, uint64_t *frac_lo)
    342342{
    343343        uint64_t tmp_hi, tmp_lo;
  • uspace/lib/softfloat/generic/comparison.c

    r8bcd727 r88d5c1e  
    4545 * @return 1 if float is NaN, 0 otherwise.
    4646 */
    47 int isFloat32NaN(float32 f)
     47int is_float32_nan(float32 f)
    4848{
    4949        /* NaN : exp = 0xff and nonzero fraction */
     
    5858 * @return 1 if float is NaN, 0 otherwise.
    5959 */
    60 int isFloat64NaN(float64 d)
     60int is_float64_nan(float64 d)
    6161{
    6262        /* NaN : exp = 0x7ff and nonzero fraction */
     
    7171 * @return 1 if float is NaN, 0 otherwise.
    7272 */
    73 int isFloat128NaN(float128 ld)
     73int is_float128_nan(float128 ld)
    7474{
    7575        /* NaN : exp = 0x7fff and nonzero fraction */
     
    8484 * @return 1 if float is signalling NaN, 0 otherwise.
    8585 */
    86 int isFloat32SigNaN(float32 f)
     86int is_float32_signan(float32 f)
    8787{
    8888        /* SigNaN : exp = 0xff and fraction = 0xxxxx..x (binary),
     
    9898 * @return 1 if float is signalling NaN, 0 otherwise.
    9999 */
    100 int isFloat64SigNaN(float64 d)
     100int is_float64_signan(float64 d)
    101101{
    102102        /* SigNaN : exp = 0x7ff and fraction = 0xxxxx..x (binary),
     
    112112 * @return 1 if float is signalling NaN, 0 otherwise.
    113113 */
    114 int isFloat128SigNaN(float128 ld)
     114int is_float128_signan(float128 ld)
    115115{
    116116        /* SigNaN : exp = 0x7fff and fraction = 0xxxxx..x (binary),
     
    128128 * @return 1 if float is infinite, 0 otherwise.
    129129 */
    130 int isFloat32Infinity(float32 f)
     130int is_float32_infinity(float32 f)
    131131{
    132132        /* NaN : exp = 0x7ff and zero fraction */
     
    140140 * @return 1 if float is infinite, 0 otherwise.
    141141 */
    142 int isFloat64Infinity(float64 d)
     142int is_float64_infinity(float64 d)
    143143{
    144144        /* NaN : exp = 0x7ff and zero fraction */
     
    152152 * @return 1 if float is infinite, 0 otherwise.
    153153 */
    154 int isFloat128Infinity(float128 ld)
     154int is_float128_infinity(float128 ld)
    155155{
    156156        /* NaN : exp = 0x7fff and zero fraction */
     
    165165 * @return 1 if float is zero, 0 otherwise.
    166166 */
    167 int isFloat32Zero(float32 f)
    168 {
    169         return (((f.binary) & 0x7FFFFFFF) == 0);
     167int is_float32_zero(float32 f)
     168{
     169        return (((f.bin) & 0x7FFFFFFF) == 0);
    170170}
    171171
     
    176176 * @return 1 if float is zero, 0 otherwise.
    177177 */
    178 int isFloat64Zero(float64 d)
    179 {
    180         return (((d.binary) & 0x7FFFFFFFFFFFFFFFll) == 0);
     178int is_float64_zero(float64 d)
     179{
     180        return (((d.bin) & 0x7FFFFFFFFFFFFFFFll) == 0);
    181181}
    182182
     
    187187 * @return 1 if float is zero, 0 otherwise.
    188188 */
    189 int isFloat128Zero(float128 ld)
     189int is_float128_zero(float128 ld)
    190190{
    191191        uint64_t tmp_hi;
    192192        uint64_t tmp_lo;
    193 
    194         and128(ld.binary.hi, ld.binary.lo,
     193       
     194        and128(ld.bin.hi, ld.bin.lo,
    195195            0x7FFFFFFFFFFFFFFFll, 0xFFFFFFFFFFFFFFFFll, &tmp_hi, &tmp_lo);
    196 
     196       
    197197        return eq128(tmp_hi, tmp_lo, 0x0ll, 0x0ll);
    198198}
     
    205205 * @return 1 if both floats are equal, 0 otherwise.
    206206 */
    207 int isFloat32eq(float32 a, float32 b)
     207int is_float32_eq(float32 a, float32 b)
    208208{
    209209        /* a equals to b or both are zeros (with any sign) */
    210         return ((a.binary == b.binary) ||
    211             (((a.binary | b.binary) & 0x7FFFFFFF) == 0));
     210        return ((a.bin == b.bin) ||
     211            (((a.bin | b.bin) & 0x7FFFFFFF) == 0));
    212212}
    213213
     
    219219 * @return 1 if both floats are equal, 0 otherwise.
    220220 */
    221 int isFloat64eq(float64 a, float64 b)
     221int is_float64_eq(float64 a, float64 b)
    222222{
    223223        /* a equals to b or both are zeros (with any sign) */
    224         return ((a.binary == b.binary) ||
    225             (((a.binary | b.binary) & 0x7FFFFFFFFFFFFFFFll) == 0));
     224        return ((a.bin == b.bin) ||
     225            (((a.bin | b.bin) & 0x7FFFFFFFFFFFFFFFll) == 0));
    226226}
    227227
     
    233233 * @return 1 if both floats are equal, 0 otherwise.
    234234 */
    235 int isFloat128eq(float128 a, float128 b)
     235int is_float128_eq(float128 a, float128 b)
    236236{
    237237        uint64_t tmp_hi;
    238238        uint64_t tmp_lo;
    239 
     239       
    240240        /* both are zeros (with any sign) */
    241         or128(a.binary.hi, a.binary.lo,
    242             b.binary.hi, b.binary.lo, &tmp_hi, &tmp_lo);
     241        or128(a.bin.hi, a.bin.lo,
     242            b.bin.hi, b.bin.lo, &tmp_hi, &tmp_lo);
    243243        and128(tmp_hi, tmp_lo,
    244244            0x7FFFFFFFFFFFFFFFll, 0xFFFFFFFFFFFFFFFFll, &tmp_hi, &tmp_lo);
     
    246246       
    247247        /* a equals to b */
    248         int are_equal = eq128(a.binary.hi, a.binary.lo, b.binary.hi, b.binary.lo);
    249 
     248        int are_equal = eq128(a.bin.hi, a.bin.lo, b.bin.hi, b.bin.lo);
     249       
    250250        return are_equal || both_zero;
    251251}
     
    258258 * @return 1 if a is lower than b, 0 otherwise.
    259259 */
    260 int isFloat32lt(float32 a, float32 b)
    261 {
    262         if (((a.binary | b.binary) & 0x7FFFFFFF) == 0) {
    263                 return 0; /* +- zeroes */
     260int is_float32_lt(float32 a, float32 b)
     261{
     262        if (((a.bin | b.bin) & 0x7FFFFFFF) == 0) {
     263                /* +- zeroes */
     264                return 0;
    264265        }
    265266       
    266267        if ((a.parts.sign) && (b.parts.sign)) {
    267268                /* if both are negative, smaller is that with greater binary value */
    268                 return (a.binary > b.binary);
    269         }
    270        
    271         /* lets negate signs - now will be positive numbers allways bigger than
    272          * negative (first bit will be set for unsigned integer comparison) */
    273         a.parts.sign = !a.parts.sign;
    274         b.parts.sign = !b.parts.sign;
    275         return (a.binary < b.binary);
     269                return (a.bin > b.bin);
     270        }
     271       
     272        /*
     273         * lets negate signs - now will be positive numbers always
     274         * bigger than negative (first bit will be set for unsigned
     275         * integer comparison)
     276         */
     277        a.parts.sign = !a.parts.sign;
     278        b.parts.sign = !b.parts.sign;
     279        return (a.bin < b.bin);
    276280}
    277281
     
    283287 * @return 1 if a is lower than b, 0 otherwise.
    284288 */
    285 int isFloat64lt(float64 a, float64 b)
    286 {
    287         if (((a.binary | b.binary) & 0x7FFFFFFFFFFFFFFFll) == 0) {
    288                 return 0; /* +- zeroes */
    289         }
    290 
     289int is_float64_lt(float64 a, float64 b)
     290{
     291        if (((a.bin | b.bin) & 0x7FFFFFFFFFFFFFFFll) == 0) {
     292                /* +- zeroes */
     293                return 0;
     294        }
     295       
    291296        if ((a.parts.sign) && (b.parts.sign)) {
    292297                /* if both are negative, smaller is that with greater binary value */
    293                 return (a.binary > b.binary);
    294         }
    295 
    296         /* lets negate signs - now will be positive numbers allways bigger than
    297          * negative (first bit will be set for unsigned integer comparison) */
    298         a.parts.sign = !a.parts.sign;
    299         b.parts.sign = !b.parts.sign;
    300         return (a.binary < b.binary);
     298                return (a.bin > b.bin);
     299        }
     300       
     301        /*
     302         * lets negate signs - now will be positive numbers always
     303         * bigger than negative (first bit will be set for unsigned
     304         * integer comparison)
     305         */
     306        a.parts.sign = !a.parts.sign;
     307        b.parts.sign = !b.parts.sign;
     308        return (a.bin < b.bin);
    301309}
    302310
     
    308316 * @return 1 if a is lower than b, 0 otherwise.
    309317 */
    310 int isFloat128lt(float128 a, float128 b)
     318int is_float128_lt(float128 a, float128 b)
    311319{
    312320        uint64_t tmp_hi;
    313321        uint64_t tmp_lo;
    314 
    315         or128(a.binary.hi, a.binary.lo,
    316             b.binary.hi, b.binary.lo, &tmp_hi, &tmp_lo);
     322       
     323        or128(a.bin.hi, a.bin.lo,
     324            b.bin.hi, b.bin.lo, &tmp_hi, &tmp_lo);
    317325        and128(tmp_hi, tmp_lo,
    318326            0x7FFFFFFFFFFFFFFFll, 0xFFFFFFFFFFFFFFFFll, &tmp_hi, &tmp_lo);
    319327        if (eq128(tmp_hi, tmp_lo, 0x0ll, 0x0ll)) {
    320                 return 0; /* +- zeroes */
    321         }
    322 
     328                /* +- zeroes */
     329                return 0;
     330        }
     331       
    323332        if ((a.parts.sign) && (b.parts.sign)) {
    324333                /* if both are negative, smaller is that with greater binary value */
    325                 return lt128(b.binary.hi, b.binary.lo, a.binary.hi, a.binary.lo);
    326         }
    327 
    328         /* lets negate signs - now will be positive numbers allways bigger than
    329          * negative (first bit will be set for unsigned integer comparison) */
    330         a.parts.sign = !a.parts.sign;
    331         b.parts.sign = !b.parts.sign;
    332         return lt128(a.binary.hi, a.binary.lo, b.binary.hi, b.binary.lo);
     334                return lt128(b.bin.hi, b.bin.lo, a.bin.hi, a.bin.lo);
     335        }
     336       
     337        /*
     338         * lets negate signs - now will be positive numbers always
     339         * bigger than negative (first bit will be set for unsigned
     340         * integer comparison)
     341         */
     342        a.parts.sign = !a.parts.sign;
     343        b.parts.sign = !b.parts.sign;
     344        return lt128(a.bin.hi, a.bin.lo, b.bin.hi, b.bin.lo);
    333345}
    334346
     
    340352 * @return 1 if a is greater than b, 0 otherwise.
    341353 */
    342 int isFloat32gt(float32 a, float32 b)
    343 {
    344         if (((a.binary | b.binary) & 0x7FFFFFFF) == 0) {
    345                 return 0; /* zeroes are equal with any sign */
     354int is_float32_gt(float32 a, float32 b)
     355{
     356        if (((a.bin | b.bin) & 0x7FFFFFFF) == 0) {
     357                /* zeroes are equal with any sign */
     358                return 0;
    346359        }
    347360       
    348361        if ((a.parts.sign) && (b.parts.sign)) {
    349362                /* if both are negative, greater is that with smaller binary value */
    350                 return (a.binary < b.binary);
    351         }
    352        
    353         /* lets negate signs - now will be positive numbers allways bigger than
    354          *  negative (first bit will be set for unsigned integer comparison) */
    355         a.parts.sign = !a.parts.sign;
    356         b.parts.sign = !b.parts.sign;
    357         return (a.binary > b.binary);
     363                return (a.bin < b.bin);
     364        }
     365       
     366        /*
     367         * lets negate signs - now will be positive numbers always
     368         * bigger than negative (first bit will be set for unsigned
     369         * integer comparison)
     370         */
     371        a.parts.sign = !a.parts.sign;
     372        b.parts.sign = !b.parts.sign;
     373        return (a.bin > b.bin);
    358374}
    359375
     
    365381 * @return 1 if a is greater than b, 0 otherwise.
    366382 */
    367 int isFloat64gt(float64 a, float64 b)
    368 {
    369         if (((a.binary | b.binary) & 0x7FFFFFFFFFFFFFFFll) == 0) {
    370                 return 0; /* zeroes are equal with any sign */
    371         }
    372 
     383int is_float64_gt(float64 a, float64 b)
     384{
     385        if (((a.bin | b.bin) & 0x7FFFFFFFFFFFFFFFll) == 0) {
     386                /* zeroes are equal with any sign */
     387                return 0;
     388        }
     389       
    373390        if ((a.parts.sign) && (b.parts.sign)) {
    374391                /* if both are negative, greater is that with smaller binary value */
    375                 return (a.binary < b.binary);
    376         }
    377 
    378         /* lets negate signs - now will be positive numbers allways bigger than
    379          *  negative (first bit will be set for unsigned integer comparison) */
    380         a.parts.sign = !a.parts.sign;
    381         b.parts.sign = !b.parts.sign;
    382         return (a.binary > b.binary);
     392                return (a.bin < b.bin);
     393        }
     394       
     395        /*
     396         * lets negate signs - now will be positive numbers always
     397         * bigger than negative (first bit will be set for unsigned
     398         * integer comparison)
     399         */
     400        a.parts.sign = !a.parts.sign;
     401        b.parts.sign = !b.parts.sign;
     402        return (a.bin > b.bin);
    383403}
    384404
     
    390410 * @return 1 if a is greater than b, 0 otherwise.
    391411 */
    392 int isFloat128gt(float128 a, float128 b)
     412int is_float128_gt(float128 a, float128 b)
    393413{
    394414        uint64_t tmp_hi;
    395415        uint64_t tmp_lo;
    396 
    397         or128(a.binary.hi, a.binary.lo,
    398             b.binary.hi, b.binary.lo, &tmp_hi, &tmp_lo);
     416       
     417        or128(a.bin.hi, a.bin.lo,
     418            b.bin.hi, b.bin.lo, &tmp_hi, &tmp_lo);
    399419        and128(tmp_hi, tmp_lo,
    400420            0x7FFFFFFFFFFFFFFFll, 0xFFFFFFFFFFFFFFFFll, &tmp_hi, &tmp_lo);
    401421        if (eq128(tmp_hi, tmp_lo, 0x0ll, 0x0ll)) {
    402                 return 0; /* zeroes are equal with any sign */
    403         }
    404 
     422                /* zeroes are equal with any sign */
     423                return 0;
     424        }
     425       
    405426        if ((a.parts.sign) && (b.parts.sign)) {
    406427                /* if both are negative, greater is that with smaller binary value */
    407                 return lt128(a.binary.hi, a.binary.lo, b.binary.hi, b.binary.lo);
    408         }
    409 
    410         /* lets negate signs - now will be positive numbers allways bigger than
    411          *  negative (first bit will be set for unsigned integer comparison) */
    412         a.parts.sign = !a.parts.sign;
    413         b.parts.sign = !b.parts.sign;
    414         return lt128(b.binary.hi, b.binary.lo, a.binary.hi, a.binary.lo);
     428                return lt128(a.bin.hi, a.bin.lo, b.bin.hi, b.bin.lo);
     429        }
     430       
     431        /*
     432         * lets negate signs - now will be positive numbers always
     433         * bigger than negative (first bit will be set for unsigned
     434         * integer comparison)
     435         */
     436        a.parts.sign = !a.parts.sign;
     437        b.parts.sign = !b.parts.sign;
     438        return lt128(b.bin.hi, b.bin.lo, a.bin.hi, a.bin.lo);
    415439}
    416440
  • uspace/lib/softfloat/generic/conversion.c

    r8bcd727 r88d5c1e  
    3939#include <common.h>
    4040
    41 float64 convertFloat32ToFloat64(float32 a)
     41float64 float32_to_float64(float32 a)
    4242{
    4343        float64 result;
     
    4848        result.parts.fraction <<= (FLOAT64_FRACTION_SIZE - FLOAT32_FRACTION_SIZE);
    4949       
    50         if ((isFloat32Infinity(a)) || (isFloat32NaN(a))) {
     50        if ((is_float32_infinity(a)) || (is_float32_nan(a))) {
    5151                result.parts.exp = FLOAT64_MAX_EXPONENT;
    52                 /* TODO; check if its correct for SigNaNs*/
     52                // TODO; check if its correct for SigNaNs
    5353                return result;
    5454        }
     
    5757        if (a.parts.exp == 0) {
    5858                /* normalize denormalized numbers */
    59 
     59               
    6060                if (result.parts.fraction == 0) { /* fix zero */
    6161                        result.parts.exp = 0;
     
    7777}
    7878
    79 float128 convertFloat32ToFloat128(float32 a)
     79float128 float32_to_float128(float32 a)
    8080{
    8181        float128 result;
    8282        uint64_t frac_hi, frac_lo;
    8383        uint64_t tmp_hi, tmp_lo;
    84 
     84       
    8585        result.parts.sign = a.parts.sign;
    8686        result.parts.frac_hi = 0;
     
    9191        result.parts.frac_hi = frac_hi;
    9292        result.parts.frac_lo = frac_lo;
    93 
    94         if ((isFloat32Infinity(a)) || (isFloat32NaN(a))) {
     93       
     94        if ((is_float32_infinity(a)) || (is_float32_nan(a))) {
    9595                result.parts.exp = FLOAT128_MAX_EXPONENT;
    96                 /* TODO; check if its correct for SigNaNs*/
    97                 return result;
    98         }
    99 
     96                // TODO; check if its correct for SigNaNs
     97                return result;
     98        }
     99       
    100100        result.parts.exp = a.parts.exp + ((int) FLOAT128_BIAS - FLOAT32_BIAS);
    101101        if (a.parts.exp == 0) {
    102102                /* normalize denormalized numbers */
    103 
     103               
    104104                if (eq128(result.parts.frac_hi,
    105105                    result.parts.frac_lo, 0x0ll, 0x0ll)) { /* fix zero */
     
    107107                        return result;
    108108                }
    109 
     109               
    110110                frac_hi = result.parts.frac_hi;
    111111                frac_lo = result.parts.frac_lo;
    112 
     112               
    113113                and128(frac_hi, frac_lo,
    114114                    FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO,
     
    118118                        --result.parts.exp;
    119119                }
    120 
     120               
    121121                ++result.parts.exp;
    122122                result.parts.frac_hi = frac_hi;
    123123                result.parts.frac_lo = frac_lo;
    124124        }
    125 
    126         return result;
    127 }
    128 
    129 float128 convertFloat64ToFloat128(float64 a)
     125       
     126        return result;
     127}
     128
     129float128 float64_to_float128(float64 a)
    130130{
    131131        float128 result;
    132132        uint64_t frac_hi, frac_lo;
    133133        uint64_t tmp_hi, tmp_lo;
    134 
     134       
    135135        result.parts.sign = a.parts.sign;
    136136        result.parts.frac_hi = 0;
     
    141141        result.parts.frac_hi = frac_hi;
    142142        result.parts.frac_lo = frac_lo;
    143 
    144         if ((isFloat64Infinity(a)) || (isFloat64NaN(a))) {
     143       
     144        if ((is_float64_infinity(a)) || (is_float64_nan(a))) {
    145145                result.parts.exp = FLOAT128_MAX_EXPONENT;
    146                 /* TODO; check if its correct for SigNaNs*/
    147                 return result;
    148         }
    149 
     146                // TODO; check if its correct for SigNaNs
     147                return result;
     148        }
     149       
    150150        result.parts.exp = a.parts.exp + ((int) FLOAT128_BIAS - FLOAT64_BIAS);
    151151        if (a.parts.exp == 0) {
    152152                /* normalize denormalized numbers */
    153 
     153               
    154154                if (eq128(result.parts.frac_hi,
    155155                    result.parts.frac_lo, 0x0ll, 0x0ll)) { /* fix zero */
     
    157157                        return result;
    158158                }
    159 
     159               
    160160                frac_hi = result.parts.frac_hi;
    161161                frac_lo = result.parts.frac_lo;
    162 
     162               
    163163                and128(frac_hi, frac_lo,
    164164                    FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO,
     
    168168                        --result.parts.exp;
    169169                }
    170 
     170               
    171171                ++result.parts.exp;
    172172                result.parts.frac_hi = frac_hi;
    173173                result.parts.frac_lo = frac_lo;
    174174        }
    175 
    176         return result;
    177 }
    178 
    179 float32 convertFloat64ToFloat32(float64 a)
     175       
     176        return result;
     177}
     178
     179float32 float64_to_float32(float64 a)
    180180{
    181181        float32 result;
     
    185185        result.parts.sign = a.parts.sign;
    186186       
    187         if (isFloat64NaN(a)) {
     187        if (is_float64_nan(a)) {
    188188                result.parts.exp = FLOAT32_MAX_EXPONENT;
    189189               
    190                 if (isFloat64SigNaN(a)) {
     190                if (is_float64_signan(a)) {
    191191                        /* set first bit of fraction nonzero */
    192192                        result.parts.fraction = FLOAT32_HIDDEN_BIT_MASK >> 1;
    193193                        return result;
    194194                }
    195 
     195               
    196196                /* fraction nonzero but its first bit is zero */
    197197                result.parts.fraction = 0x1;
    198198                return result;
    199199        }
    200 
    201         if (isFloat64Infinity(a)) {
     200       
     201        if (is_float64_infinity(a)) {
    202202                result.parts.fraction = 0;
    203203                result.parts.exp = FLOAT32_MAX_EXPONENT;
    204204                return result;
    205205        }
    206 
     206       
    207207        exp = (int) a.parts.exp - FLOAT64_BIAS + FLOAT32_BIAS;
    208208       
     
    239239                return result;
    240240        }
    241 
     241       
    242242        result.parts.exp = exp;
    243243        result.parts.fraction =
     
    246246}
    247247
    248 float32 convertFloat128ToFloat32(float128 a)
     248float32 float128_to_float32(float128 a)
    249249{
    250250        float32 result;
    251251        int32_t exp;
    252252        uint64_t frac_hi, frac_lo;
    253 
     253       
    254254        result.parts.sign = a.parts.sign;
    255 
    256         if (isFloat128NaN(a)) {
     255       
     256        if (is_float128_nan(a)) {
    257257                result.parts.exp = FLOAT32_MAX_EXPONENT;
    258 
    259                 if (isFloat128SigNaN(a)) {
     258               
     259                if (is_float128_signan(a)) {
    260260                        /* set first bit of fraction nonzero */
    261261                        result.parts.fraction = FLOAT32_HIDDEN_BIT_MASK >> 1;
    262262                        return result;
    263263                }
    264 
     264               
    265265                /* fraction nonzero but its first bit is zero */
    266266                result.parts.fraction = 0x1;
    267267                return result;
    268268        }
    269 
    270         if (isFloat128Infinity(a)) {
     269       
     270        if (is_float128_infinity(a)) {
    271271                result.parts.fraction = 0;
    272272                result.parts.exp = FLOAT32_MAX_EXPONENT;
    273273                return result;
    274274        }
    275 
     275       
    276276        exp = (int) a.parts.exp - FLOAT128_BIAS + FLOAT32_BIAS;
    277 
     277       
    278278        if (exp >= FLOAT32_MAX_EXPONENT) {
    279279                /* FIXME: overflow */
     
    283283        } else if (exp <= 0) {
    284284                /* underflow or denormalized */
    285 
     285               
    286286                result.parts.exp = 0;
    287 
     287               
    288288                exp *= -1;
    289289                if (exp > FLOAT32_FRACTION_SIZE) {
     
    292292                        return result;
    293293                }
    294 
     294               
    295295                /* denormalized */
    296 
     296               
    297297                frac_hi = a.parts.frac_hi;
    298298                frac_lo = a.parts.frac_lo;
    299 
     299               
    300300                /* denormalize and set hidden bit */
    301301                frac_hi |= FLOAT128_HIDDEN_BIT_MASK_HI;
    302 
     302               
    303303                rshift128(frac_hi, frac_lo,
    304304                    (FLOAT128_FRACTION_SIZE - FLOAT32_FRACTION_SIZE + 1),
    305305                    &frac_hi, &frac_lo);
    306 
     306               
    307307                while (exp > 0) {
    308308                        --exp;
     
    310310                }
    311311                result.parts.fraction = frac_lo;
    312 
    313                 return result;
    314         }
    315 
     312               
     313                return result;
     314        }
     315       
    316316        result.parts.exp = exp;
    317317        frac_hi = a.parts.frac_hi;
     
    324324}
    325325
    326 float64 convertFloat128ToFloat64(float128 a)
     326float64 float128_to_float64(float128 a)
    327327{
    328328        float64 result;
    329329        int32_t exp;
    330330        uint64_t frac_hi, frac_lo;
    331 
     331       
    332332        result.parts.sign = a.parts.sign;
    333 
    334         if (isFloat128NaN(a)) {
     333       
     334        if (is_float128_nan(a)) {
    335335                result.parts.exp = FLOAT64_MAX_EXPONENT;
    336 
    337                 if (isFloat128SigNaN(a)) {
     336               
     337                if (is_float128_signan(a)) {
    338338                        /* set first bit of fraction nonzero */
    339339                        result.parts.fraction = FLOAT64_HIDDEN_BIT_MASK >> 1;
    340340                        return result;
    341341                }
    342 
     342               
    343343                /* fraction nonzero but its first bit is zero */
    344344                result.parts.fraction = 0x1;
    345345                return result;
    346346        }
    347 
    348         if (isFloat128Infinity(a)) {
     347       
     348        if (is_float128_infinity(a)) {
    349349                result.parts.fraction = 0;
    350350                result.parts.exp = FLOAT64_MAX_EXPONENT;
    351351                return result;
    352352        }
    353 
     353       
    354354        exp = (int) a.parts.exp - FLOAT128_BIAS + FLOAT64_BIAS;
    355 
     355       
    356356        if (exp >= FLOAT64_MAX_EXPONENT) {
    357357                /* FIXME: overflow */
     
    361361        } else if (exp <= 0) {
    362362                /* underflow or denormalized */
    363 
     363               
    364364                result.parts.exp = 0;
    365 
     365               
    366366                exp *= -1;
    367367                if (exp > FLOAT64_FRACTION_SIZE) {
     
    370370                        return result;
    371371                }
    372 
     372               
    373373                /* denormalized */
    374 
     374               
    375375                frac_hi = a.parts.frac_hi;
    376376                frac_lo = a.parts.frac_lo;
    377 
     377               
    378378                /* denormalize and set hidden bit */
    379379                frac_hi |= FLOAT128_HIDDEN_BIT_MASK_HI;
    380 
     380               
    381381                rshift128(frac_hi, frac_lo,
    382382                    (FLOAT128_FRACTION_SIZE - FLOAT64_FRACTION_SIZE + 1),
    383383                    &frac_hi, &frac_lo);
    384 
     384               
    385385                while (exp > 0) {
    386386                        --exp;
     
    388388                }
    389389                result.parts.fraction = frac_lo;
    390 
    391                 return result;
    392         }
    393 
     390               
     391                return result;
     392        }
     393       
    394394        result.parts.exp = exp;
    395395        frac_hi = a.parts.frac_hi;
     
    402402}
    403403
    404 
    405 /**
    406  * Helping procedure for converting float32 to uint32.
     404/** Helper procedure for converting float32 to uint32.
    407405 *
    408406 * @param a Floating point number in normalized form
     
    424422        /* shift fraction to left so hidden bit will be the most significant bit */
    425423        frac <<= 32 - FLOAT32_FRACTION_SIZE - 1;
    426 
     424       
    427425        frac >>= 32 - (a.parts.exp - FLOAT32_BIAS) - 1;
    428426        if ((a.parts.sign == 1) && (frac != 0)) {
     
    434432}
    435433
    436 /* 
    437  * FIXME: Im not sure what to return if overflow/underflow happens 
    438  *      - now its the biggest or the smallest int
    439  */ 
     434/*
     435 * FIXME: Im not sure what to return if overflow/underflow happens
     436 *  - now its the biggest or the smallest int
     437 */
    440438uint32_t float32_to_uint32(float32 a)
    441439{
    442         if (isFloat32NaN(a))
     440        if (is_float32_nan(a))
    443441                return UINT32_MAX;
    444442       
    445         if (isFloat32Infinity(a) || (a.parts.exp >= (32 + FLOAT32_BIAS))) {
     443        if (is_float32_infinity(a) || (a.parts.exp >= (32 + FLOAT32_BIAS))) {
    446444                if (a.parts.sign)
    447445                        return UINT32_MIN;
     
    453451}
    454452
    455 /* 
    456  * FIXME: Im not sure what to return if overflow/underflow happens 
    457  *      - now its the biggest or the smallest int
    458  */ 
     453/*
     454 * FIXME: Im not sure what to return if overflow/underflow happens
     455 *  - now its the biggest or the smallest int
     456 */
    459457int32_t float32_to_int32(float32 a)
    460458{
    461         if (isFloat32NaN(a))
     459        if (is_float32_nan(a))
    462460                return INT32_MAX;
    463461       
    464         if (isFloat32Infinity(a) || (a.parts.exp >= (32 + FLOAT32_BIAS))) {
     462        if (is_float32_infinity(a) || (a.parts.exp >= (32 + FLOAT32_BIAS))) {
    465463                if (a.parts.sign)
    466464                        return INT32_MIN;
     
    472470}
    473471
    474 
    475 /**
    476  * Helping procedure for converting float32 to uint64.
     472/** Helper procedure for converting float32 to uint64.
    477473 *
    478474 * @param a Floating point number in normalized form
     
    483479{
    484480        uint64_t frac;
    485 
     481       
    486482        if (a.parts.exp < FLOAT32_BIAS) {
    487                 /*TODO: rounding*/
     483                // TODO: rounding
    488484                return 0;
    489485        }
    490 
     486       
    491487        frac = a.parts.fraction;
    492 
     488       
    493489        frac |= FLOAT32_HIDDEN_BIT_MASK;
    494490        /* shift fraction to left so hidden bit will be the most significant bit */
    495491        frac <<= 64 - FLOAT32_FRACTION_SIZE - 1;
    496 
     492       
    497493        frac >>= 64 - (a.parts.exp - FLOAT32_BIAS) - 1;
    498494        if ((a.parts.sign == 1) && (frac != 0)) {
     
    500496                ++frac;
    501497        }
    502 
     498       
    503499        return frac;
    504500}
    505501
    506 /* 
     502/*
    507503 * FIXME: Im not sure what to return if overflow/underflow happens
    508  *      - now its the biggest or the smallest int
     504 *  - now its the biggest or the smallest int
    509505 */
    510506uint64_t float32_to_uint64(float32 a)
    511507{
    512         if (isFloat32NaN(a))
     508        if (is_float32_nan(a))
    513509                return UINT64_MAX;
    514 
    515 
    516         if (isFloat32Infinity(a) || (a.parts.exp >= (64 + FLOAT32_BIAS))) {
     510       
     511        if (is_float32_infinity(a) || (a.parts.exp >= (64 + FLOAT32_BIAS))) {
    517512                if (a.parts.sign)
    518513                        return UINT64_MIN;
    519 
     514               
    520515                return UINT64_MAX;
    521516        }
    522 
     517       
    523518        return _float32_to_uint64_helper(a);
    524519}
    525520
    526 /* 
     521/*
    527522 * FIXME: Im not sure what to return if overflow/underflow happens
    528  *      - now its the biggest or the smallest int
     523 *  - now its the biggest or the smallest int
    529524 */
    530525int64_t float32_to_int64(float32 a)
    531526{
    532         if (isFloat32NaN(a))
     527        if (is_float32_nan(a))
    533528                return INT64_MAX;
    534 
    535         if (isFloat32Infinity(a) || (a.parts.exp >= (64 + FLOAT32_BIAS))) {
     529       
     530        if (is_float32_infinity(a) || (a.parts.exp >= (64 + FLOAT32_BIAS))) {
    536531                if (a.parts.sign)
    537532                        return INT64_MIN;
    538 
     533               
    539534                return INT64_MAX;
    540535        }
    541 
     536       
    542537        return _float32_to_uint64_helper(a);
    543538}
    544539
    545 
    546 /**
    547  * Helping procedure for converting float64 to uint64.
     540/** Helper procedure for converting float64 to uint64.
    548541 *
    549542 * @param a Floating point number in normalized form
     
    554547{
    555548        uint64_t frac;
    556 
     549       
    557550        if (a.parts.exp < FLOAT64_BIAS) {
    558                 /*TODO: rounding*/
     551                // TODO: rounding
    559552                return 0;
    560553        }
    561 
     554       
    562555        frac = a.parts.fraction;
    563 
     556       
    564557        frac |= FLOAT64_HIDDEN_BIT_MASK;
    565558        /* shift fraction to left so hidden bit will be the most significant bit */
    566559        frac <<= 64 - FLOAT64_FRACTION_SIZE - 1;
    567 
     560       
    568561        frac >>= 64 - (a.parts.exp - FLOAT64_BIAS) - 1;
    569562        if ((a.parts.sign == 1) && (frac != 0)) {
     
    571564                ++frac;
    572565        }
    573 
     566       
    574567        return frac;
    575568}
     
    577570/*
    578571 * FIXME: Im not sure what to return if overflow/underflow happens
    579  *      - now its the biggest or the smallest int
     572 *  - now its the biggest or the smallest int
    580573 */
    581574uint32_t float64_to_uint32(float64 a)
    582575{
    583         if (isFloat64NaN(a))
     576        if (is_float64_nan(a))
    584577                return UINT32_MAX;
    585 
    586         if (isFloat64Infinity(a) || (a.parts.exp >= (32 + FLOAT64_BIAS))) {
     578       
     579        if (is_float64_infinity(a) || (a.parts.exp >= (32 + FLOAT64_BIAS))) {
    587580                if (a.parts.sign)
    588581                        return UINT32_MIN;
    589 
     582               
    590583                return UINT32_MAX;
    591584        }
    592 
     585       
    593586        return (uint32_t) _float64_to_uint64_helper(a);
    594587}
     
    596589/*
    597590 * FIXME: Im not sure what to return if overflow/underflow happens
    598  *      - now its the biggest or the smallest int
     591 *  - now its the biggest or the smallest int
    599592 */
    600593int32_t float64_to_int32(float64 a)
    601594{
    602         if (isFloat64NaN(a))
     595        if (is_float64_nan(a))
    603596                return INT32_MAX;
    604 
    605         if (isFloat64Infinity(a) || (a.parts.exp >= (32 + FLOAT64_BIAS))) {
     597       
     598        if (is_float64_infinity(a) || (a.parts.exp >= (32 + FLOAT64_BIAS))) {
    606599                if (a.parts.sign)
    607600                        return INT32_MIN;
    608 
     601               
    609602                return INT32_MAX;
    610603        }
    611 
     604       
    612605        return (int32_t) _float64_to_uint64_helper(a);
    613606}
    614607
    615 
    616 /*
     608/*
    617609 * FIXME: Im not sure what to return if overflow/underflow happens
    618  *      - now its the biggest or the smallest int
    619  */ 
     610 *  - now its the biggest or the smallest int
     611 */
    620612uint64_t float64_to_uint64(float64 a)
    621613{
    622         if (isFloat64NaN(a))
     614        if (is_float64_nan(a))
    623615                return UINT64_MAX;
    624616       
    625         if (isFloat64Infinity(a) || (a.parts.exp >= (64 + FLOAT64_BIAS))) {
     617        if (is_float64_infinity(a) || (a.parts.exp >= (64 + FLOAT64_BIAS))) {
    626618                if (a.parts.sign)
    627619                        return UINT64_MIN;
     
    633625}
    634626
    635 /* 
     627/*
    636628 * FIXME: Im not sure what to return if overflow/underflow happens
    637  *      - now its the biggest or the smallest int
    638  */ 
     629 *  - now its the biggest or the smallest int
     630 */
    639631int64_t float64_to_int64(float64 a)
    640632{
    641         if (isFloat64NaN(a))
     633        if (is_float64_nan(a))
    642634                return INT64_MAX;
    643635       
    644         if (isFloat64Infinity(a) || (a.parts.exp >= (64 + FLOAT64_BIAS))) {
     636        if (is_float64_infinity(a) || (a.parts.exp >= (64 + FLOAT64_BIAS))) {
    645637                if (a.parts.sign)
    646638                        return INT64_MIN;
     
    652644}
    653645
    654 
    655 /**
    656  * Helping procedure for converting float128 to uint64.
     646/** Helper procedure for converting float128 to uint64.
    657647 *
    658648 * @param a Floating point number in normalized form
     
    663653{
    664654        uint64_t frac_hi, frac_lo;
    665 
     655       
    666656        if (a.parts.exp < FLOAT128_BIAS) {
    667                 /*TODO: rounding*/
     657                // TODO: rounding
    668658                return 0;
    669659        }
    670 
     660       
    671661        frac_hi = a.parts.frac_hi;
    672662        frac_lo = a.parts.frac_lo;
    673 
     663       
    674664        frac_hi |= FLOAT128_HIDDEN_BIT_MASK_HI;
    675665        /* shift fraction to left so hidden bit will be the most significant bit */
    676666        lshift128(frac_hi, frac_lo,
    677667            (128 - FLOAT128_FRACTION_SIZE - 1), &frac_hi, &frac_lo);
    678 
     668       
    679669        rshift128(frac_hi, frac_lo,
    680670            (128 - (a.parts.exp - FLOAT128_BIAS) - 1), &frac_hi, &frac_lo);
     
    683673                add128(frac_hi, frac_lo, 0x0ll, 0x1ll, &frac_hi, &frac_lo);
    684674        }
    685 
     675       
    686676        return frac_lo;
    687677}
     
    689679/*
    690680 * FIXME: Im not sure what to return if overflow/underflow happens
    691  *      - now its the biggest or the smallest int
     681 *  - now its the biggest or the smallest int
    692682 */
    693683uint32_t float128_to_uint32(float128 a)
    694684{
    695         if (isFloat128NaN(a))
     685        if (is_float128_nan(a))
    696686                return UINT32_MAX;
    697 
    698         if (isFloat128Infinity(a) || (a.parts.exp >= (32 + FLOAT128_BIAS))) {
     687       
     688        if (is_float128_infinity(a) || (a.parts.exp >= (32 + FLOAT128_BIAS))) {
    699689                if (a.parts.sign)
    700690                        return UINT32_MIN;
    701 
     691               
    702692                return UINT32_MAX;
    703693        }
    704 
     694       
    705695        return (uint32_t) _float128_to_uint64_helper(a);
    706696}
     
    708698/*
    709699 * FIXME: Im not sure what to return if overflow/underflow happens
    710  *      - now its the biggest or the smallest int
     700 *  - now its the biggest or the smallest int
    711701 */
    712702int32_t float128_to_int32(float128 a)
    713703{
    714         if (isFloat128NaN(a))
     704        if (is_float128_nan(a))
    715705                return INT32_MAX;
    716 
    717         if (isFloat128Infinity(a) || (a.parts.exp >= (32 + FLOAT128_BIAS))) {
     706       
     707        if (is_float128_infinity(a) || (a.parts.exp >= (32 + FLOAT128_BIAS))) {
    718708                if (a.parts.sign)
    719709                        return INT32_MIN;
    720 
     710               
    721711                return INT32_MAX;
    722712        }
    723 
     713       
    724714        return (int32_t) _float128_to_uint64_helper(a);
    725715}
    726716
    727 
    728717/*
    729718 * FIXME: Im not sure what to return if overflow/underflow happens
    730  *      - now its the biggest or the smallest int
     719 *  - now its the biggest or the smallest int
    731720 */
    732721uint64_t float128_to_uint64(float128 a)
    733722{
    734         if (isFloat128NaN(a))
     723        if (is_float128_nan(a))
    735724                return UINT64_MAX;
    736 
    737         if (isFloat128Infinity(a) || (a.parts.exp >= (64 + FLOAT128_BIAS))) {
     725       
     726        if (is_float128_infinity(a) || (a.parts.exp >= (64 + FLOAT128_BIAS))) {
    738727                if (a.parts.sign)
    739728                        return UINT64_MIN;
    740 
     729               
    741730                return UINT64_MAX;
    742731        }
    743 
     732       
    744733        return _float128_to_uint64_helper(a);
    745734}
     
    747736/*
    748737 * FIXME: Im not sure what to return if overflow/underflow happens
    749  *      - now its the biggest or the smallest int
     738 *  - now its the biggest or the smallest int
    750739 */
    751740int64_t float128_to_int64(float128 a)
    752741{
    753         if (isFloat128NaN(a))
     742        if (is_float128_nan(a))
    754743                return INT64_MAX;
    755 
    756         if (isFloat128Infinity(a) || (a.parts.exp >= (64 + FLOAT128_BIAS))) {
     744       
     745        if (is_float128_infinity(a) || (a.parts.exp >= (64 + FLOAT128_BIAS))) {
    757746                if (a.parts.sign)
    758747                        return INT64_MIN;
    759 
     748               
    760749                return INT64_MAX;
    761750        }
    762 
     751       
    763752        return _float128_to_uint64_helper(a);
    764753}
    765 
    766754
    767755float32 uint32_to_float32(uint32_t i)
     
    773761        result.parts.sign = 0;
    774762        result.parts.fraction = 0;
    775 
    776         counter = countZeroes32(i);
    777 
     763       
     764        counter = count_zeroes32(i);
     765       
    778766        exp = FLOAT32_BIAS + 32 - counter - 1;
    779767       
    780768        if (counter == 32) {
    781                 result.binary = 0;
     769                result.bin = 0;
    782770                return result;
    783771        }
     
    788776                i >>= 1;
    789777        }
    790 
    791         roundFloat32(&exp, &i);
    792 
     778       
     779        round_float32(&exp, &i);
     780       
    793781        result.parts.fraction = i >> (32 - FLOAT32_FRACTION_SIZE - 2);
    794782        result.parts.exp = exp;
    795 
    796         return result;
    797 }
    798 
    799 float32 int32_to_float32(int32_t i) 
     783       
     784        return result;
     785}
     786
     787float32 int32_to_float32(int32_t i)
    800788{
    801789        float32 result;
    802 
    803         if (i < 0) {
     790       
     791        if (i < 0)
    804792                result = uint32_to_float32((uint32_t) (-i));
    805         } else {
     793        else
    806794                result = uint32_to_float32((uint32_t) i);
    807         }
    808795       
    809796        result.parts.sign = i < 0;
    810 
    811         return result;
    812 }
    813 
    814 
    815 float32 uint64_to_float32(uint64_t i)
     797       
     798        return result;
     799}
     800
     801float32 uint64_to_float32(uint64_t i)
    816802{
    817803        int counter;
     
    822808        result.parts.sign = 0;
    823809        result.parts.fraction = 0;
    824 
    825         counter = countZeroes64(i);
    826 
     810       
     811        counter = count_zeroes64(i);
     812       
    827813        exp = FLOAT32_BIAS + 64 - counter - 1;
    828814       
    829815        if (counter == 64) {
    830                 result.binary = 0;
     816                result.bin = 0;
    831817                return result;
    832818        }
     
    840826       
    841827        j = (uint32_t) i;
    842         roundFloat32(&exp, &j);
    843 
     828        round_float32(&exp, &j);
     829       
    844830        result.parts.fraction = j >> (32 - FLOAT32_FRACTION_SIZE - 2);
    845831        result.parts.exp = exp;
     
    847833}
    848834
    849 float32 int64_to_float32(int64_t i) 
     835float32 int64_to_float32(int64_t i)
    850836{
    851837        float32 result;
    852 
    853         if (i < 0) {
     838       
     839        if (i < 0)
    854840                result = uint64_to_float32((uint64_t) (-i));
    855         } else {
     841        else
    856842                result = uint64_to_float32((uint64_t) i);
    857         }
    858843       
    859844        result.parts.sign = i < 0;
    860 
    861         return result;
     845       
     846        return result;
    862847}
    863848
     
    871856        result.parts.sign = 0;
    872857        result.parts.fraction = 0;
    873 
    874         counter = countZeroes32(i);
    875 
     858       
     859        counter = count_zeroes32(i);
     860       
    876861        exp = FLOAT64_BIAS + 32 - counter - 1;
    877862       
    878863        if (counter == 32) {
    879                 result.binary = 0;
     864                result.bin = 0;
    880865                return result;
    881866        }
    882867       
    883868        frac = i;
    884         frac <<= counter + 32 - 1; 
    885 
    886         roundFloat64(&exp, &frac);
    887 
     869        frac <<= counter + 32 - 1;
     870       
     871        round_float64(&exp, &frac);
     872       
    888873        result.parts.fraction = frac >> (64 - FLOAT64_FRACTION_SIZE - 2);
    889874        result.parts.exp = exp;
    890 
    891         return result;
    892 }
    893 
    894 float64 int32_to_float64(int32_t i) 
     875       
     876        return result;
     877}
     878
     879float64 int32_to_float64(int32_t i)
    895880{
    896881        float64 result;
    897 
    898         if (i < 0) {
     882       
     883        if (i < 0)
    899884                result = uint32_to_float64((uint32_t) (-i));
    900         } else {
     885        else
    901886                result = uint32_to_float64((uint32_t) i);
    902         }
    903887       
    904888        result.parts.sign = i < 0;
    905 
    906         return result;
    907 }
    908 
    909 
    910 float64 uint64_to_float64(uint64_t i) 
     889       
     890        return result;
     891}
     892
     893
     894float64 uint64_to_float64(uint64_t i)
    911895{
    912896        int counter;
     
    916900        result.parts.sign = 0;
    917901        result.parts.fraction = 0;
    918 
    919         counter = countZeroes64(i);
    920 
     902       
     903        counter = count_zeroes64(i);
     904       
    921905        exp = FLOAT64_BIAS + 64 - counter - 1;
    922906       
    923907        if (counter == 64) {
    924                 result.binary = 0;
     908                result.bin = 0;
    925909                return result;
    926910        }
     
    931915                i >>= 1;
    932916        }
    933 
    934         roundFloat64(&exp, &i);
    935 
     917       
     918        round_float64(&exp, &i);
     919       
    936920        result.parts.fraction = i >> (64 - FLOAT64_FRACTION_SIZE - 2);
    937921        result.parts.exp = exp;
     
    939923}
    940924
    941 float64 int64_to_float64(int64_t i) 
     925float64 int64_to_float64(int64_t i)
    942926{
    943927        float64 result;
    944 
    945         if (i < 0) {
     928       
     929        if (i < 0)
    946930                result = uint64_to_float64((uint64_t) (-i));
    947         } else {
     931        else
    948932                result = uint64_to_float64((uint64_t) i);
    949         }
    950933       
    951934        result.parts.sign = i < 0;
    952 
    953         return result;
    954 }
    955 
     935       
     936        return result;
     937}
    956938
    957939float128 uint32_to_float128(uint32_t i)
     
    961943        float128 result;
    962944        uint64_t frac_hi, frac_lo;
    963 
     945       
    964946        result.parts.sign = 0;
    965947        result.parts.frac_hi = 0;
    966948        result.parts.frac_lo = 0;
    967 
    968         counter = countZeroes32(i);
    969 
     949       
     950        counter = count_zeroes32(i);
     951       
    970952        exp = FLOAT128_BIAS + 32 - counter - 1;
    971 
     953       
    972954        if (counter == 32) {
    973                 result.binary.hi = 0;
    974                 result.binary.lo = 0;
    975                 return result;
    976         }
    977 
     955                result.bin.hi = 0;
     956                result.bin.lo = 0;
     957                return result;
     958        }
     959       
    978960        frac_hi = 0;
    979961        frac_lo = i;
    980962        lshift128(frac_hi, frac_lo, (counter + 96 - 1), &frac_hi, &frac_lo);
    981 
    982         roundFloat128(&exp, &frac_hi, &frac_lo);
    983 
     963       
     964        round_float128(&exp, &frac_hi, &frac_lo);
     965       
    984966        rshift128(frac_hi, frac_lo,
    985967            (128 - FLOAT128_FRACTION_SIZE - 2), &frac_hi, &frac_lo);
     
    987969        result.parts.frac_lo = frac_lo;
    988970        result.parts.exp = exp;
    989 
     971       
    990972        return result;
    991973}
     
    994976{
    995977        float128 result;
    996 
    997         if (i < 0) {
     978       
     979        if (i < 0)
    998980                result = uint32_to_float128((uint32_t) (-i));
    999         } else {
     981        else
    1000982                result = uint32_to_float128((uint32_t) i);
    1001         }
    1002 
     983       
    1003984        result.parts.sign = i < 0;
    1004 
    1005         return result;
     985       
     986        return result;
    1006987}
    1007988
     
    1013994        float128 result;
    1014995        uint64_t frac_hi, frac_lo;
    1015 
     996       
    1016997        result.parts.sign = 0;
    1017998        result.parts.frac_hi = 0;
    1018999        result.parts.frac_lo = 0;
    1019 
    1020         counter = countZeroes64(i);
    1021 
     1000       
     1001        counter = count_zeroes64(i);
     1002       
    10221003        exp = FLOAT128_BIAS + 64 - counter - 1;
    1023 
     1004       
    10241005        if (counter == 64) {
    1025                 result.binary.hi = 0;
    1026                 result.binary.lo = 0;
    1027                 return result;
    1028         }
    1029 
     1006                result.bin.hi = 0;
     1007                result.bin.lo = 0;
     1008                return result;
     1009        }
     1010       
    10301011        frac_hi = 0;
    10311012        frac_lo = i;
    10321013        lshift128(frac_hi, frac_lo, (counter + 64 - 1), &frac_hi, &frac_lo);
    1033 
    1034         roundFloat128(&exp, &frac_hi, &frac_lo);
    1035 
     1014       
     1015        round_float128(&exp, &frac_hi, &frac_lo);
     1016       
    10361017        rshift128(frac_hi, frac_lo,
    10371018            (128 - FLOAT128_FRACTION_SIZE - 2), &frac_hi, &frac_lo);
     
    10391020        result.parts.frac_lo = frac_lo;
    10401021        result.parts.exp = exp;
    1041 
     1022       
    10421023        return result;
    10431024}
     
    10461027{
    10471028        float128 result;
    1048 
    1049         if (i < 0) {
     1029       
     1030        if (i < 0)
    10501031                result = uint64_to_float128((uint64_t) (-i));
    1051         } else {
     1032        else
    10521033                result = uint64_to_float128((uint64_t) i);
    1053         }
    1054 
     1034       
    10551035        result.parts.sign = i < 0;
    1056 
    1057         return result;
     1036       
     1037        return result;
    10581038}
    10591039
  • uspace/lib/softfloat/generic/div.c

    r8bcd727 r88d5c1e  
    4141#include <common.h>
    4242
    43 /**
    44  * Divide two single-precision floats.
    45  *
     43/** Divide two single-precision floats.
     44 *
    4645 * @param a Nominator.
    4746 * @param b Denominator.
     47 *
    4848 * @return Result of division.
    49  */
    50 float32 divFloat32(float32 a, float32 b)
     49 *
     50 */
     51float32 div_float32(float32 a, float32 b)
    5152{
    5253        float32 result;
     
    5657        result.parts.sign = a.parts.sign ^ b.parts.sign;
    5758       
    58         if (isFloat32NaN(a)) {
    59                 if (isFloat32SigNaN(a)) {
    60                         /*FIXME: SigNaN*/
    61                 }
    62                 /*NaN*/
     59        if (is_float32_nan(a)) {
     60                if (is_float32_signan(a)) {
     61                        // FIXME: SigNaN
     62                }
     63                /* NaN */
    6364                return a;
    6465        }
    6566       
    66         if (isFloat32NaN(b)) {
    67                 if (isFloat32SigNaN(b)) {
    68                         /*FIXME: SigNaN*/
    69                 }
    70                 /*NaN*/
     67        if (is_float32_nan(b)) {
     68                if (is_float32_signan(b)) {
     69                        // FIXME: SigNaN
     70                }
     71                /* NaN */
    7172                return b;
    7273        }
    7374       
    74         if (isFloat32Infinity(a)) {
    75                 if (isFloat32Infinity(b)) {
     75        if (is_float32_infinity(a)) {
     76                if (is_float32_infinity(b)) {
    7677                        /*FIXME: inf / inf */
    77                         result.binary = FLOAT32_NAN;
     78                        result.bin = FLOAT32_NAN;
    7879                        return result;
    7980                }
     
    8384                return result;
    8485        }
    85 
    86         if (isFloat32Infinity(b)) {
    87                 if (isFloat32Zero(a)) {
     86       
     87        if (is_float32_infinity(b)) {
     88                if (is_float32_zero(a)) {
    8889                        /* FIXME 0 / inf */
    8990                        result.parts.exp = 0;
     
    9798        }
    9899       
    99         if (isFloat32Zero(b)) {
    100                 if (isFloat32Zero(a)) {
     100        if (is_float32_zero(b)) {
     101                if (is_float32_zero(a)) {
    101102                        /*FIXME: 0 / 0*/
    102                         result.binary = FLOAT32_NAN;
     103                        result.bin = FLOAT32_NAN;
    103104                        return result;
    104105                }
     
    121122                        return result;
    122123                }
    123 
     124               
    124125                /* normalize it*/
    125126                afrac <<= 1;
    126                 /* afrac is nonzero => it must stop */ 
     127                /* afrac is nonzero => it must stop */
    127128                while (!(afrac & FLOAT32_HIDDEN_BIT_MASK)) {
    128129                        afrac <<= 1;
     
    130131                }
    131132        }
    132 
     133       
    133134        if (bexp == 0) {
    134135                bfrac <<= 1;
    135                 /* bfrac is nonzero => it must stop */ 
     136                /* bfrac is nonzero => it must stop */
    136137                while (!(bfrac & FLOAT32_HIDDEN_BIT_MASK)) {
    137138                        bfrac <<= 1;
     
    139140                }
    140141        }
    141 
    142         afrac = (afrac | FLOAT32_HIDDEN_BIT_MASK) << (32 - FLOAT32_FRACTION_SIZE - 1);
    143         bfrac = (bfrac | FLOAT32_HIDDEN_BIT_MASK) << (32 - FLOAT32_FRACTION_SIZE);
    144 
     142       
     143        afrac = (afrac | FLOAT32_HIDDEN_BIT_MASK) << (32 - FLOAT32_FRACTION_SIZE - 1);
     144        bfrac = (bfrac | FLOAT32_HIDDEN_BIT_MASK) << (32 - FLOAT32_FRACTION_SIZE);
     145       
    145146        if (bfrac <= (afrac << 1)) {
    146147                afrac >>= 1;
     
    169170                ++cexp;
    170171                cfrac >>= 1;
    171         }       
    172 
     172        }
     173       
    173174        /* check overflow */
    174175        if (cexp >= FLOAT32_MAX_EXPONENT) {
     
    178179                return result;
    179180        }
    180 
     181       
    181182        if (cexp < 0) {
    182183                /* FIXME: underflow */
     
    190191                        cexp++;
    191192                        cfrac >>= 1;
    192                 }       
     193                }
    193194        } else {
    194195                result.parts.exp = (uint32_t) cexp;
     
    197198        result.parts.fraction = ((cfrac >> 6) & (~FLOAT32_HIDDEN_BIT_MASK));
    198199       
    199         return result; 
     200        return result;
    200201}
    201202
    202 /**
    203  * Divide two double-precision floats.
     203/** Divide two double-precision floats.
    204204 *
    205205 * @param a Nominator.
    206206 * @param b Denominator.
     207 *
    207208 * @return Result of division.
    208  */
    209 float64 divFloat64(float64 a, float64 b)
     209 *
     210 */
     211float64 div_float64(float64 a, float64 b)
    210212{
    211213        float64 result;
     
    217219        result.parts.sign = a.parts.sign ^ b.parts.sign;
    218220       
    219         if (isFloat64NaN(a)) {
    220                 if (isFloat64SigNaN(b)) {
    221                         /*FIXME: SigNaN*/
     221        if (is_float64_nan(a)) {
     222                if (is_float64_signan(b)) {
     223                        // FIXME: SigNaN
    222224                        return b;
    223225                }
    224226               
    225                 if (isFloat64SigNaN(a)) {
    226                         /*FIXME: SigNaN*/
    227                 }
    228                 /*NaN*/
     227                if (is_float64_signan(a)) {
     228                        // FIXME: SigNaN
     229                }
     230                /* NaN */
    229231                return a;
    230232        }
    231233       
    232         if (isFloat64NaN(b)) {
    233                 if (isFloat64SigNaN(b)) {
    234                         /*FIXME: SigNaN*/
    235                 }
    236                 /*NaN*/
     234        if (is_float64_nan(b)) {
     235                if (is_float64_signan(b)) {
     236                        // FIXME: SigNaN
     237                }
     238                /* NaN */
    237239                return b;
    238240        }
    239241       
    240         if (isFloat64Infinity(a)) {
    241                 if (isFloat64Infinity(b) || isFloat64Zero(b)) {
    242                         /*FIXME: inf / inf */
    243                         result.binary = FLOAT64_NAN;
     242        if (is_float64_infinity(a)) {
     243                if (is_float64_infinity(b) || is_float64_zero(b)) {
     244                        // FIXME: inf / inf
     245                        result.bin = FLOAT64_NAN;
    244246                        return result;
    245247                }
     
    249251                return result;
    250252        }
    251 
    252         if (isFloat64Infinity(b)) {
    253                 if (isFloat64Zero(a)) {
     253       
     254        if (is_float64_infinity(b)) {
     255                if (is_float64_zero(a)) {
    254256                        /* FIXME 0 / inf */
    255257                        result.parts.exp = 0;
     
    263265        }
    264266       
    265         if (isFloat64Zero(b)) {
    266                 if (isFloat64Zero(a)) {
     267        if (is_float64_zero(b)) {
     268                if (is_float64_zero(a)) {
    267269                        /*FIXME: 0 / 0*/
    268                         result.binary = FLOAT64_NAN;
     270                        result.bin = FLOAT64_NAN;
    269271                        return result;
    270272                }
     
    274276                return result;
    275277        }
    276 
     278       
    277279        afrac = a.parts.fraction;
    278280        aexp = a.parts.exp;
     
    287289                        return result;
    288290                }
    289 
     291               
    290292                /* normalize it*/
    291293                aexp++;
     
    296298                }
    297299        }
    298 
     300       
    299301        if (bexp == 0) {
    300302                bexp++;
     
    305307                }
    306308        }
    307 
    308         afrac = (afrac | FLOAT64_HIDDEN_BIT_MASK) << (64 - FLOAT64_FRACTION_SIZE - 2);
    309         bfrac = (bfrac | FLOAT64_HIDDEN_BIT_MASK) << (64 - FLOAT64_FRACTION_SIZE - 1);
    310 
     309       
     310        afrac = (afrac | FLOAT64_HIDDEN_BIT_MASK) << (64 - FLOAT64_FRACTION_SIZE - 2);
     311        bfrac = (bfrac | FLOAT64_HIDDEN_BIT_MASK) << (64 - FLOAT64_FRACTION_SIZE - 1);
     312       
    311313        if (bfrac <= (afrac << 1)) {
    312314                afrac >>= 1;
     
    330332       
    331333        /* round and shift */
    332         result = finishFloat64(cexp, cfrac, result.parts.sign);
     334        result = finish_float64(cexp, cfrac, result.parts.sign);
    333335        return result;
    334336}
    335337
    336 /**
    337  * Divide two quadruple-precision floats.
     338/** Divide two quadruple-precision floats.
    338339 *
    339340 * @param a Nominator.
    340341 * @param b Denominator.
     342 *
    341343 * @return Result of division.
    342  */
    343 float128 divFloat128(float128 a, float128 b)
     344 *
     345 */
     346float128 div_float128(float128 a, float128 b)
    344347{
    345348        float128 result;
     
    349352        uint64_t rem_hihi, rem_hilo, rem_lohi, rem_lolo;
    350353        uint64_t tmp_hihi, tmp_hilo, tmp_lohi, tmp_lolo;
    351 
     354       
    352355        result.parts.sign = a.parts.sign ^ b.parts.sign;
    353 
    354         if (isFloat128NaN(a)) {
    355                 if (isFloat128SigNaN(b)) {
    356                         /*FIXME: SigNaN*/
     356       
     357        if (is_float128_nan(a)) {
     358                if (is_float128_signan(b)) {
     359                        // FIXME: SigNaN
    357360                        return b;
    358361                }
    359 
    360                 if (isFloat128SigNaN(a)) {
    361                         /*FIXME: SigNaN*/
    362                 }
    363                 /*NaN*/
     362               
     363                if (is_float128_signan(a)) {
     364                        // FIXME: SigNaN
     365                }
     366                /* NaN */
    364367                return a;
    365368        }
    366 
    367         if (isFloat128NaN(b)) {
    368                 if (isFloat128SigNaN(b)) {
    369                         /*FIXME: SigNaN*/
    370                 }
    371                 /*NaN*/
     369       
     370        if (is_float128_nan(b)) {
     371                if (is_float128_signan(b)) {
     372                        // FIXME: SigNaN
     373                }
     374                /* NaN */
    372375                return b;
    373376        }
    374 
    375         if (isFloat128Infinity(a)) {
    376                 if (isFloat128Infinity(b) || isFloat128Zero(b)) {
    377                         /*FIXME: inf / inf */
    378                         result.binary.hi = FLOAT128_NAN_HI;
    379                         result.binary.lo = FLOAT128_NAN_LO;
     377       
     378        if (is_float128_infinity(a)) {
     379                if (is_float128_infinity(b) || is_float128_zero(b)) {
     380                        // FIXME: inf / inf
     381                        result.bin.hi = FLOAT128_NAN_HI;
     382                        result.bin.lo = FLOAT128_NAN_LO;
    380383                        return result;
    381384                }
     
    386389                return result;
    387390        }
    388 
    389         if (isFloat128Infinity(b)) {
    390                 if (isFloat128Zero(a)) {
    391                         /* FIXME 0 / inf */
     391       
     392        if (is_float128_infinity(b)) {
     393                if (is_float128_zero(a)) {
     394                        // FIXME 0 / inf
    392395                        result.parts.exp = 0;
    393396                        result.parts.frac_hi = 0;
     
    395398                        return result;
    396399                }
    397                 /* FIXME: num / inf*/
     400                // FIXME: num / inf
    398401                result.parts.exp = 0;
    399402                result.parts.frac_hi = 0;
     
    401404                return result;
    402405        }
    403 
    404         if (isFloat128Zero(b)) {
    405                 if (isFloat128Zero(a)) {
    406                         /*FIXME: 0 / 0*/
    407                         result.binary.hi = FLOAT128_NAN_HI;
    408                         result.binary.lo = FLOAT128_NAN_LO;
    409                         return result;
    410                 }
    411                 /* FIXME: division by zero */
     406       
     407        if (is_float128_zero(b)) {
     408                if (is_float128_zero(a)) {
     409                        // FIXME: 0 / 0
     410                        result.bin.hi = FLOAT128_NAN_HI;
     411                        result.bin.lo = FLOAT128_NAN_LO;
     412                        return result;
     413                }
     414                // FIXME: division by zero
    412415                result.parts.exp = 0;
    413416                result.parts.frac_hi = 0;
     
    415418                return result;
    416419        }
    417 
     420       
    418421        afrac_hi = a.parts.frac_hi;
    419422        afrac_lo = a.parts.frac_lo;
     
    422425        bfrac_lo = b.parts.frac_lo;
    423426        bexp = b.parts.exp;
    424 
     427       
    425428        /* denormalized numbers */
    426429        if (aexp == 0) {
     
    431434                        return result;
    432435                }
    433 
     436               
    434437                /* normalize it*/
    435438                aexp++;
     
    443446                }
    444447        }
    445 
     448       
    446449        if (bexp == 0) {
    447450                bexp++;
     
    455458                }
    456459        }
    457 
     460       
    458461        or128(afrac_hi, afrac_lo,
    459462            FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO,
     
    466469        lshift128(bfrac_hi, bfrac_lo,
    467470            (128 - FLOAT128_FRACTION_SIZE - 1), &bfrac_hi, &bfrac_lo);
    468 
     471       
    469472        if (le128(bfrac_hi, bfrac_lo, afrac_hi, afrac_lo)) {
    470473                rshift128(afrac_hi, afrac_lo, 1, &afrac_hi, &afrac_lo);
    471474                aexp++;
    472475        }
    473 
     476       
    474477        cexp = aexp - bexp + FLOAT128_BIAS - 2;
    475 
     478       
    476479        cfrac_hi = div128est(afrac_hi, afrac_lo, bfrac_hi);
    477 
     480       
    478481        mul128(bfrac_hi, bfrac_lo, 0x0ll, cfrac_hi,
    479482            &tmp_lolo /* dummy */, &tmp_hihi, &tmp_hilo, &tmp_lohi);
    480 
    481         /* sub192(afrac_hi, afrac_lo, 0, 
     483       
     484        /* sub192(afrac_hi, afrac_lo, 0,
    482485         *     tmp_hihi, tmp_hilo, tmp_lohi
    483486         *     &rem_hihi, &rem_hilo, &rem_lohi); */
     
    487490        }
    488491        rem_lohi = -tmp_lohi;
    489 
     492       
    490493        while ((int64_t) rem_hihi < 0) {
    491494                --cfrac_hi;
    492                 /* add192(rem_hihi, rem_hilo, rem_lohi, 
     495                /* add192(rem_hihi, rem_hilo, rem_lohi,
    493496                 *     0, bfrac_hi, bfrac_lo,
    494497                 *     &rem_hihi, &rem_hilo, &rem_lohi); */
     
    498501                }
    499502        }
    500 
     503       
    501504        cfrac_lo = div128est(rem_hilo, rem_lohi, bfrac_lo);
    502 
     505       
    503506        if ((cfrac_lo & 0x3FFF) <= 4) {
    504507                mul128(bfrac_hi, bfrac_lo, 0x0ll, cfrac_lo,
    505                 &tmp_hihi /* dummy */, &tmp_hilo, &tmp_lohi, &tmp_lolo);
    506 
     508                    &tmp_hihi /* dummy */, &tmp_hilo, &tmp_lohi, &tmp_lolo);
     509               
    507510                /* sub192(rem_hilo, rem_lohi, 0,
    508511                 *     tmp_hilo, tmp_lohi, tmp_lolo,
     
    513516                }
    514517                rem_lolo = -tmp_lolo;
    515 
     518               
    516519                while ((int64_t) rem_hilo < 0) {
    517520                        --cfrac_lo;
     
    524527                        }
    525528                }
    526 
     529               
    527530                cfrac_lo |= ((rem_hilo | rem_lohi | rem_lolo) != 0 );
    528531        }
    529 
     532       
    530533        shift_out = cfrac_lo << (64 - (128 - FLOAT128_FRACTION_SIZE - 1));
    531534        rshift128(cfrac_hi, cfrac_lo, (128 - FLOAT128_FRACTION_SIZE - 1),
    532535            &cfrac_hi, &cfrac_lo);
    533 
    534         result = finishFloat128(cexp, cfrac_hi, cfrac_lo, result.parts.sign, shift_out);
     536       
     537        result = finish_float128(cexp, cfrac_hi, cfrac_lo, result.parts.sign, shift_out);
    535538        return result;
    536539}
  • uspace/lib/softfloat/generic/mul.c

    r8bcd727 r88d5c1e  
    3939#include <common.h>
    4040
    41 /**
    42  * Multiply two single-precision floats.
     41/** Multiply two single-precision floats.
    4342 *
    4443 * @param a First input operand.
    4544 * @param b Second input operand.
     45 *
    4646 * @return Result of multiplication.
    47  */
    48 float32 mulFloat32(float32 a, float32 b)
     47 *
     48 */
     49float32 mul_float32(float32 a, float32 b)
    4950{
    5051        float32 result;
    5152        uint64_t frac1, frac2;
    5253        int32_t exp;
    53 
     54       
    5455        result.parts.sign = a.parts.sign ^ b.parts.sign;
    5556       
    56         if (isFloat32NaN(a) || isFloat32NaN(b)) {
     57        if (is_float32_nan(a) || is_float32_nan(b)) {
    5758                /* TODO: fix SigNaNs */
    58                 if (isFloat32SigNaN(a)) {
     59                if (is_float32_signan(a)) {
    5960                        result.parts.fraction = a.parts.fraction;
    6061                        result.parts.exp = a.parts.exp;
    6162                        return result;
    6263                }
    63                 if (isFloat32SigNaN(b)) { /* TODO: fix SigNaN */
     64                if (is_float32_signan(b)) { /* TODO: fix SigNaN */
    6465                        result.parts.fraction = b.parts.fraction;
    6566                        result.parts.exp = b.parts.exp;
     
    6768                }
    6869                /* set NaN as result */
    69                 result.binary = FLOAT32_NAN;
    70                 return result;
    71         }
    72                
    73         if (isFloat32Infinity(a)) {
    74                 if (isFloat32Zero(b)) {
    75                         /* FIXME: zero * infinity */
    76                         result.binary = FLOAT32_NAN;
     70                result.bin = FLOAT32_NAN;
     71                return result;
     72        }
     73       
     74        if (is_float32_infinity(a)) {
     75                if (is_float32_zero(b)) {
     76                        /* FIXME: zero * infinity */
     77                        result.bin = FLOAT32_NAN;
    7778                        return result;
    7879                }
     
    8182                return result;
    8283        }
    83 
    84         if (isFloat32Infinity(b)) {
    85                 if (isFloat32Zero(a)) {
    86                         /* FIXME: zero * infinity */
    87                         result.binary = FLOAT32_NAN;
     84       
     85        if (is_float32_infinity(b)) {
     86                if (is_float32_zero(a)) {
     87                        /* FIXME: zero * infinity */
     88                        result.bin = FLOAT32_NAN;
    8889                        return result;
    8990                }
     
    9293                return result;
    9394        }
    94 
     95       
    9596        /* exp is signed so we can easy detect underflow */
    9697        exp = a.parts.exp + b.parts.exp;
     
    100101                /* FIXME: overflow */
    101102                /* set infinity as result */
    102                 result.binary = FLOAT32_INF;
     103                result.bin = FLOAT32_INF;
    103104                result.parts.sign = a.parts.sign ^ b.parts.sign;
    104105                return result;
     
    121122       
    122123        frac2 = b.parts.fraction;
    123 
     124       
    124125        if (b.parts.exp > 0) {
    125126                frac2 |= FLOAT32_HIDDEN_BIT_MASK;
     
    127128                ++exp;
    128129        }
    129 
     130       
    130131        frac1 <<= 1; /* one bit space for rounding */
    131 
     132       
    132133        frac1 = frac1 * frac2;
    133 
     134       
    134135        /* round and return */
    135         while ((exp < FLOAT32_MAX_EXPONENT) && (frac1 >= (1 << (FLOAT32_FRACTION_SIZE + 2)))) {
     136        while ((exp < FLOAT32_MAX_EXPONENT) &&
     137            (frac1 >= (1 << (FLOAT32_FRACTION_SIZE + 2)))) {
    136138                /* 23 bits of fraction + one more for hidden bit (all shifted 1 bit left) */
    137139                ++exp;
    138140                frac1 >>= 1;
    139141        }
    140 
     142       
    141143        /* rounding */
    142144        /* ++frac1; FIXME: not works - without it is ok */
    143145        frac1 >>= 1; /* shift off rounding space */
    144146       
    145         if ((exp < FLOAT32_MAX_EXPONENT) && (frac1 >= (1 << (FLOAT32_FRACTION_SIZE + 1)))) {
     147        if ((exp < FLOAT32_MAX_EXPONENT) &&
     148            (frac1 >= (1 << (FLOAT32_FRACTION_SIZE + 1)))) {
    146149                ++exp;
    147150                frac1 >>= 1;
    148151        }
    149 
    150         if (exp >= FLOAT32_MAX_EXPONENT) {     
     152       
     153        if (exp >= FLOAT32_MAX_EXPONENT) {
    151154                /* TODO: fix overflow */
    152155                /* return infinity*/
     
    157160       
    158161        exp -= FLOAT32_FRACTION_SIZE;
    159 
    160         if (exp <= FLOAT32_FRACTION_SIZE) { 
     162       
     163        if (exp <= FLOAT32_FRACTION_SIZE) {
    161164                /* denormalized number */
    162165                frac1 >>= 1; /* denormalize */
     
    175178        result.parts.fraction = frac1 & ((1 << FLOAT32_FRACTION_SIZE) - 1);
    176179       
    177         return result; 
     180        return result;
    178181}
    179182
    180 /**
    181  * Multiply two double-precision floats.
     183/** Multiply two double-precision floats.
    182184 *
    183185 * @param a First input operand.
    184186 * @param b Second input operand.
     187 *
    185188 * @return Result of multiplication.
    186  */
    187 float64 mulFloat64(float64 a, float64 b)
     189 *
     190 */
     191float64 mul_float64(float64 a, float64 b)
    188192{
    189193        float64 result;
    190194        uint64_t frac1, frac2;
    191195        int32_t exp;
    192 
     196       
    193197        result.parts.sign = a.parts.sign ^ b.parts.sign;
    194198       
    195         if (isFloat64NaN(a) || isFloat64NaN(b)) {
     199        if (is_float64_nan(a) || is_float64_nan(b)) {
    196200                /* TODO: fix SigNaNs */
    197                 if (isFloat64SigNaN(a)) {
     201                if (is_float64_signan(a)) {
    198202                        result.parts.fraction = a.parts.fraction;
    199203                        result.parts.exp = a.parts.exp;
    200204                        return result;
    201205                }
    202                 if (isFloat64SigNaN(b)) { /* TODO: fix SigNaN */
     206                if (is_float64_signan(b)) { /* TODO: fix SigNaN */
    203207                        result.parts.fraction = b.parts.fraction;
    204208                        result.parts.exp = b.parts.exp;
     
    206210                }
    207211                /* set NaN as result */
    208                 result.binary = FLOAT64_NAN;
    209                 return result;
    210         }
    211                
    212         if (isFloat64Infinity(a)) {
    213                 if (isFloat64Zero(b)) {
    214                         /* FIXME: zero * infinity */
    215                         result.binary = FLOAT64_NAN;
     212                result.bin = FLOAT64_NAN;
     213                return result;
     214        }
     215       
     216        if (is_float64_infinity(a)) {
     217                if (is_float64_zero(b)) {
     218                        /* FIXME: zero * infinity */
     219                        result.bin = FLOAT64_NAN;
    216220                        return result;
    217221                }
     
    220224                return result;
    221225        }
    222 
    223         if (isFloat64Infinity(b)) {
    224                 if (isFloat64Zero(a)) {
    225                         /* FIXME: zero * infinity */
    226                         result.binary = FLOAT64_NAN;
     226       
     227        if (is_float64_infinity(b)) {
     228                if (is_float64_zero(a)) {
     229                        /* FIXME: zero * infinity */
     230                        result.bin = FLOAT64_NAN;
    227231                        return result;
    228232                }
     
    231235                return result;
    232236        }
    233 
     237       
    234238        /* exp is signed so we can easy detect underflow */
    235239        exp = a.parts.exp + b.parts.exp - FLOAT64_BIAS;
    236240       
    237241        frac1 = a.parts.fraction;
    238 
     242       
    239243        if (a.parts.exp > 0) {
    240244                frac1 |= FLOAT64_HIDDEN_BIT_MASK;
     
    244248       
    245249        frac2 = b.parts.fraction;
    246 
     250       
    247251        if (b.parts.exp > 0) {
    248252                frac2 |= FLOAT64_HIDDEN_BIT_MASK;
     
    250254                ++exp;
    251255        }
    252 
     256       
    253257        frac1 <<= (64 - FLOAT64_FRACTION_SIZE - 1);
    254258        frac2 <<= (64 - FLOAT64_FRACTION_SIZE - 2);
    255 
     259       
    256260        mul64(frac1, frac2, &frac1, &frac2);
    257 
     261       
    258262        frac1 |= (frac2 != 0);
    259263        if (frac1 & (0x1ll << 62)) {
     
    261265                exp--;
    262266        }
    263 
    264         result = finishFloat64(exp, frac1, result.parts.sign);
     267       
     268        result = finish_float64(exp, frac1, result.parts.sign);
    265269        return result;
    266270}
    267271
    268 /**
    269  * Multiply two quadruple-precision floats.
     272/** Multiply two quadruple-precision floats.
    270273 *
    271274 * @param a First input operand.
    272275 * @param b Second input operand.
     276 *
    273277 * @return Result of multiplication.
    274  */
    275 float128 mulFloat128(float128 a, float128 b)
     278 *
     279 */
     280float128 mul_float128(float128 a, float128 b)
    276281{
    277282        float128 result;
    278283        uint64_t frac1_hi, frac1_lo, frac2_hi, frac2_lo, tmp_hi, tmp_lo;
    279284        int32_t exp;
    280 
     285       
    281286        result.parts.sign = a.parts.sign ^ b.parts.sign;
    282 
    283         if (isFloat128NaN(a) || isFloat128NaN(b)) {
     287       
     288        if (is_float128_nan(a) || is_float128_nan(b)) {
    284289                /* TODO: fix SigNaNs */
    285                 if (isFloat128SigNaN(a)) {
     290                if (is_float128_signan(a)) {
    286291                        result.parts.frac_hi = a.parts.frac_hi;
    287292                        result.parts.frac_lo = a.parts.frac_lo;
     
    289294                        return result;
    290295                }
    291                 if (isFloat128SigNaN(b)) { /* TODO: fix SigNaN */
     296                if (is_float128_signan(b)) { /* TODO: fix SigNaN */
    292297                        result.parts.frac_hi = b.parts.frac_hi;
    293298                        result.parts.frac_lo = b.parts.frac_lo;
     
    296301                }
    297302                /* set NaN as result */
    298                 result.binary.hi = FLOAT128_NAN_HI;
    299                 result.binary.lo = FLOAT128_NAN_LO;
    300                 return result;
    301         }
    302 
    303         if (isFloat128Infinity(a)) {
    304                 if (isFloat128Zero(b)) {
    305                         /* FIXME: zero * infinity */
    306                         result.binary.hi = FLOAT128_NAN_HI;
    307                         result.binary.lo = FLOAT128_NAN_LO;
     303                result.bin.hi = FLOAT128_NAN_HI;
     304                result.bin.lo = FLOAT128_NAN_LO;
     305                return result;
     306        }
     307       
     308        if (is_float128_infinity(a)) {
     309                if (is_float128_zero(b)) {
     310                        /* FIXME: zero * infinity */
     311                        result.bin.hi = FLOAT128_NAN_HI;
     312                        result.bin.lo = FLOAT128_NAN_LO;
    308313                        return result;
    309314                }
     
    313318                return result;
    314319        }
    315 
    316         if (isFloat128Infinity(b)) {
    317                 if (isFloat128Zero(a)) {
    318                         /* FIXME: zero * infinity */
    319                         result.binary.hi = FLOAT128_NAN_HI;
    320                         result.binary.lo = FLOAT128_NAN_LO;
     320       
     321        if (is_float128_infinity(b)) {
     322                if (is_float128_zero(a)) {
     323                        /* FIXME: zero * infinity */
     324                        result.bin.hi = FLOAT128_NAN_HI;
     325                        result.bin.lo = FLOAT128_NAN_LO;
    321326                        return result;
    322327                }
     
    326331                return result;
    327332        }
    328 
     333       
    329334        /* exp is signed so we can easy detect underflow */
    330335        exp = a.parts.exp + b.parts.exp - FLOAT128_BIAS - 1;
    331 
     336       
    332337        frac1_hi = a.parts.frac_hi;
    333338        frac1_lo = a.parts.frac_lo;
    334 
     339       
    335340        if (a.parts.exp > 0) {
    336341                or128(frac1_hi, frac1_lo,
    337                 FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO,
    338                 &frac1_hi, &frac1_lo);
    339         } else {
    340                 ++exp;
    341         }
    342 
     342                    FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO,
     343                    &frac1_hi, &frac1_lo);
     344        } else {
     345                ++exp;
     346        }
     347       
    343348        frac2_hi = b.parts.frac_hi;
    344349        frac2_lo = b.parts.frac_lo;
    345 
     350       
    346351        if (b.parts.exp > 0) {
    347352                or128(frac2_hi, frac2_lo,
     
    351356                ++exp;
    352357        }
    353 
     358       
    354359        lshift128(frac2_hi, frac2_lo,
    355360            128 - FLOAT128_FRACTION_SIZE, &frac2_hi, &frac2_lo);
    356 
     361       
    357362        tmp_hi = frac1_hi;
    358363        tmp_lo = frac1_lo;
     
    361366        add128(frac1_hi, frac1_lo, tmp_hi, tmp_lo, &frac1_hi, &frac1_lo);
    362367        frac2_hi |= (frac2_lo != 0x0ll);
    363 
     368       
    364369        if ((FLOAT128_HIDDEN_BIT_MASK_HI << 1) <= frac1_hi) {
    365370                frac2_hi >>= 1;
     
    370375                ++exp;
    371376        }
    372 
    373         result = finishFloat128(exp, frac1_hi, frac1_lo, result.parts.sign, frac2_hi);
     377       
     378        result = finish_float128(exp, frac1_hi, frac1_lo, result.parts.sign, frac2_hi);
    374379        return result;
    375380}
  • uspace/lib/softfloat/generic/softfloat.c

    r8bcd727 r88d5c1e  
    4848#include <other.h>
    4949
    50 #include <functions.h>
    51 
    5250/* Arithmetic functions */
    5351
    5452float __addsf3(float a, float b)
    5553{
    56         float32 fa, fb;
    57         fa.f = a;
    58         fb.f = b;
    59         if (fa.parts.sign != fb.parts.sign) {
    60                 if (fa.parts.sign) {
    61                         fa.parts.sign = 0;
    62                         return subFloat32(fb, fa).f;
    63                 };
    64                 fb.parts.sign = 0;
    65                 return subFloat32(fa, fb).f;
    66         }
    67         return addFloat32(fa, fb).f;
     54        float_t fa;
     55        float_t fb;
     56        float_t res;
     57       
     58        fa.val = a;
     59        fb.val = b;
     60       
     61        if (fa.data.parts.sign != fb.data.parts.sign) {
     62                if (fa.data.parts.sign) {
     63                        fa.data.parts.sign = 0;
     64                        res.data = sub_float(fb.data, fa.data);
     65                       
     66                        return res.val;
     67                }
     68               
     69                fb.data.parts.sign = 0;
     70                res.data = sub_float(fa.data, fb.data);
     71               
     72                return res.val;
     73        }
     74       
     75        res.data = add_float(fa.data, fb.data);
     76        return res.val;
    6877}
    6978
    7079double __adddf3(double a, double b)
    7180{
    72         float64 da, db;
    73         da.d = a;
    74         db.d = b;
    75         if (da.parts.sign != db.parts.sign) {
    76                 if (da.parts.sign) {
    77                         da.parts.sign = 0;
    78                         return subFloat64(db, da).d;
    79                 };
    80                 db.parts.sign = 0;
    81                 return subFloat64(da, db).d;
    82         }
    83         return addFloat64(da, db).d;
     81        double_t da;
     82        double_t db;
     83        double_t res;
     84       
     85        da.val = a;
     86        db.val = b;
     87       
     88        if (da.data.parts.sign != db.data.parts.sign) {
     89                if (da.data.parts.sign) {
     90                        da.data.parts.sign = 0;
     91                        res.data = sub_double(db.data, da.data);
     92                       
     93                        return res.val;
     94                }
     95               
     96                db.data.parts.sign = 0;
     97                res.data = sub_double(da.data, db.data);
     98               
     99                return res.val;
     100        }
     101       
     102        res.data = add_double(da.data, db.data);
     103        return res.val;
    84104}
    85105
    86106long double __addtf3(long double a, long double b)
    87107{
    88         float128 ta, tb;
    89         ta.ld = a;
    90         tb.ld = b;
    91         if (ta.parts.sign != tb.parts.sign) {
    92                 if (ta.parts.sign) {
    93                         ta.parts.sign = 0;
    94                         return subFloat128(tb, ta).ld;
    95                 };
    96                 tb.parts.sign = 0;
    97                 return subFloat128(ta, tb).ld;
    98         }
    99         return addFloat128(ta, tb).ld;
     108        long_double_t ta;
     109        long_double_t tb;
     110        long_double_t res;
     111       
     112        ta.val = a;
     113        tb.val = b;
     114       
     115        if (ta.data.parts.sign != tb.data.parts.sign) {
     116                if (ta.data.parts.sign) {
     117                        ta.data.parts.sign = 0;
     118                        res.data = sub_long_double(tb.data, ta.data);
     119                       
     120                        return res.val;
     121                }
     122               
     123                tb.data.parts.sign = 0;
     124                res.data = sub_long_double(ta.data, tb.data);
     125               
     126                return res.val;
     127        }
     128       
     129        res.data = add_long_double(ta.data, tb.data);
     130        return res.val;
    100131}
    101132
    102133float __subsf3(float a, float b)
    103134{
    104         float32 fa, fb;
    105         fa.f = a;
    106         fb.f = b;
    107         if (fa.parts.sign != fb.parts.sign) {
    108                 fb.parts.sign = !fb.parts.sign;
    109                 return addFloat32(fa, fb).f;
    110         }
    111         return subFloat32(fa, fb).f;
     135        float_t fa;
     136        float_t fb;
     137        float_t res;
     138       
     139        fa.val = a;
     140        fb.val = b;
     141       
     142        if (fa.data.parts.sign != fb.data.parts.sign) {
     143                fb.data.parts.sign = !fb.data.parts.sign;
     144                res.data = add_float(fa.data, fb.data);
     145               
     146                return res.val;
     147        }
     148       
     149        res.data = sub_float(fa.data, fb.data);
     150        return res.val;
    112151}
    113152
    114153double __subdf3(double a, double b)
    115154{
    116         float64 da, db;
    117         da.d = a;
    118         db.d = b;
    119         if (da.parts.sign != db.parts.sign) {
    120                 db.parts.sign = !db.parts.sign;
    121                 return addFloat64(da, db).d;
    122         }
    123         return subFloat64(da, db).d;
     155        double_t da;
     156        double_t db;
     157        double_t res;
     158       
     159        da.val = a;
     160        db.val = b;
     161       
     162        if (da.data.parts.sign != db.data.parts.sign) {
     163                db.data.parts.sign = !db.data.parts.sign;
     164                res.data = add_double(da.data, db.data);
     165               
     166                return res.val;
     167        }
     168       
     169        res.data = sub_double(da.data, db.data);
     170        return res.val;
    124171}
    125172
    126173long double __subtf3(long double a, long double b)
    127174{
    128         float128 ta, tb;
    129         ta.ld = a;
    130         tb.ld = b;
    131         if (ta.parts.sign != tb.parts.sign) {
    132                 tb.parts.sign = !tb.parts.sign;
    133                 return addFloat128(ta, tb).ld;
    134         }
    135         return subFloat128(ta, tb).ld;
    136 }
    137 
    138 float __mulsf3(float a, float b)
    139 {
    140         float32 fa, fb;
    141         fa.f = a;
    142         fb.f = b;
    143         return  mulFloat32(fa, fb).f;
    144 }
    145 
    146 double __muldf3(double a, double b)
    147 {
    148         float64 da, db;
    149         da.d = a;
    150         db.d = b;
    151         return  mulFloat64(da, db).d;
     175        long_double_t ta;
     176        long_double_t tb;
     177        long_double_t res;
     178       
     179        ta.val = a;
     180        tb.val = b;
     181       
     182        if (ta.data.parts.sign != tb.data.parts.sign) {
     183                tb.data.parts.sign = !tb.data.parts.sign;
     184                res.data = add_long_double(ta.data, tb.data);
     185               
     186                return res.val;
     187        }
     188       
     189        res.data = sub_long_double(ta.data, tb.data);
     190        return res.val;
     191}
     192
     193float __mulsf3(float a, float b)
     194{
     195        float_t fa;
     196        float_t fb;
     197        float_t res;
     198       
     199        fa.val = a;
     200        fb.val = b;
     201       
     202        res.data = mul_float(fa.data, fb.data);
     203        return res.val;
     204}
     205
     206double __muldf3(double a, double b)
     207{
     208        double_t da;
     209        double_t db;
     210        double_t res;
     211       
     212        da.val = a;
     213        db.val = b;
     214       
     215        res.data = mul_double(da.data, db.data);
     216        return res.val;
    152217}
    153218
    154219long double __multf3(long double a, long double b)
    155220{
    156         float128 ta, tb;
    157         ta.ld = a;
    158         tb.ld = b;
    159         return  mulFloat128(ta, tb).ld;
    160 }
    161 
    162 float __divsf3(float a, float b)
    163 {
    164         float32 fa, fb;
    165         fa.f = a;
    166         fb.f = b;
    167         return  divFloat32(fa, fb).f;
    168 }
    169 
    170 double __divdf3(double a, double b)
    171 {
    172         float64 da, db;
    173         da.d = a;
    174         db.d = b;
    175         return  divFloat64(da, db).d;
     221        long_double_t ta;
     222        long_double_t tb;
     223        long_double_t res;
     224       
     225        ta.val = a;
     226        tb.val = b;
     227       
     228        res.data = mul_long_double(ta.data, tb.data);
     229        return res.val;
     230}
     231
     232float __divsf3(float a, float b)
     233{
     234        float_t fa;
     235        float_t fb;
     236        float_t res;
     237       
     238        fa.val = a;
     239        fb.val = b;
     240       
     241        res.data = div_float(fa.data, fb.data);
     242        return res.val;
     243}
     244
     245double __divdf3(double a, double b)
     246{
     247        double_t da;
     248        double_t db;
     249        double_t res;
     250       
     251        da.val = a;
     252        db.val = b;
     253       
     254        res.data = div_double(da.data, db.data);
     255        return res.val;
    176256}
    177257
    178258long double __divtf3(long double a, long double b)
    179259{
    180         float128 ta, tb;
    181         ta.ld = a;
    182         tb.ld = b;
    183         return  divFloat128(ta, tb).ld;
     260        long_double_t ta;
     261        long_double_t tb;
     262        long_double_t res;
     263       
     264        ta.val = a;
     265        tb.val = b;
     266       
     267        res.data = div_long_double(ta.data, tb.data);
     268        return res.val;
    184269}
    185270
    186271float __negsf2(float a)
    187272{
    188         float32 fa;
    189         fa.f = a;
    190         fa.parts.sign = !fa.parts.sign;
    191         return fa.f;
     273        float_t fa;
     274       
     275        fa.val = a;
     276        fa.data.parts.sign = !fa.data.parts.sign;
     277       
     278        return fa.val;
    192279}
    193280
    194281double __negdf2(double a)
    195282{
    196         float64 da;
    197         da.d = a;
    198         da.parts.sign = !da.parts.sign;
    199         return da.d;
     283        double_t da;
     284       
     285        da.val = a;
     286        da.data.parts.sign = !da.data.parts.sign;
     287       
     288        return da.val;
    200289}
    201290
    202291long double __negtf2(long double a)
    203292{
    204         float128 ta;
    205         ta.ld = a;
    206         ta.parts.sign = !ta.parts.sign;
    207         return ta.ld;
     293        long_double_t ta;
     294       
     295        ta.val = a;
     296        ta.data.parts.sign = !ta.data.parts.sign;
     297       
     298        return ta.val;
    208299}
    209300
    210301/* Conversion functions */
    211302
    212 double __extendsfdf2(float a)
    213 {
    214         float32 fa;
    215         fa.f = a;
    216         return convertFloat32ToFloat64(fa).d;
     303double __extendsfdf2(float a)
     304{
     305        float_t fa;
     306        double_t res;
     307       
     308        fa.val = a;
     309        res.data = float_to_double(fa.data);
     310       
     311        return res.val;
    217312}
    218313
    219314long double __extendsftf2(float a)
    220315{
    221         float32 fa;
    222         fa.f = a;
    223         return convertFloat32ToFloat128(fa).ld;
     316        float_t fa;
     317        long_double_t res;
     318       
     319        fa.val = a;
     320        res.data = float_to_long_double(fa.data);
     321       
     322        return res.val;
    224323}
    225324
    226325long double __extenddftf2(double a)
    227326{
    228         float64 da;
    229         da.d = a;
    230         return convertFloat64ToFloat128(da).ld;
    231 }
    232 
    233 float __truncdfsf2(double a)
    234 {
    235         float64 da;
    236         da.d = a;
    237         return convertFloat64ToFloat32(da).f;
     327        double_t da;
     328        long_double_t res;
     329       
     330        da.val = a;
     331        res.data = double_to_long_double(da.data);
     332       
     333        return res.val;
     334}
     335
     336float __truncdfsf2(double a)
     337{
     338        double_t da;
     339        float_t res;
     340       
     341        da.val = a;
     342        res.data = double_to_float(da.data);
     343       
     344        return res.val;
    238345}
    239346
    240347float __trunctfsf2(long double a)
    241348{
    242         float128 ta;
    243         ta.ld = a;
    244         return convertFloat128ToFloat32(ta).f;
     349        long_double_t ta;
     350        float_t res;
     351       
     352        ta.val = a;
     353        res.data = long_double_to_float(ta.data);
     354       
     355        return res.val;
    245356}
    246357
    247358double __trunctfdf2(long double a)
    248359{
    249         float128 ta;
    250         ta.ld = a;
    251         return convertFloat128ToFloat64(ta).d;
     360        long_double_t ta;
     361        double_t res;
     362       
     363        ta.val = a;
     364        res.data = long_double_to_double(ta.data);
     365       
     366        return res.val;
    252367}
    253368
    254369int __fixsfsi(float a)
    255370{
    256         float32 fa;
    257         fa.f = a;
    258        
    259         return float32_to_int(fa);
     371        float_t fa;
     372       
     373        fa.val = a;
     374        return float_to_int(fa.data);
    260375}
    261376
    262377int __fixdfsi(double a)
    263378{
    264         float64 da;
    265         da.d = a;
    266        
    267         return float64_to_int(da);
     379        double_t da;
     380       
     381        da.val = a;
     382        return double_to_int(da.data);
    268383}
    269384
    270385int __fixtfsi(long double a)
    271386{
    272         float128 ta;
    273         ta.ld = a;
    274 
    275         return float128_to_int(ta);
     387        long_double_t ta;
     388       
     389        ta.val = a;
     390        return long_double_to_int(ta.data);
    276391}
    277392 
    278393long __fixsfdi(float a)
    279394{
    280         float32 fa;
    281         fa.f = a;
    282        
    283         return float32_to_long(fa);
     395        float_t fa;
     396       
     397        fa.val = a;
     398        return float_to_long(fa.data);
    284399}
    285400
    286401long __fixdfdi(double a)
    287402{
    288         float64 da;
    289         da.d = a;
    290        
    291         return float64_to_long(da);
     403        double_t da;
     404       
     405        da.val = a;
     406        return double_to_long(da.data);
    292407}
    293408
    294409long __fixtfdi(long double a)
    295410{
    296         float128 ta;
    297         ta.ld = a;
    298 
    299         return float128_to_long(ta);
     411        long_double_t ta;
     412       
     413        ta.val = a;
     414        return long_double_to_long(ta.data);
    300415}
    301416 
    302417long long __fixsfti(float a)
    303418{
    304         float32 fa;
    305         fa.f = a;
    306        
    307         return float32_to_longlong(fa);
     419        float_t fa;
     420       
     421        fa.val = a;
     422        return float_to_llong(fa.data);
    308423}
    309424
    310425long long __fixdfti(double a)
    311426{
    312         float64 da;
    313         da.d = a;
    314        
    315         return float64_to_longlong(da);
     427        double_t da;
     428       
     429        da.val = a;
     430        return double_to_llong(da.data);
    316431}
    317432
    318433long long __fixtfti(long double a)
    319434{
    320         float128 ta;
    321         ta.ld = a;
    322 
    323         return float128_to_longlong(ta);
     435        long_double_t ta;
     436       
     437        ta.val = a;
     438        return long_double_to_llong(ta.data);
    324439}
    325440
    326441unsigned int __fixunssfsi(float a)
    327442{
    328         float32 fa;
    329         fa.f = a;
    330        
    331         return float32_to_uint(fa);
     443        float_t fa;
     444       
     445        fa.val = a;
     446        return float_to_uint(fa.data);
    332447}
    333448
    334449unsigned int __fixunsdfsi(double a)
    335450{
    336         float64 da;
    337         da.d = a;
    338        
    339         return float64_to_uint(da);
     451        double_t da;
     452       
     453        da.val = a;
     454        return double_to_uint(da.data);
    340455}
    341456
    342457unsigned int __fixunstfsi(long double a)
    343458{
    344         float128 ta;
    345         ta.ld = a;
    346 
    347         return float128_to_uint(ta);
     459        long_double_t ta;
     460       
     461        ta.val = a;
     462        return long_double_to_uint(ta.data);
    348463}
    349464 
    350465unsigned long __fixunssfdi(float a)
    351466{
    352         float32 fa;
    353         fa.f = a;
    354        
    355         return float32_to_ulong(fa);
     467        float_t fa;
     468       
     469        fa.val = a;
     470        return float_to_ulong(fa.data);
    356471}
    357472
    358473unsigned long __fixunsdfdi(double a)
    359474{
    360         float64 da;
    361         da.d = a;
    362        
    363         return float64_to_ulong(da);
     475        double_t da;
     476       
     477        da.val = a;
     478        return double_to_ulong(da.data);
    364479}
    365480
    366481unsigned long __fixunstfdi(long double a)
    367482{
    368         float128 ta;
    369         ta.ld = a;
    370 
    371         return float128_to_ulong(ta);
     483        long_double_t ta;
     484       
     485        ta.val = a;
     486        return long_double_to_ulong(ta.data);
    372487}
    373488 
    374489unsigned long long __fixunssfti(float a)
    375490{
    376         float32 fa;
    377         fa.f = a;
    378        
    379         return float32_to_ulonglong(fa);
     491        float_t fa;
     492       
     493        fa.val = a;
     494        return float_to_ullong(fa.data);
    380495}
    381496
    382497unsigned long long __fixunsdfti(double a)
    383498{
    384         float64 da;
    385         da.d = a;
    386        
    387         return float64_to_ulonglong(da);
     499        double_t da;
     500       
     501        da.val = a;
     502        return double_to_ullong(da.data);
    388503}
    389504
    390505unsigned long long __fixunstfti(long double a)
    391506{
    392         float128 ta;
    393         ta.ld = a;
    394 
    395         return float128_to_ulonglong(ta);
     507        long_double_t ta;
     508       
     509        ta.val = a;
     510        return long_double_to_ullong(ta.data);
    396511}
    397512 
    398513float __floatsisf(int i)
    399514{
    400         float32 fa;
    401        
    402         fa = int_to_float32(i);
    403         return fa.f;
     515        float_t res;
     516       
     517        res.data = int_to_float(i);
     518        return res.val;
    404519}
    405520
    406521double __floatsidf(int i)
    407522{
    408         float64 da;
    409        
    410         da = int_to_float64(i);
    411         return da.d;
     523        double_t res;
     524       
     525        res.data = int_to_double(i);
     526        return res.val;
    412527}
    413528
    414529long double __floatsitf(int i)
    415530{
    416         float128 ta;
    417 
    418         ta = int_to_float128(i);
    419         return ta.ld;
     531        long_double_t res;
     532       
     533        res.data = int_to_long_double(i);
     534        return res.val;
    420535}
    421536 
    422537float __floatdisf(long i)
    423538{
    424         float32 fa;
    425        
    426         fa = long_to_float32(i);
    427         return fa.f;
     539        float_t res;
     540       
     541        res.data = long_to_float(i);
     542        return res.val;
    428543}
    429544
    430545double __floatdidf(long i)
    431546{
    432         float64 da;
    433        
    434         da = long_to_float64(i);
    435         return da.d;
     547        double_t res;
     548       
     549        res.data = long_to_double(i);
     550        return res.val;
    436551}
    437552
    438553long double __floatditf(long i)
    439554{
    440         float128 ta;
    441 
    442         ta = long_to_float128(i);
    443         return ta.ld;
    444 }
    445  
     555        long_double_t res;
     556       
     557        res.data = long_to_long_double(i);
     558        return res.val;
     559}
     560
    446561float __floattisf(long long i)
    447562{
    448         float32 fa;
    449        
    450         fa = longlong_to_float32(i);
    451         return fa.f;
     563        float_t res;
     564       
     565        res.data = llong_to_float(i);
     566        return res.val;
    452567}
    453568
    454569double __floattidf(long long i)
    455570{
    456         float64 da;
    457        
    458         da = longlong_to_float64(i);
    459         return da.d;
     571        double_t res;
     572       
     573        res.data = llong_to_double(i);
     574        return res.val;
    460575}
    461576
    462577long double __floattitf(long long i)
    463578{
    464         float128 ta;
    465 
    466         ta = longlong_to_float128(i);
    467         return ta.ld;
     579        long_double_t res;
     580       
     581        res.data = llong_to_long_double(i);
     582        return res.val;
    468583}
    469584
    470585float __floatunsisf(unsigned int i)
    471586{
    472         float32 fa;
    473        
    474         fa = uint_to_float32(i);
    475         return fa.f;
     587        float_t res;
     588       
     589        res.data = uint_to_float(i);
     590        return res.val;
    476591}
    477592
    478593double __floatunsidf(unsigned int i)
    479594{
    480         float64 da;
    481        
    482         da = uint_to_float64(i);
    483         return da.d;
     595        double_t res;
     596       
     597        res.data = uint_to_double(i);
     598        return res.val;
    484599}
    485600
    486601long double __floatunsitf(unsigned int i)
    487602{
    488         float128 ta;
    489 
    490         ta = uint_to_float128(i);
    491         return ta.ld;
     603        long_double_t res;
     604       
     605        res.data = uint_to_long_double(i);
     606        return res.val;
    492607}
    493608 
    494609float __floatundisf(unsigned long i)
    495610{
    496         float32 fa;
    497        
    498         fa = ulong_to_float32(i);
    499         return fa.f;
     611        float_t res;
     612       
     613        res.data = ulong_to_float(i);
     614        return res.val;
    500615}
    501616
    502617double __floatundidf(unsigned long i)
    503618{
    504         float64 da;
    505        
    506         da = ulong_to_float64(i);
    507         return da.d;
     619        double_t res;
     620       
     621        res.data = ulong_to_double(i);
     622        return res.val;
    508623}
    509624
    510625long double __floatunditf(unsigned long i)
    511626{
    512         float128 ta;
    513 
    514         ta = ulong_to_float128(i);
    515         return ta.ld;
     627        long_double_t res;
     628       
     629        res.data = ulong_to_long_double(i);
     630        return res.val;
    516631}
    517632 
    518633float __floatuntisf(unsigned long long i)
    519634{
    520         float32 fa;
    521        
    522         fa = ulonglong_to_float32(i);
    523         return fa.f;
     635        float_t res;
     636       
     637        res.data = ullong_to_float(i);
     638        return res.val;
    524639}
    525640
    526641double __floatuntidf(unsigned long long i)
    527642{
    528         float64 da;
    529        
    530         da = ulonglong_to_float64(i);
    531         return da.d;
     643        double_t res;
     644       
     645        res.data = ullong_to_double(i);
     646        return res.val;
    532647}
    533648
    534649long double __floatuntitf(unsigned long long i)
    535650{
    536         float128 ta;
    537 
    538         ta = ulonglong_to_float128(i);
    539         return ta.ld;
     651        long_double_t res;
     652       
     653        res.data = ullong_to_long_double(i);
     654        return res.val;
    540655}
    541656
     
    544659int __cmpsf2(float a, float b)
    545660{
    546         float32 fa, fb;
    547         fa.f = a;
    548         fb.f = b;
    549 
    550         if ((isFloat32NaN(fa)) || (isFloat32NaN(fb))) {
    551                 return 1; /* no special constant for unordered - maybe signaled? */
    552         }
    553        
    554         if (isFloat32eq(fa, fb)) {
    555                 return 0;
    556         }
    557        
    558         if (isFloat32lt(fa, fb)) {
    559                 return -1;
    560         }
    561 
     661        float_t fa;
     662        float_t fb;
     663       
     664        fa.val = a;
     665        fb.val = b;
     666       
     667        if ((is_float_nan(fa.data)) || (is_float_nan(fb.data))) {
     668                /* no special constant for unordered - maybe signaled? */
     669                return 1;
     670        }
     671       
     672        if (is_float_eq(fa.data, fb.data))
     673                return 0;
     674       
     675        if (is_float_lt(fa.data, fb.data))
     676                return -1;
     677       
    562678        return 1;
    563679}
     
    565681int __cmpdf2(double a, double b)
    566682{
    567         float64 da, db;
    568         da.d = a;
    569         db.d = b;
    570 
    571         if ((isFloat64NaN(da)) || (isFloat64NaN(db))) {
    572                 return 1; /* no special constant for unordered - maybe signaled? */
    573         }
    574 
    575         if (isFloat64eq(da, db)) {
    576                 return 0;
    577         }
    578 
    579         if (isFloat64lt(da, db)) {
    580                 return -1;
    581         }
    582 
     683        double_t da;
     684        double_t db;
     685       
     686        da.val = a;
     687        db.val = b;
     688       
     689        if ((is_double_nan(da.data)) || (is_double_nan(db.data))) {
     690                /* no special constant for unordered - maybe signaled? */
     691                return 1;
     692        }
     693       
     694        if (is_double_eq(da.data, db.data))
     695                return 0;
     696       
     697        if (is_double_lt(da.data, db.data))
     698                return -1;
     699       
    583700        return 1;
    584701}
     
    586703int __cmptf2(long double a, long double b)
    587704{
    588         float128 ta, tb;
    589         ta.ld = a;
    590         tb.ld = b;
    591 
    592         if ((isFloat128NaN(ta)) || (isFloat128NaN(tb))) {
    593                 return 1; /* no special constant for unordered - maybe signaled? */
    594         }
    595 
    596         if (isFloat128eq(ta, tb)) {
    597                 return 0;
    598         }
    599 
    600         if (isFloat128lt(ta, tb)) {
    601                 return -1;
    602         }
    603 
     705        long_double_t ta;
     706        long_double_t tb;
     707       
     708        ta.val = a;
     709        tb.val = b;
     710       
     711        if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data))) {
     712                /* no special constant for unordered - maybe signaled? */
     713                return 1;
     714        }
     715       
     716        if (is_long_double_eq(ta.data, tb.data))
     717                return 0;
     718       
     719        if (is_long_double_lt(ta.data, tb.data))
     720                return -1;
     721       
    604722        return 1;
    605723}
    606724
    607 int __unordsf2(float a, float b)
    608 {
    609         float32 fa, fb;
    610         fa.f = a;
    611         fb.f = b;
    612         return ((isFloat32NaN(fa)) || (isFloat32NaN(fb)));
     725int __unordsf2(float a, float b)
     726{
     727        float_t fa;
     728        float_t fb;
     729       
     730        fa.val = a;
     731        fb.val = b;
     732       
     733        return ((is_float_nan(fa.data)) || (is_float_nan(fb.data)));
    613734}
    614735
    615736int __unorddf2(double a, double b)
    616737{
    617         float64 da, db;
    618         da.d = a;
    619         db.d = b;
    620         return ((isFloat64NaN(da)) || (isFloat64NaN(db)));
     738        double_t da;
     739        double_t db;
     740       
     741        da.val = a;
     742        db.val = b;
     743       
     744        return ((is_double_nan(da.data)) || (is_double_nan(db.data)));
    621745}
    622746
    623747int __unordtf2(long double a, long double b)
    624748{
    625         float128 ta, tb;
    626         ta.ld = a;
    627         tb.ld = b;
    628         return ((isFloat128NaN(ta)) || (isFloat128NaN(tb)));
    629 }
    630 
    631 int __eqsf2(float a, float b)
    632 {
    633         float32 fa, fb;
    634         fa.f = a;
    635         fb.f = b;
    636         if ((isFloat32NaN(fa)) || (isFloat32NaN(fb))) {
    637                 /* TODO: sigNaNs */
    638                 return 1;
    639         }
    640         return isFloat32eq(fa, fb) - 1;
     749        long_double_t ta;
     750        long_double_t tb;
     751       
     752        ta.val = a;
     753        tb.val = b;
     754       
     755        return ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data)));
     756}
     757
     758int __eqsf2(float a, float b)
     759{
     760        float_t fa;
     761        float_t fb;
     762       
     763        fa.val = a;
     764        fb.val = b;
     765       
     766        if ((is_float_nan(fa.data)) || (is_float_nan(fb.data))) {
     767                // TODO: sigNaNs
     768                return 1;
     769        }
     770       
     771        return is_float_eq(fa.data, fb.data) - 1;
    641772}
    642773
    643774int __eqdf2(double a, double b)
    644775{
    645         float64 da, db;
    646         da.d = a;
    647         db.d = b;
    648         if ((isFloat64NaN(da)) || (isFloat64NaN(db))) {
    649                 /* TODO: sigNaNs */
    650                 return 1;
    651         }
    652         return isFloat64eq(da, db) - 1;
     776        double_t da;
     777        double_t db;
     778       
     779        da.val = a;
     780        db.val = b;
     781       
     782        if ((is_double_nan(da.data)) || (is_double_nan(db.data))) {
     783                // TODO: sigNaNs
     784                return 1;
     785        }
     786       
     787        return is_double_eq(da.data, db.data) - 1;
    653788}
    654789
    655790int __eqtf2(long double a, long double b)
    656791{
    657         float128 ta, tb;
    658         ta.ld = a;
    659         tb.ld = b;
    660         if ((isFloat128NaN(ta)) || (isFloat128NaN(tb))) {
    661                 /* TODO: sigNaNs */
    662                 return 1;
    663         }
    664         return isFloat128eq(ta, tb) - 1;
    665 }
    666 
    667 int __nesf2(float a, float b)
     792        long_double_t ta;
     793        long_double_t tb;
     794       
     795        ta.val = a;
     796        tb.val = b;
     797       
     798        if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data))) {
     799                // TODO: sigNaNs
     800                return 1;
     801        }
     802       
     803        return is_long_double_eq(ta.data, tb.data) - 1;
     804}
     805
     806int __nesf2(float a, float b)
    668807{
    669808        /* strange behavior, but it was in gcc documentation */
     
    685824int __gesf2(float a, float b)
    686825{
    687         float32 fa, fb;
    688         fa.f = a;
    689         fb.f = b;
    690 
    691         if ((isFloat32NaN(fa)) || (isFloat32NaN(fb))) {
    692                 /* TODO: sigNaNs */
    693                 return -1;
    694         }
    695        
    696         if (isFloat32eq(fa, fb)) {
    697                 return 0;
    698         }
    699        
    700         if (isFloat32gt(fa, fb)) {
    701                 return 1;
    702         }
     826        float_t fa;
     827        float_t fb;
     828       
     829        fa.val = a;
     830        fb.val = b;
     831       
     832        if ((is_float_nan(fa.data)) || (is_float_nan(fb.data))) {
     833                // TODO: sigNaNs
     834                return -1;
     835        }
     836       
     837        if (is_float_eq(fa.data, fb.data))
     838                return 0;
     839       
     840        if (is_float_gt(fa.data, fb.data))
     841                return 1;
    703842       
    704843        return -1;
     
    707846int __gedf2(double a, double b)
    708847{
    709         float64 da, db;
    710         da.d = a;
    711         db.d = b;
    712 
    713         if ((isFloat64NaN(da)) || (isFloat64NaN(db))) {
    714                 /* TODO: sigNaNs */
    715                 return -1;
    716         }
    717 
    718         if (isFloat64eq(da, db)) {
    719                 return 0;
    720         }
    721 
    722         if (isFloat64gt(da, db)) {
    723                 return 1;
    724         }
    725 
     848        double_t da;
     849        double_t db;
     850       
     851        da.val = a;
     852        db.val = b;
     853       
     854        if ((is_double_nan(da.data)) || (is_double_nan(db.data))) {
     855                // TODO: sigNaNs
     856                return -1;
     857        }
     858       
     859        if (is_double_eq(da.data, db.data))
     860                return 0;
     861       
     862        if (is_double_gt(da.data, db.data))
     863                return 1;
     864       
    726865        return -1;
    727866}
     
    729868int __getf2(long double a, long double b)
    730869{
    731         float128 ta, tb;
    732         ta.ld = a;
    733         tb.ld = b;
    734 
    735         if ((isFloat128NaN(ta)) || (isFloat128NaN(tb))) {
    736                 /* TODO: sigNaNs */
    737                 return -1;
    738         }
    739 
    740         if (isFloat128eq(ta, tb)) {
    741                 return 0;
    742         }
    743 
    744         if (isFloat128gt(ta, tb)) {
    745                 return 1;
    746         }
    747 
     870        long_double_t ta;
     871        long_double_t tb;
     872       
     873        ta.val = a;
     874        tb.val = b;
     875       
     876        if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data))) {
     877                // TODO: sigNaNs
     878                return -1;
     879        }
     880       
     881        if (is_long_double_eq(ta.data, tb.data))
     882                return 0;
     883       
     884        if (is_long_double_gt(ta.data, tb.data))
     885                return 1;
     886       
    748887        return -1;
    749888}
     
    751890int __ltsf2(float a, float b)
    752891{
    753         float32 fa, fb;
    754         fa.f = a;
    755         fb.f = b;
    756 
    757         if ((isFloat32NaN(fa)) || (isFloat32NaN(fb))) {
    758                 /* TODO: sigNaNs */
    759                 return 1;
    760         }
    761 
    762         if (isFloat32lt(fa, fb)) {
    763                 return -1;
    764         }
    765 
     892        float_t fa;
     893        float_t fb;
     894       
     895        fa.val = a;
     896        fb.val = b;
     897       
     898        if ((is_float_nan(fa.data)) || (is_float_nan(fb.data))) {
     899                // TODO: sigNaNs
     900                return 1;
     901        }
     902       
     903        if (is_float_lt(fa.data, fb.data))
     904                return -1;
     905       
    766906        return 0;
    767907}
     
    769909int __ltdf2(double a, double b)
    770910{
    771         float64 da, db;
    772         da.d = a;
    773         db.d = b;
    774 
    775         if ((isFloat64NaN(da)) || (isFloat64NaN(db))) {
    776                 /* TODO: sigNaNs */
    777                 return 1;
    778         }
    779 
    780         if (isFloat64lt(da, db)) {
    781                 return -1;
    782         }
    783 
     911        double_t da;
     912        double_t db;
     913       
     914        da.val = a;
     915        db.val = b;
     916       
     917        if ((is_double_nan(da.data)) || (is_double_nan(db.data))) {
     918                // TODO: sigNaNs
     919                return 1;
     920        }
     921       
     922        if (is_double_lt(da.data, db.data))
     923                return -1;
     924       
    784925        return 0;
    785926}
     
    787928int __lttf2(long double a, long double b)
    788929{
    789         float128 ta, tb;
    790         ta.ld = a;
    791         tb.ld = b;
    792 
    793         if ((isFloat128NaN(ta)) || (isFloat128NaN(tb))) {
    794                 /* TODO: sigNaNs */
    795                 return 1;
    796         }
    797 
    798         if (isFloat128lt(ta, tb)) {
    799                 return -1;
    800         }
    801 
     930        long_double_t ta;
     931        long_double_t tb;
     932       
     933        ta.val = a;
     934        tb.val = b;
     935       
     936        if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data))) {
     937                // TODO: sigNaNs
     938                return 1;
     939        }
     940       
     941        if (is_long_double_lt(ta.data, tb.data))
     942                return -1;
     943       
    802944        return 0;
    803945}
     
    805947int __lesf2(float a, float b)
    806948{
    807         float32 fa, fb;
    808         fa.f = a;
    809         fb.f = b;
    810 
    811         if ((isFloat32NaN(fa)) || (isFloat32NaN(fb))) {
    812                 /* TODO: sigNaNs */
    813                 return 1;
    814         }
    815        
    816         if (isFloat32eq(fa, fb)) {
    817                 return 0;
    818         }
    819        
    820         if (isFloat32lt(fa, fb)) {
    821                 return -1;
    822         }
     949        float_t fa;
     950        float_t fb;
     951       
     952        fa.val = a;
     953        fb.val = b;
     954       
     955        if ((is_float_nan(fa.data)) || (is_float_nan(fb.data))) {
     956                // TODO: sigNaNs
     957                return 1;
     958        }
     959       
     960        if (is_float_eq(fa.data, fb.data))
     961                return 0;
     962       
     963        if (is_float_lt(fa.data, fb.data))
     964                return -1;
    823965       
    824966        return 1;
     
    827969int __ledf2(double a, double b)
    828970{
    829         float64 da, db;
    830         da.d = a;
    831         db.d = b;
    832 
    833         if ((isFloat64NaN(da)) || (isFloat64NaN(db))) {
    834                 /* TODO: sigNaNs */
    835                 return 1;
    836         }
    837 
    838         if (isFloat64eq(da, db)) {
    839                 return 0;
    840         }
    841 
    842         if (isFloat64lt(da, db)) {
    843                 return -1;
    844         }
    845 
     971        double_t da;
     972        double_t db;
     973       
     974        da.val = a;
     975        db.val = b;
     976       
     977        if ((is_double_nan(da.data)) || (is_double_nan(db.data))) {
     978                // TODO: sigNaNs
     979                return 1;
     980        }
     981       
     982        if (is_double_eq(da.data, db.data))
     983                return 0;
     984       
     985        if (is_double_lt(da.data, db.data))
     986                return -1;
     987       
    846988        return 1;
    847989}
     
    849991int __letf2(long double a, long double b)
    850992{
    851         float128 ta, tb;
    852         ta.ld = a;
    853         tb.ld = b;
    854 
    855         if ((isFloat128NaN(ta)) || (isFloat128NaN(tb))) {
    856                 /* TODO: sigNaNs */
    857                 return 1;
    858         }
    859 
    860         if (isFloat128eq(ta, tb)) {
    861                 return 0;
    862         }
    863 
    864         if (isFloat128lt(ta, tb)) {
    865                 return -1;
    866         }
    867 
     993        long_double_t ta;
     994        long_double_t tb;
     995       
     996        ta.val = a;
     997        tb.val = b;
     998       
     999        if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data))) {
     1000                // TODO: sigNaNs
     1001                return 1;
     1002        }
     1003       
     1004        if (is_long_double_eq(ta.data, tb.data))
     1005                return 0;
     1006       
     1007        if (is_long_double_lt(ta.data, tb.data))
     1008                return -1;
     1009       
    8681010        return 1;
    8691011}
     
    8711013int __gtsf2(float a, float b)
    8721014{
    873         float32 fa, fb;
    874         fa.f = a;
    875         fb.f = b;
    876 
    877         if ((isFloat32NaN(fa)) || (isFloat32NaN(fb))) {
    878                 /* TODO: sigNaNs */
    879                 return -1;
    880         }
    881 
    882         if (isFloat32gt(fa, fb)) {
    883                 return 1;
    884         }
    885 
     1015        float_t fa;
     1016        float_t fb;
     1017       
     1018        fa.val = a;
     1019        fb.val = b;
     1020       
     1021        if ((is_float_nan(fa.data)) || (is_float_nan(fb.data))) {
     1022                // TODO: sigNaNs
     1023                return -1;
     1024        }
     1025       
     1026        if (is_float_gt(fa.data, fb.data))
     1027                return 1;
     1028       
    8861029        return 0;
    8871030}
     
    8891032int __gtdf2(double a, double b)
    8901033{
    891         float64 da, db;
    892         da.d = a;
    893         db.d = b;
    894 
    895         if ((isFloat64NaN(da)) || (isFloat64NaN(db))) {
    896                 /* TODO: sigNaNs */
    897                 return -1;
    898         }
    899 
    900         if (isFloat64gt(da, db)) {
    901                 return 1;
    902         }
    903 
     1034        double_t da;
     1035        double_t db;
     1036       
     1037        da.val = a;
     1038        db.val = b;
     1039       
     1040        if ((is_double_nan(da.data)) || (is_double_nan(db.data))) {
     1041                // TODO: sigNaNs
     1042                return -1;
     1043        }
     1044       
     1045        if (is_double_gt(da.data, db.data))
     1046                return 1;
     1047       
    9041048        return 0;
    9051049}
     
    9071051int __gttf2(long double a, long double b)
    9081052{
    909         float128 ta, tb;
    910         ta.ld = a;
    911         tb.ld = b;
    912 
    913         if ((isFloat128NaN(ta)) || (isFloat128NaN(tb))) {
    914                 /* TODO: sigNaNs */
    915                 return -1;
    916         }
    917 
    918         if (isFloat128gt(ta, tb)) {
    919                 return 1;
    920         }
    921 
     1053        long_double_t ta;
     1054        long_double_t tb;
     1055       
     1056        ta.val = a;
     1057        tb.val = b;
     1058       
     1059        if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data))) {
     1060                // TODO: sigNaNs
     1061                return -1;
     1062        }
     1063       
     1064        if (is_long_double_gt(ta.data, tb.data))
     1065                return 1;
     1066       
    9221067        return 0;
    9231068}
    9241069
    925 
    926 
    927 #ifdef SPARC_SOFTFLOAT
    928 
    9291070/* SPARC quadruple-precision wrappers */
    9301071
     
    10161157int _Qp_cmp(long double *a, long double *b)
    10171158{
    1018         float128 ta, tb;
    1019         ta.ld = *a;
    1020         tb.ld = *b;
    1021 
    1022         if ((isFloat128NaN(ta)) || (isFloat128NaN(tb))) {
     1159        long_double_t ta;
     1160        long_double_t tb;
     1161       
     1162        ta.val = *a;
     1163        tb.val = *b;
     1164       
     1165        if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data)))
    10231166                return 3;
    1024         }
    1025 
    1026         if (isFloat128eq(ta, tb)) {
    1027                 return 0;
    1028         }
    1029 
    1030         if (isFloat128lt(ta, tb)) {
    1031                 return 1;
    1032         }
    1033 
     1167       
     1168        if (is_long_double_eq(ta.data, tb.data))
     1169                return 0;
     1170       
     1171        if (is_long_double_lt(ta.data, tb.data))
     1172                return 1;
     1173       
    10341174        return 2;
    10351175}
     
    10431183int _Qp_feq(long double *a, long double *b)
    10441184{
    1045         float128 ta, tb;
    1046         ta.ld = *a;
    1047         tb.ld = *b;
    1048 
    1049         if ((isFloat128NaN(ta)) || (isFloat128NaN(tb))) {
    1050                 return 0;
    1051         }
    1052 
    1053         return isFloat128eq(ta, tb);
     1185        long_double_t ta;
     1186        long_double_t tb;
     1187       
     1188        ta.val = *a;
     1189        tb.val = *b;
     1190       
     1191        if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data)))
     1192                return 0;
     1193       
     1194        return is_long_double_eq(ta.data, tb.data);
    10541195}
    10551196
    10561197int _Qp_fge(long double *a, long double *b)
    10571198{
    1058         float128 ta, tb;
    1059         ta.ld = *a;
    1060         tb.ld = *b;
    1061 
    1062         if ((isFloat128NaN(ta)) || (isFloat128NaN(tb))) {
    1063                 return 0;
    1064         }
    1065 
    1066         return isFloat128eq(ta, tb) || isFloat128gt(ta, tb);
     1199        long_double_t ta;
     1200        long_double_t tb;
     1201       
     1202        ta.val = *a;
     1203        tb.val = *b;
     1204       
     1205        if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data)))
     1206                return 0;
     1207       
     1208        return is_long_double_eq(ta.data, tb.data) ||
     1209            is_long_double_gt(ta.data, tb.data);
    10671210}
    10681211
    10691212int _Qp_fgt(long double *a, long double *b)
    10701213{
    1071         float128 ta, tb;
    1072         ta.ld = *a;
    1073         tb.ld = *b;
    1074 
    1075         if ((isFloat128NaN(ta)) || (isFloat128NaN(tb))) {
    1076                 return 0;
    1077         }
    1078 
    1079         return isFloat128gt(ta, tb);
     1214        long_double_t ta;
     1215        long_double_t tb;
     1216       
     1217        ta.val = *a;
     1218        tb.val = *b;
     1219       
     1220        if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data)))
     1221                return 0;
     1222       
     1223        return is_long_double_gt(ta.data, tb.data);
    10801224}
    10811225
    10821226int _Qp_fle(long double*a, long double *b)
    10831227{
    1084         float128 ta, tb;
    1085         ta.ld = *a;
    1086         tb.ld = *b;
    1087 
    1088         if ((isFloat128NaN(ta)) || (isFloat128NaN(tb))) {
    1089                 return 0;
    1090         }
    1091 
    1092         return isFloat128eq(ta, tb) || isFloat128lt(ta, tb);
     1228        long_double_t ta;
     1229        long_double_t tb;
     1230       
     1231        ta.val = *a;
     1232        tb.val = *b;
     1233       
     1234        if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data)))
     1235                return 0;
     1236       
     1237        return is_long_double_eq(ta.data, tb.data) ||
     1238            is_long_double_lt(ta.data, tb.data);
    10931239}
    10941240
    10951241int _Qp_flt(long double *a, long double *b)
    10961242{
    1097         float128 ta, tb;
    1098         ta.ld = *a;
    1099         tb.ld = *b;
    1100 
    1101         if ((isFloat128NaN(ta)) || (isFloat128NaN(tb))) {
    1102                 return 0;
    1103         }
    1104 
    1105         return isFloat128lt(ta, tb);
     1243        long_double_t ta;
     1244        long_double_t tb;
     1245       
     1246        ta.val = *a;
     1247        tb.val = *b;
     1248       
     1249        if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data)))
     1250                return 0;
     1251       
     1252        return is_long_double_lt(ta.data, tb.data);
    11061253}
    11071254
    11081255int _Qp_fne(long double *a, long double *b)
    11091256{
    1110         float128 ta, tb;
    1111         ta.ld = *a;
    1112         tb.ld = *b;
    1113 
    1114         if ((isFloat128NaN(ta)) || (isFloat128NaN(tb))) {
    1115                 return 1;
    1116         }
    1117 
    1118         return !isFloat128eq(ta, tb);
    1119 }
    1120 
    1121 #endif
     1257        long_double_t ta;
     1258        long_double_t tb;
     1259       
     1260        ta.val = *a;
     1261        tb.val = *b;
     1262       
     1263        if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data)))
     1264                return 0;
     1265       
     1266        return !is_long_double_eq(ta.data, tb.data);
     1267}
    11221268
    11231269/** @}
  • uspace/lib/softfloat/generic/sub.c

    r8bcd727 r88d5c1e  
    3939#include <common.h>
    4040
    41 /**
    42  * Subtract two single-precision floats with the same signs.
     41/** Subtract two single-precision floats with the same sign.
    4342 *
    4443 * @param a First input operand.
    4544 * @param b Second input operand.
     45 *
    4646 * @return Result of substraction.
    47  */
    48 float32 subFloat32(float32 a, float32 b)
     47 *
     48 */
     49float32 sub_float32(float32 a, float32 b)
    4950{
    5051        int expdiff;
    5152        uint32_t exp1, exp2, frac1, frac2;
    5253        float32 result;
    53 
    54         result.f = 0;
     54       
     55        result.bin = 0;
    5556       
    5657        expdiff = a.parts.exp - b.parts.exp;
    57         if ((expdiff < 0 ) || ((expdiff == 0) && (a.parts.fraction < b.parts.fraction))) {
    58                 if (isFloat32NaN(b)) {
    59                         /* TODO: fix SigNaN */
    60                         if (isFloat32SigNaN(b)) {
    61                         }
    62                         return b;
    63                 }
    64                
    65                 if (b.parts.exp == FLOAT32_MAX_EXPONENT) {
    66                         b.parts.sign = !b.parts.sign; /* num -(+-inf) = -+inf */
    67                         return b;
    68                 }
    69                
    70                 result.parts.sign = !a.parts.sign;
     58        if ((expdiff < 0 ) || ((expdiff == 0) &&
     59            (a.parts.fraction < b.parts.fraction))) {
     60                if (is_float32_nan(b)) {
     61                        if (is_float32_signan(b)) {
     62                                // TODO: fix SigNaN
     63                        }
     64                       
     65                        return b;
     66                }
     67               
     68                if (b.parts.exp == FLOAT32_MAX_EXPONENT) {
     69                        /* num -(+-inf) = -+inf */
     70                        b.parts.sign = !b.parts.sign;
     71                        return b;
     72                }
     73               
     74                result.parts.sign = !a.parts.sign;
    7175               
    7276                frac1 = b.parts.fraction;
     
    7680                expdiff *= -1;
    7781        } else {
    78                 if (isFloat32NaN(a)) {
    79                         /* TODO: fix SigNaN */
    80                         if (isFloat32SigNaN(a) || isFloat32SigNaN(b)) {
    81                         }
    82                         return a;
    83                 }
    84                
    85                 if (a.parts.exp == FLOAT32_MAX_EXPONENT) {
     82                if (is_float32_nan(a)) {
     83                        if ((is_float32_signan(a)) || (is_float32_signan(b))) {
     84                                // TODO: fix SigNaN
     85                        }
     86                       
     87                        return a;
     88                }
     89               
     90                if (a.parts.exp == FLOAT32_MAX_EXPONENT) {
    8691                        if (b.parts.exp == FLOAT32_MAX_EXPONENT) {
    8792                                /* inf - inf => nan */
    88                                 /* TODO: fix exception */
    89                                 result.binary = FLOAT32_NAN;
     93                                // TODO: fix exception
     94                                result.bin = FLOAT32_NAN;
    9095                                return result;
    9196                        }
     97                       
    9298                        return a;
    9399                }
     
    98104                exp1 = a.parts.exp;
    99105                frac2 = b.parts.fraction;
    100                 exp2 = b.parts.exp;     
     106                exp2 = b.parts.exp;
    101107        }
    102108       
     
    105111                result.parts.fraction = frac1 - frac2;
    106112                if (result.parts.fraction > frac1) {
    107                         /* TODO: underflow exception */
     113                        // TODO: underflow exception
    108114                        return result;
    109115                }
     116               
    110117                result.parts.exp = 0;
    111118                return result;
    112119        }
    113 
     120       
    114121        /* add hidden bit */
    115         frac1 |= FLOAT32_HIDDEN_BIT_MASK; 
     122        frac1 |= FLOAT32_HIDDEN_BIT_MASK;
    116123       
    117124        if (exp2 == 0) {
    118125                /* denormalized */
    119                 --expdiff;     
     126                --expdiff;
    120127        } else {
    121128                /* normalized */
     
    127134        frac2 <<= 6;
    128135       
    129         if (expdiff > FLOAT32_FRACTION_SIZE + 1) {
     136        if (expdiff > FLOAT32_FRACTION_SIZE + 1)
    130137                goto done;
    131         }
    132138       
    133139        frac1 = frac1 - (frac2 >> expdiff);
    134 
     140       
    135141done:
    136142        /* TODO: find first nonzero digit and shift result and detect possibly underflow */
     
    143149        /* rounding - if first bit after fraction is set then round up */
    144150        frac1 += 0x20;
    145 
     151       
    146152        if (frac1 & (FLOAT32_HIDDEN_BIT_MASK << 7)) {
    147153                ++exp1;
     
    150156       
    151157        /* Clear hidden bit and shift */
    152         result.parts.fraction = ((frac1 >> 6) & (~FLOAT32_HIDDEN_BIT_MASK)); 
     158        result.parts.fraction = ((frac1 >> 6) & (~FLOAT32_HIDDEN_BIT_MASK));
    153159        result.parts.exp = exp1;
    154160       
     
    156162}
    157163
    158 /**
    159  * Subtract two double-precision floats with the same signs.
     164/** Subtract two double-precision floats with the same sign.
    160165 *
    161166 * @param a First input operand.
    162167 * @param b Second input operand.
     168 *
    163169 * @return Result of substraction.
    164  */
    165 float64 subFloat64(float64 a, float64 b)
     170 *
     171 */
     172float64 sub_float64(float64 a, float64 b)
    166173{
    167174        int expdiff;
     
    169176        uint64_t frac1, frac2;
    170177        float64 result;
    171 
    172         result.d = 0;
     178       
     179        result.bin = 0;
    173180       
    174181        expdiff = a.parts.exp - b.parts.exp;
    175         if ((expdiff < 0 ) || ((expdiff == 0) && (a.parts.fraction < b.parts.fraction))) {
    176                 if (isFloat64NaN(b)) {
    177                         /* TODO: fix SigNaN */
    178                         if (isFloat64SigNaN(b)) {
    179                         }
    180                         return b;
    181                 }
    182                
    183                 if (b.parts.exp == FLOAT64_MAX_EXPONENT) {
    184                         b.parts.sign = !b.parts.sign; /* num -(+-inf) = -+inf */
    185                         return b;
    186                 }
    187                
    188                 result.parts.sign = !a.parts.sign;
     182        if ((expdiff < 0 ) ||
     183            ((expdiff == 0) && (a.parts.fraction < b.parts.fraction))) {
     184                if (is_float64_nan(b)) {
     185                        if (is_float64_signan(b)) {
     186                                // TODO: fix SigNaN
     187                        }
     188                       
     189                        return b;
     190                }
     191               
     192                if (b.parts.exp == FLOAT64_MAX_EXPONENT) {
     193                        /* num -(+-inf) = -+inf */
     194                        b.parts.sign = !b.parts.sign;
     195                        return b;
     196                }
     197               
     198                result.parts.sign = !a.parts.sign;
    189199               
    190200                frac1 = b.parts.fraction;
     
    194204                expdiff *= -1;
    195205        } else {
    196                 if (isFloat64NaN(a)) {
    197                         /* TODO: fix SigNaN */
    198                         if (isFloat64SigNaN(a) || isFloat64SigNaN(b)) {
    199                         }
    200                         return a;
    201                 }
    202                
    203                 if (a.parts.exp == FLOAT64_MAX_EXPONENT) {
     206                if (is_float64_nan(a)) {
     207                        if (is_float64_signan(a) || is_float64_signan(b)) {
     208                                // TODO: fix SigNaN
     209                        }
     210                       
     211                        return a;
     212                }
     213               
     214                if (a.parts.exp == FLOAT64_MAX_EXPONENT) {
    204215                        if (b.parts.exp == FLOAT64_MAX_EXPONENT) {
    205216                                /* inf - inf => nan */
    206                                 /* TODO: fix exception */
    207                                 result.binary = FLOAT64_NAN;
     217                                // TODO: fix exception
     218                                result.bin = FLOAT64_NAN;
    208219                                return result;
    209220                        }
     221                       
    210222                        return a;
    211223                }
     
    216228                exp1 = a.parts.exp;
    217229                frac2 = b.parts.fraction;
    218                 exp2 = b.parts.exp;     
     230                exp2 = b.parts.exp;
    219231        }
    220232       
     
    223235                result.parts.fraction = frac1 - frac2;
    224236                if (result.parts.fraction > frac1) {
    225                         /* TODO: underflow exception */
     237                        // TODO: underflow exception
    226238                        return result;
    227239                }
     240               
    228241                result.parts.exp = 0;
    229242                return result;
    230243        }
    231 
     244       
    232245        /* add hidden bit */
    233         frac1 |= FLOAT64_HIDDEN_BIT_MASK; 
     246        frac1 |= FLOAT64_HIDDEN_BIT_MASK;
    234247       
    235248        if (exp2 == 0) {
    236249                /* denormalized */
    237                 --expdiff;     
     250                --expdiff;
    238251        } else {
    239252                /* normalized */
     
    245258        frac2 <<= 6;
    246259       
    247         if (expdiff > FLOAT64_FRACTION_SIZE + 1) {
     260        if (expdiff > FLOAT64_FRACTION_SIZE + 1)
    248261                goto done;
    249         }
    250262       
    251263        frac1 = frac1 - (frac2 >> expdiff);
    252 
     264       
    253265done:
    254266        /* TODO: find first nonzero digit and shift result and detect possibly underflow */
     
    261273        /* rounding - if first bit after fraction is set then round up */
    262274        frac1 += 0x20;
    263 
     275       
    264276        if (frac1 & (FLOAT64_HIDDEN_BIT_MASK << 7)) {
    265277                ++exp1;
     
    268280       
    269281        /* Clear hidden bit and shift */
    270         result.parts.fraction = ((frac1 >> 6) & (~FLOAT64_HIDDEN_BIT_MASK)); 
     282        result.parts.fraction = ((frac1 >> 6) & (~FLOAT64_HIDDEN_BIT_MASK));
    271283        result.parts.exp = exp1;
    272284       
     
    274286}
    275287
    276 /**
    277  * Subtract two quadruple-precision floats with the same signs.
     288/** Subtract two quadruple-precision floats with the same sign.
    278289 *
    279290 * @param a First input operand.
    280291 * @param b Second input operand.
     292 *
    281293 * @return Result of substraction.
    282  */
    283 float128 subFloat128(float128 a, float128 b)
     294 *
     295 */
     296float128 sub_float128(float128 a, float128 b)
    284297{
    285298        int expdiff;
     
    287300        uint64_t frac1_hi, frac1_lo, frac2_hi, frac2_lo, tmp_hi, tmp_lo;
    288301        float128 result;
    289 
    290         result.binary.hi = 0;
    291         result.binary.lo = 0;
    292 
     302       
     303        result.bin.hi = 0;
     304        result.bin.lo = 0;
     305       
    293306        expdiff = a.parts.exp - b.parts.exp;
    294307        if ((expdiff < 0 ) || ((expdiff == 0) &&
    295308            lt128(a.parts.frac_hi, a.parts.frac_lo, b.parts.frac_hi, b.parts.frac_lo))) {
    296                 if (isFloat128NaN(b)) {
    297                         /* TODO: fix SigNaN */
    298                         if (isFloat128SigNaN(b)) {
    299                         }
    300                         return b;
    301                 }
    302 
     309                if (is_float128_nan(b)) {
     310                        if (is_float128_signan(b)) {
     311                                // TODO: fix SigNaN
     312                        }
     313                       
     314                        return b;
     315                }
     316               
    303317                if (b.parts.exp == FLOAT128_MAX_EXPONENT) {
    304                         b.parts.sign = !b.parts.sign; /* num -(+-inf) = -+inf */
    305                         return b;
    306                 }
    307 
     318                        /* num -(+-inf) = -+inf */
     319                        b.parts.sign = !b.parts.sign;
     320                        return b;
     321                }
     322               
    308323                result.parts.sign = !a.parts.sign;
    309 
     324               
    310325                frac1_hi = b.parts.frac_hi;
    311326                frac1_lo = b.parts.frac_lo;
     
    316331                expdiff *= -1;
    317332        } else {
    318                 if (isFloat128NaN(a)) {
    319                         /* TODO: fix SigNaN */
    320                         if (isFloat128SigNaN(a) || isFloat128SigNaN(b)) {
    321                         }
    322                         return a;
    323                 }
    324 
     333                if (is_float128_nan(a)) {
     334                        if (is_float128_signan(a) || is_float128_signan(b)) {
     335                                // TODO: fix SigNaN
     336                        }
     337                       
     338                        return a;
     339                }
     340               
    325341                if (a.parts.exp == FLOAT128_MAX_EXPONENT) {
    326342                        if (b.parts.exp == FLOAT128_MAX_EXPONENT) {
    327343                                /* inf - inf => nan */
    328                                 /* TODO: fix exception */
    329                                 result.binary.hi = FLOAT128_NAN_HI;
    330                                 result.binary.lo = FLOAT128_NAN_LO;
     344                                // TODO: fix exception
     345                                result.bin.hi = FLOAT128_NAN_HI;
     346                                result.bin.lo = FLOAT128_NAN_LO;
    331347                                return result;
    332348                        }
    333349                        return a;
    334350                }
    335 
     351               
    336352                result.parts.sign = a.parts.sign;
    337 
     353               
    338354                frac1_hi = a.parts.frac_hi;
    339355                frac1_lo = a.parts.frac_lo;
     
    343359                exp2 = b.parts.exp;
    344360        }
    345 
     361       
    346362        if (exp1 == 0) {
    347363                /* both are denormalized */
     
    350366                result.parts.frac_lo = tmp_lo;
    351367                if (lt128(frac1_hi, frac1_lo, result.parts.frac_hi, result.parts.frac_lo)) {
    352                         /* TODO: underflow exception */
     368                        // TODO: underflow exception
    353369                        return result;
    354370                }
     371               
    355372                result.parts.exp = 0;
    356373                return result;
    357374        }
    358 
     375       
    359376        /* add hidden bit */
    360377        or128(frac1_hi, frac1_lo,
    361378            FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO,
    362379            &frac1_hi, &frac1_lo);
    363 
     380       
    364381        if (exp2 == 0) {
    365382                /* denormalized */
     
    371388                    &frac2_hi, &frac2_lo);
    372389        }
    373 
     390       
    374391        /* create some space for rounding */
    375392        lshift128(frac1_hi, frac1_lo, 6, &frac1_hi, &frac1_lo);
    376393        lshift128(frac2_hi, frac2_lo, 6, &frac2_hi, &frac2_lo);
    377 
    378         if (expdiff > FLOAT128_FRACTION_SIZE + 1) {
     394       
     395        if (expdiff > FLOAT128_FRACTION_SIZE + 1)
    379396                goto done;
    380         }
    381 
     397       
    382398        rshift128(frac2_hi, frac2_lo, expdiff, &tmp_hi, &tmp_lo);
    383399        sub128(frac1_hi, frac1_lo, tmp_hi, tmp_lo, &frac1_hi, &frac1_lo);
    384 
     400       
    385401done:
    386402        /* TODO: find first nonzero digit and shift result and detect possibly underflow */
     
    392408                lshift128(frac1_hi, frac1_lo, 1, &frac1_hi, &frac1_lo);
    393409                /* TODO: fix underflow - frac1 == 0 does not necessary means underflow... */
    394 
     410               
    395411                lshift128(FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO, 6,
    396412                    &tmp_hi, &tmp_lo);
    397413                and128(frac1_hi, frac1_lo, tmp_hi, tmp_lo, &tmp_hi, &tmp_lo);
    398414        }
    399 
     415       
    400416        /* rounding - if first bit after fraction is set then round up */
    401417        add128(frac1_hi, frac1_lo, 0x0ll, 0x20ll, &frac1_hi, &frac1_lo);
    402 
     418       
    403419        lshift128(FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO, 7,
    404420           &tmp_hi, &tmp_lo);
     
    408424                rshift128(frac1_hi, frac1_lo, 1, &frac1_hi, &frac1_lo);
    409425        }
    410 
     426       
    411427        /* Clear hidden bit and shift */
    412428        rshift128(frac1_hi, frac1_lo, 6, &frac1_hi, &frac1_lo);
     
    416432        result.parts.frac_hi = tmp_hi;
    417433        result.parts.frac_lo = tmp_lo;
    418 
     434       
    419435        result.parts.exp = exp1;
    420 
     436       
    421437        return result;
    422438}
  • uspace/lib/softfloat/include/add.h

    r8bcd727 r88d5c1e  
    3737#define __ADD_H__
    3838
    39 extern float32 addFloat32(float32, float32);
    40 extern float64 addFloat64(float64, float64);
    41 extern float128 addFloat128(float128, float128);
     39extern float32 add_float32(float32, float32);
     40extern float64 add_float64(float64, float64);
     41extern float96 add_float96(float96, float96);
     42extern float128 add_float128(float128, float128);
    4243
    4344#endif
  • uspace/lib/softfloat/include/common.h

    r8bcd727 r88d5c1e  
    3939#include <sftypes.h>
    4040
    41 extern float64 finishFloat64(int32_t, uint64_t, char);
    42 extern float128 finishFloat128(int32_t, uint64_t, uint64_t, char, uint64_t);
     41extern float64 finish_float64(int32_t, uint64_t, char);
     42extern float128 finish_float128(int32_t, uint64_t, uint64_t, char, uint64_t);
    4343
    44 extern int countZeroes8(uint8_t);
    45 extern int countZeroes32(uint32_t);
    46 extern int countZeroes64(uint64_t);
     44extern int count_zeroes8(uint8_t);
     45extern int count_zeroes32(uint32_t);
     46extern int count_zeroes64(uint64_t);
    4747
    48 extern void roundFloat32(int32_t *, uint32_t *);
    49 extern void roundFloat64(int32_t *, uint64_t *);
    50 extern void roundFloat128(int32_t *, uint64_t *, uint64_t *);
     48extern void round_float32(int32_t *, uint32_t *);
     49extern void round_float64(int32_t *, uint64_t *);
     50extern void round_float128(int32_t *, uint64_t *, uint64_t *);
    5151
    5252extern void lshift128(uint64_t, uint64_t, int, uint64_t *, uint64_t *);
  • uspace/lib/softfloat/include/comparison.h

    r8bcd727 r88d5c1e  
    3737#define __COMPARISON_H__
    3838
    39 extern int isFloat32NaN(float32);
    40 extern int isFloat32SigNaN(float32);
     39extern int is_float32_nan(float32);
     40extern int is_float32_signan(float32);
    4141
    42 extern int isFloat32Infinity(float32);
    43 extern int isFloat32Zero(float32);
     42extern int is_float32_infinity(float32);
     43extern int is_float32_zero(float32);
    4444
    45 extern int isFloat32eq(float32, float32);
    46 extern int isFloat32lt(float32, float32);
    47 extern int isFloat32gt(float32, float32);
     45extern int is_float32_eq(float32, float32);
     46extern int is_float32_lt(float32, float32);
     47extern int is_float32_gt(float32, float32);
    4848
    49 extern int isFloat64NaN(float64);
    50 extern int isFloat64SigNaN(float64);
     49extern int is_float64_nan(float64);
     50extern int is_float64_signan(float64);
    5151
    52 extern int isFloat64Infinity(float64);
    53 extern int isFloat64Zero(float64);
     52extern int is_float64_infinity(float64);
     53extern int is_float64_zero(float64);
    5454
    55 extern int isFloat64eq(float64, float64);
    56 extern int isFloat64lt(float64, float64);
    57 extern int isFloat64gt(float64, float64);
     55extern int is_float64_eq(float64, float64);
     56extern int is_float64_lt(float64, float64);
     57extern int is_float64_gt(float64, float64);
    5858
    59 extern int isFloat128NaN(float128);
    60 extern int isFloat128SigNaN(float128);
     59extern int is_float96_nan(float96);
     60extern int is_float96_signan(float96);
    6161
    62 extern int isFloat128Infinity(float128);
    63 extern int isFloat128Zero(float128);
     62extern int is_float96_infinity(float96);
     63extern int is_float96_zero(float96);
    6464
    65 extern int isFloat128eq(float128, float128);
    66 extern int isFloat128lt(float128, float128);
    67 extern int isFloat128gt(float128, float128);
     65extern int is_float96_eq(float96, float96);
     66extern int is_float96_lt(float96, float96);
     67extern int is_float96_gt(float96, float96);
     68
     69extern int is_float128_nan(float128);
     70extern int is_float128_signan(float128);
     71
     72extern int is_float128_infinity(float128);
     73extern int is_float128_zero(float128);
     74
     75extern int is_float128_eq(float128, float128);
     76extern int is_float128_lt(float128, float128);
     77extern int is_float128_gt(float128, float128);
    6878
    6979#endif
  • uspace/lib/softfloat/include/conversion.h

    r8bcd727 r88d5c1e  
    3737#define __CONVERSION_H__
    3838
    39 extern float64 convertFloat32ToFloat64(float32);
    40 extern float128 convertFloat32ToFloat128(float32);
    41 extern float128 convertFloat64ToFloat128(float64);
     39extern float64 float32_to_float64(float32);
     40extern float96 float32_to_float96(float32);
     41extern float128 float32_to_float128(float32);
     42extern float96 float64_to_float96(float64);
     43extern float128 float64_to_float128(float64);
     44extern float128 float96_to_float128(float96);
    4245
    43 
    44 extern float32 convertFloat64ToFloat32(float64);
    45 extern float32 convertFloat128ToFloat32(float128);
    46 extern float64 convertFloat128ToFloat64(float128);
    47 
     46extern float32 float64_to_float32(float64);
     47extern float32 float96_to_float32(float96);
     48extern float64 float96_to_float64(float96);
     49extern float32 float128_to_float32(float128);
     50extern float64 float128_to_float64(float128);
     51extern float96 float128_to_float96(float128);
    4852
    4953extern uint32_t float32_to_uint32(float32);
     
    5963extern int64_t float64_to_int64(float64);
    6064
     65extern uint32_t float96_to_uint32(float96);
     66extern int32_t float96_to_int32(float96);
     67
     68extern uint64_t float96_to_uint64(float96);
     69extern int64_t float96_to_int64(float96);
     70
    6171extern uint32_t float128_to_uint32(float128);
    6272extern int32_t float128_to_int32(float128);
     
    6474extern uint64_t float128_to_uint64(float128);
    6575extern int64_t float128_to_int64(float128);
    66 
    6776
    6877extern float32 uint32_to_float32(uint32_t);
     
    7887extern float64 int64_to_float64(int64_t);
    7988
     89extern float96 uint32_to_float96(uint32_t);
     90extern float96 int32_to_float96(int32_t);
     91
     92extern float96 uint64_to_float96(uint64_t);
     93extern float96 int64_to_float96(int64_t);
     94
    8095extern float128 uint32_to_float128(uint32_t);
    8196extern float128 int32_to_float128(int32_t);
  • uspace/lib/softfloat/include/div.h

    r8bcd727 r88d5c1e  
    3737#define __DIV_H__
    3838
    39 extern float32 divFloat32(float32, float32);
    40 extern float64 divFloat64(float64, float64);
    41 extern float128 divFloat128(float128, float128);
     39extern float32 div_float32(float32, float32);
     40extern float64 div_float64(float64, float64);
     41extern float96 div_float96(float96, float96);
     42extern float128 div_float128(float128, float128);
    4243
    4344#endif
  • uspace/lib/softfloat/include/mul.h

    r8bcd727 r88d5c1e  
    3737#define __MUL_H__
    3838
    39 extern float32 mulFloat32(float32, float32);
    40 extern float64 mulFloat64(float64, float64);
    41 extern float128 mulFloat128(float128, float128);
     39extern float32 mul_float32(float32, float32);
     40extern float64 mul_float64(float64, float64);
     41extern float96 mul_float96(float96, float96);
     42extern float128 mul_float128(float128, float128);
    4243
    4344#endif
  • uspace/lib/softfloat/include/sftypes.h

    r8bcd727 r88d5c1e  
    4040#include <stdint.h>
    4141
    42 typedef union {
    43         float f;
    44         uint32_t binary;
    45        
    46         struct {
     42/*
     43 * For recognizing NaNs or infinity use specialized comparison
     44 * functions, comparing with these constants is not sufficient.
     45 */
     46
     47#define FLOAT32_NAN     UINT32_C(0x7FC00001)
     48#define FLOAT32_SIGNAN  UINT32_C(0x7F800001)
     49#define FLOAT32_INF     UINT32_C(0x7F800000)
     50
     51#define FLOAT64_NAN     UINT64_C(0x7FF8000000000001)
     52#define FLOAT64_SIGNAN  UINT64_C(0x7FF0000000000001)
     53#define FLOAT64_INF     UINT64_C(0x7FF0000000000000)
     54
     55#define FLOAT96_NAN_HI     UINT64_C(0x7FFF80000000)
     56#define FLOAT96_NAN_LO     UINT32_C(0x00010000)
     57#define FLOAT96_SIGNAN_HI  UINT64_C(0x7FFF00000000)
     58#define FLOAT96_SIGNAN_LO  UINT32_C(0x00010000)
     59
     60#define FLOAT128_NAN_HI     UINT64_C(0x7FFF800000000000)
     61#define FLOAT128_NAN_LO     UINT64_C(0x0000000000000001)
     62#define FLOAT128_SIGNAN_HI  UINT64_C(0x7FFF000000000000)
     63#define FLOAT128_SIGNAN_LO  UINT64_C(0x0000000000000001)
     64#define FLOAT128_INF_HI     UINT64_C(0x7FFF000000000000)
     65#define FLOAT128_INF_LO     UINT64_C(0x0000000000000000)
     66
     67#define FLOAT32_FRACTION_SIZE   23
     68#define FLOAT64_FRACTION_SIZE   52
     69#define FLOAT96_FRACTION_SIZE   64
     70#define FLOAT128_FRACTION_SIZE  112
     71#define FLOAT128_FRAC_HI_SIZE   48
     72#define FLOAT128_FRAC_LO_SIZE   64
     73
     74#define FLOAT32_HIDDEN_BIT_MASK      UINT32_C(0x800000)
     75#define FLOAT64_HIDDEN_BIT_MASK      UINT64_C(0x10000000000000)
     76#define FLOAT128_HIDDEN_BIT_MASK_HI  UINT64_C(0x1000000000000)
     77#define FLOAT128_HIDDEN_BIT_MASK_LO  UINT64_C(0x0000000000000000)
     78
     79#define FLOAT32_MAX_EXPONENT   0xFF
     80#define FLOAT64_MAX_EXPONENT   0x7FF
     81#define FLOAT96_MAX_EXPONENT   0x7FFF
     82#define FLOAT128_MAX_EXPONENT  0x7FFF
     83
     84#define FLOAT32_BIAS   0x7F
     85#define FLOAT64_BIAS   0x3FF
     86#define FLOAT96_BIAS   0x3FFF
     87#define FLOAT128_BIAS  0x3FFF
     88
    4789#if defined(__BE__)
     90
     91typedef union {
     92        uint32_t bin;
     93       
     94        struct {
    4895                uint32_t sign : 1;
    4996                uint32_t exp : 8;
    5097                uint32_t fraction : 23;
    51 #elif defined(__LE__)
    52                 uint32_t fraction : 23;
    53                 uint32_t exp : 8;
    54                 uint32_t sign : 1;
    55 #else
    56         #error Unknown endianess
    57 #endif
    58         } parts __attribute__ ((packed));
     98        } parts __attribute__((packed));
    5999} float32;
    60100
    61101typedef union {
    62         double d;
    63         uint64_t binary;
    64        
    65         struct {
    66 #if defined(__BE__)
     102        uint64_t bin;
     103       
     104        struct {
    67105                uint64_t sign : 1;
    68106                uint64_t exp : 11;
    69107                uint64_t fraction : 52;
    70 #elif defined(__LE__)
    71                 uint64_t fraction : 52;
    72                 uint64_t exp : 11;
     108        } parts __attribute__((packed));
     109} float64;
     110
     111typedef union {
     112        struct {
     113                uint64_t hi;
     114                uint32_t lo;
     115        } bin __attribute__((packed));
     116       
     117        struct {
     118                uint64_t padding : 16;
    73119                uint64_t sign : 1;
    74 #else
    75         #error Unknown endianess
    76 #endif
    77         } parts __attribute__ ((packed));
    78 } float64;
    79 
    80 typedef union {
    81         long double ld;
    82         struct {
    83 #if defined(__BE__)
     120                uint64_t exp : 15;
     121                uint64_t fraction : 64;
     122        } parts __attribute__((packed));
     123} float96;
     124
     125typedef union {
     126        struct {
    84127                uint64_t hi;
    85128                uint64_t lo;
    86 #elif defined(__LE__)
    87                 uint64_t lo;
    88                 uint64_t hi;
    89 #else
    90         #error Unknown endianess
    91 #endif
    92         } binary;
    93 
    94         struct {
    95 #if defined(__BE__)
     129        } bin __attribute__((packed));
     130       
     131        struct {
    96132                uint64_t sign : 1;
    97133                uint64_t exp : 15;
    98134                uint64_t frac_hi : 48;
    99135                uint64_t frac_lo : 64;
     136        } parts __attribute__((packed));
     137} float128;
     138
    100139#elif defined(__LE__)
     140
     141typedef union {
     142        uint32_t bin;
     143       
     144        struct {
     145                uint32_t fraction : 23;
     146                uint32_t exp : 8;
     147                uint32_t sign : 1;
     148        } parts __attribute__((packed));
     149} float32;
     150
     151typedef union {
     152        uint64_t bin;
     153       
     154        struct {
     155                uint64_t fraction : 52;
     156                uint64_t exp : 11;
     157                uint64_t sign : 1;
     158        } parts __attribute__((packed));
     159} float64;
     160
     161typedef union {
     162        struct {
     163                uint32_t lo;
     164                uint64_t hi;
     165        } bin __attribute__((packed));
     166       
     167        struct {
     168                uint64_t fraction : 64;
     169                uint64_t exp : 15;
     170                uint64_t sign : 1;
     171                uint64_t padding : 16;
     172        } parts __attribute__((packed));
     173} float96;
     174
     175typedef union {
     176        struct {
     177                uint64_t lo;
     178                uint64_t hi;
     179        } bin __attribute__((packed));
     180       
     181        struct {
    101182                uint64_t frac_lo : 64;
    102183                uint64_t frac_hi : 48;
    103184                uint64_t exp : 15;
    104185                uint64_t sign : 1;
     186        } parts __attribute__((packed));
     187} float128;
     188
    105189#else
    106190        #error Unknown endianess
    107191#endif
    108         } parts __attribute__ ((packed));
    109 } float128;
    110 
    111 /*
    112  * For recognizing NaNs or infinity use specialized comparison functions,
    113  * comparing with these constants is not sufficient.
    114  */
    115 
    116 #define FLOAT32_NAN     0x7FC00001
    117 #define FLOAT32_SIGNAN  0x7F800001
    118 #define FLOAT32_INF     0x7F800000
    119 
    120 #define FLOAT64_NAN     0x7FF8000000000001ll