1/* 2 * Linux/PA-RISC Project (http://www.parisc-linux.org/) 3 * 4 * Floating-point emulation code 5 * Copyright (C) 2001 Hewlett-Packard (Paul Bame) <bame@debian.org> 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License as published by 9 * the Free Software Foundation; either version 2, or (at your option) 10 * any later version. 11 * 12 * This program is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * GNU General Public License for more details. 16 * 17 * You should have received a copy of the GNU General Public License 18 * along with this program; if not, write to the Free Software 19 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 20 */ 21#ifdef __NO_PA_HDRS 22 PA header file -- do not include this header file for non-PA builds. 23#endif 24 25/* 32-bit word grabing functions */ 26#define Dbl_firstword(value) Dallp1(value) 27#define Dbl_secondword(value) Dallp2(value) 28#define Dbl_thirdword(value) dummy_location 29#define Dbl_fourthword(value) dummy_location 30 31#define Dbl_sign(object) Dsign(object) 32#define Dbl_exponent(object) Dexponent(object) 33#define Dbl_signexponent(object) Dsignexponent(object) 34#define Dbl_mantissap1(object) Dmantissap1(object) 35#define Dbl_mantissap2(object) Dmantissap2(object) 36#define Dbl_exponentmantissap1(object) Dexponentmantissap1(object) 37#define Dbl_allp1(object) Dallp1(object) 38#define Dbl_allp2(object) Dallp2(object) 39 40/* dbl_and_signs ands the sign bits of each argument and puts the result 41 * into the first argument. dbl_or_signs ors those same sign bits */ 42#define Dbl_and_signs( src1dst, src2) \ 43 Dallp1(src1dst) = (Dallp1(src2)|~((unsigned int)1<<31)) & Dallp1(src1dst) 44#define Dbl_or_signs( src1dst, src2) \ 45 Dallp1(src1dst) = (Dallp1(src2)&((unsigned int)1<<31)) | Dallp1(src1dst) 46 47/* The hidden bit is always the low bit of the exponent */ 48#define Dbl_clear_exponent_set_hidden(srcdst) Deposit_dexponent(srcdst,1) 49#define Dbl_clear_signexponent_set_hidden(srcdst) \ 50 Deposit_dsignexponent(srcdst,1) 51#define Dbl_clear_sign(srcdst) Dallp1(srcdst) &= ~((unsigned int)1<<31) 52#define Dbl_clear_signexponent(srcdst) \ 53 Dallp1(srcdst) &= Dmantissap1((unsigned int)-1) 54 55/* Exponent field for doubles has already been cleared and may be 56 * included in the shift. Here we need to generate two double width 57 * variable shifts. The insignificant bits can be ignored. 58 * MTSAR f(varamount) 59 * VSHD srcdst.high,srcdst.low => srcdst.low 60 * VSHD 0,srcdst.high => srcdst.high 61 * This is very difficult to model with C expressions since the shift amount 62 * could exceed 32. */ 63/* varamount must be less than 64 */ 64#define Dbl_rightshift(srcdstA, srcdstB, varamount) \ 65 {if((varamount) >= 32) { \ 66 Dallp2(srcdstB) = Dallp1(srcdstA) >> (varamount-32); \ 67 Dallp1(srcdstA)=0; \ 68 } \ 69 else if(varamount > 0) { \ 70 Variable_shift_double(Dallp1(srcdstA), Dallp2(srcdstB), \ 71 (varamount), Dallp2(srcdstB)); \ 72 Dallp1(srcdstA) >>= varamount; \ 73 } } 74/* varamount must be less than 64 */ 75#define Dbl_rightshift_exponentmantissa(srcdstA, srcdstB, varamount) \ 76 {if((varamount) >= 32) { \ 77 Dallp2(srcdstB) = Dexponentmantissap1(srcdstA) >> (varamount-32); \ 78 Dallp1(srcdstA) &= ((unsigned int)1<<31); /* clear expmant field */ \ 79 } \ 80 else if(varamount > 0) { \ 81 Variable_shift_double(Dexponentmantissap1(srcdstA), Dallp2(srcdstB), \ 82 (varamount), Dallp2(srcdstB)); \ 83 Deposit_dexponentmantissap1(srcdstA, \ 84 (Dexponentmantissap1(srcdstA)>>varamount)); \ 85 } } 86/* varamount must be less than 64 */ 87#define Dbl_leftshift(srcdstA, srcdstB, varamount) \ 88 {if((varamount) >= 32) { \ 89 Dallp1(srcdstA) = Dallp2(srcdstB) << (varamount-32); \ 90 Dallp2(srcdstB)=0; \ 91 } \ 92 else { \ 93 if ((varamount) > 0) { \ 94 Dallp1(srcdstA) = (Dallp1(srcdstA) << (varamount)) | \ 95 (Dallp2(srcdstB) >> (32-(varamount))); \ 96 Dallp2(srcdstB) <<= varamount; \ 97 } \ 98 } } 99#define Dbl_leftshiftby1_withextent(lefta,leftb,right,resulta,resultb) \ 100 Shiftdouble(Dallp1(lefta), Dallp2(leftb), 31, Dallp1(resulta)); \ 101 Shiftdouble(Dallp2(leftb), Extall(right), 31, Dallp2(resultb)) 102 103#define Dbl_rightshiftby1_withextent(leftb,right,dst) \ 104 Extall(dst) = (Dallp2(leftb) << 31) | ((unsigned int)Extall(right) >> 1) | \ 105 Extlow(right) 106 107#define Dbl_arithrightshiftby1(srcdstA,srcdstB) \ 108 Shiftdouble(Dallp1(srcdstA),Dallp2(srcdstB),1,Dallp2(srcdstB));\ 109 Dallp1(srcdstA) = (int)Dallp1(srcdstA) >> 1 110 111/* Sign extend the sign bit with an integer destination */ 112#define Dbl_signextendedsign(value) Dsignedsign(value) 113 114#define Dbl_isone_hidden(dbl_value) (Is_dhidden(dbl_value)!=0) 115/* Singles and doubles may include the sign and exponent fields. The 116 * hidden bit and the hidden overflow must be included. */ 117#define Dbl_increment(dbl_valueA,dbl_valueB) \ 118 if( (Dallp2(dbl_valueB) += 1) == 0 ) Dallp1(dbl_valueA) += 1 119#define Dbl_increment_mantissa(dbl_valueA,dbl_valueB) \ 120 if( (Dmantissap2(dbl_valueB) += 1) == 0 ) \ 121 Deposit_dmantissap1(dbl_valueA,dbl_valueA+1) 122#define Dbl_decrement(dbl_valueA,dbl_valueB) \ 123 if( Dallp2(dbl_valueB) == 0 ) Dallp1(dbl_valueA) -= 1; \ 124 Dallp2(dbl_valueB) -= 1 125 126#define Dbl_isone_sign(dbl_value) (Is_dsign(dbl_value)!=0) 127#define Dbl_isone_hiddenoverflow(dbl_value) (Is_dhiddenoverflow(dbl_value)!=0) 128#define Dbl_isone_lowmantissap1(dbl_valueA) (Is_dlowp1(dbl_valueA)!=0) 129#define Dbl_isone_lowmantissap2(dbl_valueB) (Is_dlowp2(dbl_valueB)!=0) 130#define Dbl_isone_signaling(dbl_value) (Is_dsignaling(dbl_value)!=0) 131#define Dbl_is_signalingnan(dbl_value) (Dsignalingnan(dbl_value)==0xfff) 132#define Dbl_isnotzero(dbl_valueA,dbl_valueB) \ 133 (Dallp1(dbl_valueA) || Dallp2(dbl_valueB)) 134#define Dbl_isnotzero_hiddenhigh7mantissa(dbl_value) \ 135 (Dhiddenhigh7mantissa(dbl_value)!=0) 136#define Dbl_isnotzero_exponent(dbl_value) (Dexponent(dbl_value)!=0) 137#define Dbl_isnotzero_mantissa(dbl_valueA,dbl_valueB) \ 138 (Dmantissap1(dbl_valueA) || Dmantissap2(dbl_valueB)) 139#define Dbl_isnotzero_mantissap1(dbl_valueA) (Dmantissap1(dbl_valueA)!=0) 140#define Dbl_isnotzero_mantissap2(dbl_valueB) (Dmantissap2(dbl_valueB)!=0) 141#define Dbl_isnotzero_exponentmantissa(dbl_valueA,dbl_valueB) \ 142 (Dexponentmantissap1(dbl_valueA) || Dmantissap2(dbl_valueB)) 143#define Dbl_isnotzero_low4p2(dbl_value) (Dlow4p2(dbl_value)!=0) 144#define Dbl_iszero(dbl_valueA,dbl_valueB) (Dallp1(dbl_valueA)==0 && \ 145 Dallp2(dbl_valueB)==0) 146#define Dbl_iszero_allp1(dbl_value) (Dallp1(dbl_value)==0) 147#define Dbl_iszero_allp2(dbl_value) (Dallp2(dbl_value)==0) 148#define Dbl_iszero_hidden(dbl_value) (Is_dhidden(dbl_value)==0) 149#define Dbl_iszero_hiddenoverflow(dbl_value) (Is_dhiddenoverflow(dbl_value)==0) 150#define Dbl_iszero_hiddenhigh3mantissa(dbl_value) \ 151 (Dhiddenhigh3mantissa(dbl_value)==0) 152#define Dbl_iszero_hiddenhigh7mantissa(dbl_value) \ 153 (Dhiddenhigh7mantissa(dbl_value)==0) 154#define Dbl_iszero_sign(dbl_value) (Is_dsign(dbl_value)==0) 155#define Dbl_iszero_exponent(dbl_value) (Dexponent(dbl_value)==0) 156#define Dbl_iszero_mantissa(dbl_valueA,dbl_valueB) \ 157 (Dmantissap1(dbl_valueA)==0 && Dmantissap2(dbl_valueB)==0) 158#define Dbl_iszero_exponentmantissa(dbl_valueA,dbl_valueB) \ 159 (Dexponentmantissap1(dbl_valueA)==0 && Dmantissap2(dbl_valueB)==0) 160#define Dbl_isinfinity_exponent(dbl_value) \ 161 (Dexponent(dbl_value)==DBL_INFINITY_EXPONENT) 162#define Dbl_isnotinfinity_exponent(dbl_value) \ 163 (Dexponent(dbl_value)!=DBL_INFINITY_EXPONENT) 164#define Dbl_isinfinity(dbl_valueA,dbl_valueB) \ 165 (Dexponent(dbl_valueA)==DBL_INFINITY_EXPONENT && \ 166 Dmantissap1(dbl_valueA)==0 && Dmantissap2(dbl_valueB)==0) 167#define Dbl_isnan(dbl_valueA,dbl_valueB) \ 168 (Dexponent(dbl_valueA)==DBL_INFINITY_EXPONENT && \ 169 (Dmantissap1(dbl_valueA)!=0 || Dmantissap2(dbl_valueB)!=0)) 170#define Dbl_isnotnan(dbl_valueA,dbl_valueB) \ 171 (Dexponent(dbl_valueA)!=DBL_INFINITY_EXPONENT || \ 172 (Dmantissap1(dbl_valueA)==0 && Dmantissap2(dbl_valueB)==0)) 173 174#define Dbl_islessthan(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_isgreaterthan(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_isnotlessthan(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_isnotgreaterthan(dbl_op1a,dbl_op1b,dbl_op2a,dbl_op2b) \ 187 (Dallp1(dbl_op1a) < Dallp1(dbl_op2a) || \ 188 (Dallp1(dbl_op1a) == Dallp1(dbl_op2a) && \ 189 Dallp2(dbl_op1b) <= Dallp2(dbl_op2b))) 190#define Dbl_isequal(dbl_op1a,dbl_op1b,dbl_op2a,dbl_op2b) \ 191 ((Dallp1(dbl_op1a) == Dallp1(dbl_op2a)) && \ 192 (Dallp2(dbl_op1b) == Dallp2(dbl_op2b))) 193 194#define Dbl_leftshiftby8(dbl_valueA,dbl_valueB) \ 195 Shiftdouble(Dallp1(dbl_valueA),Dallp2(dbl_valueB),24,Dallp1(dbl_valueA)); \ 196 Dallp2(dbl_valueB) <<= 8 197#define Dbl_leftshiftby7(dbl_valueA,dbl_valueB) \ 198 Shiftdouble(Dallp1(dbl_valueA),Dallp2(dbl_valueB),25,Dallp1(dbl_valueA)); \ 199 Dallp2(dbl_valueB) <<= 7 200#define Dbl_leftshiftby4(dbl_valueA,dbl_valueB) \ 201 Shiftdouble(Dallp1(dbl_valueA),Dallp2(dbl_valueB),28,Dallp1(dbl_valueA)); \ 202 Dallp2(dbl_valueB) <<= 4 203#define Dbl_leftshiftby3(dbl_valueA,dbl_valueB) \ 204 Shiftdouble(Dallp1(dbl_valueA),Dallp2(dbl_valueB),29,Dallp1(dbl_valueA)); \ 205 Dallp2(dbl_valueB) <<= 3 206#define Dbl_leftshiftby2(dbl_valueA,dbl_valueB) \ 207 Shiftdouble(Dallp1(dbl_valueA),Dallp2(dbl_valueB),30,Dallp1(dbl_valueA)); \ 208 Dallp2(dbl_valueB) <<= 2 209#define Dbl_leftshiftby1(dbl_valueA,dbl_valueB) \ 210 Shiftdouble(Dallp1(dbl_valueA),Dallp2(dbl_valueB),31,Dallp1(dbl_valueA)); \ 211 Dallp2(dbl_valueB) <<= 1 212 213#define Dbl_rightshiftby8(dbl_valueA,dbl_valueB) \ 214 Shiftdouble(Dallp1(dbl_valueA),Dallp2(dbl_valueB),8,Dallp2(dbl_valueB)); \ 215 Dallp1(dbl_valueA) >>= 8 216#define Dbl_rightshiftby4(dbl_valueA,dbl_valueB) \ 217 Shiftdouble(Dallp1(dbl_valueA),Dallp2(dbl_valueB),4,Dallp2(dbl_valueB)); \ 218 Dallp1(dbl_valueA) >>= 4 219#define Dbl_rightshiftby2(dbl_valueA,dbl_valueB) \ 220 Shiftdouble(Dallp1(dbl_valueA),Dallp2(dbl_valueB),2,Dallp2(dbl_valueB)); \ 221 Dallp1(dbl_valueA) >>= 2 222#define Dbl_rightshiftby1(dbl_valueA,dbl_valueB) \ 223 Shiftdouble(Dallp1(dbl_valueA),Dallp2(dbl_valueB),1,Dallp2(dbl_valueB)); \ 224 Dallp1(dbl_valueA) >>= 1 225 226/* This magnitude comparison uses the signless first words and 227 * the regular part2 words. The comparison is graphically: 228 * 229 * 1st greater? ------------- 230 * | 231 * 1st less?-----------------+--------- 232 * | | 233 * 2nd greater or equal----->| | 234 * False True 235 */ 236#define Dbl_ismagnitudeless(leftB,rightB,signlessleft,signlessright) \ 237 ((signlessleft <= signlessright) && \ 238 ( (signlessleft < signlessright) || (Dallp2(leftB)<Dallp2(rightB)) )) 239 240#define Dbl_copytoint_exponentmantissap1(src,dest) \ 241 dest = Dexponentmantissap1(src) 242 243/* A quiet NaN has the high mantissa bit clear and at least on other (in this 244 * case the adjacent bit) bit set. */ 245#define Dbl_set_quiet(dbl_value) Deposit_dhigh2mantissa(dbl_value,1) 246#define Dbl_set_exponent(dbl_value, exp) Deposit_dexponent(dbl_value,exp) 247 248#define Dbl_set_mantissa(desta,destb,valuea,valueb) \ 249 Deposit_dmantissap1(desta,valuea); \ 250 Dmantissap2(destb) = Dmantissap2(valueb) 251#define Dbl_set_mantissap1(desta,valuea) \ 252 Deposit_dmantissap1(desta,valuea) 253#define Dbl_set_mantissap2(destb,valueb) \ 254 Dmantissap2(destb) = Dmantissap2(valueb) 255 256#define Dbl_set_exponentmantissa(desta,destb,valuea,valueb) \ 257 Deposit_dexponentmantissap1(desta,valuea); \ 258 Dmantissap2(destb) = Dmantissap2(valueb) 259#define Dbl_set_exponentmantissap1(dest,value) \ 260 Deposit_dexponentmantissap1(dest,value) 261 262#define Dbl_copyfromptr(src,desta,destb) \ 263 Dallp1(desta) = src->wd0; \ 264 Dallp2(destb) = src->wd1 265#define Dbl_copytoptr(srca,srcb,dest) \ 266 dest->wd0 = Dallp1(srca); \ 267 dest->wd1 = Dallp2(srcb) 268 269/* An infinity is represented with the max exponent and a zero mantissa */ 270#define Dbl_setinfinity_exponent(dbl_value) \ 271 Deposit_dexponent(dbl_value,DBL_INFINITY_EXPONENT) 272#define Dbl_setinfinity_exponentmantissa(dbl_valueA,dbl_valueB) \ 273 Deposit_dexponentmantissap1(dbl_valueA, \ 274 (DBL_INFINITY_EXPONENT << (32-(1+DBL_EXP_LENGTH)))); \ 275 Dmantissap2(dbl_valueB) = 0 276#define Dbl_setinfinitypositive(dbl_valueA,dbl_valueB) \ 277 Dallp1(dbl_valueA) \ 278 = (DBL_INFINITY_EXPONENT << (32-(1+DBL_EXP_LENGTH))); \ 279 Dmantissap2(dbl_valueB) = 0 280#define Dbl_setinfinitynegative(dbl_valueA,dbl_valueB) \ 281 Dallp1(dbl_valueA) = ((unsigned int)1<<31) | \ 282 (DBL_INFINITY_EXPONENT << (32-(1+DBL_EXP_LENGTH))); \ 283 Dmantissap2(dbl_valueB) = 0 284#define Dbl_setinfinity(dbl_valueA,dbl_valueB,sign) \ 285 Dallp1(dbl_valueA) = ((unsigned int)sign << 31) | \ 286 (DBL_INFINITY_EXPONENT << (32-(1+DBL_EXP_LENGTH))); \ 287 Dmantissap2(dbl_valueB) = 0 288 289#define Dbl_sethigh4bits(dbl_value, extsign) Deposit_dhigh4p1(dbl_value,extsign) 290#define Dbl_set_sign(dbl_value,sign) Deposit_dsign(dbl_value,sign) 291#define Dbl_invert_sign(dbl_value) Deposit_dsign(dbl_value,~Dsign(dbl_value)) 292#define Dbl_setone_sign(dbl_value) Deposit_dsign(dbl_value,1) 293#define Dbl_setone_lowmantissap2(dbl_value) Deposit_dlowp2(dbl_value,1) 294#define Dbl_setzero_sign(dbl_value) Dallp1(dbl_value) &= 0x7fffffff 295#define Dbl_setzero_exponent(dbl_value) \ 296 Dallp1(dbl_value) &= 0x800fffff 297#define Dbl_setzero_mantissa(dbl_valueA,dbl_valueB) \ 298 Dallp1(dbl_valueA) &= 0xfff00000; \ 299 Dallp2(dbl_valueB) = 0 300#define Dbl_setzero_mantissap1(dbl_value) Dallp1(dbl_value) &= 0xfff00000 301#define Dbl_setzero_mantissap2(dbl_value) Dallp2(dbl_value) = 0 302#define Dbl_setzero_exponentmantissa(dbl_valueA,dbl_valueB) \ 303 Dallp1(dbl_valueA) &= 0x80000000; \ 304 Dallp2(dbl_valueB) = 0 305#define Dbl_setzero_exponentmantissap1(dbl_valueA) \ 306 Dallp1(dbl_valueA) &= 0x80000000 307#define Dbl_setzero(dbl_valueA,dbl_valueB) \ 308 Dallp1(dbl_valueA) = 0; Dallp2(dbl_valueB) = 0 309#define Dbl_setzerop1(dbl_value) Dallp1(dbl_value) = 0 310#define Dbl_setzerop2(dbl_value) Dallp2(dbl_value) = 0 311#define Dbl_setnegativezero(dbl_value) \ 312 Dallp1(dbl_value) = (unsigned int)1 << 31; Dallp2(dbl_value) = 0 313#define Dbl_setnegativezerop1(dbl_value) Dallp1(dbl_value) = (unsigned int)1<<31 314 315/* Use the following macro for both overflow & underflow conditions */ 316#define ovfl - 317#define unfl + 318#define Dbl_setwrapped_exponent(dbl_value,exponent,op) \ 319 Deposit_dexponent(dbl_value,(exponent op DBL_WRAP)) 320 321#define Dbl_setlargestpositive(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 ); \ 324 Dallp2(dbl_valueB) = 0xFFFFFFFF 325#define Dbl_setlargestnegative(dbl_valueA,dbl_valueB) \ 326 Dallp1(dbl_valueA) = ((DBL_EMAX+DBL_BIAS) << (32-(1+DBL_EXP_LENGTH))) \ 327 | ((1<<(32-(1+DBL_EXP_LENGTH))) - 1 ) \ 328 | ((unsigned int)1<<31); \ 329 Dallp2(dbl_valueB) = 0xFFFFFFFF 330#define Dbl_setlargest_exponentmantissa(dbl_valueA,dbl_valueB) \ 331 Deposit_dexponentmantissap1(dbl_valueA, \ 332 (((DBL_EMAX+DBL_BIAS) << (32-(1+DBL_EXP_LENGTH))) \ 333 | ((1<<(32-(1+DBL_EXP_LENGTH))) - 1 ))); \ 334 Dallp2(dbl_valueB) = 0xFFFFFFFF 335 336#define Dbl_setnegativeinfinity(dbl_valueA,dbl_valueB) \ 337 Dallp1(dbl_valueA) = ((1<<DBL_EXP_LENGTH) | DBL_INFINITY_EXPONENT) \ 338 << (32-(1+DBL_EXP_LENGTH)) ; \ 339 Dallp2(dbl_valueB) = 0 340#define Dbl_setlargest(dbl_valueA,dbl_valueB,sign) \ 341 Dallp1(dbl_valueA) = ((unsigned int)sign << 31) | \ 342 ((DBL_EMAX+DBL_BIAS) << (32-(1+DBL_EXP_LENGTH))) | \ 343 ((1 << (32-(1+DBL_EXP_LENGTH))) - 1 ); \ 344 Dallp2(dbl_valueB) = 0xFFFFFFFF 345 346 347/* The high bit is always zero so arithmetic or logical shifts will work. */ 348#define Dbl_right_align(srcdstA,srcdstB,shift,extent) \ 349 if( shift >= 32 ) \ 350 { \ 351 /* Big shift requires examining the portion shift off \ 352 the end to properly set inexact. */ \ 353 if(shift < 64) \ 354 { \ 355 if(shift > 32) \ 356 { \ 357 Variable_shift_double(Dallp1(srcdstA),Dallp2(srcdstB), \ 358 shift-32, Extall(extent)); \ 359 if(Dallp2(srcdstB) << 64 - (shift)) Ext_setone_low(extent); \ 360 } \ 361 else Extall(extent) = Dallp2(srcdstB); \ 362 Dallp2(srcdstB) = Dallp1(srcdstA) >> (shift - 32); \ 363 } \ 364 else \ 365 { \ 366 Extall(extent) = Dallp1(srcdstA); \ 367 if(Dallp2(srcdstB)) Ext_setone_low(extent); \ 368 Dallp2(srcdstB) = 0; \ 369 } \ 370 Dallp1(srcdstA) = 0; \ 371 } \ 372 else \ 373 { \ 374 /* Small alignment is simpler. Extension is easily set. */ \ 375 if (shift > 0) \ 376 { \ 377 Extall(extent) = Dallp2(srcdstB) << 32 - (shift); \ 378 Variable_shift_double(Dallp1(srcdstA),Dallp2(srcdstB),shift, \ 379 Dallp2(srcdstB)); \ 380 Dallp1(srcdstA) >>= shift; \ 381 } \ 382 else Extall(extent) = 0; \ 383 } 384 385/* 386 * Here we need to shift the result right to correct for an overshift 387 * (due to the exponent becoming negative) during normalization. 388 */ 389#define Dbl_fix_overshift(srcdstA,srcdstB,shift,extent) \ 390 Extall(extent) = Dallp2(srcdstB) << 32 - (shift); \ 391 Dallp2(srcdstB) = (Dallp1(srcdstA) << 32 - (shift)) | \ 392 (Dallp2(srcdstB) >> (shift)); \ 393 Dallp1(srcdstA) = Dallp1(srcdstA) >> shift 394 395#define Dbl_hiddenhigh3mantissa(dbl_value) Dhiddenhigh3mantissa(dbl_value) 396#define Dbl_hidden(dbl_value) Dhidden(dbl_value) 397#define Dbl_lowmantissap2(dbl_value) Dlowp2(dbl_value) 398 399/* The left argument is never smaller than the right argument */ 400#define Dbl_subtract(lefta,leftb,righta,rightb,resulta,resultb) \ 401 if( Dallp2(rightb) > Dallp2(leftb) ) Dallp1(lefta)--; \ 402 Dallp2(resultb) = Dallp2(leftb) - Dallp2(rightb); \ 403 Dallp1(resulta) = Dallp1(lefta) - Dallp1(righta) 404 405/* Subtract right augmented with extension from left augmented with zeros and 406 * store into result and extension. */ 407#define Dbl_subtract_withextension(lefta,leftb,righta,rightb,extent,resulta,resultb) \ 408 Dbl_subtract(lefta,leftb,righta,rightb,resulta,resultb); \ 409 if( (Extall(extent) = 0-Extall(extent)) ) \ 410 { \ 411 if((Dallp2(resultb)--) == 0) Dallp1(resulta)--; \ 412 } 413 414#define Dbl_addition(lefta,leftb,righta,rightb,resulta,resultb) \ 415 /* If the sum of the low words is less than either source, then \ 416 * an overflow into the next word occurred. */ \ 417 Dallp1(resulta) = Dallp1(lefta) + Dallp1(righta); \ 418 if((Dallp2(resultb) = Dallp2(leftb) + Dallp2(rightb)) < Dallp2(rightb)) \ 419 Dallp1(resulta)++ 420 421#define Dbl_xortointp1(left,right,result) \ 422 result = Dallp1(left) XOR Dallp1(right) 423 424#define Dbl_xorfromintp1(left,right,result) \ 425 Dallp1(result) = left XOR Dallp1(right) 426 427#define Dbl_swap_lower(left,right) \ 428 Dallp2(left) = Dallp2(left) XOR Dallp2(right); \ 429 Dallp2(right) = Dallp2(left) XOR Dallp2(right); \ 430 Dallp2(left) = Dallp2(left) XOR Dallp2(right) 431 432/* Need to Initialize */ 433#define Dbl_makequietnan(desta,destb) \ 434 Dallp1(desta) = ((DBL_EMAX+DBL_BIAS)+1)<< (32-(1+DBL_EXP_LENGTH)) \ 435 | (1<<(32-(1+DBL_EXP_LENGTH+2))); \ 436 Dallp2(destb) = 0 437#define Dbl_makesignalingnan(desta,destb) \ 438 Dallp1(desta) = ((DBL_EMAX+DBL_BIAS)+1)<< (32-(1+DBL_EXP_LENGTH)) \ 439 | (1<<(32-(1+DBL_EXP_LENGTH+1))); \ 440 Dallp2(destb) = 0 441 442#define Dbl_normalize(dbl_opndA,dbl_opndB,exponent) \ 443 while(Dbl_iszero_hiddenhigh7mantissa(dbl_opndA)) { \ 444 Dbl_leftshiftby8(dbl_opndA,dbl_opndB); \ 445 exponent -= 8; \ 446 } \ 447 if(Dbl_iszero_hiddenhigh3mantissa(dbl_opndA)) { \ 448 Dbl_leftshiftby4(dbl_opndA,dbl_opndB); \ 449 exponent -= 4; \ 450 } \ 451 while(Dbl_iszero_hidden(dbl_opndA)) { \ 452 Dbl_leftshiftby1(dbl_opndA,dbl_opndB); \ 453 exponent -= 1; \ 454 } 455 456#define Twoword_add(src1dstA,src1dstB,src2A,src2B) \ 457 /* \ 458 * want this macro to generate: \ 459 * ADD src1dstB,src2B,src1dstB; \ 460 * ADDC src1dstA,src2A,src1dstA; \ 461 */ \ 462 if ((src1dstB) + (src2B) < (src1dstB)) Dallp1(src1dstA)++; \ 463 Dallp1(src1dstA) += (src2A); \ 464 Dallp2(src1dstB) += (src2B) 465 466#define Twoword_subtract(src1dstA,src1dstB,src2A,src2B) \ 467 /* \ 468 * want this macro to generate: \ 469 * SUB src1dstB,src2B,src1dstB; \ 470 * SUBB src1dstA,src2A,src1dstA; \ 471 */ \ 472 if ((src1dstB) < (src2B)) Dallp1(src1dstA)--; \ 473 Dallp1(src1dstA) -= (src2A); \ 474 Dallp2(src1dstB) -= (src2B) 475 476#define Dbl_setoverflow(resultA,resultB) \ 477 /* set result to infinity or largest number */ \ 478 switch (Rounding_mode()) { \ 479 case ROUNDPLUS: \ 480 if (Dbl_isone_sign(resultA)) { \ 481 Dbl_setlargestnegative(resultA,resultB); \ 482 } \ 483 else { \ 484 Dbl_setinfinitypositive(resultA,resultB); \ 485 } \ 486 break; \ 487 case ROUNDMINUS: \ 488 if (Dbl_iszero_sign(resultA)) { \ 489 Dbl_setlargestpositive(resultA,resultB); \ 490 } \ 491 else { \ 492 Dbl_setinfinitynegative(resultA,resultB); \ 493 } \ 494 break; \ 495 case ROUNDNEAREST: \ 496 Dbl_setinfinity_exponentmantissa(resultA,resultB); \ 497 break; \ 498 case ROUNDZERO: \ 499 Dbl_setlargest_exponentmantissa(resultA,resultB); \ 500 } 501 502#define Dbl_denormalize(opndp1,opndp2,exponent,guard,sticky,inexact) \ 503 Dbl_clear_signexponent_set_hidden(opndp1); \ 504 if (exponent >= (1-DBL_P)) { \ 505 if (exponent >= -31) { \ 506 guard = (Dallp2(opndp2) >> -exponent) & 1; \ 507 if (exponent < 0) sticky |= Dallp2(opndp2) << (32+exponent); \ 508 if (exponent > -31) { \ 509 Variable_shift_double(opndp1,opndp2,1-exponent,opndp2); \ 510 Dallp1(opndp1) >>= 1-exponent; \ 511 } \ 512 else { \ 513 Dallp2(opndp2) = Dallp1(opndp1); \ 514 Dbl_setzerop1(opndp1); \ 515 } \ 516 } \ 517 else { \ 518 guard = (Dallp1(opndp1) >> -32-exponent) & 1; \ 519 if (exponent == -32) sticky |= Dallp2(opndp2); \ 520 else sticky |= (Dallp2(opndp2) | Dallp1(opndp1) << 64+exponent); \ 521 Dallp2(opndp2) = Dallp1(opndp1) >> -31-exponent; \ 522 Dbl_setzerop1(opndp1); \ 523 } \ 524 inexact = guard | sticky; \ 525 } \ 526 else { \ 527 guard = 0; \ 528 sticky |= (Dallp1(opndp1) | Dallp2(opndp2)); \ 529 Dbl_setzero(opndp1,opndp2); \ 530 inexact = sticky; \ 531 } 532 533/* 534 * The fused multiply add instructions requires a double extended format, 535 * with 106 bits of mantissa. 536 */ 537#define DBLEXT_THRESHOLD 106 538 539#define Dblext_setzero(valA,valB,valC,valD) \ 540 Dextallp1(valA) = 0; Dextallp2(valB) = 0; \ 541 Dextallp3(valC) = 0; Dextallp4(valD) = 0 542 543 544#define Dblext_isnotzero_mantissap3(valC) (Dextallp3(valC)!=0) 545#define Dblext_isnotzero_mantissap4(valD) (Dextallp3(valD)!=0) 546#define Dblext_isone_lowp2(val) (Dextlowp2(val)!=0) 547#define Dblext_isone_highp3(val) (Dexthighp3(val)!=0) 548#define Dblext_isnotzero_low31p3(val) (Dextlow31p3(val)!=0) 549#define Dblext_iszero(valA,valB,valC,valD) (Dextallp1(valA)==0 && \ 550 Dextallp2(valB)==0 && Dextallp3(valC)==0 && Dextallp4(valD)==0) 551 552#define Dblext_copy(srca,srcb,srcc,srcd,desta,destb,destc,destd) \ 553 Dextallp1(desta) = Dextallp4(srca); \ 554 Dextallp2(destb) = Dextallp4(srcb); \ 555 Dextallp3(destc) = Dextallp4(srcc); \ 556 Dextallp4(destd) = Dextallp4(srcd) 557 558#define Dblext_swap_lower(leftp2,leftp3,leftp4,rightp2,rightp3,rightp4) \ 559 Dextallp2(leftp2) = Dextallp2(leftp2) XOR Dextallp2(rightp2); \ 560 Dextallp2(rightp2) = Dextallp2(leftp2) XOR Dextallp2(rightp2); \ 561 Dextallp2(leftp2) = Dextallp2(leftp2) XOR Dextallp2(rightp2); \ 562 Dextallp3(leftp3) = Dextallp3(leftp3) XOR Dextallp3(rightp3); \ 563 Dextallp3(rightp3) = Dextallp3(leftp3) XOR Dextallp3(rightp3); \ 564 Dextallp3(leftp3) = Dextallp3(leftp3) XOR Dextallp3(rightp3); \ 565 Dextallp4(leftp4) = Dextallp4(leftp4) XOR Dextallp4(rightp4); \ 566 Dextallp4(rightp4) = Dextallp4(leftp4) XOR Dextallp4(rightp4); \ 567 Dextallp4(leftp4) = Dextallp4(leftp4) XOR Dextallp4(rightp4) 568 569#define Dblext_setone_lowmantissap4(dbl_value) Deposit_dextlowp4(dbl_value,1) 570 571/* The high bit is always zero so arithmetic or logical shifts will work. */ 572#define Dblext_right_align(srcdstA,srcdstB,srcdstC,srcdstD,shift) \ 573 {int shiftamt, sticky; \ 574 shiftamt = shift % 32; \ 575 sticky = 0; \ 576 switch (shift/32) { \ 577 case 0: if (shiftamt > 0) { \ 578 sticky = Dextallp4(srcdstD) << 32 - (shiftamt); \ 579 Variable_shift_double(Dextallp3(srcdstC), \ 580 Dextallp4(srcdstD),shiftamt,Dextallp4(srcdstD)); \ 581 Variable_shift_double(Dextallp2(srcdstB), \ 582 Dextallp3(srcdstC),shiftamt,Dextallp3(srcdstC)); \ 583 Variable_shift_double(Dextallp1(srcdstA), \ 584 Dextallp2(srcdstB),shiftamt,Dextallp2(srcdstB)); \ 585 Dextallp1(srcdstA) >>= shiftamt; \ 586 } \ 587 break; \ 588 case 1: if (shiftamt > 0) { \ 589 sticky = (Dextallp3(srcdstC) << 31 - shiftamt) | \ 590 Dextallp4(srcdstD); \ 591 Variable_shift_double(Dextallp2(srcdstB), \ 592 Dextallp3(srcdstC),shiftamt,Dextallp4(srcdstD)); \ 593 Variable_shift_double(Dextallp1(srcdstA), \ 594 Dextallp2(srcdstB),shiftamt,Dextallp3(srcdstC)); \ 595 } \ 596 else { \ 597 sticky = Dextallp4(srcdstD); \ 598 Dextallp4(srcdstD) = Dextallp3(srcdstC); \ 599 Dextallp3(srcdstC) = Dextallp2(srcdstB); \ 600 } \ 601 Dextallp2(srcdstB) = Dextallp1(srcdstA) >> shiftamt; \ 602 Dextallp1(srcdstA) = 0; \ 603 break; \ 604 case 2: if (shiftamt > 0) { \ 605 sticky = (Dextallp2(srcdstB) << 31 - shiftamt) | \ 606 Dextallp3(srcdstC) | Dextallp4(srcdstD); \ 607 Variable_shift_double(Dextallp1(srcdstA), \ 608 Dextallp2(srcdstB),shiftamt,Dextallp4(srcdstD)); \ 609 } \ 610 else { \ 611 sticky = Dextallp3(srcdstC) | Dextallp4(srcdstD); \ 612 Dextallp4(srcdstD) = Dextallp2(srcdstB); \ 613 } \ 614 Dextallp3(srcdstC) = Dextallp1(srcdstA) >> shiftamt; \ 615 Dextallp1(srcdstA) = Dextallp2(srcdstB) = 0; \ 616 break; \ 617 case 3: if (shiftamt > 0) { \ 618 sticky = (Dextallp1(srcdstA) << 31 - shiftamt) | \ 619 Dextallp2(srcdstB) | Dextallp3(srcdstC) | \ 620 Dextallp4(srcdstD); \ 621 } \ 622 else { \ 623 sticky = Dextallp2(srcdstB) | Dextallp3(srcdstC) | \ 624 Dextallp4(srcdstD); \ 625 } \ 626 Dextallp4(srcdstD) = Dextallp1(srcdstA) >> shiftamt; \ 627 Dextallp1(srcdstA) = Dextallp2(srcdstB) = 0; \ 628 Dextallp3(srcdstC) = 0; \ 629 break; \ 630 } \ 631 if (sticky) Dblext_setone_lowmantissap4(srcdstD); \ 632 } 633 634/* The left argument is never smaller than the right argument */ 635#define Dblext_subtract(lefta,leftb,leftc,leftd,righta,rightb,rightc,rightd,resulta,resultb,resultc,resultd) \ 636 if( Dextallp4(rightd) > Dextallp4(leftd) ) \ 637 if( (Dextallp3(leftc)--) == 0) \ 638 if( (Dextallp2(leftb)--) == 0) Dextallp1(lefta)--; \ 639 Dextallp4(resultd) = Dextallp4(leftd) - Dextallp4(rightd); \ 640 if( Dextallp3(rightc) > Dextallp3(leftc) ) \ 641 if( (Dextallp2(leftb)--) == 0) Dextallp1(lefta)--; \ 642 Dextallp3(resultc) = Dextallp3(leftc) - Dextallp3(rightc); \ 643 if( Dextallp2(rightb) > Dextallp2(leftb) ) Dextallp1(lefta)--; \ 644 Dextallp2(resultb) = Dextallp2(leftb) - Dextallp2(rightb); \ 645 Dextallp1(resulta) = Dextallp1(lefta) - Dextallp1(righta) 646 647#define Dblext_addition(lefta,leftb,leftc,leftd,righta,rightb,rightc,rightd,resulta,resultb,resultc,resultd) \ 648 /* If the sum of the low words is less than either source, then \ 649 * an overflow into the next word occurred. */ \ 650 if ((Dextallp4(resultd) = Dextallp4(leftd)+Dextallp4(rightd)) < \ 651 Dextallp4(rightd)) \ 652 if((Dextallp3(resultc) = Dextallp3(leftc)+Dextallp3(rightc)+1) <= \ 653 Dextallp3(rightc)) \ 654 if((Dextallp2(resultb) = Dextallp2(leftb)+Dextallp2(rightb)+1) \ 655 <= Dextallp2(rightb)) \ 656 Dextallp1(resulta) = Dextallp1(lefta)+Dextallp1(righta)+1; \ 657 else Dextallp1(resulta) = Dextallp1(lefta)+Dextallp1(righta); \ 658 else \ 659 if ((Dextallp2(resultb) = Dextallp2(leftb)+Dextallp2(rightb)) < \ 660 Dextallp2(rightb)) \ 661 Dextallp1(resulta) = Dextallp1(lefta)+Dextallp1(righta)+1; \ 662 else Dextallp1(resulta) = Dextallp1(lefta)+Dextallp1(righta); \ 663 else \ 664 if ((Dextallp3(resultc) = Dextallp3(leftc)+Dextallp3(rightc)) < \ 665 Dextallp3(rightc)) \ 666 if ((Dextallp2(resultb) = Dextallp2(leftb)+Dextallp2(rightb)+1) \ 667 <= Dextallp2(rightb)) \ 668 Dextallp1(resulta) = Dextallp1(lefta)+Dextallp1(righta)+1; \ 669 else Dextallp1(resulta) = Dextallp1(lefta)+Dextallp1(righta); \ 670 else \ 671 if ((Dextallp2(resultb) = Dextallp2(leftb)+Dextallp2(rightb)) < \ 672 Dextallp2(rightb)) \ 673 Dextallp1(resulta) = Dextallp1(lefta)+Dextallp1(righta)+1; \ 674 else Dextallp1(resulta) = Dextallp1(lefta)+Dextallp1(righta) 675 676 677#define Dblext_arithrightshiftby1(srcdstA,srcdstB,srcdstC,srcdstD) \ 678 Shiftdouble(Dextallp3(srcdstC),Dextallp4(srcdstD),1,Dextallp4(srcdstD)); \ 679 Shiftdouble(Dextallp2(srcdstB),Dextallp3(srcdstC),1,Dextallp3(srcdstC)); \ 680 Shiftdouble(Dextallp1(srcdstA),Dextallp2(srcdstB),1,Dextallp2(srcdstB)); \ 681 Dextallp1(srcdstA) = (int)Dextallp1(srcdstA) >> 1 682 683#define Dblext_leftshiftby8(valA,valB,valC,valD) \ 684 Shiftdouble(Dextallp1(valA),Dextallp2(valB),24,Dextallp1(valA)); \ 685 Shiftdouble(Dextallp2(valB),Dextallp3(valC),24,Dextallp2(valB)); \ 686 Shiftdouble(Dextallp3(valC),Dextallp4(valD),24,Dextallp3(valC)); \ 687 Dextallp4(valD) <<= 8 688#define Dblext_leftshiftby4(valA,valB,valC,valD) \ 689 Shiftdouble(Dextallp1(valA),Dextallp2(valB),28,Dextallp1(valA)); \ 690 Shiftdouble(Dextallp2(valB),Dextallp3(valC),28,Dextallp2(valB)); \ 691 Shiftdouble(Dextallp3(valC),Dextallp4(valD),28,Dextallp3(valC)); \ 692 Dextallp4(valD) <<= 4 693#define Dblext_leftshiftby3(valA,valB,valC,valD) \ 694 Shiftdouble(Dextallp1(valA),Dextallp2(valB),29,Dextallp1(valA)); \ 695 Shiftdouble(Dextallp2(valB),Dextallp3(valC),29,Dextallp2(valB)); \ 696 Shiftdouble(Dextallp3(valC),Dextallp4(valD),29,Dextallp3(valC)); \ 697 Dextallp4(valD) <<= 3 698#define Dblext_leftshiftby2(valA,valB,valC,valD) \ 699 Shiftdouble(Dextallp1(valA),Dextallp2(valB),30,Dextallp1(valA)); \ 700 Shiftdouble(Dextallp2(valB),Dextallp3(valC),30,Dextallp2(valB)); \ 701 Shiftdouble(Dextallp3(valC),Dextallp4(valD),30,Dextallp3(valC)); \ 702 Dextallp4(valD) <<= 2 703#define Dblext_leftshiftby1(valA,valB,valC,valD) \ 704 Shiftdouble(Dextallp1(valA),Dextallp2(valB),31,Dextallp1(valA)); \ 705 Shiftdouble(Dextallp2(valB),Dextallp3(valC),31,Dextallp2(valB)); \ 706 Shiftdouble(Dextallp3(valC),Dextallp4(valD),31,Dextallp3(valC)); \ 707 Dextallp4(valD) <<= 1 708 709#define Dblext_rightshiftby4(valueA,valueB,valueC,valueD) \ 710 Shiftdouble(Dextallp3(valueC),Dextallp4(valueD),4,Dextallp4(valueD)); \ 711 Shiftdouble(Dextallp2(valueB),Dextallp3(valueC),4,Dextallp3(valueC)); \ 712 Shiftdouble(Dextallp1(valueA),Dextallp2(valueB),4,Dextallp2(valueB)); \ 713 Dextallp1(valueA) >>= 4 714#define Dblext_rightshiftby1(valueA,valueB,valueC,valueD) \ 715 Shiftdouble(Dextallp3(valueC),Dextallp4(valueD),1,Dextallp4(valueD)); \ 716 Shiftdouble(Dextallp2(valueB),Dextallp3(valueC),1,Dextallp3(valueC)); \ 717 Shiftdouble(Dextallp1(valueA),Dextallp2(valueB),1,Dextallp2(valueB)); \ 718 Dextallp1(valueA) >>= 1 719 720#define Dblext_xortointp1(left,right,result) Dbl_xortointp1(left,right,result) 721 722#define Dblext_xorfromintp1(left,right,result) \ 723 Dbl_xorfromintp1(left,right,result) 724 725#define Dblext_copytoint_exponentmantissap1(src,dest) \ 726 Dbl_copytoint_exponentmantissap1(src,dest) 727 728#define Dblext_ismagnitudeless(leftB,rightB,signlessleft,signlessright) \ 729 Dbl_ismagnitudeless(leftB,rightB,signlessleft,signlessright) 730 731#define Dbl_copyto_dblext(src1,src2,dest1,dest2,dest3,dest4) \ 732 Dextallp1(dest1) = Dallp1(src1); Dextallp2(dest2) = Dallp2(src2); \ 733 Dextallp3(dest3) = 0; Dextallp4(dest4) = 0 734 735#define Dblext_set_sign(dbl_value,sign) Dbl_set_sign(dbl_value,sign) 736#define Dblext_clear_signexponent_set_hidden(srcdst) \ 737 Dbl_clear_signexponent_set_hidden(srcdst) 738#define Dblext_clear_signexponent(srcdst) Dbl_clear_signexponent(srcdst) 739#define Dblext_clear_sign(srcdst) Dbl_clear_sign(srcdst) 740#define Dblext_isone_hidden(dbl_value) Dbl_isone_hidden(dbl_value) 741 742/* 743 * The Fourword_add() macro assumes that integers are 4 bytes in size. 744 * It will break if this is not the case. 745 */ 746 747#define Fourword_add(src1dstA,src1dstB,src1dstC,src1dstD,src2A,src2B,src2C,src2D) \ 748 /* \ 749 * want this macro to generate: \ 750 * ADD src1dstD,src2D,src1dstD; \ 751 * ADDC src1dstC,src2C,src1dstC; \ 752 * ADDC src1dstB,src2B,src1dstB; \ 753 * ADDC src1dstA,src2A,src1dstA; \ 754 */ \ 755 if ((unsigned int)(src1dstD += (src2D)) < (unsigned int)(src2D)) { \ 756 if ((unsigned int)(src1dstC += (src2C) + 1) <= \ 757 (unsigned int)(src2C)) { \ 758 if ((unsigned int)(src1dstB += (src2B) + 1) <= \ 759 (unsigned int)(src2B)) src1dstA++; \ 760 } \ 761 else if ((unsigned int)(src1dstB += (src2B)) < \ 762 (unsigned int)(src2B)) src1dstA++; \ 763 } \ 764 else { \ 765 if ((unsigned int)(src1dstC += (src2C)) < \ 766 (unsigned int)(src2C)) { \ 767 if ((unsigned int)(src1dstB += (src2B) + 1) <= \ 768 (unsigned int)(src2B)) src1dstA++; \ 769 } \ 770 else if ((unsigned int)(src1dstB += (src2B)) < \ 771 (unsigned int)(src2B)) src1dstA++; \ 772 } \ 773 src1dstA += (src2A) 774 775#define Dblext_denormalize(opndp1,opndp2,opndp3,opndp4,exponent,is_tiny) \ 776 {int shiftamt, sticky; \ 777 is_tiny = TRUE; \ 778 if (exponent == 0 && (Dextallp3(opndp3) || Dextallp4(opndp4))) { \ 779 switch (Rounding_mode()) { \ 780 case ROUNDPLUS: \ 781 if (Dbl_iszero_sign(opndp1)) { \ 782 Dbl_increment(opndp1,opndp2); \ 783 if (Dbl_isone_hiddenoverflow(opndp1)) \ 784 is_tiny = FALSE; \ 785 Dbl_decrement(opndp1,opndp2); \ 786 } \ 787 break; \ 788 case ROUNDMINUS: \ 789 if (Dbl_isone_sign(opndp1)) { \ 790 Dbl_increment(opndp1,opndp2); \ 791 if (Dbl_isone_hiddenoverflow(opndp1)) \ 792 is_tiny = FALSE; \ 793 Dbl_decrement(opndp1,opndp2); \ 794 } \ 795 break; \ 796 case ROUNDNEAREST: \ 797 if (Dblext_isone_highp3(opndp3) && \ 798 (Dblext_isone_lowp2(opndp2) || \ 799 Dblext_isnotzero_low31p3(opndp3))) { \ 800 Dbl_increment(opndp1,opndp2); \ 801 if (Dbl_isone_hiddenoverflow(opndp1)) \ 802 is_tiny = FALSE; \ 803 Dbl_decrement(opndp1,opndp2); \ 804 } \ 805 break; \ 806 } \ 807 } \ 808 Dblext_clear_signexponent_set_hidden(opndp1); \ 809 if (exponent >= (1-QUAD_P)) { \ 810 shiftamt = (1-exponent) % 32; \ 811 switch((1-exponent)/32) { \ 812 case 0: sticky = Dextallp4(opndp4) << 32-(shiftamt); \ 813 Variableshiftdouble(opndp3,opndp4,shiftamt,opndp4); \ 814 Variableshiftdouble(opndp2,opndp3,shiftamt,opndp3); \ 815 Variableshiftdouble(opndp1,opndp2,shiftamt,opndp2); \ 816 Dextallp1(opndp1) >>= shiftamt; \ 817 break; \ 818 case 1: sticky = (Dextallp3(opndp3) << 32-(shiftamt)) | \ 819 Dextallp4(opndp4); \ 820 Variableshiftdouble(opndp2,opndp3,shiftamt,opndp4); \ 821 Variableshiftdouble(opndp1,opndp2,shiftamt,opndp3); \ 822 Dextallp2(opndp2) = Dextallp1(opndp1) >> shiftamt; \ 823 Dextallp1(opndp1) = 0; \ 824 break; \ 825 case 2: sticky = (Dextallp2(opndp2) << 32-(shiftamt)) | \ 826 Dextallp3(opndp3) | Dextallp4(opndp4); \ 827 Variableshiftdouble(opndp1,opndp2,shiftamt,opndp4); \ 828 Dextallp3(opndp3) = Dextallp1(opndp1) >> shiftamt; \ 829 Dextallp1(opndp1) = Dextallp2(opndp2) = 0; \ 830 break; \ 831 case 3: sticky = (Dextallp1(opndp1) << 32-(shiftamt)) | \ 832 Dextallp2(opndp2) | Dextallp3(opndp3) | \ 833 Dextallp4(opndp4); \ 834 Dextallp4(opndp4) = Dextallp1(opndp1) >> shiftamt; \ 835 Dextallp1(opndp1) = Dextallp2(opndp2) = 0; \ 836 Dextallp3(opndp3) = 0; \ 837 break; \ 838 } \ 839 } \ 840 else { \ 841 sticky = Dextallp1(opndp1) | Dextallp2(opndp2) | \ 842 Dextallp3(opndp3) | Dextallp4(opndp4); \ 843 Dblext_setzero(opndp1,opndp2,opndp3,opndp4); \ 844 } \ 845 if (sticky) Dblext_setone_lowmantissap4(opndp4); \ 846 exponent = 0; \ 847 } 848