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