WebSVN – HelenOS-historic – Path Comparison – / – /uspace/ Rev 687 and /uspace/ Rev 688

Ignore whitespace Rev 687 → Rev 688

/uspace/trunk/softfloat/include/arithmetic.h
31,6 → 31,7

float32 addFloat32(float32 a, float32 b);
float32 subFloat32(float32 a, float32 b);
float32 mulFloat32(float32 a, float32 b);

#endif

/uspace/trunk/softfloat/include/comparison.h
33,6 → 33,7
inline int isFloat32SigNaN(float32 f);

inline int isFloat32Infinity(float32 f);
inline int isFloat32Zero(float32 f);

inline int isFloat32eq(float32 a, float32 b);
inline int isFloat32lt(float32 a, float32 b);

 /uspace/trunk/softfloat/include/sftypes.h
 ,7 → 78,9
 #define FLOAT32_SIGNAN 0x7FC00000
 #define FLOAT32_INF 0x7F800000
-#define FLOAT32_BIAS 0xF7
+#define FLOAT32_MANTISA_SIZE 23
+#define FLOAT32_BIAS 0x7F
 #define FLOAT64_BIAS 0x3FF
 #define FLOAT80_BIAS 0x3FFF

 /uspace/trunk/softfloat/generic/softfloat.c
 ,6 → 63,14
     return subFloat32(fa,fb).f;
 };
+float __mulsf3(float a, float b)
+{
+    float32 fa, fb;
+    fa.f=a;
+    fb.f=b;
+    return  mulFloat32(fa, fb).f;
+}
 float __negsf2(float a)
 {
     float32 fa;

 /uspace/trunk/softfloat/generic/arithmetic.c
 ,6 → 43,7
             //TODO: fix SigNaN
             if (isFloat32SigNaN(b)) {
             };
             return b;
         };
 ,7 → 219,7
         mant1 <<= 1;
         if(mant1 == 0) {
             /* Realy is it an underflow? ... */
-            //TODO: fix underflow
+            /* TODO: fix underflow */
         };
     };
 ,3 → 237,141
     return result;
 };
+/** Multiply two 32 bit float numbers
+ *
+ */
+float32 mulFloat32(float32 a, float32 b)
+{
+    float32 result;
+    __u64 mant1, mant2;
+    __s32 exp;
+    result.parts.sign = a.parts.sign ^ b.parts.sign;
+    if ((isFloat32NaN(a))||(isFloat32NaN(b))) {
+        /* TODO: fix SigNaNs */
+        if (isFloat32SigNaN(a)) {
+            result.parts.mantisa = a.parts.mantisa;
+            result.parts.exp = a.parts.exp;
+            return result;
+        };
+        if (isFloat32SigNaN(b)) { /* TODO: fix SigNaN */
+            result.parts.mantisa = b.parts.mantisa;
+            result.parts.exp = b.parts.exp;
+            return result;
+        };
+        /* set NaN as result */
+        result.parts.mantisa = 0x1;
+        result.parts.exp = 0xFF;
+        return result;
+    };
+    if (isFloat32Infinity(a)) {
+        if (isFloat32Zero(b)) {
+            /* FIXME: zero * infinity */
+            result.parts.mantisa = 0x1;
+            result.parts.exp = 0xFF;
+            return result;
+        }
+        result.parts.mantisa = a.parts.mantisa;
+        result.parts.exp = a.parts.exp;
+        return result;
+    }
+    if (isFloat32Infinity(b)) {
+        if (isFloat32Zero(a)) {
+            /* FIXME: zero * infinity */
+            result.parts.mantisa = 0x1;
+            result.parts.exp = 0xFF;
+            return result;
+        }
+        result.parts.mantisa = b.parts.mantisa;
+        result.parts.exp = b.parts.exp;
+        return result;
+    }
+    /* exp is signed so we can easy detect underflow */
+    exp = a.parts.exp + b.parts.exp;
+    exp -= FLOAT32_BIAS;
+    if (exp >= 0xFF ) {
+        /* FIXME: overflow */
+        /* set infinity as result */
+        result.parts.mantisa = 0x0;
+        result.parts.exp = 0xFF;
+        return result;
+    };
+    if (exp < 0) {
+        /* FIXME: underflow */
+        /* return signed zero */
+        result.parts.mantisa = 0x0;
+        result.parts.exp = 0x0;
+        return result;
+    };
+    mant1 = a.parts.mantisa;
+    if (a.parts.exp>0) {
+        mant1 |= 0x800000;
+    } else {
+        ++exp;
+    };
+    mant2 = b.parts.mantisa;
+    if (b.parts.exp>0) {
+        mant2 |= 0x800000;
+    } else {
+        ++exp;
+    };
+    mant1 <<= 1; /* one bit space for rounding */
+    mant1 = mant1 * mant2;
+/* round and return */
+    while ((exp < 0xFF )&&(mant1 > 0x1FFFFFF )) { /* 0xFFFFFF is 23 bits of mantisa + one more for hidden bit (all shifted 1 bit left)*/
+        ++exp;
+        mant1 >>= 1;
+    };
+    /* rounding */
+    //++mant1; /* FIXME: not works - without it is ok */
+    mant1 >>= 1; /* shift off rounding space */
+    if ((exp < 0xFF )&&(mant1 > 0xFFFFFF )) {
+        ++exp;
+        mant1 >>= 1;
+    };
+    if (exp >= 0xFF ) {
+        /* TODO: fix overflow */
+        /* return infinity*/
+        result.parts.exp = 0xFF;
+        result.parts.mantisa = 0x0;
+        return result;
+    }
+    exp -= FLOAT32_MANTISA_SIZE;
+    if (exp <= FLOAT32_MANTISA_SIZE) {
+        /* denormalized number */
+        mant1 >>= 1; /* denormalize */
+        while ((mant1 > 0) && (exp < 0)) {
+            mant1 >>= 1;
+            ++exp;
+        };
+        if (mant1 == 0) {
+            /* FIXME : underflow */
+        result.parts.exp = 0;
+        result.parts.mantisa = 0;
+        return result;
+        };
+    };
+    result.parts.exp = exp;
+    result.parts.mantisa = mant1 & 0x7FFFFF;
+    return result;
+};

 /uspace/trunk/softfloat/generic/comparison.c
 ,6 → 44,11
     return ((f.parts.exp==0xFF)&&(f.parts.mantisa==0x0));
 };
+inline int isFloat32Zero(float32 f)
+{
+    return (((f.binary) & 0x7FFFFFFF) == 0);
+}
 /**
  * @return 1, if both floats are equal - but NaNs are not recognized
  */

Subversion Repositories HelenOS-historic

Compare Revisions

Ignore whitespace Rev 687 → Rev 688