| /*---------------------------------------------------------------------------+ |
| | 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 billm@suburbia.net | |
| | | |
| | | |
| +---------------------------------------------------------------------------*/ |
| |
| /*---------------------------------------------------------------------------+ |
| | 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; |
| } |
| |
