Annotation of sys/lib/libkern/softfloat.h, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: softfloat.h,v 1.1 2002/04/28 20:55:14 pvalchev Exp $ */
2: /* $NetBSD: softfloat.h,v 1.1 2001/04/26 03:10:48 ross Exp $ */
3:
4: /* This is a derivative work. */
5:
6: /*-
7: * Copyright (c) 2001 The NetBSD Foundation, Inc.
8: * All rights reserved.
9: *
10: * This code is derived from software contributed to The NetBSD Foundation
11: * by Ross Harvey.
12: *
13: * Redistribution and use in source and binary forms, with or without
14: * modification, are permitted provided that the following conditions
15: * are met:
16: * 1. Redistributions of source code must retain the above copyright
17: * notice, this list of conditions and the following disclaimer.
18: * 2. Redistributions in binary form must reproduce the above copyright
19: * notice, this list of conditions and the following disclaimer in the
20: * documentation and/or other materials provided with the distribution.
21: * 3. All advertising materials mentioning features or use of this software
22: * must display the following acknowledgement:
23: * This product includes software developed by the NetBSD
24: * Foundation, Inc. and its contributors.
25: * 4. Neither the name of The NetBSD Foundation nor the names of its
26: * contributors may be used to endorse or promote products derived
27: * from this software without specific prior written permission.
28: *
29: * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
30: * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
31: * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
32: * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
33: * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
34: * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
35: * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
36: * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
37: * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
38: * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
39: * POSSIBILITY OF SUCH DAMAGE.
40: */
41:
42: /*
43: ===============================================================================
44:
45: This C header file is part of the SoftFloat IEC/IEEE Floating-point
46: Arithmetic Package, Release 2a.
47:
48: Written by John R. Hauser. This work was made possible in part by the
49: International Computer Science Institute, located at Suite 600, 1947 Center
50: Street, Berkeley, California 94704. Funding was partially provided by the
51: National Science Foundation under grant MIP-9311980. The original version
52: of this code was written as part of a project to build a fixed-point vector
53: processor in collaboration with the University of California at Berkeley,
54: overseen by Profs. Nelson Morgan and John Wawrzynek. More information
55: is available through the Web page `http://HTTP.CS.Berkeley.EDU/~jhauser/
56: arithmetic/SoftFloat.html'.
57:
58: THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE. Although reasonable
59: effort has been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT
60: WILL AT TIMES RESULT IN INCORRECT BEHAVIOR. USE OF THIS SOFTWARE IS
61: RESTRICTED TO PERSONS AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL
62: RESPONSIBILITY FOR ALL LOSSES, COSTS, OR OTHER PROBLEMS ARISING FROM
63: THEIR OWN USE OF THE SOFTWARE, AND WHO ALSO EFFECTIVELY INDEMNIFY
64: (possibly via similar legal warning) JOHN HAUSER AND THE INTERNATIONAL
65: COMPUTER SCIENCE INSTITUTE AGAINST ALL LOSSES, COSTS, OR OTHER PROBLEMS
66: ARISING FROM THE USE OF THE SOFTWARE BY THEIR CUSTOMERS AND CLIENTS.
67:
68: Derivative works are acceptable, even for commercial purposes, so long as
69: (1) they include prominent notice that the work is derivative, and (2) they
70: include prominent notice akin to these four paragraphs for those parts of
71: this code that are retained.
72:
73: ===============================================================================
74: */
75:
76: #ifndef NO_IEEE
77:
78: #include <sys/types.h>
79:
80: #if !defined(_KERNEL) && !defined(_STANDALONE)
81: #include <ieeefp.h>
82: #else
83: #include "machine/ieeefp.h"
84: #endif
85: #include <sys/endian.h>
86:
87: /*
88: -------------------------------------------------------------------------------
89: The macro `FLOATX80' must be defined to enable the extended double-precision
90: floating-point format `floatx80'. If this macro is not defined, the
91: `floatx80' type will not be defined, and none of the functions that either
92: input or output the `floatx80' type will be defined. The same applies to
93: the `FLOAT128' macro and the quadruple-precision format `float128'.
94: -------------------------------------------------------------------------------
95: */
96: /* #define FLOATX80 */
97: /* #define FLOAT128 */
98:
99: /*
100: -------------------------------------------------------------------------------
101: Software IEC/IEEE floating-point types.
102: -------------------------------------------------------------------------------
103: */
104: typedef u_int32_t float32;
105: typedef u_int64_t float64;
106: #ifdef FLOATX80
107: typedef struct {
108: #if BYTE_ORDER == BIG_ENDIAN
109: u_int16_t high;
110: u_int64_t low;
111: #else
112: u_int64_t low;
113: u_int16_t high;
114: #endif
115: } floatx80;
116: #endif
117: #ifdef FLOAT128
118: typedef struct {
119: u_int64_t high, low;
120: } float128;
121: #endif
122:
123: /*
124: * Some of the global variables that used to be here have been removed for
125: * fairly obvious (defopt-MULTIPROCESSOR) reasons. The rest (which don't
126: * change dynamically) will be removed later. [ross]
127: */
128:
129: #define float_rounding_mode() fpgetround()
130:
131: /*
132: -------------------------------------------------------------------------------
133: Software IEC/IEEE floating-point underflow tininess-detection mode.
134: -------------------------------------------------------------------------------
135: */
136:
137: extern int float_detect_tininess;
138: enum {
139: float_tininess_after_rounding = 1,
140: float_tininess_before_rounding = 0
141: };
142:
143: /*
144: -------------------------------------------------------------------------------
145: Software IEC/IEEE floating-point rounding mode.
146: -------------------------------------------------------------------------------
147: */
148:
149: enum {
150: float_round_nearest_even = FP_RN,
151: float_round_to_zero = FP_RZ,
152: float_round_down = FP_RM,
153: float_round_up = FP_RP
154: };
155:
156: /*
157: -------------------------------------------------------------------------------
158: Software IEC/IEEE floating-point exception flags.
159: -------------------------------------------------------------------------------
160: */
161:
162: enum {
163: float_flag_inexact = FP_X_IMP,
164: float_flag_underflow = FP_X_UFL,
165: float_flag_overflow = FP_X_OFL,
166: float_flag_divbyzero = FP_X_DZ,
167: float_flag_invalid = FP_X_INV
168: };
169:
170: /*
171: -------------------------------------------------------------------------------
172: Software IEC/IEEE integer-to-floating-point conversion routines.
173: -------------------------------------------------------------------------------
174: */
175: float32 int32_to_float32( int );
176: float64 int32_to_float64( int );
177: #ifdef FLOATX80
178: floatx80 int32_to_floatx80( int );
179: #endif
180: #ifdef FLOAT128
181: float128 int32_to_float128( int );
182: #endif
183: #ifndef SOFTFLOAT_FOR_GCC /* __floatdi?f is in libgcc2.c */
184: float32 int64_to_float32( int64_t );
185: float64 int64_to_float64( int64_t );
186: #ifdef FLOATX80
187: floatx80 int64_to_floatx80( int64_t );
188: #endif
189: #ifdef FLOAT128
190: float128 int64_to_float128( int64_t );
191: #endif
192: #endif
193:
194: /*
195: -------------------------------------------------------------------------------
196: Software IEC/IEEE single-precision conversion routines.
197: -------------------------------------------------------------------------------
198: */
199: int float32_to_int32( float32 );
200: int float32_to_int32_round_to_zero( float32 );
201: #ifndef SOFTFLOAT_FOR_GCC /* __fix?fdi provided by libgcc2.c */
202: int64_t float32_to_int64( float32 );
203: int64_t float32_to_int64_round_to_zero( float32 );
204: #endif
205: float64 float32_to_float64( float32 );
206: #ifdef FLOATX80
207: floatx80 float32_to_floatx80( float32 );
208: #endif
209: #ifdef FLOAT128
210: float128 float32_to_float128( float32 );
211: #endif
212:
213: /*
214: -------------------------------------------------------------------------------
215: Software IEC/IEEE single-precision operations.
216: -------------------------------------------------------------------------------
217: */
218: float32 float32_round_to_int( float32 );
219: float32 float32_add( float32, float32 );
220: float32 float32_sub( float32, float32 );
221: float32 float32_mul( float32, float32 );
222: float32 float32_div( float32, float32 );
223: float32 float32_rem( float32, float32 );
224: float32 float32_sqrt( float32 );
225: int float32_eq( float32, float32 );
226: int float32_le( float32, float32 );
227: int float32_lt( float32, float32 );
228: int float32_eq_signaling( float32, float32 );
229: int float32_le_quiet( float32, float32 );
230: int float32_lt_quiet( float32, float32 );
231: #ifndef SOFTFLOAT_FOR_GCC
232: int float32_is_signaling_nan( float32 );
233: #endif
234:
235: /*
236: -------------------------------------------------------------------------------
237: Software IEC/IEEE double-precision conversion routines.
238: -------------------------------------------------------------------------------
239: */
240: int float64_to_int32( float64 );
241: int float64_to_int32_round_to_zero( float64 );
242: #ifndef SOFTFLOAT_FOR_GCC /* __fix?fdi provided by libgcc2.c */
243: int64_t float64_to_int64( float64 );
244: int64_t float64_to_int64_round_to_zero( float64 );
245: #endif
246: float32 float64_to_float32( float64 );
247: #ifdef FLOATX80
248: floatx80 float64_to_floatx80( float64 );
249: #endif
250: #ifdef FLOAT128
251: float128 float64_to_float128( float64 );
252: #endif
253:
254: /*
255: -------------------------------------------------------------------------------
256: Software IEC/IEEE double-precision operations.
257: -------------------------------------------------------------------------------
258: */
259: #define float64_default_nan 0xFFF8000000000000LL
260:
261: static __inline int
262: float64_is_nan(float64 a)
263: {
264: return 0xFFE0000000000000LL < a << 1;
265: }
266:
267: static __inline int
268: float64_is_signaling_nan(float64 a)
269: {
270: return (a >> 51 & 0xFFF) == 0xFFE && (a & 0x0007FFFFFFFFFFFFLL);
271: }
272:
273: float64 float64_round_to_int( float64 );
274: float64 float64_add( float64, float64 );
275: float64 float64_sub( float64, float64 );
276: float64 float64_mul( float64, float64 );
277: float64 float64_div( float64, float64 );
278: float64 float64_rem( float64, float64 );
279: float64 float64_sqrt( float64 );
280: int float64_eq( float64, float64 );
281: int float64_le( float64, float64 );
282: int float64_lt( float64, float64 );
283: int float64_eq_signaling( float64, float64 );
284: int float64_le_quiet( float64, float64 );
285: int float64_lt_quiet( float64, float64 );
286: #ifndef SOFTFLOAT_FOR_GCC
287: int float64_is_signaling_nan( float64 );
288: #endif
289:
290: #ifdef FLOATX80
291:
292: /*
293: -------------------------------------------------------------------------------
294: Software IEC/IEEE extended double-precision conversion routines.
295: -------------------------------------------------------------------------------
296: */
297: int floatx80_to_int32( floatx80 );
298: int floatx80_to_int32_round_to_zero( floatx80 );
299: int64_t floatx80_to_int64( floatx80 );
300: int64_t floatx80_to_int64_round_to_zero( floatx80 );
301: float32 floatx80_to_float32( floatx80 );
302: float64 floatx80_to_float64( floatx80 );
303: #ifdef FLOAT128
304: float128 floatx80_to_float128( floatx80 );
305: #endif
306:
307: /*
308: -------------------------------------------------------------------------------
309: Software IEC/IEEE extended double-precision rounding precision. Valid
310: values are 32, 64, and 80.
311: -------------------------------------------------------------------------------
312: */
313: extern int floatx80_rounding_precision;
314:
315: /*
316: -------------------------------------------------------------------------------
317: Software IEC/IEEE extended double-precision operations.
318: -------------------------------------------------------------------------------
319: */
320: floatx80 floatx80_round_to_int( floatx80 );
321: floatx80 floatx80_add( floatx80, floatx80 );
322: floatx80 floatx80_sub( floatx80, floatx80 );
323: floatx80 floatx80_mul( floatx80, floatx80 );
324: floatx80 floatx80_div( floatx80, floatx80 );
325: floatx80 floatx80_rem( floatx80, floatx80 );
326: floatx80 floatx80_sqrt( floatx80 );
327: int floatx80_eq( floatx80, floatx80 );
328: int floatx80_le( floatx80, floatx80 );
329: int floatx80_lt( floatx80, floatx80 );
330: int floatx80_eq_signaling( floatx80, floatx80 );
331: int floatx80_le_quiet( floatx80, floatx80 );
332: int floatx80_lt_quiet( floatx80, floatx80 );
333: int floatx80_is_signaling_nan( floatx80 );
334:
335: #endif
336:
337: #ifdef FLOAT128
338:
339: /*
340: -------------------------------------------------------------------------------
341: Software IEC/IEEE quadruple-precision conversion routines.
342: -------------------------------------------------------------------------------
343: */
344: int float128_to_int32( float128 );
345: int float128_to_int32_round_to_zero( float128 );
346: int64_t float128_to_int64( float128 );
347: int64_t float128_to_int64_round_to_zero( float128 );
348: float32 float128_to_float32( float128 );
349: float64 float128_to_float64( float128 );
350: #ifdef FLOATX80
351: floatx80 float128_to_floatx80( float128 );
352: #endif
353:
354: /*
355: -------------------------------------------------------------------------------
356: Software IEC/IEEE quadruple-precision operations.
357: -------------------------------------------------------------------------------
358: */
359: float128 float128_round_to_int( float128 );
360: float128 float128_add( float128, float128 );
361: float128 float128_sub( float128, float128 );
362: float128 float128_mul( float128, float128 );
363: float128 float128_div( float128, float128 );
364: float128 float128_rem( float128, float128 );
365: float128 float128_sqrt( float128 );
366: int float128_eq( float128, float128 );
367: int float128_le( float128, float128 );
368: int float128_lt( float128, float128 );
369: int float128_eq_signaling( float128, float128 );
370: int float128_le_quiet( float128, float128 );
371: int float128_lt_quiet( float128, float128 );
372: int float128_is_signaling_nan( float128 );
373:
374: #endif
375:
376: #endif /* !NO_IEEE */
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to softfloat.h CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / lib / libkern