Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/softfloat/generic/div.c

    r9d58539 r88d5c1e  
    4141#include <common.h>
    4242
    43 /**
    44  * Divide two single-precision floats.
    45  *
     43/** Divide two single-precision floats.
     44 *
    4645 * @param a Nominator.
    4746 * @param b Denominator.
     47 *
    4848 * @return Result of division.
    49  */
    50 float32 divFloat32(float32 a, float32 b)
     49 *
     50 */
     51float32 div_float32(float32 a, float32 b)
    5152{
    5253        float32 result;
    … …  
    5657        result.parts.sign = a.parts.sign ^ b.parts.sign;
    5758       
    58         if (isFloat32NaN(a)) {
    59                 if (isFloat32SigNaN(a)) {
    60                         /*FIXME: SigNaN*/
    61                 }
    62                 /*NaN*/
     59        if (is_float32_nan(a)) {
     60                if (is_float32_signan(a)) {
     61                        // FIXME: SigNaN
     62                }
     63                /* NaN */
    6364                return a;
    6465        }
    6566       
    66         if (isFloat32NaN(b)) {
    67                 if (isFloat32SigNaN(b)) {
    68                         /*FIXME: SigNaN*/
    69                 }
    70                 /*NaN*/
     67        if (is_float32_nan(b)) {
     68                if (is_float32_signan(b)) {
     69                        // FIXME: SigNaN
     70                }
     71                /* NaN */
    7172                return b;
    7273        }
    7374       
    74         if (isFloat32Infinity(a)) {
    75                 if (isFloat32Infinity(b)) {
     75        if (is_float32_infinity(a)) {
     76                if (is_float32_infinity(b)) {
    7677                        /*FIXME: inf / inf */
    77                         result.binary = FLOAT32_NAN;
     78                        result.bin = FLOAT32_NAN;
    7879                        return result;
    7980                }
    … …  
    8384                return result;
    8485        }
    85 
    86         if (isFloat32Infinity(b)) {
    87                 if (isFloat32Zero(a)) {
     86       
     87        if (is_float32_infinity(b)) {
     88                if (is_float32_zero(a)) {
    8889                        /* FIXME 0 / inf */
    8990                        result.parts.exp = 0;
    … …  
    9798        }
    9899       
    99         if (isFloat32Zero(b)) {
    100                 if (isFloat32Zero(a)) {
     100        if (is_float32_zero(b)) {
     101                if (is_float32_zero(a)) {
    101102                        /*FIXME: 0 / 0*/
    102                         result.binary = FLOAT32_NAN;
     103                        result.bin = FLOAT32_NAN;
    103104                        return result;
    104105                }
    … …  
    121122                        return result;
    122123                }
    123 
     124               
    124125                /* normalize it*/
    125126                afrac <<= 1;
    126                 /* afrac is nonzero => it must stop */ 
     127                /* afrac is nonzero => it must stop */
    127128                while (!(afrac & FLOAT32_HIDDEN_BIT_MASK)) {
    128129                        afrac <<= 1;
    … …  
    130131                }
    131132        }
    132 
     133       
    133134        if (bexp == 0) {
    134135                bfrac <<= 1;
    135                 /* bfrac is nonzero => it must stop */ 
     136                /* bfrac is nonzero => it must stop */
    136137                while (!(bfrac & FLOAT32_HIDDEN_BIT_MASK)) {
    137138                        bfrac <<= 1;
    … …  
    139140                }
    140141        }
    141 
    142         afrac = (afrac | FLOAT32_HIDDEN_BIT_MASK) << (32 - FLOAT32_FRACTION_SIZE - 1);
    143         bfrac = (bfrac | FLOAT32_HIDDEN_BIT_MASK) << (32 - FLOAT32_FRACTION_SIZE);
    144 
     142       
     143        afrac = (afrac | FLOAT32_HIDDEN_BIT_MASK) << (32 - FLOAT32_FRACTION_SIZE - 1);
     144        bfrac = (bfrac | FLOAT32_HIDDEN_BIT_MASK) << (32 - FLOAT32_FRACTION_SIZE);
     145       
    145146        if (bfrac <= (afrac << 1)) {
    146147                afrac >>= 1;
    … …  
    169170                ++cexp;
    170171                cfrac >>= 1;
    171         }       
    172 
     172        }
     173       
    173174        /* check overflow */
    174175        if (cexp >= FLOAT32_MAX_EXPONENT) {
    … …  
    178179                return result;
    179180        }
    180 
     181       
    181182        if (cexp < 0) {
    182183                /* FIXME: underflow */
    … …  
    190191                        cexp++;
    191192                        cfrac >>= 1;
    192                 }       
     193                }
    193194        } else {
    194195                result.parts.exp = (uint32_t) cexp;
    … …  
    197198        result.parts.fraction = ((cfrac >> 6) & (~FLOAT32_HIDDEN_BIT_MASK));
    198199       
    199         return result; 
     200        return result;
    200201}
    201202
    202 /**
    203  * Divide two double-precision floats.
     203/** Divide two double-precision floats.
    204204 *
    205205 * @param a Nominator.
    206206 * @param b Denominator.
     207 *
    207208 * @return Result of division.
    208  */
    209 float64 divFloat64(float64 a, float64 b)
     209 *
     210 */
     211float64 div_float64(float64 a, float64 b)
    210212{
    211213        float64 result;
    … …  
    217219        result.parts.sign = a.parts.sign ^ b.parts.sign;
    218220       
    219         if (isFloat64NaN(a)) {
    220                 if (isFloat64SigNaN(b)) {
    221                         /*FIXME: SigNaN*/
     221        if (is_float64_nan(a)) {
     222                if (is_float64_signan(b)) {
     223                        // FIXME: SigNaN
    222224                        return b;
    223225                }
    224226               
    225                 if (isFloat64SigNaN(a)) {
    226                         /*FIXME: SigNaN*/
    227                 }
    228                 /*NaN*/
     227                if (is_float64_signan(a)) {
     228                        // FIXME: SigNaN
     229                }
     230                /* NaN */
    229231                return a;
    230232        }
    231233       
    232         if (isFloat64NaN(b)) {
    233                 if (isFloat64SigNaN(b)) {
    234                         /*FIXME: SigNaN*/
    235                 }
    236                 /*NaN*/
     234        if (is_float64_nan(b)) {
     235                if (is_float64_signan(b)) {
     236                        // FIXME: SigNaN
     237                }
     238                /* NaN */
    237239                return b;
    238240        }
    239241       
    240         if (isFloat64Infinity(a)) {
    241                 if (isFloat64Infinity(b) || isFloat64Zero(b)) {
    242                         /*FIXME: inf / inf */
    243                         result.binary = FLOAT64_NAN;
     242        if (is_float64_infinity(a)) {
     243                if (is_float64_infinity(b) || is_float64_zero(b)) {
     244                        // FIXME: inf / inf
     245                        result.bin = FLOAT64_NAN;
    244246                        return result;
    245247                }
    … …  
    249251                return result;
    250252        }
    251 
    252         if (isFloat64Infinity(b)) {
    253                 if (isFloat64Zero(a)) {
     253       
     254        if (is_float64_infinity(b)) {
     255                if (is_float64_zero(a)) {
    254256                        /* FIXME 0 / inf */
    255257                        result.parts.exp = 0;
    … …  
    263265        }
    264266       
    265         if (isFloat64Zero(b)) {
    266                 if (isFloat64Zero(a)) {
     267        if (is_float64_zero(b)) {
     268                if (is_float64_zero(a)) {
    267269                        /*FIXME: 0 / 0*/
    268                         result.binary = FLOAT64_NAN;
     270                        result.bin = FLOAT64_NAN;
    269271                        return result;
    270272                }
    … …  
    274276                return result;
    275277        }
    276 
     278       
    277279        afrac = a.parts.fraction;
    278280        aexp = a.parts.exp;
    … …  
    287289                        return result;
    288290                }
    289 
     291               
    290292                /* normalize it*/
    291293                aexp++;
    … …  
    296298                }
    297299        }
    298 
     300       
    299301        if (bexp == 0) {
    300302                bexp++;
    … …  
    305307                }
    306308        }
    307 
    308         afrac = (afrac | FLOAT64_HIDDEN_BIT_MASK) << (64 - FLOAT64_FRACTION_SIZE - 2);
    309         bfrac = (bfrac | FLOAT64_HIDDEN_BIT_MASK) << (64 - FLOAT64_FRACTION_SIZE - 1);
    310 
     309       
     310        afrac = (afrac | FLOAT64_HIDDEN_BIT_MASK) << (64 - FLOAT64_FRACTION_SIZE - 2);
     311        bfrac = (bfrac | FLOAT64_HIDDEN_BIT_MASK) << (64 - FLOAT64_FRACTION_SIZE - 1);
     312       
    311313        if (bfrac <= (afrac << 1)) {
    312314                afrac >>= 1;
    … …  
    330332       
    331333        /* round and shift */
    332         result = finishFloat64(cexp, cfrac, result.parts.sign);
     334        result = finish_float64(cexp, cfrac, result.parts.sign);
    333335        return result;
    334336}
    335337
    336 /**
    337  * Divide two quadruple-precision floats.
     338/** Divide two quadruple-precision floats.
    338339 *
    339340 * @param a Nominator.
    340341 * @param b Denominator.
     342 *
    341343 * @return Result of division.
    342  */
    343 float128 divFloat128(float128 a, float128 b)
     344 *
     345 */
     346float128 div_float128(float128 a, float128 b)
    344347{
    345348        float128 result;
    … …  
    349352        uint64_t rem_hihi, rem_hilo, rem_lohi, rem_lolo;
    350353        uint64_t tmp_hihi, tmp_hilo, tmp_lohi, tmp_lolo;
    351 
     354       
    352355        result.parts.sign = a.parts.sign ^ b.parts.sign;
    353 
    354         if (isFloat128NaN(a)) {
    355                 if (isFloat128SigNaN(b)) {
    356                         /*FIXME: SigNaN*/
     356       
     357        if (is_float128_nan(a)) {
     358                if (is_float128_signan(b)) {
     359                        // FIXME: SigNaN
    357360                        return b;
    358361                }
    359 
    360                 if (isFloat128SigNaN(a)) {
    361                         /*FIXME: SigNaN*/
    362                 }
    363                 /*NaN*/
     362               
     363                if (is_float128_signan(a)) {
     364                        // FIXME: SigNaN
     365                }
     366                /* NaN */
    364367                return a;
    365368        }
    366 
    367         if (isFloat128NaN(b)) {
    368                 if (isFloat128SigNaN(b)) {
    369                         /*FIXME: SigNaN*/
    370                 }
    371                 /*NaN*/
     369       
     370        if (is_float128_nan(b)) {
     371                if (is_float128_signan(b)) {
     372                        // FIXME: SigNaN
     373                }
     374                /* NaN */
    372375                return b;
    373376        }
    374 
    375         if (isFloat128Infinity(a)) {
    376                 if (isFloat128Infinity(b) || isFloat128Zero(b)) {
    377                         /*FIXME: inf / inf */
    378                         result.binary.hi = FLOAT128_NAN_HI;
    379                         result.binary.lo = FLOAT128_NAN_LO;
     377       
     378        if (is_float128_infinity(a)) {
     379                if (is_float128_infinity(b) || is_float128_zero(b)) {
     380                        // FIXME: inf / inf
     381                        result.bin.hi = FLOAT128_NAN_HI;
     382                        result.bin.lo = FLOAT128_NAN_LO;
    380383                        return result;
    381384                }
    … …  
    386389                return result;
    387390        }
    388 
    389         if (isFloat128Infinity(b)) {
    390                 if (isFloat128Zero(a)) {
    391                         /* FIXME 0 / inf */
     391       
     392        if (is_float128_infinity(b)) {
     393                if (is_float128_zero(a)) {
     394                        // FIXME 0 / inf
    392395                        result.parts.exp = 0;
    393396                        result.parts.frac_hi = 0;
    … …  
    395398                        return result;
    396399                }
    397                 /* FIXME: num / inf*/
     400                // FIXME: num / inf
    398401                result.parts.exp = 0;
    399402                result.parts.frac_hi = 0;
    … …  
    401404                return result;
    402405        }
    403 
    404         if (isFloat128Zero(b)) {
    405                 if (isFloat128Zero(a)) {
    406                         /*FIXME: 0 / 0*/
    407                         result.binary.hi = FLOAT128_NAN_HI;
    408                         result.binary.lo = FLOAT128_NAN_LO;
    409                         return result;
    410                 }
    411                 /* FIXME: division by zero */
     406       
     407        if (is_float128_zero(b)) {
     408                if (is_float128_zero(a)) {
     409                        // FIXME: 0 / 0
     410                        result.bin.hi = FLOAT128_NAN_HI;
     411                        result.bin.lo = FLOAT128_NAN_LO;
     412                        return result;
     413                }
     414                // FIXME: division by zero
    412415                result.parts.exp = 0;
    413416                result.parts.frac_hi = 0;
    … …  
    415418                return result;
    416419        }
    417 
     420       
    418421        afrac_hi = a.parts.frac_hi;
    419422        afrac_lo = a.parts.frac_lo;
    … …  
    422425        bfrac_lo = b.parts.frac_lo;
    423426        bexp = b.parts.exp;
    424 
     427       
    425428        /* denormalized numbers */
    426429        if (aexp == 0) {
    … …  
    431434                        return result;
    432435                }
    433 
     436               
    434437                /* normalize it*/
    435438                aexp++;
    … …  
    443446                }
    444447        }
    445 
     448       
    446449        if (bexp == 0) {
    447450                bexp++;
    … …  
    455458                }
    456459        }
    457 
     460       
    458461        or128(afrac_hi, afrac_lo,
    459462            FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO,
    … …  
    466469        lshift128(bfrac_hi, bfrac_lo,
    467470            (128 - FLOAT128_FRACTION_SIZE - 1), &bfrac_hi, &bfrac_lo);
    468 
     471       
    469472        if (le128(bfrac_hi, bfrac_lo, afrac_hi, afrac_lo)) {
    470473                rshift128(afrac_hi, afrac_lo, 1, &afrac_hi, &afrac_lo);
    471474                aexp++;
    472475        }
    473 
     476       
    474477        cexp = aexp - bexp + FLOAT128_BIAS - 2;
    475 
     478       
    476479        cfrac_hi = div128est(afrac_hi, afrac_lo, bfrac_hi);
    477 
     480       
    478481        mul128(bfrac_hi, bfrac_lo, 0x0ll, cfrac_hi,
    479482            &tmp_lolo /* dummy */, &tmp_hihi, &tmp_hilo, &tmp_lohi);
    480 
    481         /* sub192(afrac_hi, afrac_lo, 0, 
     483       
     484        /* sub192(afrac_hi, afrac_lo, 0,
    482485         *     tmp_hihi, tmp_hilo, tmp_lohi
    483486         *     &rem_hihi, &rem_hilo, &rem_lohi); */
    … …  
    487490        }
    488491        rem_lohi = -tmp_lohi;
    489 
     492       
    490493        while ((int64_t) rem_hihi < 0) {
    491494                --cfrac_hi;
    492                 /* add192(rem_hihi, rem_hilo, rem_lohi, 
     495                /* add192(rem_hihi, rem_hilo, rem_lohi,
    493496                 *     0, bfrac_hi, bfrac_lo,
    494497                 *     &rem_hihi, &rem_hilo, &rem_lohi); */
    … …  
    498501                }
    499502        }
    500 
     503       
    501504        cfrac_lo = div128est(rem_hilo, rem_lohi, bfrac_lo);
    502 
     505       
    503506        if ((cfrac_lo & 0x3FFF) <= 4) {
    504507                mul128(bfrac_hi, bfrac_lo, 0x0ll, cfrac_lo,
    505                 &tmp_hihi /* dummy */, &tmp_hilo, &tmp_lohi, &tmp_lolo);
    506 
     508                    &tmp_hihi /* dummy */, &tmp_hilo, &tmp_lohi, &tmp_lolo);
     509               
    507510                /* sub192(rem_hilo, rem_lohi, 0,
    508511                 *     tmp_hilo, tmp_lohi, tmp_lolo,
    … …  
    513516                }
    514517                rem_lolo = -tmp_lolo;
    515 
     518               
    516519                while ((int64_t) rem_hilo < 0) {
    517520                        --cfrac_lo;
    … …  
    524527                        }
    525528                }
    526 
     529               
    527530                cfrac_lo |= ((rem_hilo | rem_lohi | rem_lolo) != 0 );
    528531        }
    529 
     532       
    530533        shift_out = cfrac_lo << (64 - (128 - FLOAT128_FRACTION_SIZE - 1));
    531534        rshift128(cfrac_hi, cfrac_lo, (128 - FLOAT128_FRACTION_SIZE - 1),
    532535            &cfrac_hi, &cfrac_lo);
    533 
    534         result = finishFloat128(cexp, cfrac_hi, cfrac_lo, result.parts.sign, shift_out);
     536       
     537        result = finish_float128(cexp, cfrac_hi, cfrac_lo, result.parts.sign, shift_out);
    535538        return result;
    536539}
Note: See TracChangeset for help on using the changeset viewer.