git.oblomov.eu Git - linux-2.6/blob - arch/parisc/math-emu/dbl_float.h

   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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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   }