Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r88d5c1e r9d58539  
    4141#include <common.h>
    4242
    43 /** Divide two single-precision floats.
    44  *
     43/**
     44 * Divide two single-precision floats.
     45 *
    4546 * @param a Nominator.
    4647 * @param b Denominator.
    47  *
    4848 * @return Result of division.
    49  *
    50  */
    51 float32 div_float32(float32 a, float32 b)
     49 */
     50float32 divFloat32(float32 a, float32 b)
    5251{
    5352        float32 result;
    … …  
    5756        result.parts.sign = a.parts.sign ^ b.parts.sign;
    5857       
    59         if (is_float32_nan(a)) {
    60                 if (is_float32_signan(a)) {
    61                         // FIXME: SigNaN
    62                 }
    63                 /* NaN */
     58        if (isFloat32NaN(a)) {
     59                if (isFloat32SigNaN(a)) {
     60                        /*FIXME: SigNaN*/
     61                }
     62                /*NaN*/
    6463                return a;
    6564        }
    6665       
    67         if (is_float32_nan(b)) {
    68                 if (is_float32_signan(b)) {
    69                         // FIXME: SigNaN
    70                 }
    71                 /* NaN */
     66        if (isFloat32NaN(b)) {
     67                if (isFloat32SigNaN(b)) {
     68                        /*FIXME: SigNaN*/
     69                }
     70                /*NaN*/
    7271                return b;
    7372        }
    7473       
    75         if (is_float32_infinity(a)) {
    76                 if (is_float32_infinity(b)) {
     74        if (isFloat32Infinity(a)) {
     75                if (isFloat32Infinity(b)) {
    7776                        /*FIXME: inf / inf */
    78                         result.bin = FLOAT32_NAN;
     77                        result.binary = FLOAT32_NAN;
    7978                        return result;
    8079                }
    … …  
    8483                return result;
    8584        }
    86        
    87         if (is_float32_infinity(b)) {
    88                 if (is_float32_zero(a)) {
     85
     86        if (isFloat32Infinity(b)) {
     87                if (isFloat32Zero(a)) {
    8988                        /* FIXME 0 / inf */
    9089                        result.parts.exp = 0;
    … …  
    9897        }
    9998       
    100         if (is_float32_zero(b)) {
    101                 if (is_float32_zero(a)) {
     99        if (isFloat32Zero(b)) {
     100                if (isFloat32Zero(a)) {
    102101                        /*FIXME: 0 / 0*/
    103                         result.bin = FLOAT32_NAN;
     102                        result.binary = FLOAT32_NAN;
    104103                        return result;
    105104                }
    … …  
    122121                        return result;
    123122                }
    124                
     123
    125124                /* normalize it*/
    126125                afrac <<= 1;
    127                 /* afrac is nonzero => it must stop */
     126                /* afrac is nonzero => it must stop */ 
    128127                while (!(afrac & FLOAT32_HIDDEN_BIT_MASK)) {
    129128                        afrac <<= 1;
    … …  
    131130                }
    132131        }
    133        
     132
    134133        if (bexp == 0) {
    135134                bfrac <<= 1;
    136                 /* bfrac is nonzero => it must stop */
     135                /* bfrac is nonzero => it must stop */ 
    137136                while (!(bfrac & FLOAT32_HIDDEN_BIT_MASK)) {
    138137                        bfrac <<= 1;
    … …  
    140139                }
    141140        }
    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        
     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
    146145        if (bfrac <= (afrac << 1)) {
    147146                afrac >>= 1;
    … …  
    170169                ++cexp;
    171170                cfrac >>= 1;
    172         }
    173        
     171        }       
     172
    174173        /* check overflow */
    175174        if (cexp >= FLOAT32_MAX_EXPONENT) {
    … …  
    179178                return result;
    180179        }
    181        
     180
    182181        if (cexp < 0) {
    183182                /* FIXME: underflow */
    … …  
    191190                        cexp++;
    192191                        cfrac >>= 1;
    193                 }
     192                }       
    194193        } else {
    195194                result.parts.exp = (uint32_t) cexp;
    … …  
    198197        result.parts.fraction = ((cfrac >> 6) & (~FLOAT32_HIDDEN_BIT_MASK));
    199198       
    200         return result;
     199        return result; 
    201200}
    202201
    203 /** Divide two double-precision floats.
     202/**
     203 * Divide two double-precision floats.
    204204 *
    205205 * @param a Nominator.
    206206 * @param b Denominator.
    207  *
    208207 * @return Result of division.
    209  *
    210  */
    211 float64 div_float64(float64 a, float64 b)
     208 */
     209float64 divFloat64(float64 a, float64 b)
    212210{
    213211        float64 result;
    … …  
    219217        result.parts.sign = a.parts.sign ^ b.parts.sign;
    220218       
    221         if (is_float64_nan(a)) {
    222                 if (is_float64_signan(b)) {
    223                         // FIXME: SigNaN
     219        if (isFloat64NaN(a)) {
     220                if (isFloat64SigNaN(b)) {
     221                        /*FIXME: SigNaN*/
    224222                        return b;
    225223                }
    226224               
    227                 if (is_float64_signan(a)) {
    228                         // FIXME: SigNaN
    229                 }
    230                 /* NaN */
     225                if (isFloat64SigNaN(a)) {
     226                        /*FIXME: SigNaN*/
     227                }
     228                /*NaN*/
    231229                return a;
    232230        }
    233231       
    234         if (is_float64_nan(b)) {
    235                 if (is_float64_signan(b)) {
    236                         // FIXME: SigNaN
    237                 }
    238                 /* NaN */
     232        if (isFloat64NaN(b)) {
     233                if (isFloat64SigNaN(b)) {
     234                        /*FIXME: SigNaN*/
     235                }
     236                /*NaN*/
    239237                return b;
    240238        }
    241239       
    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;
     240        if (isFloat64Infinity(a)) {
     241                if (isFloat64Infinity(b) || isFloat64Zero(b)) {
     242                        /*FIXME: inf / inf */
     243                        result.binary = FLOAT64_NAN;
    246244                        return result;
    247245                }
    … …  
    251249                return result;
    252250        }
    253        
    254         if (is_float64_infinity(b)) {
    255                 if (is_float64_zero(a)) {
     251
     252        if (isFloat64Infinity(b)) {
     253                if (isFloat64Zero(a)) {
    256254                        /* FIXME 0 / inf */
    257255                        result.parts.exp = 0;
    … …  
    265263        }
    266264       
    267         if (is_float64_zero(b)) {
    268                 if (is_float64_zero(a)) {
     265        if (isFloat64Zero(b)) {
     266                if (isFloat64Zero(a)) {
    269267                        /*FIXME: 0 / 0*/
    270                         result.bin = FLOAT64_NAN;
     268                        result.binary = FLOAT64_NAN;
    271269                        return result;
    272270                }
    … …  
    276274                return result;
    277275        }
    278        
     276
    279277        afrac = a.parts.fraction;
    280278        aexp = a.parts.exp;
    … …  
    289287                        return result;
    290288                }
    291                
     289
    292290                /* normalize it*/
    293291                aexp++;
    … …  
    298296                }
    299297        }
    300        
     298
    301299        if (bexp == 0) {
    302300                bexp++;
    … …  
    307305                }
    308306        }
    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        
     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
    313311        if (bfrac <= (afrac << 1)) {
    314312                afrac >>= 1;
    … …  
    332330       
    333331        /* round and shift */
    334         result = finish_float64(cexp, cfrac, result.parts.sign);
     332        result = finishFloat64(cexp, cfrac, result.parts.sign);
    335333        return result;
    336334}
    337335
    338 /** Divide two quadruple-precision floats.
     336/**
     337 * Divide two quadruple-precision floats.
    339338 *
    340339 * @param a Nominator.
    341340 * @param b Denominator.
    342  *
    343341 * @return Result of division.
    344  *
    345  */
    346 float128 div_float128(float128 a, float128 b)
     342 */
     343float128 divFloat128(float128 a, float128 b)
    347344{
    348345        float128 result;
    … …  
    352349        uint64_t rem_hihi, rem_hilo, rem_lohi, rem_lolo;
    353350        uint64_t tmp_hihi, tmp_hilo, tmp_lohi, tmp_lolo;
    354        
     351
    355352        result.parts.sign = a.parts.sign ^ b.parts.sign;
    356        
    357         if (is_float128_nan(a)) {
    358                 if (is_float128_signan(b)) {
    359                         // FIXME: SigNaN
     353
     354        if (isFloat128NaN(a)) {
     355                if (isFloat128SigNaN(b)) {
     356                        /*FIXME: SigNaN*/
    360357                        return b;
    361358                }
    362                
    363                 if (is_float128_signan(a)) {
    364                         // FIXME: SigNaN
    365                 }
    366                 /* NaN */
     359
     360                if (isFloat128SigNaN(a)) {
     361                        /*FIXME: SigNaN*/
     362                }
     363                /*NaN*/
    367364                return a;
    368365        }
    369        
    370         if (is_float128_nan(b)) {
    371                 if (is_float128_signan(b)) {
    372                         // FIXME: SigNaN
    373                 }
    374                 /* NaN */
     366
     367        if (isFloat128NaN(b)) {
     368                if (isFloat128SigNaN(b)) {
     369                        /*FIXME: SigNaN*/
     370                }
     371                /*NaN*/
    375372                return b;
    376373        }
    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;
     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;
    383380                        return result;
    384381                }
    … …  
    389386                return result;
    390387        }
    391        
    392         if (is_float128_infinity(b)) {
    393                 if (is_float128_zero(a)) {
    394                         // FIXME 0 / inf
     388
     389        if (isFloat128Infinity(b)) {
     390                if (isFloat128Zero(a)) {
     391                        /* FIXME 0 / inf */
    395392                        result.parts.exp = 0;
    396393                        result.parts.frac_hi = 0;
    … …  
    398395                        return result;
    399396                }
    400                 // FIXME: num / inf
     397                /* FIXME: num / inf*/
    401398                result.parts.exp = 0;
    402399                result.parts.frac_hi = 0;
    … …  
    404401                return result;
    405402        }
    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
     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 */
    415412                result.parts.exp = 0;
    416413                result.parts.frac_hi = 0;
    … …  
    418415                return result;
    419416        }
    420        
     417
    421418        afrac_hi = a.parts.frac_hi;
    422419        afrac_lo = a.parts.frac_lo;
    … …  
    425422        bfrac_lo = b.parts.frac_lo;
    426423        bexp = b.parts.exp;
    427        
     424
    428425        /* denormalized numbers */
    429426        if (aexp == 0) {
    … …  
    434431                        return result;
    435432                }
    436                
     433
    437434                /* normalize it*/
    438435                aexp++;
    … …  
    446443                }
    447444        }
    448        
     445
    449446        if (bexp == 0) {
    450447                bexp++;
    … …  
    458455                }
    459456        }
    460        
     457
    461458        or128(afrac_hi, afrac_lo,
    462459            FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO,
    … …  
    469466        lshift128(bfrac_hi, bfrac_lo,
    470467            (128 - FLOAT128_FRACTION_SIZE - 1), &bfrac_hi, &bfrac_lo);
    471        
     468
    472469        if (le128(bfrac_hi, bfrac_lo, afrac_hi, afrac_lo)) {
    473470                rshift128(afrac_hi, afrac_lo, 1, &afrac_hi, &afrac_lo);
    474471                aexp++;
    475472        }
    476        
     473
    477474        cexp = aexp - bexp + FLOAT128_BIAS - 2;
    478        
     475
    479476        cfrac_hi = div128est(afrac_hi, afrac_lo, bfrac_hi);
    480        
     477
    481478        mul128(bfrac_hi, bfrac_lo, 0x0ll, cfrac_hi,
    482479            &tmp_lolo /* dummy */, &tmp_hihi, &tmp_hilo, &tmp_lohi);
    483        
    484         /* sub192(afrac_hi, afrac_lo, 0,
     480
     481        /* sub192(afrac_hi, afrac_lo, 0, 
    485482         *     tmp_hihi, tmp_hilo, tmp_lohi
    486483         *     &rem_hihi, &rem_hilo, &rem_lohi); */
    … …  
    490487        }
    491488        rem_lohi = -tmp_lohi;
    492        
     489
    493490        while ((int64_t) rem_hihi < 0) {
    494491                --cfrac_hi;
    495                 /* add192(rem_hihi, rem_hilo, rem_lohi,
     492                /* add192(rem_hihi, rem_hilo, rem_lohi, 
    496493                 *     0, bfrac_hi, bfrac_lo,
    497494                 *     &rem_hihi, &rem_hilo, &rem_lohi); */
    … …  
    501498                }
    502499        }
    503        
     500
    504501        cfrac_lo = div128est(rem_hilo, rem_lohi, bfrac_lo);
    505        
     502
    506503        if ((cfrac_lo & 0x3FFF) <= 4) {
    507504                mul128(bfrac_hi, bfrac_lo, 0x0ll, cfrac_lo,
    508                     &tmp_hihi /* dummy */, &tmp_hilo, &tmp_lohi, &tmp_lolo);
    509                
     505                &tmp_hihi /* dummy */, &tmp_hilo, &tmp_lohi, &tmp_lolo);
     506
    510507                /* sub192(rem_hilo, rem_lohi, 0,
    511508                 *     tmp_hilo, tmp_lohi, tmp_lolo,
    … …  
    516513                }
    517514                rem_lolo = -tmp_lolo;
    518                
     515
    519516                while ((int64_t) rem_hilo < 0) {
    520517                        --cfrac_lo;
    … …  
    527524                        }
    528525                }
    529                
     526
    530527                cfrac_lo |= ((rem_hilo | rem_lohi | rem_lolo) != 0 );
    531528        }
    532        
     529
    533530        shift_out = cfrac_lo << (64 - (128 - FLOAT128_FRACTION_SIZE - 1));
    534531        rshift128(cfrac_hi, cfrac_lo, (128 - FLOAT128_FRACTION_SIZE - 1),
    535532            &cfrac_hi, &cfrac_lo);
    536        
    537         result = finish_float128(cexp, cfrac_hi, cfrac_lo, result.parts.sign, shift_out);
     533
     534        result = finishFloat128(cexp, cfrac_hi, cfrac_lo, result.parts.sign, shift_out);
    538535        return result;
    539536}
Note: See TracChangeset for help on using the changeset viewer.