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