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