reg_add_sub.c

Go to the documentation of this file.

/*---------------------------------------------------------------------------+
 |  reg_add_sub.c                                                            |
 |                                                                           |
 | Functions to add or subtract two registers and put the result in a third. |
 |                                                                           |
 | Copyright (C) 1992,1993,1997                                              |
 |                  W. Metzenthen, 22 Parker St, Ormond, Vic 3163, Australia |
 |                  E-mail   [email protected]                              |
 |                                                                           |
 |                                                                           |
 +---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------+
 |  For each function, the destination may be any FPU_REG, including one of  |
 | the source FPU_REGs.                                                      |
 |  Each function returns 0 if the answer is o.k., otherwise a non-zero      |
 | value is returned, indicating either an exception condition or an         |
 | internal error.                                                           |
 +---------------------------------------------------------------------------*/

#include "exception.h"
#include "reg_constant.h"
#include "fpu_emu.h"
#include "control_w.h"
#include "fpu_system.h"

static
int add_sub_specials(FPU_REG const *a, u_char taga, u_char signa,
             FPU_REG const *b, u_char tagb, u_char signb,
             FPU_REG * dest, int deststnr, int control_w);

/*
  Operates on st(0) and st(n), or on st(0) and temporary data.
  The destination must be one of the source st(x).
  */
int FPU_add(FPU_REG const *b, u_char tagb, int deststnr, int control_w)
{
    FPU_REG *a = &st(0);
    FPU_REG *dest = &st(deststnr);
    u_char signb = getsign(b);
    u_char taga = FPU_gettag0();
    u_char signa = getsign(a);
    u_char saved_sign = getsign(dest);
    int diff, tag, expa, expb;

    if (!(taga | tagb)) {
        expa = exponent(a);
        expb = exponent(b);

          valid_add:
        /* Both registers are valid */
        if (!(signa ^ signb)) {
            /* signs are the same */
            tag =
                FPU_u_add(a, b, dest, control_w, signa, expa, expb);
        } else {
            /* The signs are different, so do a subtraction */
            diff = expa - expb;
            if (!diff) {
                diff = a->sigh - b->sigh;   /* This works only if the ms bits
                                   are identical. */
                if (!diff) {
                    diff = a->sigl > b->sigl;
                    if (!diff)
                        diff = -(a->sigl < b->sigl);
                }
            }

            if (diff > 0) {
                tag =
                    FPU_u_sub(a, b, dest, control_w, signa,
                          expa, expb);
            } else if (diff < 0) {
                tag =
                    FPU_u_sub(b, a, dest, control_w, signb,
                          expb, expa);
            } else {
                FPU_copy_to_regi(&CONST_Z, TAG_Zero, deststnr);
                /* sign depends upon rounding mode */
                setsign(dest, ((control_w & CW_RC) != RC_DOWN)
                    ? SIGN_POS : SIGN_NEG);
                return TAG_Zero;
            }
        }

        if (tag < 0) {
            setsign(dest, saved_sign);
            return tag;
        }
        FPU_settagi(deststnr, tag);
        return tag;
    }

    if (taga == TAG_Special)
        taga = FPU_Special(a);
    if (tagb == TAG_Special)
        tagb = FPU_Special(b);

    if (((taga == TAG_Valid) && (tagb == TW_Denormal))
        || ((taga == TW_Denormal) && (tagb == TAG_Valid))
        || ((taga == TW_Denormal) && (tagb == TW_Denormal))) {
        FPU_REG x, y;

        if (denormal_operand() < 0)
            return FPU_Exception;

        FPU_to_exp16(a, &x);
        FPU_to_exp16(b, &y);
        a = &x;
        b = &y;
        expa = exponent16(a);
        expb = exponent16(b);
        goto valid_add;
    }

    if ((taga == TW_NaN) || (tagb == TW_NaN)) {
        if (deststnr == 0)
            return real_2op_NaN(b, tagb, deststnr, a);
        else
            return real_2op_NaN(a, taga, deststnr, a);
    }

    return add_sub_specials(a, taga, signa, b, tagb, signb,
                dest, deststnr, control_w);
}

/* Subtract b from a.  (a-b) -> dest */
int FPU_sub(int flags, int rm, int control_w)
{
    FPU_REG const *a, *b;
    FPU_REG *dest;
    u_char taga, tagb, signa, signb, saved_sign, sign;
    int diff, tag = 0, expa, expb, deststnr;

    a = &st(0);
    taga = FPU_gettag0();

    deststnr = 0;
    if (flags & LOADED) {
        b = (FPU_REG *) rm;
        tagb = flags & 0x0f;
    } else {
        b = &st(rm);
        tagb = FPU_gettagi(rm);

        if (flags & DEST_RM)
            deststnr = rm;
    }

    signa = getsign(a);
    signb = getsign(b);

    if (flags & REV) {
        signa ^= SIGN_NEG;
        signb ^= SIGN_NEG;
    }

    dest = &st(deststnr);
    saved_sign = getsign(dest);

    if (!(taga | tagb)) {
        expa = exponent(a);
        expb = exponent(b);

          valid_subtract:
        /* Both registers are valid */

        diff = expa - expb;

        if (!diff) {
            diff = a->sigh - b->sigh;   /* Works only if ms bits are identical */
            if (!diff) {
                diff = a->sigl > b->sigl;
                if (!diff)
                    diff = -(a->sigl < b->sigl);
            }
        }

        switch ((((int)signa) * 2 + signb) / SIGN_NEG) {
        case 0: /* P - P */
        case 3: /* N - N */
            if (diff > 0) {
                /* |a| > |b| */
                tag =
                    FPU_u_sub(a, b, dest, control_w, signa,
                          expa, expb);
            } else if (diff == 0) {
                FPU_copy_to_regi(&CONST_Z, TAG_Zero, deststnr);

                /* sign depends upon rounding mode */
                setsign(dest, ((control_w & CW_RC) != RC_DOWN)
                    ? SIGN_POS : SIGN_NEG);
                return TAG_Zero;
            } else {
                sign = signa ^ SIGN_NEG;
                tag =
                    FPU_u_sub(b, a, dest, control_w, sign, expb,
                          expa);
            }
            break;
        case 1: /* P - N */
            tag =
                FPU_u_add(a, b, dest, control_w, SIGN_POS, expa,
                      expb);
            break;
        case 2: /* N - P */
            tag =
                FPU_u_add(a, b, dest, control_w, SIGN_NEG, expa,
                      expb);
            break;
#ifdef PARANOID
        default:
            EXCEPTION(EX_INTERNAL | 0x111);
            return -1;
#endif
        }
        if (tag < 0) {
            setsign(dest, saved_sign);
            return tag;
        }
        FPU_settagi(deststnr, tag);
        return tag;
    }

    if (taga == TAG_Special)
        taga = FPU_Special(a);
    if (tagb == TAG_Special)
        tagb = FPU_Special(b);

    if (((taga == TAG_Valid) && (tagb == TW_Denormal))
        || ((taga == TW_Denormal) && (tagb == TAG_Valid))
        || ((taga == TW_Denormal) && (tagb == TW_Denormal))) {
        FPU_REG x, y;

        if (denormal_operand() < 0)
            return FPU_Exception;

        FPU_to_exp16(a, &x);
        FPU_to_exp16(b, &y);
        a = &x;
        b = &y;
        expa = exponent16(a);
        expb = exponent16(b);

        goto valid_subtract;
    }

    if ((taga == TW_NaN) || (tagb == TW_NaN)) {
        FPU_REG const *d1, *d2;
        if (flags & REV) {
            d1 = b;
            d2 = a;
        } else {
            d1 = a;
            d2 = b;
        }
        if (flags & LOADED)
            return real_2op_NaN(b, tagb, deststnr, d1);
        if (flags & DEST_RM)
            return real_2op_NaN(a, taga, deststnr, d2);
        else
            return real_2op_NaN(b, tagb, deststnr, d2);
    }

    return add_sub_specials(a, taga, signa, b, tagb, signb ^ SIGN_NEG,
                dest, deststnr, control_w);
}

static
int add_sub_specials(FPU_REG const *a, u_char taga, u_char signa,
             FPU_REG const *b, u_char tagb, u_char signb,
             FPU_REG * dest, int deststnr, int control_w)
{
    if (((taga == TW_Denormal) || (tagb == TW_Denormal))
        && (denormal_operand() < 0))
        return FPU_Exception;

    if (taga == TAG_Zero) {
        if (tagb == TAG_Zero) {
            /* Both are zero, result will be zero. */
            u_char different_signs = signa ^ signb;

            FPU_copy_to_regi(a, TAG_Zero, deststnr);
            if (different_signs) {
                /* Signs are different. */
                /* Sign of answer depends upon rounding mode. */
                setsign(dest, ((control_w & CW_RC) != RC_DOWN)
                    ? SIGN_POS : SIGN_NEG);
            } else
                setsign(dest, signa);   /* signa may differ from the sign of a. */
            return TAG_Zero;
        } else {
            reg_copy(b, dest);
            if ((tagb == TW_Denormal) && (b->sigh & 0x80000000)) {
                /* A pseudoDenormal, convert it. */
                addexponent(dest, 1);
                tagb = TAG_Valid;
            } else if (tagb > TAG_Empty)
                tagb = TAG_Special;
            setsign(dest, signb);   /* signb may differ from the sign of b. */
            FPU_settagi(deststnr, tagb);
            return tagb;
        }
    } else if (tagb == TAG_Zero) {
        reg_copy(a, dest);
        if ((taga == TW_Denormal) && (a->sigh & 0x80000000)) {
            /* A pseudoDenormal */
            addexponent(dest, 1);
            taga = TAG_Valid;
        } else if (taga > TAG_Empty)
            taga = TAG_Special;
        setsign(dest, signa);   /* signa may differ from the sign of a. */
        FPU_settagi(deststnr, taga);
        return taga;
    } else if (taga == TW_Infinity) {
        if ((tagb != TW_Infinity) || (signa == signb)) {
            FPU_copy_to_regi(a, TAG_Special, deststnr);
            setsign(dest, signa);   /* signa may differ from the sign of a. */
            return taga;
        }
        /* Infinity-Infinity is undefined. */
        return arith_invalid(deststnr);
    } else if (tagb == TW_Infinity) {
        FPU_copy_to_regi(b, TAG_Special, deststnr);
        setsign(dest, signb);   /* signb may differ from the sign of b. */
        return tagb;
    }
#ifdef PARANOID
    EXCEPTION(EX_INTERNAL | 0x101);
#endif

    return FPU_Exception;
}