Annotation of sys/arch/hppa/spmath/sgl_float.h, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: sgl_float.h,v 1.11 2006/11/29 10:40:44 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: /* @(#)sgl_float.h: Revision: 2.8.88.1 Date: 93/12/07 15:07:17 */
16:
17: #include <sys/cdefs.h>
18:
19: /******************************
20: * Single precision functions *
21: ******************************/
22:
23: /* 32-bit word grabing functions */
24: #define Sgl_firstword(value) Sall(value)
25: #define Sgl_secondword(value) dummy_location
26: #define Sgl_thirdword(value) dummy_location
27: #define Sgl_fourthword(value) dummy_location
28:
29: #define Sgl_sign(object) Ssign(object)
30: #define Sgl_exponent(object) Sexponent(object)
31: #define Sgl_signexponent(object) Ssignexponent(object)
32: #define Sgl_mantissa(object) Smantissa(object)
33: #define Sgl_exponentmantissa(object) Sexponentmantissa(object)
34: #define Sgl_all(object) Sall(object)
35:
36: /* sgl_and_signs ands the sign bits of each argument and puts the result
37: * into the first argument. sgl_or_signs ors those same sign bits */
38: #define Sgl_and_signs( src1dst, src2) \
39: Sall(src1dst) = (Sall(src2)|~(1<<31)) & Sall(src1dst)
40: #define Sgl_or_signs( src1dst, src2) \
41: Sall(src1dst) = (Sall(src2)&(1<<31)) | Sall(src1dst)
42:
43: /* The hidden bit is always the low bit of the exponent */
44: #define Sgl_clear_exponent_set_hidden(srcdst) Deposit_sexponent(srcdst,1)
45: #define Sgl_clear_signexponent_set_hidden(srcdst) \
46: Deposit_ssignexponent(srcdst,1)
47: #define Sgl_clear_sign(srcdst) Sall(srcdst) &= ~(1<<31)
48: #define Sgl_clear_signexponent(srcdst) Sall(srcdst) &= 0x007fffff
49:
50: /* varamount must be less than 32 for the next three functions */
51: #define Sgl_rightshift(srcdst, varamount) \
52: Sall(srcdst) >>= varamount
53: #define Sgl_leftshift(srcdst, varamount) \
54: Sall(srcdst) <<= varamount
55: #define Sgl_rightshift_exponentmantissa(srcdst, varamount) \
56: Sall(srcdst) = \
57: (Sexponentmantissa(srcdst) >> (varamount)) | (Sall(srcdst) & (1<<31))
58:
59: #define Sgl_leftshiftby1_withextent(left,right,result) \
60: Shiftdouble(Sall(left),Extall(right),31,Sall(result))
61:
62: #define Sgl_rightshiftby1_withextent(left,right,dst) \
63: Shiftdouble(Sall(left),Extall(right),1,Extall(right))
64: #define Sgl_arithrightshiftby1(srcdst) \
65: Sall(srcdst) = (int)Sall(srcdst) >> 1
66:
67: /* Sign extend the sign bit with an integer destination */
68: #define Sgl_signextendedsign(value) Ssignedsign(value)
69:
70: #define Sgl_isone_hidden(sgl_value) (Shidden(sgl_value))
71: #define Sgl_increment(sgl_value) Sall(sgl_value) += 1
72: #define Sgl_increment_mantissa(sgl_value) \
73: Deposit_smantissa(sgl_value,sgl_value+1)
74: #define Sgl_decrement(sgl_value) Sall(sgl_value) -= 1
75:
76: #define Sgl_isone_sign(sgl_value) (Is_ssign(sgl_value)!=0)
77: #define Sgl_isone_hiddenoverflow(sgl_value) \
78: (Is_shiddenoverflow(sgl_value)!=0)
79: #define Sgl_isone_lowmantissa(sgl_value) (Is_slow(sgl_value)!=0)
80: #define Sgl_isone_signaling(sgl_value) (Is_ssignaling(sgl_value)!=0)
81: #define Sgl_is_signalingnan(sgl_value) (Ssignalingnan(sgl_value)==0x1ff)
82: #define Sgl_isnotzero(sgl_value) (Sall(sgl_value)!=0)
83: #define Sgl_isnotzero_hiddenhigh7mantissa(sgl_value) \
84: (Shiddenhigh7mantissa(sgl_value)!=0)
85: #define Sgl_isnotzero_low4(sgl_value) (Slow4(sgl_value)!=0)
86: #define Sgl_isnotzero_exponent(sgl_value) (Sexponent(sgl_value)!=0)
87: #define Sgl_isnotzero_mantissa(sgl_value) (Smantissa(sgl_value)!=0)
88: #define Sgl_isnotzero_exponentmantissa(sgl_value) \
89: (Sexponentmantissa(sgl_value)!=0)
90: #define Sgl_iszero(sgl_value) (Sall(sgl_value)==0)
91: #define Sgl_iszero_signaling(sgl_value) (Is_ssignaling(sgl_value)==0)
92: #define Sgl_iszero_hidden(sgl_value) (Is_shidden(sgl_value)==0)
93: #define Sgl_iszero_hiddenoverflow(sgl_value) \
94: (Is_shiddenoverflow(sgl_value)==0)
95: #define Sgl_iszero_hiddenhigh3mantissa(sgl_value) \
96: (Shiddenhigh3mantissa(sgl_value)==0)
97: #define Sgl_iszero_hiddenhigh7mantissa(sgl_value) \
98: (Shiddenhigh7mantissa(sgl_value)==0)
99: #define Sgl_iszero_sign(sgl_value) (Is_ssign(sgl_value)==0)
100: #define Sgl_iszero_exponent(sgl_value) (Sexponent(sgl_value)==0)
101: #define Sgl_iszero_mantissa(sgl_value) (Smantissa(sgl_value)==0)
102: #define Sgl_iszero_exponentmantissa(sgl_value) \
103: (Sexponentmantissa(sgl_value)==0)
104: #define Sgl_isinfinity_exponent(sgl_value) \
105: (Sgl_exponent(sgl_value)==SGL_INFINITY_EXPONENT)
106: #define Sgl_isnotinfinity_exponent(sgl_value) \
107: (Sgl_exponent(sgl_value)!=SGL_INFINITY_EXPONENT)
108: #define Sgl_isinfinity(sgl_value) \
109: (Sgl_exponent(sgl_value)==SGL_INFINITY_EXPONENT && \
110: Sgl_mantissa(sgl_value)==0)
111: #define Sgl_isnan(sgl_value) \
112: (Sgl_exponent(sgl_value)==SGL_INFINITY_EXPONENT && \
113: Sgl_mantissa(sgl_value)!=0)
114: #define Sgl_isnotnan(sgl_value) \
115: (Sgl_exponent(sgl_value)!=SGL_INFINITY_EXPONENT || \
116: Sgl_mantissa(sgl_value)==0)
117: #define Sgl_islessthan(sgl_op1,sgl_op2) \
118: (Sall(sgl_op1) < Sall(sgl_op2))
119: #define Sgl_isgreaterthan(sgl_op1,sgl_op2) \
120: (Sall(sgl_op1) > Sall(sgl_op2))
121: #define Sgl_isnotlessthan(sgl_op1,sgl_op2) \
122: (Sall(sgl_op1) >= Sall(sgl_op2))
123: #define Sgl_isequal(sgl_op1,sgl_op2) \
124: (Sall(sgl_op1) == Sall(sgl_op2))
125:
126: #define Sgl_leftshiftby8(sgl_value) \
127: Sall(sgl_value) <<= 8
128: #define Sgl_leftshiftby4(sgl_value) \
129: Sall(sgl_value) <<= 4
130: #define Sgl_leftshiftby3(sgl_value) \
131: Sall(sgl_value) <<= 3
132: #define Sgl_leftshiftby2(sgl_value) \
133: Sall(sgl_value) <<= 2
134: #define Sgl_leftshiftby1(sgl_value) \
135: Sall(sgl_value) <<= 1
136: #define Sgl_rightshiftby1(sgl_value) \
137: Sall(sgl_value) >>= 1
138: #define Sgl_rightshiftby4(sgl_value) \
139: Sall(sgl_value) >>= 4
140: #define Sgl_rightshiftby8(sgl_value) \
141: Sall(sgl_value) >>= 8
142:
143: #define Sgl_ismagnitudeless(signlessleft,signlessright) \
144: /* unsigned int signlessleft, signlessright; */ \
145: (signlessleft < signlessright)
146:
147:
148: #define Sgl_copytoint_exponentmantissa(source,dest) \
149: dest = Sexponentmantissa(source)
150:
151: /* A quiet NaN has the high mantissa bit clear and at least on other (in this
152: * case the adjacent bit) bit set. */
153: #define Sgl_set_quiet(sgl_value) Deposit_shigh2mantissa(sgl_value,1)
154: #define Sgl_set_exponent(sgl_value,exp) Deposit_sexponent(sgl_value,exp)
155:
156: #define Sgl_set_mantissa(dest,value) Deposit_smantissa(dest,value)
157: #define Sgl_set_exponentmantissa(dest,value) \
158: Deposit_sexponentmantissa(dest,value)
159:
160: /* An infinity is represented with the max exponent and a zero mantissa */
161: #define Sgl_setinfinity_exponent(sgl_value) \
162: Deposit_sexponent(sgl_value,SGL_INFINITY_EXPONENT)
163: #define Sgl_setinfinity_exponentmantissa(sgl_value) \
164: Deposit_sexponentmantissa(sgl_value, \
165: (SGL_INFINITY_EXPONENT << (32-(1+SGL_EXP_LENGTH))))
166: #define Sgl_setinfinitypositive(sgl_value) \
167: Sall(sgl_value) = (SGL_INFINITY_EXPONENT << (32-(1+SGL_EXP_LENGTH)))
168: #define Sgl_setinfinitynegative(sgl_value) \
169: Sall(sgl_value) = (SGL_INFINITY_EXPONENT << (32-(1+SGL_EXP_LENGTH))) \
170: | (1<<31)
171: #define Sgl_setinfinity(sgl_value,sign) \
172: Sall(sgl_value) = (SGL_INFINITY_EXPONENT << (32-(1+SGL_EXP_LENGTH))) | \
173: (sign << 31)
174: #define Sgl_sethigh4bits(sgl_value, extsign) \
175: Deposit_shigh4(sgl_value,extsign)
176: #define Sgl_set_sign(sgl_value,sign) Deposit_ssign(sgl_value,sign)
177: #define Sgl_invert_sign(sgl_value) \
178: Deposit_ssign(sgl_value,~Ssign(sgl_value))
179: #define Sgl_setone_sign(sgl_value) Deposit_ssign(sgl_value,1)
180: #define Sgl_setone_lowmantissa(sgl_value) Deposit_slow(sgl_value,1)
181: #define Sgl_setzero_sign(sgl_value) Sall(sgl_value) &= 0x7fffffff
182: #define Sgl_setzero_exponent(sgl_value) Sall(sgl_value) &= 0x807fffff
183: #define Sgl_setzero_mantissa(sgl_value) Sall(sgl_value) &= 0xff800000
184: #define Sgl_setzero_exponentmantissa(sgl_value) Sall(sgl_value) &= 0x80000000
185: #define Sgl_setzero(sgl_value) Sall(sgl_value) = 0
186: #define Sgl_setnegativezero(sgl_value) Sall(sgl_value) = 1 << 31
187:
188: /* Use following macro for both overflow & underflow conditions */
189: #define ovfl -
190: #define unfl +
191: #define Sgl_setwrapped_exponent(sgl_value,exponent,op) \
192: Deposit_sexponent(sgl_value,(exponent op SGL_WRAP))
193:
194: #define Sgl_setlargestpositive(sgl_value) \
195: Sall(sgl_value) = ((SGL_EMAX+SGL_BIAS) << (32-(1+SGL_EXP_LENGTH))) \
196: | ((1<<(32-(1+SGL_EXP_LENGTH))) - 1)
197: #define Sgl_setlargestnegative(sgl_value) \
198: Sall(sgl_value) = ((SGL_EMAX+SGL_BIAS) << (32-(1+SGL_EXP_LENGTH))) \
199: | ((1<<(32-(1+SGL_EXP_LENGTH))) - 1 ) | (1<<31)
200:
201: #define Sgl_setnegativeinfinity(sgl_value) \
202: Sall(sgl_value) = \
203: ((1<<SGL_EXP_LENGTH) | SGL_INFINITY_EXPONENT) << (32-(1+SGL_EXP_LENGTH))
204: #define Sgl_setlargest(sgl_value,sign) \
205: Sall(sgl_value) = ((sign) << 31) | \
206: (((SGL_EMAX+SGL_BIAS) << (32-(1+SGL_EXP_LENGTH))) \
207: | ((1 << (32-(1+SGL_EXP_LENGTH))) - 1 ))
208: #define Sgl_setlargest_exponentmantissa(sgl_value) \
209: Sall(sgl_value) = (Sall(sgl_value) & (1<<31)) | \
210: (((SGL_EMAX+SGL_BIAS) << (32-(1+SGL_EXP_LENGTH))) \
211: | ((1 << (32-(1+SGL_EXP_LENGTH))) - 1 ))
212:
213: /* The high bit is always zero so arithmetic or logical shifts will work. */
214: #define Sgl_right_align(srcdst,shift,extent) \
215: /* sgl_floating_point srcdst; int shift; extension extent */ \
216: if (shift < 32) { \
217: Extall(extent) = Sall(srcdst) << (32-(shift)); \
218: Sall(srcdst) >>= shift; \
219: } \
220: else { \
221: Extall(extent) = Sall(srcdst); \
222: Sall(srcdst) = 0; \
223: }
224: #define Sgl_hiddenhigh3mantissa(sgl_value) Shiddenhigh3mantissa(sgl_value)
225: #define Sgl_hidden(sgl_value) Shidden(sgl_value)
226: #define Sgl_lowmantissa(sgl_value) Slow(sgl_value)
227:
228: /* The left argument is never smaller than the right argument */
229: #define Sgl_subtract(sgl_left,sgl_right,sgl_result) \
230: Sall(sgl_result) = Sall(sgl_left) - Sall(sgl_right)
231:
232: /* Subtract right augmented with extension from left augmented with zeros and
233: * store into result and extension. */
234: #define Sgl_subtract_withextension(left,right,extent,result) \
235: /* sgl_floating_point left,right,result; extension extent */ \
236: Sgl_subtract(left,right,result); \
237: if((Extall(extent) = 0-Extall(extent))) \
238: Sall(result) = Sall(result)-1
239:
240: #define Sgl_addition(sgl_left,sgl_right,sgl_result) \
241: Sall(sgl_result) = Sall(sgl_left) + Sall(sgl_right)
242:
243: #define Sgl_xortointp1(left,right,result) \
244: result = Sall(left) XOR Sall(right);
245:
246: #define Sgl_xorfromintp1(left,right,result) \
247: Sall(result) = left XOR Sall(right)
248:
249: /* Need to Initialize */
250: #define Sgl_makequietnan(dest) \
251: Sall(dest) = ((SGL_EMAX+SGL_BIAS)+1)<< (32-(1+SGL_EXP_LENGTH)) \
252: | (1<<(32-(1+SGL_EXP_LENGTH+2)))
253: #define Sgl_makesignalingnan(dest) \
254: Sall(dest) = ((SGL_EMAX+SGL_BIAS)+1)<< (32-(1+SGL_EXP_LENGTH)) \
255: | (1<<(32-(1+SGL_EXP_LENGTH+1)))
256:
257: #define Sgl_normalize(sgl_opnd,exponent) \
258: while(Sgl_iszero_hiddenhigh7mantissa(sgl_opnd)) { \
259: Sgl_leftshiftby8(sgl_opnd); \
260: exponent -= 8; \
261: } \
262: if(Sgl_iszero_hiddenhigh3mantissa(sgl_opnd)) { \
263: Sgl_leftshiftby4(sgl_opnd); \
264: exponent -= 4; \
265: } \
266: while(Sgl_iszero_hidden(sgl_opnd)) { \
267: Sgl_leftshiftby1(sgl_opnd); \
268: exponent -= 1; \
269: }
270:
271: #define Sgl_setoverflow(sgl_opnd) \
272: /* set result to infinity or largest number */ \
273: switch (Rounding_mode()) { \
274: case ROUNDPLUS: \
275: if (Sgl_isone_sign(sgl_opnd)) { \
276: Sgl_setlargestnegative(sgl_opnd); \
277: } \
278: else { \
279: Sgl_setinfinitypositive(sgl_opnd); \
280: } \
281: break; \
282: case ROUNDMINUS: \
283: if (Sgl_iszero_sign(sgl_opnd)) { \
284: Sgl_setlargestpositive(sgl_opnd); \
285: } \
286: else { \
287: Sgl_setinfinitynegative(sgl_opnd); \
288: } \
289: break; \
290: case ROUNDNEAREST: \
291: Sgl_setinfinity_exponentmantissa(sgl_opnd); \
292: break; \
293: case ROUNDZERO: \
294: Sgl_setlargest_exponentmantissa(sgl_opnd); \
295: }
296:
297: #define Sgl_denormalize(opnd,exponent,guard,sticky,inexact) \
298: Sgl_clear_signexponent_set_hidden(opnd); \
299: if (exponent >= (1 - SGL_P)) { \
300: guard = (Sall(opnd) >> (-(exponent))) & 1; \
301: if (exponent < 0) sticky |= Sall(opnd) << (32+exponent); \
302: inexact = (guard) | (sticky); \
303: Sall(opnd) >>= (1-exponent); \
304: } \
305: else { \
306: guard = 0; \
307: sticky |= Sall(opnd); \
308: inexact = sticky; \
309: Sgl_setzero(opnd); \
310: }
311:
312: int sgl_fadd(sgl_floating_point *, sgl_floating_point *, sgl_floating_point *, unsigned int *);
313: int sgl_fcmp(sgl_floating_point *, sgl_floating_point *, unsigned int, unsigned int *);
314: int sgl_fdiv(sgl_floating_point *, sgl_floating_point *, sgl_floating_point *, unsigned int *);
315: int sgl_fmpy(sgl_floating_point *, sgl_floating_point *, sgl_floating_point *, unsigned int *);
316: int sgl_frem(sgl_floating_point *, sgl_floating_point *, sgl_floating_point *, unsigned int *);
317: int sgl_fsqrt(sgl_floating_point *, sgl_floating_point *, sgl_floating_point *, unsigned int *);
318: int sgl_fsub(sgl_floating_point *, sgl_floating_point *, sgl_floating_point *, unsigned int *);
319: int sgl_frnd(sgl_floating_point *, sgl_floating_point *, sgl_floating_point *, unsigned int *);
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to sgl_float.h CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / hppa / spmath