]>
Commit | Line | Data |
---|---|---|
158142c2 FB |
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 | ||
0475a5ca TS |
35 | #if defined(HOST_SOLARIS) && defined(NEEDS_LIBSUNMATH) |
36 | #include <sunmath.h> | |
37 | #endif | |
38 | ||
158142c2 FB |
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 | *----------------------------------------------------------------------------*/ | |
750afe93 | 50 | typedef uint8_t flag; |
158142c2 FB |
51 | typedef uint8_t uint8; |
52 | typedef int8_t int8; | |
53 | typedef int uint16; | |
54 | typedef int int16; | |
55 | typedef unsigned int uint32; | |
56 | typedef signed int int32; | |
57 | typedef uint64_t uint64; | |
58 | typedef int64_t int64; | |
59 | ||
60 | /*---------------------------------------------------------------------------- | |
61 | | Each of the following `typedef's defines a type that holds integers | |
62 | | of _exactly_ the number of bits specified. For instance, for most | |
63 | | implementation of C, `bits16' and `sbits16' should be `typedef'ed to | |
64 | | `unsigned short int' and `signed short int' (or `short int'), respectively. | |
65 | *----------------------------------------------------------------------------*/ | |
66 | typedef uint8_t bits8; | |
67 | typedef int8_t sbits8; | |
68 | typedef uint16_t bits16; | |
69 | typedef int16_t sbits16; | |
70 | typedef uint32_t bits32; | |
71 | typedef int32_t sbits32; | |
72 | typedef uint64_t bits64; | |
73 | typedef int64_t sbits64; | |
74 | ||
75 | #define LIT64( a ) a##LL | |
76 | #define INLINE static inline | |
77 | ||
78 | /*---------------------------------------------------------------------------- | |
79 | | The macro `FLOATX80' must be defined to enable the extended double-precision | |
80 | | floating-point format `floatx80'. If this macro is not defined, the | |
81 | | `floatx80' type will not be defined, and none of the functions that either | |
82 | | input or output the `floatx80' type will be defined. The same applies to | |
83 | | the `FLOAT128' macro and the quadruple-precision format `float128'. | |
84 | *----------------------------------------------------------------------------*/ | |
85 | #ifdef CONFIG_SOFTFLOAT | |
86 | /* bit exact soft float support */ | |
87 | #define FLOATX80 | |
88 | #define FLOAT128 | |
89 | #else | |
90 | /* native float support */ | |
91 | #if (defined(__i386__) || defined(__x86_64__)) && !defined(_BSD) | |
92 | #define FLOATX80 | |
93 | #endif | |
94 | #endif /* !CONFIG_SOFTFLOAT */ | |
95 | ||
96 | #define STATUS_PARAM , float_status *status | |
97 | #define STATUS(field) status->field | |
98 | #define STATUS_VAR , status | |
99 | ||
1d6bda35 FB |
100 | /*---------------------------------------------------------------------------- |
101 | | Software IEC/IEEE floating-point ordering relations | |
102 | *----------------------------------------------------------------------------*/ | |
103 | enum { | |
104 | float_relation_less = -1, | |
105 | float_relation_equal = 0, | |
106 | float_relation_greater = 1, | |
107 | float_relation_unordered = 2 | |
108 | }; | |
109 | ||
158142c2 FB |
110 | #ifdef CONFIG_SOFTFLOAT |
111 | /*---------------------------------------------------------------------------- | |
112 | | Software IEC/IEEE floating-point types. | |
113 | *----------------------------------------------------------------------------*/ | |
114 | typedef uint32_t float32; | |
115 | typedef uint64_t float64; | |
116 | #ifdef FLOATX80 | |
117 | typedef struct { | |
118 | uint64_t low; | |
119 | uint16_t high; | |
120 | } floatx80; | |
121 | #endif | |
122 | #ifdef FLOAT128 | |
123 | typedef struct { | |
124 | #ifdef WORDS_BIGENDIAN | |
125 | uint64_t high, low; | |
126 | #else | |
127 | uint64_t low, high; | |
128 | #endif | |
129 | } float128; | |
130 | #endif | |
131 | ||
132 | /*---------------------------------------------------------------------------- | |
133 | | Software IEC/IEEE floating-point underflow tininess-detection mode. | |
134 | *----------------------------------------------------------------------------*/ | |
135 | enum { | |
136 | float_tininess_after_rounding = 0, | |
137 | float_tininess_before_rounding = 1 | |
138 | }; | |
139 | ||
140 | /*---------------------------------------------------------------------------- | |
141 | | Software IEC/IEEE floating-point rounding mode. | |
142 | *----------------------------------------------------------------------------*/ | |
143 | enum { | |
144 | float_round_nearest_even = 0, | |
145 | float_round_down = 1, | |
146 | float_round_up = 2, | |
147 | float_round_to_zero = 3 | |
148 | }; | |
149 | ||
150 | /*---------------------------------------------------------------------------- | |
151 | | Software IEC/IEEE floating-point exception flags. | |
152 | *----------------------------------------------------------------------------*/ | |
153 | enum { | |
154 | float_flag_invalid = 1, | |
155 | float_flag_divbyzero = 4, | |
156 | float_flag_overflow = 8, | |
157 | float_flag_underflow = 16, | |
158 | float_flag_inexact = 32 | |
159 | }; | |
160 | ||
161 | typedef struct float_status { | |
162 | signed char float_detect_tininess; | |
163 | signed char float_rounding_mode; | |
164 | signed char float_exception_flags; | |
165 | #ifdef FLOATX80 | |
166 | signed char floatx80_rounding_precision; | |
167 | #endif | |
168 | } float_status; | |
169 | ||
170 | void set_float_rounding_mode(int val STATUS_PARAM); | |
1d6bda35 FB |
171 | void set_float_exception_flags(int val STATUS_PARAM); |
172 | INLINE int get_float_exception_flags(float_status *status) | |
173 | { | |
174 | return STATUS(float_exception_flags); | |
175 | } | |
158142c2 FB |
176 | #ifdef FLOATX80 |
177 | void set_floatx80_rounding_precision(int val STATUS_PARAM); | |
178 | #endif | |
179 | ||
180 | /*---------------------------------------------------------------------------- | |
181 | | Routine to raise any or all of the software IEC/IEEE floating-point | |
182 | | exception flags. | |
183 | *----------------------------------------------------------------------------*/ | |
ec530c81 | 184 | void float_raise( int8 flags STATUS_PARAM); |
158142c2 FB |
185 | |
186 | /*---------------------------------------------------------------------------- | |
187 | | Software IEC/IEEE integer-to-floating-point conversion routines. | |
188 | *----------------------------------------------------------------------------*/ | |
189 | float32 int32_to_float32( int STATUS_PARAM ); | |
190 | float64 int32_to_float64( int STATUS_PARAM ); | |
1d6bda35 FB |
191 | float32 uint32_to_float32( unsigned int STATUS_PARAM ); |
192 | float64 uint32_to_float64( unsigned int STATUS_PARAM ); | |
158142c2 FB |
193 | #ifdef FLOATX80 |
194 | floatx80 int32_to_floatx80( int STATUS_PARAM ); | |
195 | #endif | |
196 | #ifdef FLOAT128 | |
197 | float128 int32_to_float128( int STATUS_PARAM ); | |
198 | #endif | |
199 | float32 int64_to_float32( int64_t STATUS_PARAM ); | |
75d62a58 | 200 | float32 uint64_to_float32( uint64_t STATUS_PARAM ); |
158142c2 | 201 | float64 int64_to_float64( int64_t STATUS_PARAM ); |
75d62a58 | 202 | float64 uint64_to_float64( uint64_t STATUS_PARAM ); |
158142c2 FB |
203 | #ifdef FLOATX80 |
204 | floatx80 int64_to_floatx80( int64_t STATUS_PARAM ); | |
205 | #endif | |
206 | #ifdef FLOAT128 | |
207 | float128 int64_to_float128( int64_t STATUS_PARAM ); | |
208 | #endif | |
209 | ||
210 | /*---------------------------------------------------------------------------- | |
211 | | Software IEC/IEEE single-precision conversion routines. | |
212 | *----------------------------------------------------------------------------*/ | |
213 | int float32_to_int32( float32 STATUS_PARAM ); | |
214 | int float32_to_int32_round_to_zero( float32 STATUS_PARAM ); | |
1d6bda35 FB |
215 | unsigned int float32_to_uint32( float32 STATUS_PARAM ); |
216 | unsigned int float32_to_uint32_round_to_zero( float32 STATUS_PARAM ); | |
158142c2 FB |
217 | int64_t float32_to_int64( float32 STATUS_PARAM ); |
218 | int64_t float32_to_int64_round_to_zero( float32 STATUS_PARAM ); | |
219 | float64 float32_to_float64( float32 STATUS_PARAM ); | |
220 | #ifdef FLOATX80 | |
221 | floatx80 float32_to_floatx80( float32 STATUS_PARAM ); | |
222 | #endif | |
223 | #ifdef FLOAT128 | |
224 | float128 float32_to_float128( float32 STATUS_PARAM ); | |
225 | #endif | |
226 | ||
227 | /*---------------------------------------------------------------------------- | |
228 | | Software IEC/IEEE single-precision operations. | |
229 | *----------------------------------------------------------------------------*/ | |
230 | float32 float32_round_to_int( float32 STATUS_PARAM ); | |
231 | float32 float32_add( float32, float32 STATUS_PARAM ); | |
232 | float32 float32_sub( float32, float32 STATUS_PARAM ); | |
233 | float32 float32_mul( float32, float32 STATUS_PARAM ); | |
234 | float32 float32_div( float32, float32 STATUS_PARAM ); | |
235 | float32 float32_rem( float32, float32 STATUS_PARAM ); | |
236 | float32 float32_sqrt( float32 STATUS_PARAM ); | |
750afe93 FB |
237 | int float32_eq( float32, float32 STATUS_PARAM ); |
238 | int float32_le( float32, float32 STATUS_PARAM ); | |
239 | int float32_lt( float32, float32 STATUS_PARAM ); | |
240 | int float32_eq_signaling( float32, float32 STATUS_PARAM ); | |
241 | int float32_le_quiet( float32, float32 STATUS_PARAM ); | |
242 | int float32_lt_quiet( float32, float32 STATUS_PARAM ); | |
243 | int float32_compare( float32, float32 STATUS_PARAM ); | |
244 | int float32_compare_quiet( float32, float32 STATUS_PARAM ); | |
924b2c07 | 245 | int float32_is_nan( float32 ); |
750afe93 | 246 | int float32_is_signaling_nan( float32 ); |
9ee6e8bb | 247 | float32 float32_scalbn( float32, int STATUS_PARAM ); |
158142c2 | 248 | |
1d6bda35 FB |
249 | INLINE float32 float32_abs(float32 a) |
250 | { | |
251 | return a & 0x7fffffff; | |
252 | } | |
253 | ||
254 | INLINE float32 float32_chs(float32 a) | |
255 | { | |
256 | return a ^ 0x80000000; | |
257 | } | |
258 | ||
158142c2 FB |
259 | /*---------------------------------------------------------------------------- |
260 | | Software IEC/IEEE double-precision conversion routines. | |
261 | *----------------------------------------------------------------------------*/ | |
262 | int float64_to_int32( float64 STATUS_PARAM ); | |
263 | int float64_to_int32_round_to_zero( float64 STATUS_PARAM ); | |
1d6bda35 FB |
264 | unsigned int float64_to_uint32( float64 STATUS_PARAM ); |
265 | unsigned int float64_to_uint32_round_to_zero( float64 STATUS_PARAM ); | |
158142c2 FB |
266 | int64_t float64_to_int64( float64 STATUS_PARAM ); |
267 | int64_t float64_to_int64_round_to_zero( float64 STATUS_PARAM ); | |
75d62a58 JM |
268 | uint64_t float64_to_uint64 (float64 a STATUS_PARAM); |
269 | uint64_t float64_to_uint64_round_to_zero (float64 a STATUS_PARAM); | |
158142c2 FB |
270 | float32 float64_to_float32( float64 STATUS_PARAM ); |
271 | #ifdef FLOATX80 | |
272 | floatx80 float64_to_floatx80( float64 STATUS_PARAM ); | |
273 | #endif | |
274 | #ifdef FLOAT128 | |
275 | float128 float64_to_float128( float64 STATUS_PARAM ); | |
276 | #endif | |
277 | ||
278 | /*---------------------------------------------------------------------------- | |
279 | | Software IEC/IEEE double-precision operations. | |
280 | *----------------------------------------------------------------------------*/ | |
281 | float64 float64_round_to_int( float64 STATUS_PARAM ); | |
e6e5906b | 282 | float64 float64_trunc_to_int( float64 STATUS_PARAM ); |
158142c2 FB |
283 | float64 float64_add( float64, float64 STATUS_PARAM ); |
284 | float64 float64_sub( float64, float64 STATUS_PARAM ); | |
285 | float64 float64_mul( float64, float64 STATUS_PARAM ); | |
286 | float64 float64_div( float64, float64 STATUS_PARAM ); | |
287 | float64 float64_rem( float64, float64 STATUS_PARAM ); | |
288 | float64 float64_sqrt( float64 STATUS_PARAM ); | |
750afe93 FB |
289 | int float64_eq( float64, float64 STATUS_PARAM ); |
290 | int float64_le( float64, float64 STATUS_PARAM ); | |
291 | int float64_lt( float64, float64 STATUS_PARAM ); | |
292 | int float64_eq_signaling( float64, float64 STATUS_PARAM ); | |
293 | int float64_le_quiet( float64, float64 STATUS_PARAM ); | |
294 | int float64_lt_quiet( float64, float64 STATUS_PARAM ); | |
295 | int float64_compare( float64, float64 STATUS_PARAM ); | |
296 | int float64_compare_quiet( float64, float64 STATUS_PARAM ); | |
924b2c07 | 297 | int float64_is_nan( float64 a ); |
750afe93 | 298 | int float64_is_signaling_nan( float64 ); |
9ee6e8bb | 299 | float64 float64_scalbn( float64, int STATUS_PARAM ); |
158142c2 | 300 | |
1d6bda35 FB |
301 | INLINE float64 float64_abs(float64 a) |
302 | { | |
303 | return a & 0x7fffffffffffffffLL; | |
304 | } | |
305 | ||
306 | INLINE float64 float64_chs(float64 a) | |
307 | { | |
308 | return a ^ 0x8000000000000000LL; | |
309 | } | |
310 | ||
158142c2 FB |
311 | #ifdef FLOATX80 |
312 | ||
313 | /*---------------------------------------------------------------------------- | |
314 | | Software IEC/IEEE extended double-precision conversion routines. | |
315 | *----------------------------------------------------------------------------*/ | |
316 | int floatx80_to_int32( floatx80 STATUS_PARAM ); | |
317 | int floatx80_to_int32_round_to_zero( floatx80 STATUS_PARAM ); | |
318 | int64_t floatx80_to_int64( floatx80 STATUS_PARAM ); | |
319 | int64_t floatx80_to_int64_round_to_zero( floatx80 STATUS_PARAM ); | |
320 | float32 floatx80_to_float32( floatx80 STATUS_PARAM ); | |
321 | float64 floatx80_to_float64( floatx80 STATUS_PARAM ); | |
322 | #ifdef FLOAT128 | |
323 | float128 floatx80_to_float128( floatx80 STATUS_PARAM ); | |
324 | #endif | |
325 | ||
326 | /*---------------------------------------------------------------------------- | |
327 | | Software IEC/IEEE extended double-precision operations. | |
328 | *----------------------------------------------------------------------------*/ | |
329 | floatx80 floatx80_round_to_int( floatx80 STATUS_PARAM ); | |
330 | floatx80 floatx80_add( floatx80, floatx80 STATUS_PARAM ); | |
331 | floatx80 floatx80_sub( floatx80, floatx80 STATUS_PARAM ); | |
332 | floatx80 floatx80_mul( floatx80, floatx80 STATUS_PARAM ); | |
333 | floatx80 floatx80_div( floatx80, floatx80 STATUS_PARAM ); | |
334 | floatx80 floatx80_rem( floatx80, floatx80 STATUS_PARAM ); | |
335 | floatx80 floatx80_sqrt( floatx80 STATUS_PARAM ); | |
750afe93 FB |
336 | int floatx80_eq( floatx80, floatx80 STATUS_PARAM ); |
337 | int floatx80_le( floatx80, floatx80 STATUS_PARAM ); | |
338 | int floatx80_lt( floatx80, floatx80 STATUS_PARAM ); | |
339 | int floatx80_eq_signaling( floatx80, floatx80 STATUS_PARAM ); | |
340 | int floatx80_le_quiet( floatx80, floatx80 STATUS_PARAM ); | |
341 | int floatx80_lt_quiet( floatx80, floatx80 STATUS_PARAM ); | |
924b2c07 | 342 | int floatx80_is_nan( floatx80 ); |
750afe93 | 343 | int floatx80_is_signaling_nan( floatx80 ); |
9ee6e8bb | 344 | floatx80 floatx80_scalbn( floatx80, int STATUS_PARAM ); |
158142c2 | 345 | |
1d6bda35 FB |
346 | INLINE floatx80 floatx80_abs(floatx80 a) |
347 | { | |
348 | a.high &= 0x7fff; | |
349 | return a; | |
350 | } | |
351 | ||
352 | INLINE floatx80 floatx80_chs(floatx80 a) | |
353 | { | |
354 | a.high ^= 0x8000; | |
355 | return a; | |
356 | } | |
357 | ||
158142c2 FB |
358 | #endif |
359 | ||
360 | #ifdef FLOAT128 | |
361 | ||
362 | /*---------------------------------------------------------------------------- | |
363 | | Software IEC/IEEE quadruple-precision conversion routines. | |
364 | *----------------------------------------------------------------------------*/ | |
365 | int float128_to_int32( float128 STATUS_PARAM ); | |
366 | int float128_to_int32_round_to_zero( float128 STATUS_PARAM ); | |
367 | int64_t float128_to_int64( float128 STATUS_PARAM ); | |
368 | int64_t float128_to_int64_round_to_zero( float128 STATUS_PARAM ); | |
369 | float32 float128_to_float32( float128 STATUS_PARAM ); | |
370 | float64 float128_to_float64( float128 STATUS_PARAM ); | |
371 | #ifdef FLOATX80 | |
372 | floatx80 float128_to_floatx80( float128 STATUS_PARAM ); | |
373 | #endif | |
374 | ||
375 | /*---------------------------------------------------------------------------- | |
376 | | Software IEC/IEEE quadruple-precision operations. | |
377 | *----------------------------------------------------------------------------*/ | |
378 | float128 float128_round_to_int( float128 STATUS_PARAM ); | |
379 | float128 float128_add( float128, float128 STATUS_PARAM ); | |
380 | float128 float128_sub( float128, float128 STATUS_PARAM ); | |
381 | float128 float128_mul( float128, float128 STATUS_PARAM ); | |
382 | float128 float128_div( float128, float128 STATUS_PARAM ); | |
383 | float128 float128_rem( float128, float128 STATUS_PARAM ); | |
384 | float128 float128_sqrt( float128 STATUS_PARAM ); | |
750afe93 FB |
385 | int float128_eq( float128, float128 STATUS_PARAM ); |
386 | int float128_le( float128, float128 STATUS_PARAM ); | |
387 | int float128_lt( float128, float128 STATUS_PARAM ); | |
388 | int float128_eq_signaling( float128, float128 STATUS_PARAM ); | |
389 | int float128_le_quiet( float128, float128 STATUS_PARAM ); | |
390 | int float128_lt_quiet( float128, float128 STATUS_PARAM ); | |
924b2c07 | 391 | int float128_is_nan( float128 ); |
750afe93 | 392 | int float128_is_signaling_nan( float128 ); |
9ee6e8bb | 393 | float128 float128_scalbn( float128, int STATUS_PARAM ); |
158142c2 | 394 | |
1d6bda35 FB |
395 | INLINE float128 float128_abs(float128 a) |
396 | { | |
397 | a.high &= 0x7fffffffffffffffLL; | |
398 | return a; | |
399 | } | |
400 | ||
401 | INLINE float128 float128_chs(float128 a) | |
402 | { | |
403 | a.high ^= 0x8000000000000000LL; | |
404 | return a; | |
405 | } | |
406 | ||
158142c2 FB |
407 | #endif |
408 | ||
409 | #else /* CONFIG_SOFTFLOAT */ | |
410 | ||
411 | #include "softfloat-native.h" | |
412 | ||
413 | #endif /* !CONFIG_SOFTFLOAT */ | |
414 | ||
415 | #endif /* !SOFTFLOAT_H */ |