Changeset 1266543 in mainline for softfloat/generic/add.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/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}
Note: See TracChangeset for help on using the changeset viewer.