VirtualBox

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

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

rem: Synced with v0.12.5.
  • Property svn:eol-style set to native
File size: 19.1 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(CONFIG_SOLARIS) && defined(CONFIG_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(CONFIG_BSD) || defined(VBOX)) /** @todo VBOX: not correct on windows */
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 HOST_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 half-precision conversion routines.
255*----------------------------------------------------------------------------*/
256bits16 float32_to_float16( float32, flag STATUS_PARAM );
257float32 float16_to_float32( bits16, flag STATUS_PARAM );
258
259/*----------------------------------------------------------------------------
260| Software IEC/IEEE single-precision conversion routines.
261*----------------------------------------------------------------------------*/
262int float32_to_int32( float32 STATUS_PARAM );
263int float32_to_int32_round_to_zero( float32 STATUS_PARAM );
264unsigned int float32_to_uint32( float32 STATUS_PARAM );
265unsigned int float32_to_uint32_round_to_zero( float32 STATUS_PARAM );
266int64_t float32_to_int64( float32 STATUS_PARAM );
267int64_t float32_to_int64_round_to_zero( float32 STATUS_PARAM );
268float64 float32_to_float64( float32 STATUS_PARAM );
269#ifdef FLOATX80
270floatx80 float32_to_floatx80( float32 STATUS_PARAM );
271#endif
272#ifdef FLOAT128
273float128 float32_to_float128( float32 STATUS_PARAM );
274#endif
275
276/*----------------------------------------------------------------------------
277| Software IEC/IEEE single-precision operations.
278*----------------------------------------------------------------------------*/
279float32 float32_round_to_int( float32 STATUS_PARAM );
280float32 float32_add( float32, float32 STATUS_PARAM );
281float32 float32_sub( float32, float32 STATUS_PARAM );
282float32 float32_mul( float32, float32 STATUS_PARAM );
283float32 float32_div( float32, float32 STATUS_PARAM );
284float32 float32_rem( float32, float32 STATUS_PARAM );
285float32 float32_sqrt( float32 STATUS_PARAM );
286float32 float32_log2( float32 STATUS_PARAM );
287int float32_eq( float32, float32 STATUS_PARAM );
288int float32_le( float32, float32 STATUS_PARAM );
289int float32_lt( float32, float32 STATUS_PARAM );
290int float32_eq_signaling( float32, float32 STATUS_PARAM );
291int float32_le_quiet( float32, float32 STATUS_PARAM );
292int float32_lt_quiet( float32, float32 STATUS_PARAM );
293int float32_compare( float32, float32 STATUS_PARAM );
294int float32_compare_quiet( float32, float32 STATUS_PARAM );
295int float32_is_nan( float32 );
296int float32_is_signaling_nan( float32 );
297float32 float32_scalbn( float32, int STATUS_PARAM );
298
299INLINE float32 float32_abs(float32 a)
300{
301 return make_float32(float32_val(a) & 0x7fffffff);
302}
303
304INLINE float32 float32_chs(float32 a)
305{
306 return make_float32(float32_val(a) ^ 0x80000000);
307}
308
309INLINE int float32_is_infinity(float32 a)
310{
311 return (float32_val(a) & 0x7fffffff) == 0x7f800000;
312}
313
314INLINE int float32_is_neg(float32 a)
315{
316 return float32_val(a) >> 31;
317}
318
319INLINE int float32_is_zero(float32 a)
320{
321 return (float32_val(a) & 0x7fffffff) == 0;
322}
323
324#define float32_zero make_float32(0)
325#define float32_one make_float32(0x3f800000)
326
327/*----------------------------------------------------------------------------
328| Software IEC/IEEE double-precision conversion routines.
329*----------------------------------------------------------------------------*/
330int float64_to_int32( float64 STATUS_PARAM );
331int float64_to_int32_round_to_zero( float64 STATUS_PARAM );
332unsigned int float64_to_uint32( float64 STATUS_PARAM );
333unsigned int float64_to_uint32_round_to_zero( float64 STATUS_PARAM );
334int64_t float64_to_int64( float64 STATUS_PARAM );
335int64_t float64_to_int64_round_to_zero( float64 STATUS_PARAM );
336uint64_t float64_to_uint64 (float64 a STATUS_PARAM);
337uint64_t float64_to_uint64_round_to_zero (float64 a STATUS_PARAM);
338float32 float64_to_float32( float64 STATUS_PARAM );
339#ifdef FLOATX80
340floatx80 float64_to_floatx80( float64 STATUS_PARAM );
341#endif
342#ifdef FLOAT128
343float128 float64_to_float128( float64 STATUS_PARAM );
344#endif
345
346/*----------------------------------------------------------------------------
347| Software IEC/IEEE double-precision operations.
348*----------------------------------------------------------------------------*/
349float64 float64_round_to_int( float64 STATUS_PARAM );
350float64 float64_trunc_to_int( float64 STATUS_PARAM );
351float64 float64_add( float64, float64 STATUS_PARAM );
352float64 float64_sub( float64, float64 STATUS_PARAM );
353float64 float64_mul( float64, float64 STATUS_PARAM );
354float64 float64_div( float64, float64 STATUS_PARAM );
355float64 float64_rem( float64, float64 STATUS_PARAM );
356float64 float64_sqrt( float64 STATUS_PARAM );
357float64 float64_log2( float64 STATUS_PARAM );
358int float64_eq( float64, float64 STATUS_PARAM );
359int float64_le( float64, float64 STATUS_PARAM );
360int float64_lt( float64, float64 STATUS_PARAM );
361int float64_eq_signaling( float64, float64 STATUS_PARAM );
362int float64_le_quiet( float64, float64 STATUS_PARAM );
363int float64_lt_quiet( float64, float64 STATUS_PARAM );
364int float64_compare( float64, float64 STATUS_PARAM );
365int float64_compare_quiet( float64, float64 STATUS_PARAM );
366int float64_is_nan( float64 a );
367int float64_is_signaling_nan( float64 );
368float64 float64_scalbn( float64, int STATUS_PARAM );
369
370INLINE float64 float64_abs(float64 a)
371{
372 return make_float64(float64_val(a) & 0x7fffffffffffffffLL);
373}
374
375INLINE float64 float64_chs(float64 a)
376{
377 return make_float64(float64_val(a) ^ 0x8000000000000000LL);
378}
379
380INLINE int float64_is_infinity(float64 a)
381{
382 return (float64_val(a) & 0x7fffffffffffffffLL ) == 0x7ff0000000000000LL;
383}
384
385INLINE int float64_is_neg(float64 a)
386{
387 return float64_val(a) >> 63;
388}
389
390INLINE int float64_is_zero(float64 a)
391{
392 return (float64_val(a) & 0x7fffffffffffffffLL) == 0;
393}
394
395#define float64_zero make_float64(0)
396#define float64_one make_float64(0x3ff0000000000000LL)
397
398#ifdef FLOATX80
399
400/*----------------------------------------------------------------------------
401| Software IEC/IEEE extended double-precision conversion routines.
402*----------------------------------------------------------------------------*/
403int floatx80_to_int32( floatx80 STATUS_PARAM );
404int floatx80_to_int32_round_to_zero( floatx80 STATUS_PARAM );
405int64_t floatx80_to_int64( floatx80 STATUS_PARAM );
406int64_t floatx80_to_int64_round_to_zero( floatx80 STATUS_PARAM );
407float32 floatx80_to_float32( floatx80 STATUS_PARAM );
408float64 floatx80_to_float64( floatx80 STATUS_PARAM );
409#ifdef FLOAT128
410float128 floatx80_to_float128( floatx80 STATUS_PARAM );
411#endif
412
413/*----------------------------------------------------------------------------
414| Software IEC/IEEE extended double-precision operations.
415*----------------------------------------------------------------------------*/
416floatx80 floatx80_round_to_int( floatx80 STATUS_PARAM );
417floatx80 floatx80_add( floatx80, floatx80 STATUS_PARAM );
418floatx80 floatx80_sub( floatx80, floatx80 STATUS_PARAM );
419floatx80 floatx80_mul( floatx80, floatx80 STATUS_PARAM );
420floatx80 floatx80_div( floatx80, floatx80 STATUS_PARAM );
421floatx80 floatx80_rem( floatx80, floatx80 STATUS_PARAM );
422floatx80 floatx80_sqrt( floatx80 STATUS_PARAM );
423int floatx80_eq( floatx80, floatx80 STATUS_PARAM );
424int floatx80_le( floatx80, floatx80 STATUS_PARAM );
425int floatx80_lt( floatx80, floatx80 STATUS_PARAM );
426int floatx80_eq_signaling( floatx80, floatx80 STATUS_PARAM );
427int floatx80_le_quiet( floatx80, floatx80 STATUS_PARAM );
428int floatx80_lt_quiet( floatx80, floatx80 STATUS_PARAM );
429int floatx80_is_nan( floatx80 );
430int floatx80_is_signaling_nan( floatx80 );
431floatx80 floatx80_scalbn( floatx80, int STATUS_PARAM );
432
433INLINE floatx80 floatx80_abs(floatx80 a)
434{
435 a.high &= 0x7fff;
436 return a;
437}
438
439INLINE floatx80 floatx80_chs(floatx80 a)
440{
441 a.high ^= 0x8000;
442 return a;
443}
444
445INLINE int floatx80_is_infinity(floatx80 a)
446{
447 return (a.high & 0x7fff) == 0x7fff && a.low == 0;
448}
449
450INLINE int floatx80_is_neg(floatx80 a)
451{
452 return a.high >> 15;
453}
454
455INLINE int floatx80_is_zero(floatx80 a)
456{
457 return (a.high & 0x7fff) == 0 && a.low == 0;
458}
459
460#endif
461
462#ifdef FLOAT128
463
464/*----------------------------------------------------------------------------
465| Software IEC/IEEE quadruple-precision conversion routines.
466*----------------------------------------------------------------------------*/
467int float128_to_int32( float128 STATUS_PARAM );
468int float128_to_int32_round_to_zero( float128 STATUS_PARAM );
469int64_t float128_to_int64( float128 STATUS_PARAM );
470int64_t float128_to_int64_round_to_zero( float128 STATUS_PARAM );
471float32 float128_to_float32( float128 STATUS_PARAM );
472float64 float128_to_float64( float128 STATUS_PARAM );
473#ifdef FLOATX80
474floatx80 float128_to_floatx80( float128 STATUS_PARAM );
475#endif
476
477/*----------------------------------------------------------------------------
478| Software IEC/IEEE quadruple-precision operations.
479*----------------------------------------------------------------------------*/
480float128 float128_round_to_int( float128 STATUS_PARAM );
481float128 float128_add( float128, float128 STATUS_PARAM );
482float128 float128_sub( float128, float128 STATUS_PARAM );
483float128 float128_mul( float128, float128 STATUS_PARAM );
484float128 float128_div( float128, float128 STATUS_PARAM );
485float128 float128_rem( float128, float128 STATUS_PARAM );
486float128 float128_sqrt( float128 STATUS_PARAM );
487int float128_eq( float128, float128 STATUS_PARAM );
488int float128_le( float128, float128 STATUS_PARAM );
489int float128_lt( float128, float128 STATUS_PARAM );
490int float128_eq_signaling( float128, float128 STATUS_PARAM );
491int float128_le_quiet( float128, float128 STATUS_PARAM );
492int float128_lt_quiet( float128, float128 STATUS_PARAM );
493int float128_compare( float128, float128 STATUS_PARAM );
494int float128_compare_quiet( float128, float128 STATUS_PARAM );
495int float128_is_nan( float128 );
496int float128_is_signaling_nan( float128 );
497float128 float128_scalbn( float128, int STATUS_PARAM );
498
499INLINE float128 float128_abs(float128 a)
500{
501 a.high &= 0x7fffffffffffffffLL;
502 return a;
503}
504
505INLINE float128 float128_chs(float128 a)
506{
507 a.high ^= 0x8000000000000000LL;
508 return a;
509}
510
511INLINE int float128_is_infinity(float128 a)
512{
513 return (a.high & 0x7fffffffffffffffLL) == 0x7fff000000000000LL && a.low == 0;
514}
515
516INLINE int float128_is_neg(float128 a)
517{
518 return a.high >> 63;
519}
520
521INLINE int float128_is_zero(float128 a)
522{
523 return (a.high & 0x7fffffffffffffffLL) == 0 && a.low == 0;
524}
525
526#endif
527
528#else /* CONFIG_SOFTFLOAT */
529
530#include "softfloat-native.h"
531
532#endif /* !CONFIG_SOFTFLOAT */
533
534#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