Ignore:
File:
1 edited

Legend:

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

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