Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/softfloat/add.c

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