The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 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 | |
David 'Digit' Turner | 2c538c8 | 2010-05-10 16:48:20 -0700 | [diff] [blame^] | 35 | #if defined(CONFIG_SOLARIS) && defined(CONFIG_NEEDS_LIBSUNMATH) |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 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; |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 53 | #ifndef _AIX |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 54 | typedef int uint16; |
| 55 | typedef int int16; |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 56 | #endif |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 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 */ |
David 'Digit' Turner | 2c538c8 | 2010-05-10 16:48:20 -0700 | [diff] [blame^] | 93 | #if (defined(__i386__) || defined(__x86_64__)) && !defined(CONFIG_BSD) |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 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; |
David 'Digit' Turner | 2c538c8 | 2010-05-10 16:48:20 -0700 | [diff] [blame^] | 190 | signed char float_exception_mask; |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 191 | #ifdef FLOATX80 |
| 192 | signed char floatx80_rounding_precision; |
| 193 | #endif |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 194 | flag flush_to_zero; |
| 195 | flag default_nan_mode; |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 196 | } float_status; |
| 197 | |
| 198 | void set_float_rounding_mode(int val STATUS_PARAM); |
| 199 | void set_float_exception_flags(int val STATUS_PARAM); |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 200 | INLINE void set_flush_to_zero(flag val STATUS_PARAM) |
| 201 | { |
| 202 | STATUS(flush_to_zero) = val; |
| 203 | } |
| 204 | INLINE void set_default_nan_mode(flag val STATUS_PARAM) |
| 205 | { |
| 206 | STATUS(default_nan_mode) = val; |
| 207 | } |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 208 | INLINE int get_float_exception_flags(float_status *status) |
| 209 | { |
| 210 | return STATUS(float_exception_flags); |
| 211 | } |
| 212 | #ifdef FLOATX80 |
| 213 | void set_floatx80_rounding_precision(int val STATUS_PARAM); |
| 214 | #endif |
| 215 | |
| 216 | /*---------------------------------------------------------------------------- |
| 217 | | Routine to raise any or all of the software IEC/IEEE floating-point |
| 218 | | exception flags. |
| 219 | *----------------------------------------------------------------------------*/ |
| 220 | void float_raise( int8 flags STATUS_PARAM); |
| 221 | |
| 222 | /*---------------------------------------------------------------------------- |
| 223 | | Software IEC/IEEE integer-to-floating-point conversion routines. |
| 224 | *----------------------------------------------------------------------------*/ |
| 225 | float32 int32_to_float32( int STATUS_PARAM ); |
| 226 | float64 int32_to_float64( int STATUS_PARAM ); |
| 227 | float32 uint32_to_float32( unsigned int STATUS_PARAM ); |
| 228 | float64 uint32_to_float64( unsigned int STATUS_PARAM ); |
| 229 | #ifdef FLOATX80 |
| 230 | floatx80 int32_to_floatx80( int STATUS_PARAM ); |
| 231 | #endif |
| 232 | #ifdef FLOAT128 |
| 233 | float128 int32_to_float128( int STATUS_PARAM ); |
| 234 | #endif |
| 235 | float32 int64_to_float32( int64_t STATUS_PARAM ); |
| 236 | float32 uint64_to_float32( uint64_t STATUS_PARAM ); |
| 237 | float64 int64_to_float64( int64_t STATUS_PARAM ); |
| 238 | float64 uint64_to_float64( uint64_t STATUS_PARAM ); |
| 239 | #ifdef FLOATX80 |
| 240 | floatx80 int64_to_floatx80( int64_t STATUS_PARAM ); |
| 241 | #endif |
| 242 | #ifdef FLOAT128 |
| 243 | float128 int64_to_float128( int64_t STATUS_PARAM ); |
| 244 | #endif |
| 245 | |
| 246 | /*---------------------------------------------------------------------------- |
David 'Digit' Turner | 2c538c8 | 2010-05-10 16:48:20 -0700 | [diff] [blame^] | 247 | | Software half-precision conversion routines. |
| 248 | *----------------------------------------------------------------------------*/ |
| 249 | bits16 float32_to_float16( float32, flag STATUS_PARAM ); |
| 250 | float32 float16_to_float32( bits16, flag STATUS_PARAM ); |
| 251 | |
| 252 | /*---------------------------------------------------------------------------- |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 253 | | Software IEC/IEEE single-precision conversion routines. |
| 254 | *----------------------------------------------------------------------------*/ |
| 255 | int float32_to_int32( float32 STATUS_PARAM ); |
| 256 | int float32_to_int32_round_to_zero( float32 STATUS_PARAM ); |
| 257 | unsigned int float32_to_uint32( float32 STATUS_PARAM ); |
| 258 | unsigned int float32_to_uint32_round_to_zero( float32 STATUS_PARAM ); |
| 259 | int64_t float32_to_int64( float32 STATUS_PARAM ); |
| 260 | int64_t float32_to_int64_round_to_zero( float32 STATUS_PARAM ); |
| 261 | float64 float32_to_float64( float32 STATUS_PARAM ); |
| 262 | #ifdef FLOATX80 |
| 263 | floatx80 float32_to_floatx80( float32 STATUS_PARAM ); |
| 264 | #endif |
| 265 | #ifdef FLOAT128 |
| 266 | float128 float32_to_float128( float32 STATUS_PARAM ); |
| 267 | #endif |
| 268 | |
| 269 | /*---------------------------------------------------------------------------- |
| 270 | | Software IEC/IEEE single-precision operations. |
| 271 | *----------------------------------------------------------------------------*/ |
| 272 | float32 float32_round_to_int( float32 STATUS_PARAM ); |
| 273 | float32 float32_add( float32, float32 STATUS_PARAM ); |
| 274 | float32 float32_sub( float32, float32 STATUS_PARAM ); |
| 275 | float32 float32_mul( float32, float32 STATUS_PARAM ); |
| 276 | float32 float32_div( float32, float32 STATUS_PARAM ); |
| 277 | float32 float32_rem( float32, float32 STATUS_PARAM ); |
| 278 | float32 float32_sqrt( float32 STATUS_PARAM ); |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 279 | float32 float32_log2( float32 STATUS_PARAM ); |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 280 | int float32_eq( float32, float32 STATUS_PARAM ); |
| 281 | int float32_le( float32, float32 STATUS_PARAM ); |
| 282 | int float32_lt( float32, float32 STATUS_PARAM ); |
| 283 | int float32_eq_signaling( float32, float32 STATUS_PARAM ); |
| 284 | int float32_le_quiet( float32, float32 STATUS_PARAM ); |
| 285 | int float32_lt_quiet( float32, float32 STATUS_PARAM ); |
| 286 | int float32_compare( float32, float32 STATUS_PARAM ); |
| 287 | int float32_compare_quiet( float32, float32 STATUS_PARAM ); |
| 288 | int float32_is_nan( float32 ); |
| 289 | int float32_is_signaling_nan( float32 ); |
| 290 | float32 float32_scalbn( float32, int STATUS_PARAM ); |
| 291 | |
| 292 | INLINE float32 float32_abs(float32 a) |
| 293 | { |
| 294 | return make_float32(float32_val(a) & 0x7fffffff); |
| 295 | } |
| 296 | |
| 297 | INLINE float32 float32_chs(float32 a) |
| 298 | { |
| 299 | return make_float32(float32_val(a) ^ 0x80000000); |
| 300 | } |
| 301 | |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 302 | INLINE int float32_is_infinity(float32 a) |
| 303 | { |
| 304 | return (float32_val(a) & 0x7fffffff) == 0x7f800000; |
| 305 | } |
| 306 | |
| 307 | INLINE int float32_is_neg(float32 a) |
| 308 | { |
| 309 | return float32_val(a) >> 31; |
| 310 | } |
| 311 | |
| 312 | INLINE int float32_is_zero(float32 a) |
| 313 | { |
| 314 | return (float32_val(a) & 0x7fffffff) == 0; |
| 315 | } |
| 316 | |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 317 | #define float32_zero make_float32(0) |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 318 | #define float32_one make_float32(0x3f800000) |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 319 | |
| 320 | /*---------------------------------------------------------------------------- |
| 321 | | Software IEC/IEEE double-precision conversion routines. |
| 322 | *----------------------------------------------------------------------------*/ |
| 323 | int float64_to_int32( float64 STATUS_PARAM ); |
| 324 | int float64_to_int32_round_to_zero( float64 STATUS_PARAM ); |
| 325 | unsigned int float64_to_uint32( float64 STATUS_PARAM ); |
| 326 | unsigned int float64_to_uint32_round_to_zero( float64 STATUS_PARAM ); |
| 327 | int64_t float64_to_int64( float64 STATUS_PARAM ); |
| 328 | int64_t float64_to_int64_round_to_zero( float64 STATUS_PARAM ); |
| 329 | uint64_t float64_to_uint64 (float64 a STATUS_PARAM); |
| 330 | uint64_t float64_to_uint64_round_to_zero (float64 a STATUS_PARAM); |
| 331 | float32 float64_to_float32( float64 STATUS_PARAM ); |
| 332 | #ifdef FLOATX80 |
| 333 | floatx80 float64_to_floatx80( float64 STATUS_PARAM ); |
| 334 | #endif |
| 335 | #ifdef FLOAT128 |
| 336 | float128 float64_to_float128( float64 STATUS_PARAM ); |
| 337 | #endif |
| 338 | |
| 339 | /*---------------------------------------------------------------------------- |
| 340 | | Software IEC/IEEE double-precision operations. |
| 341 | *----------------------------------------------------------------------------*/ |
| 342 | float64 float64_round_to_int( float64 STATUS_PARAM ); |
| 343 | float64 float64_trunc_to_int( float64 STATUS_PARAM ); |
| 344 | float64 float64_add( float64, float64 STATUS_PARAM ); |
| 345 | float64 float64_sub( float64, float64 STATUS_PARAM ); |
| 346 | float64 float64_mul( float64, float64 STATUS_PARAM ); |
| 347 | float64 float64_div( float64, float64 STATUS_PARAM ); |
| 348 | float64 float64_rem( float64, float64 STATUS_PARAM ); |
| 349 | float64 float64_sqrt( float64 STATUS_PARAM ); |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 350 | float64 float64_log2( float64 STATUS_PARAM ); |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 351 | int float64_eq( float64, float64 STATUS_PARAM ); |
| 352 | int float64_le( float64, float64 STATUS_PARAM ); |
| 353 | int float64_lt( float64, float64 STATUS_PARAM ); |
| 354 | int float64_eq_signaling( float64, float64 STATUS_PARAM ); |
| 355 | int float64_le_quiet( float64, float64 STATUS_PARAM ); |
| 356 | int float64_lt_quiet( float64, float64 STATUS_PARAM ); |
| 357 | int float64_compare( float64, float64 STATUS_PARAM ); |
| 358 | int float64_compare_quiet( float64, float64 STATUS_PARAM ); |
| 359 | int float64_is_nan( float64 a ); |
| 360 | int float64_is_signaling_nan( float64 ); |
| 361 | float64 float64_scalbn( float64, int STATUS_PARAM ); |
| 362 | |
| 363 | INLINE float64 float64_abs(float64 a) |
| 364 | { |
| 365 | return make_float64(float64_val(a) & 0x7fffffffffffffffLL); |
| 366 | } |
| 367 | |
| 368 | INLINE float64 float64_chs(float64 a) |
| 369 | { |
| 370 | return make_float64(float64_val(a) ^ 0x8000000000000000LL); |
| 371 | } |
| 372 | |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 373 | INLINE int float64_is_infinity(float64 a) |
| 374 | { |
| 375 | return (float64_val(a) & 0x7fffffffffffffffLL ) == 0x7ff0000000000000LL; |
| 376 | } |
| 377 | |
| 378 | INLINE int float64_is_neg(float64 a) |
| 379 | { |
| 380 | return float64_val(a) >> 63; |
| 381 | } |
| 382 | |
| 383 | INLINE int float64_is_zero(float64 a) |
| 384 | { |
| 385 | return (float64_val(a) & 0x7fffffffffffffffLL) == 0; |
| 386 | } |
| 387 | |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 388 | #define float64_zero make_float64(0) |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 389 | #define float64_one make_float64(0x3ff0000000000000LL) |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 390 | |
| 391 | #ifdef FLOATX80 |
| 392 | |
| 393 | /*---------------------------------------------------------------------------- |
| 394 | | Software IEC/IEEE extended double-precision conversion routines. |
| 395 | *----------------------------------------------------------------------------*/ |
| 396 | int floatx80_to_int32( floatx80 STATUS_PARAM ); |
| 397 | int floatx80_to_int32_round_to_zero( floatx80 STATUS_PARAM ); |
| 398 | int64_t floatx80_to_int64( floatx80 STATUS_PARAM ); |
| 399 | int64_t floatx80_to_int64_round_to_zero( floatx80 STATUS_PARAM ); |
| 400 | float32 floatx80_to_float32( floatx80 STATUS_PARAM ); |
| 401 | float64 floatx80_to_float64( floatx80 STATUS_PARAM ); |
| 402 | #ifdef FLOAT128 |
| 403 | float128 floatx80_to_float128( floatx80 STATUS_PARAM ); |
| 404 | #endif |
| 405 | |
| 406 | /*---------------------------------------------------------------------------- |
| 407 | | Software IEC/IEEE extended double-precision operations. |
| 408 | *----------------------------------------------------------------------------*/ |
| 409 | floatx80 floatx80_round_to_int( floatx80 STATUS_PARAM ); |
| 410 | floatx80 floatx80_add( floatx80, floatx80 STATUS_PARAM ); |
| 411 | floatx80 floatx80_sub( floatx80, floatx80 STATUS_PARAM ); |
| 412 | floatx80 floatx80_mul( floatx80, floatx80 STATUS_PARAM ); |
| 413 | floatx80 floatx80_div( floatx80, floatx80 STATUS_PARAM ); |
| 414 | floatx80 floatx80_rem( floatx80, floatx80 STATUS_PARAM ); |
| 415 | floatx80 floatx80_sqrt( floatx80 STATUS_PARAM ); |
| 416 | int floatx80_eq( floatx80, floatx80 STATUS_PARAM ); |
| 417 | int floatx80_le( floatx80, floatx80 STATUS_PARAM ); |
| 418 | int floatx80_lt( floatx80, floatx80 STATUS_PARAM ); |
| 419 | int floatx80_eq_signaling( floatx80, floatx80 STATUS_PARAM ); |
| 420 | int floatx80_le_quiet( floatx80, floatx80 STATUS_PARAM ); |
| 421 | int floatx80_lt_quiet( floatx80, floatx80 STATUS_PARAM ); |
| 422 | int floatx80_is_nan( floatx80 ); |
| 423 | int floatx80_is_signaling_nan( floatx80 ); |
| 424 | floatx80 floatx80_scalbn( floatx80, int STATUS_PARAM ); |
| 425 | |
| 426 | INLINE floatx80 floatx80_abs(floatx80 a) |
| 427 | { |
| 428 | a.high &= 0x7fff; |
| 429 | return a; |
| 430 | } |
| 431 | |
| 432 | INLINE floatx80 floatx80_chs(floatx80 a) |
| 433 | { |
| 434 | a.high ^= 0x8000; |
| 435 | return a; |
| 436 | } |
| 437 | |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 438 | INLINE int floatx80_is_infinity(floatx80 a) |
| 439 | { |
| 440 | return (a.high & 0x7fff) == 0x7fff && a.low == 0; |
| 441 | } |
| 442 | |
| 443 | INLINE int floatx80_is_neg(floatx80 a) |
| 444 | { |
| 445 | return a.high >> 15; |
| 446 | } |
| 447 | |
| 448 | INLINE int floatx80_is_zero(floatx80 a) |
| 449 | { |
| 450 | return (a.high & 0x7fff) == 0 && a.low == 0; |
| 451 | } |
| 452 | |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 453 | #endif |
| 454 | |
| 455 | #ifdef FLOAT128 |
| 456 | |
| 457 | /*---------------------------------------------------------------------------- |
| 458 | | Software IEC/IEEE quadruple-precision conversion routines. |
| 459 | *----------------------------------------------------------------------------*/ |
| 460 | int float128_to_int32( float128 STATUS_PARAM ); |
| 461 | int float128_to_int32_round_to_zero( float128 STATUS_PARAM ); |
| 462 | int64_t float128_to_int64( float128 STATUS_PARAM ); |
| 463 | int64_t float128_to_int64_round_to_zero( float128 STATUS_PARAM ); |
| 464 | float32 float128_to_float32( float128 STATUS_PARAM ); |
| 465 | float64 float128_to_float64( float128 STATUS_PARAM ); |
| 466 | #ifdef FLOATX80 |
| 467 | floatx80 float128_to_floatx80( float128 STATUS_PARAM ); |
| 468 | #endif |
| 469 | |
| 470 | /*---------------------------------------------------------------------------- |
| 471 | | Software IEC/IEEE quadruple-precision operations. |
| 472 | *----------------------------------------------------------------------------*/ |
| 473 | float128 float128_round_to_int( float128 STATUS_PARAM ); |
| 474 | float128 float128_add( float128, float128 STATUS_PARAM ); |
| 475 | float128 float128_sub( float128, float128 STATUS_PARAM ); |
| 476 | float128 float128_mul( float128, float128 STATUS_PARAM ); |
| 477 | float128 float128_div( float128, float128 STATUS_PARAM ); |
| 478 | float128 float128_rem( float128, float128 STATUS_PARAM ); |
| 479 | float128 float128_sqrt( float128 STATUS_PARAM ); |
| 480 | int float128_eq( float128, float128 STATUS_PARAM ); |
| 481 | int float128_le( float128, float128 STATUS_PARAM ); |
| 482 | int float128_lt( float128, float128 STATUS_PARAM ); |
| 483 | int float128_eq_signaling( float128, float128 STATUS_PARAM ); |
| 484 | int float128_le_quiet( float128, float128 STATUS_PARAM ); |
| 485 | int float128_lt_quiet( float128, float128 STATUS_PARAM ); |
| 486 | int float128_compare( float128, float128 STATUS_PARAM ); |
| 487 | int float128_compare_quiet( float128, float128 STATUS_PARAM ); |
| 488 | int float128_is_nan( float128 ); |
| 489 | int float128_is_signaling_nan( float128 ); |
| 490 | float128 float128_scalbn( float128, int STATUS_PARAM ); |
| 491 | |
| 492 | INLINE float128 float128_abs(float128 a) |
| 493 | { |
| 494 | a.high &= 0x7fffffffffffffffLL; |
| 495 | return a; |
| 496 | } |
| 497 | |
| 498 | INLINE float128 float128_chs(float128 a) |
| 499 | { |
| 500 | a.high ^= 0x8000000000000000LL; |
| 501 | return a; |
| 502 | } |
| 503 | |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 504 | INLINE int float128_is_infinity(float128 a) |
| 505 | { |
| 506 | return (a.high & 0x7fffffffffffffffLL) == 0x7fff000000000000LL && a.low == 0; |
| 507 | } |
| 508 | |
| 509 | INLINE int float128_is_neg(float128 a) |
| 510 | { |
| 511 | return a.high >> 63; |
| 512 | } |
| 513 | |
| 514 | INLINE int float128_is_zero(float128 a) |
| 515 | { |
| 516 | return (a.high & 0x7fffffffffffffffLL) == 0 && a.low == 0; |
| 517 | } |
| 518 | |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 519 | #endif |
| 520 | |
| 521 | #else /* CONFIG_SOFTFLOAT */ |
| 522 | |
| 523 | #include "softfloat-native.h" |
| 524 | |
| 525 | #endif /* !CONFIG_SOFTFLOAT */ |
| 526 | |
| 527 | #endif /* !SOFTFLOAT_H */ |