WebSVN – HelenOS – Path Comparison – / – //uspace/trunk/softfloat/ Rev 733 and //uspace/trunk/softfloat/ Rev 734

Ignore whitespace Rev 733 → Rev 734

//uspace/trunk/softfloat/include/sub.h
31,5 → 31,7

float32 subFloat32(float32 a, float32 b);

float64 subFloat64(float64 a, float64 b);

#endif

 //uspace/trunk/softfloat/include/sftypes.h
 ,10 → 73,14
 #define FLOAT64_MIN
 /* 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
 #define FLOAT64_MANTISA_SIZE 52
 ,7 → 88,7
 #define FLOAT64_HIDDEN_BIT_MASK 0x10000000000000ll
 #define FLOAT32_MAX_EXPONENT 0xFF
-#define FLOAT64_MAX_EXPONENT 0x8FF
+#define FLOAT64_MAX_EXPONENT 0x7FF
 #define FLOAT32_BIAS 0x7F
 #define FLOAT64_BIAS 0x3FF

 //uspace/trunk/softfloat/generic/softfloat.c
 ,6 → 56,22
     return addFloat32(fa,fb).f;
 }
+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)
 {
     float32 fa, fb;
 ,6 → 84,18
     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;
+}
 float __mulsf3(float a, float b)
 {
     float32 fa, fb;

 //uspace/trunk/softfloat/generic/add.c
 ,7 → 132,8
 float64 addFloat64(float64 a, float64 b)
 {
     int expdiff;
-    __u64 exp1, exp2, mant1, mant2;
+    __u32 exp1, exp2;
+    __u64 mant1, mant2;
     expdiff = a.parts.exp - b.parts.exp;
     if (expdiff < 0) {

 //uspace/trunk/softfloat/generic/sub.c
 ,8 → 26,9
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-#include "sftypes.h"
-#include "sub.h"
+#include<sftypes.h>
+#include<sub.h>
+#include<comparison.h>
 /** Subtract two float32 numbers with same signs
  */
 ,13 → 35,13
 float32 subFloat32(float32 a, float32 b)
 {
     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
             if (isFloat32SigNaN(b)) {
 ,28 → 49,28
             return b;
         };
-        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;
         }
         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))) {
+            if (isFloat32SigNaN(a) || isFloat32SigNaN(b)) {
             };
             return a;
         };
-        if (a.parts.exp==0xFF) {
-            if (b.parts.exp==0xFF) {
+        if (a.parts.exp == FLOAT32_MAX_EXPONENT) {
+            if (b.parts.exp == FLOAT32_MAX_EXPONENT) {
                 /* inf - inf => nan */
                 //TODO: fix exception
                 result.binary = FLOAT32_NAN;
 ,60 → 81,175
         result.parts.sign = a.parts.sign;
-        mant1=a.parts.mantisa;
-        exp1=a.parts.exp;
-        mant2=b.parts.mantisa;
-        exp2=b.parts.exp;
+        mant1 = a.parts.mantisa;
+        exp1 = a.parts.exp;
+        mant2 = b.parts.mantisa;
+        exp2 = b.parts.exp;
     };
-    if (exp1==0) {
+    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;
     };
+    /* add hidden bit */
+    mant1 |= FLOAT32_HIDDEN_BIT_MASK;
-    // create some space for rounding
-    mant1<<=6;
-    mant2<<=6;
+    if (exp2 == 0) {
+        /* denormalized */
+        --expdiff;
+    } else {
+        /* normalized */
+        mant2 |= FLOAT32_HIDDEN_BIT_MASK;
+    };
-    mant1|=0x20000000; //add hidden bit
+    /* create some space for rounding */
+    mant1 <<= 6;
+    mant2 <<= 6;
+    if (expdiff > FLOAT32_MANTISA_SIZE + 1) {
+         goto done;
+         };
-    if (exp2==0) {
+    mant1 = mant1 - (mant2 >> expdiff);
+done:
+    //TODO: find first nonzero digit and shift result and detect possibly underflow
+    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 */
+    mant1 += 0x20;
+    if (mant1 & (FLOAT32_HIDDEN_BIT_MASK << 7)) {
+        ++exp1;
+        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 {
-        mant2|=0x20000000; //hidden bit
+        /* normalized */
+        mant2 |= FLOAT64_HIDDEN_BIT_MASK;
     };
-    if (expdiff>24) {
+    /* create some space for rounding */
+    mant1 <<= 6;
+    mant2 <<= 6;
+    if (expdiff > FLOAT64_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 & (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
+    /* rounding - if first bit after mantisa is set then round up */
     mant1 += 0x20;
-    if (mant1&0x40000000) {
+    if (mant1 & (FLOAT64_HIDDEN_BIT_MASK << 7)) {
         ++exp1;
-        mant1>>=1;
+        mant1 >>= 1;
     };
-    result.parts.mantisa = ((mant1&(~0x20000000))>>6); /*Clear hidden bit and shift */
+    /*Clear hidden bit and shift */
+    result.parts.mantisa = ((mant1 >> 6) & (~FLOAT64_HIDDEN_BIT_MASK));
     result.parts.exp = exp1;
     return result;
-};
+}

 //uspace/trunk/softfloat/generic/comparison.c
 ,13 → 40,13
 };
 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));
 };
 inline int isFloat32Infinity(float32 f)

Subversion Repositories HelenOS

Compare Revisions

Ignore whitespace Rev 733 → Rev 734