VirtualBox

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

Last change on this file since 69465 was 69465, checked in by vboxsync, 7 years ago

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