source: mainline/softfloat/generic/softfloat.c@ d3ca210

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since d3ca210 was e6a40ac, checked in by Josef Cejka <malyzelenyhnus@…>, 20 years ago

64bit float division added.
Some bugs fixed in 64bit multiplication and adding.
  • Property mode set to 100644
File size: 5.7 KB
Line 
1/*
2 * Copyright (C) 2005 Josef Cejka
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 *
9 * - Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * - Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
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
15 * derived from this software without specific prior written permission.
16 *
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
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
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
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
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29#include<softfloat.h>
30#include<sftypes.h>
31
32#include<add.h>
33#include<sub.h>
34#include<mul.h>
35#include<div.h>
36
37#include<conversion.h>
38#include<comparison.h>
39#include<other.h>
40
41/* Arithmetic functions */
42
43float __addsf3(float a, float b)
44{
45 float32 fa, fb;
46 fa.f = a;
47 fb.f = b;
48 if (fa.parts.sign != fb.parts.sign) {
49 if (fa.parts.sign) {
50 fa.parts.sign = 0;
51 return subFloat32(fb, fa).f;
52 };
53 fb.parts.sign = 0;
54 return subFloat32(fa, fb).f;
55 }
56 return addFloat32(fa, fb).f;
57}
58
59double __adddf3(double a, double b)
60{
61 float64 da, db;
62 da.d = a;
63 db.d = b;
64 if (da.parts.sign != db.parts.sign) {
65 if (da.parts.sign) {
66 da.parts.sign = 0;
67 return subFloat64(db, da).d;
68 };
69 db.parts.sign = 0;
70 return subFloat64(da, db).d;
71 }
72 return addFloat64(da, db).d;
73}
74
75float __subsf3(float a, float b)
76{
77 float32 fa, fb;
78 fa.f = a;
79 fb.f = b;
80 if (fa.parts.sign != fb.parts.sign) {
81 fb.parts.sign = !fb.parts.sign;
82 return addFloat32(fa, fb).f;
83 }
84 return subFloat32(fa, fb).f;
85}
86
87double __subdf3(double a, double b)
88{
89 float64 da, db;
90 da.d = a;
91 db.d = b;
92 if (da.parts.sign != db.parts.sign) {
93 db.parts.sign = !db.parts.sign;
94 return addFloat64(da, db).d;
95 }
96 return subFloat64(da, db).d;
97}
98
99float __mulsf3(float a, float b)
100{
101 float32 fa, fb;
102 fa.f = a;
103 fb.f = b;
104 return mulFloat32(fa, fb).f;
105}
106
107double __muldf3(double a, double b)
108{
109 float64 da, db;
110 da.d = a;
111 db.d = b;
112 return mulFloat64(da, db).d;
113}
114
115float __divsf3(float a, float b)
116{
117 float32 fa, fb;
118 fa.f = a;
119 fb.f = b;
120 return divFloat32(fa, fb).f;
121}
122
123double __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
131float __negsf2(float a)
132{
133 float32 fa;
134 fa.f = a;
135 fa.parts.sign = !fa.parts.sign;
136 return fa.f;
137}
138
139double __negdf2(double a)
140{
141 float64 fa;
142 fa.d = a;
143 fa.parts.sign = !fa.parts.sign;
144 return fa.d;
145}
146
147/* Conversion functions */
148
149double __extendsfdf2(float a)
150{
151 float32 fa;
152 fa.f = a;
153 return convertFloat32ToFloat64(fa).d;
154}
155
156float __truncdfsf2(double a)
157{
158 float64 da;
159 da.d = a;
160 return convertFloat64ToFloat32(da).f;
161}
162
163/* Comparison functions */
164
165/* a<b .. -1
166 * a=b .. 0
167 * a>b .. 1
168 * */
169
170int __cmpsf2(float a, float b)
171{
172 float32 fa, fb;
173 fa.f = a;
174 fb.f = b;
175 if ( (isFloat32NaN(fa)) || (isFloat32NaN(fb)) ) {
176 return 1; /* no special constant for unordered - maybe signaled? */
177 };
178
179
180 if (isFloat32eq(fa, fb)) {
181 return 0;
182 };
183
184 if (isFloat32lt(fa, fb)) {
185 return -1;
186 };
187 return 1;
188}
189
190int __unordsf2(float a, float b)
191{
192 float32 fa, fb;
193 fa.f = a;
194 fb.f = b;
195 return ( (isFloat32NaN(fa)) || (isFloat32NaN(fb)) );
196}
197
198/**
199 * @return zero, if neither argument is a NaN and are equal
200 * */
201int __eqsf2(float a, float b)
202{
203 float32 fa, fb;
204 fa.f = a;
205 fb.f = b;
206 if ( (isFloat32NaN(fa)) || (isFloat32NaN(fb)) ) {
207 /* TODO: sigNaNs*/
208 return 1;
209 };
210 return isFloat32eq(fa, fb) - 1;
211}
212
213/* strange behavior, but it was in gcc documentation */
214int __nesf2(float a, float b)
215{
216 return __eqsf2(a, b);
217}
218
219/* return value >= 0 if a>=b and neither is NaN */
220int __gesf2(float a, float b)
221{
222 float32 fa, fb;
223 fa.f = a;
224 fb.f = b;
225 if ( (isFloat32NaN(fa)) || (isFloat32NaN(fb)) ) {
226 /* TODO: sigNaNs*/
227 return -1;
228 };
229
230 if (isFloat32eq(fa, fb)) {
231 return 0;
232 };
233
234 if (isFloat32gt(fa, fb)) {
235 return 1;
236 };
237
238 return -1;
239}
240
241/** Return negative value, if a<b and neither is NaN*/
242int __ltsf2(float a, float b)
243{
244 float32 fa, fb;
245 fa.f = a;
246 fb.f = b;
247 if ( (isFloat32NaN(fa)) || (isFloat32NaN(fb)) ) {
248 /* TODO: sigNaNs*/
249 return 1;
250 };
251 if (isFloat32lt(fa, fb)) {
252 return -1;
253 };
254 return 0;
255}
256
257/* return value <= 0 if a<=b and neither is NaN */
258int __lesf2(float a, float b)
259{
260 float32 fa, fb;
261 fa.f = a;
262 fb.f = b;
263 if ( (isFloat32NaN(fa)) || (isFloat32NaN(fb)) ) {
264 /* TODO: sigNaNs*/
265 return 1;
266 };
267
268 if (isFloat32eq(fa, fb)) {
269 return 0;
270 };
271
272 if (isFloat32lt(fa, fb)) {
273 return -1;
274 };
275
276 return 1;
277}
278
279/** Return positive value, if a>b and neither is NaN*/
280int __gtsf2(float a, float b)
281{
282 float32 fa, fb;
283 fa.f = a;
284 fb.f = b;
285 if ( (isFloat32NaN(fa)) || (isFloat32NaN(fb)) ) {
286 /* TODO: sigNaNs*/
287 return -1;
288 };
289 if (isFloat32gt(fa, fb)) {
290 return 1;
291 };
292 return 0;
293}
294
295/* Other functions */
296
297float __powisf2(float a, int b)
298{
299/* TODO: */
300}
301
302float __mulsc3(float a, float b, float c, float d)
303{
304/* TODO: */
305}
306
307float __divsc3(float a, float b, float c, float d)
308{
309/* TODO: */
310}
311
Note: See TracBrowser for help on using the repository browser.