1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * Linux/PA-RISC Project (http://www.parisc-linux.org/)
4 *
5 * Floating-point emulation code
6 * Copyright (C) 2001 Hewlett-Packard (Paul Bame) <bame@debian.org>
7 */
8 /*
9 * BEGIN_DESC
10 *
11 * File:
12 * @(#) pa/spmath/fcnvff.c $Revision: 1.1 $
13 *
14 * Purpose:
15 * Single Floating-point to Double Floating-point
16 * Double Floating-point to Single Floating-point
17 *
18 * External Interfaces:
19 * dbl_to_sgl_fcnvff(srcptr,nullptr,dstptr,status)
20 * sgl_to_dbl_fcnvff(srcptr,nullptr,dstptr,status)
21 *
22 * Internal Interfaces:
23 *
24 * Theory:
25 * <<please update with a overview of the operation of this file>>
26 *
27 * END_DESC
28 */
29
30
31 #include "float.h"
32 #include "sgl_float.h"
33 #include "dbl_float.h"
34 #include "cnv_float.h"
35
36 /*
37 * Single Floating-point to Double Floating-point
38 */
39 /*ARGSUSED*/
40 int
41 sgl_to_dbl_fcnvff(
42 sgl_floating_point *srcptr,
43 unsigned int *nullptr,
44 dbl_floating_point *dstptr,
45 unsigned int *status)
46 {
47 register unsigned int src, resultp1, resultp2;
48 register int src_exponent;
49
50 src = *srcptr;
51 src_exponent = Sgl_exponent(src);
52 Dbl_allp1(resultp1) = Sgl_all(src); /* set sign of result */
53 /*
54 * Test for NaN or infinity
55 */
56 if (src_exponent == SGL_INFINITY_EXPONENT) {
57 /*
58 * determine if NaN or infinity
59 */
60 if (Sgl_iszero_mantissa(src)) {
61 /*
62 * is infinity; want to return double infinity
63 */
64 Dbl_setinfinity_exponentmantissa(resultp1,resultp2);
65 Dbl_copytoptr(resultp1,resultp2,dstptr);
66 return(NOEXCEPTION);
67 }
68 else {
69 /*
70 * is NaN; signaling or quiet?
71 */
72 if (Sgl_isone_signaling(src)) {
73 /* trap if INVALIDTRAP enabled */
74 if (Is_invalidtrap_enabled())
75 return(INVALIDEXCEPTION);
76 /* make NaN quiet */
77 else {
78 Set_invalidflag();
79 Sgl_set_quiet(src);
80 }
81 }
82 /*
83 * NaN is quiet, return as double NaN
84 */
85 Dbl_setinfinity_exponent(resultp1);
86 Sgl_to_dbl_mantissa(src,resultp1,resultp2);
87 Dbl_copytoptr(resultp1,resultp2,dstptr);
88 return(NOEXCEPTION);
89 }
90 }
91 /*
92 * Test for zero or denormalized
93 */
94 if (src_exponent == 0) {
95 /*
96 * determine if zero or denormalized
97 */
98 if (Sgl_isnotzero_mantissa(src)) {
99 /*
100 * is denormalized; want to normalize
101 */
102 Sgl_clear_signexponent(src);
103 Sgl_leftshiftby1(src);
104 Sgl_normalize(src,src_exponent);
105 Sgl_to_dbl_exponent(src_exponent,resultp1);
106 Sgl_to_dbl_mantissa(src,resultp1,resultp2);
107 }
108 else {
109 Dbl_setzero_exponentmantissa(resultp1,resultp2);
110 }
111 Dbl_copytoptr(resultp1,resultp2,dstptr);
112 return(NOEXCEPTION);
113 }
114 /*
115 * No special cases, just complete the conversion
116 */
117 Sgl_to_dbl_exponent(src_exponent, resultp1);
118 Sgl_to_dbl_mantissa(Sgl_mantissa(src), resultp1,resultp2);
119 Dbl_copytoptr(resultp1,resultp2,dstptr);
120 return(NOEXCEPTION);
121 }
122
123 /*
124 * Double Floating-point to Single Floating-point
125 */
126 /*ARGSUSED*/
127 int
128 dbl_to_sgl_fcnvff(
129 dbl_floating_point *srcptr,
130 unsigned int *nullptr,
131 sgl_floating_point *dstptr,
132 unsigned int *status)
133 {
134 register unsigned int srcp1, srcp2, result;
135 register int src_exponent, dest_exponent, dest_mantissa;
136 register boolean inexact = FALSE, guardbit = FALSE, stickybit = FALSE;
137 register boolean lsb_odd = FALSE;
138 boolean is_tiny = FALSE;
139
140 Dbl_copyfromptr(srcptr,srcp1,srcp2);
141 src_exponent = Dbl_exponent(srcp1);
142 Sgl_all(result) = Dbl_allp1(srcp1); /* set sign of result */
143 /*
144 * Test for NaN or infinity
145 */
146 if (src_exponent == DBL_INFINITY_EXPONENT) {
147 /*
148 * determine if NaN or infinity
149 */
150 if (Dbl_iszero_mantissa(srcp1,srcp2)) {
151 /*
152 * is infinity; want to return single infinity
153 */
154 Sgl_setinfinity_exponentmantissa(result);
155 *dstptr = result;
156 return(NOEXCEPTION);
157 }
158 /*
159 * is NaN; signaling or quiet?
160 */
161 if (Dbl_isone_signaling(srcp1)) {
162 /* trap if INVALIDTRAP enabled */
163 if (Is_invalidtrap_enabled()) return(INVALIDEXCEPTION);
164 else {
165 Set_invalidflag();
166 /* make NaN quiet */
167 Dbl_set_quiet(srcp1);
168 }
169 }
170 /*
171 * NaN is quiet, return as single NaN
172 */
173 Sgl_setinfinity_exponent(result);
174 Sgl_set_mantissa(result,Dallp1(srcp1)<<3 | Dallp2(srcp2)>>29);
175 if (Sgl_iszero_mantissa(result)) Sgl_set_quiet(result);
176 *dstptr = result;
177 return(NOEXCEPTION);
178 }
179 /*
180 * Generate result
181 */
182 Dbl_to_sgl_exponent(src_exponent,dest_exponent);
183 if (dest_exponent > 0) {
184 Dbl_to_sgl_mantissa(srcp1,srcp2,dest_mantissa,inexact,guardbit,
185 stickybit,lsb_odd);
186 }
187 else {
188 if (Dbl_iszero_exponentmantissa(srcp1,srcp2)){
189 Sgl_setzero_exponentmantissa(result);
190 *dstptr = result;
191 return(NOEXCEPTION);
192 }
193 if (Is_underflowtrap_enabled()) {
194 Dbl_to_sgl_mantissa(srcp1,srcp2,dest_mantissa,inexact,
195 guardbit,stickybit,lsb_odd);
196 }
197 else {
198 /* compute result, determine inexact info,
199 * and set Underflowflag if appropriate
200 */
201 Dbl_to_sgl_denormalized(srcp1,srcp2,dest_exponent,
202 dest_mantissa,inexact,guardbit,stickybit,lsb_odd,
203 is_tiny);
204 }
205 }
206 /*
207 * Now round result if not exact
208 */
209 if (inexact) {
210 switch (Rounding_mode()) {
211 case ROUNDPLUS:
212 if (Sgl_iszero_sign(result)) dest_mantissa++;
213 break;
214 case ROUNDMINUS:
215 if (Sgl_isone_sign(result)) dest_mantissa++;
216 break;
217 case ROUNDNEAREST:
218 if (guardbit) {
219 if (stickybit || lsb_odd) dest_mantissa++;
220 }
221 }
222 }
223 Sgl_set_exponentmantissa(result,dest_mantissa);
224
225 /*
226 * check for mantissa overflow after rounding
227 */
228 if ((dest_exponent>0 || Is_underflowtrap_enabled()) &&
229 Sgl_isone_hidden(result)) dest_exponent++;
230
231 /*
232 * Test for overflow
233 */
234 if (dest_exponent >= SGL_INFINITY_EXPONENT) {
235 /* trap if OVERFLOWTRAP enabled */
236 if (Is_overflowtrap_enabled()) {
237 /*
238 * Check for gross overflow
239 */
240 if (dest_exponent >= SGL_INFINITY_EXPONENT+SGL_WRAP)
241 return(UNIMPLEMENTEDEXCEPTION);
242
243 /*
244 * Adjust bias of result
245 */
246 Sgl_setwrapped_exponent(result,dest_exponent,ovfl);
247 *dstptr = result;
248 if (inexact)
249 if (Is_inexacttrap_enabled())
250 return(OVERFLOWEXCEPTION|INEXACTEXCEPTION);
251 else Set_inexactflag();
252 return(OVERFLOWEXCEPTION);
253 }
254 Set_overflowflag();
255 inexact = TRUE;
256 /* set result to infinity or largest number */
257 Sgl_setoverflow(result);
258 }
259 /*
260 * Test for underflow
261 */
262 else if (dest_exponent <= 0) {
263 /* trap if UNDERFLOWTRAP enabled */
264 if (Is_underflowtrap_enabled()) {
265 /*
266 * Check for gross underflow
267 */
268 if (dest_exponent <= -(SGL_WRAP))
269 return(UNIMPLEMENTEDEXCEPTION);
270 /*
271 * Adjust bias of result
272 */
273 Sgl_setwrapped_exponent(result,dest_exponent,unfl);
274 *dstptr = result;
275 if (inexact)
276 if (Is_inexacttrap_enabled())
277 return(UNDERFLOWEXCEPTION|INEXACTEXCEPTION);
278 else Set_inexactflag();
279 return(UNDERFLOWEXCEPTION);
280 }
281 /*
282 * result is denormalized or signed zero
283 */
284 if (inexact && is_tiny) Set_underflowflag();
285
286 }
287 else Sgl_set_exponent(result,dest_exponent);
288 *dstptr = result;
289 /*
290 * Trap if inexact trap is enabled
291 */
292 if (inexact)
293 if (Is_inexacttrap_enabled()) return(INEXACTEXCEPTION);
294 else Set_inexactflag();
295 return(NOEXCEPTION);
296 }