![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to softfloat.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Previous NeXT emulator] / previous_trunk / src / softfloat|
Return to softfloat.h CVS log | Up to [Previous NeXT emulator] / previous_trunk / src / softfloat |
1.1 root 1:
2: /*============================================================================
3:
4: This C header file is part of the SoftFloat IEC/IEEE Floating-point Arithmetic
5: Package, Release 2b.
6:
7: Written by John R. Hauser. This work was made possible in part by the
8: International Computer Science Institute, located at Suite 600, 1947 Center
9: Street, Berkeley, California 94704. Funding was partially provided by the
10: National Science Foundation under grant MIP-9311980. The original version
11: of this code was written as part of a project to build a fixed-point vector
12: processor in collaboration with the University of California at Berkeley,
13: overseen by Profs. Nelson Morgan and John Wawrzynek. More information
14: is available through the Web page `http://www.cs.berkeley.edu/~jhauser/
15: arithmetic/SoftFloat.html'.
16:
17: THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE. Although reasonable effort has
18: been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT TIMES
19: RESULT IN INCORRECT BEHAVIOR. USE OF THIS SOFTWARE IS RESTRICTED TO PERSONS
20: AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ALL LOSSES,
21: COSTS, OR OTHER PROBLEMS THEY INCUR DUE TO THE SOFTWARE, AND WHO FURTHERMORE
22: EFFECTIVELY INDEMNIFY JOHN HAUSER AND THE INTERNATIONAL COMPUTER SCIENCE
23: INSTITUTE (possibly via similar legal warning) AGAINST ALL LOSSES, COSTS, OR
24: OTHER PROBLEMS INCURRED BY THEIR CUSTOMERS AND CLIENTS DUE TO THE SOFTWARE.
25:
26: Derivative works are acceptable, even for commercial purposes, so long as
27: (1) the source code for the derivative work includes prominent notice that
28: the work is derivative, and (2) the source code includes prominent notice with
29: these four paragraphs for those parts of this code that are retained.
30:
31: =============================================================================*/
32:
33: #ifndef SOFTFLOAT_H
34: #define SOFTFLOAT_H
35: /*----------------------------------------------------------------------------
36: | The macro `FLOATX80' must be defined to enable the extended double-precision
37: | floating-point format `floatx80'. If this macro is not defined, the
38: | `floatx80' type will not be defined, and none of the functions that either
39: | input or output the `floatx80' type will be defined. The same applies to
40: | the `FLOAT128' macro and the quadruple-precision format `float128'.
41: *----------------------------------------------------------------------------*/
42: #define FLOATX80
43: #define FLOAT128
44:
45: /*----------------------------------------------------------------------------
46: | Software IEC/IEEE floating-point types.
47: *----------------------------------------------------------------------------*/
48:
49: #include "mamesf.h"
50:
51: typedef bits32 float32;
52: typedef bits64 float64;
53: #ifdef FLOATX80
54: typedef struct {
55: bits16 high;
56: bits64 low;
57: } floatx80;
58: #endif
59: #ifdef FLOAT128
60: typedef struct {
61: bits64 high, low;
62: } float128;
63: #endif
64:
65: /*----------------------------------------------------------------------------
66: | Primitive arithmetic functions, including multi-word arithmetic, and
67: | division and square root approximations. (Can be specialized to target if
68: | desired.)
69: *----------------------------------------------------------------------------*/
70: #include "softfloat-macros.h"
71:
72: /*----------------------------------------------------------------------------
73: | Software IEC/IEEE floating-point underflow tininess-detection mode.
74: *----------------------------------------------------------------------------*/
75: #if 0
76: extern int8 float_detect_tininess;
77: #endif
78: enum {
79: float_tininess_after_rounding = 0,
80: float_tininess_before_rounding = 1
81: };
82:
83: /*----------------------------------------------------------------------------
84: | Software IEC/IEEE floating-point rounding mode.
85: *----------------------------------------------------------------------------*/
86: #if 0
87: extern int8 float_rounding_mode;
88: #ifdef SOFTFLOAT_I860
89: extern int8 float_rounding_mode2;
90: #endif
91: #endif
92: enum {
93: float_round_nearest_even = 0,
94: float_round_to_zero = 1,
95: float_round_down = 2,
96: float_round_up = 3
97: };
98:
99: /*----------------------------------------------------------------------------
100: | Software IEC/IEEE floating-point exception flags.
101: *----------------------------------------------------------------------------*/
102: #if 0
103: extern int8 float_exception_flags;
104: #ifdef SOFTFLOAT_I860
105: extern int8 float_exception_flags2;
106: #endif
107: #endif
108: enum {
109: float_flag_invalid = 0x01, float_flag_denormal = 0x02, float_flag_divbyzero = 0x04, float_flag_overflow = 0x08,
110: float_flag_underflow = 0x10, float_flag_inexact = 0x20, float_flag_signaling = 0x40, float_flag_decimal = 0x80
111: };
112:
113: /*----------------------------------------------------------------------------
114: | Variables for storing sign, exponent and significand of internal extended
115: | double-precision floating-point value for external use.
116: *----------------------------------------------------------------------------*/
117: #if 0
118: extern flag floatx80_internal_sign;
119: extern int32 floatx80_internal_exp;
120: extern bits64 floatx80_internal_sig0;
121: extern bits64 floatx80_internal_sig1;
122: extern int8 floatx80_internal_precision;
123: extern int8 floatx80_internal_mode;
124: #endif
125:
126:
127: typedef struct {
128: int8 float_detect_tininess;
129: int8 float_exception_flags;
130: int8 float_rounding_mode;
131: #ifdef FLOATX80
132: int8 floatx80_rounding_precision;
133: flag floatx80_internal_sign;
134: int32 floatx80_internal_exp;
135: bits64 floatx80_internal_sig0;
136: bits64 floatx80_internal_sig1;
137: int8 floatx80_internal_precision;
138: int8 floatx80_internal_mode;
139: #endif
140: } float_ctrl;
141:
142: void float_init( float_ctrl* c );
143: int8 get_float_rounding_mode( float_ctrl* c );
144: void set_float_rounding_mode( int8 mode, float_ctrl* c );
145: int8 get_float_rounding_precision( float_ctrl* c );
146: void set_float_rounding_precision( int8 precision, float_ctrl* c );
147: int8 get_float_exception_flags( float_ctrl* c );
148: void set_float_exception_flags( int8 flags, float_ctrl* c );
149: int8 get_float_detect_tininess( float_ctrl* c );
150: void set_float_detect_tininess( int8 mode, float_ctrl* c );
151:
152: /*----------------------------------------------------------------------------
153: | Function for getting sign, exponent and significand of extended
154: | double-precision floating-point intermediate result for external use.
155: *----------------------------------------------------------------------------*/
156: floatx80 getFloatInternalOverflow( float_ctrl* c );
157: floatx80 getFloatInternalUnderflow( float_ctrl* c );
158: floatx80 getFloatInternalRoundedAll( float_ctrl* c );
159: floatx80 getFloatInternalRoundedSome( float_ctrl* c );
160: floatx80 getFloatInternalUnrounded( float_ctrl* c );
161: floatx80 getFloatInternalFloatx80( float_ctrl* c );
162: bits64 getFloatInternalGRS( float_ctrl* c );
163:
164: /*----------------------------------------------------------------------------
165: | Routine to raise any or all of the software IEC/IEEE floating-point
166: | exception flags.
167: *----------------------------------------------------------------------------*/
168: void float_raise( int8, float_ctrl* c );
169: #if 0
170: #ifdef SOFTFLOAT_I860
171: void float_raise2( int8 );
172: #endif
173: #endif
174:
175: /*----------------------------------------------------------------------------
176: | The pattern for a default generated single-precision NaN.
177: *----------------------------------------------------------------------------*/
178: #define float32_default_nan 0x7FFFFFFF
179:
180: /*----------------------------------------------------------------------------
181: | The pattern for a default generated double-precision NaN.
182: *----------------------------------------------------------------------------*/
183: #define float64_default_nan LIT64( 0x7FFFFFFFFFFFFFFF )
184:
185: #ifdef FLOATX80
186: /*----------------------------------------------------------------------------
187: | The pattern for a default generated extended double-precision NaN. The
188: | `high' and `low' values hold the most- and least-significant bits,
189: | respectively.
190: *----------------------------------------------------------------------------*/
191: #define floatx80_default_nan_high 0x7FFF
192: #define floatx80_default_nan_low LIT64( 0xFFFFFFFFFFFFFFFF )
193: #endif
194: #ifdef FLOAT128
195: /*----------------------------------------------------------------------------
196: | The pattern for a default generated quadruple-precision NaN. The `high' and
197: | `low' values hold the most- and least-significant bits, respectively.
198: *----------------------------------------------------------------------------*/
199: #define float128_default_nan_high LIT64( 0x7FFFFFFFFFFFFFFF )
200: #define float128_default_nan_low LIT64( 0xFFFFFFFFFFFFFFFF )
201: #endif
202: #ifdef FLOATX80
203: /*----------------------------------------------------------------------------
204: | The pattern for a default generated extended double-precision infinity.
205: *----------------------------------------------------------------------------*/
206: #define floatx80_default_infinity_low LIT64( 0x0000000000000000 )
207: #endif
208:
209: /*----------------------------------------------------------------------------
210: | Software IEC/IEEE integer-to-floating-point conversion routines.
211: *----------------------------------------------------------------------------*/
212: float32 int32_to_float32( int32, float_ctrl* );
213: float64 int32_to_float64( int32 );
214: #ifdef FLOATX80
215: floatx80 int32_to_floatx80( int32 );
216: #endif
217: #ifdef FLOAT128
218: float128 int32_to_float128( int32 );
219: #endif
220: float32 int64_to_float32( int64, float_ctrl* );
221: float64 int64_to_float64( int64, float_ctrl* );
222: #ifdef FLOATX80
223: floatx80 int64_to_floatx80( int64 );
224: #endif
225: #ifdef FLOAT128
226: float128 int64_to_float128( int64 );
227: #endif
228:
229: /*----------------------------------------------------------------------------
230: | Software IEC/IEEE single-precision conversion routines.
231: *----------------------------------------------------------------------------*/
232: int32 float32_to_int32( float32, float_ctrl* );
233: int32 float32_to_int32_round_to_zero( float32, float_ctrl* );
234: int64 float32_to_int64( float32, float_ctrl* );
235: int64 float32_to_int64_round_to_zero( float32, float_ctrl* );
236: float64 float32_to_float64( float32, float_ctrl* );
237: #ifdef FLOATX80
238: floatx80 float32_to_floatx80( float32, float_ctrl* );
239: floatx80 float32_to_floatx80_allowunnormal( float32 );
240: #endif
241: #ifdef FLOAT128
242: float128 float32_to_float128( float32, float_ctrl* );
243: #endif
244:
245: /*----------------------------------------------------------------------------
246: | Software IEC/IEEE single-precision operations.
247: *----------------------------------------------------------------------------*/
248: float32 float32_round_to_int( float32, float_ctrl* );
249: float32 float32_add( float32, float32, float_ctrl* );
250: float32 float32_sub( float32, float32, float_ctrl* );
251: float32 float32_mul( float32, float32, float_ctrl* );
252: float32 float32_div( float32, float32, float_ctrl* );
253: float32 float32_rem( float32, float32, float_ctrl* );
254: float32 float32_sqrt( float32, float_ctrl* );
255: flag float32_eq( float32, float32, float_ctrl* );
256: flag float32_le( float32, float32, float_ctrl* );
257: flag float32_lt( float32, float32, float_ctrl* );
258: #ifdef SOFTFLOAT_I860
259: flag float32_gt( float32, float32, float_ctrl* );
260: #endif
261: flag float32_eq_signaling( float32, float32, float_ctrl* );
262: flag float32_le_quiet( float32, float32, float_ctrl* );
263: flag float32_lt_quiet( float32, float32, float_ctrl* );
264: flag float32_is_signaling_nan( float32 );
265:
266: /*----------------------------------------------------------------------------
267: | Software IEC/IEEE double-precision conversion routines.
268: *----------------------------------------------------------------------------*/
269: int32 float64_to_int32( float64, float_ctrl* );
270: int32 float64_to_int32_round_to_zero( float64, float_ctrl* );
271: int64 float64_to_int64( float64, float_ctrl* );
272: int64 float64_to_int64_round_to_zero( float64, float_ctrl* );
273: float32 float64_to_float32( float64, float_ctrl* );
274: #ifdef FLOATX80
275: floatx80 float64_to_floatx80( float64, float_ctrl* );
276: floatx80 float64_to_floatx80_allowunnormal( float64 );
277: #endif
278: #ifdef FLOAT128
279: float128 float64_to_float128( float64, float_ctrl* );
280: #endif
281:
282: /*----------------------------------------------------------------------------
283: | Software IEC/IEEE double-precision operations.
284: *----------------------------------------------------------------------------*/
285: float64 float64_round_to_int( float64, float_ctrl* );
286: float64 float64_add( float64, float64, float_ctrl* );
287: float64 float64_sub( float64, float64, float_ctrl* );
288: float64 float64_mul( float64, float64, float_ctrl* );
289: float64 float64_div( float64, float64, float_ctrl* );
290: float64 float64_rem( float64, float64, float_ctrl* );
291: float64 float64_sqrt( float64, float_ctrl* );
292: flag float64_eq( float64, float64, float_ctrl* );
293: flag float64_le( float64, float64, float_ctrl* );
294: flag float64_lt( float64, float64, float_ctrl* );
295: #ifdef SOFTFLOAT_I860
296: flag float64_gt( float64, float64, float_ctrl* );
297: #endif
298: flag float64_eq_signaling( float64, float64, float_ctrl* );
299: flag float64_le_quiet( float64, float64, float_ctrl* );
300: flag float64_lt_quiet( float64, float64, float_ctrl* );
301: flag float64_is_signaling_nan( float64 );
302:
303: #ifdef FLOATX80
304:
305: /*----------------------------------------------------------------------------
306: | Software IEC/IEEE extended double-precision conversion routines.
307: *----------------------------------------------------------------------------*/
308: int32 floatx80_to_int32( floatx80, float_ctrl* );
309: #ifdef SOFTFLOAT_68K
310: int16 floatx80_to_int16( floatx80, float_ctrl* );
311: int8 floatx80_to_int8( floatx80, float_ctrl* );
312: #endif
313: int32 floatx80_to_int32_round_to_zero( floatx80, float_ctrl* );
314: int64 floatx80_to_int64( floatx80, float_ctrl* );
315: int64 floatx80_to_int64_round_to_zero( floatx80, float_ctrl* );
316: float32 floatx80_to_float32( floatx80, float_ctrl* );
317: float64 floatx80_to_float64( floatx80, float_ctrl* );
318: #ifdef SOFTFLOAT_68K
319: floatx80 floatx80_to_floatx80( floatx80, float_ctrl* );
320: floatx80 floatdecimal_to_floatx80( floatx80, float_ctrl* );
321: floatx80 floatx80_to_floatdecimal( floatx80, int32*, float_ctrl* );
322: #endif
323: #ifdef FLOAT128
324: float128 floatx80_to_float128( floatx80, float_ctrl* );
325: #endif
326: bits64 extractFloatx80Frac( floatx80 a );
327: int32 extractFloatx80Exp( floatx80 a );
328: flag extractFloatx80Sign( floatx80 a );
329:
330: /*----------------------------------------------------------------------------
331: | Software IEC/IEEE extended double-precision rounding precision. Valid
332: | values are 32, 64, and 80.
333: *----------------------------------------------------------------------------*/
334: #if 0
335: extern int8 floatx80_rounding_precision;
336: #endif
337:
338: /*----------------------------------------------------------------------------
339: | Software IEC/IEEE extended double-precision operations.
340: *----------------------------------------------------------------------------*/
341: floatx80 floatx80_round_to_int( floatx80, float_ctrl* );
342: #ifdef SOFTFLOAT_68K
343: floatx80 floatx80_round_to_int_toward_zero( floatx80, float_ctrl* );
344: floatx80 floatx80_round_to_float32( floatx80, float_ctrl* );
345: floatx80 floatx80_round_to_float64( floatx80, float_ctrl* );
346: floatx80 floatx80_round32( floatx80, float_ctrl* );
347: floatx80 floatx80_round64( floatx80, float_ctrl* );
348: floatx80 floatx80_normalize( floatx80 );
349: floatx80 floatx80_denormalize( floatx80, flag );
350: #endif
351: floatx80 floatx80_add( floatx80, floatx80, float_ctrl* );
352: floatx80 floatx80_sub( floatx80, floatx80, float_ctrl* );
353: floatx80 floatx80_mul( floatx80, floatx80, float_ctrl* );
354: floatx80 floatx80_div( floatx80, floatx80, float_ctrl* );
355: #ifndef SOFTFLOAT_68K
356: floatx80 floatx80_rem( floatx80, floatx80, float_ctrl* );
357: #endif
358: floatx80 floatx80_sqrt( floatx80, float_ctrl* );
359:
360: flag floatx80_eq( floatx80, floatx80, float_ctrl* );
361: flag floatx80_le( floatx80, floatx80, float_ctrl* );
362: flag floatx80_lt( floatx80, floatx80, float_ctrl* );
363: flag floatx80_eq_signaling( floatx80, floatx80, float_ctrl* );
364: flag floatx80_le_quiet( floatx80, floatx80, float_ctrl* );
365: flag floatx80_lt_quiet( floatx80, floatx80, float_ctrl* );
366:
367: flag floatx80_is_signaling_nan( floatx80 );
368: flag floatx80_is_nan( floatx80 );
369: #ifdef SOFTFLOAT_68K
370: flag floatx80_is_zero( floatx80 );
371: flag floatx80_is_infinity( floatx80 );
372: flag floatx80_is_negative( floatx80 );
373: flag floatx80_is_denormal( floatx80 );
374: flag floatx80_is_unnormal( floatx80 );
375: flag floatx80_is_normal( floatx80 );
376:
377: // functions are in softfloat.c
378: floatx80 floatx80_move( floatx80 a, float_ctrl* c );
379: floatx80 floatx80_abs( floatx80 a, float_ctrl* c );
380: floatx80 floatx80_neg( floatx80 a, float_ctrl* c );
381: floatx80 floatx80_getexp( floatx80 a, float_ctrl* c );
382: floatx80 floatx80_getman( floatx80 a, float_ctrl* c );
383: floatx80 floatx80_scale(floatx80 a, floatx80 b, float_ctrl* c );
384: floatx80 floatx80_rem( floatx80 a, floatx80 b, bits64 *q, flag *s, float_ctrl* c );
385: floatx80 floatx80_mod( floatx80 a, floatx80 b, bits64 *q, flag *s, float_ctrl* c );
386: floatx80 floatx80_sglmul( floatx80 a, floatx80 b, float_ctrl* c );
387: floatx80 floatx80_sgldiv( floatx80 a, floatx80 b, float_ctrl* c );
388: floatx80 floatx80_cmp( floatx80 a, floatx80 b, float_ctrl* c );
389: floatx80 floatx80_tst( floatx80 a, float_ctrl* c );
390:
391: // functions are in softfloat_fpsp.c
392: floatx80 floatx80_acos(floatx80 a, float_ctrl* c);
393: floatx80 floatx80_asin(floatx80 a, float_ctrl* c);
394: floatx80 floatx80_atan(floatx80 a, float_ctrl* c);
395: floatx80 floatx80_atanh(floatx80 a, float_ctrl* c);
396: floatx80 floatx80_cos(floatx80 a, float_ctrl* c);
397: floatx80 floatx80_cosh(floatx80 a, float_ctrl* c);
398: floatx80 floatx80_etox(floatx80 a, float_ctrl* c);
399: floatx80 floatx80_etoxm1(floatx80 a, float_ctrl* c);
400: floatx80 floatx80_log10(floatx80 a, float_ctrl* c);
401: floatx80 floatx80_log2(floatx80 a, float_ctrl* c);
402: floatx80 floatx80_logn(floatx80 a, float_ctrl* c);
403: floatx80 floatx80_lognp1(floatx80 a, float_ctrl* c);
404: floatx80 floatx80_sin(floatx80 a, float_ctrl* c);
405: floatx80 floatx80_sinh(floatx80 a, float_ctrl* c);
406: floatx80 floatx80_tan(floatx80 a, float_ctrl* c);
407: floatx80 floatx80_tanh(floatx80 a, float_ctrl* c);
408: floatx80 floatx80_tentox(floatx80 a, float_ctrl* c);
409: floatx80 floatx80_twotox(floatx80 a, float_ctrl* c);
410: #endif
411:
412: // functions originally internal to softfloat.c
413: void normalizeFloatx80Subnormal( bits64 aSig, int32 *zExpPtr, bits64 *zSigPtr );
414: floatx80 packFloatx80( flag zSign, int32 zExp, bits64 zSig );
415: floatx80 roundAndPackFloatx80( int8 roundingPrecision, flag zSign, int32 zExp, bits64 zSig0, bits64 zSig1, float_ctrl* c );
416:
417: // functions are in softfloat-specialize.h
418: floatx80 propagateFloatx80NaNOneArg( floatx80 a, float_ctrl* c );
419: floatx80 propagateFloatx80NaN( floatx80 a, floatx80 b, float_ctrl* c );
420:
421: #endif
422:
423: #ifdef FLOAT128
424:
425: /*----------------------------------------------------------------------------
426: | Software IEC/IEEE quadruple-precision conversion routines.
427: *----------------------------------------------------------------------------*/
428: int32 float128_to_int32( float128, float_ctrl* );
429: int32 float128_to_int32_round_to_zero( float128, float_ctrl* );
430: int64 float128_to_int64( float128, float_ctrl* );
431: int64 float128_to_int64_round_to_zero( float128, float_ctrl* );
432: float32 float128_to_float32( float128, float_ctrl* );
433: float64 float128_to_float64( float128, float_ctrl* );
434: #ifdef FLOATX80
435: floatx80 float128_to_floatx80( float128, float_ctrl* );
436: #endif
437:
438: /*----------------------------------------------------------------------------
439: | Software IEC/IEEE quadruple-precision operations.
440: *----------------------------------------------------------------------------*/
441: float128 float128_round_to_int( float128, float_ctrl* );
442: float128 float128_add( float128, float128, float_ctrl* );
443: float128 float128_sub( float128, float128, float_ctrl* );
444: float128 float128_mul( float128, float128, float_ctrl* );
445: float128 float128_div( float128, float128, float_ctrl* );
446: float128 float128_rem( float128, float128, float_ctrl* );
447: float128 float128_sqrt( float128, float_ctrl* );
448: flag float128_eq( float128, float128, float_ctrl* );
449: flag float128_le( float128, float128, float_ctrl* );
450: flag float128_lt( float128, float128, float_ctrl* );
451: flag float128_eq_signaling( float128, float128, float_ctrl* );
452: flag float128_le_quiet( float128, float128, float_ctrl* );
453: flag float128_lt_quiet( float128, float128, float_ctrl* );
454: flag float128_is_signaling_nan( float128 );
455:
456: // functions originally internal to softfloat.c
457: float128 packFloat128( flag zSign, int32 zExp, bits64 zSig0, bits64 zSig1 );
458: float128 roundAndPackFloat128( flag zSign, int32 zExp, bits64 zSig0, bits64 zSig1, bits64 zSig2, float_ctrl* c );
459: float128 normalizeRoundAndPackFloat128( flag zSign, int32 zExp, bits64 zSig0, bits64 zSig1, float_ctrl* c );
460:
461: #endif
462:
463: #endif //SOFTFLOAT_H
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.