Changeset a96c570 in mainline

Timestamp:

2006-01-22T15:51:00Z (19 years ago)

Author:

Josef Cejka <malyzelenyhnus@…>

Branches:

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

Children:

bff16dd

Parents:

4a5abddd

Message:

Added function for 64bit subtraction.
Fixed bug in recognizing signaling and quiet NaNs.
Some 64-bit add and sub testing done.

Location:

softfloat

Files:

• generic/add.c (modified) (1 diff)
• generic/comparison.c (modified) (1 diff)
• generic/softfloat.c (modified) (2 diffs)
• generic/sub.c (modified) (5 diffs)
• include/sftypes.h (modified) (2 diffs)
• include/sub.h (modified) (1 diff)

softfloat/generic/add.c

@@ -133 +133 @@
 {
         int expdiff;
-        __u64 exp1, exp2, mant1, mant2;
+        __u32 exp1, exp2;
+        __u64 mant1, mant2;
         
         expdiff = a.parts.exp - b.parts.exp;

softfloat/generic/comparison.c

@@ -41 +41 @@
 
 inline int isFloat32SigNaN(float32 f)
-{       /* SigNaN : exp = 0xff mantisa = 1xxxxx..x (binary), where at least one x is nonzero */
-        return ((f.parts.exp==0xFF)&&(f.parts.mantisa>0x400000));
+{       /* SigNaN : exp = 0xff mantisa = 0xxxxx..x (binary), where at least one x is nonzero */
+        return ((f.parts.exp==0xFF)&&(f.parts.mantisa<0x400000)&&(f.parts.mantisa));
 };
 
 inline int isFloat64SigNaN(float64 d)
-{       /* SigNaN : exp = 0x7ff mantisa = 1xxxxx..x (binary), where at least one x is nonzero */
-        return ((d.parts.exp==0x7FF)&&(d.parts.mantisa>0x8000000000000ll));
+{       /* SigNaN : exp = 0x7ff mantisa = 0xxxxx..x (binary), where at least one x is nonzero */
+        return ((d.parts.exp==0x7FF)&&(d.parts.mantisa)&&(d.parts.mantisa<0x8000000000000ll));
 };
 

softfloat/generic/softfloat.c

@@ -57 +57 @@
 }
 
+double __adddf3(double a, double b)
+{
+        float64 da, db;
+        da.d=a;
+        db.d=b;
+        if (da.parts.sign!=db.parts.sign) {
+                if (da.parts.sign) {
+                        da.parts.sign=0;
+                        return subFloat64(db,da).d;
+                };
+                db.parts.sign=0;
+                return subFloat64(da,db).d;
+        }
+        return addFloat64(da,db).d;
+}
+
 float __subsf3(float a, float b)
 {
@@ -67 +83 @@
         }
         return subFloat32(fa,fb).f;
+}
+
+double __subdf3(double a, double b)
+{
+        float64 da, db;
+        da.d = a;
+        db.d = b;
+        if (da.parts.sign != db.parts.sign) {
+                db.parts.sign = !db.parts.sign;
+                return addFloat64(da, db).d;
+        }
+        return subFloat64(da, db).d;
 }
 

softfloat/generic/sub.c

@@ -27 +27 @@
  */
 
-#include "sftypes.h"
-#include "sub.h"
+#include<sftypes.h>
+#include<sub.h>
+#include<comparison.h>
 
 /** Subtract two float32 numbers with same signs
@@ -35 +36 @@
 {
         int expdiff;
-        __u32 exp1,exp2,mant1,mant2;
+        __u32 exp1, exp2, mant1, mant2;
         float32 result;
 
         result.f = 0;
         
-        expdiff=a.parts.exp - b.parts.exp;
-        if ((expdiff<0)||((expdiff==0)&&(a.parts.mantisa<b.parts.mantisa))) {
+        expdiff = a.parts.exp - b.parts.exp;
+        if ((expdiff < 0 ) || ((expdiff == 0) && (a.parts.mantisa < b.parts.mantisa))) {
                 if (isFloat32NaN(b)) {
                         //TODO: fix SigNaN
@@ -49 +50 @@
                 };
                 
-                if (b.parts.exp==0xFF) { 
-                        b.parts.sign=!b.parts.sign; /* num -(+-inf) = -+inf */
+                if (b.parts.exp == FLOAT32_MAX_EXPONENT) { 
+                        b.parts.sign = !b.parts.sign; /* num -(+-inf) = -+inf */
                         return b;
                 }
@@ -56 +57 @@
                 result.parts.sign = !a.parts.sign; 
                 
-                mant1=b.parts.mantisa;
-                exp1=b.parts.exp;
-                mant2=a.parts.mantisa;
-                exp2=a.parts.exp;
-                expdiff*=-1;
+                mant1 = b.parts.mantisa;
+                exp1 = b.parts.exp;
+                mant2 = a.parts.mantisa;
+                exp2 = a.parts.exp;
+                expdiff *= -1;
         } else {
                 if (isFloat32NaN(a)) {
                         //TODO: fix SigNaN
-                        if ((isFloat32SigNaN(a))||(isFloat32SigNaN(b))) {
-                        };
-                        return a;
-                };
-                
-                if (a.parts.exp==0xFF) { 
-                        if (b.parts.exp==0xFF) {
+                        if (isFloat32SigNaN(a) || isFloat32SigNaN(b)) {
+                        };
+                        return a;
+                };
+                
+                if (a.parts.exp == FLOAT32_MAX_EXPONENT) { 
+                        if (b.parts.exp == FLOAT32_MAX_EXPONENT) {
                                 /* inf - inf => nan */
                                 //TODO: fix exception
@@ -81 +82 @@
                 result.parts.sign = a.parts.sign;
                 
-                mant1=a.parts.mantisa;
-                exp1=a.parts.exp;
-                mant2=b.parts.mantisa;
-                exp2=b.parts.exp;       
-        };
-        
-        if (exp1==0) {
+                mant1 = a.parts.mantisa;
+                exp1 = a.parts.exp;
+                mant2 = b.parts.mantisa;
+                exp2 = b.parts.exp;     
+        };
+        
+        if (exp1 == 0) {
                 //both are denormalized
-                result.parts.mantisa=mant1-mant2;
-                if (result.parts.mantisa>mant1) {
+                result.parts.mantisa = mant1-mant2;
+                if (result.parts.mantisa > mant1) {
                         //TODO: underflow exception
                         return result;
                 };
-                result.parts.exp=0;
+                result.parts.exp = 0;
                 return result;
         };
-        
-        // create some space for rounding
-        mant1<<=6;
-        mant2<<=6;
-        
-        mant1|=0x20000000; //add hidden bit
-        
-        
-        if (exp2==0) {
+
+        /* add hidden bit */
+        mant1 |= FLOAT32_HIDDEN_BIT_MASK; 
+        
+        if (exp2 == 0) {
+                /* denormalized */
                 --expdiff;      
         } else {
-                mant2|=0x20000000; //hidden bit
-        };
-        
-        if (expdiff>24) {
+                /* normalized */
+                mant2 |= FLOAT32_HIDDEN_BIT_MASK;
+        };
+        
+        /* create some space for rounding */
+        mant1 <<= 6;
+        mant2 <<= 6;
+        
+        if (expdiff > FLOAT32_MANTISA_SIZE + 1) {
              goto done; 
              };
         
-        mant1 = mant1-(mant2>>expdiff);
+        mant1 = mant1 - (mant2 >> expdiff);
 done:
         //TODO: find first nonzero digit and shift result and detect possibly underflow
-        while ((exp1>0)&&(!(mant1&0x20000000))) {
-                exp1--;
+        while ((exp1 > 0) && (!(mant1 & (FLOAT32_HIDDEN_BIT_MASK << 6 )))) {
+                --exp1;
                 mant1 <<= 1;
                         /* TODO: fix underflow - mant1 == 0 does not necessary means underflow... */
         };
         
-        //rounding - if first bit after mantisa is set then round up    
+        /* rounding - if first bit after mantisa is set then round up */
         mant1 += 0x20;
 
-        if (mant1&0x40000000) {
+        if (mant1 & (FLOAT32_HIDDEN_BIT_MASK << 7)) {
                 ++exp1;
-                mant1>>=1;
-        };
-        
-        result.parts.mantisa = ((mant1&(~0x20000000))>>6); /*Clear hidden bit and shift */
+                mant1 >>= 1;
+        };
+        
+        /*Clear hidden bit and shift */
+        result.parts.mantisa = ((mant1 >> 6) & (~FLOAT32_HIDDEN_BIT_MASK)); 
         result.parts.exp = exp1;
         
         return result;
-};
-
+}
+
+/** Subtract two float64 numbers with same signs
+ */
+float64 subFloat64(float64 a, float64 b)
+{
+        int expdiff;
+        __u32 exp1, exp2;
+        __u64 mant1, mant2;
+        float64 result;
+
+        result.d = 0;
+        
+        expdiff = a.parts.exp - b.parts.exp;
+        if ((expdiff < 0 ) || ((expdiff == 0) && (a.parts.mantisa < b.parts.mantisa))) {
+                if (isFloat64NaN(b)) {
+                        //TODO: fix SigNaN
+                        if (isFloat64SigNaN(b)) {
+                        };
+                        return b;
+                };
+                
+                if (b.parts.exp == FLOAT64_MAX_EXPONENT) { 
+                        b.parts.sign = !b.parts.sign; /* num -(+-inf) = -+inf */
+                        return b;
+                }
+                
+                result.parts.sign = !a.parts.sign; 
+                
+                mant1 = b.parts.mantisa;
+                exp1 = b.parts.exp;
+                mant2 = a.parts.mantisa;
+                exp2 = a.parts.exp;
+                expdiff *= -1;
+        } else {
+                if (isFloat64NaN(a)) {
+                        //TODO: fix SigNaN
+                        if (isFloat64SigNaN(a) || isFloat64SigNaN(b)) {
+                        };
+                        return a;
+                };
+                
+                if (a.parts.exp == FLOAT64_MAX_EXPONENT) { 
+                        if (b.parts.exp == FLOAT64_MAX_EXPONENT) {
+                                /* inf - inf => nan */
+                                //TODO: fix exception
+                                result.binary = FLOAT64_NAN;
+                                return result;
+                        };
+                        return a;
+                }
+                
+                result.parts.sign = a.parts.sign;
+                
+                mant1 = a.parts.mantisa;
+                exp1 = a.parts.exp;
+                mant2 = b.parts.mantisa;
+                exp2 = b.parts.exp;     
+        };
+        
+        if (exp1 == 0) {
+                //both are denormalized
+                result.parts.mantisa = mant1 - mant2;
+                if (result.parts.mantisa > mant1) {
+                        //TODO: underflow exception
+                        return result;
+                };
+                result.parts.exp = 0;
+                return result;
+        };
+
+        /* add hidden bit */
+        mant1 |= FLOAT64_HIDDEN_BIT_MASK; 
+        
+        if (exp2 == 0) {
+                /* denormalized */
+                --expdiff;      
+        } else {
+                /* normalized */
+                mant2 |= FLOAT64_HIDDEN_BIT_MASK;
+        };
+        
+        /* create some space for rounding */
+        mant1 <<= 6;
+        mant2 <<= 6;
+        
+        if (expdiff > FLOAT64_MANTISA_SIZE + 1) {
+             goto done; 
+             };
+        
+        mant1 = mant1 - (mant2 >> expdiff);
+done:
+        //TODO: find first nonzero digit and shift result and detect possibly underflow
+        while ((exp1 > 0) && (!(mant1 & (FLOAT64_HIDDEN_BIT_MASK << 6 )))) {
+                --exp1;
+                mant1 <<= 1;
+                        /* TODO: fix underflow - mant1 == 0 does not necessary means underflow... */
+        };
+        
+        /* rounding - if first bit after mantisa is set then round up */
+        mant1 += 0x20;
+
+        if (mant1 & (FLOAT64_HIDDEN_BIT_MASK << 7)) {
+                ++exp1;
+                mant1 >>= 1;
+        };
+        
+        /*Clear hidden bit and shift */
+        result.parts.mantisa = ((mant1 >> 6) & (~FLOAT64_HIDDEN_BIT_MASK)); 
+        result.parts.exp = exp1;
+        
+        return result;
+}
+

softfloat/include/sftypes.h

@@ -74 +74 @@
 
 /* For recognizing NaNs or infinity use isFloat32NaN and is Float32Inf, comparing with this constants is not sufficient */
-#define FLOAT32_NAN 0x7F800001
-#define FLOAT32_SIGNAN 0x7FC00000
+#define FLOAT32_NAN 0x7FC00001
+#define FLOAT32_SIGNAN 0x7F800001
 #define FLOAT32_INF 0x7F800000
+
+#define FLOAT64_NAN 0x7FF8000000000001ll
+#define FLOAT64_SIGNAN 0x7FF0000000000001ll
+#define FLOAT64_INF 0x7FF0000000000000ll
 
 #define FLOAT32_MANTISA_SIZE 23
@@ -85 +89 @@
 
 #define FLOAT32_MAX_EXPONENT 0xFF
-#define FLOAT64_MAX_EXPONENT 0x8FF
+#define FLOAT64_MAX_EXPONENT 0x7FF
 
 #define FLOAT32_BIAS 0x7F

softfloat/include/sub.h

@@ -32 +32 @@
 float32 subFloat32(float32 a, float32 b);
 
+float64 subFloat64(float64 a, float64 b);
+
 #endif