Changeset 75a23abf in mainline

Timestamp:

2005-12-23T17:44:31Z (19 years ago)

Author:

Josef Cejka <malyzelenyhnus@…>

Branches:

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

Children:

3af72dc

Parents:

cf4a823

Message:

Softfloat - function for float subtraction added.

Location:

softfloat

Files:

• generic/arithmetic.c (modified) (1 diff)
• include/sftypes.h (modified) (1 diff)

softfloat/generic/arithmetic.c

@@ -112 +112 @@
         mant1+=0x20;
         
+        if (mant1&0x40000000) { 
+                ++exp1;
+                mant1>>=1;
+        };
+        
         a.parts.exp=exp1;
-        a.parts.mantisa=mant1>>6;
+        a.parts.mantisa = ((mant1&(~0x20000000))>>6); /*Clear hidden bit and shift */
         return a;
 };
 
-/** Substract two float32 numbers with same signs
+/** Subtract two float32 numbers with same signs
  */
 float32 subFloat32(float32 a, float32 b)
 {
-        
-        
+        int expdiff;
+        __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))) {
+                if (isFloat32NaN(b)) {
+                        //TODO: fix SigNaN
+                        if (isFloat32SigNaN(b)) {
+                        };
+                        return b;
+                };
+                
+                if (b.parts.exp==0xFF) { 
+                        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 (isFloat32NaN(a)) {
+                        //TODO: fix SigNaN
+                        if ((isFloat32SigNaN(a))||(isFloat32SigNaN(b))) {
+                        };
+                        return a;
+                };
+                
+                if (a.parts.exp==0xFF) { 
+                        if (b.parts.exp==0xFF) {
+                                /* inf - inf => nan */
+                                //TODO: fix exception
+                                result.binary = FLOAT32_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;
+        };
+        
+        // create some space for rounding
+        mant1<<=6;
+        mant2<<=6;
+        
+        mant1|=0x20000000; //add hidden bit
+        
+        
+        if (exp2==0) {
+                --expdiff;      
+        } else {
+                mant2|=0x20000000; //hidden bit
+        };
+        
+        if (expdiff>24) {
+             goto done; 
+             };
+        
+        mant1 = mant1-(mant2>>expdiff);
+done:
+        
+        //TODO: find first nonzero digit and shift result and detect possibly underflow
+        while ((exp1>0)&&(!(mant1&0x20000000))) {
+                exp1--;
+                mant1 <<= 1;
+                if(mant1 == 0) {
+                        /* Realy is it an underflow? ... */
+                        //TODO: fix underflow
+                };
+        };
+        
+        //rounding - if first bit after mantisa is set then round up    
+        mant1 += 0x20;
+
+        if (mant1&0x40000000) {
+                ++exp1;
+                mant1>>=1;
+        };
+        
+        result.parts.mantisa = ((mant1&(~0x20000000))>>6); /*Clear hidden bit and shift */
+        result.parts.exp = exp1;
+        
+        return result;
 };
 

softfloat/include/sftypes.h

@@ -74 +74 @@
 #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_INF 0x7F800000
+
 #define FLOAT32_BIAS 0xF7
 #define FLOAT64_BIAS 0x3FF