LXR linux/arch/x86/math-emu/reg_add

   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