VirtualBox

source: vbox/trunk/src/recompiler/fpu/softfloat.h@ 35555

Last change on this file since 35555 was 26499, checked in by vboxsync, 15 years ago

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

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette