Changeset e979fea in mainline

Timestamp:

2006-02-10T13:43:41Z (19 years ago)

Author:

Josef Cejka <malyzelenyhnus@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

d3ca210

Parents:

e6a40ac

Message:

Fixed some problems with 64 bit arithmetic but others still persisting.

Location:

softfloat

Files:

• generic/common.c (added)
• generic/div.c (modified) (2 diffs)
• generic/mul.c (modified) (4 diffs)
• include/common.h (added)
• include/div.h (modified) (1 diff)

softfloat/generic/div.c

@@ -32 +32 @@
 #include<comparison.h>
 #include<mul.h>
+#include<common.h>
+
 
 float32 divFloat32(float32 a, float32 b) 
@@ -307 +309 @@
         }
         
-        /* pack and round */
-        
-        /* find first nonzero digit and shift result and detect possibly underflow */
-        while ((cexp > 0) && (cfrac) && (!(cfrac & (FLOAT64_HIDDEN_BIT_MASK << (64 - FLOAT64_FRACTION_SIZE - 1 ) )))) {
-                cexp--; 
-                cfrac <<= 1;
-                        /* TODO: fix underflow */
-        };
-        
-        
-        cfrac >>= 1;
-        ++cexp;
-        cfrac += (0x1 << (64 - FLOAT64_FRACTION_SIZE - 3)); 
-
-        if (cfrac & (FLOAT64_HIDDEN_BIT_MASK << (64 - FLOAT64_FRACTION_SIZE - 1 ))) {
-                ++cexp;
-                cfrac >>= 1;
-                }       
-
-        /* check overflow */
-        if (cexp >= FLOAT64_MAX_EXPONENT ) {
-                /* FIXME: overflow, return infinity */
-                result.parts.exp = FLOAT64_MAX_EXPONENT;
-                result.parts.fraction = 0;
-                return result;
-        }
-
-        if (cexp < 0) {
-                /* FIXME: underflow */
-                result.parts.exp = 0;
-                if ((cexp + FLOAT64_FRACTION_SIZE) < 0) {
-                        result.parts.fraction = 0;
-                        return result;
-                }
-                cfrac >>= 1;
-                while (cexp < 0) {
-                        cexp ++;
-                        cfrac >>= 1;
-                }
-                return result;
-                
-        } else {
-                cexp ++; /*normalized*/
-                result.parts.exp = (__u32)cexp;
-        }
-        
-        result.parts.fraction = ((cfrac >>(64 - FLOAT64_FRACTION_SIZE - 2 ) ) & (~FLOAT64_HIDDEN_BIT_MASK)); 
-        
-        return result;  
+        /* round and shift */
+        result = finishFloat64(cexp, cfrac, result.parts.sign);
+        return result;
+
 }
 

softfloat/generic/mul.c

@@ -30 +30 @@
 #include<mul.h>
 #include<comparison.h>
+#include<common.h>
 
 /** Multiply two 32 bit float numbers
@@ -218 +219 @@
 
         /* exp is signed so we can easy detect underflow */
-        exp = a.parts.exp + b.parts.exp;
-        exp -= FLOAT64_BIAS;
-        
-        if (exp >= FLOAT64_MAX_EXPONENT) {
-                /* FIXME: overflow */
-                /* set infinity as result */
-                result.binary = FLOAT64_INF;
-                result.parts.sign = a.parts.sign ^ b.parts.sign;
-                return result;
-        };
-        
-        if (exp < 0) { 
-                /* FIXME: underflow */
-                /* return signed zero */
-                result.parts.fraction = 0x0;
-                result.parts.exp = 0x0;
-                return result;
-        };
+        exp = a.parts.exp + b.parts.exp - FLOAT64_BIAS;
         
         frac1 = a.parts.fraction;
+
         if (a.parts.exp > 0) {
                 frac1 |= FLOAT64_HIDDEN_BIT_MASK;
@@ -252 +237 @@
         };
 
-        frac1 <<= 1; /* one bit space for rounding */
+        frac1 <<= (64 - FLOAT64_FRACTION_SIZE - 1);
+        frac2 <<= (64 - FLOAT64_FRACTION_SIZE - 2);
 
         mul64integers(frac1, frac2, &frac1, &frac2);
 
-/* round and return */
-        /* FIXME: ugly soulution is to shift whole frac2 >> as in 32bit version
-         * Here is is more slower because we have to shift two numbers with carry
-         * Better is find first nonzero bit and make only one shift
-         * Third version is to shift both numbers a bit to right and result will be then 
-         * placed in higher part of result. Then lower part will be good only for rounding.
-         */
-        
-        while ((exp < FLOAT64_MAX_EXPONENT) && (frac2 > 0 )) { 
-                frac1 >>= 1;
-                frac1 &= ((frac2 & 0x1) << 63);
-                frac2 >>= 1;
-                ++exp;
-        }
-        
-        while ((exp < FLOAT64_MAX_EXPONENT) && (frac1 >= ( (__u64)1 << (FLOAT64_FRACTION_SIZE + 2)))) { 
-                ++exp;
-                frac1 >>= 1;
-        };
-
-        /* rounding */
-        /* ++frac1;  FIXME: not works - without it is ok */
-        frac1 >>= 1; /* shift off rounding space */
-        
-        if ((exp < FLOAT64_MAX_EXPONENT) && (frac1 >= ((__u64)1 << (FLOAT64_FRACTION_SIZE + 1)))) {
-                ++exp;
-                frac1 >>= 1;
-        };
-
-        if (exp >= FLOAT64_MAX_EXPONENT ) {     
-                /* TODO: fix overflow */
-                /* return infinity*/
-                result.parts.exp = FLOAT64_MAX_EXPONENT;
-                result.parts.fraction = 0x0;
-                return result;
-        }
-        
-        exp -= FLOAT64_FRACTION_SIZE;
-
-        if (exp <= FLOAT64_FRACTION_SIZE) { 
-                /* denormalized number */
-                frac1 >>= 1; /* denormalize */
-                while ((frac1 > 0) && (exp < 0)) {
-                        frac1 >>= 1;
-                        ++exp;
-                };
-                if (frac1 == 0) {
-                        /* FIXME : underflow */
-                result.parts.exp = 0;
-                result.parts.fraction = 0;
-                return result;
-                };
-        };
-        result.parts.exp = exp; 
-        result.parts.fraction = frac1 & ( ((__u64)1 << FLOAT64_FRACTION_SIZE) - 1);
-        
-        return result;  
-        
+        frac2 |= (frac1 != 0);
+        if (frac2 & (0x1ll << 62)) {
+                frac2 <<= 1;
+                exp--;
+        }
+
+        result = finishFloat64(exp, frac2, result.parts.sign);
+        return result;
 }
 
@@ -326 +262 @@
         __u64 low, high, middle1, middle2;
         __u32 alow, blow;
-        
+
         alow = a & 0xFFFFFFFF;
         blow = b & 0xFFFFFFFF;

softfloat/include/div.h

@@ -34 +34 @@
 
 __u64 divFloat64estim(__u64 a, __u64 b);
+
 #endif