VirtualBox

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

Last change on this file since 36145 was 36140, checked in by vboxsync, 14 years ago

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

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