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