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

Subversion Repositories HelenOS-historic

(root)/uspace/trunk/softfloat/generic/softfloat.c – Rev 804 → 828