arch/x86/math-emu/reg_add_sub.c

   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
  27 static
  28 int 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   */
  36 int 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 */
 128 int 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
 269 static
 270 int 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 }