1 /* Native implementation of soft float functions. Only a single status
2 context is supported */
3 #include "softfloat.h"
4 #include <math.h>
5 #if defined(CONFIG_SOLARIS)
6 #include <fenv.h>
7 #endif
8
set_float_rounding_mode(int val STATUS_PARAM)9 void set_float_rounding_mode(int val STATUS_PARAM)
10 {
11 STATUS(float_rounding_mode) = val;
12 #if (defined(CONFIG_BSD) && !defined(__APPLE__) && !defined(__GLIBC__)) || \
13 (defined(CONFIG_SOLARIS) && CONFIG_SOLARIS_VERSION < 10)
14 fpsetround(val);
15 #else
16 fesetround(val);
17 #endif
18 }
19
20 #ifdef FLOATX80
set_floatx80_rounding_precision(int val STATUS_PARAM)21 void set_floatx80_rounding_precision(int val STATUS_PARAM)
22 {
23 STATUS(floatx80_rounding_precision) = val;
24 }
25 #endif
26
27 #if defined(CONFIG_BSD) || \
28 (defined(CONFIG_SOLARIS) && CONFIG_SOLARIS_VERSION < 10)
29 #define lrint(d) ((int32_t)rint(d))
30 #define llrint(d) ((int64_t)rint(d))
31 #define lrintf(f) ((int32_t)rint(f))
32 #define llrintf(f) ((int64_t)rint(f))
33 #define sqrtf(f) ((float)sqrt(f))
34 #define remainderf(fa, fb) ((float)remainder(fa, fb))
35 #define rintf(f) ((float)rint(f))
36 #if !defined(__sparc__) && \
37 (defined(CONFIG_SOLARIS) && CONFIG_SOLARIS_VERSION < 10)
38 extern long double rintl(long double);
39 extern long double scalbnl(long double, int);
40
41 long long
llrintl(long double x)42 llrintl(long double x) {
43 return ((long long) rintl(x));
44 }
45
46 long
lrintl(long double x)47 lrintl(long double x) {
48 return ((long) rintl(x));
49 }
50
51 long double
ldexpl(long double x,int n)52 ldexpl(long double x, int n) {
53 return (scalbnl(x, n));
54 }
55 #endif
56 #endif
57
58 #if defined(_ARCH_PPC)
59
60 /* correct (but slow) PowerPC rint() (glibc version is incorrect) */
qemu_rint(double x)61 static double qemu_rint(double x)
62 {
63 double y = 4503599627370496.0;
64 if (fabs(x) >= y)
65 return x;
66 if (x < 0)
67 y = -y;
68 y = (x + y) - y;
69 if (y == 0.0)
70 y = copysign(y, x);
71 return y;
72 }
73
74 #define rint qemu_rint
75 #endif
76
77 /*----------------------------------------------------------------------------
78 | Software IEC/IEEE integer-to-floating-point conversion routines.
79 *----------------------------------------------------------------------------*/
int32_to_float32(int v STATUS_PARAM)80 float32 int32_to_float32(int v STATUS_PARAM)
81 {
82 return (float32)v;
83 }
84
uint32_to_float32(unsigned int v STATUS_PARAM)85 float32 uint32_to_float32(unsigned int v STATUS_PARAM)
86 {
87 return (float32)v;
88 }
89
int32_to_float64(int v STATUS_PARAM)90 float64 int32_to_float64(int v STATUS_PARAM)
91 {
92 return (float64)v;
93 }
94
uint32_to_float64(unsigned int v STATUS_PARAM)95 float64 uint32_to_float64(unsigned int v STATUS_PARAM)
96 {
97 return (float64)v;
98 }
99
100 #ifdef FLOATX80
int32_to_floatx80(int v STATUS_PARAM)101 floatx80 int32_to_floatx80(int v STATUS_PARAM)
102 {
103 return (floatx80)v;
104 }
105 #endif
int64_to_float32(int64_t v STATUS_PARAM)106 float32 int64_to_float32( int64_t v STATUS_PARAM)
107 {
108 return (float32)v;
109 }
uint64_to_float32(uint64_t v STATUS_PARAM)110 float32 uint64_to_float32( uint64_t v STATUS_PARAM)
111 {
112 return (float32)v;
113 }
int64_to_float64(int64_t v STATUS_PARAM)114 float64 int64_to_float64( int64_t v STATUS_PARAM)
115 {
116 return (float64)v;
117 }
uint64_to_float64(uint64_t v STATUS_PARAM)118 float64 uint64_to_float64( uint64_t v STATUS_PARAM)
119 {
120 return (float64)v;
121 }
122 #ifdef FLOATX80
int64_to_floatx80(int64_t v STATUS_PARAM)123 floatx80 int64_to_floatx80( int64_t v STATUS_PARAM)
124 {
125 return (floatx80)v;
126 }
127 #endif
128
129 /* XXX: this code implements the x86 behaviour, not the IEEE one. */
130 #if HOST_LONG_BITS == 32
long_to_int32(long a)131 static inline int long_to_int32(long a)
132 {
133 return a;
134 }
135 #else
long_to_int32(long a)136 static inline int long_to_int32(long a)
137 {
138 if (a != (int32_t)a)
139 a = 0x80000000;
140 return a;
141 }
142 #endif
143
144 /*----------------------------------------------------------------------------
145 | Software IEC/IEEE single-precision conversion routines.
146 *----------------------------------------------------------------------------*/
float32_to_int32(float32 a STATUS_PARAM)147 int float32_to_int32( float32 a STATUS_PARAM)
148 {
149 return long_to_int32(lrintf(a));
150 }
float32_to_int32_round_to_zero(float32 a STATUS_PARAM)151 int float32_to_int32_round_to_zero( float32 a STATUS_PARAM)
152 {
153 return (int)a;
154 }
float32_to_int64(float32 a STATUS_PARAM)155 int64_t float32_to_int64( float32 a STATUS_PARAM)
156 {
157 return llrintf(a);
158 }
159
float32_to_int64_round_to_zero(float32 a STATUS_PARAM)160 int64_t float32_to_int64_round_to_zero( float32 a STATUS_PARAM)
161 {
162 return (int64_t)a;
163 }
164
float32_to_float64(float32 a STATUS_PARAM)165 float64 float32_to_float64( float32 a STATUS_PARAM)
166 {
167 return a;
168 }
169 #ifdef FLOATX80
float32_to_floatx80(float32 a STATUS_PARAM)170 floatx80 float32_to_floatx80( float32 a STATUS_PARAM)
171 {
172 return a;
173 }
174 #endif
175
float32_to_uint32(float32 a STATUS_PARAM)176 unsigned int float32_to_uint32( float32 a STATUS_PARAM)
177 {
178 int64_t v;
179 unsigned int res;
180
181 v = llrintf(a);
182 if (v < 0) {
183 res = 0;
184 } else if (v > 0xffffffff) {
185 res = 0xffffffff;
186 } else {
187 res = v;
188 }
189 return res;
190 }
float32_to_uint32_round_to_zero(float32 a STATUS_PARAM)191 unsigned int float32_to_uint32_round_to_zero( float32 a STATUS_PARAM)
192 {
193 int64_t v;
194 unsigned int res;
195
196 v = (int64_t)a;
197 if (v < 0) {
198 res = 0;
199 } else if (v > 0xffffffff) {
200 res = 0xffffffff;
201 } else {
202 res = v;
203 }
204 return res;
205 }
206
207 /*----------------------------------------------------------------------------
208 | Software IEC/IEEE single-precision operations.
209 *----------------------------------------------------------------------------*/
float32_round_to_int(float32 a STATUS_PARAM)210 float32 float32_round_to_int( float32 a STATUS_PARAM)
211 {
212 return rintf(a);
213 }
214
float32_rem(float32 a,float32 b STATUS_PARAM)215 float32 float32_rem( float32 a, float32 b STATUS_PARAM)
216 {
217 return remainderf(a, b);
218 }
219
float32_sqrt(float32 a STATUS_PARAM)220 float32 float32_sqrt( float32 a STATUS_PARAM)
221 {
222 return sqrtf(a);
223 }
float32_compare(float32 a,float32 b STATUS_PARAM)224 int float32_compare( float32 a, float32 b STATUS_PARAM )
225 {
226 if (a < b) {
227 return float_relation_less;
228 } else if (a == b) {
229 return float_relation_equal;
230 } else if (a > b) {
231 return float_relation_greater;
232 } else {
233 return float_relation_unordered;
234 }
235 }
float32_compare_quiet(float32 a,float32 b STATUS_PARAM)236 int float32_compare_quiet( float32 a, float32 b STATUS_PARAM )
237 {
238 if (isless(a, b)) {
239 return float_relation_less;
240 } else if (a == b) {
241 return float_relation_equal;
242 } else if (isgreater(a, b)) {
243 return float_relation_greater;
244 } else {
245 return float_relation_unordered;
246 }
247 }
float32_is_signaling_nan(float32 a1)248 int float32_is_signaling_nan( float32 a1)
249 {
250 float32u u;
251 uint32_t a;
252 u.f = a1;
253 a = u.i;
254 return ( ( ( a>>22 ) & 0x1FF ) == 0x1FE ) && ( a & 0x003FFFFF );
255 }
256
float32_is_quiet_nan(float32 a1)257 int float32_is_quiet_nan( float32 a1 )
258 {
259 float32u u;
260 uint64_t a;
261 u.f = a1;
262 a = u.i;
263 return ( 0xFF800000 < ( a<<1 ) );
264 }
265
float32_is_any_nan(float32 a1)266 int float32_is_any_nan( float32 a1 )
267 {
268 float32u u;
269 uint32_t a;
270 u.f = a1;
271 a = u.i;
272 return (a & ~(1 << 31)) > 0x7f800000U;
273 }
274
275 /*----------------------------------------------------------------------------
276 | Software IEC/IEEE double-precision conversion routines.
277 *----------------------------------------------------------------------------*/
float64_to_int32(float64 a STATUS_PARAM)278 int float64_to_int32( float64 a STATUS_PARAM)
279 {
280 return long_to_int32(lrint(a));
281 }
float64_to_int32_round_to_zero(float64 a STATUS_PARAM)282 int float64_to_int32_round_to_zero( float64 a STATUS_PARAM)
283 {
284 return (int)a;
285 }
float64_to_int64(float64 a STATUS_PARAM)286 int64_t float64_to_int64( float64 a STATUS_PARAM)
287 {
288 return llrint(a);
289 }
float64_to_int64_round_to_zero(float64 a STATUS_PARAM)290 int64_t float64_to_int64_round_to_zero( float64 a STATUS_PARAM)
291 {
292 return (int64_t)a;
293 }
float64_to_float32(float64 a STATUS_PARAM)294 float32 float64_to_float32( float64 a STATUS_PARAM)
295 {
296 return a;
297 }
298 #ifdef FLOATX80
float64_to_floatx80(float64 a STATUS_PARAM)299 floatx80 float64_to_floatx80( float64 a STATUS_PARAM)
300 {
301 return a;
302 }
303 #endif
304 #ifdef FLOAT128
float64_to_float128(float64 a STATUS_PARAM)305 float128 float64_to_float128( float64 a STATUS_PARAM)
306 {
307 return a;
308 }
309 #endif
310
float64_to_uint32(float64 a STATUS_PARAM)311 unsigned int float64_to_uint32( float64 a STATUS_PARAM)
312 {
313 int64_t v;
314 unsigned int res;
315
316 v = llrint(a);
317 if (v < 0) {
318 res = 0;
319 } else if (v > 0xffffffff) {
320 res = 0xffffffff;
321 } else {
322 res = v;
323 }
324 return res;
325 }
float64_to_uint32_round_to_zero(float64 a STATUS_PARAM)326 unsigned int float64_to_uint32_round_to_zero( float64 a STATUS_PARAM)
327 {
328 int64_t v;
329 unsigned int res;
330
331 v = (int64_t)a;
332 if (v < 0) {
333 res = 0;
334 } else if (v > 0xffffffff) {
335 res = 0xffffffff;
336 } else {
337 res = v;
338 }
339 return res;
340 }
float64_to_uint64(float64 a STATUS_PARAM)341 uint64_t float64_to_uint64 (float64 a STATUS_PARAM)
342 {
343 int64_t v;
344
345 v = llrint(a + (float64)INT64_MIN);
346
347 return v - INT64_MIN;
348 }
float64_to_uint64_round_to_zero(float64 a STATUS_PARAM)349 uint64_t float64_to_uint64_round_to_zero (float64 a STATUS_PARAM)
350 {
351 int64_t v;
352
353 v = (int64_t)(a + (float64)INT64_MIN);
354
355 return v - INT64_MIN;
356 }
357
358 /*----------------------------------------------------------------------------
359 | Software IEC/IEEE double-precision operations.
360 *----------------------------------------------------------------------------*/
361 #if defined(__sun__) && \
362 (defined(CONFIG_SOLARIS) && CONFIG_SOLARIS_VERSION < 10)
trunc(float64 x)363 static inline float64 trunc(float64 x)
364 {
365 return x < 0 ? -floor(-x) : floor(x);
366 }
367 #endif
float64_trunc_to_int(float64 a STATUS_PARAM)368 float64 float64_trunc_to_int( float64 a STATUS_PARAM )
369 {
370 return trunc(a);
371 }
372
float64_round_to_int(float64 a STATUS_PARAM)373 float64 float64_round_to_int( float64 a STATUS_PARAM )
374 {
375 return rint(a);
376 }
377
float64_rem(float64 a,float64 b STATUS_PARAM)378 float64 float64_rem( float64 a, float64 b STATUS_PARAM)
379 {
380 return remainder(a, b);
381 }
382
float64_sqrt(float64 a STATUS_PARAM)383 float64 float64_sqrt( float64 a STATUS_PARAM)
384 {
385 return sqrt(a);
386 }
float64_compare(float64 a,float64 b STATUS_PARAM)387 int float64_compare( float64 a, float64 b STATUS_PARAM )
388 {
389 if (a < b) {
390 return float_relation_less;
391 } else if (a == b) {
392 return float_relation_equal;
393 } else if (a > b) {
394 return float_relation_greater;
395 } else {
396 return float_relation_unordered;
397 }
398 }
float64_compare_quiet(float64 a,float64 b STATUS_PARAM)399 int float64_compare_quiet( float64 a, float64 b STATUS_PARAM )
400 {
401 if (isless(a, b)) {
402 return float_relation_less;
403 } else if (a == b) {
404 return float_relation_equal;
405 } else if (isgreater(a, b)) {
406 return float_relation_greater;
407 } else {
408 return float_relation_unordered;
409 }
410 }
float64_is_signaling_nan(float64 a1)411 int float64_is_signaling_nan( float64 a1)
412 {
413 float64u u;
414 uint64_t a;
415 u.f = a1;
416 a = u.i;
417 return
418 ( ( ( a>>51 ) & 0xFFF ) == 0xFFE )
419 && ( a & LIT64( 0x0007FFFFFFFFFFFF ) );
420
421 }
422
float64_is_quiet_nan(float64 a1)423 int float64_is_quiet_nan( float64 a1 )
424 {
425 float64u u;
426 uint64_t a;
427 u.f = a1;
428 a = u.i;
429
430 return ( LIT64( 0xFFF0000000000000 ) < (uint64_t) ( a<<1 ) );
431
432 }
433
float64_is_any_nan(float64 a1)434 int float64_is_any_nan( float64 a1 )
435 {
436 float64u u;
437 uint64_t a;
438 u.f = a1;
439 a = u.i;
440
441 return (a & ~(1ULL << 63)) > LIT64 (0x7FF0000000000000 );
442 }
443
444 #ifdef FLOATX80
445
446 /*----------------------------------------------------------------------------
447 | Software IEC/IEEE extended double-precision conversion routines.
448 *----------------------------------------------------------------------------*/
floatx80_to_int32(floatx80 a STATUS_PARAM)449 int floatx80_to_int32( floatx80 a STATUS_PARAM)
450 {
451 return long_to_int32(lrintl(a));
452 }
floatx80_to_int32_round_to_zero(floatx80 a STATUS_PARAM)453 int floatx80_to_int32_round_to_zero( floatx80 a STATUS_PARAM)
454 {
455 return (int)a;
456 }
floatx80_to_int64(floatx80 a STATUS_PARAM)457 int64_t floatx80_to_int64( floatx80 a STATUS_PARAM)
458 {
459 return llrintl(a);
460 }
floatx80_to_int64_round_to_zero(floatx80 a STATUS_PARAM)461 int64_t floatx80_to_int64_round_to_zero( floatx80 a STATUS_PARAM)
462 {
463 return (int64_t)a;
464 }
floatx80_to_float32(floatx80 a STATUS_PARAM)465 float32 floatx80_to_float32( floatx80 a STATUS_PARAM)
466 {
467 return a;
468 }
floatx80_to_float64(floatx80 a STATUS_PARAM)469 float64 floatx80_to_float64( floatx80 a STATUS_PARAM)
470 {
471 return a;
472 }
473
474 /*----------------------------------------------------------------------------
475 | Software IEC/IEEE extended double-precision operations.
476 *----------------------------------------------------------------------------*/
floatx80_round_to_int(floatx80 a STATUS_PARAM)477 floatx80 floatx80_round_to_int( floatx80 a STATUS_PARAM)
478 {
479 return rintl(a);
480 }
floatx80_rem(floatx80 a,floatx80 b STATUS_PARAM)481 floatx80 floatx80_rem( floatx80 a, floatx80 b STATUS_PARAM)
482 {
483 return remainderl(a, b);
484 }
floatx80_sqrt(floatx80 a STATUS_PARAM)485 floatx80 floatx80_sqrt( floatx80 a STATUS_PARAM)
486 {
487 return sqrtl(a);
488 }
floatx80_compare(floatx80 a,floatx80 b STATUS_PARAM)489 int floatx80_compare( floatx80 a, floatx80 b STATUS_PARAM )
490 {
491 if (a < b) {
492 return float_relation_less;
493 } else if (a == b) {
494 return float_relation_equal;
495 } else if (a > b) {
496 return float_relation_greater;
497 } else {
498 return float_relation_unordered;
499 }
500 }
floatx80_compare_quiet(floatx80 a,floatx80 b STATUS_PARAM)501 int floatx80_compare_quiet( floatx80 a, floatx80 b STATUS_PARAM )
502 {
503 if (isless(a, b)) {
504 return float_relation_less;
505 } else if (a == b) {
506 return float_relation_equal;
507 } else if (isgreater(a, b)) {
508 return float_relation_greater;
509 } else {
510 return float_relation_unordered;
511 }
512 }
floatx80_is_signaling_nan(floatx80 a1)513 int floatx80_is_signaling_nan( floatx80 a1)
514 {
515 floatx80u u;
516 uint64_t aLow;
517 u.f = a1;
518
519 aLow = u.i.low & ~ LIT64( 0x4000000000000000 );
520 return
521 ( ( u.i.high & 0x7FFF ) == 0x7FFF )
522 && (uint64_t) ( aLow<<1 )
523 && ( u.i.low == aLow );
524 }
525
floatx80_is_quiet_nan(floatx80 a1)526 int floatx80_is_quiet_nan( floatx80 a1 )
527 {
528 floatx80u u;
529 u.f = a1;
530 return ( ( u.i.high & 0x7FFF ) == 0x7FFF ) && (uint64_t) ( u.i.low<<1 );
531 }
532
floatx80_is_any_nan(floatx80 a1)533 int floatx80_is_any_nan( floatx80 a1 )
534 {
535 floatx80u u;
536 u.f = a1;
537 return ((u.i.high & 0x7FFF) == 0x7FFF) && ( u.i.low<<1 );
538 }
539
540 #endif
541