Changeset 8565a42 in mainline for uspace/lib/softfloat/mul.c


Ignore:
Timestamp:
2018-03-02T20:34:50Z (7 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.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • 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}
Note: See TracChangeset for help on using the changeset viewer.