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