Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/softfloat/mul.c

    ra35b458 r1b20da0  
    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.