Annotation of sys/arch/hppa/spmath/sgl_float.h, Revision 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