Ignore:
File:
1 edited

Legend:

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

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