Changeset 1266543 in mainline


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.

Location:
softfloat
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • softfloat/generic/add.c

    rb7e65d4 r1266543  
    3636{
    3737        int expdiff;
    38         __u32 exp1, exp2,mant1, mant2;
     38        __u32 exp1, exp2,frac1, frac2;
    3939       
    4040        expdiff = a.parts.exp - b.parts.exp;
    4141        if (expdiff < 0) {
    4242                if (isFloat32NaN(b)) {
    43                         //TODO: fix SigNaN
     43                        /* TODO: fix SigNaN */
    4444                        if (isFloat32SigNaN(b)) {
    4545                        };
    … …  
    5252                }
    5353               
    54                 mant1 = b.parts.mantisa;
     54                frac1 = b.parts.fraction;
    5555                exp1 = b.parts.exp;
    56                 mant2 = a.parts.mantisa;
     56                frac2 = a.parts.fraction;
    5757                exp2 = a.parts.exp;
    5858                expdiff *= -1;
    5959        } else {
    60                 if (isFloat32NaN(a)) {
    61                         //TODO: fix SigNaN
     60                if ((isFloat32NaN(a)) || (isFloat32NaN(b))) {
     61                        /* TODO: fix SigNaN */
    6262                        if (isFloat32SigNaN(a) || isFloat32SigNaN(b)) {
    6363                        };
    64                         return a;
     64                        return (isFloat32NaN(a)?a:b);
    6565                };
    6666               
    … …  
    6969                }
    7070               
    71                 mant1 = a.parts.mantisa;
     71                frac1 = a.parts.fraction;
    7272                exp1 = a.parts.exp;
    73                 mant2 = b.parts.mantisa;
     73                frac2 = b.parts.fraction;
    7474                exp2 = b.parts.exp;
    7575        };
    … …  
    7777        if (exp1 == 0) {
    7878                /* both are denormalized */
    79                 mant1 += mant2;
    80                 if (mant1 & FLOAT32_HIDDEN_BIT_MASK ) {
     79                frac1 += frac2;
     80                if (frac1 & FLOAT32_HIDDEN_BIT_MASK ) {
    8181                        /* result is not denormalized */
    8282                        a.parts.exp = 1;
    8383                };
    84                 a.parts.mantisa = mant1;
     84                a.parts.fraction = frac1;
    8585                return a;
    8686        };
    8787       
    88         mant1 |= FLOAT32_HIDDEN_BIT_MASK; //add hidden bit
     88        frac1 |= FLOAT32_HIDDEN_BIT_MASK; /* add hidden bit */
    8989
    9090        if (exp2 == 0) {
    … …  
    9393        } else {
    9494                /* add hidden bit to second operand */
    95                 mant2 |= FLOAT32_HIDDEN_BIT_MASK;
     95                frac2 |= FLOAT32_HIDDEN_BIT_MASK;
    9696        };
    9797       
    9898        /* create some space for rounding */
    99         mant1 <<= 6;
    100         mant2 <<= 6;
    101        
    102         if (expdiff > (FLOAT32_MANTISA_SIZE + 1) ) {
    103              goto done;
    104              };
    105        
    106         mant2 >>= expdiff;
    107         mant1 += mant2;
    108 done:
    109         if (mant1 & (FLOAT32_HIDDEN_BIT_MASK << 7) ) {
    110                 ++exp1;
    111                 mant1 >>= 1;
    112         };
    113        
    114         /* rounding - if first bit after mantisa is set then round up */
    115         mant1 += (0x1 << 5);
    116        
    117         if (mant1 & (FLOAT32_HIDDEN_BIT_MASK << 7)) {
    118                 ++exp1;
    119                 mant1 >>= 1;
    120         };
     99        frac1 <<= 6;
     100        frac2 <<= 6;
     101       
     102        if (expdiff < (FLOAT32_FRACTION_SIZE + 2) ) {
     103                frac2 >>= expdiff;
     104                frac1 += frac2;
     105                };
     106       
     107        if (frac1 & (FLOAT32_HIDDEN_BIT_MASK << 7) ) {
     108                ++exp1;
     109                frac1 >>= 1;
     110        };
     111       
     112        /* rounding - if first bit after fraction is set then round up */
     113        frac1 += (0x1 << 5);
     114       
     115        if (frac1 & (FLOAT32_HIDDEN_BIT_MASK << 7)) {
     116                /* rounding overflow */
     117                ++exp1;
     118                frac1 >>= 1;
     119        };
     120       
     121        if ((a.parts.exp == FLOAT32_MAX_EXPONENT ) || (a.parts.exp < exp1)) {
     122                        /* overflow - set infinity as result */
     123                        a.parts.exp = FLOAT32_MAX_EXPONENT;
     124                        a.parts.fraction = 0;
     125                        return a;
     126                        }
    121127       
    122128        a.parts.exp = exp1;
    123129       
    124130        /*Clear hidden bit and shift */
    125         a.parts.mantisa = ((mant1 >> 6) & (~FLOAT32_HIDDEN_BIT_MASK)) ;
     131        a.parts.fraction = ((frac1 >> 6) & (~FLOAT32_HIDDEN_BIT_MASK)) ;
    126132        return a;
    127133}
    … …  
    134140        int expdiff;
    135141        __u32 exp1, exp2;
    136         __u64 mant1, mant2;
     142        __u64 frac1, frac2;
    137143       
    138144        expdiff = a.parts.exp - b.parts.exp;
    139145        if (expdiff < 0) {
    140146                if (isFloat64NaN(b)) {
    141                         //TODO: fix SigNaN
     147                        /* TODO: fix SigNaN */
    142148                        if (isFloat64SigNaN(b)) {
    143149                        };
    … …  
    151157                }
    152158               
    153                 mant1 = b.parts.mantisa;
     159                frac1 = b.parts.fraction;
    154160                exp1 = b.parts.exp;
    155                 mant2 = a.parts.mantisa;
     161                frac2 = a.parts.fraction;
    156162                exp2 = a.parts.exp;
    157163                expdiff *= -1;
    158164        } else {
    159165                if (isFloat64NaN(a)) {
    160                         //TODO: fix SigNaN
     166                        /* TODO: fix SigNaN */
    161167                        if (isFloat64SigNaN(a) || isFloat64SigNaN(b)) {
    162168                        };
    … …  
    169175                }
    170176               
    171                 mant1 = a.parts.mantisa;
     177                frac1 = a.parts.fraction;
    172178                exp1 = a.parts.exp;
    173                 mant2 = b.parts.mantisa;
     179                frac2 = b.parts.fraction;
    174180                exp2 = b.parts.exp;
    175181        };
    … …  
    177183        if (exp1 == 0) {
    178184                /* both are denormalized */
    179                 mant1 += mant2;
    180                 if (mant1 & FLOAT64_HIDDEN_BIT_MASK) {
     185                frac1 += frac2;
     186                if (frac1 & FLOAT64_HIDDEN_BIT_MASK) {
    181187                        /* result is not denormalized */
    182188                        a.parts.exp = 1;
    183189                };
    184                 a.parts.mantisa = mant1;
     190                a.parts.fraction = frac1;
    185191                return a;
    186192        };
    187193       
    188         /* add hidden bit - mant1 is sure not denormalized */
    189         mant1 |= FLOAT64_HIDDEN_BIT_MASK;
     194        /* add hidden bit - frac1 is sure not denormalized */
     195        frac1 |= FLOAT64_HIDDEN_BIT_MASK;
    190196
    191197        /* second operand ... */
    … …  
    195201        } else {
    196202                /* is not denormalized */
    197                 mant2 |= FLOAT64_HIDDEN_BIT_MASK;
     203                frac2 |= FLOAT64_HIDDEN_BIT_MASK;
    198204        };
    199205       
    200206        /* create some space for rounding */
    201         mant1 <<= 6;
    202         mant2 <<= 6;
    203        
    204         if (expdiff > (FLOAT64_MANTISA_SIZE + 1) ) {
    205              goto done;
    206              };
    207        
    208         mant2 >>= expdiff;
    209         mant1 += mant2;
    210 done:
    211         if (mant1 & (FLOAT64_HIDDEN_BIT_MASK << 7) ) {
    212                 ++exp1;
    213                 mant1 >>= 1;
    214         };
    215        
    216         /* rounding - if first bit after mantisa is set then round up */
    217         mant1 += (0x1 << 5);
    218        
    219         if (mant1 & (FLOAT64_HIDDEN_BIT_MASK << 7)) {
    220                 ++exp1;
    221                 mant1 >>= 1;
    222         };
     207        frac1 <<= 6;
     208        frac2 <<= 6;
     209       
     210        if (expdiff < (FLOAT64_FRACTION_SIZE + 2) ) {
     211                frac2 >>= expdiff;
     212                frac1 += frac2;
     213                };
     214       
     215        if (frac1 & (FLOAT64_HIDDEN_BIT_MASK << 7) ) {
     216                ++exp1;
     217                frac1 >>= 1;
     218        };
     219       
     220        /* rounding - if first bit after fraction is set then round up */
     221        frac1 += (0x1 << 5);
     222       
     223        if (frac1 & (FLOAT64_HIDDEN_BIT_MASK << 7)) {
     224                /* rounding overflow */
     225                ++exp1;
     226                frac1 >>= 1;
     227        };
     228       
     229        if ((a.parts.exp == FLOAT64_MAX_EXPONENT ) || (a.parts.exp < exp1)) {
     230                        /* overflow - set infinity as result */
     231                        a.parts.exp = FLOAT64_MAX_EXPONENT;
     232                        a.parts.fraction = 0;
     233                        return a;
     234                        }
    223235       
    224236        a.parts.exp = exp1;
    225237        /*Clear hidden bit and shift */
    226         a.parts.mantisa = ( (mant1 >> 6 ) & (~FLOAT64_HIDDEN_BIT_MASK));
     238        a.parts.fraction = ( (frac1 >> 6 ) & (~FLOAT64_HIDDEN_BIT_MASK));
    227239        return a;
    228240}

  • softfloat/generic/comparison.c

    rb7e65d4 r1266543  
    3131
    3232inline int isFloat32NaN(float32 f)
    33 {       /* NaN : exp = 0xff and nonzero mantisa */
    34         return ((f.parts.exp==0xFF)&&(f.parts.mantisa));
     33{       /* NaN : exp = 0xff and nonzero fraction */
     34        return ((f.parts.exp==0xFF)&&(f.parts.fraction));
    3535};
    3636
    3737inline int isFloat64NaN(float64 d)
    38 {       /* NaN : exp = 0x7ff and nonzero mantisa */
    39         return ((d.parts.exp==0x7FF)&&(d.parts.mantisa));
     38{       /* NaN : exp = 0x7ff and nonzero fraction */
     39        return ((d.parts.exp==0x7FF)&&(d.parts.fraction));
    4040};
    4141
    4242inline int isFloat32SigNaN(float32 f)
    43 {       /* SigNaN : exp = 0xff mantisa = 0xxxxx..x (binary), where at least one x is nonzero */
    44         return ((f.parts.exp==0xFF)&&(f.parts.mantisa<0x400000)&&(f.parts.mantisa));
     43{       /* SigNaN : exp = 0xff fraction = 0xxxxx..x (binary), where at least one x is nonzero */
     44        return ((f.parts.exp==0xFF)&&(f.parts.fraction<0x400000)&&(f.parts.fraction));
    4545};
    4646
    4747inline int isFloat64SigNaN(float64 d)
    48 {       /* SigNaN : exp = 0x7ff mantisa = 0xxxxx..x (binary), where at least one x is nonzero */
    49         return ((d.parts.exp==0x7FF)&&(d.parts.mantisa)&&(d.parts.mantisa<0x8000000000000ll));
     48{       /* SigNaN : exp = 0x7ff fraction = 0xxxxx..x (binary), where at least one x is nonzero */
     49        return ((d.parts.exp==0x7FF)&&(d.parts.fraction)&&(d.parts.fraction<0x8000000000000ll));
    5050};
    5151
    5252inline int isFloat32Infinity(float32 f)
    5353{
    54         return ((f.parts.exp==0xFF)&&(f.parts.mantisa==0x0));
     54        return ((f.parts.exp==0xFF)&&(f.parts.fraction==0x0));
    5555};
    5656
    5757inline int isFloat64Infinity(float64 d)
    5858{
    59         return ((d.parts.exp==0x7FF)&&(d.parts.mantisa==0x0));
     59        return ((d.parts.exp==0x7FF)&&(d.parts.fraction==0x0));
    6060};
    6161

  • softfloat/generic/conversion.c

    rb7e65d4 r1266543  
    3333{
    3434        float64 result;
    35         __u64 mant;
     35        __u64 frac;
    3636       
    3737        result.parts.sign = a.parts.sign;
    38         result.parts.mantisa = a.parts.mantisa;
    39         result.parts.mantisa <<= (FLOAT64_MANTISA_SIZE - FLOAT32_MANTISA_SIZE );
     38        result.parts.fraction = a.parts.fraction;
     39        result.parts.fraction <<= (FLOAT64_FRACTION_SIZE - FLOAT32_FRACTION_SIZE );
    4040       
    4141        if ((isFloat32Infinity(a))||(isFloat32NaN(a))) {
    … …  
    4949                /* normalize denormalized numbers */
    5050
    51                 if (result.parts.mantisa == 0ll) { /* fix zero */
     51                if (result.parts.fraction == 0ll) { /* fix zero */
    5252                        result.parts.exp = 0ll;
    5353                        return result;
    5454                }
    5555                       
    56                 mant = result.parts.mantisa;
     56                frac = result.parts.fraction;
    5757               
    58                 while (!(mant & (0x10000000000000ll))) {
    59                         mant <<= 1;
     58                while (!(frac & (0x10000000000000ll))) {
     59                        frac <<= 1;
    6060                        --result.parts.exp;
    6161                };
    6262               
    6363                ++result.parts.exp;
    64                 result.parts.mantisa = mant;
     64                result.parts.fraction = frac;
    6565        };
    6666       
    … …  
    7373        float32 result;
    7474        __s32 exp;
    75         __u64 mant;
     75        __u64 frac;
    7676       
    7777        result.parts.sign = a.parts.sign;
    … …  
    8282               
    8383                if (isFloat64SigNaN(a)) {
    84                         result.parts.mantisa = 0x800000; /* set first bit of mantisa nonzero */
     84                        result.parts.fraction = 0x800000; /* set first bit of fraction nonzero */
    8585                        return result;
    8686                }
    8787       
    88                 result.parts.mantisa = 0x1; /* mantisa nonzero but its first bit is zero */
     88                result.parts.fraction = 0x1; /* fraction nonzero but its first bit is zero */
    8989                return result;
    9090        };
    9191
    9292        if (isFloat64Infinity(a)) {
    93                 result.parts.mantisa = 0;
     93                result.parts.fraction = 0;
    9494                result.parts.exp = 0xFF;
    9595                return result;
    … …  
    100100        if (exp >= 0xFF) {
    101101                /*FIXME: overflow*/
    102                 result.parts.mantisa = 0;
     102                result.parts.fraction = 0;
    103103                result.parts.exp = 0xFF;
    104104                return result;
    … …  
    111111               
    112112                exp *= -1;     
    113                 if (exp > FLOAT32_MANTISA_SIZE ) {
     113                if (exp > FLOAT32_FRACTION_SIZE ) {
    114114                        /* FIXME: underflow */
    115                         result.parts.mantisa = 0;
     115                        result.parts.fraction = 0;
    116116                        return result;
    117117                };
    … …  
    119119                /* denormalized */
    120120               
    121                 mant = a.parts.mantisa;
    122                 mant |= 0x10000000000000ll; /* denormalize and set hidden bit */
     121                frac = a.parts.fraction;
     122                frac |= 0x10000000000000ll; /* denormalize and set hidden bit */
    123123               
    124                 mant >>= (FLOAT64_MANTISA_SIZE - FLOAT32_MANTISA_SIZE + 1);
     124                frac >>= (FLOAT64_FRACTION_SIZE - FLOAT32_FRACTION_SIZE + 1);
    125125               
    126126                while (exp > 0) {
    127127                        --exp;
    128                         mant >>= 1;
     128                        frac >>= 1;
    129129                };
    130                 result.parts.mantisa = mant;
     130                result.parts.fraction = frac;
    131131               
    132132                return result;
    … …  
    134134
    135135        result.parts.exp = exp;
    136         result.parts.mantisa = a.parts.mantisa >> (FLOAT64_MANTISA_SIZE - FLOAT32_MANTISA_SIZE);
     136        result.parts.fraction = a.parts.fraction >> (FLOAT64_FRACTION_SIZE - FLOAT32_FRACTION_SIZE);
    137137        return result;
    138138};

  • softfloat/generic/div.c

    rb7e65d4 r1266543  
    3333float32 divFloat32(float32 a, float32 b)
    3434{
    35 /* TODO: */
     35        float32 result;
     36        __s32 aexp, bexp, cexp;
     37        __u64 afrac, bfrac, cfrac;
    3638       
     39        result.parts.sign = a.parts.sign ^ b.parts.sign;
     40       
     41        if (isFloat32NaN(a)) {
     42                if (isFloat32SigNaN(a)) {
     43                        /*FIXME: SigNaN*/
     44                }
     45                /*NaN*/
     46                return a;
     47        }
     48       
     49        if (isFloat32NaN(b)) {
     50                if (isFloat32SigNaN(b)) {
     51                        /*FIXME: SigNaN*/
     52                }
     53                /*NaN*/
     54                return b;
     55        }
     56       
     57        if (isFloat32Infinity(a)) {
     58                if (isFloat32Infinity(b)) {
     59                        /*FIXME: inf / inf */
     60                        result.binary = FLOAT32_NAN;
     61                        return result;
     62                }
     63                /* inf / num */
     64                result.parts.exp = a.parts.exp;
     65                result.parts.fraction = a.parts.fraction;
     66                return result;
     67        }
     68
     69        if (isFloat32Infinity(b)) {
     70                if (isFloat32Zero(a)) {
     71                        /* FIXME 0 / inf */
     72                        result.parts.exp = 0;
     73                        result.parts.fraction = 0;
     74                        return result;
     75                }
     76                /* FIXME: num / inf*/
     77                result.parts.exp = 0;
     78                result.parts.fraction = 0;
     79                return result;
     80        }
     81       
     82        if (isFloat32Zero(b)) {
     83                if (isFloat32Zero(a)) {
     84                        /*FIXME: 0 / 0*/
     85                        result.binary = FLOAT32_NAN;
     86                        return result;
     87                }
     88                /* FIXME: division by zero */
     89                result.parts.exp = 0;
     90                result.parts.fraction = 0;
     91                return result;
     92        }
     93
     94       
     95        afrac = a.parts.fraction;
     96        aexp = a.parts.exp;
     97        bfrac = b.parts.fraction;
     98        bexp = b.parts.exp;
     99       
     100        /* denormalized numbers */
     101        if (aexp == 0) {
     102                if (afrac == 0) {
     103                result.parts.exp = 0;
     104                result.parts.fraction = 0;
     105                return result;
     106                }
     107                /* normalize it*/
     108               
     109                afrac <<= 1;
     110                        /* afrac is nonzero => it must stop */ 
     111                while (! (afrac & FLOAT32_HIDDEN_BIT_MASK) ) {
     112                        afrac <<= 1;
     113                        aexp--;
     114                }
     115        }
     116
     117        if (bexp == 0) {
     118                bfrac <<= 1;
     119                        /* bfrac is nonzero => it must stop */ 
     120                while (! (bfrac & FLOAT32_HIDDEN_BIT_MASK) ) {
     121                        bfrac <<= 1;
     122                        bexp--;
     123                }
     124        }
     125
     126        afrac = (afrac | FLOAT32_HIDDEN_BIT_MASK ) << (32 - FLOAT32_FRACTION_SIZE - 1 );
     127        bfrac = (bfrac | FLOAT32_HIDDEN_BIT_MASK ) << (32 - FLOAT32_FRACTION_SIZE );
     128
     129        if ( bfrac <= (afrac << 1) ) {
     130                afrac >>= 1;
     131                aexp++;
     132        }
     133       
     134        cexp = aexp - bexp + FLOAT32_BIAS - 2;
     135       
     136        cfrac = (afrac << 32) / bfrac;
     137        if ((  cfrac & 0x3F ) == 0) {
     138                cfrac |= ( bfrac * cfrac != afrac << 32 );
     139        }
     140       
     141        /* pack and round */
     142       
     143        /* TODO: find first nonzero digit and shift result and detect possibly underflow */
     144        while ((cexp > 0) && (cfrac) && (!(cfrac & (FLOAT32_HIDDEN_BIT_MASK << 7 )))) {
     145                cexp--;
     146                cfrac <<= 1;
     147                        /* TODO: fix underflow */
     148        };
     149       
     150       
     151        cfrac += (0x1 << 6); /* FIXME: 7 is not sure*/
     152       
     153        if (cfrac & (FLOAT32_HIDDEN_BIT_MASK << 7)) {
     154                ++cexp;
     155                cfrac >>= 1;
     156                }       
     157
     158        /* check overflow */
     159        if (cexp >= FLOAT32_MAX_EXPONENT ) {
     160                /* FIXME: overflow, return infinity */
     161                result.parts.exp = FLOAT32_MAX_EXPONENT;
     162                result.parts.fraction = 0;
     163                return result;
     164        }
     165
     166        if (cexp < 0) {
     167                /* FIXME: underflow */
     168                result.parts.exp = 0;
     169                if ((cexp + FLOAT32_FRACTION_SIZE) < 0) {
     170                        result.parts.fraction = 0;
     171                        return result;
     172                }
     173                cfrac >>= 1;
     174                while (cexp < 0) {
     175                        cexp ++;
     176                        cfrac >>= 1;
     177                }
     178               
     179        } else {
     180                result.parts.exp = (__u32)cexp;
     181        }
     182       
     183        result.parts.fraction = ((cfrac >> 6) & (~FLOAT32_HIDDEN_BIT_MASK));
     184       
     185        return result; 
    37186}
    38187

  • 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);

  • softfloat/generic/softfloat.c

    rb7e65d4 r1266543  
    4444{
    4545        float32 fa, fb;
    46         fa.f=a;
    47         fb.f=b;
    48         if (fa.parts.sign!=fb.parts.sign) {
     46        fa.f = a;
     47        fb.f = b;
     48        if (fa.parts.sign != fb.parts.sign) {
    4949                if (fa.parts.sign) {
    50                         fa.parts.sign=0;
    51                         return subFloat32(fb,fa).f;
    52                 };
    53                 fb.parts.sign=0;
    54                 return subFloat32(fa,fb).f;
     50                        fa.parts.sign = 0;
     51                        return subFloat32(fb, fa).f;
     52                };
     53                fb.parts.sign = 0;
     54                return subFloat32(fa, fb).f;
    5555        }
    56         return addFloat32(fa,fb).f;
     56        return addFloat32(fa, fb).f;
    5757}
    5858
    … …  
    6060{
    6161        float64 da, db;
    62         da.d=a;
    63         db.d=b;
    64         if (da.parts.sign!=db.parts.sign) {
     62        da.d = a;
     63        db.d = b;
     64        if (da.parts.sign != db.parts.sign) {
    6565                if (da.parts.sign) {
    66                         da.parts.sign=0;
    67                         return subFloat64(db,da).d;
    68                 };
    69                 db.parts.sign=0;
    70                 return subFloat64(da,db).d;
     66                        da.parts.sign = 0;
     67                        return subFloat64(db, da).d;
     68                };
     69                db.parts.sign = 0;
     70                return subFloat64(da, db).d;
    7171        }
    72         return addFloat64(da,db).d;
     72        return addFloat64(da, db).d;
    7373}
    7474
    … …  
    7676{
    7777        float32 fa, fb;
    78         fa.f=a;
    79         fb.f=b;
    80         if (fa.parts.sign!=fb.parts.sign) {
    81                 fb.parts.sign=!fb.parts.sign;
    82                 return addFloat32(fa,fb).f;
     78        fa.f = a;
     79        fb.f = b;
     80        if (fa.parts.sign != fb.parts.sign) {
     81                fb.parts.sign = !fb.parts.sign;
     82                return addFloat32(fa, fb).f;
    8383        }
    84         return subFloat32(fa,fb).f;
     84        return subFloat32(fa, fb).f;
    8585}
    8686
    … …  
    100100{
    101101        float32 fa, fb;
    102         fa.f=a;
    103         fb.f=b;
     102        fa.f = a;
     103        fb.f = b;
    104104        return  mulFloat32(fa, fb).f;
    105105}
    … …  
    116116{
    117117        float32 fa, fb;
    118         fa.f=a;
    119         fb.f=b;
    120         //return        divFloat32(fa, fb).f;
     118        fa.f = a;
     119        fb.f = b;
     120        return  divFloat32(fa, fb).f;
    121121}
    122122
    … …  
    124124{
    125125        float32 fa;
    126         fa.f=a;
    127         fa.parts.sign=!fa.parts.sign;
     126        fa.f = a;
     127        fa.parts.sign = !fa.parts.sign;
    128128        return fa.f;
    129129}
    … …  
    132132{
    133133        float64 fa;
    134         fa.d=a;
    135         fa.parts.sign=!fa.parts.sign;
     134        fa.d = a;
     135        fa.parts.sign = !fa.parts.sign;
    136136        return fa.d;
    137137}
    … …  
    162162int __cmpsf2(float a, float b)
    163163{
    164         float32 fa,fb;
    165         fa.f=a;
    166         fb.f=b;
    167         if ((isFloat32NaN(fa))||(isFloat32NaN(fb))) {
     164        float32 fa, fb;
     165        fa.f = a;
     166        fb.f = b;
     167        if ( (isFloat32NaN(fa)) || (isFloat32NaN(fb)) ) {
    168168                return 1; /* no special constant for unordered - maybe signaled? */
    169169        };
    170170
    171171       
    172         if (isFloat32eq(fa,fb)) {
     172        if (isFloat32eq(fa, fb)) {
    173173                return 0;
    174174        };
    175175       
    176         if (isFloat32lt(fa,fb)) {
     176        if (isFloat32lt(fa, fb)) {
    177177                return -1;
    178178                };
    … …  
    182182int __unordsf2(float a, float b)
    183183{
    184         float32 fa,fb;
    185         fa.f=a;
    186         fb.f=b;
    187         return ((isFloat32NaN(fa))||(isFloat32NaN(fb)));
     184        float32 fa, fb;
     185        fa.f = a;
     186        fb.f = b;
     187        return ( (isFloat32NaN(fa)) || (isFloat32NaN(fb)) );
    188188}
    189189
    … …  
    193193int __eqsf2(float a, float b)
    194194{
    195         float32 fa,fb;
    196         fa.f=a;
    197         fb.f=b;
    198         if ((isFloat32NaN(fa))||(isFloat32NaN(fb))) {
    199                 /* TODO: sigNaNs*/
    200                 return 1;
    201                 };
    202         return isFloat32eq(fa,fb)-1;
     195        float32 fa, fb;
     196        fa.f = a;
     197        fb.f = b;
     198        if ( (isFloat32NaN(fa)) || (isFloat32NaN(fb)) ) {
     199                /* TODO: sigNaNs*/
     200                return 1;
     201                };
     202        return isFloat32eq(fa, fb) - 1;
    203203}
    204204
    … …  
    206206int __nesf2(float a, float b)
    207207{
    208         return __eqsf2(a,b);
     208        return __eqsf2(a, b);
    209209}
    210210
    … …  
    212212int __gesf2(float a, float b)
    213213{
    214         float32 fa,fb;
    215         fa.f=a;
    216         fb.f=b;
    217         if ((isFloat32NaN(fa))||(isFloat32NaN(fb))) {
    218                 /* TODO: sigNaNs*/
    219                 return -1;
    220                 };
    221        
    222         if (isFloat32eq(fa,fb)) {
     214        float32 fa, fb;
     215        fa.f = a;
     216        fb.f = b;
     217        if ( (isFloat32NaN(fa)) || (isFloat32NaN(fb)) ) {
     218                /* TODO: sigNaNs*/
     219                return -1;
     220                };
     221       
     222        if (isFloat32eq(fa, fb)) {
    223223                return 0;
    224224        };
    225225       
    226         if (isFloat32gt(fa,fb)) {
     226        if (isFloat32gt(fa, fb)) {
    227227                return 1;
    228228                };
    … …  
    234234int __ltsf2(float a, float b)
    235235{
    236         float32 fa,fb;
    237         fa.f=a;
    238         fb.f=b;
    239         if ((isFloat32NaN(fa))||(isFloat32NaN(fb))) {
     236        float32 fa, fb;
     237        fa.f = a;
     238        fb.f = b;
     239        if ( (isFloat32NaN(fa)) || (isFloat32NaN(fb)) ) {
    240240                /* TODO: sigNaNs*/
    241241                return 1;
    … …  
    250250int __lesf2(float a, float b)
    251251{
    252         float32 fa,fb;
    253         fa.f=a;
    254         fb.f=b;
    255         if ((isFloat32NaN(fa))||(isFloat32NaN(fb))) {
    256                 /* TODO: sigNaNs*/
    257                 return 1;
    258                 };
    259        
    260         if (isFloat32eq(fa,fb)) {
     252        float32 fa, fb;
     253        fa.f = a;
     254        fb.f = b;
     255        if ( (isFloat32NaN(fa)) || (isFloat32NaN(fb)) ) {
     256                /* TODO: sigNaNs*/
     257                return 1;
     258                };
     259       
     260        if (isFloat32eq(fa, fb)) {
    261261                return 0;
    262262        };
    263263       
    264         if (isFloat32lt(fa,fb)) {
     264        if (isFloat32lt(fa, fb)) {
    265265                return -1;
    266266                };
    … …  
    272272int __gtsf2(float a, float b)
    273273{
    274         float32 fa,fb;
    275         fa.f=a;
    276         fb.f=b;
    277         if ((isFloat32NaN(fa))||(isFloat32NaN(fb))) {
     274        float32 fa, fb;
     275        fa.f = a;
     276        fb.f = b;
     277        if ( (isFloat32NaN(fa)) || (isFloat32NaN(fb)) ) {
    278278                /* TODO: sigNaNs*/
    279279                return -1;
    … …  
    289289float __powisf2(float a, int b)
    290290{
    291 //TODO:
     291/* TODO: */
    292292}
    293293
    294294float __mulsc3(float a, float b, float c, float d)
    295295{
    296 //TODO:
     296/* TODO: */
    297297}
    298298
    299299float __divsc3(float a, float b, float c, float d)
    300300{
    301 //TODO:
    302 }
    303 
     301/* TODO: */
     302}
     303

  • softfloat/generic/sub.c

    rb7e65d4 r1266543  
    3636{
    3737        int expdiff;
    38         __u32 exp1, exp2, mant1, mant2;
     38        __u32 exp1, exp2, frac1, frac2;
    3939        float32 result;
    4040
    … …  
    4242       
    4343        expdiff = a.parts.exp - b.parts.exp;
    44         if ((expdiff < 0 ) || ((expdiff == 0) && (a.parts.mantisa < b.parts.mantisa))) {
     44        if ((expdiff < 0 ) || ((expdiff == 0) && (a.parts.fraction < b.parts.fraction))) {
    4545                if (isFloat32NaN(b)) {
    46                         //TODO: fix SigNaN
     46                        /* TODO: fix SigNaN */
    4747                        if (isFloat32SigNaN(b)) {
    4848                        };
    … …  
    5757                result.parts.sign = !a.parts.sign;
    5858               
    59                 mant1 = b.parts.mantisa;
     59                frac1 = b.parts.fraction;
    6060                exp1 = b.parts.exp;
    61                 mant2 = a.parts.mantisa;
     61                frac2 = a.parts.fraction;
    6262                exp2 = a.parts.exp;
    6363                expdiff *= -1;
    6464        } else {
    6565                if (isFloat32NaN(a)) {
    66                         //TODO: fix SigNaN
     66                        /* TODO: fix SigNaN */
    6767                        if (isFloat32SigNaN(a) || isFloat32SigNaN(b)) {
    6868                        };
    … …  
    7373                        if (b.parts.exp == FLOAT32_MAX_EXPONENT) {
    7474                                /* inf - inf => nan */
    75                                 //TODO: fix exception
     75                                /* TODO: fix exception */
    7676                                result.binary = FLOAT32_NAN;
    7777                                return result;
    … …  
    8282                result.parts.sign = a.parts.sign;
    8383               
    84                 mant1 = a.parts.mantisa;
     84                frac1 = a.parts.fraction;
    8585                exp1 = a.parts.exp;
    86                 mant2 = b.parts.mantisa;
     86                frac2 = b.parts.fraction;
    8787                exp2 = b.parts.exp;     
    8888        };
    8989       
    9090        if (exp1 == 0) {
    91                 //both are denormalized
    92                 result.parts.mantisa = mant1-mant2;
    93                 if (result.parts.mantisa > mant1) {
    94                         //TODO: underflow exception
     91                /* both are denormalized */
     92                result.parts.fraction = frac1-frac2;
     93                if (result.parts.fraction > frac1) {
     94                        /* TODO: underflow exception */
    9595                        return result;
    9696                };
    … …  
    100100
    101101        /* add hidden bit */
    102         mant1 |= FLOAT32_HIDDEN_BIT_MASK;
     102        frac1 |= FLOAT32_HIDDEN_BIT_MASK;
    103103       
    104104        if (exp2 == 0) {
    … …  
    107107        } else {
    108108                /* normalized */
    109                 mant2 |= FLOAT32_HIDDEN_BIT_MASK;
     109                frac2 |= FLOAT32_HIDDEN_BIT_MASK;
    110110        };
    111111       
    112112        /* create some space for rounding */
    113         mant1 <<= 6;
    114         mant2 <<= 6;
    115        
    116         if (expdiff > FLOAT32_MANTISA_SIZE + 1) {
     113        frac1 <<= 6;
     114        frac2 <<= 6;
     115       
     116        if (expdiff > FLOAT32_FRACTION_SIZE + 1) {
    117117             goto done;
    118118             };
    119119       
    120         mant1 = mant1 - (mant2 >> expdiff);
     120        frac1 = frac1 - (frac2 >> expdiff);
    121121done:
    122         //TODO: find first nonzero digit and shift result and detect possibly underflow
    123         while ((exp1 > 0) && (!(mant1 & (FLOAT32_HIDDEN_BIT_MASK << 6 )))) {
     122        /* TODO: find first nonzero digit and shift result and detect possibly underflow */
     123        while ((exp1 > 0) && (!(frac1 & (FLOAT32_HIDDEN_BIT_MASK << 6 )))) {
    124124                --exp1;
    125                 mant1 <<= 1;
    126                         /* TODO: fix underflow - mant1 == 0 does not necessary means underflow... */
    127         };
    128        
    129         /* rounding - if first bit after mantisa is set then round up */
    130         mant1 += 0x20;
    131 
    132         if (mant1 & (FLOAT32_HIDDEN_BIT_MASK << 7)) {
     125                frac1 <<= 1;
     126                        /* TODO: fix underflow - frac1 == 0 does not necessary means underflow... */
     127        };
     128       
     129        /* rounding - if first bit after fraction is set then round up */
     130        frac1 += 0x20;
     131
     132        if (frac1 & (FLOAT32_HIDDEN_BIT_MASK << 7)) {
    133133                ++exp1;
    134                 mant1 >>= 1;
     134                frac1 >>= 1;
    135135        };
    136136       
    137137        /*Clear hidden bit and shift */
    138         result.parts.mantisa = ((mant1 >> 6) & (~FLOAT32_HIDDEN_BIT_MASK));
     138        result.parts.fraction = ((frac1 >> 6) & (~FLOAT32_HIDDEN_BIT_MASK));
    139139        result.parts.exp = exp1;
    140140       
    … …  
    148148        int expdiff;
    149149        __u32 exp1, exp2;
    150         __u64 mant1, mant2;
     150        __u64 frac1, frac2;
    151151        float64 result;
    152152
    … …  
    154154       
    155155        expdiff = a.parts.exp - b.parts.exp;
    156         if ((expdiff < 0 ) || ((expdiff == 0) && (a.parts.mantisa < b.parts.mantisa))) {
     156        if ((expdiff < 0 ) || ((expdiff == 0) && (a.parts.fraction < b.parts.fraction))) {
    157157                if (isFloat64NaN(b)) {
    158                         //TODO: fix SigNaN
     158                        /* TODO: fix SigNaN */
    159159                        if (isFloat64SigNaN(b)) {
    160160                        };
    … …  
    169169                result.parts.sign = !a.parts.sign;
    170170               
    171                 mant1 = b.parts.mantisa;
     171                frac1 = b.parts.fraction;
    172172                exp1 = b.parts.exp;
    173                 mant2 = a.parts.mantisa;
     173                frac2 = a.parts.fraction;
    174174                exp2 = a.parts.exp;
    175175                expdiff *= -1;
    176176        } else {
    177177                if (isFloat64NaN(a)) {
    178                         //TODO: fix SigNaN
     178                        /* TODO: fix SigNaN */
    179179                        if (isFloat64SigNaN(a) || isFloat64SigNaN(b)) {
    180180                        };
    … …  
    185185                        if (b.parts.exp == FLOAT64_MAX_EXPONENT) {
    186186                                /* inf - inf => nan */
    187                                 //TODO: fix exception
     187                                /* TODO: fix exception */
    188188                                result.binary = FLOAT64_NAN;
    189189                                return result;
    … …  
    194194                result.parts.sign = a.parts.sign;
    195195               
    196                 mant1 = a.parts.mantisa;
     196                frac1 = a.parts.fraction;
    197197                exp1 = a.parts.exp;
    198                 mant2 = b.parts.mantisa;
     198                frac2 = b.parts.fraction;
    199199                exp2 = b.parts.exp;     
    200200        };
    201201       
    202202        if (exp1 == 0) {
    203                 //both are denormalized
    204                 result.parts.mantisa = mant1 - mant2;
    205                 if (result.parts.mantisa > mant1) {
    206                         //TODO: underflow exception
     203                /* both are denormalized */
     204                result.parts.fraction = frac1 - frac2;
     205                if (result.parts.fraction > frac1) {
     206                        /* TODO: underflow exception */
    207207                        return result;
    208208                };
    … …  
    212212
    213213        /* add hidden bit */
    214         mant1 |= FLOAT64_HIDDEN_BIT_MASK;
     214        frac1 |= FLOAT64_HIDDEN_BIT_MASK;
    215215       
    216216        if (exp2 == 0) {
    … …  
    219219        } else {
    220220                /* normalized */
    221                 mant2 |= FLOAT64_HIDDEN_BIT_MASK;
     221                frac2 |= FLOAT64_HIDDEN_BIT_MASK;
    222222        };
    223223       
    224224        /* create some space for rounding */
    225         mant1 <<= 6;
    226         mant2 <<= 6;
    227        
    228         if (expdiff > FLOAT64_MANTISA_SIZE + 1) {
     225        frac1 <<= 6;
     226        frac2 <<= 6;
     227       
     228        if (expdiff > FLOAT64_FRACTION_SIZE + 1) {
    229229             goto done;
    230230             };
    231231       
    232         mant1 = mant1 - (mant2 >> expdiff);
     232        frac1 = frac1 - (frac2 >> expdiff);
    233233done:
    234         //TODO: find first nonzero digit and shift result and detect possibly underflow
    235         while ((exp1 > 0) && (!(mant1 & (FLOAT64_HIDDEN_BIT_MASK << 6 )))) {
     234        /* TODO: find first nonzero digit and shift result and detect possibly underflow */
     235        while ((exp1 > 0) && (!(frac1 & (FLOAT64_HIDDEN_BIT_MASK << 6 )))) {
    236236                --exp1;
    237                 mant1 <<= 1;
    238                         /* TODO: fix underflow - mant1 == 0 does not necessary means underflow... */
    239         };
    240        
    241         /* rounding - if first bit after mantisa is set then round up */
    242         mant1 += 0x20;
    243 
    244         if (mant1 & (FLOAT64_HIDDEN_BIT_MASK << 7)) {
     237                frac1 <<= 1;
     238                        /* TODO: fix underflow - frac1 == 0 does not necessary means underflow... */
     239        };
     240       
     241        /* rounding - if first bit after fraction is set then round up */
     242        frac1 += 0x20;
     243
     244        if (frac1 & (FLOAT64_HIDDEN_BIT_MASK << 7)) {
    245245                ++exp1;
    246                 mant1 >>= 1;
     246                frac1 >>= 1;
    247247        };
    248248       
    249249        /*Clear hidden bit and shift */
    250         result.parts.mantisa = ((mant1 >> 6) & (~FLOAT64_HIDDEN_BIT_MASK));
     250        result.parts.fraction = ((frac1 >> 6) & (~FLOAT64_HIDDEN_BIT_MASK));
    251251        result.parts.exp = exp1;
    252252       

  • softfloat/include/sftypes.h

    rb7e65d4 r1266543  
    3838                __u32 sign:1;
    3939                __u32 exp:8;
    40                 __u32 mantisa:23;
     40                __u32 fraction:23;
    4141                #elif defined __LITTLE_ENDIAN__
    42                 __u32 mantisa:23;
     42                __u32 fraction:23;
    4343                __u32 exp:8;
    4444                __u32 sign:1;
    … …  
    5757                __u64 sign:1;
    5858                __u64 exp:11;
    59                 __u64 mantisa:52;
     59                __u64 fraction:52;
    6060                #elif defined __LITTLE_ENDIAN__
    61                 __u64 mantisa:52;
     61                __u64 fraction:52;
    6262                __u64 exp:11;
    6363                __u64 sign:1;
    … …  
    8282#define FLOAT64_INF 0x7FF0000000000000ll
    8383
    84 #define FLOAT32_MANTISA_SIZE 23
    85 #define FLOAT64_MANTISA_SIZE 52
     84#define FLOAT32_FRACTION_SIZE 23
     85#define FLOAT64_FRACTION_SIZE 52
    8686
    8787#define FLOAT32_HIDDEN_BIT_MASK 0x800000
Note: See TracChangeset for help on using the changeset viewer.