Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r88d5c1e rc67aff2  
    3939#include <common.h>
    4040
    41 /** Multiply two single-precision floats.
     41/**
     42 * Multiply two single-precision floats.
    4243 *
    4344 * @param a First input operand.
    4445 * @param b Second input operand.
    45  *
    4646 * @return Result of multiplication.
    47  *
    48  */
    49 float32 mul_float32(float32 a, float32 b)
     47 */
     48float32 mulFloat32(float32 a, float32 b)
    5049{
    5150        float32 result;
    5251        uint64_t frac1, frac2;
    5352        int32_t exp;
    54        
     53
    5554        result.parts.sign = a.parts.sign ^ b.parts.sign;
    5655       
    57         if (is_float32_nan(a) || is_float32_nan(b)) {
     56        if (isFloat32NaN(a) || isFloat32NaN(b)) {
    5857                /* TODO: fix SigNaNs */
    59                 if (is_float32_signan(a)) {
     58                if (isFloat32SigNaN(a)) {
    6059                        result.parts.fraction = a.parts.fraction;
    6160                        result.parts.exp = a.parts.exp;
    6261                        return result;
    6362                }
    64                 if (is_float32_signan(b)) { /* TODO: fix SigNaN */
     63                if (isFloat32SigNaN(b)) { /* TODO: fix SigNaN */
    6564                        result.parts.fraction = b.parts.fraction;
    6665                        result.parts.exp = b.parts.exp;
    … …  
    6867                }
    6968                /* set NaN as result */
    70                 result.bin = FLOAT32_NAN;
    71                 return result;
    72         }
    73        
    74         if (is_float32_infinity(a)) {
    75                 if (is_float32_zero(b)) {
    76                         /* FIXME: zero * infinity */
    77                         result.bin = FLOAT32_NAN;
     69                result.binary = FLOAT32_NAN;
     70                return result;
     71        }
     72               
     73        if (isFloat32Infinity(a)) {
     74                if (isFloat32Zero(b)) {
     75                        /* FIXME: zero * infinity */
     76                        result.binary = FLOAT32_NAN;
    7877                        return result;
    7978                }
    … …  
    8281                return result;
    8382        }
    84        
    85         if (is_float32_infinity(b)) {
    86                 if (is_float32_zero(a)) {
    87                         /* FIXME: zero * infinity */
    88                         result.bin = FLOAT32_NAN;
     83
     84        if (isFloat32Infinity(b)) {
     85                if (isFloat32Zero(a)) {
     86                        /* FIXME: zero * infinity */
     87                        result.binary = FLOAT32_NAN;
    8988                        return result;
    9089                }
    … …  
    9392                return result;
    9493        }
    95        
     94
    9695        /* exp is signed so we can easy detect underflow */
    9796        exp = a.parts.exp + b.parts.exp;
    … …  
    101100                /* FIXME: overflow */
    102101                /* set infinity as result */
    103                 result.bin = FLOAT32_INF;
     102                result.binary = FLOAT32_INF;
    104103                result.parts.sign = a.parts.sign ^ b.parts.sign;
    105104                return result;
    … …  
    122121       
    123122        frac2 = b.parts.fraction;
    124        
     123
    125124        if (b.parts.exp > 0) {
    126125                frac2 |= FLOAT32_HIDDEN_BIT_MASK;
    … …  
    128127                ++exp;
    129128        }
    130        
     129
    131130        frac1 <<= 1; /* one bit space for rounding */
    132        
     131
    133132        frac1 = frac1 * frac2;
    134        
     133
    135134        /* round and return */
    136         while ((exp < FLOAT32_MAX_EXPONENT) &&
    137             (frac1 >= (1 << (FLOAT32_FRACTION_SIZE + 2)))) {
     135        while ((exp < FLOAT32_MAX_EXPONENT) && (frac1 >= (1 << (FLOAT32_FRACTION_SIZE + 2)))) {
    138136                /* 23 bits of fraction + one more for hidden bit (all shifted 1 bit left) */
    139137                ++exp;
    140138                frac1 >>= 1;
    141139        }
    142        
     140
    143141        /* rounding */
    144142        /* ++frac1; FIXME: not works - without it is ok */
    145143        frac1 >>= 1; /* shift off rounding space */
    146144       
    147         if ((exp < FLOAT32_MAX_EXPONENT) &&
    148             (frac1 >= (1 << (FLOAT32_FRACTION_SIZE + 1)))) {
     145        if ((exp < FLOAT32_MAX_EXPONENT) && (frac1 >= (1 << (FLOAT32_FRACTION_SIZE + 1)))) {
    149146                ++exp;
    150147                frac1 >>= 1;
    151148        }
    152        
    153         if (exp >= FLOAT32_MAX_EXPONENT) {
     149
     150        if (exp >= FLOAT32_MAX_EXPONENT) {     
    154151                /* TODO: fix overflow */
    155152                /* return infinity*/
    … …  
    160157       
    161158        exp -= FLOAT32_FRACTION_SIZE;
    162        
    163         if (exp <= FLOAT32_FRACTION_SIZE) {
     159
     160        if (exp <= FLOAT32_FRACTION_SIZE) { 
    164161                /* denormalized number */
    165162                frac1 >>= 1; /* denormalize */
    … …  
    178175        result.parts.fraction = frac1 & ((1 << FLOAT32_FRACTION_SIZE) - 1);
    179176       
    180         return result;
     177        return result; 
    181178}
    182179
    183 /** Multiply two double-precision floats.
     180/**
     181 * Multiply two double-precision floats.
    184182 *
    185183 * @param a First input operand.
    186184 * @param b Second input operand.
    187  *
    188185 * @return Result of multiplication.
    189  *
    190  */
    191 float64 mul_float64(float64 a, float64 b)
     186 */
     187float64 mulFloat64(float64 a, float64 b)
    192188{
    193189        float64 result;
    194190        uint64_t frac1, frac2;
    195191        int32_t exp;
    196        
     192
    197193        result.parts.sign = a.parts.sign ^ b.parts.sign;
    198194       
    199         if (is_float64_nan(a) || is_float64_nan(b)) {
     195        if (isFloat64NaN(a) || isFloat64NaN(b)) {
    200196                /* TODO: fix SigNaNs */
    201                 if (is_float64_signan(a)) {
     197                if (isFloat64SigNaN(a)) {
    202198                        result.parts.fraction = a.parts.fraction;
    203199                        result.parts.exp = a.parts.exp;
    204200                        return result;
    205201                }
    206                 if (is_float64_signan(b)) { /* TODO: fix SigNaN */
     202                if (isFloat64SigNaN(b)) { /* TODO: fix SigNaN */
    207203                        result.parts.fraction = b.parts.fraction;
    208204                        result.parts.exp = b.parts.exp;
    … …  
    210206                }
    211207                /* set NaN as result */
    212                 result.bin = FLOAT64_NAN;
    213                 return result;
    214         }
    215        
    216         if (is_float64_infinity(a)) {
    217                 if (is_float64_zero(b)) {
    218                         /* FIXME: zero * infinity */
    219                         result.bin = FLOAT64_NAN;
     208                result.binary = FLOAT64_NAN;
     209                return result;
     210        }
     211               
     212        if (isFloat64Infinity(a)) {
     213                if (isFloat64Zero(b)) {
     214                        /* FIXME: zero * infinity */
     215                        result.binary = FLOAT64_NAN;
    220216                        return result;
    221217                }
    … …  
    224220                return result;
    225221        }
    226        
    227         if (is_float64_infinity(b)) {
    228                 if (is_float64_zero(a)) {
    229                         /* FIXME: zero * infinity */
    230                         result.bin = FLOAT64_NAN;
     222
     223        if (isFloat64Infinity(b)) {
     224                if (isFloat64Zero(a)) {
     225                        /* FIXME: zero * infinity */
     226                        result.binary = FLOAT64_NAN;
    231227                        return result;
    232228                }
    … …  
    235231                return result;
    236232        }
    237        
     233
    238234        /* exp is signed so we can easy detect underflow */
    239235        exp = a.parts.exp + b.parts.exp - FLOAT64_BIAS;
    240236       
    241237        frac1 = a.parts.fraction;
    242        
     238
    243239        if (a.parts.exp > 0) {
    244240                frac1 |= FLOAT64_HIDDEN_BIT_MASK;
    … …  
    248244       
    249245        frac2 = b.parts.fraction;
    250        
     246
    251247        if (b.parts.exp > 0) {
    252248                frac2 |= FLOAT64_HIDDEN_BIT_MASK;
    … …  
    254250                ++exp;
    255251        }
    256        
     252
    257253        frac1 <<= (64 - FLOAT64_FRACTION_SIZE - 1);
    258254        frac2 <<= (64 - FLOAT64_FRACTION_SIZE - 2);
    259        
     255
    260256        mul64(frac1, frac2, &frac1, &frac2);
    261        
     257
    262258        frac1 |= (frac2 != 0);
    263259        if (frac1 & (0x1ll << 62)) {
    … …  
    265261                exp--;
    266262        }
    267        
    268         result = finish_float64(exp, frac1, result.parts.sign);
     263
     264        result = finishFloat64(exp, frac1, result.parts.sign);
    269265        return result;
    270266}
    271267
    272 /** Multiply two quadruple-precision floats.
     268/**
     269 * Multiply two quadruple-precision floats.
    273270 *
    274271 * @param a First input operand.
    275272 * @param b Second input operand.
    276  *
    277273 * @return Result of multiplication.
    278  *
    279  */
    280 float128 mul_float128(float128 a, float128 b)
     274 */
     275float128 mulFloat128(float128 a, float128 b)
    281276{
    282277        float128 result;
    283278        uint64_t frac1_hi, frac1_lo, frac2_hi, frac2_lo, tmp_hi, tmp_lo;
    284279        int32_t exp;
    285        
     280
    286281        result.parts.sign = a.parts.sign ^ b.parts.sign;
    287        
    288         if (is_float128_nan(a) || is_float128_nan(b)) {
     282
     283        if (isFloat128NaN(a) || isFloat128NaN(b)) {
    289284                /* TODO: fix SigNaNs */
    290                 if (is_float128_signan(a)) {
     285                if (isFloat128SigNaN(a)) {
    291286                        result.parts.frac_hi = a.parts.frac_hi;
    292287                        result.parts.frac_lo = a.parts.frac_lo;
    … …  
    294289                        return result;
    295290                }
    296                 if (is_float128_signan(b)) { /* TODO: fix SigNaN */
     291                if (isFloat128SigNaN(b)) { /* TODO: fix SigNaN */
    297292                        result.parts.frac_hi = b.parts.frac_hi;
    298293                        result.parts.frac_lo = b.parts.frac_lo;
    … …  
    301296                }
    302297                /* set NaN as result */
    303                 result.bin.hi = FLOAT128_NAN_HI;
    304                 result.bin.lo = FLOAT128_NAN_LO;
    305                 return result;
    306         }
    307        
    308         if (is_float128_infinity(a)) {
    309                 if (is_float128_zero(b)) {
    310                         /* FIXME: zero * infinity */
    311                         result.bin.hi = FLOAT128_NAN_HI;
    312                         result.bin.lo = FLOAT128_NAN_LO;
     298                result.binary.hi = FLOAT128_NAN_HI;
     299                result.binary.lo = FLOAT128_NAN_LO;
     300                return result;
     301        }
     302
     303        if (isFloat128Infinity(a)) {
     304                if (isFloat128Zero(b)) {
     305                        /* FIXME: zero * infinity */
     306                        result.binary.hi = FLOAT128_NAN_HI;
     307                        result.binary.lo = FLOAT128_NAN_LO;
    313308                        return result;
    314309                }
    … …  
    318313                return result;
    319314        }
    320        
    321         if (is_float128_infinity(b)) {
    322                 if (is_float128_zero(a)) {
    323                         /* FIXME: zero * infinity */
    324                         result.bin.hi = FLOAT128_NAN_HI;
    325                         result.bin.lo = FLOAT128_NAN_LO;
     315
     316        if (isFloat128Infinity(b)) {
     317                if (isFloat128Zero(a)) {
     318                        /* FIXME: zero * infinity */
     319                        result.binary.hi = FLOAT128_NAN_HI;
     320                        result.binary.lo = FLOAT128_NAN_LO;
    326321                        return result;
    327322                }
    … …  
    331326                return result;
    332327        }
    333        
     328
    334329        /* exp is signed so we can easy detect underflow */
    335330        exp = a.parts.exp + b.parts.exp - FLOAT128_BIAS - 1;
    336        
     331
    337332        frac1_hi = a.parts.frac_hi;
    338333        frac1_lo = a.parts.frac_lo;
    339        
     334
    340335        if (a.parts.exp > 0) {
    341336                or128(frac1_hi, frac1_lo,
    342                     FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO,
    343                     &frac1_hi, &frac1_lo);
    344         } else {
    345                 ++exp;
    346         }
    347        
     337                FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO,
     338                &frac1_hi, &frac1_lo);
     339        } else {
     340                ++exp;
     341        }
     342
    348343        frac2_hi = b.parts.frac_hi;
    349344        frac2_lo = b.parts.frac_lo;
    350        
     345
    351346        if (b.parts.exp > 0) {
    352347                or128(frac2_hi, frac2_lo,
    … …  
    356351                ++exp;
    357352        }
    358        
     353
    359354        lshift128(frac2_hi, frac2_lo,
    360355            128 - FLOAT128_FRACTION_SIZE, &frac2_hi, &frac2_lo);
    361        
     356
    362357        tmp_hi = frac1_hi;
    363358        tmp_lo = frac1_lo;
    … …  
    366361        add128(frac1_hi, frac1_lo, tmp_hi, tmp_lo, &frac1_hi, &frac1_lo);
    367362        frac2_hi |= (frac2_lo != 0x0ll);
    368        
     363
    369364        if ((FLOAT128_HIDDEN_BIT_MASK_HI << 1) <= frac1_hi) {
    370365                frac2_hi >>= 1;
    … …  
    375370                ++exp;
    376371        }
    377        
    378         result = finish_float128(exp, frac1_hi, frac1_lo, result.parts.sign, frac2_hi);
     372
     373        result = finishFloat128(exp, frac1_hi, frac1_lo, result.parts.sign, frac2_hi);
    379374        return result;
    380375}
Note: See TracChangeset for help on using the changeset viewer.