|
1 /*============================================================================ |
|
2 |
|
3 This C header file is part of the SoftFloat IEC/IEEE Floating-point Arithmetic |
|
4 Package, Release 2b. |
|
5 |
|
6 Written by John R. Hauser. This work was made possible in part by the |
|
7 International Computer Science Institute, located at Suite 600, 1947 Center |
|
8 Street, Berkeley, California 94704. Funding was partially provided by the |
|
9 National Science Foundation under grant MIP-9311980. The original version |
|
10 of this code was written as part of a project to build a fixed-point vector |
|
11 processor in collaboration with the University of California at Berkeley, |
|
12 overseen by Profs. Nelson Morgan and John Wawrzynek. More information |
|
13 is available through the Web page `http://www.cs.berkeley.edu/~jhauser/ |
|
14 arithmetic/SoftFloat.html'. |
|
15 |
|
16 THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE. Although reasonable effort has |
|
17 been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT TIMES |
|
18 RESULT IN INCORRECT BEHAVIOR. USE OF THIS SOFTWARE IS RESTRICTED TO PERSONS |
|
19 AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ALL LOSSES, |
|
20 COSTS, OR OTHER PROBLEMS THEY INCUR DUE TO THE SOFTWARE, AND WHO FURTHERMORE |
|
21 EFFECTIVELY INDEMNIFY JOHN HAUSER AND THE INTERNATIONAL COMPUTER SCIENCE |
|
22 INSTITUTE (possibly via similar legal warning) AGAINST ALL LOSSES, COSTS, OR |
|
23 OTHER PROBLEMS INCURRED BY THEIR CUSTOMERS AND CLIENTS DUE TO THE SOFTWARE. |
|
24 |
|
25 Derivative works are acceptable, even for commercial purposes, so long as |
|
26 (1) the source code for the derivative work includes prominent notice that |
|
27 the work is derivative, and (2) the source code includes prominent notice with |
|
28 these four paragraphs for those parts of this code that are retained. |
|
29 |
|
30 =============================================================================*/ |
|
31 |
|
32 #ifndef SOFTFLOAT_H |
|
33 #define SOFTFLOAT_H |
|
34 |
|
35 #if defined(HOST_SOLARIS) && defined(NEEDS_LIBSUNMATH) |
|
36 #include <sunmath.h> |
|
37 #endif |
|
38 |
|
39 #include <inttypes.h> |
|
40 #include "config.h" |
|
41 |
|
42 /*---------------------------------------------------------------------------- |
|
43 | Each of the following `typedef's defines the most convenient type that holds |
|
44 | integers of at least as many bits as specified. For example, `uint8' should |
|
45 | be the most convenient type that can hold unsigned integers of as many as |
|
46 | 8 bits. The `flag' type must be able to hold either a 0 or 1. For most |
|
47 | implementations of C, `flag', `uint8', and `int8' should all be `typedef'ed |
|
48 | to the same as `int'. |
|
49 *----------------------------------------------------------------------------*/ |
|
50 typedef uint8_t flag; |
|
51 typedef uint8_t uint8; |
|
52 typedef int8_t int8; |
|
53 #ifndef _AIX |
|
54 typedef int uint16; |
|
55 typedef int int16; |
|
56 #endif |
|
57 typedef unsigned int uint32; |
|
58 typedef signed int int32; |
|
59 typedef uint64_t uint64; |
|
60 typedef int64_t int64; |
|
61 |
|
62 /*---------------------------------------------------------------------------- |
|
63 | Each of the following `typedef's defines a type that holds integers |
|
64 | of _exactly_ the number of bits specified. For instance, for most |
|
65 | implementation of C, `bits16' and `sbits16' should be `typedef'ed to |
|
66 | `unsigned short int' and `signed short int' (or `short int'), respectively. |
|
67 *----------------------------------------------------------------------------*/ |
|
68 typedef uint8_t bits8; |
|
69 typedef int8_t sbits8; |
|
70 typedef uint16_t bits16; |
|
71 typedef int16_t sbits16; |
|
72 typedef uint32_t bits32; |
|
73 typedef int32_t sbits32; |
|
74 typedef uint64_t bits64; |
|
75 typedef int64_t sbits64; |
|
76 |
|
77 #define LIT64( a ) a##LL |
|
78 #define INLINE static inline |
|
79 |
|
80 /*---------------------------------------------------------------------------- |
|
81 | The macro `FLOATX80' must be defined to enable the extended double-precision |
|
82 | floating-point format `floatx80'. If this macro is not defined, the |
|
83 | `floatx80' type will not be defined, and none of the functions that either |
|
84 | input or output the `floatx80' type will be defined. The same applies to |
|
85 | the `FLOAT128' macro and the quadruple-precision format `float128'. |
|
86 *----------------------------------------------------------------------------*/ |
|
87 #ifdef CONFIG_SOFTFLOAT |
|
88 /* bit exact soft float support */ |
|
89 #define FLOATX80 |
|
90 #define FLOAT128 |
|
91 #else |
|
92 /* native float support */ |
|
93 #if (defined(__i386__) || defined(__x86_64__)) && !defined(_BSD) |
|
94 #define FLOATX80 |
|
95 #endif |
|
96 #endif /* !CONFIG_SOFTFLOAT */ |
|
97 |
|
98 #define STATUS_PARAM , float_status *status |
|
99 #define STATUS(field) status->field |
|
100 #define STATUS_VAR , status |
|
101 |
|
102 /*---------------------------------------------------------------------------- |
|
103 | Software IEC/IEEE floating-point ordering relations |
|
104 *----------------------------------------------------------------------------*/ |
|
105 enum { |
|
106 float_relation_less = -1, |
|
107 float_relation_equal = 0, |
|
108 float_relation_greater = 1, |
|
109 float_relation_unordered = 2 |
|
110 }; |
|
111 |
|
112 #ifdef CONFIG_SOFTFLOAT |
|
113 /*---------------------------------------------------------------------------- |
|
114 | Software IEC/IEEE floating-point types. |
|
115 *----------------------------------------------------------------------------*/ |
|
116 /* Use structures for soft-float types. This prevents accidentally mixing |
|
117 them with native int/float types. A sufficiently clever compiler and |
|
118 sane ABI should be able to see though these structs. However |
|
119 x86/gcc 3.x seems to struggle a bit, so leave them disabled by default. */ |
|
120 //#define USE_SOFTFLOAT_STRUCT_TYPES |
|
121 #ifdef USE_SOFTFLOAT_STRUCT_TYPES |
|
122 typedef struct { |
|
123 uint32_t v; |
|
124 } float32; |
|
125 /* The cast ensures an error if the wrong type is passed. */ |
|
126 #define float32_val(x) (((float32)(x)).v) |
|
127 #define make_float32(x) __extension__ ({ float32 f32_val = {x}; f32_val; }) |
|
128 typedef struct { |
|
129 uint64_t v; |
|
130 } float64; |
|
131 #define float64_val(x) (((float64)(x)).v) |
|
132 #define make_float64(x) __extension__ ({ float64 f64_val = {x}; f64_val; }) |
|
133 #else |
|
134 typedef uint32_t float32; |
|
135 typedef uint64_t float64; |
|
136 #define float32_val(x) (x) |
|
137 #define float64_val(x) (x) |
|
138 #define make_float32(x) (x) |
|
139 #define make_float64(x) (x) |
|
140 #endif |
|
141 #ifdef FLOATX80 |
|
142 typedef struct { |
|
143 uint64_t low; |
|
144 uint16_t high; |
|
145 } floatx80; |
|
146 #endif |
|
147 #ifdef FLOAT128 |
|
148 typedef struct { |
|
149 #ifdef WORDS_BIGENDIAN |
|
150 uint64_t high, low; |
|
151 #else |
|
152 uint64_t low, high; |
|
153 #endif |
|
154 } float128; |
|
155 #endif |
|
156 |
|
157 /*---------------------------------------------------------------------------- |
|
158 | Software IEC/IEEE floating-point underflow tininess-detection mode. |
|
159 *----------------------------------------------------------------------------*/ |
|
160 enum { |
|
161 float_tininess_after_rounding = 0, |
|
162 float_tininess_before_rounding = 1 |
|
163 }; |
|
164 |
|
165 /*---------------------------------------------------------------------------- |
|
166 | Software IEC/IEEE floating-point rounding mode. |
|
167 *----------------------------------------------------------------------------*/ |
|
168 enum { |
|
169 float_round_nearest_even = 0, |
|
170 float_round_down = 1, |
|
171 float_round_up = 2, |
|
172 float_round_to_zero = 3 |
|
173 }; |
|
174 |
|
175 /*---------------------------------------------------------------------------- |
|
176 | Software IEC/IEEE floating-point exception flags. |
|
177 *----------------------------------------------------------------------------*/ |
|
178 enum { |
|
179 float_flag_invalid = 1, |
|
180 float_flag_divbyzero = 4, |
|
181 float_flag_overflow = 8, |
|
182 float_flag_underflow = 16, |
|
183 float_flag_inexact = 32 |
|
184 }; |
|
185 |
|
186 typedef struct float_status { |
|
187 signed char float_detect_tininess; |
|
188 signed char float_rounding_mode; |
|
189 signed char float_exception_flags; |
|
190 #ifdef FLOATX80 |
|
191 signed char floatx80_rounding_precision; |
|
192 #endif |
|
193 flag flush_to_zero; |
|
194 flag default_nan_mode; |
|
195 } float_status; |
|
196 |
|
197 void set_float_rounding_mode(int val STATUS_PARAM); |
|
198 void set_float_exception_flags(int val STATUS_PARAM); |
|
199 INLINE void set_flush_to_zero(flag val STATUS_PARAM) |
|
200 { |
|
201 STATUS(flush_to_zero) = val; |
|
202 } |
|
203 INLINE void set_default_nan_mode(flag val STATUS_PARAM) |
|
204 { |
|
205 STATUS(default_nan_mode) = val; |
|
206 } |
|
207 INLINE int get_float_exception_flags(float_status *status) |
|
208 { |
|
209 return STATUS(float_exception_flags); |
|
210 } |
|
211 #ifdef FLOATX80 |
|
212 void set_floatx80_rounding_precision(int val STATUS_PARAM); |
|
213 #endif |
|
214 |
|
215 /*---------------------------------------------------------------------------- |
|
216 | Routine to raise any or all of the software IEC/IEEE floating-point |
|
217 | exception flags. |
|
218 *----------------------------------------------------------------------------*/ |
|
219 void float_raise( int8 flags STATUS_PARAM); |
|
220 |
|
221 /*---------------------------------------------------------------------------- |
|
222 | Software IEC/IEEE integer-to-floating-point conversion routines. |
|
223 *----------------------------------------------------------------------------*/ |
|
224 float32 int32_to_float32( int STATUS_PARAM ); |
|
225 float64 int32_to_float64( int STATUS_PARAM ); |
|
226 float32 uint32_to_float32( unsigned int STATUS_PARAM ); |
|
227 float64 uint32_to_float64( unsigned int STATUS_PARAM ); |
|
228 #ifdef FLOATX80 |
|
229 floatx80 int32_to_floatx80( int STATUS_PARAM ); |
|
230 #endif |
|
231 #ifdef FLOAT128 |
|
232 float128 int32_to_float128( int STATUS_PARAM ); |
|
233 #endif |
|
234 float32 int64_to_float32( int64_t STATUS_PARAM ); |
|
235 float32 uint64_to_float32( uint64_t STATUS_PARAM ); |
|
236 float64 int64_to_float64( int64_t STATUS_PARAM ); |
|
237 float64 uint64_to_float64( uint64_t STATUS_PARAM ); |
|
238 #ifdef FLOATX80 |
|
239 floatx80 int64_to_floatx80( int64_t STATUS_PARAM ); |
|
240 #endif |
|
241 #ifdef FLOAT128 |
|
242 float128 int64_to_float128( int64_t STATUS_PARAM ); |
|
243 #endif |
|
244 |
|
245 /*---------------------------------------------------------------------------- |
|
246 | Software half-precision conversion routines. |
|
247 *----------------------------------------------------------------------------*/ |
|
248 bits16 float32_to_float16( float32, flag STATUS_PARAM ); |
|
249 float32 float16_to_float32( bits16, flag STATUS_PARAM ); |
|
250 |
|
251 /*---------------------------------------------------------------------------- |
|
252 | Software IEC/IEEE single-precision conversion routines. |
|
253 *----------------------------------------------------------------------------*/ |
|
254 int float32_to_int32( float32 STATUS_PARAM ); |
|
255 int float32_to_int32_round_to_zero( float32 STATUS_PARAM ); |
|
256 unsigned int float32_to_uint32( float32 STATUS_PARAM ); |
|
257 unsigned int float32_to_uint32_round_to_zero( float32 STATUS_PARAM ); |
|
258 int64_t float32_to_int64( float32 STATUS_PARAM ); |
|
259 int64_t float32_to_int64_round_to_zero( float32 STATUS_PARAM ); |
|
260 float64 float32_to_float64( float32 STATUS_PARAM ); |
|
261 #ifdef FLOATX80 |
|
262 floatx80 float32_to_floatx80( float32 STATUS_PARAM ); |
|
263 #endif |
|
264 #ifdef FLOAT128 |
|
265 float128 float32_to_float128( float32 STATUS_PARAM ); |
|
266 #endif |
|
267 |
|
268 /*---------------------------------------------------------------------------- |
|
269 | Software IEC/IEEE single-precision operations. |
|
270 *----------------------------------------------------------------------------*/ |
|
271 float32 float32_round_to_int( float32 STATUS_PARAM ); |
|
272 float32 float32_add( float32, float32 STATUS_PARAM ); |
|
273 float32 float32_sub( float32, float32 STATUS_PARAM ); |
|
274 float32 float32_mul( float32, float32 STATUS_PARAM ); |
|
275 float32 float32_div( float32, float32 STATUS_PARAM ); |
|
276 float32 float32_rem( float32, float32 STATUS_PARAM ); |
|
277 float32 float32_sqrt( float32 STATUS_PARAM ); |
|
278 int float32_eq( float32, float32 STATUS_PARAM ); |
|
279 int float32_le( float32, float32 STATUS_PARAM ); |
|
280 int float32_lt( float32, float32 STATUS_PARAM ); |
|
281 int float32_eq_signaling( float32, float32 STATUS_PARAM ); |
|
282 int float32_le_quiet( float32, float32 STATUS_PARAM ); |
|
283 int float32_lt_quiet( float32, float32 STATUS_PARAM ); |
|
284 int float32_compare( float32, float32 STATUS_PARAM ); |
|
285 int float32_compare_quiet( float32, float32 STATUS_PARAM ); |
|
286 int float32_is_nan( float32 ); |
|
287 int float32_is_signaling_nan( float32 ); |
|
288 float32 float32_scalbn( float32, int STATUS_PARAM ); |
|
289 |
|
290 INLINE float32 float32_abs(float32 a) |
|
291 { |
|
292 return make_float32(float32_val(a) & 0x7fffffff); |
|
293 } |
|
294 |
|
295 INLINE float32 float32_chs(float32 a) |
|
296 { |
|
297 return make_float32(float32_val(a) ^ 0x80000000); |
|
298 } |
|
299 |
|
300 INLINE int float32_is_infinity(float32 a) |
|
301 { |
|
302 return (float32_val(a) & 0x7fffffff) == 0x7f800000; |
|
303 } |
|
304 |
|
305 INLINE int float32_is_neg(float32 a) |
|
306 { |
|
307 return float32_val(a) >> 31; |
|
308 } |
|
309 |
|
310 INLINE int float32_is_zero(float32 a) |
|
311 { |
|
312 return (float32_val(a) & 0x7fffffff) == 0; |
|
313 } |
|
314 |
|
315 #define float32_zero make_float32(0) |
|
316 |
|
317 /*---------------------------------------------------------------------------- |
|
318 | Software IEC/IEEE double-precision conversion routines. |
|
319 *----------------------------------------------------------------------------*/ |
|
320 int float64_to_int32( float64 STATUS_PARAM ); |
|
321 int float64_to_int32_round_to_zero( float64 STATUS_PARAM ); |
|
322 unsigned int float64_to_uint32( float64 STATUS_PARAM ); |
|
323 unsigned int float64_to_uint32_round_to_zero( float64 STATUS_PARAM ); |
|
324 int64_t float64_to_int64( float64 STATUS_PARAM ); |
|
325 int64_t float64_to_int64_round_to_zero( float64 STATUS_PARAM ); |
|
326 uint64_t float64_to_uint64 (float64 a STATUS_PARAM); |
|
327 uint64_t float64_to_uint64_round_to_zero (float64 a STATUS_PARAM); |
|
328 float32 float64_to_float32( float64 STATUS_PARAM ); |
|
329 #ifdef FLOATX80 |
|
330 floatx80 float64_to_floatx80( float64 STATUS_PARAM ); |
|
331 #endif |
|
332 #ifdef FLOAT128 |
|
333 float128 float64_to_float128( float64 STATUS_PARAM ); |
|
334 #endif |
|
335 |
|
336 /*---------------------------------------------------------------------------- |
|
337 | Software IEC/IEEE double-precision operations. |
|
338 *----------------------------------------------------------------------------*/ |
|
339 float64 float64_round_to_int( float64 STATUS_PARAM ); |
|
340 float64 float64_trunc_to_int( float64 STATUS_PARAM ); |
|
341 float64 float64_add( float64, float64 STATUS_PARAM ); |
|
342 float64 float64_sub( float64, float64 STATUS_PARAM ); |
|
343 float64 float64_mul( float64, float64 STATUS_PARAM ); |
|
344 float64 float64_div( float64, float64 STATUS_PARAM ); |
|
345 float64 float64_rem( float64, float64 STATUS_PARAM ); |
|
346 float64 float64_sqrt( float64 STATUS_PARAM ); |
|
347 int float64_eq( float64, float64 STATUS_PARAM ); |
|
348 int float64_le( float64, float64 STATUS_PARAM ); |
|
349 int float64_lt( float64, float64 STATUS_PARAM ); |
|
350 int float64_eq_signaling( float64, float64 STATUS_PARAM ); |
|
351 int float64_le_quiet( float64, float64 STATUS_PARAM ); |
|
352 int float64_lt_quiet( float64, float64 STATUS_PARAM ); |
|
353 int float64_compare( float64, float64 STATUS_PARAM ); |
|
354 int float64_compare_quiet( float64, float64 STATUS_PARAM ); |
|
355 int float64_is_nan( float64 a ); |
|
356 int float64_is_signaling_nan( float64 ); |
|
357 float64 float64_scalbn( float64, int STATUS_PARAM ); |
|
358 |
|
359 INLINE float64 float64_abs(float64 a) |
|
360 { |
|
361 return make_float64(float64_val(a) & 0x7fffffffffffffffLL); |
|
362 } |
|
363 |
|
364 INLINE float64 float64_chs(float64 a) |
|
365 { |
|
366 return make_float64(float64_val(a) ^ 0x8000000000000000LL); |
|
367 } |
|
368 |
|
369 INLINE int float64_is_infinity(float64 a) |
|
370 { |
|
371 return (float64_val(a) & 0x7fffffffffffffffLL ) == 0x7ff0000000000000LL; |
|
372 } |
|
373 |
|
374 INLINE int float64_is_neg(float64 a) |
|
375 { |
|
376 return float64_val(a) >> 63; |
|
377 } |
|
378 |
|
379 INLINE int float64_is_zero(float64 a) |
|
380 { |
|
381 return (float64_val(a) & 0x7fffffffffffffffLL) == 0; |
|
382 } |
|
383 |
|
384 #define float64_zero make_float64(0) |
|
385 |
|
386 #ifdef FLOATX80 |
|
387 |
|
388 /*---------------------------------------------------------------------------- |
|
389 | Software IEC/IEEE extended double-precision conversion routines. |
|
390 *----------------------------------------------------------------------------*/ |
|
391 int floatx80_to_int32( floatx80 STATUS_PARAM ); |
|
392 int floatx80_to_int32_round_to_zero( floatx80 STATUS_PARAM ); |
|
393 int64_t floatx80_to_int64( floatx80 STATUS_PARAM ); |
|
394 int64_t floatx80_to_int64_round_to_zero( floatx80 STATUS_PARAM ); |
|
395 float32 floatx80_to_float32( floatx80 STATUS_PARAM ); |
|
396 float64 floatx80_to_float64( floatx80 STATUS_PARAM ); |
|
397 #ifdef FLOAT128 |
|
398 float128 floatx80_to_float128( floatx80 STATUS_PARAM ); |
|
399 #endif |
|
400 |
|
401 /*---------------------------------------------------------------------------- |
|
402 | Software IEC/IEEE extended double-precision operations. |
|
403 *----------------------------------------------------------------------------*/ |
|
404 floatx80 floatx80_round_to_int( floatx80 STATUS_PARAM ); |
|
405 floatx80 floatx80_add( floatx80, floatx80 STATUS_PARAM ); |
|
406 floatx80 floatx80_sub( floatx80, floatx80 STATUS_PARAM ); |
|
407 floatx80 floatx80_mul( floatx80, floatx80 STATUS_PARAM ); |
|
408 floatx80 floatx80_div( floatx80, floatx80 STATUS_PARAM ); |
|
409 floatx80 floatx80_rem( floatx80, floatx80 STATUS_PARAM ); |
|
410 floatx80 floatx80_sqrt( floatx80 STATUS_PARAM ); |
|
411 int floatx80_eq( floatx80, floatx80 STATUS_PARAM ); |
|
412 int floatx80_le( floatx80, floatx80 STATUS_PARAM ); |
|
413 int floatx80_lt( floatx80, floatx80 STATUS_PARAM ); |
|
414 int floatx80_eq_signaling( floatx80, floatx80 STATUS_PARAM ); |
|
415 int floatx80_le_quiet( floatx80, floatx80 STATUS_PARAM ); |
|
416 int floatx80_lt_quiet( floatx80, floatx80 STATUS_PARAM ); |
|
417 int floatx80_is_nan( floatx80 ); |
|
418 int floatx80_is_signaling_nan( floatx80 ); |
|
419 floatx80 floatx80_scalbn( floatx80, int STATUS_PARAM ); |
|
420 |
|
421 INLINE floatx80 floatx80_abs(floatx80 a) |
|
422 { |
|
423 a.high &= 0x7fff; |
|
424 return a; |
|
425 } |
|
426 |
|
427 INLINE floatx80 floatx80_chs(floatx80 a) |
|
428 { |
|
429 a.high ^= 0x8000; |
|
430 return a; |
|
431 } |
|
432 |
|
433 INLINE int floatx80_is_infinity(floatx80 a) |
|
434 { |
|
435 return (a.high & 0x7fff) == 0x7fff && a.low == 0; |
|
436 } |
|
437 |
|
438 INLINE int floatx80_is_neg(floatx80 a) |
|
439 { |
|
440 return a.high >> 15; |
|
441 } |
|
442 |
|
443 INLINE int floatx80_is_zero(floatx80 a) |
|
444 { |
|
445 return (a.high & 0x7fff) == 0 && a.low == 0; |
|
446 } |
|
447 |
|
448 #endif |
|
449 |
|
450 #ifdef FLOAT128 |
|
451 |
|
452 /*---------------------------------------------------------------------------- |
|
453 | Software IEC/IEEE quadruple-precision conversion routines. |
|
454 *----------------------------------------------------------------------------*/ |
|
455 int float128_to_int32( float128 STATUS_PARAM ); |
|
456 int float128_to_int32_round_to_zero( float128 STATUS_PARAM ); |
|
457 int64_t float128_to_int64( float128 STATUS_PARAM ); |
|
458 int64_t float128_to_int64_round_to_zero( float128 STATUS_PARAM ); |
|
459 float32 float128_to_float32( float128 STATUS_PARAM ); |
|
460 float64 float128_to_float64( float128 STATUS_PARAM ); |
|
461 #ifdef FLOATX80 |
|
462 floatx80 float128_to_floatx80( float128 STATUS_PARAM ); |
|
463 #endif |
|
464 |
|
465 /*---------------------------------------------------------------------------- |
|
466 | Software IEC/IEEE quadruple-precision operations. |
|
467 *----------------------------------------------------------------------------*/ |
|
468 float128 float128_round_to_int( float128 STATUS_PARAM ); |
|
469 float128 float128_add( float128, float128 STATUS_PARAM ); |
|
470 float128 float128_sub( float128, float128 STATUS_PARAM ); |
|
471 float128 float128_mul( float128, float128 STATUS_PARAM ); |
|
472 float128 float128_div( float128, float128 STATUS_PARAM ); |
|
473 float128 float128_rem( float128, float128 STATUS_PARAM ); |
|
474 float128 float128_sqrt( float128 STATUS_PARAM ); |
|
475 int float128_eq( float128, float128 STATUS_PARAM ); |
|
476 int float128_le( float128, float128 STATUS_PARAM ); |
|
477 int float128_lt( float128, float128 STATUS_PARAM ); |
|
478 int float128_eq_signaling( float128, float128 STATUS_PARAM ); |
|
479 int float128_le_quiet( float128, float128 STATUS_PARAM ); |
|
480 int float128_lt_quiet( float128, float128 STATUS_PARAM ); |
|
481 int float128_compare( float128, float128 STATUS_PARAM ); |
|
482 int float128_compare_quiet( float128, float128 STATUS_PARAM ); |
|
483 int float128_is_nan( float128 ); |
|
484 int float128_is_signaling_nan( float128 ); |
|
485 float128 float128_scalbn( float128, int STATUS_PARAM ); |
|
486 |
|
487 INLINE float128 float128_abs(float128 a) |
|
488 { |
|
489 a.high &= 0x7fffffffffffffffLL; |
|
490 return a; |
|
491 } |
|
492 |
|
493 INLINE float128 float128_chs(float128 a) |
|
494 { |
|
495 a.high ^= 0x8000000000000000LL; |
|
496 return a; |
|
497 } |
|
498 |
|
499 INLINE int float128_is_infinity(float128 a) |
|
500 { |
|
501 return (a.high & 0x7fffffffffffffffLL) == 0x7fff000000000000LL && a.low == 0; |
|
502 } |
|
503 |
|
504 INLINE int float128_is_neg(float128 a) |
|
505 { |
|
506 return a.high >> 63; |
|
507 } |
|
508 |
|
509 INLINE int float128_is_zero(float128 a) |
|
510 { |
|
511 return (a.high & 0x7fffffffffffffffLL) == 0 && a.low == 0; |
|
512 } |
|
513 |
|
514 #endif |
|
515 |
|
516 #else /* CONFIG_SOFTFLOAT */ |
|
517 |
|
518 #include "softfloat-native.h" |
|
519 |
|
520 #endif /* !CONFIG_SOFTFLOAT */ |
|
521 |
|
522 #endif /* !SOFTFLOAT_H */ |