WebSVN – HelenOS-historic – Diff – /uspace/trunk/softfloat/generic/common.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.
 */
 
/** @addtogroup softfloat  
 * @{
 */
/** @file
 */
 
#include<sftypes.h>
#include<common.h>
 
/* Table for fast leading zeroes counting */
char zeroTable[256] = {
    8, 7, 7, 6, 6, 6, 6, 4, 4, 4, 4, 4, 4, 4, 4, \
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, \
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, \
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, \
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};
 
 
 
/** Take fraction shifted by 10 bits to left, round it, normalize it and detect exceptions
 * @param cexp exponent with bias
 * @param cfrac fraction shifted 10 places left with added hidden bit
 * @param sign
 * @return valied float64
 */
float64 finishFloat64(int32_t cexp, uint64_t cfrac, char sign)
{
    float64 result;
 
    result.parts.sign = sign;
 
    /* find first nonzero digit and shift result and detect possibly underflow */
    while ((cexp > 0) && (cfrac) && (!(cfrac & (FLOAT64_HIDDEN_BIT_MASK << (64 - FLOAT64_FRACTION_SIZE - 1 ) )))) {
        cexp--;
        cfrac <<= 1;
            /* TODO: fix underflow */
    };
   
    if ((cexp < 0) || ( cexp == 0 && (!(cfrac & (FLOAT64_HIDDEN_BIT_MASK << (64 - FLOAT64_FRACTION_SIZE - 1)))))) {
        /* FIXME: underflow */
        result.parts.exp = 0;
        if ((cexp + FLOAT64_FRACTION_SIZE + 1) < 0) { /* +1 is place for rounding */
            result.parts.fraction = 0;
            return result;
        }
       
        while (cexp < 0) {
            cexp++;
            cfrac >>= 1;
        }
   
        cfrac += (0x1 << (64 - FLOAT64_FRACTION_SIZE - 3));
       
        if (!(cfrac & (FLOAT64_HIDDEN_BIT_MASK << (64 - FLOAT64_FRACTION_SIZE - 1)))) {
           
            result.parts.fraction = ((cfrac >>(64 - FLOAT64_FRACTION_SIZE - 2) ) & (~FLOAT64_HIDDEN_BIT_MASK));
            return result;
        }  
    } else {
        cfrac += (0x1 << (64 - FLOAT64_FRACTION_SIZE - 3));
    }
   
    ++cexp;
 
    if (cfrac & (FLOAT64_HIDDEN_BIT_MASK << (64 - FLOAT64_FRACTION_SIZE - 1 ))) {
        ++cexp;
        cfrac >>= 1;
    }  
 
    /* check overflow */
    if (cexp >= FLOAT64_MAX_EXPONENT ) {
        /* FIXME: overflow, return infinity */
        result.parts.exp = FLOAT64_MAX_EXPONENT;
        result.parts.fraction = 0;
        return result;
    }
 
    result.parts.exp = (uint32_t)cexp;
   
    result.parts.fraction = ((cfrac >>(64 - FLOAT64_FRACTION_SIZE - 2 ) ) & (~FLOAT64_HIDDEN_BIT_MASK));
   
    return result; 
}
 
/** Counts leading zeroes in 64bit unsigned integer
 * @param i
 */
int countZeroes64(uint64_t i)
{
    int j;
    for (j =0; j < 64; j += 8) {
        if ( i & (0xFFll << (56 - j))) {
            return (j + countZeroes8(i >> (56 - j)));
        }
    }
 
    return 64;
}
 
/** Counts leading zeroes in 32bit unsigned integer
 * @param i
 */
int countZeroes32(uint32_t i)
{
    int j;
    for (j =0; j < 32; j += 8) {
        if ( i & (0xFF << (24 - j))) {
            return (j + countZeroes8(i >> (24 - j)));
        }
    }
 
    return 32;
}
 
/** Counts leading zeroes in byte
 * @param i
 */
int countZeroes8(uint8_t i)
{
    return zeroTable[i];
}
 
/** Round and normalize number expressed by exponent and fraction with first bit (equal to hidden bit) at 30. bit
 * @param exp exponent
 * @param fraction part with hidden bit shifted to 30. bit
 */
void roundFloat32(int32_t *exp, uint32_t *fraction)
{
    /* rounding - if first bit after fraction is set then round up */
    (*fraction) += (0x1 << 6);
   
    if ((*fraction) & (FLOAT32_HIDDEN_BIT_MASK << 8)) {
        /* rounding overflow */
        ++(*exp);
        (*fraction) >>= 1;
    };
   
    if (((*exp) >= FLOAT32_MAX_EXPONENT ) || ((*exp) < 0)) {
        /* overflow - set infinity as result */
        (*exp) = FLOAT32_MAX_EXPONENT;
        (*fraction) = 0;
        return;
    }
 
    return;
}
 
/** Round and normalize number expressed by exponent and fraction with first bit (equal to hidden bit) at 62. bit
 * @param exp exponent
 * @param fraction part with hidden bit shifted to 62. bit
 */
void roundFloat64(int32_t *exp, uint64_t *fraction)
{
    /* rounding - if first bit after fraction is set then round up */
    (*fraction) += (0x1 << 9);
   
    if ((*fraction) & (FLOAT64_HIDDEN_BIT_MASK << 11)) {
        /* rounding overflow */
        ++(*exp);
        (*fraction) >>= 1;
    };
   
    if (((*exp) >= FLOAT64_MAX_EXPONENT ) || ((*exp) < 0)) {
        /* overflow - set infinity as result */
        (*exp) = FLOAT64_MAX_EXPONENT;
        (*fraction) = 0;
        return;
    }
 
    return;
}
 
 
/** @}
 */
 
 

Rev 1657	Rev 1740
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	/** @addtogroup softfloat	29	/** @addtogroup softfloat
30	* @{	30	* @{
31	*/	31	*/
32	/** @file	32	/** @file
33	*/	33	*/
34		34
35	#include<sftypes.h>	35	#include<sftypes.h>
36	#include<common.h>	36	#include<common.h>
37		37
38	/* Table for fast leading zeroes counting */	38	/* Table for fast leading zeroes counting */
39	char zeroTable[256] = {	39	char zeroTable[256] = {
40	8, 7, 7, 6, 6, 6, 6, 4, 4, 4, 4, 4, 4, 4, 4, \	40	8, 7, 7, 6, 6, 6, 6, 4, 4, 4, 4, 4, 4, 4, 4, \
41	3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, \	41	3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, \
42	2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, \	42	2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, \
43	2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, \	43	2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, \
44	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \	44	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
45	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \	45	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
46	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \	46	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
47	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \	47	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
48	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \	48	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
49	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \	49	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
50	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \	50	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
51	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \	51	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
52	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \	52	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
53	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \	53	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
54	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \	54	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
55	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0	55	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
56	};	56	};
57		57
58		58
59		59
60	/** Take fraction shifted by 10 bits to left, round it, normalize it and detect exceptions	60	/** Take fraction shifted by 10 bits to left, round it, normalize it and detect exceptions
61	* @param cexp exponent with bias	61	* @param cexp exponent with bias
62	* @param cfrac fraction shifted 10 places left with added hidden bit	62	* @param cfrac fraction shifted 10 places left with added hidden bit
63	* @param sign	63	* @param sign
64	* @return valied float64	64	* @return valied float64
65	*/	65	*/
66	float64 finishFloat64(int32_t cexp, uint64_t cfrac, char sign)	66	float64 finishFloat64(int32_t cexp, uint64_t cfrac, char sign)
67	{	67	{
68	float64 result;	68	float64 result;
69		69
70	result.parts.sign = sign;	70	result.parts.sign = sign;
71		71
72	/* find first nonzero digit and shift result and detect possibly underflow */	72	/* find first nonzero digit and shift result and detect possibly underflow */
73	while ((cexp > 0) && (cfrac) && (!(cfrac & (FLOAT64_HIDDEN_BIT_MASK << (64 - FLOAT64_FRACTION_SIZE - 1 ) )))) {	73	while ((cexp > 0) && (cfrac) && (!(cfrac & (FLOAT64_HIDDEN_BIT_MASK << (64 - FLOAT64_FRACTION_SIZE - 1 ) )))) {
74	cexp--;	74	cexp--;
75	cfrac <<= 1;	75	cfrac <<= 1;
76	/* TODO: fix underflow */	76	/* TODO: fix underflow */
77	};	77	};
78		78
79	if ((cexp < 0) \|\| ( cexp == 0 && (!(cfrac & (FLOAT64_HIDDEN_BIT_MASK << (64 - FLOAT64_FRACTION_SIZE - 1)))))) {	79	if ((cexp < 0) \|\| ( cexp == 0 && (!(cfrac & (FLOAT64_HIDDEN_BIT_MASK << (64 - FLOAT64_FRACTION_SIZE - 1)))))) {
80	/* FIXME: underflow */	80	/* FIXME: underflow */
81	result.parts.exp = 0;	81	result.parts.exp = 0;
82	if ((cexp + FLOAT64_FRACTION_SIZE + 1) < 0) { /* +1 is place for rounding */	82	if ((cexp + FLOAT64_FRACTION_SIZE + 1) < 0) { /* +1 is place for rounding */
83	result.parts.fraction = 0;	83	result.parts.fraction = 0;
84	return result;	84	return result;
85	}	85	}
86		86
87	while (cexp < 0) {	87	while (cexp < 0) {
88	cexp++;	88	cexp++;
89	cfrac >>= 1;	89	cfrac >>= 1;
90	}	90	}
91		91
92	cfrac += (0x1 << (64 - FLOAT64_FRACTION_SIZE - 3));	92	cfrac += (0x1 << (64 - FLOAT64_FRACTION_SIZE - 3));
93		93
94	if (!(cfrac & (FLOAT64_HIDDEN_BIT_MASK << (64 - FLOAT64_FRACTION_SIZE - 1)))) {	94	if (!(cfrac & (FLOAT64_HIDDEN_BIT_MASK << (64 - FLOAT64_FRACTION_SIZE - 1)))) {
95		95
96	result.parts.fraction = ((cfrac >>(64 - FLOAT64_FRACTION_SIZE - 2) ) & (~FLOAT64_HIDDEN_BIT_MASK));	96	result.parts.fraction = ((cfrac >>(64 - FLOAT64_FRACTION_SIZE - 2) ) & (~FLOAT64_HIDDEN_BIT_MASK));
97	return result;	97	return result;
98	}	98	}
99	} else {	99	} else {
100	cfrac += (0x1 << (64 - FLOAT64_FRACTION_SIZE - 3));	100	cfrac += (0x1 << (64 - FLOAT64_FRACTION_SIZE - 3));
101	}	101	}
102		102
103	++cexp;	103	++cexp;
104		104
105	if (cfrac & (FLOAT64_HIDDEN_BIT_MASK << (64 - FLOAT64_FRACTION_SIZE - 1 ))) {	105	if (cfrac & (FLOAT64_HIDDEN_BIT_MASK << (64 - FLOAT64_FRACTION_SIZE - 1 ))) {
106	++cexp;	106	++cexp;
107	cfrac >>= 1;	107	cfrac >>= 1;
108	}	108	}
109		109
110	/* check overflow */	110	/* check overflow */
111	if (cexp >= FLOAT64_MAX_EXPONENT ) {	111	if (cexp >= FLOAT64_MAX_EXPONENT ) {
112	/* FIXME: overflow, return infinity */	112	/* FIXME: overflow, return infinity */
113	result.parts.exp = FLOAT64_MAX_EXPONENT;	113	result.parts.exp = FLOAT64_MAX_EXPONENT;
114	result.parts.fraction = 0;	114	result.parts.fraction = 0;
115	return result;	115	return result;
116	}	116	}
117		117
118	result.parts.exp = (uint32_t)cexp;	118	result.parts.exp = (uint32_t)cexp;
119		119
120	result.parts.fraction = ((cfrac >>(64 - FLOAT64_FRACTION_SIZE - 2 ) ) & (~FLOAT64_HIDDEN_BIT_MASK));	120	result.parts.fraction = ((cfrac >>(64 - FLOAT64_FRACTION_SIZE - 2 ) ) & (~FLOAT64_HIDDEN_BIT_MASK));
121		121
122	return result;	122	return result;
123	}	123	}
124		124
125	/** Counts leading zeroes in 64bit unsigned integer	125	/** Counts leading zeroes in 64bit unsigned integer
126	* @param i	126	* @param i
127	*/	127	*/
128	int countZeroes64(uint64_t i)	128	int countZeroes64(uint64_t i)
129	{	129	{
130	int j;	130	int j;
131	for (j =0; j < 64; j += 8) {	131	for (j =0; j < 64; j += 8) {
132	if ( i & (0xFFll << (56 - j))) {	132	if ( i & (0xFFll << (56 - j))) {
133	return (j + countZeroes8(i >> (56 - j)));	133	return (j + countZeroes8(i >> (56 - j)));
134	}	134	}
135	}	135	}
136		136
137	return 64;	137	return 64;
138	}	138	}
139		139
140	/** Counts leading zeroes in 32bit unsigned integer	140	/** Counts leading zeroes in 32bit unsigned integer
141	* @param i	141	* @param i
142	*/	142	*/
143	int countZeroes32(uint32_t i)	143	int countZeroes32(uint32_t i)
144	{	144	{
145	int j;	145	int j;
146	for (j =0; j < 32; j += 8) {	146	for (j =0; j < 32; j += 8) {
147	if ( i & (0xFF << (24 - j))) {	147	if ( i & (0xFF << (24 - j))) {
148	return (j + countZeroes8(i >> (24 - j)));	148	return (j + countZeroes8(i >> (24 - j)));
149	}	149	}
150	}	150	}
151		151
152	return 32;	152	return 32;
153	}	153	}
154		154
155	/** Counts leading zeroes in byte	155	/** Counts leading zeroes in byte
156	* @param i	156	* @param i
157	*/	157	*/
158	int countZeroes8(uint8_t i)	158	int countZeroes8(uint8_t i)
159	{	159	{
160	return zeroTable[i];	160	return zeroTable[i];
161	}	161	}
162		162
163	/** Round and normalize number expressed by exponent and fraction with first bit (equal to hidden bit) at 30. bit	163	/** Round and normalize number expressed by exponent and fraction with first bit (equal to hidden bit) at 30. bit
164	* @param exp exponent	164	* @param exp exponent
165	* @param fraction part with hidden bit shifted to 30. bit	165	* @param fraction part with hidden bit shifted to 30. bit
166	*/	166	*/
167	void roundFloat32(int32_t exp, uint32_t fraction)	167	void roundFloat32(int32_t exp, uint32_t fraction)
168	{	168	{
169	/* rounding - if first bit after fraction is set then round up */	169	/* rounding - if first bit after fraction is set then round up */
170	(*fraction) += (0x1 << 6);	170	(*fraction) += (0x1 << 6);
171		171
172	if ((*fraction) & (FLOAT32_HIDDEN_BIT_MASK << 8)) {	172	if ((*fraction) & (FLOAT32_HIDDEN_BIT_MASK << 8)) {
173	/* rounding overflow */	173	/* rounding overflow */
174	++(*exp);	174	++(*exp);
175	(*fraction) >>= 1;	175	(*fraction) >>= 1;
176	};	176	};
177		177
178	if (((exp) >= FLOAT32_MAX_EXPONENT ) \|\| ((exp) < 0)) {	178	if (((exp) >= FLOAT32_MAX_EXPONENT ) \|\| ((exp) < 0)) {
179	/* overflow - set infinity as result */	179	/* overflow - set infinity as result */
180	(*exp) = FLOAT32_MAX_EXPONENT;	180	(*exp) = FLOAT32_MAX_EXPONENT;
181	(*fraction) = 0;	181	(*fraction) = 0;
182	return;	182	return;
183	}	183	}
184		184
185	return;	185	return;
186	}	186	}
187		187
188	/** Round and normalize number expressed by exponent and fraction with first bit (equal to hidden bit) at 62. bit	188	/** Round and normalize number expressed by exponent and fraction with first bit (equal to hidden bit) at 62. bit
189	* @param exp exponent	189	* @param exp exponent
190	* @param fraction part with hidden bit shifted to 62. bit	190	* @param fraction part with hidden bit shifted to 62. bit
191	*/	191	*/
192	void roundFloat64(int32_t exp, uint64_t fraction)	192	void roundFloat64(int32_t exp, uint64_t fraction)
193	{	193	{
194	/* rounding - if first bit after fraction is set then round up */	194	/* rounding - if first bit after fraction is set then round up */
195	(*fraction) += (0x1 << 9);	195	(*fraction) += (0x1 << 9);
196		196
197	if ((*fraction) & (FLOAT64_HIDDEN_BIT_MASK << 11)) {	197	if ((*fraction) & (FLOAT64_HIDDEN_BIT_MASK << 11)) {
198	/* rounding overflow */	198	/* rounding overflow */
199	++(*exp);	199	++(*exp);
200	(*fraction) >>= 1;	200	(*fraction) >>= 1;
201	};	201	};
202		202
203	if (((exp) >= FLOAT64_MAX_EXPONENT ) \|\| ((exp) < 0)) {	203	if (((exp) >= FLOAT64_MAX_EXPONENT ) \|\| ((exp) < 0)) {
204	/* overflow - set infinity as result */	204	/* overflow - set infinity as result */
205	(*exp) = FLOAT64_MAX_EXPONENT;	205	(*exp) = FLOAT64_MAX_EXPONENT;
206	(*fraction) = 0;	206	(*fraction) = 0;
207	return;	207	return;
208	}	208	}
209		209
210	return;	210	return;
211	}	211	}
212		212
213		-
214	/** @}	213	/** @}
215	*/	214	*/
216		215
217		216

Subversion Repositories HelenOS-historic

(root)/uspace/trunk/softfloat/generic/common.c – Rev 1657 → 1740