WebSVN – HelenOS-historic – Diff – /uspace/trunk/softfloat/generic/softfloat.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<softfloat.h>
#include<sftypes.h>
#include<arithmetic.h>
#include<conversion.h>
#include<comparison.h>
#include<other.h>
 
/* Arithmetic functions */
 
float __addsf3(float a, float b)
{
    float32 fa, fb;
    fa.f=a;
    fb.f=b;
    if (fa.parts.sign!=fb.parts.sign) {
        if (fa.parts.sign) {
            fa.parts.sign=0;
            return subFloat32(fb,fa).f;
        };
        fb.parts.sign=0;
        return subFloat32(fa,fb).f;
    }
    return addFloat32(fa,fb).f;
}
 
float __subsf3(float a, float b)
{
    float32 fa, fb;
    fa.f=a;
    fb.f=b;
    if (fa.parts.sign!=fb.parts.sign) {
        fb.parts.sign=!fb.parts.sign;
        return addFloat32(fa,fb).f;
    }
    return subFloat32(fa,fb).f;
}
 
float __mulsf3(float a, float b)
{
    float32 fa, fb;
    fa.f=a;
    fb.f=b;
    return  mulFloat32(fa, fb).f;
}
 
float __divsf3(float a, float b)
{
    float32 fa, fb;
    fa.f=a;
    fb.f=b;
//  return  divFloat32(fa, fb).f;
}
 
float __negsf2(float a)
{
    float32 fa;
    fa.f=a;
    fa.parts.sign=!fa.parts.sign;
    return fa.f;
}
 
double __negdf2(double a)
{
    float64 fa;
    fa.d=a;
    fa.parts.sign=!fa.parts.sign;
    return fa.d;
}
 
/* Conversion functions */
 
double __extendsfdf2(float a)
{
    float32 fa;
    fa.f = a;
    return convertFloat32ToFloat64(fa).d;
}
 
float __truncdfsf2(double a)
{
    float64 da;
    da.d = a;
    return convertFloat64ToFloat32(da).f;
}
 
/* Comparison functions */
 
/* a<b .. -1
 * a=b ..  0
 * a>b ..  1
 * */
 
int __cmpsf2(float a, float b)
{
    float32 fa,fb;
    fa.f=a;
    fb.f=b;
    if ((isFloat32NaN(fa))||(isFloat32NaN(fb))) {
        return 1; /* no special constant for unordered - maybe signaled? */
    };
 
   
    if (isFloat32eq(fa,fb)) {
        return 0;
    };
   
    if (isFloat32lt(fa,fb)) {
        return -1;
        };
    return 1;
}
 
int __unordsf2(float a, float b)
{
    float32 fa,fb;
    fa.f=a;
    fb.f=b;
    return ((isFloat32NaN(fa))||(isFloat32NaN(fb)));
}
 
/**
 * @return zero, if neither argument is a NaN and are equal
 * */
int __eqsf2(float a, float b)
{
    float32 fa,fb;
    fa.f=a;
    fb.f=b;
    if ((isFloat32NaN(fa))||(isFloat32NaN(fb))) {
        /* TODO: sigNaNs*/
        return 1;
        };
    return isFloat32eq(fa,fb)-1;
}
 
/* strange behavior, but it was in gcc documentation */
int __nesf2(float a, float b)
{
    return __eqsf2(a,b);
}
 
/* return value >= 0 if a>=b and neither is NaN */
int __gesf2(float a, float b)
{
    float32 fa,fb;
    fa.f=a;
    fb.f=b;
    if ((isFloat32NaN(fa))||(isFloat32NaN(fb))) {
        /* TODO: sigNaNs*/
        return -1;
        };
   
    if (isFloat32eq(fa,fb)) {
        return 0;
    };
   
    if (isFloat32gt(fa,fb)) {
        return 1;
        };
   
    return -1;
}
 
/** Return negative value, if a<b and neither is NaN*/
int __ltsf2(float a, float b)
{
    float32 fa,fb;
    fa.f=a;
    fb.f=b;
    if ((isFloat32NaN(fa))||(isFloat32NaN(fb))) {
        /* TODO: sigNaNs*/
        return 1;
        };
    if (isFloat32lt(fa, fb)) {
        return -1;
        };
    return 0;
}
 
/* return value <= 0 if a<=b and neither is NaN */
int __lesf2(float a, float b)
{
    float32 fa,fb;
    fa.f=a;
    fb.f=b;
    if ((isFloat32NaN(fa))||(isFloat32NaN(fb))) {
        /* TODO: sigNaNs*/
        return 1;
        };
   
    if (isFloat32eq(fa,fb)) {
        return 0;
    };
   
    if (isFloat32lt(fa,fb)) {
        return -1;
        };
   
    return 1;
}
 
/** Return positive value, if a>b and neither is NaN*/
int __gtsf2(float a, float b)
{
    float32 fa,fb;
    fa.f=a;
    fb.f=b;
    if ((isFloat32NaN(fa))||(isFloat32NaN(fb))) {
        /* TODO: sigNaNs*/
        return -1;
        };
    if (isFloat32gt(fa, fb)) {
        return 1;
        };
    return 0;
}
 
/* Other functions */
 
float __powisf2(float a, int b)
{
//TODO: 
}
 
float __mulsc3(float a, float b, float c, float d)
{
//TODO:
}
 
float __divsc3(float a, float b, float c, float d)
{
//TODO:
}
 
 

Rev 697	Rev 698
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<softfloat.h>	29	#include<softfloat.h>
30	#include<sftypes.h>	30	#include<sftypes.h>
31	#include<arithmetic.h>	31	#include<arithmetic.h>
32	#include<conversion.h>	32	#include<conversion.h>
33	#include<comparison.h>	33	#include<comparison.h>
34	#include<other.h>	34	#include<other.h>
35		35
36	/* Arithmetic functions */	36	/* Arithmetic functions */
37		37
38	float __addsf3(float a, float b)	38	float __addsf3(float a, float b)
39	{	39	{
40	float32 fa, fb;	40	float32 fa, fb;
41	fa.f=a;	41	fa.f=a;
42	fb.f=b;	42	fb.f=b;
43	if (fa.parts.sign!=fb.parts.sign) {	43	if (fa.parts.sign!=fb.parts.sign) {
44	if (fa.parts.sign) {	44	if (fa.parts.sign) {
45	fa.parts.sign=0;	45	fa.parts.sign=0;
46	return subFloat32(fb,fa).f;	46	return subFloat32(fb,fa).f;
47	};	47	};
48	fb.parts.sign=0;	48	fb.parts.sign=0;
49	return subFloat32(fa,fb).f;	49	return subFloat32(fa,fb).f;
50	}	50	}
51	return addFloat32(fa,fb).f;	51	return addFloat32(fa,fb).f;
52	};	52	}
53		53
54	float __subsf3(float a, float b)	54	float __subsf3(float a, float b)
55	{	55	{
56	float32 fa, fb;	56	float32 fa, fb;
57	fa.f=a;	57	fa.f=a;
58	fb.f=b;	58	fb.f=b;
59	if (fa.parts.sign!=fb.parts.sign) {	59	if (fa.parts.sign!=fb.parts.sign) {
60	fb.parts.sign=!fb.parts.sign;	60	fb.parts.sign=!fb.parts.sign;
61	return addFloat32(fa,fb).f;	61	return addFloat32(fa,fb).f;
62	}	62	}
63	return subFloat32(fa,fb).f;	63	return subFloat32(fa,fb).f;
64	};	64	}
65		65
66	float __mulsf3(float a, float b)	66	float __mulsf3(float a, float b)
67	{	67	{
68	float32 fa, fb;	68	float32 fa, fb;
69	fa.f=a;	69	fa.f=a;
70	fb.f=b;	70	fb.f=b;
71	return mulFloat32(fa, fb).f;	71	return mulFloat32(fa, fb).f;
72	}	72	}
73		73
74	float __divsf3(float a, float b)	74	float __divsf3(float a, float b)
75	{	75	{
76	float32 fa, fb;	76	float32 fa, fb;
77	fa.f=a;	77	fa.f=a;
78	fb.f=b;	78	fb.f=b;
79	// return divFloat32(fa, fb).f;	79	// return divFloat32(fa, fb).f;
80	};	80	}
81		81
82	float __negsf2(float a)	82	float __negsf2(float a)
83	{	83	{
84	float32 fa;	84	float32 fa;
85	fa.f=a;	85	fa.f=a;
86	fa.parts.sign=!fa.parts.sign;	86	fa.parts.sign=!fa.parts.sign;
87	return fa.f;	87	return fa.f;
88	};	88	}
89		89
90	double __negdf2(double a)	90	double __negdf2(double a)
91	{	91	{
92	float64 fa;	92	float64 fa;
93	fa.d=a;	93	fa.d=a;
94	fa.parts.sign=!fa.parts.sign;	94	fa.parts.sign=!fa.parts.sign;
95	return fa.d;	95	return fa.d;
96	};	96	}
97		97
98	/* Conversion functions */	98	/* Conversion functions */
99		99
100	double __extendsfdf2(float a)	100	double __extendsfdf2(float a)
101	{	101	{
102	float32 fa;	102	float32 fa;
103	fa.f = a;	103	fa.f = a;
104	return convertFloat32ToFloat64(fa).d;	104	return convertFloat32ToFloat64(fa).d;
105	};	105	}
106		106
107	float __truncdfsf2(double a)	107	float __truncdfsf2(double a)
108	{	108	{
109	float64 da;	109	float64 da;
110	da.d = a;	110	da.d = a;
111	return convertFloat64ToFloat32(da).f;	111	return convertFloat64ToFloat32(da).f;
112	}	112	}
-		113
113	/* Comparison functions */	114	/* Comparison functions */
114		115
115	/* a<b .. -1	116	/* a<b .. -1
116	* a=b .. 0	117	* a=b .. 0
117	* a>b .. 1	118	* a>b .. 1
118	* */	119	* */
119		120
120	int __cmpsf2(float a, float b)	121	int __cmpsf2(float a, float b)
121	{	122	{
122	float32 fa,fb;	123	float32 fa,fb;
123	fa.f=a;	124	fa.f=a;
124	fb.f=b;	125	fb.f=b;
125	if ((isFloat32NaN(fa))\|\|(isFloat32NaN(fb))) {	126	if ((isFloat32NaN(fa))\|\|(isFloat32NaN(fb))) {
126	return 1; /* no special constant for unordered - maybe signaled? */	127	return 1; /* no special constant for unordered - maybe signaled? */
127	};	128	};
128		129
129		130
130	if (isFloat32eq(fa,fb)) {	131	if (isFloat32eq(fa,fb)) {
131	return 0;	132	return 0;
132	};	133	};
133		134
134	if (isFloat32lt(fa,fb)) {	135	if (isFloat32lt(fa,fb)) {
135	return -1;	136	return -1;
136	};	137	};
137	return 1;	138	return 1;
138	}	139	}
139		140
140	int __unordsf2(float a, float b)	141	int __unordsf2(float a, float b)
141	{	142	{
142	float32 fa,fb;	143	float32 fa,fb;
143	fa.f=a;	144	fa.f=a;
144	fb.f=b;	145	fb.f=b;
145	return ((isFloat32NaN(fa))\|\|(isFloat32NaN(fb)));	146	return ((isFloat32NaN(fa))\|\|(isFloat32NaN(fb)));
146	};	147	}
147		148
148	/**	149	/**
149	* @return zero, if neither argument is a NaN and are equal	150	* @return zero, if neither argument is a NaN and are equal
150	* */	151	* */
151	int __eqsf2(float a, float b)	152	int __eqsf2(float a, float b)
152	{	153	{
153	float32 fa,fb;	154	float32 fa,fb;
154	fa.f=a;	155	fa.f=a;
155	fb.f=b;	156	fb.f=b;
156	if ((isFloat32NaN(fa))\|\|(isFloat32NaN(fb))) {	157	if ((isFloat32NaN(fa))\|\|(isFloat32NaN(fb))) {
157	/* TODO: sigNaNs*/	158	/* TODO: sigNaNs*/
158	return 1;	159	return 1;
159	};	160	};
160	return isFloat32eq(fa,fb)-1;	161	return isFloat32eq(fa,fb)-1;
161	};	162	}
162		163
163	/* strange behavior, but it was in gcc documentation */	164	/* strange behavior, but it was in gcc documentation */
164	int __nesf2(float a, float b)	165	int __nesf2(float a, float b)
165	{	166	{
166	return __eqsf2(a,b);	167	return __eqsf2(a,b);
167	};	168	}
168		169
169	/* return value >= 0 if a>=b and neither is NaN */	170	/* return value >= 0 if a>=b and neither is NaN */
170	int __gesf2(float a, float b)	171	int __gesf2(float a, float b)
171	{	172	{
172	float32 fa,fb;	173	float32 fa,fb;
173	fa.f=a;	174	fa.f=a;
174	fb.f=b;	175	fb.f=b;
175	if ((isFloat32NaN(fa))\|\|(isFloat32NaN(fb))) {	176	if ((isFloat32NaN(fa))\|\|(isFloat32NaN(fb))) {
176	/* TODO: sigNaNs*/	177	/* TODO: sigNaNs*/
177	return -1;	178	return -1;
178	};	179	};
179		180
180	if (isFloat32eq(fa,fb)) {	181	if (isFloat32eq(fa,fb)) {
181	return 0;	182	return 0;
182	};	183	};
183		184
184	if (isFloat32gt(fa,fb)) {	185	if (isFloat32gt(fa,fb)) {
185	return 1;	186	return 1;
186	};	187	};
187		188
188	return -1;	189	return -1;
189	}	190	}
190		191
191	/** Return negative value, if a<b and neither is NaN*/	192	/** Return negative value, if a<b and neither is NaN*/
192	int __ltsf2(float a, float b)	193	int __ltsf2(float a, float b)
193	{	194	{
194	float32 fa,fb;	195	float32 fa,fb;
195	fa.f=a;	196	fa.f=a;
196	fb.f=b;	197	fb.f=b;
197	if ((isFloat32NaN(fa))\|\|(isFloat32NaN(fb))) {	198	if ((isFloat32NaN(fa))\|\|(isFloat32NaN(fb))) {
198	/* TODO: sigNaNs*/	199	/* TODO: sigNaNs*/
199	return 1;	200	return 1;
200	};	201	};
201	if (isFloat32lt(fa, fb)) {	202	if (isFloat32lt(fa, fb)) {
202	return -1;	203	return -1;
203	};	204	};
204	return 0;	205	return 0;
205	}	206	}
206		207
207	/* return value <= 0 if a<=b and neither is NaN */	208	/* return value <= 0 if a<=b and neither is NaN */
208	int __lesf2(float a, float b)	209	int __lesf2(float a, float b)
209	{	210	{
210	float32 fa,fb;	211	float32 fa,fb;
211	fa.f=a;	212	fa.f=a;
212	fb.f=b;	213	fb.f=b;
213	if ((isFloat32NaN(fa))\|\|(isFloat32NaN(fb))) {	214	if ((isFloat32NaN(fa))\|\|(isFloat32NaN(fb))) {
214	/* TODO: sigNaNs*/	215	/* TODO: sigNaNs*/
215	return 1;	216	return 1;
216	};	217	};
217		218
218	if (isFloat32eq(fa,fb)) {	219	if (isFloat32eq(fa,fb)) {
219	return 0;	220	return 0;
220	};	221	};
221		222
222	if (isFloat32lt(fa,fb)) {	223	if (isFloat32lt(fa,fb)) {
223	return -1;	224	return -1;
224	};	225	};
225		226
226	return 1;	227	return 1;
227	}	228	}
228		229
229	/** Return positive value, if a>b and neither is NaN*/	230	/** Return positive value, if a>b and neither is NaN*/
230	int __gtsf2(float a, float b)	231	int __gtsf2(float a, float b)
231	{	232	{
232	float32 fa,fb;	233	float32 fa,fb;
233	fa.f=a;	234	fa.f=a;
234	fb.f=b;	235	fb.f=b;
235	if ((isFloat32NaN(fa))\|\|(isFloat32NaN(fb))) {	236	if ((isFloat32NaN(fa))\|\|(isFloat32NaN(fb))) {
236	/* TODO: sigNaNs*/	237	/* TODO: sigNaNs*/
237	return -1;	238	return -1;
238	};	239	};
239	if (isFloat32gt(fa, fb)) {	240	if (isFloat32gt(fa, fb)) {
240	return 1;	241	return 1;
241	};	242	};
242	return 0;	243	return 0;
243	}	244	}
244		245
245	/* Other functions */	246	/* Other functions */
246		247
-		248	float __powisf2(float a, int b)
-		249	{
-		250	//TODO:
-		251	}
-		252
-		253	float __mulsc3(float a, float b, float c, float d)
-		254	{
-		255	//TODO:
-		256	}
-		257
-		258	float __divsc3(float a, float b, float c, float d)
-		259	{
-		260	//TODO:
-		261	}
-		262
247		263

Subversion Repositories HelenOS-historic

(root)/uspace/trunk/softfloat/generic/softfloat.c – Rev 697 → 698