WebSVN – HelenOS-historic – Diff – /uspace/trunk/softfloat/generic/conversion.c


/*
 * Copyright (C) 2005 Josef Cejka
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * - The name of the author may not be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
#include "sftypes.h"
#include "conversion.h"
#include "comparison.h"
#include "common.h"
 
float64 convertFloat32ToFloat64(float32 a)
{
    float64 result;
    __u64 frac;
   
    result.parts.sign = a.parts.sign;
    result.parts.fraction = a.parts.fraction;
    result.parts.fraction <<= (FLOAT64_FRACTION_SIZE - FLOAT32_FRACTION_SIZE );
   
    if ((isFloat32Infinity(a))||(isFloat32NaN(a))) {
        result.parts.exp = 0x7FF;
        /* TODO; check if its correct for SigNaNs*/
        return result;
    };
   
    result.parts.exp = a.parts.exp + ( (int)FLOAT64_BIAS - FLOAT32_BIAS );
    if (a.parts.exp == 0) {
        /* normalize denormalized numbers */
 
        if (result.parts.fraction == 0ll) { /* fix zero */
            result.parts.exp = 0ll;
            return result;
        }
           
        frac = result.parts.fraction;
       
        while (!(frac & (0x10000000000000ll))) {
            frac <<= 1;
            --result.parts.exp;
        };
       
        ++result.parts.exp;
        result.parts.fraction = frac;
    };
   
    return result;
   
}
 
float32 convertFloat64ToFloat32(float64 a)
{
    float32 result;
    __s32 exp;
    __u64 frac;
   
    result.parts.sign = a.parts.sign;
   
    if (isFloat64NaN(a)) {
       
        result.parts.exp = 0xFF;
       
        if (isFloat64SigNaN(a)) {
            result.parts.fraction = 0x800000; /* set first bit of fraction nonzero */
            return result;
        }
   
        result.parts.fraction = 0x1; /* fraction nonzero but its first bit is zero */
        return result;
    };
 
    if (isFloat64Infinity(a)) {
        result.parts.fraction = 0;
        result.parts.exp = 0xFF;
        return result;
    };
 
    exp = (int)a.parts.exp - FLOAT64_BIAS + FLOAT32_BIAS;
   
    if (exp >= 0xFF) {
        /*FIXME: overflow*/
        result.parts.fraction = 0;
        result.parts.exp = 0xFF;
        return result;
       
    } else if (exp <= 0 ) {
       
        /* underflow or denormalized */
       
        result.parts.exp = 0;
       
        exp *= -1; 
        if (exp > FLOAT32_FRACTION_SIZE ) {
            /* FIXME: underflow */
            result.parts.fraction = 0;
            return result;
        };
       
        /* denormalized */
       
        frac = a.parts.fraction;
        frac |= 0x10000000000000ll; /* denormalize and set hidden bit */
       
        frac >>= (FLOAT64_FRACTION_SIZE - FLOAT32_FRACTION_SIZE + 1);
       
        while (exp > 0) {
            --exp;
            frac >>= 1;
        };
        result.parts.fraction = frac;
       
        return result;
    };
 
    result.parts.exp = exp;
    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);
}  
 
 
/** Helping procedure for converting float64 to uint64
 * @param a floating point number in normalized form (no NaNs or Inf are checked )
 * @return unsigned integer
 */
static __u64 _float64_to_uint64_helper(float64 a)
{
    __u64 frac;
   
    if (a.parts.exp < FLOAT64_BIAS) {
        /*TODO: rounding*/
        return 0;
    }
   
    frac = a.parts.fraction;
   
    frac |= FLOAT64_HIDDEN_BIT_MASK;
    /* shift fraction to left so hidden bit will be the most significant bit */
    frac <<= 64 - FLOAT64_FRACTION_SIZE - 1;
 
    frac >>= 64 - (a.parts.exp - FLOAT64_BIAS) - 1;
    if ((a.parts.sign == 1) && (frac != 0)) {
        frac = ~frac;
        ++frac;
    }
   
    return frac;
}
 
/* Convert float to unsigned int64
 * FIXME: Im not sure what to return if overflow/underflow happens
 *  - now its the biggest or the smallest int
 */
__u64 float64_to_uint64(float64 a)
{
    if (isFloat64NaN(a)) {
        return MAX_UINT64;
    }
   
    if (isFloat64Infinity(a) || (a.parts.exp >= (64 + FLOAT64_BIAS)))  {
        if (a.parts.sign) {
            return MIN_UINT64;
        }
        return MAX_UINT64;
    }
   
    return _float64_to_uint64_helper(a);   
}
 
/* Convert float to signed int64
 * FIXME: Im not sure what to return if overflow/underflow happens
 *  - now its the biggest or the smallest int
 */
__s64 float64_to_int64(float64 a)
{
    if (isFloat64NaN(a)) {
        return MAX_INT64;
    }
   
    if (isFloat64Infinity(a) || (a.parts.exp >= (64 + FLOAT64_BIAS)))  {
        if (a.parts.sign) {
            return MIN_INT64;
        }
        return MAX_INT64;
    }
    return _float64_to_uint64_helper(a);
}  
 
 
 
 
 
/** Helping procedure for converting float32 to uint64
 * @param a floating point number in normalized form (no NaNs or Inf are checked )
 * @return unsigned integer
 */
static __u64 _float32_to_uint64_helper(float32 a)
{
    __u64 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 <<= 64 - FLOAT32_FRACTION_SIZE - 1;
 
    frac >>= 64 - (a.parts.exp - FLOAT32_BIAS) - 1;
    if ((a.parts.sign == 1) && (frac != 0)) {
        frac = ~frac;
        ++frac;
    }
   
    return frac;
}
 
/* Convert float to unsigned int64
 * FIXME: Im not sure what to return if overflow/underflow happens
 *  - now its the biggest or the smallest int
 */
__u64 float32_to_uint64(float32 a)
{
    if (isFloat32NaN(a)) {
        return MAX_UINT64;
    }
   
    if (isFloat32Infinity(a) || (a.parts.exp >= (64 + FLOAT32_BIAS)))  {
        if (a.parts.sign) {
            return MIN_UINT64;
        }
        return MAX_UINT64;
    }
   
    return _float32_to_uint64_helper(a);   
}
 
/* Convert float to signed int64
 * FIXME: Im not sure what to return if overflow/underflow happens
 *  - now its the biggest or the smallest int
 */
__s64 float32_to_int64(float32 a)
{
    if (isFloat32NaN(a)) {
        return MAX_INT64;
    }
   
    if (isFloat32Infinity(a) || (a.parts.exp >= (64 + FLOAT32_BIAS)))  {
        if (a.parts.sign) {
            return (MIN_INT64);
        }
        return MAX_INT64;
    }
    return _float32_to_uint64_helper(a);
}  
 
 
/* Convert float64 to unsigned int32
 * FIXME: Im not sure what to return if overflow/underflow happens
 *  - now its the biggest or the smallest int
 */
__u32 float64_to_uint32(float64 a)
{
    if (isFloat64NaN(a)) {
        return MAX_UINT32;
    }
   
    if (isFloat64Infinity(a) || (a.parts.exp >= (32 + FLOAT64_BIAS)))  {
        if (a.parts.sign) {
            return MIN_UINT32;
        }
        return MAX_UINT32;
    }
   
    return (__u32)_float64_to_uint64_helper(a);
}
 
/* Convert float64 to signed int32
 * FIXME: Im not sure what to return if overflow/underflow happens
 *  - now its the biggest or the smallest int
 */
__s32 float64_to_int32(float64 a)
{
    if (isFloat64NaN(a)) {
        return MAX_INT32;
    }
   
    if (isFloat64Infinity(a) || (a.parts.exp >= (32 + FLOAT64_BIAS)))  {
        if (a.parts.sign) {
            return MIN_INT32;
        }
        return MAX_INT32;
    }
    return (__s32)_float64_to_uint64_helper(a);
}  
 
   
/** Convert unsigned integer to float32
 *
 *
 */
float32 uint32_to_float32(__u32 i)
{
    int counter;
    __s32 exp;
    float32 result;
   
    result.parts.sign = 0;
    result.parts.fraction = 0;
 
    counter = countZeroes32(i);
 
    exp = FLOAT32_BIAS + 32 - counter - 1;
   
    if (counter == 32) {
        result.binary = 0;
        return result;
    }
   
    if (counter > 0) {
        i <<= counter - 1;
    } else {
        i >>= 1;
    }
 
    roundFloat32(&exp, &i);
 
    result.parts.fraction = i >> 7;
    result.parts.exp = exp;
 
    return result;
}
 
float32 int32_to_float32(__s32 i)
{
    float32 result;
 
    if (i < 0) {
        result = uint32_to_float32((__u32)(-i));
    } else {
        result = uint32_to_float32((__u32)i);
    }
   
    result.parts.sign = i < 0;
 
    return result;
}
 
 
float32 uint64_to_float32(__u64 i)
{
}
 
float32 int64_to_float32(__s64 i)
{
    float32 result;
 
    if (i < 0) {
        result = uint64_to_float32((__u64)(-i));
    } else {
        result = uint64_to_float32((__u64)i);
    }
   
    result.parts.sign = i < 0;
 
    return result;
}
 

Rev 865	Rev 874
1	/*	1	/*
2	* Copyright (C) 2005 Josef Cejka	2	* Copyright (C) 2005 Josef Cejka
3	* All rights reserved.	3	* All rights reserved.
4	*	4	*
5	* Redistribution and use in source and binary forms, with or without	5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions	6	* modification, are permitted provided that the following conditions
7	* are met:	7	* are met:
8	*	8	*
9	* - Redistributions of source code must retain the above copyright	9	* - Redistributions of source code must retain the above copyright
10	* notice, this list of conditions and the following disclaimer.	10	* notice, this list of conditions and the following disclaimer.
11	* - Redistributions in binary form must reproduce the above copyright	11	* - Redistributions in binary form must reproduce the above copyright
12	* notice, this list of conditions and the following disclaimer in the	12	* notice, this list of conditions and the following disclaimer in the
13	* documentation and/or other materials provided with the distribution.	13	* documentation and/or other materials provided with the distribution.
14	* - The name of the author may not be used to endorse or promote products	14	* - The name of the author may not be used to endorse or promote products
15	* derived from this software without specific prior written permission.	15	* derived from this software without specific prior written permission.
16	*	16	*
17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR	17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES	18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.	19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,	20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT	21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,	22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY	23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT	24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF	25	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.	26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27	*/	27	*/
28		28
29	#include "sftypes.h"	29	#include "sftypes.h"
30	#include "conversion.h"	30	#include "conversion.h"
31	#include "comparison.h"	31	#include "comparison.h"
-		32	#include "common.h"
32		33
33	float64 convertFloat32ToFloat64(float32 a)	34	float64 convertFloat32ToFloat64(float32 a)
34	{	35	{
35	float64 result;	36	float64 result;
36	__u64 frac;	37	__u64 frac;
37		38
38	result.parts.sign = a.parts.sign;	39	result.parts.sign = a.parts.sign;
39	result.parts.fraction = a.parts.fraction;	40	result.parts.fraction = a.parts.fraction;
40	result.parts.fraction <<= (FLOAT64_FRACTION_SIZE - FLOAT32_FRACTION_SIZE );	41	result.parts.fraction <<= (FLOAT64_FRACTION_SIZE - FLOAT32_FRACTION_SIZE );
41		42
42	if ((isFloat32Infinity(a))\|\|(isFloat32NaN(a))) {	43	if ((isFloat32Infinity(a))\|\|(isFloat32NaN(a))) {
43	result.parts.exp = 0x7FF;	44	result.parts.exp = 0x7FF;
44	/* TODO; check if its correct for SigNaNs*/	45	/* TODO; check if its correct for SigNaNs*/
45	return result;	46	return result;
46	};	47	};
47		48
48	result.parts.exp = a.parts.exp + ( (int)FLOAT64_BIAS - FLOAT32_BIAS );	49	result.parts.exp = a.parts.exp + ( (int)FLOAT64_BIAS - FLOAT32_BIAS );
49	if (a.parts.exp == 0) {	50	if (a.parts.exp == 0) {
50	/* normalize denormalized numbers */	51	/* normalize denormalized numbers */
51		52
52	if (result.parts.fraction == 0ll) { /* fix zero */	53	if (result.parts.fraction == 0ll) { /* fix zero */
53	result.parts.exp = 0ll;	54	result.parts.exp = 0ll;
54	return result;	55	return result;
55	}	56	}
56		57
57	frac = result.parts.fraction;	58	frac = result.parts.fraction;
58		59
59	while (!(frac & (0x10000000000000ll))) {	60	while (!(frac & (0x10000000000000ll))) {
60	frac <<= 1;	61	frac <<= 1;
61	--result.parts.exp;	62	--result.parts.exp;
62	};	63	};
63		64
64	++result.parts.exp;	65	++result.parts.exp;
65	result.parts.fraction = frac;	66	result.parts.fraction = frac;
66	};	67	};
67		68
68	return result;	69	return result;
69		70
70	}	71	}
71		72
72	float32 convertFloat64ToFloat32(float64 a)	73	float32 convertFloat64ToFloat32(float64 a)
73	{	74	{
74	float32 result;	75	float32 result;
75	__s32 exp;	76	__s32 exp;
76	__u64 frac;	77	__u64 frac;
77		78
78	result.parts.sign = a.parts.sign;	79	result.parts.sign = a.parts.sign;
79		80
80	if (isFloat64NaN(a)) {	81	if (isFloat64NaN(a)) {
81		82
82	result.parts.exp = 0xFF;	83	result.parts.exp = 0xFF;
83		84
84	if (isFloat64SigNaN(a)) {	85	if (isFloat64SigNaN(a)) {
85	result.parts.fraction = 0x800000; /* set first bit of fraction nonzero */	86	result.parts.fraction = 0x800000; /* set first bit of fraction nonzero */
86	return result;	87	return result;
87	}	88	}
88		89
89	result.parts.fraction = 0x1; /* fraction nonzero but its first bit is zero */	90	result.parts.fraction = 0x1; /* fraction nonzero but its first bit is zero */
90	return result;	91	return result;
91	};	92	};
92		93
93	if (isFloat64Infinity(a)) {	94	if (isFloat64Infinity(a)) {
94	result.parts.fraction = 0;	95	result.parts.fraction = 0;
95	result.parts.exp = 0xFF;	96	result.parts.exp = 0xFF;
96	return result;	97	return result;
97	};	98	};
98		99
99	exp = (int)a.parts.exp - FLOAT64_BIAS + FLOAT32_BIAS;	100	exp = (int)a.parts.exp - FLOAT64_BIAS + FLOAT32_BIAS;
100		101
101	if (exp >= 0xFF) {	102	if (exp >= 0xFF) {
102	/FIXME: overflow/	103	/FIXME: overflow/
103	result.parts.fraction = 0;	104	result.parts.fraction = 0;
104	result.parts.exp = 0xFF;	105	result.parts.exp = 0xFF;
105	return result;	106	return result;
106		107
107	} else if (exp <= 0 ) {	108	} else if (exp <= 0 ) {
108		109
109	/* underflow or denormalized */	110	/* underflow or denormalized */
110		111
111	result.parts.exp = 0;	112	result.parts.exp = 0;
112		113
113	exp *= -1;	114	exp *= -1;
114	if (exp > FLOAT32_FRACTION_SIZE ) {	115	if (exp > FLOAT32_FRACTION_SIZE ) {
115	/* FIXME: underflow */	116	/* FIXME: underflow */
116	result.parts.fraction = 0;	117	result.parts.fraction = 0;
117	return result;	118	return result;
118	};	119	};
119		120
120	/* denormalized */	121	/* denormalized */
121		122
122	frac = a.parts.fraction;	123	frac = a.parts.fraction;
123	frac \|= 0x10000000000000ll; /* denormalize and set hidden bit */	124	frac \|= 0x10000000000000ll; /* denormalize and set hidden bit */
124		125
125	frac >>= (FLOAT64_FRACTION_SIZE - FLOAT32_FRACTION_SIZE + 1);	126	frac >>= (FLOAT64_FRACTION_SIZE - FLOAT32_FRACTION_SIZE + 1);
126		127
127	while (exp > 0) {	128	while (exp > 0) {
128	--exp;	129	--exp;
129	frac >>= 1;	130	frac >>= 1;
130	};	131	};
131	result.parts.fraction = frac;	132	result.parts.fraction = frac;
132		133
133	return result;	134	return result;
134	};	135	};
135		136
136	result.parts.exp = exp;	137	result.parts.exp = exp;
137	result.parts.fraction = a.parts.fraction >> (FLOAT64_FRACTION_SIZE - FLOAT32_FRACTION_SIZE);	138	result.parts.fraction = a.parts.fraction >> (FLOAT64_FRACTION_SIZE - FLOAT32_FRACTION_SIZE);
138	return result;	139	return result;
139	}	140	}
140		141
141		142
142	/** Helping procedure for converting float32 to uint32	143	/** Helping procedure for converting float32 to uint32
143	* @param a floating point number in normalized form (no NaNs or Inf are checked )	144	* @param a floating point number in normalized form (no NaNs or Inf are checked )
144	* @return unsigned integer	145	* @return unsigned integer
145	*/	146	*/
146	static __u32 _float32_to_uint32_helper(float32 a)	147	static __u32 _float32_to_uint32_helper(float32 a)
147	{	148	{
148	__u32 frac;	149	__u32 frac;
149		150
150	if (a.parts.exp < FLOAT32_BIAS) {	151	if (a.parts.exp < FLOAT32_BIAS) {
151	/TODO: rounding/	152	/TODO: rounding/
152	return 0;	153	return 0;
153	}	154	}
154		155
155	frac = a.parts.fraction;	156	frac = a.parts.fraction;
156		157
157	frac \|= FLOAT32_HIDDEN_BIT_MASK;	158	frac \|= FLOAT32_HIDDEN_BIT_MASK;
158	/* shift fraction to left so hidden bit will be the most significant bit */	159	/* shift fraction to left so hidden bit will be the most significant bit */
159	frac <<= 32 - FLOAT32_FRACTION_SIZE - 1;	160	frac <<= 32 - FLOAT32_FRACTION_SIZE - 1;
160		161
161	frac >>= 32 - (a.parts.exp - FLOAT32_BIAS) - 1;	162	frac >>= 32 - (a.parts.exp - FLOAT32_BIAS) - 1;
162	if ((a.parts.sign == 1) && (frac != 0)) {	163	if ((a.parts.sign == 1) && (frac != 0)) {
163	frac = ~frac;	164	frac = ~frac;
164	++frac;	165	++frac;
165	}	166	}
166		167
167	return frac;	168	return frac;
168	}	169	}
169		170
170	/* Convert float to unsigned int32	171	/* Convert float to unsigned int32
171	* FIXME: Im not sure what to return if overflow/underflow happens	172	* FIXME: Im not sure what to return if overflow/underflow happens
172	* - now its the biggest or the smallest int	173	* - now its the biggest or the smallest int
173	*/	174	*/
174	__u32 float32_to_uint32(float32 a)	175	__u32 float32_to_uint32(float32 a)
175	{	176	{
176	if (isFloat32NaN(a)) {	177	if (isFloat32NaN(a)) {
177	return MAX_UINT32;	178	return MAX_UINT32;
178	}	179	}
179		180
180	if (isFloat32Infinity(a) \|\| (a.parts.exp >= (32 + FLOAT32_BIAS))) {	181	if (isFloat32Infinity(a) \|\| (a.parts.exp >= (32 + FLOAT32_BIAS))) {
181	if (a.parts.sign) {	182	if (a.parts.sign) {
182	return MIN_UINT32;	183	return MIN_UINT32;
183	}	184	}
184	return MAX_UINT32;	185	return MAX_UINT32;
185	}	186	}
186		187
187	return _float32_to_uint32_helper(a);	188	return _float32_to_uint32_helper(a);
188	}	189	}
189		190
190	/* Convert float to signed int32	191	/* Convert float to signed int32
191	* FIXME: Im not sure what to return if overflow/underflow happens	192	* FIXME: Im not sure what to return if overflow/underflow happens
192	* - now its the biggest or the smallest int	193	* - now its the biggest or the smallest int
193	*/	194	*/
194	__s32 float32_to_int32(float32 a)	195	__s32 float32_to_int32(float32 a)
195	{	196	{
196	if (isFloat32NaN(a)) {	197	if (isFloat32NaN(a)) {
197	return MAX_INT32;	198	return MAX_INT32;
198	}	199	}
199		200
200	if (isFloat32Infinity(a) \|\| (a.parts.exp >= (32 + FLOAT32_BIAS))) {	201	if (isFloat32Infinity(a) \|\| (a.parts.exp >= (32 + FLOAT32_BIAS))) {
201	if (a.parts.sign) {	202	if (a.parts.sign) {
202	return MIN_INT32;	203	return MIN_INT32;
203	}	204	}
204	return MAX_INT32;	205	return MAX_INT32;
205	}	206	}
206	return _float32_to_uint32_helper(a);	207	return _float32_to_uint32_helper(a);
207	}	208	}
208		209
209		210
210	/** Helping procedure for converting float64 to uint64	211	/** Helping procedure for converting float64 to uint64
211	* @param a floating point number in normalized form (no NaNs or Inf are checked )	212	* @param a floating point number in normalized form (no NaNs or Inf are checked )
212	* @return unsigned integer	213	* @return unsigned integer
213	*/	214	*/
214	static __u64 _float64_to_uint64_helper(float64 a)	215	static __u64 _float64_to_uint64_helper(float64 a)
215	{	216	{
216	__u64 frac;	217	__u64 frac;
217		218
218	if (a.parts.exp < FLOAT64_BIAS) {	219	if (a.parts.exp < FLOAT64_BIAS) {
219	/TODO: rounding/	220	/TODO: rounding/
220	return 0;	221	return 0;
221	}	222	}
222		223
223	frac = a.parts.fraction;	224	frac = a.parts.fraction;
224		225
225	frac \|= FLOAT64_HIDDEN_BIT_MASK;	226	frac \|= FLOAT64_HIDDEN_BIT_MASK;
226	/* shift fraction to left so hidden bit will be the most significant bit */	227	/* shift fraction to left so hidden bit will be the most significant bit */
227	frac <<= 64 - FLOAT64_FRACTION_SIZE - 1;	228	frac <<= 64 - FLOAT64_FRACTION_SIZE - 1;
228		229
229	frac >>= 64 - (a.parts.exp - FLOAT64_BIAS) - 1;	230	frac >>= 64 - (a.parts.exp - FLOAT64_BIAS) - 1;
230	if ((a.parts.sign == 1) && (frac != 0)) {	231	if ((a.parts.sign == 1) && (frac != 0)) {
231	frac = ~frac;	232	frac = ~frac;
232	++frac;	233	++frac;
233	}	234	}
234		235
235	return frac;	236	return frac;
236	}	237	}
237		238
238	/* Convert float to unsigned int64	239	/* Convert float to unsigned int64
239	* FIXME: Im not sure what to return if overflow/underflow happens	240	* FIXME: Im not sure what to return if overflow/underflow happens
240	* - now its the biggest or the smallest int	241	* - now its the biggest or the smallest int
241	*/	242	*/
242	__u64 float64_to_uint64(float64 a)	243	__u64 float64_to_uint64(float64 a)
243	{	244	{
244	if (isFloat64NaN(a)) {	245	if (isFloat64NaN(a)) {
245	return MAX_UINT64;	246	return MAX_UINT64;
246	}	247	}
247		248
248	if (isFloat64Infinity(a) \|\| (a.parts.exp >= (64 + FLOAT64_BIAS))) {	249	if (isFloat64Infinity(a) \|\| (a.parts.exp >= (64 + FLOAT64_BIAS))) {
249	if (a.parts.sign) {	250	if (a.parts.sign) {
250	return MIN_UINT64;	251	return MIN_UINT64;
251	}	252	}
252	return MAX_UINT64;	253	return MAX_UINT64;
253	}	254	}
254		255
255	return _float64_to_uint64_helper(a);	256	return _float64_to_uint64_helper(a);
256	}	257	}
257		258
258	/* Convert float to signed int64	259	/* Convert float to signed int64
259	* FIXME: Im not sure what to return if overflow/underflow happens	260	* FIXME: Im not sure what to return if overflow/underflow happens
260	* - now its the biggest or the smallest int	261	* - now its the biggest or the smallest int
261	*/	262	*/
262	__s64 float64_to_int64(float64 a)	263	__s64 float64_to_int64(float64 a)
263	{	264	{
264	if (isFloat64NaN(a)) {	265	if (isFloat64NaN(a)) {
265	return MAX_INT64;	266	return MAX_INT64;
266	}	267	}
267		268
268	if (isFloat64Infinity(a) \|\| (a.parts.exp >= (64 + FLOAT64_BIAS))) {	269	if (isFloat64Infinity(a) \|\| (a.parts.exp >= (64 + FLOAT64_BIAS))) {
269	if (a.parts.sign) {	270	if (a.parts.sign) {
270	return MIN_INT64;	271	return MIN_INT64;
271	}	272	}
272	return MAX_INT64;	273	return MAX_INT64;
273	}	274	}
274	return _float64_to_uint64_helper(a);	275	return _float64_to_uint64_helper(a);
275	}	276	}
276		277
277		278
278		279
279		280
280		281
281	/** Helping procedure for converting float32 to uint64	282	/** Helping procedure for converting float32 to uint64
282	* @param a floating point number in normalized form (no NaNs or Inf are checked )	283	* @param a floating point number in normalized form (no NaNs or Inf are checked )
283	* @return unsigned integer	284	* @return unsigned integer
284	*/	285	*/
285	static __u64 _float32_to_uint64_helper(float32 a)	286	static __u64 _float32_to_uint64_helper(float32 a)
286	{	287	{
287	__u64 frac;	288	__u64 frac;
288		289
289	if (a.parts.exp < FLOAT32_BIAS) {	290	if (a.parts.exp < FLOAT32_BIAS) {
290	/TODO: rounding/	291	/TODO: rounding/
291	return 0;	292	return 0;
292	}	293	}
293		294
294	frac = a.parts.fraction;	295	frac = a.parts.fraction;
295		296
296	frac \|= FLOAT32_HIDDEN_BIT_MASK;	297	frac \|= FLOAT32_HIDDEN_BIT_MASK;
297	/* shift fraction to left so hidden bit will be the most significant bit */	298	/* shift fraction to left so hidden bit will be the most significant bit */
298	frac <<= 64 - FLOAT32_FRACTION_SIZE - 1;	299	frac <<= 64 - FLOAT32_FRACTION_SIZE - 1;
299		300
300	frac >>= 64 - (a.parts.exp - FLOAT32_BIAS) - 1;	301	frac >>= 64 - (a.parts.exp - FLOAT32_BIAS) - 1;
301	if ((a.parts.sign == 1) && (frac != 0)) {	302	if ((a.parts.sign == 1) && (frac != 0)) {
302	frac = ~frac;	303	frac = ~frac;
303	++frac;	304	++frac;
304	}	305	}
305		306
306	return frac;	307	return frac;
307	}	308	}
308		309
309	/* Convert float to unsigned int64	310	/* Convert float to unsigned int64
310	* FIXME: Im not sure what to return if overflow/underflow happens	311	* FIXME: Im not sure what to return if overflow/underflow happens
311	* - now its the biggest or the smallest int	312	* - now its the biggest or the smallest int
312	*/	313	*/
313	__u64 float32_to_uint64(float32 a)	314	__u64 float32_to_uint64(float32 a)
314	{	315	{
315	if (isFloat32NaN(a)) {	316	if (isFloat32NaN(a)) {
316	return MAX_UINT64;	317	return MAX_UINT64;
317	}	318	}
318		319
319	if (isFloat32Infinity(a) \|\| (a.parts.exp >= (64 + FLOAT32_BIAS))) {	320	if (isFloat32Infinity(a) \|\| (a.parts.exp >= (64 + FLOAT32_BIAS))) {
320	if (a.parts.sign) {	321	if (a.parts.sign) {
321	return MIN_UINT64;	322	return MIN_UINT64;
322	}	323	}
323	return MAX_UINT64;	324	return MAX_UINT64;
324	}	325	}
325		326
326	return _float32_to_uint64_helper(a);	327	return _float32_to_uint64_helper(a);
327	}	328	}
328		329
329	/* Convert float to signed int64	330	/* Convert float to signed int64
330	* FIXME: Im not sure what to return if overflow/underflow happens	331	* FIXME: Im not sure what to return if overflow/underflow happens
331	* - now its the biggest or the smallest int	332	* - now its the biggest or the smallest int
332	*/	333	*/
333	__s64 float32_to_int64(float32 a)	334	__s64 float32_to_int64(float32 a)
334	{	335	{
335	if (isFloat32NaN(a)) {	336	if (isFloat32NaN(a)) {
336	return MAX_INT64;	337	return MAX_INT64;
337	}	338	}
338		339
339	if (isFloat32Infinity(a) \|\| (a.parts.exp >= (64 + FLOAT32_BIAS))) {	340	if (isFloat32Infinity(a) \|\| (a.parts.exp >= (64 + FLOAT32_BIAS))) {
340	if (a.parts.sign) {	341	if (a.parts.sign) {
341	return (MIN_INT64);	342	return (MIN_INT64);
342	}	343	}
343	return MAX_INT64;	344	return MAX_INT64;
344	}	345	}
345	return _float32_to_uint64_helper(a);	346	return _float32_to_uint64_helper(a);
346	}	347	}
347		348
348		349
349	/* Convert float64 to unsigned int32	350	/* Convert float64 to unsigned int32
350	* FIXME: Im not sure what to return if overflow/underflow happens	351	* FIXME: Im not sure what to return if overflow/underflow happens
351	* - now its the biggest or the smallest int	352	* - now its the biggest or the smallest int
352	*/	353	*/
353	__u32 float64_to_uint32(float64 a)	354	__u32 float64_to_uint32(float64 a)
354	{	355	{
355	if (isFloat64NaN(a)) {	356	if (isFloat64NaN(a)) {
356	return MAX_UINT32;	357	return MAX_UINT32;
357	}	358	}
358		359
359	if (isFloat64Infinity(a) \|\| (a.parts.exp >= (32 + FLOAT64_BIAS))) {	360	if (isFloat64Infinity(a) \|\| (a.parts.exp >= (32 + FLOAT64_BIAS))) {
360	if (a.parts.sign) {	361	if (a.parts.sign) {
361	return MIN_UINT32;	362	return MIN_UINT32;
362	}	363	}
363	return MAX_UINT32;	364	return MAX_UINT32;
364	}	365	}
365		366
366	return (__u32)_float64_to_uint64_helper(a);	367	return (__u32)_float64_to_uint64_helper(a);
367	}	368	}
368		369
369	/* Convert float64 to signed int32	370	/* Convert float64 to signed int32
370	* FIXME: Im not sure what to return if overflow/underflow happens	371	* FIXME: Im not sure what to return if overflow/underflow happens
371	* - now its the biggest or the smallest int	372	* - now its the biggest or the smallest int
372	*/	373	*/
373	__s32 float64_to_int32(float64 a)	374	__s32 float64_to_int32(float64 a)
374	{	375	{
375	if (isFloat64NaN(a)) {	376	if (isFloat64NaN(a)) {
376	return MAX_INT32;	377	return MAX_INT32;
377	}	378	}
378		379
379	if (isFloat64Infinity(a) \|\| (a.parts.exp >= (32 + FLOAT64_BIAS))) {	380	if (isFloat64Infinity(a) \|\| (a.parts.exp >= (32 + FLOAT64_BIAS))) {
380	if (a.parts.sign) {	381	if (a.parts.sign) {
381	return MIN_INT32;	382	return MIN_INT32;
382	}	383	}
383	return MAX_INT32;	384	return MAX_INT32;
384	}	385	}
385	return (__s32)_float64_to_uint64_helper(a);	386	return (__s32)_float64_to_uint64_helper(a);
386	}	387	}
387		388
-		389
-		390	/** Convert unsigned integer to float32
-		391	*
-		392	*
-		393	*/
-		394	float32 uint32_to_float32(__u32 i)
-		395	{
-		396	int counter;
-		397	__s32 exp;
-		398	float32 result;
-		399
-		400	result.parts.sign = 0;
-		401	result.parts.fraction = 0;
-		402
-		403	counter = countZeroes32(i);
-		404
-		405	exp = FLOAT32_BIAS + 32 - counter - 1;
-		406
-		407	if (counter == 32) {
-		408	result.binary = 0;
-		409	return result;
-		410	}
-		411
-		412	if (counter > 0) {
-		413	i <<= counter - 1;
-		414	} else {
-		415	i >>= 1;
-		416	}
-		417
-		418	roundFloat32(&exp, &i);
-		419
-		420	result.parts.fraction = i >> 7;
-		421	result.parts.exp = exp;
-		422
-		423	return result;
-		424	}
388		425
-		426	float32 int32_to_float32(__s32 i)
-		427	{
-		428	float32 result;
-		429
-		430	if (i < 0) {
-		431	result = uint32_to_float32((__u32)(-i));
-		432	} else {
-		433	result = uint32_to_float32((__u32)i);
-		434	}
-		435
-		436	result.parts.sign = i < 0;
-		437
-		438	return result;
-		439	}
-		440
-		441
-		442	float32 uint64_to_float32(__u64 i)
-		443	{
-		444	}
-		445
-		446	float32 int64_to_float32(__s64 i)
-		447	{
-		448	float32 result;
-		449
-		450	if (i < 0) {
-		451	result = uint64_to_float32((__u64)(-i));
-		452	} else {
-		453	result = uint64_to_float32((__u64)i);
-		454	}
-		455
-		456	result.parts.sign = i < 0;
-		457
-		458	return result;
-		459	}
389		460

Subversion Repositories HelenOS-historic

(root)/uspace/trunk/softfloat/generic/conversion.c – Rev 865 → 874