![[BACK]](/icons/back.gif){kind=icon}
Return to fcnvff.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / hppa / spmath|
Return to fcnvff.c CVS log | Up to [local] / sys / arch / hppa / spmath |
1.1 nbrk 1: /* $OpenBSD: fcnvff.c,v 1.7 2003/04/10 17:27:58 mickey Exp $ */
2: /*
3: (c) Copyright 1986 HEWLETT-PACKARD COMPANY
4: To anyone who acknowledges that this file is provided "AS IS"
5: without any express or implied warranty:
6: permission to use, copy, modify, and distribute this file
7: for any purpose is hereby granted without fee, provided that
8: the above copyright notice and this notice appears in all
9: copies, and that the name of Hewlett-Packard Company not be
10: used in advertising or publicity pertaining to distribution
11: of the software without specific, written prior permission.
12: Hewlett-Packard Company makes no representations about the
13: suitability of this software for any purpose.
14: */
15: /* @(#)fcnvff.c: Revision: 2.8.88.1 Date: 93/12/07 15:06:09 */
16:
17: #include "float.h"
18: #include "sgl_float.h"
19: #include "dbl_float.h"
20: #include "cnv_float.h"
21:
22: /*
23: * Single Floating-point to Double Floating-point
24: */
25: /*ARGSUSED*/
26: int
27: sgl_to_dbl_fcnvff(srcptr, null, dstptr, status)
28: sgl_floating_point *srcptr, *null;
29: dbl_floating_point *dstptr;
30: unsigned int *status;
31: {
32: register unsigned int src, resultp1, resultp2;
33: register int src_exponent;
34:
35: src = *srcptr;
36: src_exponent = Sgl_exponent(src);
37: Dbl_allp1(resultp1) = Sgl_all(src); /* set sign of result */
38: /*
39: * Test for NaN or infinity
40: */
41: if (src_exponent == SGL_INFINITY_EXPONENT) {
42: /*
43: * determine if NaN or infinity
44: */
45: if (Sgl_iszero_mantissa(src)) {
46: /*
47: * is infinity; want to return double infinity
48: */
49: Dbl_setinfinity_exponentmantissa(resultp1,resultp2);
50: Dbl_copytoptr(resultp1,resultp2,dstptr);
51: return(NOEXCEPTION);
52: }
53: else {
54: /*
55: * is NaN; signaling or quiet?
56: */
57: if (Sgl_isone_signaling(src)) {
58: /* trap if INVALIDTRAP enabled */
59: if (Is_invalidtrap_enabled())
60: return(INVALIDEXCEPTION);
61: /* make NaN quiet */
62: else {
63: Set_invalidflag();
64: Sgl_set_quiet(src);
65: }
66: }
67: /*
68: * NaN is quiet, return as double NaN
69: */
70: Dbl_setinfinity_exponent(resultp1);
71: Sgl_to_dbl_mantissa(src,resultp1,resultp2);
72: Dbl_copytoptr(resultp1,resultp2,dstptr);
73: return(NOEXCEPTION);
74: }
75: }
76: /*
77: * Test for zero or denormalized
78: */
79: if (src_exponent == 0) {
80: /*
81: * determine if zero or denormalized
82: */
83: if (Sgl_isnotzero_mantissa(src)) {
84: /*
85: * is denormalized; want to normalize
86: */
87: Sgl_clear_signexponent(src);
88: Sgl_leftshiftby1(src);
89: Sgl_normalize(src,src_exponent);
90: Sgl_to_dbl_exponent(src_exponent,resultp1);
91: Sgl_to_dbl_mantissa(src,resultp1,resultp2);
92: }
93: else {
94: Dbl_setzero_exponentmantissa(resultp1,resultp2);
95: }
96: Dbl_copytoptr(resultp1,resultp2,dstptr);
97: return(NOEXCEPTION);
98: }
99: /*
100: * No special cases, just complete the conversion
101: */
102: Sgl_to_dbl_exponent(src_exponent, resultp1);
103: Sgl_to_dbl_mantissa(Sgl_mantissa(src), resultp1,resultp2);
104: Dbl_copytoptr(resultp1,resultp2,dstptr);
105: return(NOEXCEPTION);
106: }
107:
108: /*
109: * Double Floating-point to Single Floating-point
110: */
111: /*ARGSUSED*/
112: int
113: dbl_to_sgl_fcnvff(srcptr, null, dstptr, status)
114: dbl_floating_point *srcptr, *null;
115: sgl_floating_point *dstptr;
116: unsigned int *status;
117: {
118: register unsigned int srcp1, srcp2, result;
119: register int src_exponent, dest_exponent, dest_mantissa;
120: register int inexact = FALSE, guardbit = FALSE, stickybit = FALSE;
121: register int lsb_odd = FALSE;
122: int is_tiny;
123:
124: Dbl_copyfromptr(srcptr,srcp1,srcp2);
125: src_exponent = Dbl_exponent(srcp1);
126: Sgl_all(result) = Dbl_allp1(srcp1); /* set sign of result */
127: /*
128: * Test for NaN or infinity
129: */
130: if (src_exponent == DBL_INFINITY_EXPONENT) {
131: /*
132: * determine if NaN or infinity
133: */
134: if (Dbl_iszero_mantissa(srcp1,srcp2)) {
135: /*
136: * is infinity; want to return single infinity
137: */
138: Sgl_setinfinity_exponentmantissa(result);
139: *dstptr = result;
140: return(NOEXCEPTION);
141: }
142: /*
143: * is NaN; signaling or quiet?
144: */
145: if (Dbl_isone_signaling(srcp1)) {
146: /* trap if INVALIDTRAP enabled */
147: if (Is_invalidtrap_enabled()) return(INVALIDEXCEPTION);
148: else {
149: Set_invalidflag();
150: /* make NaN quiet */
151: Dbl_set_quiet(srcp1);
152: }
153: }
154: /*
155: * NaN is quiet, return as single NaN
156: */
157: Sgl_setinfinity_exponent(result);
158: Sgl_set_mantissa(result,Dallp1(srcp1)<<3 | Dallp2(srcp2)>>29);
159: if (Sgl_iszero_mantissa(result)) Sgl_set_quiet(result);
160: *dstptr = result;
161: return(NOEXCEPTION);
162: }
163: /*
164: * Generate result
165: */
166: Dbl_to_sgl_exponent(src_exponent,dest_exponent);
167: if (dest_exponent > 0) {
168: Dbl_to_sgl_mantissa(srcp1,srcp2,dest_mantissa,inexact,guardbit,
169: stickybit,lsb_odd);
170: }
171: else {
172: if (Dbl_iszero_exponentmantissa(srcp1,srcp2)){
173: Sgl_setzero_exponentmantissa(result);
174: *dstptr = result;
175: return(NOEXCEPTION);
176: }
177: if (Is_underflowtrap_enabled()) {
178: Dbl_to_sgl_mantissa(srcp1,srcp2,dest_mantissa,inexact,
179: guardbit,stickybit,lsb_odd);
180: }
181: else {
182: /* compute result, determine inexact info,
183: * and set Underflowflag if appropriate
184: */
185: Dbl_to_sgl_denormalized(srcp1,srcp2,dest_exponent,
186: dest_mantissa,inexact,guardbit,stickybit,lsb_odd,
187: is_tiny);
188: }
189: }
190: /*
191: * Now round result if not exact
192: */
193: if (inexact) {
194: switch (Rounding_mode()) {
195: case ROUNDPLUS:
196: if (Sgl_iszero_sign(result)) dest_mantissa++;
197: break;
198: case ROUNDMINUS:
199: if (Sgl_isone_sign(result)) dest_mantissa++;
200: break;
201: case ROUNDNEAREST:
202: if (guardbit) {
203: if (stickybit || lsb_odd) dest_mantissa++;
204: }
205: }
206: }
207: Sgl_set_exponentmantissa(result,dest_mantissa);
208:
209: /*
210: * check for mantissa overflow after rounding
211: */
212: if ((dest_exponent>0 || Is_underflowtrap_enabled()) &&
213: Sgl_isone_hidden(result)) dest_exponent++;
214:
215: /*
216: * Test for overflow
217: */
218: if (dest_exponent >= SGL_INFINITY_EXPONENT) {
219: /* trap if OVERFLOWTRAP enabled */
220: if (Is_overflowtrap_enabled()) {
221: /*
222: * Check for gross overflow
223: */
224: if (dest_exponent >= SGL_INFINITY_EXPONENT+SGL_WRAP)
225: return(UNIMPLEMENTEDEXCEPTION);
226:
227: /*
228: * Adjust bias of result
229: */
230: Sgl_setwrapped_exponent(result,dest_exponent,ovfl);
231: *dstptr = result;
232: if (inexact) {
233: if (Is_inexacttrap_enabled())
234: return(OVERFLOWEXCEPTION|INEXACTEXCEPTION);
235: else
236: Set_inexactflag();
237: }
238: return(OVERFLOWEXCEPTION);
239: }
240: Set_overflowflag();
241: inexact = TRUE;
242: /* set result to infinity or largest number */
243: Sgl_setoverflow(result);
244: }
245: /*
246: * Test for underflow
247: */
248: else if (dest_exponent <= 0) {
249: /* trap if UNDERFLOWTRAP enabled */
250: if (Is_underflowtrap_enabled()) {
251: /*
252: * Check for gross underflow
253: */
254: if (dest_exponent <= -(SGL_WRAP))
255: return(UNIMPLEMENTEDEXCEPTION);
256: /*
257: * Adjust bias of result
258: */
259: Sgl_setwrapped_exponent(result,dest_exponent,unfl);
260: *dstptr = result;
261: if (inexact) {
262: if (Is_inexacttrap_enabled())
263: return(UNDERFLOWEXCEPTION|INEXACTEXCEPTION);
264: else
265: Set_inexactflag();
266: }
267: return(UNDERFLOWEXCEPTION);
268: }
269: /*
270: * result is denormalized or signed zero
271: */
272: if (inexact && is_tiny) Set_underflowflag();
273:
274: }
275: else Sgl_set_exponent(result,dest_exponent);
276: *dstptr = result;
277: /*
278: * Trap if inexact trap is enabled
279: */
280: if (inexact) {
281: if (Is_inexacttrap_enabled())
282: return(INEXACTEXCEPTION);
283: else
284: Set_inexactflag();
285: }
286: return(NOEXCEPTION);
287: }