/*---------------------------------------------------------------------------+
   |  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;

  }