Changeset a35b458 in mainline for uspace/lib/softfloat


Ignore:
Timestamp:
2018-03-02T20:10:49Z (7 years ago)
Author:
Jiří Zárevúcky <zarevucky.jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
f1380b7
Parents:
3061bc1
git-author:
Jiří Zárevúcky <zarevucky.jiri@…> (2018-02-28 17:38:31)
git-committer:
Jiří Zárevúcky <zarevucky.jiri@…> (2018-03-02 20:10:49)
Message:

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

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

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

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

Location:
uspace/lib/softfloat
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • uspace/lib/softfloat/add.c

    r3061bc1 ra35b458  
    4949        int expdiff;
    5050        uint32_t exp1, exp2, frac1, frac2;
    51        
     51
    5252        expdiff = a.parts.exp - b.parts.exp;
    5353        if (expdiff < 0) {
     
    5959                        return b;
    6060                }
    61                
     61
    6262                if (b.parts.exp == FLOAT32_MAX_EXPONENT) {
    6363                        return b;
    6464                }
    65                
     65
    6666                frac1 = b.parts.fraction;
    6767                exp1 = b.parts.exp;
     
    7676                        return (is_float32_nan(a) ? a : b);
    7777                }
    78                
     78
    7979                if (a.parts.exp == FLOAT32_MAX_EXPONENT) {
    8080                        return a;
    8181                }
    82                
     82
    8383                frac1 = a.parts.fraction;
    8484                exp1 = a.parts.exp;
     
    8686                exp2 = b.parts.exp;
    8787        }
    88        
     88
    8989        if (exp1 == 0) {
    9090                /* both are denormalized */
     
    9797                return a;
    9898        }
    99        
     99
    100100        frac1 |= FLOAT32_HIDDEN_BIT_MASK; /* add hidden bit */
    101101
     
    107107                frac2 |= FLOAT32_HIDDEN_BIT_MASK;
    108108        }
    109        
     109
    110110        /* create some space for rounding */
    111111        frac1 <<= 6;
    112112        frac2 <<= 6;
    113        
     113
    114114        if (expdiff < (FLOAT32_FRACTION_SIZE + 2)) {
    115115                frac2 >>= expdiff;
     
    120120                return a;
    121121        }
    122        
     122
    123123        if (frac1 & (FLOAT32_HIDDEN_BIT_MASK << 7)) {
    124124                ++exp1;
    125125                frac1 >>= 1;
    126126        }
    127        
     127
    128128        /* rounding - if first bit after fraction is set then round up */
    129129        frac1 += (0x1 << 5);
    130        
     130
    131131        if (frac1 & (FLOAT32_HIDDEN_BIT_MASK << 7)) {
    132132                /* rounding overflow */
     
    134134                frac1 >>= 1;
    135135        }
    136        
     136
    137137        if ((exp1 == FLOAT32_MAX_EXPONENT) || (exp2 > exp1)) {
    138138                /* overflow - set infinity as result */
     
    141141                return a;
    142142        }
    143        
     143
    144144        a.parts.exp = exp1;
    145        
     145
    146146        /* Clear hidden bit and shift */
    147147        a.parts.fraction = ((frac1 >> 6) & (~FLOAT32_HIDDEN_BIT_MASK));
     
    160160        uint32_t exp1, exp2;
    161161        uint64_t frac1, frac2;
    162        
     162
    163163        expdiff = ((int) a.parts.exp) - b.parts.exp;
    164164        if (expdiff < 0) {
     
    170170                        return b;
    171171                }
    172                
     172
    173173                /* b is infinity and a not */
    174174                if (b.parts.exp == FLOAT64_MAX_EXPONENT) {
    175175                        return b;
    176176                }
    177                
     177
    178178                frac1 = b.parts.fraction;
    179179                exp1 = b.parts.exp;
     
    188188                        return a;
    189189                }
    190                
     190
    191191                /* a is infinity and b not */
    192192                if (a.parts.exp == FLOAT64_MAX_EXPONENT) {
    193193                        return a;
    194194                }
    195                
     195
    196196                frac1 = a.parts.fraction;
    197197                exp1 = a.parts.exp;
     
    199199                exp2 = b.parts.exp;
    200200        }
    201        
     201
    202202        if (exp1 == 0) {
    203203                /* both are denormalized */
     
    210210                return a;
    211211        }
    212        
     212
    213213        /* add hidden bit - frac1 is sure not denormalized */
    214214        frac1 |= FLOAT64_HIDDEN_BIT_MASK;
     
    222222                frac2 |= FLOAT64_HIDDEN_BIT_MASK;
    223223        }
    224        
     224
    225225        /* create some space for rounding */
    226226        frac1 <<= 6;
    227227        frac2 <<= 6;
    228        
     228
    229229        if (expdiff < (FLOAT64_FRACTION_SIZE + 2)) {
    230230                frac2 >>= expdiff;
     
    235235                return a;
    236236        }
    237        
     237
    238238        if (frac1 & (FLOAT64_HIDDEN_BIT_MASK << 7)) {
    239239                ++exp1;
    240240                frac1 >>= 1;
    241241        }
    242        
     242
    243243        /* rounding - if first bit after fraction is set then round up */
    244244        frac1 += (0x1 << 5);
    245        
     245
    246246        if (frac1 & (FLOAT64_HIDDEN_BIT_MASK << 7)) {
    247247                /* rounding overflow */
     
    249249                frac1 >>= 1;
    250250        }
    251        
     251
    252252        if ((exp1 == FLOAT64_MAX_EXPONENT) || (exp2 > exp1)) {
    253253                /* overflow - set infinity as result */
     
    256256                return a;
    257257        }
    258        
     258
    259259        a.parts.exp = exp1;
    260260        /* Clear hidden bit and shift */
     
    400400
    401401        a.parts.exp = exp1;
    402        
     402
    403403        /* Clear hidden bit and shift */
    404404        rshift128(frac1_hi, frac1_lo, 6, &frac1_hi, &frac1_lo);
     
    419419        float32_u ua;
    420420        ua.val = a;
    421        
     421
    422422        float32_u ub;
    423423        ub.val = b;
    424        
     424
    425425        float32_u res;
    426        
     426
    427427        if (ua.data.parts.sign != ub.data.parts.sign) {
    428428                if (ua.data.parts.sign) {
     
    435435        } else
    436436                res.data = add_float32(ua.data, ub.data);
    437        
     437
    438438        return res.val;
    439439}
     
    443443        float32_u ua;
    444444        ua.val = a;
    445        
     445
    446446        float32_u ub;
    447447        ub.val = b;
    448        
     448
    449449        float32_u res;
    450        
     450
    451451        if (ua.data.parts.sign != ub.data.parts.sign) {
    452452                if (ua.data.parts.sign) {
     
    459459        } else
    460460                res.data = add_float32(ua.data, ub.data);
    461        
     461
    462462        return res.val;
    463463}
     
    471471        float64_u ua;
    472472        ua.val = a;
    473        
     473
    474474        float64_u ub;
    475475        ub.val = b;
    476        
     476
    477477        float64_u res;
    478        
     478
    479479        if (ua.data.parts.sign != ub.data.parts.sign) {
    480480                if (ua.data.parts.sign) {
     
    487487        } else
    488488                res.data = add_float64(ua.data, ub.data);
    489        
     489
    490490        return res.val;
    491491}
     
    495495        float64_u ua;
    496496        ua.val = a;
    497        
     497
    498498        float64_u ub;
    499499        ub.val = b;
    500        
     500
    501501        float64_u res;
    502        
     502
    503503        if (ua.data.parts.sign != ub.data.parts.sign) {
    504504                if (ua.data.parts.sign) {
     
    511511        } else
    512512                res.data = add_float64(ua.data, ub.data);
    513        
     513
    514514        return res.val;
    515515}
     
    523523        float128_u ua;
    524524        ua.val = a;
    525        
     525
    526526        float128_u ub;
    527527        ub.val = b;
    528        
     528
    529529        float128_u res;
    530        
     530
    531531        if (ua.data.parts.sign != ub.data.parts.sign) {
    532532                if (ua.data.parts.sign) {
     
    539539        } else
    540540                res.data = add_float128(ua.data, ub.data);
    541        
     541
    542542        return res.val;
    543543}
  • uspace/lib/softfloat/common.c

    r3061bc1 ra35b458  
    7878                /* TODO: fix underflow */
    7979        }
    80        
     80
    8181        if ((cexp < 0) || (cexp == 0 &&
    8282            (!(cfrac & (FLOAT64_HIDDEN_BIT_MASK << (64 - FLOAT64_FRACTION_SIZE - 1)))))) {
     
    8787                        return result;
    8888                }
    89                
     89
    9090                while (cexp < 0) {
    9191                        cexp++;
    9292                        cfrac >>= 1;
    9393                }
    94        
     94
    9595                cfrac += (0x1 << (64 - FLOAT64_FRACTION_SIZE - 3));
    96                
     96
    9797                if (!(cfrac & (FLOAT64_HIDDEN_BIT_MASK << (64 - FLOAT64_FRACTION_SIZE - 1)))) {
    9898                        result.parts.fraction =
     
    103103                cfrac += (0x1 << (64 - FLOAT64_FRACTION_SIZE - 3));
    104104        }
    105        
     105
    106106        ++cexp;
    107107
     
    120120
    121121        result.parts.exp = (uint32_t) cexp;
    122        
     122
    123123        result.parts.fraction =
    124124            ((cfrac >> (64 - FLOAT64_FRACTION_SIZE - 2)) & (~FLOAT64_HIDDEN_BIT_MASK));
    125        
     125
    126126        return result;
    127127}
     
    289289        /* rounding - if first bit after fraction is set then round up */
    290290        (*fraction) += (0x1 << (32 - FLOAT32_FRACTION_SIZE - 3));
    291        
     291
    292292        if ((*fraction) &
    293293            (FLOAT32_HIDDEN_BIT_MASK << (32 - FLOAT32_FRACTION_SIZE - 1))) {
     
    296296                (*fraction) >>= 1;
    297297        }
    298        
     298
    299299        if (((*exp) >= FLOAT32_MAX_EXPONENT) || ((*exp) < 0)) {
    300300                /* overflow - set infinity as result */
     
    322322         */
    323323        (*fraction) += (0x1 << (64 - FLOAT64_FRACTION_SIZE - 3));
    324        
     324
    325325        /* See if there was a carry to bit 63. */
    326326        if ((*fraction) &
     
    330330                (*fraction) >>= 1;
    331331        }
    332        
     332
    333333        if (((*exp) >= FLOAT64_MAX_EXPONENT) || ((*exp) < 0)) {
    334334                /* overflow - set infinity as result */
     
    677677        mul64(b, result, &tmp_hi, &tmp_lo);
    678678        sub128(a_hi, a_lo, tmp_hi, tmp_lo, &rem_hi, &rem_lo);
    679        
     679
    680680        while ((int64_t) rem_hi < 0) {
    681681                result -= 0x1ll << 32;
  • uspace/lib/softfloat/comparison.c

    r3061bc1 ra35b458  
    190190        uint64_t tmp_hi;
    191191        uint64_t tmp_lo;
    192        
     192
    193193        and128(ld.bin.hi, ld.bin.lo,
    194194            0x7FFFFFFFFFFFFFFFll, 0xFFFFFFFFFFFFFFFFll, &tmp_hi, &tmp_lo);
    195        
     195
    196196        return eq128(tmp_hi, tmp_lo, 0x0ll, 0x0ll);
    197197}
     
    236236        uint64_t tmp_hi;
    237237        uint64_t tmp_lo;
    238        
     238
    239239        /* both are zeros (with any sign) */
    240240        or128(a.bin.hi, a.bin.lo,
     
    243243            0x7FFFFFFFFFFFFFFFll, 0xFFFFFFFFFFFFFFFFll, &tmp_hi, &tmp_lo);
    244244        int both_zero = eq128(tmp_hi, tmp_lo, 0x0ll, 0x0ll);
    245        
     245
    246246        /* a equals to b */
    247247        int are_equal = eq128(a.bin.hi, a.bin.lo, b.bin.hi, b.bin.lo);
    248        
     248
    249249        return are_equal || both_zero;
    250250}
     
    263263                return 0;
    264264        }
    265        
     265
    266266        if ((a.parts.sign) && (b.parts.sign)) {
    267267                /* if both are negative, smaller is that with greater binary value */
    268268                return (a.bin > b.bin);
    269269        }
    270        
     270
    271271        /*
    272272         * lets negate signs - now will be positive numbers always
     
    292292                return 0;
    293293        }
    294        
     294
    295295        if ((a.parts.sign) && (b.parts.sign)) {
    296296                /* if both are negative, smaller is that with greater binary value */
    297297                return (a.bin > b.bin);
    298298        }
    299        
     299
    300300        /*
    301301         * lets negate signs - now will be positive numbers always
     
    319319        uint64_t tmp_hi;
    320320        uint64_t tmp_lo;
    321        
     321
    322322        or128(a.bin.hi, a.bin.lo,
    323323            b.bin.hi, b.bin.lo, &tmp_hi, &tmp_lo);
     
    328328                return 0;
    329329        }
    330        
     330
    331331        if ((a.parts.sign) && (b.parts.sign)) {
    332332                /* if both are negative, smaller is that with greater binary value */
    333333                return lt128(b.bin.hi, b.bin.lo, a.bin.hi, a.bin.lo);
    334334        }
    335        
     335
    336336        /*
    337337         * lets negate signs - now will be positive numbers always
     
    357357                return 0;
    358358        }
    359        
     359
    360360        if ((a.parts.sign) && (b.parts.sign)) {
    361361                /* if both are negative, greater is that with smaller binary value */
    362362                return (a.bin < b.bin);
    363363        }
    364        
     364
    365365        /*
    366366         * lets negate signs - now will be positive numbers always
     
    386386                return 0;
    387387        }
    388        
     388
    389389        if ((a.parts.sign) && (b.parts.sign)) {
    390390                /* if both are negative, greater is that with smaller binary value */
    391391                return (a.bin < b.bin);
    392392        }
    393        
     393
    394394        /*
    395395         * lets negate signs - now will be positive numbers always
     
    413413        uint64_t tmp_hi;
    414414        uint64_t tmp_lo;
    415        
     415
    416416        or128(a.bin.hi, a.bin.lo,
    417417            b.bin.hi, b.bin.lo, &tmp_hi, &tmp_lo);
     
    422422                return 0;
    423423        }
    424        
     424
    425425        if ((a.parts.sign) && (b.parts.sign)) {
    426426                /* if both are negative, greater is that with smaller binary value */
    427427                return lt128(a.bin.hi, a.bin.lo, b.bin.hi, b.bin.lo);
    428428        }
    429        
     429
    430430        /*
    431431         * lets negate signs - now will be positive numbers always
     
    444444        float32_u ua;
    445445        ua.val = a;
    446        
     446
    447447        float32_u ub;
    448448        ub.val = b;
    449        
     449
    450450        if ((is_float32_nan(ua.data)) || (is_float32_nan(ub.data))) {
    451451                // TODO: sigNaNs
    452452                return -1;
    453453        }
    454        
     454
    455455        if (is_float32_gt(ua.data, ub.data))
    456456                return 1;
    457        
     457
    458458        return 0;
    459459}
     
    463463        float32_u ua;
    464464        ua.val = a;
    465        
     465
    466466        float32_u ub;
    467467        ub.val = b;
    468        
     468
    469469        if ((is_float32_nan(ua.data)) || (is_float32_nan(ub.data))) {
    470470                // TODO: sigNaNs
    471471                return -1;
    472472        }
    473        
     473
    474474        if (is_float32_eq(ua.data, ub.data))
    475475                return 0;
    476        
     476
    477477        if (is_float32_gt(ua.data, ub.data))
    478478                return 1;
    479        
     479
    480480        return -1;
    481481}
     
    485485        float32_u ua;
    486486        ua.val = a;
    487        
     487
    488488        float32_u ub;
    489489        ub.val = b;
    490        
     490
    491491        if ((is_float32_nan(ua.data)) || (is_float32_nan(ub.data))) {
    492492                // TODO: sigNaNs
    493493                return 1;
    494494        }
    495        
     495
    496496        if (is_float32_lt(ua.data, ub.data))
    497497                return -1;
    498        
     498
    499499        return 0;
    500500}
     
    504504        float32_u ua;
    505505        ua.val = a;
    506        
     506
    507507        float32_u ub;
    508508        ub.val = b;
    509        
     509
    510510        if ((is_float32_nan(ua.data)) || (is_float32_nan(ub.data))) {
    511511                // TODO: sigNaNs
    512512                return 1;
    513513        }
    514        
     514
    515515        if (is_float32_eq(ua.data, ub.data))
    516516                return 0;
    517        
     517
    518518        if (is_float32_lt(ua.data, ub.data))
    519519                return -1;
    520        
     520
    521521        return 1;
    522522}
     
    526526        float32_u ua;
    527527        ua.val = a;
    528        
     528
    529529        float32_u ub;
    530530        ub.val = b;
    531        
     531
    532532        if ((is_float32_nan(ua.data)) || (is_float32_nan(ub.data))) {
    533533                // TODO: sigNaNs
    534534                return 1;
    535535        }
    536        
     536
    537537        return is_float32_eq(ua.data, ub.data) - 1;
    538538}
     
    548548        float32_u ua;
    549549        ua.val = a;
    550        
     550
    551551        float32_u ub;
    552552        ub.val = b;
    553        
     553
    554554        if ((is_float32_nan(ua.data)) || (is_float32_nan(ub.data))) {
    555555                /* No special constant for unordered - maybe signaled? */
    556556                return 1;
    557557        }
    558        
     558
    559559        if (is_float32_eq(ua.data, ub.data))
    560560                return 0;
    561        
     561
    562562        if (is_float32_lt(ua.data, ub.data))
    563563                return -1;
    564        
     564
    565565        return 1;
    566566}
     
    570570        float32_u ua;
    571571        ua.val = a;
    572        
     572
    573573        float32_u ub;
    574574        ub.val = b;
    575        
     575
    576576        return ((is_float32_nan(ua.data)) || (is_float32_nan(ub.data)));
    577577}
     
    581581        float32_u ua;
    582582        ua.val = a;
    583        
     583
    584584        float32_u ub;
    585585        ub.val = b;
    586        
     586
    587587        if ((is_float32_nan(ua.data)) || (is_float32_nan(ub.data))) {
    588588                // TODO: sigNaNs
    589589                return -1;
    590590        }
    591        
     591
    592592        if (is_float32_gt(ua.data, ub.data))
    593593                return 1;
    594        
     594
    595595        return 0;
    596596}
     
    600600        float32_u ua;
    601601        ua.val = a;
    602        
     602
    603603        float32_u ub;
    604604        ub.val = b;
    605        
     605
    606606        if ((is_float32_nan(ua.data)) || (is_float32_nan(ub.data))) {
    607607                // TODO: sigNaNs
    608608                return 1;
    609609        }
    610        
     610
    611611        if (is_float32_lt(ua.data, ub.data))
    612612                return -1;
    613        
     613
    614614        return 0;
    615615}
     
    619619        float32_u ua;
    620620        ua.val = a;
    621        
     621
    622622        float32_u ub;
    623623        ub.val = b;
    624        
     624
    625625        if ((is_float32_nan(ua.data)) || (is_float32_nan(ub.data))) {
    626626                // TODO: sigNaNs
    627627                return -1;
    628628        }
    629        
     629
    630630        if (is_float32_eq(ua.data, ub.data))
    631631                return 0;
    632        
     632
    633633        if (is_float32_gt(ua.data, ub.data))
    634634                return 1;
    635        
     635
    636636        return -1;
    637637}
     
    641641        float32_u ua;
    642642        ua.val = a;
    643        
     643
    644644        float32_u ub;
    645645        ub.val = b;
    646        
     646
    647647        if ((is_float32_nan(ua.data)) || (is_float32_nan(ub.data))) {
    648648                // TODO: sigNaNs
    649649                return 1;
    650650        }
    651        
     651
    652652        return is_float32_eq(ua.data, ub.data) - 1;
    653653}
     
    661661        float64_u ua;
    662662        ua.val = a;
    663        
     663
    664664        float64_u ub;
    665665        ub.val = b;
    666        
     666
    667667        if ((is_float64_nan(ua.data)) || (is_float64_nan(ub.data))) {
    668668                // TODO: sigNaNs
    669669                return -1;
    670670        }
    671        
     671
    672672        if (is_float64_gt(ua.data, ub.data))
    673673                return 1;
    674        
     674
    675675        return 0;
    676676}
     
    680680        float64_u ua;
    681681        ua.val = a;
    682        
     682
    683683        float64_u ub;
    684684        ub.val = b;
    685        
     685
    686686        if ((is_float64_nan(ua.data)) || (is_float64_nan(ub.data))) {
    687687                // TODO: sigNaNs
    688688                return -1;
    689689        }
    690        
     690
    691691        if (is_float64_eq(ua.data, ub.data))
    692692                return 0;
    693        
     693
    694694        if (is_float64_gt(ua.data, ub.data))
    695695                return 1;
    696        
     696
    697697        return -1;
    698698}
     
    702702        float64_u ua;
    703703        ua.val = a;
    704        
     704
    705705        float64_u ub;
    706706        ub.val = b;
    707        
     707
    708708        if ((is_float64_nan(ua.data)) || (is_float64_nan(ub.data))) {
    709709                // TODO: sigNaNs
    710710                return 1;
    711711        }
    712        
     712
    713713        if (is_float64_lt(ua.data, ub.data))
    714714                return -1;
    715        
     715
    716716        return 0;
    717717}
     
    721721        float64_u ua;
    722722        ua.val = a;
    723        
     723
    724724        float64_u ub;
    725725        ub.val = b;
    726        
     726
    727727        if ((is_float64_nan(ua.data)) || (is_float64_nan(ub.data))) {
    728728                // TODO: sigNaNs
    729729                return 1;
    730730        }
    731        
     731
    732732        if (is_float64_eq(ua.data, ub.data))
    733733                return 0;
    734        
     734
    735735        if (is_float64_lt(ua.data, ub.data))
    736736                return -1;
    737        
     737
    738738        return 1;
    739739}
     
    743743        float64_u ua;
    744744        ua.val = a;
    745        
     745
    746746        float64_u ub;
    747747        ub.val = b;
    748        
     748
    749749        if ((is_float64_nan(ua.data)) || (is_float64_nan(ub.data))) {
    750750                // TODO: sigNaNs
    751751                return 1;
    752752        }
    753        
     753
    754754        return is_float64_eq(ua.data, ub.data) - 1;
    755755}
     
    765765        float64_u ua;
    766766        ua.val = a;
    767        
     767
    768768        float64_u ub;
    769769        ub.val = b;
    770        
     770
    771771        if ((is_float64_nan(ua.data)) || (is_float64_nan(ub.data))) {
    772772                /* No special constant for unordered - maybe signaled? */
    773773                return 1;
    774774        }
    775        
     775
    776776        if (is_float64_eq(ua.data, ub.data))
    777777                return 0;
    778        
     778
    779779        if (is_float64_lt(ua.data, ub.data))
    780780                return -1;
    781        
     781
    782782        return 1;
    783783}
     
    787787        float64_u ua;
    788788        ua.val = a;
    789        
     789
    790790        float64_u ub;
    791791        ub.val = b;
    792        
     792
    793793        return ((is_float64_nan(ua.data)) || (is_float64_nan(ub.data)));
    794794}
     
    798798        float64_u ua;
    799799        ua.val = a;
    800        
     800
    801801        float64_u ub;
    802802        ub.val = b;
    803        
     803
    804804        if ((is_float64_nan(ua.data)) || (is_float64_nan(ub.data))) {
    805805                // TODO: sigNaNs
    806806                return 1;
    807807        }
    808        
     808
    809809        if (is_float64_lt(ua.data, ub.data))
    810810                return -1;
    811        
     811
    812812        return 0;
    813813}
     
    817817        float64_u ua;
    818818        ua.val = a;
    819        
     819
    820820        float64_u ub;
    821821        ub.val = b;
    822        
     822
    823823        if ((is_float64_nan(ua.data)) || (is_float64_nan(ub.data))) {
    824824                // TODO: sigNaNs
    825825                return 1;
    826826        }
    827        
     827
    828828        return is_float64_eq(ua.data, ub.data) - 1;
    829829}
     
    833833        float64_u ua;
    834834        ua.val = a;
    835        
     835
    836836        float64_u ub;
    837837        ub.val = b;
    838        
     838
    839839        if ((is_float64_nan(ua.data)) || (is_float64_nan(ub.data))) {
    840840                // TODO: sigNaNs
    841841                return -1;
    842842        }
    843        
     843
    844844        if (is_float64_gt(ua.data, ub.data))
    845845                return 1;
    846        
     846
    847847        return 0;
    848848}
     
    852852        float64_u ua;
    853853        ua.val = a;
    854        
     854
    855855        float64_u ub;
    856856        ub.val = b;
    857        
     857
    858858        if ((is_float64_nan(ua.data)) || (is_float64_nan(ub.data))) {
    859859                // TODO: sigNaNs
    860860                return -1;
    861861        }
    862        
     862
    863863        if (is_float64_eq(ua.data, ub.data))
    864864                return 0;
    865        
     865
    866866        if (is_float64_gt(ua.data, ub.data))
    867867                return 1;
    868        
     868
    869869        return -1;
    870870}
     
    874874        float64_u ua;
    875875        ua.val = a;
    876        
     876
    877877        float64_u ub;
    878878        ub.val = b;
    879        
     879
    880880        if ((is_float64_nan(ua.data)) || (is_float64_nan(ub.data))) {
    881881                // TODO: sigNaNs
    882882                return 1;
    883883        }
    884        
     884
    885885        if (is_float64_eq(ua.data, ub.data))
    886886                return 0;
    887        
     887
    888888        if (is_float64_lt(ua.data, ub.data))
    889889                return -1;
    890        
     890
    891891        return 1;
    892892}
     
    900900        float128_u ua;
    901901        ua.val = a;
    902        
    903         float128_u ub;
    904         ub.val = b;
    905        
     902
     903        float128_u ub;
     904        ub.val = b;
     905
    906906        if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data))) {
    907907                // TODO: sigNaNs
    908908                return -1;
    909909        }
    910        
     910
    911911        if (is_float128_gt(ua.data, ub.data))
    912912                return 1;
    913        
     913
    914914        return 0;
    915915}
     
    919919        float128_u ua;
    920920        ua.val = a;
    921        
    922         float128_u ub;
    923         ub.val = b;
    924        
     921
     922        float128_u ub;
     923        ub.val = b;
     924
    925925        if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data))) {
    926926                // TODO: sigNaNs
    927927                return -1;
    928928        }
    929        
     929
    930930        if (is_float128_eq(ua.data, ub.data))
    931931                return 0;
    932        
     932
    933933        if (is_float128_gt(ua.data, ub.data))
    934934                return 1;
    935        
     935
    936936        return -1;
    937937}
     
    941941        float128_u ua;
    942942        ua.val = a;
    943        
    944         float128_u ub;
    945         ub.val = b;
    946        
     943
     944        float128_u ub;
     945        ub.val = b;
     946
    947947        if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data))) {
    948948                // TODO: sigNaNs
    949949                return 1;
    950950        }
    951        
     951
    952952        if (is_float128_lt(ua.data, ub.data))
    953953                return -1;
    954        
     954
    955955        return 0;
    956956}
     
    960960        float128_u ua;
    961961        ua.val = a;
    962        
    963         float128_u ub;
    964         ub.val = b;
    965        
     962
     963        float128_u ub;
     964        ub.val = b;
     965
    966966        if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data))) {
    967967                // TODO: sigNaNs
    968968                return 1;
    969969        }
    970        
     970
    971971        if (is_float128_eq(ua.data, ub.data))
    972972                return 0;
    973        
     973
    974974        if (is_float128_lt(ua.data, ub.data))
    975975                return -1;
    976        
     976
    977977        return 1;
    978978}
     
    982982        float128_u ua;
    983983        ua.val = a;
    984        
    985         float128_u ub;
    986         ub.val = b;
    987        
     984
     985        float128_u ub;
     986        ub.val = b;
     987
    988988        if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data))) {
    989989                // TODO: sigNaNs
    990990                return 1;
    991991        }
    992        
     992
    993993        return is_float128_eq(ua.data, ub.data) - 1;
    994994}
     
    10041004        float128_u ua;
    10051005        ua.val = a;
    1006        
    1007         float128_u ub;
    1008         ub.val = b;
    1009        
     1006
     1007        float128_u ub;
     1008        ub.val = b;
     1009
    10101010        if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data))) {
    10111011                /* No special constant for unordered - maybe signaled? */
    10121012                return 1;
    10131013        }
    1014        
     1014
    10151015        if (is_float128_eq(ua.data, ub.data))
    10161016                return 0;
    1017        
     1017
    10181018        if (is_float128_lt(ua.data, ub.data))
    10191019                return -1;
    1020        
     1020
    10211021        return 1;
    10221022}
     
    10261026        float128_u ua;
    10271027        ua.val = a;
    1028        
    1029         float128_u ub;
    1030         ub.val = b;
    1031        
     1028
     1029        float128_u ub;
     1030        ub.val = b;
     1031
    10321032        return ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data)));
    10331033}
     
    10371037        float128_u ua;
    10381038        ua.val = *a;
    1039        
     1039
    10401040        float128_u ub;
    10411041        ub.val = *b;
    1042        
     1042
    10431043        if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data)))
    10441044                return 3;
    1045        
     1045
    10461046        if (is_float128_eq(ua.data, ub.data))
    10471047                return 0;
    1048        
     1048
    10491049        if (is_float128_lt(ua.data, ub.data))
    10501050                return 1;
    1051        
     1051
    10521052        return 2;
    10531053}
     
    10631063        float128_u ua;
    10641064        ua.val = *a;
    1065        
     1065
    10661066        float128_u ub;
    10671067        ub.val = *b;
    1068        
     1068
    10691069        if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data)))
    10701070                return 0;
    1071        
     1071
    10721072        return is_float128_gt(ua.data, ub.data);
    10731073}
     
    10771077        float128_u ua;
    10781078        ua.val = *a;
    1079        
     1079
    10801080        float128_u ub;
    10811081        ub.val = *b;
    1082        
     1082
    10831083        if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data)))
    10841084                return 0;
    1085        
     1085
    10861086        return is_float128_eq(ua.data, ub.data) ||
    10871087            is_float128_gt(ua.data, ub.data);
     
    10921092        float128_u ua;
    10931093        ua.val = *a;
    1094        
     1094
    10951095        float128_u ub;
    10961096        ub.val = *b;
    1097        
     1097
    10981098        if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data)))
    10991099                return 0;
    1100        
     1100
    11011101        return is_float128_lt(ua.data, ub.data);
    11021102}
     
    11061106        float128_u ua;
    11071107        ua.val = *a;
    1108        
     1108
    11091109        float128_u ub;
    11101110        ub.val = *b;
    1111        
     1111
    11121112        if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data)))
    11131113                return 0;
    1114        
     1114
    11151115        return is_float128_eq(ua.data, ub.data) ||
    11161116            is_float128_lt(ua.data, ub.data);
     
    11211121        float128_u ua;
    11221122        ua.val = *a;
    1123        
     1123
    11241124        float128_u ub;
    11251125        ub.val = *b;
    1126        
     1126
    11271127        if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data)))
    11281128                return 0;
    1129        
     1129
    11301130        return is_float128_eq(ua.data, ub.data);
    11311131}
     
    11351135        float128_u ua;
    11361136        ua.val = *a;
    1137        
     1137
    11381138        float128_u ub;
    11391139        ub.val = *b;
    1140        
     1140
    11411141        if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data)))
    11421142                return 0;
    1143        
     1143
    11441144        return !is_float128_eq(ua.data, ub.data);
    11451145}
  • uspace/lib/softfloat/conversion.c

    r3061bc1 ra35b458  
    4242        float64 result;
    4343        uint64_t frac;
    44        
     44
    4545        result.parts.sign = a.parts.sign;
    4646        result.parts.fraction = a.parts.fraction;
    4747        result.parts.fraction <<= (FLOAT64_FRACTION_SIZE - FLOAT32_FRACTION_SIZE);
    48        
     48
    4949        if ((is_float32_infinity(a)) || (is_float32_nan(a))) {
    5050                result.parts.exp = FLOAT64_MAX_EXPONENT;
     
    5252                return result;
    5353        }
    54        
     54
    5555        result.parts.exp = a.parts.exp + ((int) FLOAT64_BIAS - FLOAT32_BIAS);
    5656        if (a.parts.exp == 0) {
    5757                /* normalize denormalized numbers */
    58                
     58
    5959                if (result.parts.fraction == 0) { /* fix zero */
    6060                        result.parts.exp = 0;
    6161                        return result;
    6262                }
    63                        
     63
    6464                frac = result.parts.fraction;
    65                
     65
    6666                while (!(frac & FLOAT64_HIDDEN_BIT_MASK)) {
    6767                        frac <<= 1;
    6868                        --result.parts.exp;
    6969                }
    70                
     70
    7171                ++result.parts.exp;
    7272                result.parts.fraction = frac;
    7373        }
    74        
     74
    7575        return result;
    7676}
     
    8181        uint64_t frac_hi, frac_lo;
    8282        uint64_t tmp_hi, tmp_lo;
    83        
     83
    8484        result.parts.sign = a.parts.sign;
    8585        result.parts.frac_hi = 0;
     
    9090        result.parts.frac_hi = frac_hi;
    9191        result.parts.frac_lo = frac_lo;
    92        
     92
    9393        if ((is_float32_infinity(a)) || (is_float32_nan(a))) {
    9494                result.parts.exp = FLOAT128_MAX_EXPONENT;
     
    9696                return result;
    9797        }
    98        
     98
    9999        result.parts.exp = a.parts.exp + ((int) FLOAT128_BIAS - FLOAT32_BIAS);
    100100        if (a.parts.exp == 0) {
    101101                /* normalize denormalized numbers */
    102                
     102
    103103                if (eq128(result.parts.frac_hi,
    104104                    result.parts.frac_lo, 0x0ll, 0x0ll)) { /* fix zero */
     
    106106                        return result;
    107107                }
    108                
     108
    109109                frac_hi = result.parts.frac_hi;
    110110                frac_lo = result.parts.frac_lo;
    111                
     111
    112112                and128(frac_hi, frac_lo,
    113113                    FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO,
     
    117117                        --result.parts.exp;
    118118                }
    119                
     119
    120120                ++result.parts.exp;
    121121                result.parts.frac_hi = frac_hi;
    122122                result.parts.frac_lo = frac_lo;
    123123        }
    124        
     124
    125125        return result;
    126126}
     
    131131        uint64_t frac_hi, frac_lo;
    132132        uint64_t tmp_hi, tmp_lo;
    133        
     133
    134134        result.parts.sign = a.parts.sign;
    135135        result.parts.frac_hi = 0;
     
    140140        result.parts.frac_hi = frac_hi;
    141141        result.parts.frac_lo = frac_lo;
    142        
     142
    143143        if ((is_float64_infinity(a)) || (is_float64_nan(a))) {
    144144                result.parts.exp = FLOAT128_MAX_EXPONENT;
     
    146146                return result;
    147147        }
    148        
     148
    149149        result.parts.exp = a.parts.exp + ((int) FLOAT128_BIAS - FLOAT64_BIAS);
    150150        if (a.parts.exp == 0) {
    151151                /* normalize denormalized numbers */
    152                
     152
    153153                if (eq128(result.parts.frac_hi,
    154154                    result.parts.frac_lo, 0x0ll, 0x0ll)) { /* fix zero */
     
    156156                        return result;
    157157                }
    158                
     158
    159159                frac_hi = result.parts.frac_hi;
    160160                frac_lo = result.parts.frac_lo;
    161                
     161
    162162                and128(frac_hi, frac_lo,
    163163                    FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO,
     
    167167                        --result.parts.exp;
    168168                }
    169                
     169
    170170                ++result.parts.exp;
    171171                result.parts.frac_hi = frac_hi;
    172172                result.parts.frac_lo = frac_lo;
    173173        }
    174        
     174
    175175        return result;
    176176}
     
    181181        int32_t exp;
    182182        uint64_t frac;
    183        
     183
    184184        result.parts.sign = a.parts.sign;
    185        
     185
    186186        if (is_float64_nan(a)) {
    187187                result.parts.exp = FLOAT32_MAX_EXPONENT;
    188                
     188
    189189                if (is_float64_signan(a)) {
    190190                        /* set first bit of fraction nonzero */
     
    192192                        return result;
    193193                }
    194                
     194
    195195                /* fraction nonzero but its first bit is zero */
    196196                result.parts.fraction = 0x1;
    197197                return result;
    198198        }
    199        
     199
    200200        if (is_float64_infinity(a)) {
    201201                result.parts.fraction = 0;
     
    203203                return result;
    204204        }
    205        
     205
    206206        exp = (int) a.parts.exp - FLOAT64_BIAS + FLOAT32_BIAS;
    207        
     207
    208208        if (exp >= FLOAT32_MAX_EXPONENT) {
    209209                /* FIXME: overflow */
     
    213213        } else if (exp <= 0) {
    214214                /* underflow or denormalized */
    215                
     215
    216216                result.parts.exp = 0;
    217                
     217
    218218                exp *= -1;
    219219                if (exp > FLOAT32_FRACTION_SIZE) {
     
    222222                        return result;
    223223                }
    224                
     224
    225225                /* denormalized */
    226                
     226
    227227                frac = a.parts.fraction;
    228228                frac |= FLOAT64_HIDDEN_BIT_MASK; /* denormalize and set hidden bit */
    229                
     229
    230230                frac >>= (FLOAT64_FRACTION_SIZE - FLOAT32_FRACTION_SIZE + 1);
    231                
     231
    232232                while (exp > 0) {
    233233                        --exp;
     
    235235                }
    236236                result.parts.fraction = frac;
    237                
    238                 return result;
    239         }
    240        
     237
     238                return result;
     239        }
     240
    241241        result.parts.exp = exp;
    242242        result.parts.fraction =
     
    250250        int32_t exp;
    251251        uint64_t frac_hi, frac_lo;
    252        
     252
    253253        result.parts.sign = a.parts.sign;
    254        
     254
    255255        if (is_float128_nan(a)) {
    256256                result.parts.exp = FLOAT32_MAX_EXPONENT;
    257                
     257
    258258                if (is_float128_signan(a)) {
    259259                        /* set first bit of fraction nonzero */
     
    261261                        return result;
    262262                }
    263                
     263
    264264                /* fraction nonzero but its first bit is zero */
    265265                result.parts.fraction = 0x1;
    266266                return result;
    267267        }
    268        
     268
    269269        if (is_float128_infinity(a)) {
    270270                result.parts.fraction = 0;
     
    272272                return result;
    273273        }
    274        
     274
    275275        exp = (int) a.parts.exp - FLOAT128_BIAS + FLOAT32_BIAS;
    276        
     276
    277277        if (exp >= FLOAT32_MAX_EXPONENT) {
    278278                /* FIXME: overflow */
     
    282282        } else if (exp <= 0) {
    283283                /* underflow or denormalized */
    284                
     284
    285285                result.parts.exp = 0;
    286                
     286
    287287                exp *= -1;
    288288                if (exp > FLOAT32_FRACTION_SIZE) {
     
    291291                        return result;
    292292                }
    293                
     293
    294294                /* denormalized */
    295                
     295
    296296                frac_hi = a.parts.frac_hi;
    297297                frac_lo = a.parts.frac_lo;
    298                
     298
    299299                /* denormalize and set hidden bit */
    300300                frac_hi |= FLOAT128_HIDDEN_BIT_MASK_HI;
    301                
     301
    302302                rshift128(frac_hi, frac_lo,
    303303                    (FLOAT128_FRACTION_SIZE - FLOAT32_FRACTION_SIZE + 1),
    304304                    &frac_hi, &frac_lo);
    305                
     305
    306306                while (exp > 0) {
    307307                        --exp;
     
    309309                }
    310310                result.parts.fraction = frac_lo;
    311                
    312                 return result;
    313         }
    314        
     311
     312                return result;
     313        }
     314
    315315        result.parts.exp = exp;
    316316        frac_hi = a.parts.frac_hi;
     
    328328        int32_t exp;
    329329        uint64_t frac_hi, frac_lo;
    330        
     330
    331331        result.parts.sign = a.parts.sign;
    332        
     332
    333333        if (is_float128_nan(a)) {
    334334                result.parts.exp = FLOAT64_MAX_EXPONENT;
    335                
     335
    336336                if (is_float128_signan(a)) {
    337337                        /* set first bit of fraction nonzero */
     
    339339                        return result;
    340340                }
    341                
     341
    342342                /* fraction nonzero but its first bit is zero */
    343343                result.parts.fraction = 0x1;
    344344                return result;
    345345        }
    346        
     346
    347347        if (is_float128_infinity(a)) {
    348348                result.parts.fraction = 0;
     
    350350                return result;
    351351        }
    352        
     352
    353353        exp = (int) a.parts.exp - FLOAT128_BIAS + FLOAT64_BIAS;
    354        
     354
    355355        if (exp >= FLOAT64_MAX_EXPONENT) {
    356356                /* FIXME: overflow */
     
    360360        } else if (exp <= 0) {
    361361                /* underflow or denormalized */
    362                
     362
    363363                result.parts.exp = 0;
    364                
     364
    365365                exp *= -1;
    366366                if (exp > FLOAT64_FRACTION_SIZE) {
     
    369369                        return result;
    370370                }
    371                
     371
    372372                /* denormalized */
    373                
     373
    374374                frac_hi = a.parts.frac_hi;
    375375                frac_lo = a.parts.frac_lo;
    376                
     376
    377377                /* denormalize and set hidden bit */
    378378                frac_hi |= FLOAT128_HIDDEN_BIT_MASK_HI;
    379                
     379
    380380                rshift128(frac_hi, frac_lo,
    381381                    (FLOAT128_FRACTION_SIZE - FLOAT64_FRACTION_SIZE + 1),
    382382                    &frac_hi, &frac_lo);
    383                
     383
    384384                while (exp > 0) {
    385385                        --exp;
     
    387387                }
    388388                result.parts.fraction = frac_lo;
    389                
    390                 return result;
    391         }
    392        
     389
     390                return result;
     391        }
     392
    393393        result.parts.exp = exp;
    394394        frac_hi = a.parts.frac_hi;
     
    410410{
    411411        uint32_t frac;
    412        
     412
    413413        if (a.parts.exp < FLOAT32_BIAS) {
    414414                /* TODO: rounding */
    415415                return 0;
    416416        }
    417        
     417
    418418        frac = a.parts.fraction;
    419        
     419
    420420        frac |= FLOAT32_HIDDEN_BIT_MASK;
    421421        /* shift fraction to left so hidden bit will be the most significant bit */
    422422        frac <<= 32 - FLOAT32_FRACTION_SIZE - 1;
    423        
     423
    424424        frac >>= 32 - (a.parts.exp - FLOAT32_BIAS) - 1;
    425425        if ((a.parts.sign == 1) && (frac != 0)) {
     
    427427                ++frac;
    428428        }
    429        
     429
    430430        return frac;
    431431}
     
    439439        if (is_float32_nan(a))
    440440                return UINT32_MAX;
    441        
     441
    442442        if (is_float32_infinity(a) || (a.parts.exp >= (32 + FLOAT32_BIAS))) {
    443443                if (a.parts.sign)
    444444                        return UINT32_MIN;
    445                
     445
    446446                return UINT32_MAX;
    447447        }
    448        
     448
    449449        return _float32_to_uint32_helper(a);
    450450}
     
    458458        if (is_float32_nan(a))
    459459                return INT32_MAX;
    460        
     460
    461461        if (is_float32_infinity(a) || (a.parts.exp >= (32 + FLOAT32_BIAS))) {
    462462                if (a.parts.sign)
    463463                        return INT32_MIN;
    464                
     464
    465465                return INT32_MAX;
    466466        }
    467        
     467
    468468        return _float32_to_uint32_helper(a);
    469469}
     
    478478{
    479479        uint64_t frac;
    480        
     480
    481481        if (a.parts.exp < FLOAT32_BIAS) {
    482482                // TODO: rounding
    483483                return 0;
    484484        }
    485        
     485
    486486        frac = a.parts.fraction;
    487        
     487
    488488        frac |= FLOAT32_HIDDEN_BIT_MASK;
    489489        /* shift fraction to left so hidden bit will be the most significant bit */
    490490        frac <<= 64 - FLOAT32_FRACTION_SIZE - 1;
    491        
     491
    492492        frac >>= 64 - (a.parts.exp - FLOAT32_BIAS) - 1;
    493493        if ((a.parts.sign == 1) && (frac != 0)) {
     
    495495                ++frac;
    496496        }
    497        
     497
    498498        return frac;
    499499}
     
    507507        if (is_float32_nan(a))
    508508                return UINT64_MAX;
    509        
     509
    510510        if (is_float32_infinity(a) || (a.parts.exp >= (64 + FLOAT32_BIAS))) {
    511511                if (a.parts.sign)
    512512                        return UINT64_MIN;
    513                
     513
    514514                return UINT64_MAX;
    515515        }
    516        
     516
    517517        return _float32_to_uint64_helper(a);
    518518}
     
    526526        if (is_float32_nan(a))
    527527                return INT64_MAX;
    528        
     528
    529529        if (is_float32_infinity(a) || (a.parts.exp >= (64 + FLOAT32_BIAS))) {
    530530                if (a.parts.sign)
    531531                        return INT64_MIN;
    532                
     532
    533533                return INT64_MAX;
    534534        }
    535        
     535
    536536        return _float32_to_uint64_helper(a);
    537537}
     
    546546{
    547547        uint64_t frac;
    548        
     548
    549549        if (a.parts.exp < FLOAT64_BIAS) {
    550550                // TODO: rounding
    551551                return 0;
    552552        }
    553        
     553
    554554        frac = a.parts.fraction;
    555        
     555
    556556        frac |= FLOAT64_HIDDEN_BIT_MASK;
    557557        /* shift fraction to left so hidden bit will be the most significant bit */
    558558        frac <<= 64 - FLOAT64_FRACTION_SIZE - 1;
    559        
     559
    560560        frac >>= 64 - (a.parts.exp - FLOAT64_BIAS) - 1;
    561561        if ((a.parts.sign == 1) && (frac != 0)) {
     
    563563                ++frac;
    564564        }
    565        
     565
    566566        return frac;
    567567}
     
    575575        if (is_float64_nan(a))
    576576                return UINT32_MAX;
    577        
     577
    578578        if (is_float64_infinity(a) || (a.parts.exp >= (32 + FLOAT64_BIAS))) {
    579579                if (a.parts.sign)
    580580                        return UINT32_MIN;
    581                
     581
    582582                return UINT32_MAX;
    583583        }
    584        
     584
    585585        return (uint32_t) _float64_to_uint64_helper(a);
    586586}
     
    594594        if (is_float64_nan(a))
    595595                return INT32_MAX;
    596        
     596
    597597        if (is_float64_infinity(a) || (a.parts.exp >= (32 + FLOAT64_BIAS))) {
    598598                if (a.parts.sign)
    599599                        return INT32_MIN;
    600                
     600
    601601                return INT32_MAX;
    602602        }
    603        
     603
    604604        return (int32_t) _float64_to_uint64_helper(a);
    605605}
     
    613613        if (is_float64_nan(a))
    614614                return UINT64_MAX;
    615        
     615
    616616        if (is_float64_infinity(a) || (a.parts.exp >= (64 + FLOAT64_BIAS))) {
    617617                if (a.parts.sign)
    618618                        return UINT64_MIN;
    619                
     619
    620620                return UINT64_MAX;
    621621        }
    622        
     622
    623623        return _float64_to_uint64_helper(a);
    624624}
     
    632632        if (is_float64_nan(a))
    633633                return INT64_MAX;
    634        
     634
    635635        if (is_float64_infinity(a) || (a.parts.exp >= (64 + FLOAT64_BIAS))) {
    636636                if (a.parts.sign)
    637637                        return INT64_MIN;
    638                
     638
    639639                return INT64_MAX;
    640640        }
    641        
     641
    642642        return _float64_to_uint64_helper(a);
    643643}
     
    652652{
    653653        uint64_t frac_hi, frac_lo;
    654        
     654
    655655        if (a.parts.exp < FLOAT128_BIAS) {
    656656                // TODO: rounding
    657657                return 0;
    658658        }
    659        
     659
    660660        frac_hi = a.parts.frac_hi;
    661661        frac_lo = a.parts.frac_lo;
    662        
     662
    663663        frac_hi |= FLOAT128_HIDDEN_BIT_MASK_HI;
    664664        /* shift fraction to left so hidden bit will be the most significant bit */
    665665        lshift128(frac_hi, frac_lo,
    666666            (128 - FLOAT128_FRACTION_SIZE - 1), &frac_hi, &frac_lo);
    667        
     667
    668668        rshift128(frac_hi, frac_lo,
    669669            (128 - (a.parts.exp - FLOAT128_BIAS) - 1), &frac_hi, &frac_lo);
     
    672672                add128(frac_hi, frac_lo, 0x0ll, 0x1ll, &frac_hi, &frac_lo);
    673673        }
    674        
     674
    675675        return frac_lo;
    676676}
     
    684684        if (is_float128_nan(a))
    685685                return UINT32_MAX;
    686        
     686
    687687        if (is_float128_infinity(a) || (a.parts.exp >= (32 + FLOAT128_BIAS))) {
    688688                if (a.parts.sign)
    689689                        return UINT32_MIN;
    690                
     690
    691691                return UINT32_MAX;
    692692        }
    693        
     693
    694694        return (uint32_t) _float128_to_uint64_helper(a);
    695695}
     
    703703        if (is_float128_nan(a))
    704704                return INT32_MAX;
    705        
     705
    706706        if (is_float128_infinity(a) || (a.parts.exp >= (32 + FLOAT128_BIAS))) {
    707707                if (a.parts.sign)
    708708                        return INT32_MIN;
    709                
     709
    710710                return INT32_MAX;
    711711        }
    712        
     712
    713713        return (int32_t) _float128_to_uint64_helper(a);
    714714}
     
    722722        if (is_float128_nan(a))
    723723                return UINT64_MAX;
    724        
     724
    725725        if (is_float128_infinity(a) || (a.parts.exp >= (64 + FLOAT128_BIAS))) {
    726726                if (a.parts.sign)
    727727                        return UINT64_MIN;
    728                
     728
    729729                return UINT64_MAX;
    730730        }
    731        
     731
    732732        return _float128_to_uint64_helper(a);
    733733}
     
    741741        if (is_float128_nan(a))
    742742                return INT64_MAX;
    743        
     743
    744744        if (is_float128_infinity(a) || (a.parts.exp >= (64 + FLOAT128_BIAS))) {
    745745                if (a.parts.sign)
    746746                        return INT64_MIN;
    747                
     747
    748748                return INT64_MAX;
    749749        }
    750        
     750
    751751        return _float128_to_uint64_helper(a);
    752752}
     
    757757        int32_t exp;
    758758        float32 result;
    759        
     759
    760760        result.parts.sign = 0;
    761761        result.parts.fraction = 0;
    762        
     762
    763763        counter = count_zeroes32(i);
    764        
     764
    765765        exp = FLOAT32_BIAS + 32 - counter - 1;
    766        
     766
    767767        if (counter == 32) {
    768768                result.bin = 0;
    769769                return result;
    770770        }
    771        
     771
    772772        if (counter > 0) {
    773773                i <<= counter - 1;
     
    775775                i >>= 1;
    776776        }
    777        
     777
    778778        round_float32(&exp, &i);
    779        
     779
    780780        result.parts.fraction = i >> (32 - FLOAT32_FRACTION_SIZE - 2);
    781781        result.parts.exp = exp;
    782        
     782
    783783        return result;
    784784}
     
    787787{
    788788        float32 result;
    789        
     789
    790790        if (i < 0)
    791791                result = uint32_to_float32((uint32_t) (-i));
    792792        else
    793793                result = uint32_to_float32((uint32_t) i);
    794        
     794
    795795        result.parts.sign = i < 0;
    796        
     796
    797797        return result;
    798798}
     
    804804        uint32_t j;
    805805        float32 result;
    806        
     806
    807807        result.parts.sign = 0;
    808808        result.parts.fraction = 0;
    809        
     809
    810810        counter = count_zeroes64(i);
    811        
     811
    812812        exp = FLOAT32_BIAS + 64 - counter - 1;
    813        
     813
    814814        if (counter == 64) {
    815815                result.bin = 0;
    816816                return result;
    817817        }
    818        
     818
    819819        /* Shift all to the first 31 bits (31st will be hidden 1) */
    820820        if (counter > 33) {
     
    823823                i >>= 1 + 32 - counter;
    824824        }
    825        
     825
    826826        j = (uint32_t) i;
    827827        round_float32(&exp, &j);
    828        
     828
    829829        result.parts.fraction = j >> (32 - FLOAT32_FRACTION_SIZE - 2);
    830830        result.parts.exp = exp;
     
    835835{
    836836        float32 result;
    837        
     837
    838838        if (i < 0)
    839839                result = uint64_to_float32((uint64_t) (-i));
    840840        else
    841841                result = uint64_to_float32((uint64_t) i);
    842        
     842
    843843        result.parts.sign = i < 0;
    844        
     844
    845845        return result;
    846846}
     
    852852        float64 result;
    853853        uint64_t frac;
    854        
     854
    855855        result.parts.sign = 0;
    856856        result.parts.fraction = 0;
    857        
     857
    858858        counter = count_zeroes32(i);
    859        
     859
    860860        exp = FLOAT64_BIAS + 32 - counter - 1;
    861        
     861
    862862        if (counter == 32) {
    863863                result.bin = 0;
    864864                return result;
    865865        }
    866        
     866
    867867        frac = i;
    868868        frac <<= counter + 32 - 1;
    869        
     869
    870870        round_float64(&exp, &frac);
    871        
     871
    872872        result.parts.fraction = frac >> (64 - FLOAT64_FRACTION_SIZE - 2);
    873873        result.parts.exp = exp;
    874        
     874
    875875        return result;
    876876}
     
    879879{
    880880        float64 result;
    881        
     881
    882882        if (i < 0)
    883883                result = uint32_to_float64((uint32_t) (-i));
    884884        else
    885885                result = uint32_to_float64((uint32_t) i);
    886        
     886
    887887        result.parts.sign = i < 0;
    888        
     888
    889889        return result;
    890890}
     
    895895        int32_t exp;
    896896        float64 result;
    897        
     897
    898898        result.parts.sign = 0;
    899899        result.parts.fraction = 0;
    900        
     900
    901901        counter = count_zeroes64(i);
    902        
     902
    903903        exp = FLOAT64_BIAS + 64 - counter - 1;
    904        
     904
    905905        if (counter == 64) {
    906906                result.bin = 0;
    907907                return result;
    908908        }
    909        
     909
    910910        if (counter > 0) {
    911911                i <<= counter - 1;
     
    913913                i >>= 1;
    914914        }
    915        
     915
    916916        round_float64(&exp, &i);
    917        
     917
    918918        result.parts.fraction = i >> (64 - FLOAT64_FRACTION_SIZE - 2);
    919919        result.parts.exp = exp;
     
    924924{
    925925        float64 result;
    926        
     926
    927927        if (i < 0)
    928928                result = uint64_to_float64((uint64_t) (-i));
    929929        else
    930930                result = uint64_to_float64((uint64_t) i);
    931        
     931
    932932        result.parts.sign = i < 0;
    933        
     933
    934934        return result;
    935935}
     
    941941        float128 result;
    942942        uint64_t frac_hi, frac_lo;
    943        
     943
    944944        result.parts.sign = 0;
    945945        result.parts.frac_hi = 0;
    946946        result.parts.frac_lo = 0;
    947        
     947
    948948        counter = count_zeroes32(i);
    949        
     949
    950950        exp = FLOAT128_BIAS + 32 - counter - 1;
    951        
     951
    952952        if (counter == 32) {
    953953                result.bin.hi = 0;
     
    955955                return result;
    956956        }
    957        
     957
    958958        frac_hi = 0;
    959959        frac_lo = i;
    960960        lshift128(frac_hi, frac_lo, (counter + 96 - 1), &frac_hi, &frac_lo);
    961        
     961
    962962        round_float128(&exp, &frac_hi, &frac_lo);
    963        
     963
    964964        rshift128(frac_hi, frac_lo,
    965965            (128 - FLOAT128_FRACTION_SIZE - 2), &frac_hi, &frac_lo);
     
    967967        result.parts.frac_lo = frac_lo;
    968968        result.parts.exp = exp;
    969        
     969
    970970        return result;
    971971}
     
    974974{
    975975        float128 result;
    976        
     976
    977977        if (i < 0)
    978978                result = uint32_to_float128((uint32_t) (-i));
    979979        else
    980980                result = uint32_to_float128((uint32_t) i);
    981        
     981
    982982        result.parts.sign = i < 0;
    983        
     983
    984984        return result;
    985985}
     
    992992        float128 result;
    993993        uint64_t frac_hi, frac_lo;
    994        
     994
    995995        result.parts.sign = 0;
    996996        result.parts.frac_hi = 0;
    997997        result.parts.frac_lo = 0;
    998        
     998
    999999        counter = count_zeroes64(i);
    1000        
     1000
    10011001        exp = FLOAT128_BIAS + 64 - counter - 1;
    1002        
     1002
    10031003        if (counter == 64) {
    10041004                result.bin.hi = 0;
     
    10061006                return result;
    10071007        }
    1008        
     1008
    10091009        frac_hi = 0;
    10101010        frac_lo = i;
    10111011        lshift128(frac_hi, frac_lo, (counter + 64 - 1), &frac_hi, &frac_lo);
    1012        
     1012
    10131013        round_float128(&exp, &frac_hi, &frac_lo);
    1014        
     1014
    10151015        rshift128(frac_hi, frac_lo,
    10161016            (128 - FLOAT128_FRACTION_SIZE - 2), &frac_hi, &frac_lo);
     
    10181018        result.parts.frac_lo = frac_lo;
    10191019        result.parts.exp = exp;
    1020        
     1020
    10211021        return result;
    10221022}
     
    10251025{
    10261026        float128 result;
    1027        
     1027
    10281028        if (i < 0)
    10291029                result = uint64_to_float128((uint64_t) (-i));
    10301030        else
    10311031                result = uint64_to_float128((uint64_t) i);
    1032        
     1032
    10331033        result.parts.sign = i < 0;
    1034        
     1034
    10351035        return result;
    10361036}
     
    10421042        float32_u res;
    10431043        res.data = int32_to_float32(i);
    1044        
     1044
    10451045        return res.val;
    10461046}
     
    10501050        float32_u res;
    10511051        res.data = int64_to_float32(i);
    1052        
     1052
    10531053        return res.val;
    10541054}
     
    10581058        float32_u res;
    10591059        res.data = uint32_to_float32(i);
    1060        
     1060
    10611061        return res.val;
    10621062}
     
    10661066        float32_u res;
    10671067        res.data = uint64_to_float32(i);
    1068        
     1068
    10691069        return res.val;
    10701070}
     
    10741074        float32_u ua;
    10751075        ua.val = a;
    1076        
     1076
    10771077        return float32_to_int32(ua.data);
    10781078}
     
    10821082        float32_u ua;
    10831083        ua.val = a;
    1084        
     1084
    10851085        return float32_to_int64(ua.data);
    10861086}
     
    10901090        float32_u ua;
    10911091        ua.val = a;
    1092        
     1092
    10931093        return float32_to_uint32(ua.data);
    10941094}
     
    10981098        float32_u ua;
    10991099        ua.val = a;
    1100        
     1100
    11011101        return float32_to_uint64(ua.data);
    11021102}
     
    11061106        float32_u ua;
    11071107        ua.val = a;
    1108        
     1108
    11091109        return float32_to_int32(ua.data);
    11101110}
     
    11141114        float32_u ua;
    11151115        ua.val = a;
    1116        
     1116
    11171117        return float32_to_uint32(ua.data);
    11181118}
     
    11221122        float32_u res;
    11231123        res.data = int32_to_float32(i);
    1124        
     1124
    11251125        return res.val;
    11261126}
     
    11301130        float32_u res;
    11311131        res.data = int64_to_float32(i);
    1132        
     1132
    11331133        return res.val;
    11341134}
     
    11381138        float32_u res;
    11391139        res.data = uint32_to_float32(i);
    1140        
     1140
    11411141        return res.val;
    11421142}
     
    11461146        float32_u res;
    11471147        res.data = uint64_to_float32(i);
    1148        
     1148
    11491149        return res.val;
    11501150}
     
    11581158        float64_u res;
    11591159        res.data = int32_to_float64(i);
    1160        
     1160
    11611161        return res.val;
    11621162}
     
    11661166        float64_u res;
    11671167        res.data = int64_to_float64(i);
    1168        
     1168
    11691169        return res.val;
    11701170}
     
    11741174        float64_u res;
    11751175        res.data = uint32_to_float64(i);
    1176        
     1176
    11771177        return res.val;
    11781178}
     
    11821182        float64_u res;
    11831183        res.data = uint64_to_float64(i);
    1184        
     1184
    11851185        return res.val;
    11861186}
     
    11901190        float64_u ua;
    11911191        ua.val = a;
    1192        
     1192
    11931193        return float64_to_uint32(ua.data);
    11941194}
     
    11981198        float64_u ua;
    11991199        ua.val = a;
    1200        
     1200
    12011201        return float64_to_uint64(ua.data);
    12021202}
     
    12061206        float64_u ua;
    12071207        ua.val = a;
    1208        
     1208
    12091209        return float64_to_int32(ua.data);
    12101210}
     
    12141214        float64_u ua;
    12151215        ua.val = a;
    1216        
     1216
    12171217        return float64_to_int64(ua.data);
    12181218}
     
    12221222        float64_u res;
    12231223        res.data = int32_to_float64(i);
    1224        
     1224
    12251225        return res.val;
    12261226}
     
    12301230        float64_u res;
    12311231        res.data = uint32_to_float64(i);
    1232        
     1232
    12331233        return res.val;
    12341234}
     
    12381238        float64_u res;
    12391239        res.data = int64_to_float64(i);
    1240        
     1240
    12411241        return res.val;
    12421242}
     
    12461246        float64_u ua;
    12471247        ua.val = a;
    1248        
     1248
    12491249        return float64_to_int32(ua.data);
    12501250}
     
    12541254        float64_u ua;
    12551255        ua.val = a;
    1256        
     1256
    12571257        return float64_to_int64(ua.data);
    12581258}
     
    12621262        float64_u ua;
    12631263        ua.val = a;
    1264        
     1264
    12651265        return float64_to_uint32(ua.data);
    12661266}
     
    12741274        float128_u res;
    12751275        res.data = int32_to_float128(i);
    1276        
     1276
    12771277        return res.val;
    12781278}
     
    12821282        float128_u res;
    12831283        res.data = int64_to_float128(i);
    1284        
     1284
    12851285        return res.val;
    12861286}
     
    12901290        float128_u res;
    12911291        res.data = uint32_to_float128(i);
    1292        
     1292
    12931293        return res.val;
    12941294}
     
    12981298        float128_u res;
    12991299        res.data = uint64_to_float128(i);
    1300        
     1300
    13011301        return res.val;
    13021302}
     
    13061306        float128_u ua;
    13071307        ua.val = a;
    1308        
     1308
    13091309        return float128_to_int32(ua.data);
    13101310}
     
    13141314        float128_u ua;
    13151315        ua.val = a;
    1316        
     1316
    13171317        return float128_to_uint64(ua.data);
    13181318}
     
    13221322        float128_u ua;
    13231323        ua.val = a;
    1324        
     1324
    13251325        return float128_to_uint32(ua.data);
    13261326}
     
    13301330        float128_u ua;
    13311331        ua.val = a;
    1332        
     1332
    13331333        return float128_to_uint64(ua.data);
    13341334}
     
    13821382        float64_u ua;
    13831383        ua.val = a;
    1384        
     1384
    13851385        float32_u res;
    13861386        res.data = float64_to_float32(ua.data);
    1387        
     1387
    13881388        return res.val;
    13891389}
     
    13931393        float32_u ua;
    13941394        ua.val = a;
    1395        
     1395
    13961396        float64_u res;
    13971397        res.data = float32_to_float64(ua.data);
    1398        
     1398
    13991399        return res.val;
    14001400}
     
    14041404        float32_u ua;
    14051405        ua.val = a;
    1406        
     1406
    14071407        float64_u res;
    14081408        res.data = float32_to_float64(ua.data);
    1409        
     1409
    14101410        return res.val;
    14111411}
     
    14151415        float64_u ua;
    14161416        ua.val = a;
    1417        
     1417
    14181418        float32_u res;
    14191419        res.data = float64_to_float32(ua.data);
    1420        
     1420
    14211421        return res.val;
    14221422}
     
    14301430        float128_u ua;
    14311431        ua.val = a;
    1432        
     1432
    14331433        float32_u res;
    14341434        res.data = float128_to_float32(ua.data);
    1435        
     1435
    14361436        return res.val;
    14371437}
     
    14411441        float32_u ua;
    14421442        ua.val = a;
    1443        
     1443
    14441444        float128_u res;
    14451445        res.data = float32_to_float128(ua.data);
    1446        
     1446
    14471447        return res.val;
    14481448}
     
    14661466        float128_u ua;
    14671467        ua.val = a;
    1468        
     1468
    14691469        float64_u res;
    14701470        res.data = float128_to_float64(ua.data);
    1471        
     1471
    14721472        return res.val;
    14731473}
     
    14771477        float64_u ua;
    14781478        ua.val = a;
    1479        
     1479
    14801480        float128_u res;
    14811481        res.data = float64_to_float128(ua.data);
    1482        
     1482
    14831483        return res.val;
    14841484}
  • uspace/lib/softfloat/div.c

    r3061bc1 ra35b458  
    5353        int32_t aexp, bexp, cexp;
    5454        uint64_t afrac, bfrac, cfrac;
    55        
     55
    5656        result.parts.sign = a.parts.sign ^ b.parts.sign;
    57        
     57
    5858        if (is_float32_nan(a)) {
    5959                if (is_float32_signan(a)) {
     
    6363                return a;
    6464        }
    65        
     65
    6666        if (is_float32_nan(b)) {
    6767                if (is_float32_signan(b)) {
     
    7171                return b;
    7272        }
    73        
     73
    7474        if (is_float32_infinity(a)) {
    7575                if (is_float32_infinity(b)) {
     
    8383                return result;
    8484        }
    85        
     85
    8686        if (is_float32_infinity(b)) {
    8787                if (is_float32_zero(a)) {
     
    9696                return result;
    9797        }
    98        
     98
    9999        if (is_float32_zero(b)) {
    100100                if (is_float32_zero(a)) {
     
    108108                return result;
    109109        }
    110        
     110
    111111        afrac = a.parts.fraction;
    112112        aexp = a.parts.exp;
    113113        bfrac = b.parts.fraction;
    114114        bexp = b.parts.exp;
    115        
     115
    116116        /* denormalized numbers */
    117117        if (aexp == 0) {
     
    121121                        return result;
    122122                }
    123                
     123
    124124                /* normalize it*/
    125125                afrac <<= 1;
     
    130130                }
    131131        }
    132        
     132
    133133        if (bexp == 0) {
    134134                bfrac <<= 1;
     
    139139                }
    140140        }
    141        
     141
    142142        afrac = (afrac | FLOAT32_HIDDEN_BIT_MASK) << (32 - FLOAT32_FRACTION_SIZE - 1);
    143143        bfrac = (bfrac | FLOAT32_HIDDEN_BIT_MASK) << (32 - FLOAT32_FRACTION_SIZE);
    144        
     144
    145145        if (bfrac <= (afrac << 1)) {
    146146                afrac >>= 1;
    147147                aexp++;
    148148        }
    149        
     149
    150150        cexp = aexp - bexp + FLOAT32_BIAS - 2;
    151        
     151
    152152        cfrac = (afrac << 32) / bfrac;
    153153        if ((cfrac & 0x3F) == 0) {
    154154                cfrac |= (bfrac * cfrac != afrac << 32);
    155155        }
    156        
     156
    157157        /* pack and round */
    158        
     158
    159159        /* find first nonzero digit and shift result and detect possibly underflow */
    160160        while ((cexp > 0) && (cfrac) && (!(cfrac & (FLOAT32_HIDDEN_BIT_MASK << 7)))) {
     
    163163                /* TODO: fix underflow */
    164164        }
    165        
     165
    166166        cfrac += (0x1 << 6); /* FIXME: 7 is not sure*/
    167        
     167
    168168        if (cfrac & (FLOAT32_HIDDEN_BIT_MASK << 7)) {
    169169                ++cexp;
    170170                cfrac >>= 1;
    171171        }
    172        
     172
    173173        /* check overflow */
    174174        if (cexp >= FLOAT32_MAX_EXPONENT) {
     
    178178                return result;
    179179        }
    180        
     180
    181181        if (cexp < 0) {
    182182                /* FIXME: underflow */
     
    194194                result.parts.exp = (uint32_t) cexp;
    195195        }
    196        
     196
    197197        result.parts.fraction = ((cfrac >> 6) & (~FLOAT32_HIDDEN_BIT_MASK));
    198        
     198
    199199        return result;
    200200}
     
    215215        uint64_t remlo, remhi;
    216216        uint64_t tmplo, tmphi;
    217        
     217
    218218        result.parts.sign = a.parts.sign ^ b.parts.sign;
    219        
     219
    220220        if (is_float64_nan(a)) {
    221221                if (is_float64_signan(b)) {
     
    223223                        return b;
    224224                }
    225                
     225
    226226                if (is_float64_signan(a)) {
    227227                        // FIXME: SigNaN
     
    230230                return a;
    231231        }
    232        
     232
    233233        if (is_float64_nan(b)) {
    234234                if (is_float64_signan(b)) {
     
    238238                return b;
    239239        }
    240        
     240
    241241        if (is_float64_infinity(a)) {
    242242                if (is_float64_infinity(b) || is_float64_zero(b)) {
     
    250250                return result;
    251251        }
    252        
     252
    253253        if (is_float64_infinity(b)) {
    254254                if (is_float64_zero(a)) {
     
    263263                return result;
    264264        }
    265        
     265
    266266        if (is_float64_zero(b)) {
    267267                if (is_float64_zero(a)) {
     
    275275                return result;
    276276        }
    277        
     277
    278278        afrac = a.parts.fraction;
    279279        aexp = a.parts.exp;
    280280        bfrac = b.parts.fraction;
    281281        bexp = b.parts.exp;
    282        
     282
    283283        /* denormalized numbers */
    284284        if (aexp == 0) {
     
    288288                        return result;
    289289                }
    290                
     290
    291291                /* normalize it*/
    292292                aexp++;
     
    297297                }
    298298        }
    299        
     299
    300300        if (bexp == 0) {
    301301                bexp++;
     
    306306                }
    307307        }
    308        
     308
    309309        afrac = (afrac | FLOAT64_HIDDEN_BIT_MASK) << (64 - FLOAT64_FRACTION_SIZE - 2);
    310310        bfrac = (bfrac | FLOAT64_HIDDEN_BIT_MASK) << (64 - FLOAT64_FRACTION_SIZE - 1);
    311        
     311
    312312        if (bfrac <= (afrac << 1)) {
    313313                afrac >>= 1;
    314314                aexp++;
    315315        }
    316        
     316
    317317        cexp = aexp - bexp + FLOAT64_BIAS - 2;
    318        
     318
    319319        cfrac = div128est(afrac, 0x0ll, bfrac);
    320        
     320
    321321        if ((cfrac & 0x1FF) <= 2) {
    322322                mul64(bfrac, cfrac, &tmphi, &tmplo);
    323323                sub128(afrac, 0x0ll, tmphi, tmplo, &remhi, &remlo);
    324                
     324
    325325                while ((int64_t) remhi < 0) {
    326326                        cfrac--;
     
    329329                cfrac |= (remlo != 0);
    330330        }
    331        
     331
    332332        /* round and shift */
    333333        result = finish_float64(cexp, cfrac, result.parts.sign);
     
    351351        uint64_t rem_hihi, rem_hilo, rem_lohi, rem_lolo;
    352352        uint64_t tmp_hihi, tmp_hilo, tmp_lohi, tmp_lolo;
    353        
     353
    354354        result.parts.sign = a.parts.sign ^ b.parts.sign;
    355        
     355
    356356        if (is_float128_nan(a)) {
    357357                if (is_float128_signan(b)) {
     
    359359                        return b;
    360360                }
    361                
     361
    362362                if (is_float128_signan(a)) {
    363363                        // FIXME: SigNaN
     
    366366                return a;
    367367        }
    368        
     368
    369369        if (is_float128_nan(b)) {
    370370                if (is_float128_signan(b)) {
     
    374374                return b;
    375375        }
    376        
     376
    377377        if (is_float128_infinity(a)) {
    378378                if (is_float128_infinity(b) || is_float128_zero(b)) {
     
    388388                return result;
    389389        }
    390        
     390
    391391        if (is_float128_infinity(b)) {
    392392                if (is_float128_zero(a)) {
     
    403403                return result;
    404404        }
    405        
     405
    406406        if (is_float128_zero(b)) {
    407407                if (is_float128_zero(a)) {
     
    417417                return result;
    418418        }
    419        
     419
    420420        afrac_hi = a.parts.frac_hi;
    421421        afrac_lo = a.parts.frac_lo;
     
    424424        bfrac_lo = b.parts.frac_lo;
    425425        bexp = b.parts.exp;
    426        
     426
    427427        /* denormalized numbers */
    428428        if (aexp == 0) {
     
    433433                        return result;
    434434                }
    435                
     435
    436436                /* normalize it*/
    437437                aexp++;
     
    445445                }
    446446        }
    447        
     447
    448448        if (bexp == 0) {
    449449                bexp++;
     
    457457                }
    458458        }
    459        
     459
    460460        or128(afrac_hi, afrac_lo,
    461461            FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO,
     
    468468        lshift128(bfrac_hi, bfrac_lo,
    469469            (128 - FLOAT128_FRACTION_SIZE - 1), &bfrac_hi, &bfrac_lo);
    470        
     470
    471471        if (le128(bfrac_hi, bfrac_lo, afrac_hi, afrac_lo)) {
    472472                rshift128(afrac_hi, afrac_lo, 1, &afrac_hi, &afrac_lo);
    473473                aexp++;
    474474        }
    475        
     475
    476476        cexp = aexp - bexp + FLOAT128_BIAS - 2;
    477        
     477
    478478        cfrac_hi = div128est(afrac_hi, afrac_lo, bfrac_hi);
    479        
     479
    480480        mul128(bfrac_hi, bfrac_lo, 0x0ll, cfrac_hi,
    481481            &tmp_lolo /* dummy */, &tmp_hihi, &tmp_hilo, &tmp_lohi);
    482        
     482
    483483        /* sub192(afrac_hi, afrac_lo, 0,
    484484         *     tmp_hihi, tmp_hilo, tmp_lohi
     
    489489        }
    490490        rem_lohi = -tmp_lohi;
    491        
     491
    492492        while ((int64_t) rem_hihi < 0) {
    493493                --cfrac_hi;
     
    500500                }
    501501        }
    502        
     502
    503503        cfrac_lo = div128est(rem_hilo, rem_lohi, bfrac_lo);
    504        
     504
    505505        if ((cfrac_lo & 0x3FFF) <= 4) {
    506506                mul128(bfrac_hi, bfrac_lo, 0x0ll, cfrac_lo,
    507507                    &tmp_hihi /* dummy */, &tmp_hilo, &tmp_lohi, &tmp_lolo);
    508                
     508
    509509                /* sub192(rem_hilo, rem_lohi, 0,
    510510                 *     tmp_hilo, tmp_lohi, tmp_lolo,
     
    515515                }
    516516                rem_lolo = -tmp_lolo;
    517                
     517
    518518                while ((int64_t) rem_hilo < 0) {
    519519                        --cfrac_lo;
     
    526526                        }
    527527                }
    528                
     528
    529529                cfrac_lo |= ((rem_hilo | rem_lohi | rem_lolo) != 0 );
    530530        }
    531        
     531
    532532        shift_out = cfrac_lo << (64 - (128 - FLOAT128_FRACTION_SIZE - 1));
    533533        rshift128(cfrac_hi, cfrac_lo, (128 - FLOAT128_FRACTION_SIZE - 1),
    534534            &cfrac_hi, &cfrac_lo);
    535        
     535
    536536        result = finish_float128(cexp, cfrac_hi, cfrac_lo, result.parts.sign, shift_out);
    537537        return result;
     
    544544        float32_u ua;
    545545        ua.val = a;
    546        
     546
    547547        float32_u ub;
    548548        ub.val = b;
    549        
     549
    550550        float32_u res;
    551551        res.data = div_float32(ua.data, ub.data);
    552        
     552
    553553        return res.val;
    554554}
     
    558558        float32_u ua;
    559559        ua.val = a;
    560        
     560
    561561        float32_u ub;
    562562        ub.val = b;
    563        
     563
    564564        float32_u res;
    565565        res.data = div_float32(ua.data, ub.data);
    566        
     566
    567567        return res.val;
    568568}
     
    576576        float64_u ua;
    577577        ua.val = a;
    578        
     578
    579579        float64_u ub;
    580580        ub.val = b;
    581        
     581
    582582        float64_u res;
    583583        res.data = div_float64(ua.data, ub.data);
    584        
     584
    585585        return res.val;
    586586}
     
    590590        float64_u ua;
    591591        ua.val = a;
    592        
     592
    593593        float64_u ub;
    594594        ub.val = b;
    595        
     595
    596596        float64_u res;
    597597        res.data = div_float64(ua.data, ub.data);
    598        
     598
    599599        return res.val;
    600600}
     
    608608        float128_u ua;
    609609        ua.val = a;
    610        
     610
    611611        float128_u ub;
    612612        ub.val = b;
    613        
     613
    614614        float128_u res;
    615615        res.data = div_float128(ua.data, ub.data);
    616        
     616
    617617        return res.val;
    618618}
  • uspace/lib/softfloat/mul.c

    r3061bc1 ra35b458  
    5151        uint64_t frac1, frac2;
    5252        int32_t exp;
    53        
     53
    5454        result.parts.sign = a.parts.sign ^ b.parts.sign;
    55        
     55
    5656        if (is_float32_nan(a) || is_float32_nan(b)) {
    5757                /* TODO: fix SigNaNs */
     
    6161                        return result;
    6262                }
    63                
     63
    6464                if (is_float32_signan(b)) { /* TODO: fix SigNaN */
    6565                        result.parts.fraction = b.parts.fraction;
     
    6767                        return result;
    6868                }
    69                
     69
    7070                /* set NaN as result */
    7171                result.bin = FLOAT32_NAN;
    7272                return result;
    7373        }
    74        
     74
    7575        if (is_float32_infinity(a)) {
    7676                if (is_float32_zero(b)) {
     
    7979                        return result;
    8080                }
    81                
     81
    8282                result.parts.fraction = a.parts.fraction;
    8383                result.parts.exp = a.parts.exp;
    8484                return result;
    8585        }
    86        
     86
    8787        if (is_float32_infinity(b)) {
    8888                if (is_float32_zero(a)) {
     
    9191                        return result;
    9292                }
    93                
     93
    9494                result.parts.fraction = b.parts.fraction;
    9595                result.parts.exp = b.parts.exp;
    9696                return result;
    9797        }
    98        
     98
    9999        /* exp is signed so we can easy detect underflow */
    100100        exp = a.parts.exp + b.parts.exp;
    101101        exp -= FLOAT32_BIAS;
    102        
     102
    103103        if (exp >= FLOAT32_MAX_EXPONENT) {
    104104                /* FIXME: overflow */
     
    108108                return result;
    109109        }
    110        
     110
    111111        if (exp < 0) {
    112112                /* FIXME: underflow */
     
    116116                return result;
    117117        }
    118        
     118
    119119        frac1 = a.parts.fraction;
    120120        if (a.parts.exp > 0) {
     
    123123                ++exp;
    124124        }
    125        
     125
    126126        frac2 = b.parts.fraction;
    127        
     127
    128128        if (b.parts.exp > 0) {
    129129                frac2 |= FLOAT32_HIDDEN_BIT_MASK;
     
    131131                ++exp;
    132132        }
    133        
     133
    134134        frac1 <<= 1; /* one bit space for rounding */
    135        
     135
    136136        frac1 = frac1 * frac2;
    137        
     137
    138138        /* round and return */
    139139        while ((exp < FLOAT32_MAX_EXPONENT) &&
     
    143143                frac1 >>= 1;
    144144        }
    145        
     145
    146146        /* rounding */
    147147        /* ++frac1; FIXME: not works - without it is ok */
    148148        frac1 >>= 1; /* shift off rounding space */
    149        
     149
    150150        if ((exp < FLOAT32_MAX_EXPONENT) &&
    151151            (frac1 >= (1 << (FLOAT32_FRACTION_SIZE + 1)))) {
     
    153153                frac1 >>= 1;
    154154        }
    155        
     155
    156156        if (exp >= FLOAT32_MAX_EXPONENT) {
    157157                /* TODO: fix overflow */
     
    161161                return result;
    162162        }
    163        
     163
    164164        exp -= FLOAT32_FRACTION_SIZE;
    165        
     165
    166166        if (exp <= FLOAT32_FRACTION_SIZE) {
    167167                /* denormalized number */
    168168                frac1 >>= 1; /* denormalize */
    169                
     169
    170170                while ((frac1 > 0) && (exp < 0)) {
    171171                        frac1 >>= 1;
    172172                        ++exp;
    173173                }
    174                
     174
    175175                if (frac1 == 0) {
    176176                        /* FIXME : underflow */
     
    180180                }
    181181        }
    182        
     182
    183183        result.parts.exp = exp;
    184184        result.parts.fraction = frac1 & ((1 << FLOAT32_FRACTION_SIZE) - 1);
    185        
     185
    186186        return result;
    187187}
     
    200200        uint64_t frac1, frac2;
    201201        int32_t exp;
    202        
     202
    203203        result.parts.sign = a.parts.sign ^ b.parts.sign;
    204        
     204
    205205        if (is_float64_nan(a) || is_float64_nan(b)) {
    206206                /* TODO: fix SigNaNs */
     
    219219                return result;
    220220        }
    221        
     221
    222222        if (is_float64_infinity(a)) {
    223223                if (is_float64_zero(b)) {
     
    230230                return result;
    231231        }
    232        
     232
    233233        if (is_float64_infinity(b)) {
    234234                if (is_float64_zero(a)) {
     
    241241                return result;
    242242        }
    243        
     243
    244244        /* exp is signed so we can easy detect underflow */
    245245        exp = a.parts.exp + b.parts.exp - FLOAT64_BIAS;
    246        
     246
    247247        frac1 = a.parts.fraction;
    248        
     248
    249249        if (a.parts.exp > 0) {
    250250                frac1 |= FLOAT64_HIDDEN_BIT_MASK;
     
    252252                ++exp;
    253253        }
    254        
     254
    255255        frac2 = b.parts.fraction;
    256        
     256
    257257        if (b.parts.exp > 0) {
    258258                frac2 |= FLOAT64_HIDDEN_BIT_MASK;
     
    260260                ++exp;
    261261        }
    262        
     262
    263263        frac1 <<= (64 - FLOAT64_FRACTION_SIZE - 1);
    264264        frac2 <<= (64 - FLOAT64_FRACTION_SIZE - 2);
    265        
     265
    266266        mul64(frac1, frac2, &frac1, &frac2);
    267        
     267
    268268        frac1 |= (frac2 != 0);
    269269        if (frac1 & (0x1ll << 62)) {
     
    271271                exp--;
    272272        }
    273        
     273
    274274        result = finish_float64(exp, frac1, result.parts.sign);
    275275        return result;
     
    289289        uint64_t frac1_hi, frac1_lo, frac2_hi, frac2_lo, tmp_hi, tmp_lo;
    290290        int32_t exp;
    291        
     291
    292292        result.parts.sign = a.parts.sign ^ b.parts.sign;
    293        
     293
    294294        if (is_float128_nan(a) || is_float128_nan(b)) {
    295295                /* TODO: fix SigNaNs */
     
    311311                return result;
    312312        }
    313        
     313
    314314        if (is_float128_infinity(a)) {
    315315                if (is_float128_zero(b)) {
     
    324324                return result;
    325325        }
    326        
     326
    327327        if (is_float128_infinity(b)) {
    328328                if (is_float128_zero(a)) {
     
    337337                return result;
    338338        }
    339        
     339
    340340        /* exp is signed so we can easy detect underflow */
    341341        exp = a.parts.exp + b.parts.exp - FLOAT128_BIAS - 1;
    342        
     342
    343343        frac1_hi = a.parts.frac_hi;
    344344        frac1_lo = a.parts.frac_lo;
    345        
     345
    346346        if (a.parts.exp > 0) {
    347347                or128(frac1_hi, frac1_lo,
     
    351351                ++exp;
    352352        }
    353        
     353
    354354        frac2_hi = b.parts.frac_hi;
    355355        frac2_lo = b.parts.frac_lo;
    356        
     356
    357357        if (b.parts.exp > 0) {
    358358                or128(frac2_hi, frac2_lo,
     
    362362                ++exp;
    363363        }
    364        
     364
    365365        lshift128(frac2_hi, frac2_lo,
    366366            128 - FLOAT128_FRACTION_SIZE, &frac2_hi, &frac2_lo);
    367        
     367
    368368        tmp_hi = frac1_hi;
    369369        tmp_lo = frac1_lo;
     
    372372        add128(frac1_hi, frac1_lo, tmp_hi, tmp_lo, &frac1_hi, &frac1_lo);
    373373        frac2_hi |= (frac2_lo != 0x0ll);
    374        
     374
    375375        if ((FLOAT128_HIDDEN_BIT_MASK_HI << 1) <= frac1_hi) {
    376376                frac2_hi >>= 1;
     
    381381                ++exp;
    382382        }
    383        
     383
    384384        result = finish_float128(exp, frac1_hi, frac1_lo, result.parts.sign, frac2_hi);
    385385        return result;
     
    392392        float32_u ua;
    393393        ua.val = a;
    394        
     394
    395395        float32_u ub;
    396396        ub.val = b;
    397        
     397
    398398        float32_u res;
    399399        res.data = mul_float32(ua.data, ub.data);
    400        
     400
    401401        return res.val;
    402402}
     
    406406        float32_u ua;
    407407        ua.val = a;
    408        
     408
    409409        float32_u ub;
    410410        ub.val = b;
    411        
     411
    412412        float32_u res;
    413413        res.data = mul_float32(ua.data, ub.data);
    414        
     414
    415415        return res.val;
    416416}
     
    424424        float64_u ua;
    425425        ua.val = a;
    426        
     426
    427427        float64_u ub;
    428428        ub.val = b;
    429        
     429
    430430        float64_u res;
    431431        res.data = mul_float64(ua.data, ub.data);
    432        
     432
    433433        return res.val;
    434434}
     
    438438        float64_u ua;
    439439        ua.val = a;
    440        
     440
    441441        float64_u ub;
    442442        ub.val = b;
    443        
     443
    444444        float64_u res;
    445445        res.data = mul_float64(ua.data, ub.data);
    446        
     446
    447447        return res.val;
    448448}
     
    456456        float128_u ua;
    457457        ua.val = a;
    458        
     458
    459459        float128_u ub;
    460460        ub.val = b;
    461        
     461
    462462        float128_u res;
    463463        res.data = mul_float128(ua.data, ub.data);
    464        
     464
    465465        return res.val;
    466466}
  • uspace/lib/softfloat/neg.c

    r3061bc1 ra35b458  
    4343        float32_u ua;
    4444        ua.val = a;
    45        
     45
    4646        ua.data.parts.sign = !ua.data.parts.sign;
    47        
     47
    4848        return ua.val;
    4949}
     
    5757        float64_u ua;
    5858        ua.val = a;
    59        
     59
    6060        ua.data.parts.sign = !ua.data.parts.sign;
    61        
     61
    6262        return ua.val;
    6363}
     
    7171        float128_u ua;
    7272        ua.val = a;
    73        
     73
    7474        ua.data.parts.sign = !ua.data.parts.sign;
    75        
     75
    7676        return ua.val;
    7777}
  • uspace/lib/softfloat/sub.c

    r3061bc1 ra35b458  
    5252        uint32_t exp1, exp2, frac1, frac2;
    5353        float32 result;
    54        
     54
    5555        result.bin = 0;
    56        
     56
    5757        expdiff = a.parts.exp - b.parts.exp;
    5858        if ((expdiff < 0 ) || ((expdiff == 0) &&
     
    6262                                // TODO: fix SigNaN
    6363                        }
    64                        
     64
    6565                        return b;
    6666                }
    67                
     67
    6868                if (b.parts.exp == FLOAT32_MAX_EXPONENT) {
    6969                        /* num -(+-inf) = -+inf */
     
    7171                        return b;
    7272                }
    73                
     73
    7474                result.parts.sign = !a.parts.sign;
    75                
     75
    7676                frac1 = b.parts.fraction;
    7777                exp1 = b.parts.exp;
     
    8484                                // TODO: fix SigNaN
    8585                        }
    86                        
     86
    8787                        return a;
    8888                }
    89                
     89
    9090                if (a.parts.exp == FLOAT32_MAX_EXPONENT) {
    9191                        if (b.parts.exp == FLOAT32_MAX_EXPONENT) {
     
    9595                                return result;
    9696                        }
    97                        
     97
    9898                        return a;
    9999                }
    100                
     100
    101101                result.parts.sign = a.parts.sign;
    102                
     102
    103103                frac1 = a.parts.fraction;
    104104                exp1 = a.parts.exp;
     
    106106                exp2 = b.parts.exp;
    107107        }
    108        
     108
    109109        if (exp1 == 0) {
    110110                /* both are denormalized */
     
    114114                        return result;
    115115                }
    116                
     116
    117117                result.parts.exp = 0;
    118118                return result;
    119119        }
    120        
     120
    121121        /* add hidden bit */
    122122        frac1 |= FLOAT32_HIDDEN_BIT_MASK;
    123        
     123
    124124        if (exp2 == 0) {
    125125                /* denormalized */
     
    129129                frac2 |= FLOAT32_HIDDEN_BIT_MASK;
    130130        }
    131        
     131
    132132        /* create some space for rounding */
    133133        frac1 <<= 6;
    134134        frac2 <<= 6;
    135        
     135
    136136        if (expdiff > FLOAT32_FRACTION_SIZE + 1)
    137137                goto done;
    138        
     138
    139139        frac1 = frac1 - (frac2 >> expdiff);
    140        
     140
    141141done:
    142142        /* TODO: find first nonzero digit and shift result and detect possibly underflow */
     
    146146                /* TODO: fix underflow - frac1 == 0 does not necessary means underflow... */
    147147        }
    148        
     148
    149149        /* rounding - if first bit after fraction is set then round up */
    150150        frac1 += 0x20;
    151        
     151
    152152        if (frac1 & (FLOAT32_HIDDEN_BIT_MASK << 7)) {
    153153                ++exp1;
    154154                frac1 >>= 1;
    155155        }
    156        
     156
    157157        /* Clear hidden bit and shift */
    158158        result.parts.fraction = ((frac1 >> 6) & (~FLOAT32_HIDDEN_BIT_MASK));
    159159        result.parts.exp = exp1;
    160        
     160
    161161        return result;
    162162}
     
    176176        uint64_t frac1, frac2;
    177177        float64 result;
    178        
     178
    179179        result.bin = 0;
    180        
     180
    181181        expdiff = a.parts.exp - b.parts.exp;
    182182        if ((expdiff < 0 ) ||
     
    186186                                // TODO: fix SigNaN
    187187                        }
    188                        
     188
    189189                        return b;
    190190                }
    191                
     191
    192192                if (b.parts.exp == FLOAT64_MAX_EXPONENT) {
    193193                        /* num -(+-inf) = -+inf */
     
    195195                        return b;
    196196                }
    197                
     197
    198198                result.parts.sign = !a.parts.sign;
    199                
     199
    200200                frac1 = b.parts.fraction;
    201201                exp1 = b.parts.exp;
     
    208208                                // TODO: fix SigNaN
    209209                        }
    210                        
     210
    211211                        return a;
    212212                }
    213                
     213
    214214                if (a.parts.exp == FLOAT64_MAX_EXPONENT) {
    215215                        if (b.parts.exp == FLOAT64_MAX_EXPONENT) {
     
    219219                                return result;
    220220                        }
    221                        
     221
    222222                        return a;
    223223                }
    224                
     224
    225225                result.parts.sign = a.parts.sign;
    226                
     226
    227227                frac1 = a.parts.fraction;
    228228                exp1 = a.parts.exp;
     
    230230                exp2 = b.parts.exp;
    231231        }
    232        
     232
    233233        if (exp1 == 0) {
    234234                /* both are denormalized */
     
    238238                        return result;
    239239                }
    240                
     240
    241241                result.parts.exp = 0;
    242242                return result;
    243243        }
    244        
     244
    245245        /* add hidden bit */
    246246        frac1 |= FLOAT64_HIDDEN_BIT_MASK;
    247        
     247
    248248        if (exp2 == 0) {
    249249                /* denormalized */
     
    253253                frac2 |= FLOAT64_HIDDEN_BIT_MASK;
    254254        }
    255        
     255
    256256        /* create some space for rounding */
    257257        frac1 <<= 6;
    258258        frac2 <<= 6;
    259        
     259
    260260        if (expdiff > FLOAT64_FRACTION_SIZE + 1)
    261261                goto done;
    262        
     262
    263263        frac1 = frac1 - (frac2 >> expdiff);
    264        
     264
    265265done:
    266266        /* TODO: find first nonzero digit and shift result and detect possibly underflow */
     
    270270                /* TODO: fix underflow - frac1 == 0 does not necessary means underflow... */
    271271        }
    272        
     272
    273273        /* rounding - if first bit after fraction is set then round up */
    274274        frac1 += 0x20;
    275        
     275
    276276        if (frac1 & (FLOAT64_HIDDEN_BIT_MASK << 7)) {
    277277                ++exp1;
    278278                frac1 >>= 1;
    279279        }
    280        
     280
    281281        /* Clear hidden bit and shift */
    282282        result.parts.fraction = ((frac1 >> 6) & (~FLOAT64_HIDDEN_BIT_MASK));
    283283        result.parts.exp = exp1;
    284        
     284
    285285        return result;
    286286}
     
    300300        uint64_t frac1_hi, frac1_lo, frac2_hi, frac2_lo, tmp_hi, tmp_lo;
    301301        float128 result;
    302        
     302
    303303        result.bin.hi = 0;
    304304        result.bin.lo = 0;
    305        
     305
    306306        expdiff = a.parts.exp - b.parts.exp;
    307307        if ((expdiff < 0 ) || ((expdiff == 0) &&
     
    311311                                // TODO: fix SigNaN
    312312                        }
    313                        
     313
    314314                        return b;
    315315                }
    316                
     316
    317317                if (b.parts.exp == FLOAT128_MAX_EXPONENT) {
    318318                        /* num -(+-inf) = -+inf */
     
    320320                        return b;
    321321                }
    322                
     322
    323323                result.parts.sign = !a.parts.sign;
    324                
     324
    325325                frac1_hi = b.parts.frac_hi;
    326326                frac1_lo = b.parts.frac_lo;
     
    335335                                // TODO: fix SigNaN
    336336                        }
    337                        
     337
    338338                        return a;
    339339                }
    340                
     340
    341341                if (a.parts.exp == FLOAT128_MAX_EXPONENT) {
    342342                        if (b.parts.exp == FLOAT128_MAX_EXPONENT) {
     
    349349                        return a;
    350350                }
    351                
     351
    352352                result.parts.sign = a.parts.sign;
    353                
     353
    354354                frac1_hi = a.parts.frac_hi;
    355355                frac1_lo = a.parts.frac_lo;
     
    359359                exp2 = b.parts.exp;
    360360        }
    361        
     361
    362362        if (exp1 == 0) {
    363363                /* both are denormalized */
     
    369369                        return result;
    370370                }
    371                
     371
    372372                result.parts.exp = 0;
    373373                return result;
    374374        }
    375        
     375
    376376        /* add hidden bit */
    377377        or128(frac1_hi, frac1_lo,
    378378            FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO,
    379379            &frac1_hi, &frac1_lo);
    380        
     380
    381381        if (exp2 == 0) {
    382382                /* denormalized */
     
    388388                    &frac2_hi, &frac2_lo);
    389389        }
    390        
     390
    391391        /* create some space for rounding */
    392392        lshift128(frac1_hi, frac1_lo, 6, &frac1_hi, &frac1_lo);
    393393        lshift128(frac2_hi, frac2_lo, 6, &frac2_hi, &frac2_lo);
    394        
     394
    395395        if (expdiff > FLOAT128_FRACTION_SIZE + 1)
    396396                goto done;
    397        
     397
    398398        rshift128(frac2_hi, frac2_lo, expdiff, &tmp_hi, &tmp_lo);
    399399        sub128(frac1_hi, frac1_lo, tmp_hi, tmp_lo, &frac1_hi, &frac1_lo);
    400        
     400
    401401done:
    402402        /* TODO: find first nonzero digit and shift result and detect possibly underflow */
     
    408408                lshift128(frac1_hi, frac1_lo, 1, &frac1_hi, &frac1_lo);
    409409                /* TODO: fix underflow - frac1 == 0 does not necessary means underflow... */
    410                
     410
    411411                lshift128(FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO, 6,
    412412                    &tmp_hi, &tmp_lo);
    413413                and128(frac1_hi, frac1_lo, tmp_hi, tmp_lo, &tmp_hi, &tmp_lo);
    414414        }
    415        
     415
    416416        /* rounding - if first bit after fraction is set then round up */
    417417        add128(frac1_hi, frac1_lo, 0x0ll, 0x20ll, &frac1_hi, &frac1_lo);
    418        
     418
    419419        lshift128(FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO, 7,
    420420           &tmp_hi, &tmp_lo);
     
    424424                rshift128(frac1_hi, frac1_lo, 1, &frac1_hi, &frac1_lo);
    425425        }
    426        
     426
    427427        /* Clear hidden bit and shift */
    428428        rshift128(frac1_hi, frac1_lo, 6, &frac1_hi, &frac1_lo);
     
    432432        result.parts.frac_hi = tmp_hi;
    433433        result.parts.frac_lo = tmp_lo;
    434        
     434
    435435        result.parts.exp = exp1;
    436        
     436
    437437        return result;
    438438}
     
    444444        float32_u ua;
    445445        ua.val = a;
    446        
     446
    447447        float32_u ub;
    448448        ub.val = b;
    449        
     449
    450450        float32_u res;
    451        
     451
    452452        if (ua.data.parts.sign != ub.data.parts.sign) {
    453453                ub.data.parts.sign = !ub.data.parts.sign;
     
    455455        } else
    456456                res.data = sub_float32(ua.data, ub.data);
    457        
     457
    458458        return res.val;
    459459}
     
    463463        float32_u ua;
    464464        ua.val = a;
    465        
     465
    466466        float32_u ub;
    467467        ub.val = b;
    468        
     468
    469469        float32_u res;
    470        
     470
    471471        if (ua.data.parts.sign != ub.data.parts.sign) {
    472472                ub.data.parts.sign = !ub.data.parts.sign;
     
    474474        } else
    475475                res.data = sub_float32(ua.data, ub.data);
    476        
     476
    477477        return res.val;
    478478}
     
    486486        float64_u ua;
    487487        ua.val = a;
    488        
     488
    489489        float64_u ub;
    490490        ub.val = b;
    491        
     491
    492492        float64_u res;
    493        
     493
    494494        if (ua.data.parts.sign != ub.data.parts.sign) {
    495495                ub.data.parts.sign = !ub.data.parts.sign;
     
    497497        } else
    498498                res.data = sub_float64(ua.data, ub.data);
    499        
     499
    500500        return res.val;
    501501}
     
    505505        float64_u ua;
    506506        ua.val = a;
    507        
     507
    508508        float64_u ub;
    509509        ub.val = b;
    510        
     510
    511511        float64_u res;
    512        
     512
    513513        if (ua.data.parts.sign != ub.data.parts.sign) {
    514514                ub.data.parts.sign = !ub.data.parts.sign;
     
    516516        } else
    517517                res.data = sub_float64(ua.data, ub.data);
    518        
     518
    519519        return res.val;
    520520}
     
    528528        float128_u ua;
    529529        ua.val = a;
    530        
     530
    531531        float128_u ub;
    532532        ub.val = b;
    533        
     533
    534534        float128_u res;
    535        
     535
    536536        if (ua.data.parts.sign != ub.data.parts.sign) {
    537537                ub.data.parts.sign = !ub.data.parts.sign;
     
    539539        } else
    540540                res.data = sub_float128(ua.data, ub.data);
    541        
     541
    542542        return res.val;
    543543}
Note: See TracChangeset for help on using the changeset viewer.