Changeset afffa1e in mainline

Timestamp:

2006-02-20T23:12:05Z (19 years ago)

Author:

Josef Cejka <malyzelenyhnus@…>

Branches:

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

Children:

2cb202e

Parents:

d9f51ccc

Message:

Conversion functions from float to int added.
Files arch.h and types.h from arch subdirectory should be replaced later with equivalent files from libc.

Location:

softfloat

Files:

• arch/ia32/include/arch.h (added)
• arch/ia32/include/functions.h (added)
• arch/ia32/include/types.h (added)
• generic/conversion.c (modified) (3 diffs)
• generic/softfloat.c (modified) (2 diffs)
• include/sftypes.h (modified) (1 diff)
• include/softfloat.h (modified) (1 diff)

softfloat/generic/conversion.c

@@ -29 +29 @@
 #include "sftypes.h"
 #include "conversion.h"
+#include "comparison.h"
 
 float64 convertFloat32ToFloat64(float32 a) 
@@ -67 +68 @@
         return result;
         
-};
+}
 
 float32 convertFloat64ToFloat32(float64 a) 
@@ -136 +137 @@
         result.parts.fraction = a.parts.fraction >> (FLOAT64_FRACTION_SIZE - FLOAT32_FRACTION_SIZE);
         return result;
-};
-
+}
+
+
+/** Helping procedure for converting float32 to uint32
+ * @param a floating point number in normalized form (no NaNs or Inf are checked )
+ * @return unsigned integer
+ */
+static __u32 _float32_to_uint32_helper(float32 a)
+{
+        __u32 frac;
+        
+        if (a.parts.exp < FLOAT32_BIAS) {
+                /*TODO: rounding*/
+                return 0;
+        }
+        
+        frac = a.parts.fraction;
+        
+        frac |= FLOAT32_HIDDEN_BIT_MASK;
+        /* shift fraction to left so hidden bit will be the most significant bit */
+        frac <<= 32 - FLOAT32_FRACTION_SIZE - 1; 
+
+        frac >>= 32 - (a.parts.exp - FLOAT32_BIAS) - 1;
+        if ((a.parts.sign == 1) && (frac != 0)) {
+                frac = ~frac;
+                ++frac;
+        }
+        
+        return frac;
+}
+
+/* Convert float to unsigned int32
+ * FIXME: Im not sure what to return if overflow/underflow happens 
+ *      - now its the biggest or the smallest int
+ */ 
+__u32 float32_to_uint32(float32 a)
+{
+        if (isFloat32NaN(a)) {
+                return MAX_UINT32;
+        }
+        
+        if (isFloat32Infinity(a) || (a.parts.exp >= (32 + FLOAT32_BIAS)))  {
+                if (a.parts.sign) {
+                        return MIN_UINT32;
+                }
+                return MAX_UINT32;
+        }
+        
+        return _float32_to_uint32_helper(a);    
+}
+
+/* Convert float to signed int32
+ * FIXME: Im not sure what to return if overflow/underflow happens 
+ *      - now its the biggest or the smallest int
+ */ 
+__s32 float32_to_int32(float32 a)
+{
+        if (isFloat32NaN(a)) {
+                return MAX_INT32;
+        }
+        
+        if (isFloat32Infinity(a) || (a.parts.exp >= (32 + FLOAT32_BIAS)))  {
+                if (a.parts.sign) {
+                        return MIN_INT32;
+                }
+                return MAX_INT32;
+        }
+        return _float32_to_uint32_helper(a);
+}       
+
+
+

softfloat/generic/softfloat.c

@@ -39 +39 @@
 #include<other.h>
 
+#include<arch.h>
+#include<types.h>
+#include<functions.h>
+
 /* Arithmetic functions */
 
@@ -161 +165 @@
 }
 
+int __fixsfsi(float a)
+{
+        float32 fa;
+        fa.f = a;
+        
+        return float32_to_int(fa);
+}
+int __fixdfsi(double a)
+{
+}
+ 
+long __fixsfdi(float a)
+{
+        float32 fa;
+        fa.f = a;
+        
+        return float32_to_long(fa);
+}
+long __fixdfdi(double a)
+{
+}
+ 
+long long __fixsfti(float a)
+{
+}
+long long __fixdfti(double a)
+{
+}
+
+unsigned int __fixunssfsi(float a)
+{
+        float32 fa;
+        fa.f = a;
+        
+        return float32_to_uint(fa);
+}
+unsigned int __fixunsdfsi(double a)
+{
+}
+ 
+unsigned long __fixunssfdi(float a)
+{
+        float32 fa;
+        fa.f = a;
+        
+        return float32_to_long(fa);
+}
+unsigned long __fixunsdfdi(double a)
+{
+}
+ 
+unsigned long long __fixunssfti(float a)
+{
+}
+unsigned long long __fixunsdfti(double a)
+{
+}
+ 
+float __floatsisf(int i)
+{
+}
+double __floatsidf(int i)
+{
+}
+ 
+float __floatdisf(long i)
+{
+}
+double __floatdidf(long i)
+{
+}
+ 
+float __floattisf(long long i)
+{
+}
+double __floattidf(long long i)
+{
+}
+
+float __floatunsisf(unsigned int i)
+{
+}
+double __floatunsidf(unsigned int i)
+{
+}
+ 
+float __floatundisf(unsigned long i)
+{
+}
+double __floatundidf(unsigned long i)
+{
+}
+ 
+float __floatuntisf(unsigned long long i)
+{
+}
+double __floatuntidf(unsigned long long i)
+{
+}
+
+/* Comparison functions */
 /* Comparison functions */
 

softfloat/include/sftypes.h

@@ -29 +29 @@
 #ifndef __SFTYPES_H__
 #define __SFTYPES_H__
+
+#include <types.h>
+#include <arch.h>
 
 typedef union {

softfloat/include/softfloat.h

@@ -112 +112 @@
 long double __floattixf(long long i);
  
+float __floatunsisf(unsigned int i);
+double __floatunsidf(unsigned int i);
+long double __floatunsitf(unsigned int i);
+long double __floatunsixf(unsigned int i);
+ 
+float __floatundisf(unsigned long i);
+double __floatundidf(unsigned long i);
+long double __floatunditf(unsigned long i);
+long double __floatundixf(unsigned long i);
+ 
+float __floatuntisf(unsigned long long i);
+double __floatuntidf(unsigned long long i);
+long double __floatuntitf(unsigned long long i);
+long double __floatuntixf(unsigned long long i);
+ 
 int __cmpsf2(float a, float b);
 int __cmpdf2(double a, double b);