?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
No empty .Rs/.Re
[netbsd-mini2440.git] / sys / arch / hppa / spmath / cnv_float.h
blobc444e1db76c628d60ebd322dd461dcd84972a95d
1 /* $NetBSD: cnv_float.h,v 1.2 2007/02/22 05:46:28 thorpej Exp $ */
2
3 /* $OpenBSD: cnv_float.h,v 1.5 2001/03/29 03:58:17 mickey Exp $ */
4
5 /*
6 * Copyright 1996 1995 by Open Software Foundation, Inc.
7 * All Rights Reserved
8 *
9 * Permission to use, copy, modify, and distribute this software and
10 * its documentation for any purpose and without fee is hereby granted,
11 * provided that the above copyright notice appears in all copies and
12 * that both the copyright notice and this permission notice appear in
13 * supporting documentation.
14 *
15 * OSF DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE
16 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
17 * FOR A PARTICULAR PURPOSE.
18 *
19 * IN NO EVENT SHALL OSF BE LIABLE FOR ANY SPECIAL, INDIRECT, OR
20 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
21 * LOSS OF USE, DATA OR PROFITS, WHETHER IN ACTION OF CONTRACT,
22 * NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
23 * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
24 */
25 /*
26 * pmk1.1
27 */
28 /*
29 * (c) Copyright 1986 HEWLETT-PACKARD COMPANY
30 *
31 * To anyone who acknowledges that this file is provided "AS IS"
32 * without any express or implied warranty:
33 * permission to use, copy, modify, and distribute this file
34 * for any purpose is hereby granted without fee, provided that
35 * the above copyright notice and this notice appears in all
36 * copies, and that the name of Hewlett-Packard Company not be
37 * used in advertising or publicity pertaining to distribution
38 * of the software without specific, written prior permission.
39 * Hewlett-Packard Company makes no representations about the
40 * suitability of this software for any purpose.
41 */
42
43 /*
44 * Some more constants
45 */
46 #define SGL_FX_MAX_EXP 30
47 #define DBL_FX_MAX_EXP 62
48 #define QUAD_FX_MAX_EXP 126
49
50
51 #define Dintp1(object) (object)
52 #define Dintp2(object) (object)
53
54 #define Qintp0(object) (object)
55 #define Qintp1(object) (object)
56 #define Qintp2(object) (object)
57 #define Qintp3(object) (object)
58
59
60 /*
61 * These macros will be used specifically by the convert instructions.
62 *
63 *
64 * Single format macros
65 */
66
67 #define Sgl_to_dbl_exponent(src_exponent,dest) \
68 Deposit_dexponent(dest,src_exponent+(DBL_BIAS-SGL_BIAS))
69
70 #define Sgl_to_dbl_mantissa(src_mantissa,destA,destB) \
71 Deposit_dmantissap1(destA,src_mantissa>>3); \
72 Dmantissap2(destB) = src_mantissa << 29
73
74 #define Sgl_isinexact_to_fix(sgl_value,exponent) \
75 ((exponent < (SGL_P - 1)) ? \
76 (Sall(sgl_value) << (SGL_EXP_LENGTH + 1 + exponent)) : false)
77
78 #define Int_isinexact_to_sgl(int_value) (int_value << (33 - SGL_EXP_LENGTH))
79
80 #define Sgl_roundnearest_from_int(int_value,sgl_value) \
81 if (int_value & 1<<(SGL_EXP_LENGTH - 2)) /* round bit */ \
82 if ((int_value << (34 - SGL_EXP_LENGTH)) || Slow(sgl_value)) \
83 Sall(sgl_value)++
84
85 #define Dint_isinexact_to_sgl(dint_valueA,dint_valueB) \
86 ((Dintp1(dint_valueA) << (33 - SGL_EXP_LENGTH)) || Dintp2(dint_valueB))
87
88 #define Sgl_roundnearest_from_dint(dint_valueA,dint_valueB,sgl_value) \
89 if (Dintp1(dint_valueA) & 1<<(SGL_EXP_LENGTH - 2)) \
90 if ((Dintp1(dint_valueA) << (34 - SGL_EXP_LENGTH)) || \
91 Dintp2(dint_valueB) || Slow(sgl_value)) Sall(sgl_value)++
92
93 #define Dint_isinexact_to_dbl(dint_value) \
94 (Dintp2(dint_value) << (33 - DBL_EXP_LENGTH))
95
96 #define Dbl_roundnearest_from_dint(dint_opndB,dbl_opndA,dbl_opndB) \
97 if (Dintp2(dint_opndB) & 1<<(DBL_EXP_LENGTH - 2)) \
98 if ((Dintp2(dint_opndB) << (34 -DBL_EXP_LENGTH)) || Dlowp2(dbl_opndB)) \
99 if ((++Dallp2(dbl_opndB))==0) Dallp1(dbl_opndA)++
100
101 #define Sgl_isone_roundbit(sgl_value,exponent) \
102 ((Sall(sgl_value) << (SGL_EXP_LENGTH + 1 + exponent)) >> 31)
103
104 #define Sgl_isone_stickybit(sgl_value,exponent) \
105 (exponent < (SGL_P - 2) ? \
106 Sall(sgl_value) << (SGL_EXP_LENGTH + 2 + exponent) : false)
107
108
109 /*
110 * Double format macros
111 */
112
113 #define Dbl_to_sgl_exponent(src_exponent,dest) \
114 dest = src_exponent + (SGL_BIAS - DBL_BIAS)
115
116 #define Dbl_to_sgl_mantissa(srcA,srcB,dest,inexact,guard,sticky,odd) \
117 Shiftdouble(Dmantissap1(srcA),Dmantissap2(srcB),29,dest); \
118 guard = Dbit3p2(srcB); \
119 sticky = Dallp2(srcB)<<4; \
120 inexact = guard | sticky; \
121 odd = Dbit2p2(srcB)
122
123 #define Dbl_to_sgl_denormalized(srcA,srcB,exp,dest,inexact,guard,sticky,odd,tiny) \
124 Deposit_dexponent(srcA,1); \
125 tiny = true; \
126 if (exp >= -2) { \
127 if (exp == 0) { \
128 inexact = Dallp2(srcB) << 3; \
129 guard = inexact >> 31; \
130 sticky = inexact << 1; \
131 Shiftdouble(Dmantissap1(srcA),Dmantissap2(srcB),29,dest); \
132 odd = dest << 31; \
133 if (inexact) { \
134 switch(Rounding_mode()) { \
135 case ROUNDPLUS: \
136 if (Dbl_iszero_sign(srcA)) { \
137 dest++; \
138 if (Sgl_isone_hidden(dest)) \
139 tiny = false; \
140 dest--; \
141 } \
142 break; \
143 case ROUNDMINUS: \
144 if (Dbl_isone_sign(srcA)) { \
145 dest++; \
146 if (Sgl_isone_hidden(dest)) \
147 tiny = false; \
148 dest--; \
149 } \
150 break; \
151 case ROUNDNEAREST: \
152 if (guard && (sticky || odd)) { \
153 dest++; \
154 if (Sgl_isone_hidden(dest)) \
155 tiny = false; \
156 dest--; \
157 } \
158 break; \
159 } \
160 } \
161 /* shift right by one to get correct result */ \
162 guard = odd; \
163 sticky = inexact; \
164 inexact |= guard; \
165 dest >>= 1; \
166 Deposit_dsign(srcA,0); \
167 Shiftdouble(Dallp1(srcA),Dallp2(srcB),30,dest); \
168 odd = dest << 31; \
169 } \
170 else { \
171 inexact = Dallp2(srcB) << (2 + exp); \
172 guard = inexact >> 31; \
173 sticky = inexact << 1; \
174 Deposit_dsign(srcA,0); \
175 if (exp == -2) dest = Dallp1(srcA); \
176 else Variable_shift_double(Dallp1(srcA),Dallp2(srcB),30-exp,dest); \
177 odd = dest << 31; \
178 } \
179 } \
180 else { \
181 Deposit_dsign(srcA,0); \
182 if (exp > (1 - SGL_P)) { \
183 dest = Dallp1(srcA) >> (- 2 - exp); \
184 inexact = Dallp1(srcA) << (34 + exp); \
185 guard = inexact >> 31; \
186 sticky = (inexact << 1) | Dallp2(srcB); \
187 inexact |= Dallp2(srcB); \
188 odd = dest << 31; \
189 } \
190 else { \
191 dest = 0; \
192 inexact = Dallp1(srcA) | Dallp2(srcB); \
193 if (exp == (1 - SGL_P)) { \
194 guard = Dhidden(srcA); \
195 sticky = Dmantissap1(srcA) | Dallp2(srcB); \
196 } \
197 else { \
198 guard = 0; \
199 sticky = inexact; \
200 } \
201 odd = 0; \
202 } \
203 } \
204 exp = 0
205
206 #define Dbl_isinexact_to_fix(dbl_valueA,dbl_valueB,exponent) \
207 (exponent < (DBL_P-33) ? \
208 Dallp2(dbl_valueB) || Dallp1(dbl_valueA) << (DBL_EXP_LENGTH+1+exponent) : \
209 (exponent < (DBL_P-1) ? Dallp2(dbl_valueB) << (exponent + (33-DBL_P)) : \
210 false))
211
212 #define Dbl_isoverflow_to_int(exponent,dbl_valueA,dbl_valueB) \
213 ((exponent > SGL_FX_MAX_EXP + 1) || Dsign(dbl_valueA)==0 || \
214 Dmantissap1(dbl_valueA)!=0 || (Dallp2(dbl_valueB)>>21)!=0 )
215
216 #define Dbl_isone_roundbit(dbl_valueA,dbl_valueB,exponent) \
217 ((exponent < (DBL_P - 33) ? \
218 Dallp1(dbl_valueA) >> ((30 - DBL_EXP_LENGTH) - exponent) : \
219 Dallp2(dbl_valueB) >> ((DBL_P - 2) - exponent)) & 1)
220
221 #define Dbl_isone_stickybit(dbl_valueA,dbl_valueB,exponent) \
222 (exponent < (DBL_P-34) ? \
223 (Dallp2(dbl_valueB) || Dallp1(dbl_valueA)<<(DBL_EXP_LENGTH+2+exponent)) : \
224 (exponent<(DBL_P-2) ? (Dallp2(dbl_valueB) << (exponent + (34-DBL_P))) : \
225 false))
226
227
228 /* Int macros */
229
230 #define Int_from_sgl_mantissa(sgl_value,exponent) \
231 Sall(sgl_value) = \
232 (unsigned)(Sall(sgl_value) << SGL_EXP_LENGTH)>>(31 - exponent)
233
234 #define Int_from_dbl_mantissa(dbl_valueA,dbl_valueB,exponent) \
235 Shiftdouble(Dallp1(dbl_valueA),Dallp2(dbl_valueB),22,Dallp1(dbl_valueA)); \
236 if (exponent < 31) Dallp1(dbl_valueA) >>= 30 - exponent; \
237 else Dallp1(dbl_valueA) <<= 1
238
239 #define Int_negate(int_value) int_value = -int_value
240
241
242 /* Dint macros */
243
244 #define Dint_from_sgl_mantissa(sgl_value,exponent,dresultA,dresultB) \
245 {Sall(sgl_value) <<= SGL_EXP_LENGTH; /* left-justify */ \
246 if (exponent <= 31) { \
247 Dintp1(dresultA) = 0; \
248 Dintp2(dresultB) = (unsigned)Sall(sgl_value) >> (31 - exponent); \
249 } \
250 else { \
251 Dintp1(dresultA) = Sall(sgl_value) >> (63 - exponent); \
252 Dintp2(dresultB) = Sall(sgl_value) << (exponent - 31); \
253 }}
254
255
256 #define Dint_from_dbl_mantissa(dbl_valueA,dbl_valueB,exponent,destA,destB) \
257 {if (exponent < 32) { \
258 Dintp1(destA) = 0; \
259 if (exponent <= 20) \
260 Dintp2(destB) = Dallp1(dbl_valueA) >> (20-(exponent)); \
261 else Variable_shift_double(Dallp1(dbl_valueA),Dallp2(dbl_valueB), \
262 (52-(exponent)),Dintp2(destB)); \
263 } \
264 else { \
265 if (exponent <= 52) { \
266 Dintp1(destA) = Dallp1(dbl_valueA) >> (52-(exponent)); \
267 if (exponent == 52) Dintp2(destB) = Dallp2(dbl_valueB); \
268 else Variable_shift_double(Dallp1(dbl_valueA),Dallp2(dbl_valueB), \
269 52-exponent,Dintp2(destB)); \
270 } \
271 else { \
272 Variable_shift_double(Dallp1(dbl_valueA),Dallp2(dbl_valueB), \
273 84-exponent,Dintp1(destA)); \
274 Dintp2(destB) = Dallp2(dbl_valueB) << ((exponent)-52); \
275 } \
276 }}
277
278 #define Dint_setzero(dresultA,dresultB) \
279 Dintp1(dresultA) = 0; \
280 Dintp2(dresultB) = 0
281
282 #define Dint_setone_sign(dresultA,dresultB) \
283 Dintp1(dresultA) = ~Dintp1(dresultA); \
284 if ((Dintp2(dresultB) = -Dintp2(dresultB)) == 0) Dintp1(dresultA)++
285
286 #define Dint_set_minint(dresultA,dresultB) \
287 Dintp1(dresultA) = 1<<31; \
288 Dintp2(dresultB) = 0
289
290 #define Dint_isone_lowp2(dresultB) (Dintp2(dresultB) & 01)
291
292 #define Dint_increment(dresultA,dresultB) \
293 if ((++Dintp2(dresultB))==0) Dintp1(dresultA)++
294
295 #define Dint_decrement(dresultA,dresultB) \
296 if ((Dintp2(dresultB)--)==0) Dintp1(dresultA)--
297
298 #define Dint_negate(dresultA,dresultB) \
299 Dintp1(dresultA) = ~Dintp1(dresultA); \
300 if ((Dintp2(dresultB) = -Dintp2(dresultB))==0) Dintp1(dresultA)++
301
302 #define Dint_copyfromptr(src,destA,destB) \
303 Dintp1(destA) = src->wd0; \
304 Dintp2(destB) = src->wd1
305 #define Dint_copytoptr(srcA,srcB,dest) \
306 dest->wd0 = Dintp1(srcA); \
307 dest->wd1 = Dintp2(srcB)
308
309
310 /* other macros */
311
312 #define Find_ms_one_bit(value, position) \
313 { \
314 int var; \
315 for (var=8; var >=1; var >>= 1) { \
316 if (value >> (32 - position)) \
317 position -= var; \
318 else position += var; \
319 } \
320 if ((value >> (32 - position)) == 0) \
321 position--; \
322 else position -= 2; \
323 }
324
325 /*
326 * The following 4 functions handle the assignment of a floating point
327 * number to a 32-bit integer in cases where the floating point number
328 * is too large (or small) to fit in the integer field.
329 *
330 * In all these cases, HP-UX would return an UNIMPLEMENTEDEXCEPTION
331 * resulting in a SIGFPE being sent to the process. For BSD's math
332 * library (and various other applications), this was unacceptable.
333 * As a result, we now return maxint/minint (like most other OS's)
334 * and either return an INEXACTEXCEPTION (SIGFPE) or set the inexact
335 * flag (so that the program may continue execution).
336 *
337 * After discussing this with Jerry Huck @ HP, the one case where we
338 * differ from BSD is for programs that try to convert a NaN to an
339 * integer; in this case, we will return an UNIMPLEMENTEDEXCEPTION
340 * since doing anything else would be completely unreasonable.
341 *
342 * jef
343 */
344
345 #define Dbl_return_overflow(srcp1, srcp2, resultp) \
346 { \
347 if (Dbl_isnan(srcp1, srcp2)) \
348 return(UNIMPLEMENTEDEXCEPTION); \
349 if (Dbl_iszero_sign(srcp1)) \
350 *resultp = 0x7fffffff; \
351 else \
352 *resultp = 0x80000000; \
353 if (Is_overflowtrap_enabled()) { \
354 if (Is_inexacttrap_enabled()) \
355 return(OVERFLOWEXCEPTION|INEXACTEXCEPTION); \
356 else \
357 Set_inexactflag(); \
358 return(OVERFLOWEXCEPTION); \
359 } \
360 return(NOEXCEPTION); \
361 }
362
363 #define Dbl_return_overflow_dbl(srcp1, srcp2, resultp) \
364 { \
365 if (Dbl_isnan(srcp1, srcp2)) \
366 return(UNIMPLEMENTEDEXCEPTION); \
367 if (Dbl_iszero_sign(srcp1)) { \
368 Dint_copytoptr(0x7fffffff,0xffffffff,resultp); \
369 } else { \
370 Dint_copytoptr(0x80000000,0x00000000,resultp); \
371 } \
372 if (Is_overflowtrap_enabled()) { \
373 if (Is_inexacttrap_enabled()) \
374 return(OVERFLOWEXCEPTION|INEXACTEXCEPTION); \
375 else \
376 Set_inexactflag(); \
377 return(OVERFLOWEXCEPTION); \
378 } \
379 return(NOEXCEPTION); \
380 }
381
382 #define Sgl_return_overflow(src, resultp) \
383 { \
384 if (Sgl_isnan(src)) \
385 return(UNIMPLEMENTEDEXCEPTION); \
386 if (Sgl_iszero_sign(src)) \
387 *resultp = 0x7fffffff; \
388 else \
389 *resultp = 0x80000000; \
390 if (Is_overflowtrap_enabled()) { \
391 if (Is_inexacttrap_enabled()) \
392 return(OVERFLOWEXCEPTION|INEXACTEXCEPTION); \
393 else \
394 Set_inexactflag(); \
395 return(OVERFLOWEXCEPTION); \
396 } \
397 return(NOEXCEPTION); \
398 }
399
400 #define Sgl_return_overflow_dbl(src, resultp) \
401 { \
402 if (Sgl_isnan(src)) \
403 return(UNIMPLEMENTEDEXCEPTION); \
404 if (Sgl_iszero_sign(src)) { \
405 Dint_copytoptr(0x7fffffff,0xffffffff,resultp); \
406 } else { \
407 Dint_copytoptr(0x80000000,0x00000000,resultp); \
408 } \
409 if (Is_overflowtrap_enabled()) { \
410 if (Is_inexacttrap_enabled()) \
411 return(OVERFLOWEXCEPTION|INEXACTEXCEPTION); \
412 else \
413 Set_inexactflag(); \
414 return(OVERFLOWEXCEPTION); \
415 } \
416 return(NOEXCEPTION); \
417 }
418
419 int sgl_to_sgl_fcnvfx(sgl_floating_point *, sgl_floating_point *, unsigned int *);
420 int sgl_to_dbl_fcnvfx(sgl_floating_point *, dbl_integer *, unsigned int *);
421 int dbl_to_sgl_fcnvfx(dbl_floating_point *, int *, unsigned int *);
422 int dbl_to_dbl_fcnvfx(dbl_floating_point *, dbl_integer *, unsigned int *);
423
424 int sgl_to_sgl_fcnvfxt(sgl_floating_point *, int *, unsigned int *);
425 int sgl_to_dbl_fcnvfxt(sgl_floating_point *, dbl_integer *, unsigned int *);
426 int dbl_to_sgl_fcnvfxt(dbl_floating_point *, int *, unsigned int *);
427 int dbl_to_dbl_fcnvfxt(dbl_floating_point *, dbl_integer *, unsigned int *);
428
429 int sgl_to_sgl_fcnvxf(int *, sgl_floating_point *, unsigned int *);
430 int sgl_to_dbl_fcnvxf(int *, dbl_floating_point *, unsigned int *);
431 int dbl_to_sgl_fcnvxf(dbl_integer *, sgl_floating_point *, unsigned int *);
432 int dbl_to_dbl_fcnvxf(dbl_integer *, dbl_floating_point *, unsigned int *);
433
434
435
NetBSD on the FriendlyARM MINI2440