Changeset 3af72dc in mainline

Timestamp:

2006-01-08T16:26:00Z (19 years ago)

Author:

Josef Cejka <malyzelenyhnus@…>

Branches:

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

Children:

feef1cd

Parents:

75a23abf

Message:

Function for multiplying added to softfloat lib.

Location:

softfloat

Files:

• generic/arithmetic.c (modified) (3 diffs)
• generic/comparison.c (modified) (1 diff)
• generic/softfloat.c (modified) (1 diff)
• include/arithmetic.h (modified) (1 diff)
• include/comparison.h (modified) (1 diff)
• include/sftypes.h (modified) (1 diff)

softfloat/generic/arithmetic.c

@@ -44 +44 @@
                         if (isFloat32SigNaN(b)) {
                         };
+
                         return b;
                 };
@@ -219 +220 @@
                 if(mant1 == 0) {
                         /* Realy is it an underflow? ... */
-                        //TODO: fix underflow
+                        /* TODO: fix underflow */
                 };
         };
@@ -237 +238 @@
 };
 
+/** 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;  
+        
+};
+
+

softfloat/generic/comparison.c

@@ -44 +44 @@
         return ((f.parts.exp==0xFF)&&(f.parts.mantisa==0x0));
 };
+
+inline int isFloat32Zero(float32 f)
+{
+        return (((f.binary) & 0x7FFFFFFF) == 0);
+}
 
 /**

softfloat/generic/softfloat.c

@@ -64 +64 @@
 };
 
+float __mulsf3(float a, float b) 
+{
+        float32 fa, fb;
+        fa.f=a;
+        fb.f=b;
+        return  mulFloat32(fa, fb).f;
+}
+
 float __negsf2(float a)
 {

softfloat/include/arithmetic.h

@@ -32 +32 @@
 float32 addFloat32(float32 a, float32 b);
 float32 subFloat32(float32 a, float32 b);
+float32 mulFloat32(float32 a, float32 b);
 
 #endif

softfloat/include/comparison.h

@@ -34 +34 @@
 
 inline int isFloat32Infinity(float32 f);
+inline int isFloat32Zero(float32 f);
 
 inline int isFloat32eq(float32 a, float32 b);

softfloat/include/sftypes.h

@@ -79 +79 @@
 #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