]>
Commit | Line | Data |
---|---|---|
3352b62b N |
1 | /* $NetBSD: softfloat.h,v 1.10 2013/04/24 18:04:46 matt Exp $ */\r |
2 | \r | |
3 | /* This is a derivative work. */\r | |
4 | \r | |
5 | /*\r | |
6 | ===============================================================================\r | |
7 | \r | |
8 | This C header file is part of the SoftFloat IEC/IEEE Floating-point\r | |
9 | Arithmetic Package, Release 2a.\r | |
10 | \r | |
11 | Written by John R. Hauser. This work was made possible in part by the\r | |
12 | International Computer Science Institute, located at Suite 600, 1947 Center\r | |
13 | Street, Berkeley, California 94704. Funding was partially provided by the\r | |
14 | National Science Foundation under grant MIP-9311980. The original version\r | |
15 | of this code was written as part of a project to build a fixed-point vector\r | |
16 | processor in collaboration with the University of California at Berkeley,\r | |
17 | overseen by Profs. Nelson Morgan and John Wawrzynek. More information\r | |
18 | is available through the Web page `http://HTTP.CS.Berkeley.EDU/~jhauser/\r | |
19 | arithmetic/SoftFloat.html'.\r | |
20 | \r | |
21 | THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE. Although reasonable effort\r | |
22 | has been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT\r | |
23 | TIMES RESULT IN INCORRECT BEHAVIOR. USE OF THIS SOFTWARE IS RESTRICTED TO\r | |
24 | PERSONS AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ANY\r | |
25 | AND ALL LOSSES, COSTS, OR OTHER PROBLEMS ARISING FROM ITS USE.\r | |
26 | \r | |
27 | Derivative works are acceptable, even for commercial purposes, so long as\r | |
28 | (1) they include prominent notice that the work is derivative, and (2) they\r | |
29 | include prominent notice akin to these four paragraphs for those parts of\r | |
30 | this code that are retained.\r | |
31 | \r | |
32 | ===============================================================================\r | |
33 | */\r | |
34 | \r | |
35 | /*\r | |
36 | -------------------------------------------------------------------------------\r | |
37 | The macro `FLOATX80' must be defined to enable the extended double-precision\r | |
38 | floating-point format `floatx80'. If this macro is not defined, the\r | |
39 | `floatx80' type will not be defined, and none of the functions that either\r | |
40 | input or output the `floatx80' type will be defined. The same applies to\r | |
41 | the `FLOAT128' macro and the quadruple-precision format `float128'.\r | |
42 | -------------------------------------------------------------------------------\r | |
43 | */\r | |
44 | /* #define FLOATX80 */\r | |
45 | /* #define FLOAT128 */\r | |
46 | \r | |
47 | #include <stdint.h>\r | |
48 | #include <machine/ieeefp.h>\r | |
49 | \r | |
50 | /*\r | |
51 | -------------------------------------------------------------------------------\r | |
52 | Software IEC/IEEE floating-point types.\r | |
53 | -------------------------------------------------------------------------------\r | |
54 | */\r | |
55 | typedef unsigned int float32;\r | |
56 | typedef unsigned long long float64;\r | |
57 | #ifdef FLOATX80\r | |
58 | typedef struct {\r | |
59 | unsigned short high;\r | |
60 | unsigned long long low;\r | |
61 | } floatx80;\r | |
62 | #endif\r | |
63 | #ifdef FLOAT128\r | |
64 | typedef struct {\r | |
65 | unsigned long long high, low;\r | |
66 | } float128;\r | |
67 | #endif\r | |
68 | \r | |
69 | /*\r | |
70 | -------------------------------------------------------------------------------\r | |
71 | Software IEC/IEEE floating-point underflow tininess-detection mode.\r | |
72 | -------------------------------------------------------------------------------\r | |
73 | */\r | |
74 | #ifndef SOFTFLOAT_FOR_GCC\r | |
75 | extern int float_detect_tininess;\r | |
76 | #endif\r | |
77 | enum {\r | |
78 | float_tininess_after_rounding = 0,\r | |
79 | float_tininess_before_rounding = 1\r | |
80 | };\r | |
81 | \r | |
82 | /*\r | |
83 | -------------------------------------------------------------------------------\r | |
84 | Software IEC/IEEE floating-point rounding mode.\r | |
85 | -------------------------------------------------------------------------------\r | |
86 | */\r | |
87 | extern fp_rnd float_rounding_mode;\r | |
88 | #define float_round_nearest_even FP_RN\r | |
89 | #define float_round_to_zero FP_RZ\r | |
90 | #define float_round_down FP_RM\r | |
91 | #define float_round_up FP_RP\r | |
92 | \r | |
93 | /*\r | |
94 | -------------------------------------------------------------------------------\r | |
95 | Software IEC/IEEE floating-point exception flags.\r | |
96 | -------------------------------------------------------------------------------\r | |
97 | */\r | |
98 | extern fp_except float_exception_flags;\r | |
99 | extern fp_except float_exception_mask;\r | |
100 | enum {\r | |
101 | float_flag_inexact = FP_X_IMP,\r | |
102 | float_flag_underflow = FP_X_UFL,\r | |
103 | float_flag_overflow = FP_X_OFL,\r | |
104 | float_flag_divbyzero = FP_X_DZ,\r | |
105 | float_flag_invalid = FP_X_INV\r | |
106 | };\r | |
107 | \r | |
108 | /*\r | |
109 | -------------------------------------------------------------------------------\r | |
110 | Routine to raise any or all of the software IEC/IEEE floating-point\r | |
111 | exception flags.\r | |
112 | -------------------------------------------------------------------------------\r | |
113 | */\r | |
114 | void float_raise( fp_except );\r | |
115 | \r | |
116 | /*\r | |
117 | -------------------------------------------------------------------------------\r | |
118 | Software IEC/IEEE integer-to-floating-point conversion routines.\r | |
119 | -------------------------------------------------------------------------------\r | |
120 | */\r | |
121 | float32 int32_to_float32( int32 );\r | |
122 | float32 uint32_to_float32( uint32 );\r | |
123 | float64 int32_to_float64( int32 );\r | |
124 | float64 uint32_to_float64( uint32 );\r | |
125 | #ifdef FLOATX80\r | |
126 | floatx80 int32_to_floatx80( int32 );\r | |
127 | floatx80 uint32_to_floatx80( uint32 );\r | |
128 | #endif\r | |
129 | #ifdef FLOAT128\r | |
130 | float128 int32_to_float128( int32 );\r | |
131 | float128 uint32_to_float128( uint32 );\r | |
132 | #endif\r | |
133 | #ifndef SOFTFLOAT_FOR_GCC /* __floatdi?f is in libgcc2.c */\r | |
134 | float32 int64_to_float32( long long );\r | |
135 | float64 int64_to_float64( long long );\r | |
136 | #ifdef FLOATX80\r | |
137 | floatx80 int64_to_floatx80( long long );\r | |
138 | #endif\r | |
139 | #ifdef FLOAT128\r | |
140 | float128 int64_to_float128( long long );\r | |
141 | #endif\r | |
142 | #endif\r | |
143 | \r | |
144 | /*\r | |
145 | -------------------------------------------------------------------------------\r | |
146 | Software IEC/IEEE single-precision conversion routines.\r | |
147 | -------------------------------------------------------------------------------\r | |
148 | */\r | |
149 | int float32_to_int32( float32 );\r | |
150 | int float32_to_int32_round_to_zero( float32 );\r | |
151 | #if defined(SOFTFLOAT_FOR_GCC) && defined(SOFTFLOAT_NEED_FIXUNS)\r | |
152 | unsigned int float32_to_uint32_round_to_zero( float32 );\r | |
153 | #endif\r | |
154 | #ifndef SOFTFLOAT_FOR_GCC /* __fix?fdi provided by libgcc2.c */\r | |
155 | long long float32_to_int64( float32 );\r | |
156 | long long float32_to_int64_round_to_zero( float32 );\r | |
157 | #endif\r | |
158 | float64 float32_to_float64( float32 );\r | |
159 | #ifdef FLOATX80\r | |
160 | floatx80 float32_to_floatx80( float32 );\r | |
161 | #endif\r | |
162 | #ifdef FLOAT128\r | |
163 | float128 float32_to_float128( float32 );\r | |
164 | #endif\r | |
165 | \r | |
166 | /*\r | |
167 | -------------------------------------------------------------------------------\r | |
168 | Software IEC/IEEE single-precision operations.\r | |
169 | -------------------------------------------------------------------------------\r | |
170 | */\r | |
171 | float32 float32_round_to_int( float32 );\r | |
172 | float32 float32_add( float32, float32 );\r | |
173 | float32 float32_sub( float32, float32 );\r | |
174 | float32 float32_mul( float32, float32 );\r | |
175 | float32 float32_div( float32, float32 );\r | |
176 | float32 float32_rem( float32, float32 );\r | |
177 | float32 float32_sqrt( float32 );\r | |
178 | int float32_eq( float32, float32 );\r | |
179 | int float32_le( float32, float32 );\r | |
180 | int float32_lt( float32, float32 );\r | |
181 | int float32_eq_signaling( float32, float32 );\r | |
182 | int float32_le_quiet( float32, float32 );\r | |
183 | int float32_lt_quiet( float32, float32 );\r | |
184 | #ifndef SOFTFLOAT_FOR_GCC\r | |
185 | int float32_is_signaling_nan( float32 );\r | |
186 | #endif\r | |
187 | \r | |
188 | /*\r | |
189 | -------------------------------------------------------------------------------\r | |
190 | Software IEC/IEEE double-precision conversion routines.\r | |
191 | -------------------------------------------------------------------------------\r | |
192 | */\r | |
193 | int float64_to_int32( float64 );\r | |
194 | int float64_to_int32_round_to_zero( float64 );\r | |
195 | #if defined(SOFTFLOAT_FOR_GCC) && defined(SOFTFLOAT_NEED_FIXUNS)\r | |
196 | unsigned int float64_to_uint32_round_to_zero( float64 );\r | |
197 | #endif\r | |
198 | #ifndef SOFTFLOAT_FOR_GCC /* __fix?fdi provided by libgcc2.c */\r | |
199 | long long float64_to_int64( float64 );\r | |
200 | long long float64_to_int64_round_to_zero( float64 );\r | |
201 | #endif\r | |
202 | float32 float64_to_float32( float64 );\r | |
203 | #ifdef FLOATX80\r | |
204 | floatx80 float64_to_floatx80( float64 );\r | |
205 | #endif\r | |
206 | #ifdef FLOAT128\r | |
207 | float128 float64_to_float128( float64 );\r | |
208 | #endif\r | |
209 | \r | |
210 | /*\r | |
211 | -------------------------------------------------------------------------------\r | |
212 | Software IEC/IEEE double-precision operations.\r | |
213 | -------------------------------------------------------------------------------\r | |
214 | */\r | |
215 | float64 float64_round_to_int( float64 );\r | |
216 | float64 float64_add( float64, float64 );\r | |
217 | float64 float64_sub( float64, float64 );\r | |
218 | float64 float64_mul( float64, float64 );\r | |
219 | float64 float64_div( float64, float64 );\r | |
220 | float64 float64_rem( float64, float64 );\r | |
221 | float64 float64_sqrt( float64 );\r | |
222 | int float64_eq( float64, float64 );\r | |
223 | int float64_le( float64, float64 );\r | |
224 | int float64_lt( float64, float64 );\r | |
225 | int float64_eq_signaling( float64, float64 );\r | |
226 | int float64_le_quiet( float64, float64 );\r | |
227 | int float64_lt_quiet( float64, float64 );\r | |
228 | #ifndef SOFTFLOAT_FOR_GCC\r | |
229 | int float64_is_signaling_nan( float64 );\r | |
230 | #endif\r | |
231 | \r | |
232 | #ifdef FLOATX80\r | |
233 | \r | |
234 | /*\r | |
235 | -------------------------------------------------------------------------------\r | |
236 | Software IEC/IEEE extended double-precision conversion routines.\r | |
237 | -------------------------------------------------------------------------------\r | |
238 | */\r | |
239 | int floatx80_to_int32( floatx80 );\r | |
240 | int floatx80_to_int32_round_to_zero( floatx80 );\r | |
241 | long long floatx80_to_int64( floatx80 );\r | |
242 | long long floatx80_to_int64_round_to_zero( floatx80 );\r | |
243 | float32 floatx80_to_float32( floatx80 );\r | |
244 | float64 floatx80_to_float64( floatx80 );\r | |
245 | #ifdef FLOAT128\r | |
246 | float128 floatx80_to_float128( floatx80 );\r | |
247 | #endif\r | |
248 | \r | |
249 | /*\r | |
250 | -------------------------------------------------------------------------------\r | |
251 | Software IEC/IEEE extended double-precision rounding precision. Valid\r | |
252 | values are 32, 64, and 80.\r | |
253 | -------------------------------------------------------------------------------\r | |
254 | */\r | |
255 | extern int floatx80_rounding_precision;\r | |
256 | \r | |
257 | /*\r | |
258 | -------------------------------------------------------------------------------\r | |
259 | Software IEC/IEEE extended double-precision operations.\r | |
260 | -------------------------------------------------------------------------------\r | |
261 | */\r | |
262 | floatx80 floatx80_round_to_int( floatx80 );\r | |
263 | floatx80 floatx80_add( floatx80, floatx80 );\r | |
264 | floatx80 floatx80_sub( floatx80, floatx80 );\r | |
265 | floatx80 floatx80_mul( floatx80, floatx80 );\r | |
266 | floatx80 floatx80_div( floatx80, floatx80 );\r | |
267 | floatx80 floatx80_rem( floatx80, floatx80 );\r | |
268 | floatx80 floatx80_sqrt( floatx80 );\r | |
269 | int floatx80_eq( floatx80, floatx80 );\r | |
270 | int floatx80_le( floatx80, floatx80 );\r | |
271 | int floatx80_lt( floatx80, floatx80 );\r | |
272 | int floatx80_eq_signaling( floatx80, floatx80 );\r | |
273 | int floatx80_le_quiet( floatx80, floatx80 );\r | |
274 | int floatx80_lt_quiet( floatx80, floatx80 );\r | |
275 | int floatx80_is_signaling_nan( floatx80 );\r | |
276 | \r | |
277 | #endif\r | |
278 | \r | |
279 | #ifdef FLOAT128\r | |
280 | \r | |
281 | /*\r | |
282 | -------------------------------------------------------------------------------\r | |
283 | Software IEC/IEEE quadruple-precision conversion routines.\r | |
284 | -------------------------------------------------------------------------------\r | |
285 | */\r | |
286 | int float128_to_int32( float128 );\r | |
287 | int float128_to_int32_round_to_zero( float128 );\r | |
288 | long long float128_to_int64( float128 );\r | |
289 | long long float128_to_int64_round_to_zero( float128 );\r | |
290 | float32 float128_to_float32( float128 );\r | |
291 | float64 float128_to_float64( float128 );\r | |
292 | #ifdef FLOATX80\r | |
293 | floatx80 float128_to_floatx80( float128 );\r | |
294 | #endif\r | |
295 | \r | |
296 | /*\r | |
297 | -------------------------------------------------------------------------------\r | |
298 | Software IEC/IEEE quadruple-precision operations.\r | |
299 | -------------------------------------------------------------------------------\r | |
300 | */\r | |
301 | float128 float128_round_to_int( float128 );\r | |
302 | float128 float128_add( float128, float128 );\r | |
303 | float128 float128_sub( float128, float128 );\r | |
304 | float128 float128_mul( float128, float128 );\r | |
305 | float128 float128_div( float128, float128 );\r | |
306 | float128 float128_rem( float128, float128 );\r | |
307 | float128 float128_sqrt( float128 );\r | |
308 | int float128_eq( float128, float128 );\r | |
309 | int float128_le( float128, float128 );\r | |
310 | int float128_lt( float128, float128 );\r | |
311 | int float128_eq_signaling( float128, float128 );\r | |
312 | int float128_le_quiet( float128, float128 );\r | |
313 | int float128_lt_quiet( float128, float128 );\r | |
314 | int float128_is_signaling_nan( float128 );\r | |
315 | \r | |
316 | #endif\r |