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 __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 */
 
/* 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 */
 
 

Rev 653	Rev 660
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 __negsf2(float a)	66	float __negsf2(float a)
67	{	67	{
68	float32 fa;	68	float32 fa;
69	fa.f=a;	69	fa.f=a;
70	fa.parts.sign=!fa.parts.sign;	70	fa.parts.sign=!fa.parts.sign;
71	return fa.f;	71	return fa.f;
72	};	72	};
73		73
74	double __negdf2(double a)	74	double __negdf2(double a)
75	{	75	{
76	float64 fa;	76	float64 fa;
77	fa.d=a;	77	fa.d=a;
78	fa.parts.sign=!fa.parts.sign;	78	fa.parts.sign=!fa.parts.sign;
79	return fa.d;	79	return fa.d;
80	};	80	};
81		81
82	/* Conversion functions */	82	/* Conversion functions */
83		83
84	/* Comparison functions */	84	/* Comparison functions */
85		85
86	/* a<b .. -1	86	/* a<b .. -1
87	* a=b .. 0	87	* a=b .. 0
88	* a>b .. 1	88	* a>b .. 1
89	* */	89	* */
90		90
91	int __cmpsf2(double a, double b)	91	int __cmpsf2(float a, float b)
92	{	92	{
93	float32 fa,fb;	93	float32 fa,fb;
94	fa.f=a;	94	fa.f=a;
95	fb.f=b;	95	fb.f=b;
96	if ((isFloat32NaN(fa))\|\|(isFloat32NaN(fb))) {	96	if ((isFloat32NaN(fa))\|\|(isFloat32NaN(fb))) {
97	return 1; /* no special constant for unordered - maybe signaled? */	97	return 1; /* no special constant for unordered - maybe signaled? */
98	};	98	};
99		99
100		100
101	if (isFloat32eq(fa,fb)) {	101	if (isFloat32eq(fa,fb)) {
102	return 0;	102	return 0;
103	};	103	};
104		104
105	if (isFloat32lt(fa,fb)) {	105	if (isFloat32lt(fa,fb)) {
106	return -1;	106	return -1;
107	};	107	};
108	return 1;	108	return 1;
109	}	109	}
110		110
111	int __unordsf2(float a, float b)	111	int __unordsf2(float a, float b)
112	{	112	{
113	float32 fa,fb;	113	float32 fa,fb;
114	fa.f=a;	114	fa.f=a;
115	fb.f=b;	115	fb.f=b;
116	return ((isFloat32NaN(fa))\|\|(isFloat32NaN(fb)));	116	return ((isFloat32NaN(fa))\|\|(isFloat32NaN(fb)));
117	};	117	};
118		118
119	/**	119	/**
120	* @return zero, if neither argument is a NaN and are equal	120	* @return zero, if neither argument is a NaN and are equal
121	* */	121	* */
122	int __eqsf2(float a, float b)	122	int __eqsf2(float a, float b)
123	{	123	{
124	float32 fa,fb;	124	float32 fa,fb;
125	fa.f=a;	125	fa.f=a;
126	fb.f=b;	126	fb.f=b;
127	if ((isFloat32NaN(fa))\|\|(isFloat32NaN(fb))) {	127	if ((isFloat32NaN(fa))\|\|(isFloat32NaN(fb))) {
128	/* TODO: sigNaNs*/	128	/* TODO: sigNaNs*/
129	return 1;	129	return 1;
130	};	130	};
131	return isFloat32eq(fa,fb)-1;	131	return isFloat32eq(fa,fb)-1;
132	};	132	};
133		133
134	/* strange behavior, but it was in gcc documentation */	134	/* strange behavior, but it was in gcc documentation */
135	int __nesf2(float a, float b)	135	int __nesf2(float a, float b)
136	{	136	{
137	return __eqsf2(a,b);	137	return __eqsf2(a,b);
138	};	138	};
139		139
140	/* return value >= 0 if a>=b and neither is NaN */	140	/* return value >= 0 if a>=b and neither is NaN */
141	int __gesf2(float a, float b)	141	int __gesf2(float a, float b)
142	{	142	{
143	float32 fa,fb;	143	float32 fa,fb;
144	fa.f=a;	144	fa.f=a;
145	fb.f=b;	145	fb.f=b;
146	if ((isFloat32NaN(fa))\|\|(isFloat32NaN(fb))) {	146	if ((isFloat32NaN(fa))\|\|(isFloat32NaN(fb))) {
147	/* TODO: sigNaNs*/	147	/* TODO: sigNaNs*/
148	return 1;	148	return -1;
149	};	149	};
150		150
151	if (isFloat32eq(fa,fb)) {	151	if (isFloat32eq(fa,fb)) {
152	return 0;	152	return 0;
153	};	153	};
154		154
155	if (isFloat32gt(fa,fb)) {	155	if (isFloat32gt(fa,fb)) {
156	return 1;	156	return 1;
157	};	157	};
158		158
159	return -1;	159	return -1;
160	}	160	}
161		161
162	/** Return negative value, if a<b and neither is NaN*/	162	/** Return negative value, if a<b and neither is NaN*/
163	int __ltsf2(float a, float b)	163	int __ltsf2(float a, float b)
164	{	164	{
165	float32 fa,fb;	165	float32 fa,fb;
166	fa.f=a;	166	fa.f=a;
167	fb.f=b;	167	fb.f=b;
168	if ((isFloat32NaN(fa))\|\|(isFloat32NaN(fb))) {	168	if ((isFloat32NaN(fa))\|\|(isFloat32NaN(fb))) {
169	/* TODO: sigNaNs*/	169	/* TODO: sigNaNs*/
170	return 1;	170	return 1;
171	};	171	};
172	if (isFloat32lt(fa, fb)) {	172	if (isFloat32lt(fa, fb)) {
173	return -1;	173	return -1;
174	};	174	};
175	return 0;	175	return 0;
176	}	176	}
177		177
178	/* return value <= 0 if a<=b and neither is NaN */	178	/* return value <= 0 if a<=b and neither is NaN */
179	int __lesf2(float a, float b)	179	int __lesf2(float a, float b)
180	{	180	{
181	float32 fa,fb;	181	float32 fa,fb;
182	fa.f=a;	182	fa.f=a;
183	fb.f=b;	183	fb.f=b;
184	if ((isFloat32NaN(fa))\|\|(isFloat32NaN(fb))) {	184	if ((isFloat32NaN(fa))\|\|(isFloat32NaN(fb))) {
185	/* TODO: sigNaNs*/	185	/* TODO: sigNaNs*/
186	return 1;	186	return 1;
187	};	187	};
188		188
189	if (isFloat32eq(fa,fb)) {	189	if (isFloat32eq(fa,fb)) {
190	return 0;	190	return 0;
191	};	191	};
192		192
193	if (isFloat32lt(fa,fb)) {	193	if (isFloat32lt(fa,fb)) {
194	return -1;	194	return -1;
195	};	195	};
196		196
197	return 1;	197	return 1;
198	}	198	}
199		199
200	/** Return positive value, if a>b and neither is NaN*/	200	/** Return positive value, if a>b and neither is NaN*/
201	int __ltsf2(float a, float b)	201	int __gtsf2(float a, float b)
202	{	202	{
203	float32 fa,fb;	203	float32 fa,fb;
204	fa.f=a;	204	fa.f=a;
205	fb.f=b;	205	fb.f=b;
206	if ((isFloat32NaN(fa))\|\|(isFloat32NaN(fb))) {	206	if ((isFloat32NaN(fa))\|\|(isFloat32NaN(fb))) {
207	/* TODO: sigNaNs*/	207	/* TODO: sigNaNs*/
208	return 1;	208	return -1;
209	};	209	};
210	if (isFloat32gt(fa, fb)) {	210	if (isFloat32gt(fa, fb)) {
211	return 1;	211	return 1;
212	};	212	};
213	return 0;	213	return 0;
214	}	214	}
215		215
216	/* Other functions */	216	/* Other functions */
217		217
218		218

Subversion Repositories HelenOS-historic

(root)/uspace/trunk/softfloat/generic/softfloat.c – Rev 653 → 660