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/sfdiv.c $Revision: 1.1 $
13 *
14 * Purpose:
15 * Single Precision Floating-point Divide
16 *
17 * External Interfaces:
18 * sgl_fdiv(srcptr1,srcptr2,dstptr,status)
19 *
20 * Internal Interfaces:
21 *
22 * Theory:
23 * <<please update with a overview of the operation of this file>>
24 *
25 * END_DESC
26 */
27
28
29 #include "float.h"
30 #include "sgl_float.h"
31
32 /*
33 * Single Precision Floating-point Divide
34 */
35
36 int
37 sgl_fdiv (sgl_floating_point * srcptr1, sgl_floating_point * srcptr2,
38 sgl_floating_point * dstptr, unsigned int *status)
39 {
40 register unsigned int opnd1, opnd2, opnd3, result;
41 register int dest_exponent, count;
42 register boolean inexact = FALSE, guardbit = FALSE, stickybit = FALSE;
43 boolean is_tiny;
44
45 opnd1 = *srcptr1;
46 opnd2 = *srcptr2;
47 /*
48 * set sign bit of result
49 */
50 if (Sgl_sign(opnd1) ^ Sgl_sign(opnd2)) Sgl_setnegativezero(result);
51 else Sgl_setzero(result);
52 /*
53 * check first operand for NaN's or infinity
54 */
55 if (Sgl_isinfinity_exponent(opnd1)) {
56 if (Sgl_iszero_mantissa(opnd1)) {
57 if (Sgl_isnotnan(opnd2)) {
58 if (Sgl_isinfinity(opnd2)) {
59 /*
60 * invalid since both operands
61 * are infinity
62 */
63 if (Is_invalidtrap_enabled())
64 return(INVALIDEXCEPTION);
65 Set_invalidflag();
66 Sgl_makequietnan(result);
67 *dstptr = result;
68 return(NOEXCEPTION);
69 }
70 /*
71 * return infinity
72 */
73 Sgl_setinfinity_exponentmantissa(result);
74 *dstptr = result;
75 return(NOEXCEPTION);
76 }
77 }
78 else {
79 /*
80 * is NaN; signaling or quiet?
81 */
82 if (Sgl_isone_signaling(opnd1)) {
83 /* trap if INVALIDTRAP enabled */
84 if (Is_invalidtrap_enabled())
85 return(INVALIDEXCEPTION);
86 /* make NaN quiet */
87 Set_invalidflag();
88 Sgl_set_quiet(opnd1);
89 }
90 /*
91 * is second operand a signaling NaN?
92 */
93 else if (Sgl_is_signalingnan(opnd2)) {
94 /* trap if INVALIDTRAP enabled */
95 if (Is_invalidtrap_enabled())
96 return(INVALIDEXCEPTION);
97 /* make NaN quiet */
98 Set_invalidflag();
99 Sgl_set_quiet(opnd2);
100 *dstptr = opnd2;
101 return(NOEXCEPTION);
102 }
103 /*
104 * return quiet NaN
105 */
106 *dstptr = opnd1;
107 return(NOEXCEPTION);
108 }
109 }
110 /*
111 * check second operand for NaN's or infinity
112 */
113 if (Sgl_isinfinity_exponent(opnd2)) {
114 if (Sgl_iszero_mantissa(opnd2)) {
115 /*
116 * return zero
117 */
118 Sgl_setzero_exponentmantissa(result);
119 *dstptr = result;
120 return(NOEXCEPTION);
121 }
122 /*
123 * is NaN; signaling or quiet?
124 */
125 if (Sgl_isone_signaling(opnd2)) {
126 /* trap if INVALIDTRAP enabled */
127 if (Is_invalidtrap_enabled()) return(INVALIDEXCEPTION);
128 /* make NaN quiet */
129 Set_invalidflag();
130 Sgl_set_quiet(opnd2);
131 }
132 /*
133 * return quiet NaN
134 */
135 *dstptr = opnd2;
136 return(NOEXCEPTION);
137 }
138 /*
139 * check for division by zero
140 */
141 if (Sgl_iszero_exponentmantissa(opnd2)) {
142 if (Sgl_iszero_exponentmantissa(opnd1)) {
143 /* invalid since both operands are zero */
144 if (Is_invalidtrap_enabled()) return(INVALIDEXCEPTION);
145 Set_invalidflag();
146 Sgl_makequietnan(result);
147 *dstptr = result;
148 return(NOEXCEPTION);
149 }
150 if (Is_divisionbyzerotrap_enabled())
151 return(DIVISIONBYZEROEXCEPTION);
152 Set_divisionbyzeroflag();
153 Sgl_setinfinity_exponentmantissa(result);
154 *dstptr = result;
155 return(NOEXCEPTION);
156 }
157 /*
158 * Generate exponent
159 */
160 dest_exponent = Sgl_exponent(opnd1) - Sgl_exponent(opnd2) + SGL_BIAS;
161
162 /*
163 * Generate mantissa
164 */
165 if (Sgl_isnotzero_exponent(opnd1)) {
166 /* set hidden bit */
167 Sgl_clear_signexponent_set_hidden(opnd1);
168 }
169 else {
170 /* check for zero */
171 if (Sgl_iszero_mantissa(opnd1)) {
172 Sgl_setzero_exponentmantissa(result);
173 *dstptr = result;
174 return(NOEXCEPTION);
175 }
176 /* is denormalized; want to normalize */
177 Sgl_clear_signexponent(opnd1);
178 Sgl_leftshiftby1(opnd1);
179 Sgl_normalize(opnd1,dest_exponent);
180 }
181 /* opnd2 needs to have hidden bit set with msb in hidden bit */
182 if (Sgl_isnotzero_exponent(opnd2)) {
183 Sgl_clear_signexponent_set_hidden(opnd2);
184 }
185 else {
186 /* is denormalized; want to normalize */
187 Sgl_clear_signexponent(opnd2);
188 Sgl_leftshiftby1(opnd2);
189 while(Sgl_iszero_hiddenhigh7mantissa(opnd2)) {
190 Sgl_leftshiftby8(opnd2);
191 dest_exponent += 8;
192 }
193 if(Sgl_iszero_hiddenhigh3mantissa(opnd2)) {
194 Sgl_leftshiftby4(opnd2);
195 dest_exponent += 4;
196 }
197 while(Sgl_iszero_hidden(opnd2)) {
198 Sgl_leftshiftby1(opnd2);
199 dest_exponent += 1;
200 }
201 }
202
203 /* Divide the source mantissas */
204
205 /*
206 * A non_restoring divide algorithm is used.
207 */
208 Sgl_subtract(opnd1,opnd2,opnd1);
209 Sgl_setzero(opnd3);
210 for (count=1;count<=SGL_P && Sgl_all(opnd1);count++) {
211 Sgl_leftshiftby1(opnd1);
212 Sgl_leftshiftby1(opnd3);
213 if (Sgl_iszero_sign(opnd1)) {
214 Sgl_setone_lowmantissa(opnd3);
215 Sgl_subtract(opnd1,opnd2,opnd1);
216 }
217 else Sgl_addition(opnd1,opnd2,opnd1);
218 }
219 if (count <= SGL_P) {
220 Sgl_leftshiftby1(opnd3);
221 Sgl_setone_lowmantissa(opnd3);
222 Sgl_leftshift(opnd3,SGL_P-count);
223 if (Sgl_iszero_hidden(opnd3)) {
224 Sgl_leftshiftby1(opnd3);
225 dest_exponent--;
226 }
227 }
228 else {
229 if (Sgl_iszero_hidden(opnd3)) {
230 /* need to get one more bit of result */
231 Sgl_leftshiftby1(opnd1);
232 Sgl_leftshiftby1(opnd3);
233 if (Sgl_iszero_sign(opnd1)) {
234 Sgl_setone_lowmantissa(opnd3);
235 Sgl_subtract(opnd1,opnd2,opnd1);
236 }
237 else Sgl_addition(opnd1,opnd2,opnd1);
238 dest_exponent--;
239 }
240 if (Sgl_iszero_sign(opnd1)) guardbit = TRUE;
241 stickybit = Sgl_all(opnd1);
242 }
243 inexact = guardbit | stickybit;
244
245 /*
246 * round result
247 */
248 if (inexact && (dest_exponent > 0 || Is_underflowtrap_enabled())) {
249 Sgl_clear_signexponent(opnd3);
250 switch (Rounding_mode()) {
251 case ROUNDPLUS:
252 if (Sgl_iszero_sign(result))
253 Sgl_increment_mantissa(opnd3);
254 break;
255 case ROUNDMINUS:
256 if (Sgl_isone_sign(result))
257 Sgl_increment_mantissa(opnd3);
258 break;
259 case ROUNDNEAREST:
260 if (guardbit) {
261 if (stickybit || Sgl_isone_lowmantissa(opnd3))
262 Sgl_increment_mantissa(opnd3);
263 }
264 }
265 if (Sgl_isone_hidden(opnd3)) dest_exponent++;
266 }
267 Sgl_set_mantissa(result,opnd3);
268
269 /*
270 * Test for overflow
271 */
272 if (dest_exponent >= SGL_INFINITY_EXPONENT) {
273 /* trap if OVERFLOWTRAP enabled */
274 if (Is_overflowtrap_enabled()) {
275 /*
276 * Adjust bias of result
277 */
278 Sgl_setwrapped_exponent(result,dest_exponent,ovfl);
279 *dstptr = result;
280 if (inexact)
281 if (Is_inexacttrap_enabled())
282 return(OVERFLOWEXCEPTION | INEXACTEXCEPTION);
283 else Set_inexactflag();
284 return(OVERFLOWEXCEPTION);
285 }
286 Set_overflowflag();
287 /* set result to infinity or largest number */
288 Sgl_setoverflow(result);
289 inexact = TRUE;
290 }
291 /*
292 * Test for underflow
293 */
294 else if (dest_exponent <= 0) {
295 /* trap if UNDERFLOWTRAP enabled */
296 if (Is_underflowtrap_enabled()) {
297 /*
298 * Adjust bias of result
299 */
300 Sgl_setwrapped_exponent(result,dest_exponent,unfl);
301 *dstptr = result;
302 if (inexact)
303 if (Is_inexacttrap_enabled())
304 return(UNDERFLOWEXCEPTION | INEXACTEXCEPTION);
305 else Set_inexactflag();
306 return(UNDERFLOWEXCEPTION);
307 }
308
309 /* Determine if should set underflow flag */
310 is_tiny = TRUE;
311 if (dest_exponent == 0 && inexact) {
312 switch (Rounding_mode()) {
313 case ROUNDPLUS:
314 if (Sgl_iszero_sign(result)) {
315 Sgl_increment(opnd3);
316 if (Sgl_isone_hiddenoverflow(opnd3))
317 is_tiny = FALSE;
318 Sgl_decrement(opnd3);
319 }
320 break;
321 case ROUNDMINUS:
322 if (Sgl_isone_sign(result)) {
323 Sgl_increment(opnd3);
324 if (Sgl_isone_hiddenoverflow(opnd3))
325 is_tiny = FALSE;
326 Sgl_decrement(opnd3);
327 }
328 break;
329 case ROUNDNEAREST:
330 if (guardbit && (stickybit ||
331 Sgl_isone_lowmantissa(opnd3))) {
332 Sgl_increment(opnd3);
333 if (Sgl_isone_hiddenoverflow(opnd3))
334 is_tiny = FALSE;
335 Sgl_decrement(opnd3);
336 }
337 break;
338 }
339 }
340
341 /*
342 * denormalize result or set to signed zero
343 */
344 stickybit = inexact;
345 Sgl_denormalize(opnd3,dest_exponent,guardbit,stickybit,inexact);
346
347 /* return rounded number */
348 if (inexact) {
349 switch (Rounding_mode()) {
350 case ROUNDPLUS:
351 if (Sgl_iszero_sign(result)) {
352 Sgl_increment(opnd3);
353 }
354 break;
355 case ROUNDMINUS:
356 if (Sgl_isone_sign(result)) {
357 Sgl_increment(opnd3);
358 }
359 break;
360 case ROUNDNEAREST:
361 if (guardbit && (stickybit ||
362 Sgl_isone_lowmantissa(opnd3))) {
363 Sgl_increment(opnd3);
364 }
365 break;
366 }
367 if (is_tiny) Set_underflowflag();
368 }
369 Sgl_set_exponentmantissa(result,opnd3);
370 }
371 else Sgl_set_exponent(result,dest_exponent);
372 *dstptr = result;
373 /* check for inexact */
374 if (inexact) {
375 if (Is_inexacttrap_enabled()) return(INEXACTEXCEPTION);
376 else Set_inexactflag();
377 }
378 return(NOEXCEPTION);
379 }