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 * Purpose:
12 * Single Floating-point Round to Integer
13 * Double Floating-point Round to Integer
14 * Quad Floating-point Round to Integer (returns unimplemented)
15 *
16 * External Interfaces:
17 * dbl_frnd(srcptr,_nullptr,dstptr,status)
18 * sgl_frnd(srcptr,_nullptr,dstptr,status)
19 *
20 * END_DESC
21 */
22
23
24 #include "float.h"
25 #include "sgl_float.h"
26 #include "dbl_float.h"
27 #include "cnv_float.h"
28
29 /*
30 * Single Floating-point Round to Integer
31 */
32
33 /*ARGSUSED*/
34 int
35 sgl_frnd(sgl_floating_point *srcptr,
36 unsigned int *_nullptr,
37 sgl_floating_point *dstptr,
38 unsigned int *status)
39 {
40 register unsigned int src, result;
41 register int src_exponent;
42 register boolean inexact = FALSE;
43
44 src = *srcptr;
45 /*
46 * check source operand for NaN or infinity
47 */
48 if ((src_exponent = Sgl_exponent(src)) == SGL_INFINITY_EXPONENT) {
49 /*
50 * is signaling NaN?
51 */
52 if (Sgl_isone_signaling(src)) {
53 /* trap if INVALIDTRAP enabled */
54 if (Is_invalidtrap_enabled()) return(INVALIDEXCEPTION);
55 /* make NaN quiet */
56 Set_invalidflag();
57 Sgl_set_quiet(src);
58 }
59 /*
60 * return quiet NaN or infinity
61 */
62 *dstptr = src;
63 return(NOEXCEPTION);
64 }
65 /*
66 * Need to round?
67 */
68 if ((src_exponent -= SGL_BIAS) >= SGL_P - 1) {
69 *dstptr = src;
70 return(NOEXCEPTION);
71 }
72 /*
73 * Generate result
74 */
75 if (src_exponent >= 0) {
76 Sgl_clear_exponent_set_hidden(src);
77 result = src;
78 Sgl_rightshift(result,(SGL_P-1) - (src_exponent));
79 /* check for inexact */
80 if (Sgl_isinexact_to_fix(src,src_exponent)) {
81 inexact = TRUE;
82 /* round result */
83 switch (Rounding_mode()) {
84 case ROUNDPLUS:
85 if (Sgl_iszero_sign(src)) Sgl_increment(result);
86 break;
87 case ROUNDMINUS:
88 if (Sgl_isone_sign(src)) Sgl_increment(result);
89 break;
90 case ROUNDNEAREST:
91 if (Sgl_isone_roundbit(src,src_exponent))
92 if (Sgl_isone_stickybit(src,src_exponent)
93 || (Sgl_isone_lowmantissa(result)))
94 Sgl_increment(result);
95 }
96 }
97 Sgl_leftshift(result,(SGL_P-1) - (src_exponent));
98 if (Sgl_isone_hiddenoverflow(result))
99 Sgl_set_exponent(result,src_exponent + (SGL_BIAS+1));
100 else Sgl_set_exponent(result,src_exponent + SGL_BIAS);
101 }
102 else {
103 result = src; /* set sign */
104 Sgl_setzero_exponentmantissa(result);
105 /* check for inexact */
106 if (Sgl_isnotzero_exponentmantissa(src)) {
107 inexact = TRUE;
108 /* round result */
109 switch (Rounding_mode()) {
110 case ROUNDPLUS:
111 if (Sgl_iszero_sign(src))
112 Sgl_set_exponent(result,SGL_BIAS);
113 break;
114 case ROUNDMINUS:
115 if (Sgl_isone_sign(src))
116 Sgl_set_exponent(result,SGL_BIAS);
117 break;
118 case ROUNDNEAREST:
119 if (src_exponent == -1)
120 if (Sgl_isnotzero_mantissa(src))
121 Sgl_set_exponent(result,SGL_BIAS);
122 }
123 }
124 }
125 *dstptr = result;
126 if (inexact) {
127 if (Is_inexacttrap_enabled()) return(INEXACTEXCEPTION);
128 else Set_inexactflag();
129 }
130 return(NOEXCEPTION);
131 }
132
133 /*
134 * Double Floating-point Round to Integer
135 */
136
137 /*ARGSUSED*/
138 int
139 dbl_frnd(
140 dbl_floating_point *srcptr,
141 unsigned int *_nullptr,
142 dbl_floating_point *dstptr,
143 unsigned int *status)
144 {
145 register unsigned int srcp1, srcp2, resultp1, resultp2;
146 register int src_exponent;
147 register boolean inexact = FALSE;
148
149 Dbl_copyfromptr(srcptr,srcp1,srcp2);
150 /*
151 * check source operand for NaN or infinity
152 */
153 if ((src_exponent = Dbl_exponent(srcp1)) == DBL_INFINITY_EXPONENT) {
154 /*
155 * is signaling NaN?
156 */
157 if (Dbl_isone_signaling(srcp1)) {
158 /* trap if INVALIDTRAP enabled */
159 if (Is_invalidtrap_enabled()) return(INVALIDEXCEPTION);
160 /* make NaN quiet */
161 Set_invalidflag();
162 Dbl_set_quiet(srcp1);
163 }
164 /*
165 * return quiet NaN or infinity
166 */
167 Dbl_copytoptr(srcp1,srcp2,dstptr);
168 return(NOEXCEPTION);
169 }
170 /*
171 * Need to round?
172 */
173 if ((src_exponent -= DBL_BIAS) >= DBL_P - 1) {
174 Dbl_copytoptr(srcp1,srcp2,dstptr);
175 return(NOEXCEPTION);
176 }
177 /*
178 * Generate result
179 */
180 if (src_exponent >= 0) {
181 Dbl_clear_exponent_set_hidden(srcp1);
182 resultp1 = srcp1;
183 resultp2 = srcp2;
184 Dbl_rightshift(resultp1,resultp2,(DBL_P-1) - (src_exponent));
185 /* check for inexact */
186 if (Dbl_isinexact_to_fix(srcp1,srcp2,src_exponent)) {
187 inexact = TRUE;
188 /* round result */
189 switch (Rounding_mode()) {
190 case ROUNDPLUS:
191 if (Dbl_iszero_sign(srcp1))
192 Dbl_increment(resultp1,resultp2);
193 break;
194 case ROUNDMINUS:
195 if (Dbl_isone_sign(srcp1))
196 Dbl_increment(resultp1,resultp2);
197 break;
198 case ROUNDNEAREST:
199 if (Dbl_isone_roundbit(srcp1,srcp2,src_exponent))
200 if (Dbl_isone_stickybit(srcp1,srcp2,src_exponent)
201 || (Dbl_isone_lowmantissap2(resultp2)))
202 Dbl_increment(resultp1,resultp2);
203 }
204 }
205 Dbl_leftshift(resultp1,resultp2,(DBL_P-1) - (src_exponent));
206 if (Dbl_isone_hiddenoverflow(resultp1))
207 Dbl_set_exponent(resultp1,src_exponent + (DBL_BIAS+1));
208 else Dbl_set_exponent(resultp1,src_exponent + DBL_BIAS);
209 }
210 else {
211 resultp1 = srcp1; /* set sign */
212 Dbl_setzero_exponentmantissa(resultp1,resultp2);
213 /* check for inexact */
214 if (Dbl_isnotzero_exponentmantissa(srcp1,srcp2)) {
215 inexact = TRUE;
216 /* round result */
217 switch (Rounding_mode()) {
218 case ROUNDPLUS:
219 if (Dbl_iszero_sign(srcp1))
220 Dbl_set_exponent(resultp1,DBL_BIAS);
221 break;
222 case ROUNDMINUS:
223 if (Dbl_isone_sign(srcp1))
224 Dbl_set_exponent(resultp1,DBL_BIAS);
225 break;
226 case ROUNDNEAREST:
227 if (src_exponent == -1)
228 if (Dbl_isnotzero_mantissa(srcp1,srcp2))
229 Dbl_set_exponent(resultp1,DBL_BIAS);
230 }
231 }
232 }
233 Dbl_copytoptr(resultp1,resultp2,dstptr);
234 if (inexact) {
235 if (Is_inexacttrap_enabled()) return(INEXACTEXCEPTION);
236 else Set_inexactflag();
237 }
238 return(NOEXCEPTION);
239 }
240
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.