![[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 / src / softfloat|
Return to softfloat.h CVS log | Up to [Previous NeXT emulator] / previous / 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: *----------------------------------------------------------------------------*/
1.1.1.2 ! root 75: #if 0
1.1 root 76: extern int8 float_detect_tininess;
1.1.1.2 ! root 77: #endif
1.1 root 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: *----------------------------------------------------------------------------*/
1.1.1.2 ! root 86: #if 0
1.1 root 87: extern int8 float_rounding_mode;
88: #ifdef SOFTFLOAT_I860
89: extern int8 float_rounding_mode2;
90: #endif
1.1.1.2 ! root 91: #endif
1.1 root 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: *----------------------------------------------------------------------------*/
1.1.1.2 ! root 102: #if 0
1.1 root 103: extern int8 float_exception_flags;
104: #ifdef SOFTFLOAT_I860
105: extern int8 float_exception_flags2;
106: #endif
1.1.1.2 ! root 107: #endif
1.1 root 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: *----------------------------------------------------------------------------*/
1.1.1.2 ! root 117: #if 0
1.1 root 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;
1.1.1.2 ! root 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 );
1.1 root 151:
152: /*----------------------------------------------------------------------------
153: | Function for getting sign, exponent and significand of extended
154: | double-precision floating-point intermediate result for external use.
155: *----------------------------------------------------------------------------*/
1.1.1.2 ! root 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 );
1.1 root 163:
164: /*----------------------------------------------------------------------------
165: | Routine to raise any or all of the software IEC/IEEE floating-point
166: | exception flags.
167: *----------------------------------------------------------------------------*/
1.1.1.2 ! root 168: void float_raise( int8, float_ctrl* c );
! 169: #if 0
1.1 root 170: #ifdef SOFTFLOAT_I860
171: void float_raise2( int8 );
172: #endif
1.1.1.2 ! root 173: #endif
1.1 root 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: *----------------------------------------------------------------------------*/
1.1.1.2 ! root 212: float32 int32_to_float32( int32, float_ctrl* );
1.1 root 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
1.1.1.2 ! root 220: float32 int64_to_float32( int64, float_ctrl* );
! 221: float64 int64_to_float64( int64, float_ctrl* );
1.1 root 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: *----------------------------------------------------------------------------*/
1.1.1.2 ! root 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* );
1.1 root 237: #ifdef FLOATX80
1.1.1.2 ! root 238: floatx80 float32_to_floatx80( float32, float_ctrl* );
1.1 root 239: floatx80 float32_to_floatx80_allowunnormal( float32 );
240: #endif
241: #ifdef FLOAT128
1.1.1.2 ! root 242: float128 float32_to_float128( float32, float_ctrl* );
1.1 root 243: #endif
244:
245: /*----------------------------------------------------------------------------
246: | Software IEC/IEEE single-precision operations.
247: *----------------------------------------------------------------------------*/
1.1.1.2 ! root 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* );
1.1 root 258: #ifdef SOFTFLOAT_I860
1.1.1.2 ! root 259: flag float32_gt( float32, float32, float_ctrl* );
1.1 root 260: #endif
1.1.1.2 ! root 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* );
1.1 root 264: flag float32_is_signaling_nan( float32 );
265:
266: /*----------------------------------------------------------------------------
267: | Software IEC/IEEE double-precision conversion routines.
268: *----------------------------------------------------------------------------*/
1.1.1.2 ! root 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* );
1.1 root 274: #ifdef FLOATX80
1.1.1.2 ! root 275: floatx80 float64_to_floatx80( float64, float_ctrl* );
1.1 root 276: floatx80 float64_to_floatx80_allowunnormal( float64 );
277: #endif
278: #ifdef FLOAT128
1.1.1.2 ! root 279: float128 float64_to_float128( float64, float_ctrl* );
1.1 root 280: #endif
281:
282: /*----------------------------------------------------------------------------
283: | Software IEC/IEEE double-precision operations.
284: *----------------------------------------------------------------------------*/
1.1.1.2 ! root 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* );
1.1 root 295: #ifdef SOFTFLOAT_I860
1.1.1.2 ! root 296: flag float64_gt( float64, float64, float_ctrl* );
1.1 root 297: #endif
1.1.1.2 ! root 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* );
1.1 root 301: flag float64_is_signaling_nan( float64 );
302:
303: #ifdef FLOATX80
304:
305: /*----------------------------------------------------------------------------
306: | Software IEC/IEEE extended double-precision conversion routines.
307: *----------------------------------------------------------------------------*/
1.1.1.2 ! root 308: int32 floatx80_to_int32( floatx80, float_ctrl* );
1.1 root 309: #ifdef SOFTFLOAT_68K
1.1.1.2 ! root 310: int16 floatx80_to_int16( floatx80, float_ctrl* );
! 311: int8 floatx80_to_int8( floatx80, float_ctrl* );
1.1 root 312: #endif
1.1.1.2 ! root 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* );
1.1 root 318: #ifdef SOFTFLOAT_68K
1.1.1.2 ! root 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* );
1.1 root 322: #endif
323: #ifdef FLOAT128
1.1.1.2 ! root 324: float128 floatx80_to_float128( floatx80, float_ctrl* );
1.1 root 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: *----------------------------------------------------------------------------*/
1.1.1.2 ! root 334: #if 0
1.1 root 335: extern int8 floatx80_rounding_precision;
1.1.1.2 ! root 336: #endif
1.1 root 337:
338: /*----------------------------------------------------------------------------
339: | Software IEC/IEEE extended double-precision operations.
340: *----------------------------------------------------------------------------*/
1.1.1.2 ! root 341: floatx80 floatx80_round_to_int( floatx80, float_ctrl* );
1.1 root 342: #ifdef SOFTFLOAT_68K
1.1.1.2 ! root 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* );
1.1 root 348: floatx80 floatx80_normalize( floatx80 );
349: floatx80 floatx80_denormalize( floatx80, flag );
350: #endif
1.1.1.2 ! root 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* );
1.1 root 355: #ifndef SOFTFLOAT_68K
1.1.1.2 ! root 356: floatx80 floatx80_rem( floatx80, floatx80, float_ctrl* );
1.1 root 357: #endif
1.1.1.2 ! root 358: floatx80 floatx80_sqrt( floatx80, float_ctrl* );
1.1 root 359:
1.1.1.2 ! root 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* );
1.1 root 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
1.1.1.2 ! root 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 );
1.1 root 390:
391: // functions are in softfloat_fpsp.c
1.1.1.2 ! root 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);
1.1 root 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 );
1.1.1.2 ! root 415: floatx80 roundAndPackFloatx80( int8 roundingPrecision, flag zSign, int32 zExp, bits64 zSig0, bits64 zSig1, float_ctrl* c );
1.1 root 416:
417: // functions are in softfloat-specialize.h
1.1.1.2 ! root 418: floatx80 propagateFloatx80NaNOneArg( floatx80 a, float_ctrl* c );
! 419: floatx80 propagateFloatx80NaN( floatx80 a, floatx80 b, float_ctrl* c );
1.1 root 420:
421: #endif
422:
423: #ifdef FLOAT128
424:
425: /*----------------------------------------------------------------------------
426: | Software IEC/IEEE quadruple-precision conversion routines.
427: *----------------------------------------------------------------------------*/
1.1.1.2 ! root 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* );
1.1 root 434: #ifdef FLOATX80
1.1.1.2 ! root 435: floatx80 float128_to_floatx80( float128, float_ctrl* );
1.1 root 436: #endif
437:
438: /*----------------------------------------------------------------------------
439: | Software IEC/IEEE quadruple-precision operations.
440: *----------------------------------------------------------------------------*/
1.1.1.2 ! root 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* );
1.1 root 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 );
1.1.1.2 ! root 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 );
1.1 root 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.