]>
Commit | Line | Data |
---|---|---|
158142c2 FB |
1 | /* Native implementation of soft float functions */ |
2 | #include <math.h> | |
38cfa06c | 3 | |
dfe5fff3 | 4 | #if (defined(HOST_BSD) && !defined(__APPLE__)) || defined(CONFIG_SOLARIS) |
158142c2 | 5 | #include <ieeefp.h> |
38cfa06c | 6 | #define fabsf(f) ((float)fabs(f)) |
158142c2 FB |
7 | #else |
8 | #include <fenv.h> | |
9 | #endif | |
38cfa06c | 10 | |
d07cca02 | 11 | #if defined(__OpenBSD__) || defined(__NetBSD__) |
7c2a9d09 BS |
12 | #include <sys/param.h> |
13 | #endif | |
14 | ||
38cfa06c FB |
15 | /* |
16 | * Define some C99-7.12.3 classification macros and | |
17 | * some C99-.12.4 for Solaris systems OS less than 10, | |
18 | * or Solaris 10 systems running GCC 3.x or less. | |
19 | * Solaris 10 with GCC4 does not need these macros as they | |
20 | * are defined in <iso/math_c99.h> with a compiler directive | |
21 | */ | |
dfe5fff3 JQ |
22 | #if defined(CONFIG_SOLARIS) && \ |
23 | ((CONFIG_SOLARIS_VERSION <= 9 ) || \ | |
24 | ((CONFIG_SOLARIS_VERSION >= 10) && (__GNUC__ < 4))) \ | |
7c2a9d09 | 25 | || (defined(__OpenBSD__) && (OpenBSD < 200811)) |
38cfa06c FB |
26 | /* |
27 | * C99 7.12.3 classification macros | |
28 | * and | |
29 | * C99 7.12.14 comparison macros | |
30 | * | |
31 | * ... do not work on Solaris 10 using GNU CC 3.4.x. | |
32 | * Try to workaround the missing / broken C99 math macros. | |
33 | */ | |
128ab2ff BS |
34 | #if defined(__OpenBSD__) |
35 | #define unordered(x, y) (isnan(x) || isnan(y)) | |
36 | #endif | |
38cfa06c | 37 | |
d07cca02 BS |
38 | #ifdef __NetBSD__ |
39 | #ifndef isgreater | |
40 | #define isgreater(x, y) __builtin_isgreater(x, y) | |
41 | #endif | |
42 | #ifndef isgreaterequal | |
43 | #define isgreaterequal(x, y) __builtin_isgreaterequal(x, y) | |
44 | #endif | |
45 | #ifndef isless | |
46 | #define isless(x, y) __builtin_isless(x, y) | |
47 | #endif | |
48 | #ifndef islessequal | |
49 | #define islessequal(x, y) __builtin_islessequal(x, y) | |
50 | #endif | |
51 | #ifndef isunordered | |
52 | #define isunordered(x, y) __builtin_isunordered(x, y) | |
53 | #endif | |
54 | #endif | |
55 | ||
56 | ||
38cfa06c FB |
57 | #define isnormal(x) (fpclass(x) >= FP_NZERO) |
58 | #define isgreater(x, y) ((!unordered(x, y)) && ((x) > (y))) | |
59 | #define isgreaterequal(x, y) ((!unordered(x, y)) && ((x) >= (y))) | |
60 | #define isless(x, y) ((!unordered(x, y)) && ((x) < (y))) | |
61 | #define islessequal(x, y) ((!unordered(x, y)) && ((x) <= (y))) | |
62 | #define isunordered(x,y) unordered(x, y) | |
ec530c81 | 63 | #endif |
158142c2 | 64 | |
c94655b0 TS |
65 | #if defined(__sun__) && !defined(NEED_LIBSUNMATH) |
66 | ||
67 | #ifndef isnan | |
68 | # define isnan(x) \ | |
69 | (sizeof (x) == sizeof (long double) ? isnan_ld (x) \ | |
70 | : sizeof (x) == sizeof (double) ? isnan_d (x) \ | |
71 | : isnan_f (x)) | |
72 | static inline int isnan_f (float x) { return x != x; } | |
73 | static inline int isnan_d (double x) { return x != x; } | |
74 | static inline int isnan_ld (long double x) { return x != x; } | |
75 | #endif | |
76 | ||
77 | #ifndef isinf | |
78 | # define isinf(x) \ | |
79 | (sizeof (x) == sizeof (long double) ? isinf_ld (x) \ | |
80 | : sizeof (x) == sizeof (double) ? isinf_d (x) \ | |
81 | : isinf_f (x)) | |
82 | static inline int isinf_f (float x) { return isnan (x - x); } | |
83 | static inline int isinf_d (double x) { return isnan (x - x); } | |
84 | static inline int isinf_ld (long double x) { return isnan (x - x); } | |
85 | #endif | |
86 | #endif | |
87 | ||
158142c2 FB |
88 | typedef float float32; |
89 | typedef double float64; | |
90 | #ifdef FLOATX80 | |
91 | typedef long double floatx80; | |
92 | #endif | |
93 | ||
94 | typedef union { | |
95 | float32 f; | |
96 | uint32_t i; | |
97 | } float32u; | |
98 | typedef union { | |
99 | float64 f; | |
100 | uint64_t i; | |
101 | } float64u; | |
102 | #ifdef FLOATX80 | |
103 | typedef union { | |
104 | floatx80 f; | |
105 | struct { | |
106 | uint64_t low; | |
107 | uint16_t high; | |
108 | } i; | |
109 | } floatx80u; | |
110 | #endif | |
111 | ||
112 | /*---------------------------------------------------------------------------- | |
113 | | Software IEC/IEEE floating-point rounding mode. | |
114 | *----------------------------------------------------------------------------*/ | |
dfe5fff3 | 115 | #if (defined(HOST_BSD) && !defined(__APPLE__)) || defined(CONFIG_SOLARIS) |
128ab2ff BS |
116 | #if defined(__OpenBSD__) |
117 | #define FE_RM FP_RM | |
118 | #define FE_RP FP_RP | |
119 | #define FE_RZ FP_RZ | |
120 | #endif | |
158142c2 FB |
121 | enum { |
122 | float_round_nearest_even = FP_RN, | |
7918bf47 PB |
123 | float_round_down = FP_RM, |
124 | float_round_up = FP_RP, | |
125 | float_round_to_zero = FP_RZ | |
158142c2 FB |
126 | }; |
127 | #elif defined(__arm__) | |
128 | enum { | |
129 | float_round_nearest_even = 0, | |
130 | float_round_down = 1, | |
131 | float_round_up = 2, | |
132 | float_round_to_zero = 3 | |
133 | }; | |
134 | #else | |
135 | enum { | |
136 | float_round_nearest_even = FE_TONEAREST, | |
137 | float_round_down = FE_DOWNWARD, | |
138 | float_round_up = FE_UPWARD, | |
139 | float_round_to_zero = FE_TOWARDZERO | |
140 | }; | |
141 | #endif | |
142 | ||
143 | typedef struct float_status { | |
e872aa81 | 144 | int float_rounding_mode; |
158142c2 | 145 | #ifdef FLOATX80 |
e872aa81 | 146 | int floatx80_rounding_precision; |
158142c2 FB |
147 | #endif |
148 | } float_status; | |
149 | ||
150 | void set_float_rounding_mode(int val STATUS_PARAM); | |
151 | #ifdef FLOATX80 | |
152 | void set_floatx80_rounding_precision(int val STATUS_PARAM); | |
153 | #endif | |
154 | ||
155 | /*---------------------------------------------------------------------------- | |
156 | | Software IEC/IEEE integer-to-floating-point conversion routines. | |
157 | *----------------------------------------------------------------------------*/ | |
158 | float32 int32_to_float32( int STATUS_PARAM); | |
75d62a58 | 159 | float32 uint32_to_float32( unsigned int STATUS_PARAM); |
158142c2 | 160 | float64 int32_to_float64( int STATUS_PARAM); |
75d62a58 | 161 | float64 uint32_to_float64( unsigned int STATUS_PARAM); |
158142c2 FB |
162 | #ifdef FLOATX80 |
163 | floatx80 int32_to_floatx80( int STATUS_PARAM); | |
164 | #endif | |
165 | #ifdef FLOAT128 | |
166 | float128 int32_to_float128( int STATUS_PARAM); | |
167 | #endif | |
168 | float32 int64_to_float32( int64_t STATUS_PARAM); | |
75d62a58 | 169 | float32 uint64_to_float32( uint64_t STATUS_PARAM); |
158142c2 | 170 | float64 int64_to_float64( int64_t STATUS_PARAM); |
75d62a58 | 171 | float64 uint64_to_float64( uint64_t v STATUS_PARAM); |
158142c2 FB |
172 | #ifdef FLOATX80 |
173 | floatx80 int64_to_floatx80( int64_t STATUS_PARAM); | |
174 | #endif | |
175 | #ifdef FLOAT128 | |
176 | float128 int64_to_float128( int64_t STATUS_PARAM); | |
177 | #endif | |
178 | ||
179 | /*---------------------------------------------------------------------------- | |
180 | | Software IEC/IEEE single-precision conversion routines. | |
181 | *----------------------------------------------------------------------------*/ | |
182 | int float32_to_int32( float32 STATUS_PARAM); | |
183 | int float32_to_int32_round_to_zero( float32 STATUS_PARAM); | |
75d62a58 JM |
184 | unsigned int float32_to_uint32( float32 a STATUS_PARAM); |
185 | unsigned int float32_to_uint32_round_to_zero( float32 a STATUS_PARAM); | |
158142c2 FB |
186 | int64_t float32_to_int64( float32 STATUS_PARAM); |
187 | int64_t float32_to_int64_round_to_zero( float32 STATUS_PARAM); | |
188 | float64 float32_to_float64( float32 STATUS_PARAM); | |
189 | #ifdef FLOATX80 | |
190 | floatx80 float32_to_floatx80( float32 STATUS_PARAM); | |
191 | #endif | |
192 | #ifdef FLOAT128 | |
193 | float128 float32_to_float128( float32 STATUS_PARAM); | |
194 | #endif | |
195 | ||
196 | /*---------------------------------------------------------------------------- | |
197 | | Software IEC/IEEE single-precision operations. | |
198 | *----------------------------------------------------------------------------*/ | |
199 | float32 float32_round_to_int( float32 STATUS_PARAM); | |
200 | INLINE float32 float32_add( float32 a, float32 b STATUS_PARAM) | |
201 | { | |
202 | return a + b; | |
203 | } | |
204 | INLINE float32 float32_sub( float32 a, float32 b STATUS_PARAM) | |
205 | { | |
206 | return a - b; | |
207 | } | |
208 | INLINE float32 float32_mul( float32 a, float32 b STATUS_PARAM) | |
209 | { | |
210 | return a * b; | |
211 | } | |
212 | INLINE float32 float32_div( float32 a, float32 b STATUS_PARAM) | |
213 | { | |
214 | return a / b; | |
215 | } | |
216 | float32 float32_rem( float32, float32 STATUS_PARAM); | |
217 | float32 float32_sqrt( float32 STATUS_PARAM); | |
750afe93 | 218 | INLINE int float32_eq( float32 a, float32 b STATUS_PARAM) |
158142c2 | 219 | { |
158142c2 FB |
220 | return a == b; |
221 | } | |
750afe93 | 222 | INLINE int float32_le( float32 a, float32 b STATUS_PARAM) |
158142c2 FB |
223 | { |
224 | return a <= b; | |
225 | } | |
750afe93 | 226 | INLINE int float32_lt( float32 a, float32 b STATUS_PARAM) |
158142c2 FB |
227 | { |
228 | return a < b; | |
229 | } | |
750afe93 | 230 | INLINE int float32_eq_signaling( float32 a, float32 b STATUS_PARAM) |
158142c2 | 231 | { |
b109f9f8 | 232 | return a <= b && a >= b; |
158142c2 | 233 | } |
750afe93 | 234 | INLINE int float32_le_quiet( float32 a, float32 b STATUS_PARAM) |
158142c2 FB |
235 | { |
236 | return islessequal(a, b); | |
237 | } | |
750afe93 | 238 | INLINE int float32_lt_quiet( float32 a, float32 b STATUS_PARAM) |
158142c2 FB |
239 | { |
240 | return isless(a, b); | |
241 | } | |
750afe93 | 242 | INLINE int float32_unordered( float32 a, float32 b STATUS_PARAM) |
b109f9f8 FB |
243 | { |
244 | return isunordered(a, b); | |
245 | ||
246 | } | |
750afe93 FB |
247 | int float32_compare( float32, float32 STATUS_PARAM ); |
248 | int float32_compare_quiet( float32, float32 STATUS_PARAM ); | |
249 | int float32_is_signaling_nan( float32 ); | |
629bd74a | 250 | int float32_is_nan( float32 ); |
158142c2 FB |
251 | |
252 | INLINE float32 float32_abs(float32 a) | |
253 | { | |
254 | return fabsf(a); | |
255 | } | |
256 | ||
257 | INLINE float32 float32_chs(float32 a) | |
258 | { | |
259 | return -a; | |
260 | } | |
261 | ||
c52ab6f5 AJ |
262 | INLINE float32 float32_is_infinity(float32 a) |
263 | { | |
264 | return fpclassify(a) == FP_INFINITE; | |
265 | } | |
266 | ||
267 | INLINE float32 float32_is_neg(float32 a) | |
268 | { | |
8d6c92b6 AJ |
269 | float32u u; |
270 | u.f = a; | |
271 | return u.i >> 31; | |
c52ab6f5 AJ |
272 | } |
273 | ||
274 | INLINE float32 float32_is_zero(float32 a) | |
275 | { | |
276 | return fpclassify(a) == FP_ZERO; | |
277 | } | |
278 | ||
9ee6e8bb PB |
279 | INLINE float32 float32_scalbn(float32 a, int n) |
280 | { | |
281 | return scalbnf(a, n); | |
282 | } | |
283 | ||
158142c2 FB |
284 | /*---------------------------------------------------------------------------- |
285 | | Software IEC/IEEE double-precision conversion routines. | |
286 | *----------------------------------------------------------------------------*/ | |
287 | int float64_to_int32( float64 STATUS_PARAM ); | |
288 | int float64_to_int32_round_to_zero( float64 STATUS_PARAM ); | |
75d62a58 JM |
289 | unsigned int float64_to_uint32( float64 STATUS_PARAM ); |
290 | unsigned int float64_to_uint32_round_to_zero( float64 STATUS_PARAM ); | |
158142c2 FB |
291 | int64_t float64_to_int64( float64 STATUS_PARAM ); |
292 | int64_t float64_to_int64_round_to_zero( float64 STATUS_PARAM ); | |
75d62a58 JM |
293 | uint64_t float64_to_uint64( float64 STATUS_PARAM ); |
294 | uint64_t float64_to_uint64_round_to_zero( float64 STATUS_PARAM ); | |
158142c2 FB |
295 | float32 float64_to_float32( float64 STATUS_PARAM ); |
296 | #ifdef FLOATX80 | |
297 | floatx80 float64_to_floatx80( float64 STATUS_PARAM ); | |
298 | #endif | |
299 | #ifdef FLOAT128 | |
300 | float128 float64_to_float128( float64 STATUS_PARAM ); | |
301 | #endif | |
302 | ||
303 | /*---------------------------------------------------------------------------- | |
304 | | Software IEC/IEEE double-precision operations. | |
305 | *----------------------------------------------------------------------------*/ | |
306 | float64 float64_round_to_int( float64 STATUS_PARAM ); | |
e6e5906b | 307 | float64 float64_trunc_to_int( float64 STATUS_PARAM ); |
158142c2 FB |
308 | INLINE float64 float64_add( float64 a, float64 b STATUS_PARAM) |
309 | { | |
310 | return a + b; | |
311 | } | |
312 | INLINE float64 float64_sub( float64 a, float64 b STATUS_PARAM) | |
313 | { | |
314 | return a - b; | |
315 | } | |
316 | INLINE float64 float64_mul( float64 a, float64 b STATUS_PARAM) | |
317 | { | |
318 | return a * b; | |
319 | } | |
320 | INLINE float64 float64_div( float64 a, float64 b STATUS_PARAM) | |
321 | { | |
322 | return a / b; | |
323 | } | |
324 | float64 float64_rem( float64, float64 STATUS_PARAM ); | |
325 | float64 float64_sqrt( float64 STATUS_PARAM ); | |
750afe93 | 326 | INLINE int float64_eq( float64 a, float64 b STATUS_PARAM) |
158142c2 FB |
327 | { |
328 | return a == b; | |
329 | } | |
750afe93 | 330 | INLINE int float64_le( float64 a, float64 b STATUS_PARAM) |
158142c2 FB |
331 | { |
332 | return a <= b; | |
333 | } | |
750afe93 | 334 | INLINE int float64_lt( float64 a, float64 b STATUS_PARAM) |
158142c2 FB |
335 | { |
336 | return a < b; | |
337 | } | |
750afe93 | 338 | INLINE int float64_eq_signaling( float64 a, float64 b STATUS_PARAM) |
158142c2 | 339 | { |
b109f9f8 | 340 | return a <= b && a >= b; |
158142c2 | 341 | } |
750afe93 | 342 | INLINE int float64_le_quiet( float64 a, float64 b STATUS_PARAM) |
158142c2 FB |
343 | { |
344 | return islessequal(a, b); | |
345 | } | |
750afe93 | 346 | INLINE int float64_lt_quiet( float64 a, float64 b STATUS_PARAM) |
158142c2 FB |
347 | { |
348 | return isless(a, b); | |
349 | ||
350 | } | |
750afe93 | 351 | INLINE int float64_unordered( float64 a, float64 b STATUS_PARAM) |
b109f9f8 FB |
352 | { |
353 | return isunordered(a, b); | |
354 | ||
355 | } | |
750afe93 FB |
356 | int float64_compare( float64, float64 STATUS_PARAM ); |
357 | int float64_compare_quiet( float64, float64 STATUS_PARAM ); | |
358 | int float64_is_signaling_nan( float64 ); | |
359 | int float64_is_nan( float64 ); | |
158142c2 FB |
360 | |
361 | INLINE float64 float64_abs(float64 a) | |
362 | { | |
363 | return fabs(a); | |
364 | } | |
365 | ||
366 | INLINE float64 float64_chs(float64 a) | |
367 | { | |
368 | return -a; | |
369 | } | |
370 | ||
c52ab6f5 AJ |
371 | INLINE float64 float64_is_infinity(float64 a) |
372 | { | |
373 | return fpclassify(a) == FP_INFINITE; | |
374 | } | |
375 | ||
376 | INLINE float64 float64_is_neg(float64 a) | |
377 | { | |
8d6c92b6 AJ |
378 | float64u u; |
379 | u.f = a; | |
380 | return u.i >> 63; | |
c52ab6f5 AJ |
381 | } |
382 | ||
383 | INLINE float64 float64_is_zero(float64 a) | |
384 | { | |
385 | return fpclassify(a) == FP_ZERO; | |
386 | } | |
387 | ||
9ee6e8bb PB |
388 | INLINE float64 float64_scalbn(float64 a, int n) |
389 | { | |
390 | return scalbn(a, n); | |
391 | } | |
392 | ||
158142c2 FB |
393 | #ifdef FLOATX80 |
394 | ||
395 | /*---------------------------------------------------------------------------- | |
396 | | Software IEC/IEEE extended double-precision conversion routines. | |
397 | *----------------------------------------------------------------------------*/ | |
398 | int floatx80_to_int32( floatx80 STATUS_PARAM ); | |
399 | int floatx80_to_int32_round_to_zero( floatx80 STATUS_PARAM ); | |
400 | int64_t floatx80_to_int64( floatx80 STATUS_PARAM); | |
401 | int64_t floatx80_to_int64_round_to_zero( floatx80 STATUS_PARAM); | |
402 | float32 floatx80_to_float32( floatx80 STATUS_PARAM ); | |
403 | float64 floatx80_to_float64( floatx80 STATUS_PARAM ); | |
404 | #ifdef FLOAT128 | |
405 | float128 floatx80_to_float128( floatx80 STATUS_PARAM ); | |
406 | #endif | |
407 | ||
408 | /*---------------------------------------------------------------------------- | |
409 | | Software IEC/IEEE extended double-precision operations. | |
410 | *----------------------------------------------------------------------------*/ | |
411 | floatx80 floatx80_round_to_int( floatx80 STATUS_PARAM ); | |
412 | INLINE floatx80 floatx80_add( floatx80 a, floatx80 b STATUS_PARAM) | |
413 | { | |
414 | return a + b; | |
415 | } | |
416 | INLINE floatx80 floatx80_sub( floatx80 a, floatx80 b STATUS_PARAM) | |
417 | { | |
418 | return a - b; | |
419 | } | |
420 | INLINE floatx80 floatx80_mul( floatx80 a, floatx80 b STATUS_PARAM) | |
421 | { | |
422 | return a * b; | |
423 | } | |
424 | INLINE floatx80 floatx80_div( floatx80 a, floatx80 b STATUS_PARAM) | |
425 | { | |
426 | return a / b; | |
427 | } | |
428 | floatx80 floatx80_rem( floatx80, floatx80 STATUS_PARAM ); | |
429 | floatx80 floatx80_sqrt( floatx80 STATUS_PARAM ); | |
750afe93 | 430 | INLINE int floatx80_eq( floatx80 a, floatx80 b STATUS_PARAM) |
158142c2 FB |
431 | { |
432 | return a == b; | |
433 | } | |
750afe93 | 434 | INLINE int floatx80_le( floatx80 a, floatx80 b STATUS_PARAM) |
158142c2 FB |
435 | { |
436 | return a <= b; | |
437 | } | |
750afe93 | 438 | INLINE int floatx80_lt( floatx80 a, floatx80 b STATUS_PARAM) |
158142c2 FB |
439 | { |
440 | return a < b; | |
441 | } | |
750afe93 | 442 | INLINE int floatx80_eq_signaling( floatx80 a, floatx80 b STATUS_PARAM) |
158142c2 | 443 | { |
b109f9f8 | 444 | return a <= b && a >= b; |
158142c2 | 445 | } |
750afe93 | 446 | INLINE int floatx80_le_quiet( floatx80 a, floatx80 b STATUS_PARAM) |
158142c2 FB |
447 | { |
448 | return islessequal(a, b); | |
449 | } | |
750afe93 | 450 | INLINE int floatx80_lt_quiet( floatx80 a, floatx80 b STATUS_PARAM) |
158142c2 FB |
451 | { |
452 | return isless(a, b); | |
453 | ||
454 | } | |
750afe93 | 455 | INLINE int floatx80_unordered( floatx80 a, floatx80 b STATUS_PARAM) |
b109f9f8 FB |
456 | { |
457 | return isunordered(a, b); | |
458 | ||
459 | } | |
750afe93 FB |
460 | int floatx80_compare( floatx80, floatx80 STATUS_PARAM ); |
461 | int floatx80_compare_quiet( floatx80, floatx80 STATUS_PARAM ); | |
462 | int floatx80_is_signaling_nan( floatx80 ); | |
1b2ad2ec | 463 | int floatx80_is_nan( floatx80 ); |
158142c2 FB |
464 | |
465 | INLINE floatx80 floatx80_abs(floatx80 a) | |
466 | { | |
467 | return fabsl(a); | |
468 | } | |
469 | ||
470 | INLINE floatx80 floatx80_chs(floatx80 a) | |
471 | { | |
472 | return -a; | |
473 | } | |
9ee6e8bb | 474 | |
c52ab6f5 AJ |
475 | INLINE floatx80 floatx80_is_infinity(floatx80 a) |
476 | { | |
477 | return fpclassify(a) == FP_INFINITE; | |
478 | } | |
479 | ||
480 | INLINE floatx80 floatx80_is_neg(floatx80 a) | |
481 | { | |
8d6c92b6 AJ |
482 | floatx80u u; |
483 | u.f = a; | |
484 | return u.i.high >> 15; | |
c52ab6f5 AJ |
485 | } |
486 | ||
487 | INLINE floatx80 floatx80_is_zero(floatx80 a) | |
488 | { | |
489 | return fpclassify(a) == FP_ZERO; | |
490 | } | |
491 | ||
9ee6e8bb PB |
492 | INLINE floatx80 floatx80_scalbn(floatx80 a, int n) |
493 | { | |
494 | return scalbnl(a, n); | |
495 | } | |
496 | ||
158142c2 | 497 | #endif |