// SPDX-License-Identifier: GPL-2.0
/*---------------------------------------------------------------------------+
 |  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;
}