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