Changeset 1266543 in mainline for softfloat/generic/mul.c


Ignore:
Timestamp:
2006-02-07T00:41:18Z (19 years ago)
Author:
Josef Cejka <malyzelenyhnus@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
1a030b8
Parents:
b7e65d4
Message:

32 bit float division added.
Some small bugs fixed.
Code cleanup.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • softfloat/generic/mul.c

    rb7e65d4 r1266543  
    3737{
    3838        float32 result;
    39         __u64 mant1, mant2;
     39        __u64 frac1, frac2;
    4040        __s32 exp;
    4141
    … …  
    4545                /* TODO: fix SigNaNs */
    4646                if (isFloat32SigNaN(a)) {
    47                         result.parts.mantisa = a.parts.mantisa;
     47                        result.parts.fraction = a.parts.fraction;
    4848                        result.parts.exp = a.parts.exp;
    4949                        return result;
    5050                };
    5151                if (isFloat32SigNaN(b)) { /* TODO: fix SigNaN */
    52                         result.parts.mantisa = b.parts.mantisa;
     52                        result.parts.fraction = b.parts.fraction;
    5353                        result.parts.exp = b.parts.exp;
    5454                        return result;
    … …  
    6565                        return result;
    6666                }
    67                 result.parts.mantisa = a.parts.mantisa;
     67                result.parts.fraction = a.parts.fraction;
    6868                result.parts.exp = a.parts.exp;
    6969                return result;
    … …  
    7676                        return result;
    7777                }
    78                 result.parts.mantisa = b.parts.mantisa;
     78                result.parts.fraction = b.parts.fraction;
    7979                result.parts.exp = b.parts.exp;
    8080                return result;
    … …  
    9696                /* FIXME: underflow */
    9797                /* return signed zero */
    98                 result.parts.mantisa = 0x0;
     98                result.parts.fraction = 0x0;
    9999                result.parts.exp = 0x0;
    100100                return result;
    101101        };
    102102       
    103         mant1 = a.parts.mantisa;
     103        frac1 = a.parts.fraction;
    104104        if (a.parts.exp > 0) {
    105                 mant1 |= FLOAT32_HIDDEN_BIT_MASK;
     105                frac1 |= FLOAT32_HIDDEN_BIT_MASK;
    106106        } else {
    107107                ++exp;
    108108        };
    109109       
    110         mant2 = b.parts.mantisa;
     110        frac2 = b.parts.fraction;
    111111
    112112        if (b.parts.exp > 0) {
    113                 mant2 |= FLOAT32_HIDDEN_BIT_MASK;
     113                frac2 |= FLOAT32_HIDDEN_BIT_MASK;
    114114        } else {
    115115                ++exp;
    116116        };
    117117
    118         mant1 <<= 1; /* one bit space for rounding */
    119 
    120         mant1 = mant1 * mant2;
     118        frac1 <<= 1; /* one bit space for rounding */
     119
     120        frac1 = frac1 * frac2;
    121121/* round and return */
    122122       
    123         while ((exp < FLOAT32_MAX_EXPONENT) && (mant1 >= ( 1 << (FLOAT32_MANTISA_SIZE + 2)))) {
    124                 /* 23 bits of mantisa + one more for hidden bit (all shifted 1 bit left)*/
    125                 ++exp;
    126                 mant1 >>= 1;
     123        while ((exp < FLOAT32_MAX_EXPONENT) && (frac1 >= ( 1 << (FLOAT32_FRACTION_SIZE + 2)))) {
     124                /* 23 bits of fraction + one more for hidden bit (all shifted 1 bit left)*/
     125                ++exp;
     126                frac1 >>= 1;
    127127        };
    128128
    129129        /* rounding */
    130         //++mant1; /* FIXME: not works - without it is ok */
    131         mant1 >>= 1; /* shift off rounding space */
    132        
    133         if ((exp < FLOAT32_MAX_EXPONENT) && (mant1 >= (1 << (FLOAT32_MANTISA_SIZE + 1)))) {
    134                 ++exp;
    135                 mant1 >>= 1;
     130        /* ++frac1; FIXME: not works - without it is ok */
     131        frac1 >>= 1; /* shift off rounding space */
     132       
     133        if ((exp < FLOAT32_MAX_EXPONENT) && (frac1 >= (1 << (FLOAT32_FRACTION_SIZE + 1)))) {
     134                ++exp;
     135                frac1 >>= 1;
    136136        };
    137137
    … …  
    140140                /* return infinity*/
    141141                result.parts.exp = FLOAT32_MAX_EXPONENT;
    142                 result.parts.mantisa = 0x0;
    143                 return result;
    144         }
    145        
    146         exp -= FLOAT32_MANTISA_SIZE;
    147 
    148         if (exp <= FLOAT32_MANTISA_SIZE) {
     142                result.parts.fraction = 0x0;
     143                return result;
     144        }
     145       
     146        exp -= FLOAT32_FRACTION_SIZE;
     147
     148        if (exp <= FLOAT32_FRACTION_SIZE) {
    149149                /* denormalized number */
    150                 mant1 >>= 1; /* denormalize */
    151                 while ((mant1 > 0) && (exp < 0)) {
    152                         mant1 >>= 1;
     150                frac1 >>= 1; /* denormalize */
     151                while ((frac1 > 0) && (exp < 0)) {
     152                        frac1 >>= 1;
    153153                        ++exp;
    154154                };
    155                 if (mant1 == 0) {
     155                if (frac1 == 0) {
    156156                        /* FIXME : underflow */
    157157                result.parts.exp = 0;
    158                 result.parts.mantisa = 0;
     158                result.parts.fraction = 0;
    159159                return result;
    160160                };
    161161        };
    162162        result.parts.exp = exp;
    163         result.parts.mantisa = mant1 & ( (1 << FLOAT32_MANTISA_SIZE) - 1);
     163        result.parts.fraction = frac1 & ( (1 << FLOAT32_FRACTION_SIZE) - 1);
    164164       
    165165        return result; 
    … …  
    173173{
    174174        float64 result;
    175         __u64 mant1, mant2;
     175        __u64 frac1, frac2;
    176176        __s32 exp;
    177177
    … …  
    181181                /* TODO: fix SigNaNs */
    182182                if (isFloat64SigNaN(a)) {
    183                         result.parts.mantisa = a.parts.mantisa;
     183                        result.parts.fraction = a.parts.fraction;
    184184                        result.parts.exp = a.parts.exp;
    185185                        return result;
    186186                };
    187187                if (isFloat64SigNaN(b)) { /* TODO: fix SigNaN */
    188                         result.parts.mantisa = b.parts.mantisa;
     188                        result.parts.fraction = b.parts.fraction;
    189189                        result.parts.exp = b.parts.exp;
    190190                        return result;
    … …  
    201201                        return result;
    202202                }
    203                 result.parts.mantisa = a.parts.mantisa;
     203                result.parts.fraction = a.parts.fraction;
    204204                result.parts.exp = a.parts.exp;
    205205                return result;
    … …  
    212212                        return result;
    213213                }
    214                 result.parts.mantisa = b.parts.mantisa;
     214                result.parts.fraction = b.parts.fraction;
    215215                result.parts.exp = b.parts.exp;
    216216                return result;
    … …  
    232232                /* FIXME: underflow */
    233233                /* return signed zero */
    234                 result.parts.mantisa = 0x0;
     234                result.parts.fraction = 0x0;
    235235                result.parts.exp = 0x0;
    236236                return result;
    237237        };
    238238       
    239         mant1 = a.parts.mantisa;
     239        frac1 = a.parts.fraction;
    240240        if (a.parts.exp > 0) {
    241                 mant1 |= FLOAT64_HIDDEN_BIT_MASK;
     241                frac1 |= FLOAT64_HIDDEN_BIT_MASK;
    242242        } else {
    243243                ++exp;
    244244        };
    245245       
    246         mant2 = b.parts.mantisa;
     246        frac2 = b.parts.fraction;
    247247
    248248        if (b.parts.exp > 0) {
    249                 mant2 |= FLOAT64_HIDDEN_BIT_MASK;
     249                frac2 |= FLOAT64_HIDDEN_BIT_MASK;
    250250        } else {
    251251                ++exp;
    252252        };
    253253
    254         mant1 <<= 1; /* one bit space for rounding */
    255 
    256         mul64integers(mant1, mant2, &mant1, &mant2);
     254        frac1 <<= 1; /* one bit space for rounding */
     255
     256        mul64integers(frac1, frac2, &frac1, &frac2);
    257257
    258258/* round and return */
    259         /* FIXME: ugly soulution is to shift whole mant2 >> as in 32bit version
     259        /* FIXME: ugly soulution is to shift whole frac2 >> as in 32bit version
    260260         * Here is is more slower because we have to shift two numbers with carry
    261261         * Better is find first nonzero bit and make only one shift
    … …  
    264264         */
    265265       
    266         while ((exp < FLOAT64_MAX_EXPONENT) && (mant2 > 0 )) {
    267                 mant1 >>= 1;
    268                 mant1 &= ((mant2 & 0x1) << 63);
    269                 mant2 >>= 1;
    270                 ++exp;
    271         }
    272        
    273         while ((exp < FLOAT64_MAX_EXPONENT) && (mant1 >= ( (__u64)1 << (FLOAT64_MANTISA_SIZE + 2)))) {
    274                 ++exp;
    275                 mant1 >>= 1;
     266        while ((exp < FLOAT64_MAX_EXPONENT) && (frac2 > 0 )) {
     267                frac1 >>= 1;
     268                frac1 &= ((frac2 & 0x1) << 63);
     269                frac2 >>= 1;
     270                ++exp;
     271        }
     272       
     273        while ((exp < FLOAT64_MAX_EXPONENT) && (frac1 >= ( (__u64)1 << (FLOAT64_FRACTION_SIZE + 2)))) {
     274                ++exp;
     275                frac1 >>= 1;
    276276        };
    277277
    278278        /* rounding */
    279         //++mant1; /* FIXME: not works - without it is ok */
    280         mant1 >>= 1; /* shift off rounding space */
    281        
    282         if ((exp < FLOAT64_MAX_EXPONENT) && (mant1 >= ((__u64)1 << (FLOAT64_MANTISA_SIZE + 1)))) {
    283                 ++exp;
    284                 mant1 >>= 1;
     279        /* ++frac1; FIXME: not works - without it is ok */
     280        frac1 >>= 1; /* shift off rounding space */
     281       
     282        if ((exp < FLOAT64_MAX_EXPONENT) && (frac1 >= ((__u64)1 << (FLOAT64_FRACTION_SIZE + 1)))) {
     283                ++exp;
     284                frac1 >>= 1;
    285285        };
    286286
    … …  
    289289                /* return infinity*/
    290290                result.parts.exp = FLOAT64_MAX_EXPONENT;
    291                 result.parts.mantisa = 0x0;
    292                 return result;
    293         }
    294        
    295         exp -= FLOAT64_MANTISA_SIZE;
    296 
    297         if (exp <= FLOAT64_MANTISA_SIZE) {
     291                result.parts.fraction = 0x0;
     292                return result;
     293        }
     294       
     295        exp -= FLOAT64_FRACTION_SIZE;
     296
     297        if (exp <= FLOAT64_FRACTION_SIZE) {
    298298                /* denormalized number */
    299                 mant1 >>= 1; /* denormalize */
    300                 while ((mant1 > 0) && (exp < 0)) {
    301                         mant1 >>= 1;
     299                frac1 >>= 1; /* denormalize */
     300                while ((frac1 > 0) && (exp < 0)) {
     301                        frac1 >>= 1;
    302302                        ++exp;
    303303                };
    304                 if (mant1 == 0) {
     304                if (frac1 == 0) {
    305305                        /* FIXME : underflow */
    306306                result.parts.exp = 0;
    307                 result.parts.mantisa = 0;
     307                result.parts.fraction = 0;
    308308                return result;
    309309                };
    310310        };
    311311        result.parts.exp = exp;
    312         result.parts.mantisa = mant1 & ( ((__u64)1 << FLOAT64_MANTISA_SIZE) - 1);
     312        result.parts.fraction = frac1 & ( ((__u64)1 << FLOAT64_FRACTION_SIZE) - 1);
    313313       
    314314        return result; 
    … …  
    339339
    340340        middle1 += middle2;
    341         high += ((__u64)(middle1 < middle2) << 32) + middle1>>32;
    342         middle1 << 32;
     341        high += ((__u64)(middle1 < middle2) << 32) + (middle1 >> 32);
     342        middle1 <<= 32;
    343343        low += middle1;
    344344        high += (low < middle1);
Note: See TracChangeset for help on using the changeset viewer.