Annotation of sys/arch/hppa/spmath/dbl_float.h, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: dbl_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: /* @(#)dbl_float.h: Revision: 2.9.88.1 Date: 93/12/07 15:05:32 */
! 16:
! 17: /**************************************
! 18: * Declare double precision functions *
! 19: **************************************/
! 20:
! 21: /* 32-bit word grabing functions */
! 22: #define Dbl_firstword(value) Dallp1(value)
! 23: #define Dbl_secondword(value) Dallp2(value)
! 24: #define Dbl_thirdword(value) dummy_location
! 25: #define Dbl_fourthword(value) dummy_location
! 26:
! 27: #define Dbl_sign(object) Dsign(object)
! 28: #define Dbl_exponent(object) Dexponent(object)
! 29: #define Dbl_signexponent(object) Dsignexponent(object)
! 30: #define Dbl_mantissap1(object) Dmantissap1(object)
! 31: #define Dbl_mantissap2(object) Dmantissap2(object)
! 32: #define Dbl_exponentmantissap1(object) Dexponentmantissap1(object)
! 33: #define Dbl_allp1(object) Dallp1(object)
! 34: #define Dbl_allp2(object) Dallp2(object)
! 35:
! 36: /* dbl_and_signs ands the sign bits of each argument and puts the result
! 37: * into the first argument. dbl_or_signs ors those same sign bits */
! 38: #define Dbl_and_signs( src1dst, src2) \
! 39: Dallp1(src1dst) = (Dallp1(src2)|~(1<<31)) & Dallp1(src1dst)
! 40: #define Dbl_or_signs( src1dst, src2) \
! 41: Dallp1(src1dst) = (Dallp1(src2)&(1<<31)) | Dallp1(src1dst)
! 42:
! 43: /* The hidden bit is always the low bit of the exponent */
! 44: #define Dbl_clear_exponent_set_hidden(srcdst) Deposit_dexponent(srcdst,1)
! 45: #define Dbl_clear_signexponent_set_hidden(srcdst) \
! 46: Deposit_dsignexponent(srcdst,1)
! 47: #define Dbl_clear_sign(srcdst) Dallp1(srcdst) &= ~(1<<31)
! 48: #define Dbl_clear_signexponent(srcdst) \
! 49: Dallp1(srcdst) &= Dmantissap1((unsigned)-1)
! 50:
! 51: /* Exponent field for doubles has already been cleared and may be
! 52: * included in the shift. Here we need to generate two double width
! 53: * variable shifts. The insignificant bits can be ignored.
! 54: * MTSAR f(varamount)
! 55: * VSHD srcdst.high,srcdst.low => srcdst.low
! 56: * VSHD 0,srcdst.high => srcdst.high
! 57: * This is very difficult to model with C expressions since the shift amount
! 58: * could exceed 32. */
! 59: /* varamount must be less than 64 */
! 60: #define Dbl_rightshift(srcdstA, srcdstB, varamount) \
! 61: {if((varamount) >= 32) { \
! 62: Dallp2(srcdstB) = Dallp1(srcdstA) >> (varamount-32); \
! 63: Dallp1(srcdstA)=0; \
! 64: } \
! 65: else if(varamount > 0) { \
! 66: Variable_shift_double(Dallp1(srcdstA), Dallp2(srcdstB), \
! 67: (varamount), Dallp2(srcdstB)); \
! 68: Dallp1(srcdstA) >>= varamount; \
! 69: } }
! 70: /* varamount must be less than 64 */
! 71: #define Dbl_rightshift_exponentmantissa(srcdstA, srcdstB, varamount) \
! 72: {if((varamount) >= 32) { \
! 73: Dallp2(srcdstB) = Dexponentmantissap1(srcdstA) >> ((varamount)-32); \
! 74: Dallp1(srcdstA) &= (1<<31); /* clear exponentmantissa field */ \
! 75: } \
! 76: else if(varamount > 0) { \
! 77: Variable_shift_double(Dexponentmantissap1(srcdstA), Dallp2(srcdstB), \
! 78: (varamount), Dallp2(srcdstB)); \
! 79: Deposit_dexponentmantissap1(srcdstA, \
! 80: (Dexponentmantissap1(srcdstA)>>(varamount))); \
! 81: } }
! 82: /* varamount must be less than 64 */
! 83: #define Dbl_leftshift(srcdstA, srcdstB, varamount) \
! 84: {if((varamount) >= 32) { \
! 85: Dallp1(srcdstA) = Dallp2(srcdstB) << (varamount-32); \
! 86: Dallp2(srcdstB)=0; \
! 87: } \
! 88: else { \
! 89: if ((varamount) > 0) { \
! 90: Dallp1(srcdstA) = (Dallp1(srcdstA) << (varamount)) | \
! 91: (Dallp2(srcdstB) >> (32-(varamount))); \
! 92: Dallp2(srcdstB) <<= varamount; \
! 93: } \
! 94: } }
! 95: #define Dbl_leftshiftby1_withextent(lefta,leftb,right,resulta,resultb) \
! 96: Shiftdouble(Dallp1(lefta), Dallp2(leftb), 31, Dallp1(resulta)); \
! 97: Shiftdouble(Dallp2(leftb), Extall(right), 31, Dallp2(resultb))
! 98:
! 99: #define Dbl_rightshiftby1_withextent(leftb,right,dst) \
! 100: Extall(dst) = (Dallp2(leftb) << 31) | ((unsigned)Extall(right) >> 1) | \
! 101: Extlow(right)
! 102:
! 103: #define Dbl_arithrightshiftby1(srcdstA,srcdstB) \
! 104: Shiftdouble(Dallp1(srcdstA),Dallp2(srcdstB),1,Dallp2(srcdstB));\
! 105: Dallp1(srcdstA) = (int)Dallp1(srcdstA) >> 1
! 106:
! 107: /* Sign extend the sign bit with an integer destination */
! 108: #define Dbl_signextendedsign(value) Dsignedsign(value)
! 109:
! 110: #define Dbl_isone_hidden(dbl_value) (Is_dhidden(dbl_value)!=0)
! 111: /* Singles and doubles may include the sign and exponent fields. The
! 112: * hidden bit and the hidden overflow must be included. */
! 113: #define Dbl_increment(dbl_valueA,dbl_valueB) \
! 114: if( (Dallp2(dbl_valueB) += 1) == 0 ) Dallp1(dbl_valueA) += 1
! 115: #define Dbl_increment_mantissa(dbl_valueA,dbl_valueB) \
! 116: if( (Dmantissap2(dbl_valueB) += 1) == 0 ) \
! 117: Deposit_dmantissap1(dbl_valueA,dbl_valueA+1)
! 118: #define Dbl_decrement(dbl_valueA,dbl_valueB) \
! 119: if( Dallp2(dbl_valueB) == 0 ) Dallp1(dbl_valueA) -= 1; \
! 120: Dallp2(dbl_valueB) -= 1
! 121:
! 122: #define Dbl_isone_sign(dbl_value) (Is_dsign(dbl_value)!=0)
! 123: #define Dbl_isone_hiddenoverflow(dbl_value) (Is_dhiddenoverflow(dbl_value)!=0)
! 124: #define Dbl_isone_lowmantissap1(dbl_valueA) (Is_dlowp1(dbl_valueA)!=0)
! 125: #define Dbl_isone_lowmantissap2(dbl_valueB) (Is_dlowp2(dbl_valueB)!=0)
! 126: #define Dbl_isone_signaling(dbl_value) (Is_dsignaling(dbl_value)!=0)
! 127: #define Dbl_is_signalingnan(dbl_value) (Dsignalingnan(dbl_value)==0xfff)
! 128: #define Dbl_isnotzero(dbl_valueA,dbl_valueB) \
! 129: (Dallp1(dbl_valueA) || Dallp2(dbl_valueB))
! 130: #define Dbl_isnotzero_hiddenhigh7mantissa(dbl_value) \
! 131: (Dhiddenhigh7mantissa(dbl_value)!=0)
! 132: #define Dbl_isnotzero_exponent(dbl_value) (Dexponent(dbl_value)!=0)
! 133: #define Dbl_isnotzero_mantissa(dbl_valueA,dbl_valueB) \
! 134: (Dmantissap1(dbl_valueA) || Dmantissap2(dbl_valueB))
! 135: #define Dbl_isnotzero_mantissap1(dbl_valueA) (Dmantissap1(dbl_valueA)!=0)
! 136: #define Dbl_isnotzero_mantissap2(dbl_valueB) (Dmantissap2(dbl_valueB)!=0)
! 137: #define Dbl_isnotzero_exponentmantissa(dbl_valueA,dbl_valueB) \
! 138: (Dexponentmantissap1(dbl_valueA) || Dmantissap2(dbl_valueB))
! 139: #define Dbl_isnotzero_low4p2(dbl_value) (Dlow4p2(dbl_value)!=0)
! 140: #define Dbl_iszero(dbl_valueA,dbl_valueB) (Dallp1(dbl_valueA)==0 && \
! 141: Dallp2(dbl_valueB)==0)
! 142: #define Dbl_iszero_allp1(dbl_value) (Dallp1(dbl_value)==0)
! 143: #define Dbl_iszero_allp2(dbl_value) (Dallp2(dbl_value)==0)
! 144: #define Dbl_iszero_hidden(dbl_value) (Is_dhidden(dbl_value)==0)
! 145: #define Dbl_iszero_hiddenoverflow(dbl_value) (Is_dhiddenoverflow(dbl_value)==0)
! 146: #define Dbl_iszero_hiddenhigh3mantissa(dbl_value) \
! 147: (Dhiddenhigh3mantissa(dbl_value)==0)
! 148: #define Dbl_iszero_hiddenhigh7mantissa(dbl_value) \
! 149: (Dhiddenhigh7mantissa(dbl_value)==0)
! 150: #define Dbl_iszero_sign(dbl_value) (Is_dsign(dbl_value)==0)
! 151: #define Dbl_iszero_exponent(dbl_value) (Dexponent(dbl_value)==0)
! 152: #define Dbl_iszero_mantissa(dbl_valueA,dbl_valueB) \
! 153: (Dmantissap1(dbl_valueA)==0 && Dmantissap2(dbl_valueB)==0)
! 154: #define Dbl_iszero_exponentmantissa(dbl_valueA,dbl_valueB) \
! 155: (Dexponentmantissap1(dbl_valueA)==0 && Dmantissap2(dbl_valueB)==0)
! 156: #define Dbl_isinfinity_exponent(dbl_value) \
! 157: (Dexponent(dbl_value)==DBL_INFINITY_EXPONENT)
! 158: #define Dbl_isnotinfinity_exponent(dbl_value) \
! 159: (Dexponent(dbl_value)!=DBL_INFINITY_EXPONENT)
! 160: #define Dbl_isinfinity(dbl_valueA,dbl_valueB) \
! 161: (Dexponent(dbl_valueA)==DBL_INFINITY_EXPONENT && \
! 162: Dmantissap1(dbl_valueA)==0 && Dmantissap2(dbl_valueB)==0)
! 163: #define Dbl_isnan(dbl_valueA,dbl_valueB) \
! 164: (Dexponent(dbl_valueA)==DBL_INFINITY_EXPONENT && \
! 165: (Dmantissap1(dbl_valueA)!=0 || Dmantissap2(dbl_valueB)!=0))
! 166: #define Dbl_isnotnan(dbl_valueA,dbl_valueB) \
! 167: (Dexponent(dbl_valueA)!=DBL_INFINITY_EXPONENT || \
! 168: (Dmantissap1(dbl_valueA)==0 && Dmantissap2(dbl_valueB)==0))
! 169:
! 170: #define Dbl_islessthan(dbl_op1a,dbl_op1b,dbl_op2a,dbl_op2b) \
! 171: (Dallp1(dbl_op1a) < Dallp1(dbl_op2a) || \
! 172: (Dallp1(dbl_op1a) == Dallp1(dbl_op2a) && \
! 173: Dallp2(dbl_op1b) < Dallp2(dbl_op2b)))
! 174: #define Dbl_isgreaterthan(dbl_op1a,dbl_op1b,dbl_op2a,dbl_op2b) \
! 175: (Dallp1(dbl_op1a) > Dallp1(dbl_op2a) || \
! 176: (Dallp1(dbl_op1a) == Dallp1(dbl_op2a) && \
! 177: Dallp2(dbl_op1b) > Dallp2(dbl_op2b)))
! 178: #define Dbl_isnotlessthan(dbl_op1a,dbl_op1b,dbl_op2a,dbl_op2b) \
! 179: (Dallp1(dbl_op1a) > Dallp1(dbl_op2a) || \
! 180: (Dallp1(dbl_op1a) == Dallp1(dbl_op2a) && \
! 181: Dallp2(dbl_op1b) >= Dallp2(dbl_op2b)))
! 182: #define Dbl_isnotgreaterthan(dbl_op1a,dbl_op1b,dbl_op2a,dbl_op2b) \
! 183: (Dallp1(dbl_op1a) < Dallp1(dbl_op2a) || \
! 184: (Dallp1(dbl_op1a) == Dallp1(dbl_op2a) && \
! 185: Dallp2(dbl_op1b) <= Dallp2(dbl_op2b)))
! 186: #define Dbl_isequal(dbl_op1a,dbl_op1b,dbl_op2a,dbl_op2b) \
! 187: ((Dallp1(dbl_op1a) == Dallp1(dbl_op2a)) && \
! 188: (Dallp2(dbl_op1b) == Dallp2(dbl_op2b)))
! 189:
! 190: #define Dbl_leftshiftby8(dbl_valueA,dbl_valueB) \
! 191: Shiftdouble(Dallp1(dbl_valueA),Dallp2(dbl_valueB),24,Dallp1(dbl_valueA)); \
! 192: Dallp2(dbl_valueB) <<= 8
! 193: #define Dbl_leftshiftby7(dbl_valueA,dbl_valueB) \
! 194: Shiftdouble(Dallp1(dbl_valueA),Dallp2(dbl_valueB),25,Dallp1(dbl_valueA)); \
! 195: Dallp2(dbl_valueB) <<= 7
! 196: #define Dbl_leftshiftby4(dbl_valueA,dbl_valueB) \
! 197: Shiftdouble(Dallp1(dbl_valueA),Dallp2(dbl_valueB),28,Dallp1(dbl_valueA)); \
! 198: Dallp2(dbl_valueB) <<= 4
! 199: #define Dbl_leftshiftby3(dbl_valueA,dbl_valueB) \
! 200: Shiftdouble(Dallp1(dbl_valueA),Dallp2(dbl_valueB),29,Dallp1(dbl_valueA)); \
! 201: Dallp2(dbl_valueB) <<= 3
! 202: #define Dbl_leftshiftby2(dbl_valueA,dbl_valueB) \
! 203: Shiftdouble(Dallp1(dbl_valueA),Dallp2(dbl_valueB),30,Dallp1(dbl_valueA)); \
! 204: Dallp2(dbl_valueB) <<= 2
! 205: #define Dbl_leftshiftby1(dbl_valueA,dbl_valueB) \
! 206: Shiftdouble(Dallp1(dbl_valueA),Dallp2(dbl_valueB),31,Dallp1(dbl_valueA)); \
! 207: Dallp2(dbl_valueB) <<= 1
! 208:
! 209: #define Dbl_rightshiftby8(dbl_valueA,dbl_valueB) \
! 210: Shiftdouble(Dallp1(dbl_valueA),Dallp2(dbl_valueB),8,Dallp2(dbl_valueB)); \
! 211: Dallp1(dbl_valueA) >>= 8
! 212: #define Dbl_rightshiftby4(dbl_valueA,dbl_valueB) \
! 213: Shiftdouble(Dallp1(dbl_valueA),Dallp2(dbl_valueB),4,Dallp2(dbl_valueB)); \
! 214: Dallp1(dbl_valueA) >>= 4
! 215: #define Dbl_rightshiftby2(dbl_valueA,dbl_valueB) \
! 216: Shiftdouble(Dallp1(dbl_valueA),Dallp2(dbl_valueB),2,Dallp2(dbl_valueB)); \
! 217: Dallp1(dbl_valueA) >>= 2
! 218: #define Dbl_rightshiftby1(dbl_valueA,dbl_valueB) \
! 219: Shiftdouble(Dallp1(dbl_valueA),Dallp2(dbl_valueB),1,Dallp2(dbl_valueB)); \
! 220: Dallp1(dbl_valueA) >>= 1
! 221:
! 222: /* This magnitude comparison uses the signless first words and
! 223: * the regular part2 words. The comparison is graphically:
! 224: *
! 225: * 1st greater? -------------
! 226: * |
! 227: * 1st less?-----------------+---------
! 228: * | |
! 229: * 2nd greater or equal----->| |
! 230: * False True
! 231: */
! 232: #define Dbl_ismagnitudeless(leftB,rightB,signlessleft,signlessright) \
! 233: ((signlessleft <= signlessright) && \
! 234: ( (signlessleft < signlessright) || (Dallp2(leftB)<Dallp2(rightB)) ))
! 235:
! 236: #define Dbl_copytoint_exponentmantissap1(src,dest) \
! 237: dest = Dexponentmantissap1(src)
! 238:
! 239: /* A quiet NaN has the high mantissa bit clear and at least on other (in this
! 240: * case the adjacent bit) bit set. */
! 241: #define Dbl_set_quiet(dbl_value) Deposit_dhigh2mantissa(dbl_value,1)
! 242: #define Dbl_set_exponent(dbl_value, exp) Deposit_dexponent(dbl_value,exp)
! 243:
! 244: #define Dbl_set_mantissa(desta,destb,valuea,valueb) \
! 245: Deposit_dmantissap1(desta,valuea); \
! 246: Dmantissap2(destb) = Dmantissap2(valueb)
! 247: #define Dbl_set_mantissap1(desta,valuea) \
! 248: Deposit_dmantissap1(desta,valuea)
! 249: #define Dbl_set_mantissap2(destb,valueb) \
! 250: Dmantissap2(destb) = Dmantissap2(valueb)
! 251:
! 252: #define Dbl_set_exponentmantissa(desta,destb,valuea,valueb) \
! 253: Deposit_dexponentmantissap1(desta,valuea); \
! 254: Dmantissap2(destb) = Dmantissap2(valueb)
! 255: #define Dbl_set_exponentmantissap1(dest,value) \
! 256: Deposit_dexponentmantissap1(dest,value)
! 257:
! 258: #define Dbl_copyfromptr(src,desta,destb) \
! 259: Dallp1(desta) = src->wd0; \
! 260: Dallp2(destb) = src->wd1
! 261: #define Dbl_copytoptr(srca,srcb,dest) \
! 262: dest->wd0 = Dallp1(srca); \
! 263: dest->wd1 = Dallp2(srcb)
! 264:
! 265: /* An infinity is represented with the max exponent and a zero mantissa */
! 266: #define Dbl_setinfinity_exponent(dbl_value) \
! 267: Deposit_dexponent(dbl_value,DBL_INFINITY_EXPONENT)
! 268: #define Dbl_setinfinity_exponentmantissa(dbl_valueA,dbl_valueB) \
! 269: Deposit_dexponentmantissap1(dbl_valueA, \
! 270: (DBL_INFINITY_EXPONENT << (32-(1+DBL_EXP_LENGTH)))); \
! 271: Dmantissap2(dbl_valueB) = 0
! 272: #define Dbl_setinfinitypositive(dbl_valueA,dbl_valueB) \
! 273: Dallp1(dbl_valueA) \
! 274: = (DBL_INFINITY_EXPONENT << (32-(1+DBL_EXP_LENGTH))); \
! 275: Dmantissap2(dbl_valueB) = 0
! 276: #define Dbl_setinfinitynegative(dbl_valueA,dbl_valueB) \
! 277: Dallp1(dbl_valueA) = (1<<31) | \
! 278: (DBL_INFINITY_EXPONENT << (32-(1+DBL_EXP_LENGTH))); \
! 279: Dmantissap2(dbl_valueB) = 0
! 280: #define Dbl_setinfinity(dbl_valueA,dbl_valueB,sign) \
! 281: Dallp1(dbl_valueA) = (sign << 31) | \
! 282: (DBL_INFINITY_EXPONENT << (32-(1+DBL_EXP_LENGTH))); \
! 283: Dmantissap2(dbl_valueB) = 0
! 284:
! 285: #define Dbl_sethigh4bits(dbl_value, extsign) Deposit_dhigh4p1(dbl_value,extsign)
! 286: #define Dbl_set_sign(dbl_value,sign) Deposit_dsign(dbl_value,sign)
! 287: #define Dbl_invert_sign(dbl_value) Deposit_dsign(dbl_value,~Dsign(dbl_value))
! 288: #define Dbl_setone_sign(dbl_value) Deposit_dsign(dbl_value,1)
! 289: #define Dbl_setone_lowmantissap2(dbl_value) Deposit_dlowp2(dbl_value,1)
! 290: #define Dbl_setzero_sign(dbl_value) Dallp1(dbl_value) &= 0x7fffffff
! 291: #define Dbl_setzero_exponent(dbl_value) \
! 292: Dallp1(dbl_value) &= 0x800fffff
! 293: #define Dbl_setzero_mantissa(dbl_valueA,dbl_valueB) \
! 294: Dallp1(dbl_valueA) &= 0xfff00000; \
! 295: Dallp2(dbl_valueB) = 0
! 296: #define Dbl_setzero_mantissap1(dbl_value) Dallp1(dbl_value) &= 0xfff00000
! 297: #define Dbl_setzero_mantissap2(dbl_value) Dallp2(dbl_value) = 0
! 298: #define Dbl_setzero_exponentmantissa(dbl_valueA,dbl_valueB) \
! 299: Dallp1(dbl_valueA) &= 0x80000000; \
! 300: Dallp2(dbl_valueB) = 0
! 301: #define Dbl_setzero_exponentmantissap1(dbl_valueA) \
! 302: Dallp1(dbl_valueA) &= 0x80000000
! 303: #define Dbl_setzero(dbl_valueA,dbl_valueB) \
! 304: Dallp1(dbl_valueA) = 0; Dallp2(dbl_valueB) = 0
! 305: #define Dbl_setzerop1(dbl_value) Dallp1(dbl_value) = 0
! 306: #define Dbl_setzerop2(dbl_value) Dallp2(dbl_value) = 0
! 307: #define Dbl_setnegativezero(dbl_value) \
! 308: Dallp1(dbl_value) = 1 << 31; Dallp2(dbl_value) = 0
! 309: #define Dbl_setnegativezerop1(dbl_value) Dallp1(dbl_value) = 1 << 31
! 310:
! 311: /* Use the following macro for both overflow & underflow conditions */
! 312: #define ovfl -
! 313: #define unfl +
! 314: #define Dbl_setwrapped_exponent(dbl_value,exponent,op) \
! 315: Deposit_dexponent(dbl_value,(exponent op DBL_WRAP))
! 316:
! 317: #define Dbl_setlargestpositive(dbl_valueA,dbl_valueB) \
! 318: Dallp1(dbl_valueA) = ((DBL_EMAX+DBL_BIAS) << (32-(1+DBL_EXP_LENGTH))) \
! 319: | ((1<<(32-(1+DBL_EXP_LENGTH))) - 1 ); \
! 320: Dallp2(dbl_valueB) = 0xFFFFFFFF
! 321: #define Dbl_setlargestnegative(dbl_valueA,dbl_valueB) \
! 322: Dallp1(dbl_valueA) = ((DBL_EMAX+DBL_BIAS) << (32-(1+DBL_EXP_LENGTH))) \
! 323: | ((1<<(32-(1+DBL_EXP_LENGTH))) - 1 ) | (1<<31); \
! 324: Dallp2(dbl_valueB) = 0xFFFFFFFF
! 325: #define Dbl_setlargest_exponentmantissa(dbl_valueA,dbl_valueB) \
! 326: Deposit_dexponentmantissap1(dbl_valueA, \
! 327: (((DBL_EMAX+DBL_BIAS) << (32-(1+DBL_EXP_LENGTH))) \
! 328: | ((1<<(32-(1+DBL_EXP_LENGTH))) - 1 ))); \
! 329: Dallp2(dbl_valueB) = 0xFFFFFFFF
! 330:
! 331: #define Dbl_setnegativeinfinity(dbl_valueA,dbl_valueB) \
! 332: Dallp1(dbl_valueA) = ((1<<DBL_EXP_LENGTH) | DBL_INFINITY_EXPONENT) \
! 333: << (32-(1+DBL_EXP_LENGTH)) ; \
! 334: Dallp2(dbl_valueB) = 0
! 335: #define Dbl_setlargest(dbl_valueA,dbl_valueB,sign) \
! 336: Dallp1(dbl_valueA) = (sign << 31) | \
! 337: ((DBL_EMAX+DBL_BIAS) << (32-(1+DBL_EXP_LENGTH))) | \
! 338: ((1 << (32-(1+DBL_EXP_LENGTH))) - 1 ); \
! 339: Dallp2(dbl_valueB) = 0xFFFFFFFF
! 340:
! 341:
! 342: /* The high bit is always zero so arithmetic or logical shifts will work. */
! 343: #define Dbl_right_align(srcdstA,srcdstB,shift,extent) \
! 344: if( shift >= 32 ) \
! 345: { \
! 346: /* Big shift requires examining the portion shift off \
! 347: the end to properly set inexact. */ \
! 348: if(shift < 64) \
! 349: { \
! 350: if(shift > 32) \
! 351: { \
! 352: Variable_shift_double(Dallp1(srcdstA),Dallp2(srcdstB), \
! 353: shift-32, Extall(extent)); \
! 354: if(Dallp2(srcdstB) << (64 - (shift))) Ext_setone_low(extent); \
! 355: } \
! 356: else Extall(extent) = Dallp2(srcdstB); \
! 357: Dallp2(srcdstB) = Dallp1(srcdstA) >> (shift - 32); \
! 358: } \
! 359: else \
! 360: { \
! 361: Extall(extent) = Dallp1(srcdstA); \
! 362: if(Dallp2(srcdstB)) Ext_setone_low(extent); \
! 363: Dallp2(srcdstB) = 0; \
! 364: } \
! 365: Dallp1(srcdstA) = 0; \
! 366: } \
! 367: else \
! 368: { \
! 369: /* Small alignment is simpler. Extension is easily set. */ \
! 370: if (shift > 0) \
! 371: { \
! 372: Extall(extent) = Dallp2(srcdstB) << (32 - (shift)); \
! 373: Variable_shift_double(Dallp1(srcdstA),Dallp2(srcdstB),shift, \
! 374: Dallp2(srcdstB)); \
! 375: Dallp1(srcdstA) >>= shift; \
! 376: } \
! 377: else Extall(extent) = 0; \
! 378: }
! 379:
! 380: /*
! 381: * Here we need to shift the result right to correct for an overshift
! 382: * (due to the exponent becoming negative) during normalization.
! 383: */
! 384: #define Dbl_fix_overshift(srcdstA,srcdstB,shift,extent) \
! 385: Extall(extent) = Dallp2(srcdstB) << (32 - (shift)); \
! 386: Dallp2(srcdstB) = (Dallp1(srcdstA) << (32 - (shift))) | \
! 387: (Dallp2(srcdstB) >> (shift)); \
! 388: Dallp1(srcdstA) = Dallp1(srcdstA) >> shift
! 389:
! 390: #define Dbl_hiddenhigh3mantissa(dbl_value) Dhiddenhigh3mantissa(dbl_value)
! 391: #define Dbl_hidden(dbl_value) Dhidden(dbl_value)
! 392: #define Dbl_lowmantissap2(dbl_value) Dlowp2(dbl_value)
! 393:
! 394: /* The left argument is never smaller than the right argument */
! 395: #define Dbl_subtract(lefta,leftb,righta,rightb,resulta,resultb) \
! 396: if( Dallp2(rightb) > Dallp2(leftb) ) Dallp1(lefta)--; \
! 397: Dallp2(resultb) = Dallp2(leftb) - Dallp2(rightb); \
! 398: Dallp1(resulta) = Dallp1(lefta) - Dallp1(righta)
! 399:
! 400: /* Subtract right augmented with extension from left augmented with zeros and
! 401: * store into result and extension. */
! 402: #define Dbl_subtract_withextension(lefta,leftb,righta,rightb,extent,resulta,resultb) \
! 403: Dbl_subtract(lefta,leftb,righta,rightb,resulta,resultb); \
! 404: if( (Extall(extent) = 0-Extall(extent)) ) \
! 405: { \
! 406: if((Dallp2(resultb)--) == 0) Dallp1(resulta)--; \
! 407: }
! 408:
! 409: #define Dbl_addition(lefta,leftb,righta,rightb,resulta,resultb) \
! 410: /* If the sum of the low words is less than either source, then \
! 411: * an overflow into the next word occurred. */ \
! 412: Dallp1(resulta) = Dallp1(lefta) + Dallp1(righta); \
! 413: if((Dallp2(resultb) = Dallp2(leftb) + Dallp2(rightb)) < Dallp2(rightb)) \
! 414: Dallp1(resulta)++
! 415:
! 416: #define Dbl_xortointp1(left,right,result) \
! 417: result = Dallp1(left) XOR Dallp1(right)
! 418:
! 419: #define Dbl_xorfromintp1(left,right,result) \
! 420: Dallp1(result) = left XOR Dallp1(right)
! 421:
! 422: #define Dbl_swap_lower(left,right) \
! 423: Dallp2(left) = Dallp2(left) XOR Dallp2(right); \
! 424: Dallp2(right) = Dallp2(left) XOR Dallp2(right); \
! 425: Dallp2(left) = Dallp2(left) XOR Dallp2(right)
! 426:
! 427: /* Need to Initialize */
! 428: #define Dbl_makequietnan(desta,destb) \
! 429: Dallp1(desta) = ((DBL_EMAX+DBL_BIAS)+1)<< (32-(1+DBL_EXP_LENGTH)) \
! 430: | (1<<(32-(1+DBL_EXP_LENGTH+2))); \
! 431: Dallp2(destb) = 0
! 432: #define Dbl_makesignalingnan(desta,destb) \
! 433: Dallp1(desta) = ((DBL_EMAX+DBL_BIAS)+1)<< (32-(1+DBL_EXP_LENGTH)) \
! 434: | (1<<(32-(1+DBL_EXP_LENGTH+1))); \
! 435: Dallp2(destb) = 0
! 436:
! 437: #define Dbl_normalize(dbl_opndA,dbl_opndB,exponent) \
! 438: while(Dbl_iszero_hiddenhigh7mantissa(dbl_opndA)) { \
! 439: Dbl_leftshiftby8(dbl_opndA,dbl_opndB); \
! 440: exponent -= 8; \
! 441: } \
! 442: if(Dbl_iszero_hiddenhigh3mantissa(dbl_opndA)) { \
! 443: Dbl_leftshiftby4(dbl_opndA,dbl_opndB); \
! 444: exponent -= 4; \
! 445: } \
! 446: while(Dbl_iszero_hidden(dbl_opndA)) { \
! 447: Dbl_leftshiftby1(dbl_opndA,dbl_opndB); \
! 448: exponent -= 1; \
! 449: }
! 450:
! 451: #define Twoword_add(src1dstA,src1dstB,src2A,src2B) \
! 452: /* \
! 453: * want this macro to generate: \
! 454: * ADD src1dstB,src2B,src1dstB; \
! 455: * ADDC src1dstA,src2A,src1dstA; \
! 456: */ \
! 457: if ((src1dstB) + (src2B) < (src1dstB)) Dallp1(src1dstA)++; \
! 458: Dallp1(src1dstA) += (src2A); \
! 459: Dallp2(src1dstB) += (src2B)
! 460:
! 461: #define Twoword_subtract(src1dstA,src1dstB,src2A,src2B) \
! 462: /* \
! 463: * want this macro to generate: \
! 464: * SUB src1dstB,src2B,src1dstB; \
! 465: * SUBB src1dstA,src2A,src1dstA; \
! 466: */ \
! 467: if ((src1dstB) < (src2B)) Dallp1(src1dstA)--; \
! 468: Dallp1(src1dstA) -= (src2A); \
! 469: Dallp2(src1dstB) -= (src2B)
! 470:
! 471: #define Dbl_setoverflow(resultA,resultB) \
! 472: /* set result to infinity or largest number */ \
! 473: switch (Rounding_mode()) { \
! 474: case ROUNDPLUS: \
! 475: if (Dbl_isone_sign(resultA)) { \
! 476: Dbl_setlargestnegative(resultA,resultB); \
! 477: } \
! 478: else { \
! 479: Dbl_setinfinitypositive(resultA,resultB); \
! 480: } \
! 481: break; \
! 482: case ROUNDMINUS: \
! 483: if (Dbl_iszero_sign(resultA)) { \
! 484: Dbl_setlargestpositive(resultA,resultB); \
! 485: } \
! 486: else { \
! 487: Dbl_setinfinitynegative(resultA,resultB); \
! 488: } \
! 489: break; \
! 490: case ROUNDNEAREST: \
! 491: Dbl_setinfinity_exponentmantissa(resultA,resultB); \
! 492: break; \
! 493: case ROUNDZERO: \
! 494: Dbl_setlargest_exponentmantissa(resultA,resultB); \
! 495: }
! 496:
! 497: #define Dbl_denormalize(opndp1,opndp2,exponent,guard,sticky,inexact) \
! 498: Dbl_clear_signexponent_set_hidden(opndp1); \
! 499: if (exponent >= (1-DBL_P)) { \
! 500: if (exponent >= -31) { \
! 501: guard = (Dallp2(opndp2) >> (-(exponent))) & 1; \
! 502: if (exponent < 0) sticky |= Dallp2(opndp2) << (32+exponent); \
! 503: if (exponent > -31) { \
! 504: Variable_shift_double(opndp1,opndp2,1-exponent,opndp2); \
! 505: Dallp1(opndp1) >>= 1-exponent; \
! 506: } \
! 507: else { \
! 508: Dallp2(opndp2) = Dallp1(opndp1); \
! 509: Dbl_setzerop1(opndp1); \
! 510: } \
! 511: } \
! 512: else { \
! 513: guard = (Dallp1(opndp1) >> (-32-(exponent))) & 1; \
! 514: if (exponent == -32) sticky |= Dallp2(opndp2); \
! 515: else sticky |= (Dallp2(opndp2) | Dallp1(opndp1) << (64+(exponent))); \
! 516: Dallp2(opndp2) = Dallp1(opndp1) >> (-31-(exponent)); \
! 517: Dbl_setzerop1(opndp1); \
! 518: } \
! 519: inexact = guard | sticky; \
! 520: } \
! 521: else { \
! 522: guard = 0; \
! 523: sticky |= (Dallp1(opndp1) | Dallp2(opndp2)); \
! 524: Dbl_setzero(opndp1,opndp2); \
! 525: inexact = sticky; \
! 526: }
! 527:
! 528:
! 529: int dbl_fadd(dbl_floating_point *, dbl_floating_point *, dbl_floating_point *, unsigned int *);
! 530: int dbl_fcmp(dbl_floating_point *, dbl_floating_point *, unsigned int, unsigned int *);
! 531: int dbl_fdiv(dbl_floating_point *, dbl_floating_point *, dbl_floating_point *, unsigned int *);
! 532: int dbl_fmpy(dbl_floating_point *, dbl_floating_point *, dbl_floating_point *, unsigned int *);
! 533: int dbl_frem(dbl_floating_point *, dbl_floating_point *, dbl_floating_point *, unsigned int *);
! 534: int dbl_fsqrt(dbl_floating_point *, dbl_floating_point *, dbl_floating_point *, unsigned int *);
! 535: int dbl_fsub(dbl_floating_point *, dbl_floating_point *, dbl_floating_point *, unsigned int *);
! 536:
! 537: int sgl_to_dbl_fcnvff(sgl_floating_point *, sgl_floating_point *, dbl_floating_point *, unsigned int *);
! 538: int dbl_to_sgl_fcnvff(dbl_floating_point *, dbl_floating_point *, sgl_floating_point *, unsigned int *);
! 539:
! 540: int dbl_frnd(dbl_floating_point *, dbl_floating_point *, dbl_floating_point *, unsigned int *);
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to dbl_float.h CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / hppa / spmath