1/*---------------------------------------------------------------------------+ 2 | reg_add_sub.c | 3 | | 4 | Functions to add or subtract two registers and put the result in a third. | 5 | | 6 | Copyright (C) 1992,1993,1997 | 7 | W. Metzenthen, 22 Parker St, Ormond, Vic 3163, Australia | 8 | E-mail billm@suburbia.net | 9 | | 10 | | 11 +---------------------------------------------------------------------------*/ 12 13/*---------------------------------------------------------------------------+ 14 | For each function, the destination may be any FPU_REG, including one of | 15 | the source FPU_REGs. | 16 | Each function returns 0 if the answer is o.k., otherwise a non-zero | 17 | value is returned, indicating either an exception condition or an | 18 | internal error. | 19 +---------------------------------------------------------------------------*/ 20 21#include "exception.h" 22#include "reg_constant.h" 23#include "fpu_emu.h" 24#include "control_w.h" 25#include "fpu_system.h" 26 27static 28int add_sub_specials(FPU_REG const *a, u_char taga, u_char signa, 29 FPU_REG const *b, u_char tagb, u_char signb, 30 FPU_REG * dest, int deststnr, int control_w); 31 32/* 33 Operates on st(0) and st(n), or on st(0) and temporary data. 34 The destination must be one of the source st(x). 35 */ 36int FPU_add(FPU_REG const *b, u_char tagb, int deststnr, int control_w) 37{ 38 FPU_REG *a = &st(0); 39 FPU_REG *dest = &st(deststnr); 40 u_char signb = getsign(b); 41 u_char taga = FPU_gettag0(); 42 u_char signa = getsign(a); 43 u_char saved_sign = getsign(dest); 44 int diff, tag, expa, expb; 45 46 if (!(taga | tagb)) { 47 expa = exponent(a); 48 expb = exponent(b); 49 50 valid_add: 51 /* Both registers are valid */ 52 if (!(signa ^ signb)) { 53 /* signs are the same */ 54 tag = 55 FPU_u_add(a, b, dest, control_w, signa, expa, expb); 56 } else { 57 /* The signs are different, so do a subtraction */ 58 diff = expa - expb; 59 if (!diff) { 60 diff = a->sigh - b->sigh; /* This works only if the ms bits 61 are identical. */ 62 if (!diff) { 63 diff = a->sigl > b->sigl; 64 if (!diff) 65 diff = -(a->sigl < b->sigl); 66 } 67 } 68 69 if (diff > 0) { 70 tag = 71 FPU_u_sub(a, b, dest, control_w, signa, 72 expa, expb); 73 } else if (diff < 0) { 74 tag = 75 FPU_u_sub(b, a, dest, control_w, signb, 76 expb, expa); 77 } else { 78 FPU_copy_to_regi(&CONST_Z, TAG_Zero, deststnr); 79 /* sign depends upon rounding mode */ 80 setsign(dest, ((control_w & CW_RC) != RC_DOWN) 81 ? SIGN_POS : SIGN_NEG); 82 return TAG_Zero; 83 } 84 } 85 86 if (tag < 0) { 87 setsign(dest, saved_sign); 88 return tag; 89 } 90 FPU_settagi(deststnr, tag); 91 return tag; 92 } 93 94 if (taga == TAG_Special) 95 taga = FPU_Special(a); 96 if (tagb == TAG_Special) 97 tagb = FPU_Special(b); 98 99 if (((taga == TAG_Valid) && (tagb == TW_Denormal)) 100 || ((taga == TW_Denormal) && (tagb == TAG_Valid)) 101 || ((taga == TW_Denormal) && (tagb == TW_Denormal))) { 102 FPU_REG x, y; 103 104 if (denormal_operand() < 0) 105 return FPU_Exception; 106 107 FPU_to_exp16(a, &x); 108 FPU_to_exp16(b, &y); 109 a = &x; 110 b = &y; 111 expa = exponent16(a); 112 expb = exponent16(b); 113 goto valid_add; 114 } 115 116 if ((taga == TW_NaN) || (tagb == TW_NaN)) { 117 if (deststnr == 0) 118 return real_2op_NaN(b, tagb, deststnr, a); 119 else 120 return real_2op_NaN(a, taga, deststnr, a); 121 } 122 123 return add_sub_specials(a, taga, signa, b, tagb, signb, 124 dest, deststnr, control_w); 125} 126 127/* Subtract b from a. (a-b) -> dest */ 128int FPU_sub(int flags, int rm, int control_w) 129{ 130 FPU_REG const *a, *b; 131 FPU_REG *dest; 132 u_char taga, tagb, signa, signb, saved_sign, sign; 133 int diff, tag = 0, expa, expb, deststnr; 134 135 a = &st(0); 136 taga = FPU_gettag0(); 137 138 deststnr = 0; 139 if (flags & LOADED) { 140 b = (FPU_REG *) rm; 141 tagb = flags & 0x0f; 142 } else { 143 b = &st(rm); 144 tagb = FPU_gettagi(rm); 145 146 if (flags & DEST_RM) 147 deststnr = rm; 148 } 149 150 signa = getsign(a); 151 signb = getsign(b); 152 153 if (flags & REV) { 154 signa ^= SIGN_NEG; 155 signb ^= SIGN_NEG; 156 } 157 158 dest = &st(deststnr); 159 saved_sign = getsign(dest); 160 161 if (!(taga | tagb)) { 162 expa = exponent(a); 163 expb = exponent(b); 164 165 valid_subtract: 166 /* Both registers are valid */ 167 168 diff = expa - expb; 169 170 if (!diff) { 171 diff = a->sigh - b->sigh; /* Works only if ms bits are identical */ 172 if (!diff) { 173 diff = a->sigl > b->sigl; 174 if (!diff) 175 diff = -(a->sigl < b->sigl); 176 } 177 } 178 179 switch ((((int)signa) * 2 + signb) / SIGN_NEG) { 180 case 0: /* P - P */ 181 case 3: /* N - N */ 182 if (diff > 0) { 183 /* |a| > |b| */ 184 tag = 185 FPU_u_sub(a, b, dest, control_w, signa, 186 expa, expb); 187 } else if (diff == 0) { 188 FPU_copy_to_regi(&CONST_Z, TAG_Zero, deststnr); 189 190 /* sign depends upon rounding mode */ 191 setsign(dest, ((control_w & CW_RC) != RC_DOWN) 192 ? SIGN_POS : SIGN_NEG); 193 return TAG_Zero; 194 } else { 195 sign = signa ^ SIGN_NEG; 196 tag = 197 FPU_u_sub(b, a, dest, control_w, sign, expb, 198 expa); 199 } 200 break; 201 case 1: /* P - N */ 202 tag = 203 FPU_u_add(a, b, dest, control_w, SIGN_POS, expa, 204 expb); 205 break; 206 case 2: /* N - P */ 207 tag = 208 FPU_u_add(a, b, dest, control_w, SIGN_NEG, expa, 209 expb); 210 break; 211#ifdef PARANOID 212 default: 213 EXCEPTION(EX_INTERNAL | 0x111); 214 return -1; 215#endif 216 } 217 if (tag < 0) { 218 setsign(dest, saved_sign); 219 return tag; 220 } 221 FPU_settagi(deststnr, tag); 222 return tag; 223 } 224 225 if (taga == TAG_Special) 226 taga = FPU_Special(a); 227 if (tagb == TAG_Special) 228 tagb = FPU_Special(b); 229 230 if (((taga == TAG_Valid) && (tagb == TW_Denormal)) 231 || ((taga == TW_Denormal) && (tagb == TAG_Valid)) 232 || ((taga == TW_Denormal) && (tagb == TW_Denormal))) { 233 FPU_REG x, y; 234 235 if (denormal_operand() < 0) 236 return FPU_Exception; 237 238 FPU_to_exp16(a, &x); 239 FPU_to_exp16(b, &y); 240 a = &x; 241 b = &y; 242 expa = exponent16(a); 243 expb = exponent16(b); 244 245 goto valid_subtract; 246 } 247 248 if ((taga == TW_NaN) || (tagb == TW_NaN)) { 249 FPU_REG const *d1, *d2; 250 if (flags & REV) { 251 d1 = b; 252 d2 = a; 253 } else { 254 d1 = a; 255 d2 = b; 256 } 257 if (flags & LOADED) 258 return real_2op_NaN(b, tagb, deststnr, d1); 259 if (flags & DEST_RM) 260 return real_2op_NaN(a, taga, deststnr, d2); 261 else 262 return real_2op_NaN(b, tagb, deststnr, d2); 263 } 264 265 return add_sub_specials(a, taga, signa, b, tagb, signb ^ SIGN_NEG, 266 dest, deststnr, control_w); 267} 268 269static 270int add_sub_specials(FPU_REG const *a, u_char taga, u_char signa, 271 FPU_REG const *b, u_char tagb, u_char signb, 272 FPU_REG * dest, int deststnr, int control_w) 273{ 274 if (((taga == TW_Denormal) || (tagb == TW_Denormal)) 275 && (denormal_operand() < 0)) 276 return FPU_Exception; 277 278 if (taga == TAG_Zero) { 279 if (tagb == TAG_Zero) { 280 /* Both are zero, result will be zero. */ 281 u_char different_signs = signa ^ signb; 282 283 FPU_copy_to_regi(a, TAG_Zero, deststnr); 284 if (different_signs) { 285 /* Signs are different. */ 286 /* Sign of answer depends upon rounding mode. */ 287 setsign(dest, ((control_w & CW_RC) != RC_DOWN) 288 ? SIGN_POS : SIGN_NEG); 289 } else 290 setsign(dest, signa); /* signa may differ from the sign of a. */ 291 return TAG_Zero; 292 } else { 293 reg_copy(b, dest); 294 if ((tagb == TW_Denormal) && (b->sigh & 0x80000000)) { 295 /* A pseudoDenormal, convert it. */ 296 addexponent(dest, 1); 297 tagb = TAG_Valid; 298 } else if (tagb > TAG_Empty) 299 tagb = TAG_Special; 300 setsign(dest, signb); /* signb may differ from the sign of b. */ 301 FPU_settagi(deststnr, tagb); 302 return tagb; 303 } 304 } else if (tagb == TAG_Zero) { 305 reg_copy(a, dest); 306 if ((taga == TW_Denormal) && (a->sigh & 0x80000000)) { 307 /* A pseudoDenormal */ 308 addexponent(dest, 1); 309 taga = TAG_Valid; 310 } else if (taga > TAG_Empty) 311 taga = TAG_Special; 312 setsign(dest, signa); /* signa may differ from the sign of a. */ 313 FPU_settagi(deststnr, taga); 314 return taga; 315 } else if (taga == TW_Infinity) { 316 if ((tagb != TW_Infinity) || (signa == signb)) { 317 FPU_copy_to_regi(a, TAG_Special, deststnr); 318 setsign(dest, signa); /* signa may differ from the sign of a. */ 319 return taga; 320 } 321 /* Infinity-Infinity is undefined. */ 322 return arith_invalid(deststnr); 323 } else if (tagb == TW_Infinity) { 324 FPU_copy_to_regi(b, TAG_Special, deststnr); 325 setsign(dest, signb); /* signb may differ from the sign of b. */ 326 return tagb; 327 } 328#ifdef PARANOID 329 EXCEPTION(EX_INTERNAL | 0x101); 330#endif 331 332 return FPU_Exception; 333} 334