Changeset 8565a42 in mainline for uspace/lib/softfloat


Ignore:
Timestamp:
2018-03-02T20:34:50Z (8 years ago)
Author:
GitHub <noreply@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
a1a81f69, d5e5fd1
Parents:
3061bc1 (diff), 34e1206 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
git-author:
Jiří Zárevúcky <zarevucky.jiri@…> (2018-03-02 20:34:50)
git-committer:
GitHub <noreply@…> (2018-03-02 20:34:50)
Message:

Remove all trailing whitespace, everywhere.

See individual commit messages for details.

Location:
uspace/lib/softfloat
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/softfloat/add.c

    r3061bc1 r8565a42  
    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 r8565a42  
    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 r8565a42  
    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 r8565a42  
    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 r8565a42  
    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 r8565a42  
    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 r8565a42  
    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 r8565a42  
    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.