/* Software floating-point emulation. Common operations.

   Copyright (C) 1997-2018 Free Software Foundation, Inc.

   This file is part of the GNU C Library.

   Contributed by Richard Henderson (rth@cygnus.com),

		  Jakub Jelinek (jj@ultra.linux.cz),

		  David S. Miller (davem@redhat.com) and

		  Peter Maydell (pmaydell@chiark.greenend.org.uk).

   The GNU C Library is free software; you can redistribute it and/or

   modify it under the terms of the GNU Lesser General Public

   License as published by the Free Software Foundation; either

   version 2.1 of the License, or (at your option) any later version.

   In addition to the permissions in the GNU Lesser General Public

   License, the Free Software Foundation gives you unlimited

   permission to link the compiled version of this file into

   combinations with other programs, and to distribute those

   combinations without any restriction coming from the use of this

   file.  (The Lesser General Public License restrictions do apply in

   other respects; for example, they cover modification of the file,

   and distribution when not linked into a combine executable.)

   The GNU C Library is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public

   License along with the GNU C Library; if not, see

   <http://www.gnu.org/licenses/>.  */

#ifndef SOFT_FP_OP_COMMON_H

#define SOFT_FP_OP_COMMON_H	1

#define _FP_DECL(wc, X)						\

  _FP_I_TYPE X##_c __attribute__ ((unused)) _FP_ZERO_INIT;	\

  _FP_I_TYPE X##_s __attribute__ ((unused)) _FP_ZERO_INIT;	\

  _FP_I_TYPE X##_e __attribute__ ((unused)) _FP_ZERO_INIT;	\

  _FP_FRAC_DECL_##wc (X)

/* Test whether the qNaN bit denotes a signaling NaN.  */

#define _FP_FRAC_SNANP(fs, X)				\

  ((_FP_QNANNEGATEDP)					\

   ? (_FP_FRAC_HIGH_RAW_##fs (X) & _FP_QNANBIT_##fs)	\

   : !(_FP_FRAC_HIGH_RAW_##fs (X) & _FP_QNANBIT_##fs))

#define _FP_FRAC_SNANP_SEMIRAW(fs, X)			\

  ((_FP_QNANNEGATEDP)					\

   ? (_FP_FRAC_HIGH_##fs (X) & _FP_QNANBIT_SH_##fs)	\

   : !(_FP_FRAC_HIGH_##fs (X) & _FP_QNANBIT_SH_##fs))

/* Finish truly unpacking a native fp value by classifying the kind

   of fp value and normalizing both the exponent and the fraction.  */

#define _FP_UNPACK_CANONICAL(fs, wc, X)				\

  do								\

    {								\

      switch (X##_e)						\

	{							\

	default:						\

	  _FP_FRAC_HIGH_RAW_##fs (X) |= _FP_IMPLBIT_##fs;	\

	  _FP_FRAC_SLL_##wc (X, _FP_WORKBITS);			\

	  X##_e -= _FP_EXPBIAS_##fs;				\

	  X##_c = FP_CLS_NORMAL;				\

	  break;						\

								\

	case 0:							\

	  if (_FP_FRAC_ZEROP_##wc (X))				\

	    X##_c = FP_CLS_ZERO;				\

	  else if (FP_DENORM_ZERO)				\

	    {							\

	      X##_c = FP_CLS_ZERO;				\

	      _FP_FRAC_SET_##wc (X, _FP_ZEROFRAC_##wc);		\

	      FP_SET_EXCEPTION (FP_EX_DENORM);			\

	    }							\

	  else							\

	    {							\

	      /* A denormalized number.  */			\

	      _FP_I_TYPE _FP_UNPACK_CANONICAL_shift;		\

	      _FP_FRAC_CLZ_##wc (_FP_UNPACK_CANONICAL_shift,	\

				 X);				\

	      _FP_UNPACK_CANONICAL_shift -= _FP_FRACXBITS_##fs;	\

	      _FP_FRAC_SLL_##wc (X, (_FP_UNPACK_CANONICAL_shift \

				     + _FP_WORKBITS));		\

	      X##_e -= (_FP_EXPBIAS_##fs - 1			\

			+ _FP_UNPACK_CANONICAL_shift);		\

	      X##_c = FP_CLS_NORMAL;				\

	      FP_SET_EXCEPTION (FP_EX_DENORM);			\

	    }							\

	  break;						\

								\

	case _FP_EXPMAX_##fs:					\

	  if (_FP_FRAC_ZEROP_##wc (X))				\

	    X##_c = FP_CLS_INF;					\

	  else							\

	    {							\

	      X##_c = FP_CLS_NAN;				\

	      /* Check for signaling NaN.  */			\

	      if (_FP_FRAC_SNANP (fs, X))			\

		FP_SET_EXCEPTION (FP_EX_INVALID			\

				  | FP_EX_INVALID_SNAN);	\

	    }							\

	  break;						\

	}							\

    }								\

  while (0)

/* Finish unpacking an fp value in semi-raw mode: the mantissa is

   shifted by _FP_WORKBITS but the implicit MSB is not inserted and

   other classification is not done.  */

#define _FP_UNPACK_SEMIRAW(fs, wc, X)	_FP_FRAC_SLL_##wc (X, _FP_WORKBITS)

/* Check whether a raw or semi-raw input value should be flushed to

   zero, and flush it to zero if so.  */

#define _FP_CHECK_FLUSH_ZERO(fs, wc, X)			\

  do							\

    {							\

      if (FP_DENORM_ZERO				\

	  && X##_e == 0					\

	  && !_FP_FRAC_ZEROP_##wc (X))			\

	{						\

	  _FP_FRAC_SET_##wc (X, _FP_ZEROFRAC_##wc);	\

	  FP_SET_EXCEPTION (FP_EX_DENORM);		\

	}						\

    }							\

  while (0)

/* A semi-raw value has overflowed to infinity.  Adjust the mantissa

   and exponent appropriately.  */

#define _FP_OVERFLOW_SEMIRAW(fs, wc, X)			\

  do							\

    {							\

      if (FP_ROUNDMODE == FP_RND_NEAREST		\

	  || (FP_ROUNDMODE == FP_RND_PINF && !X##_s)	\

	  || (FP_ROUNDMODE == FP_RND_MINF && X##_s))	\

	{						\

	  X##_e = _FP_EXPMAX_##fs;			\

	  _FP_FRAC_SET_##wc (X, _FP_ZEROFRAC_##wc);	\

	}						\

      else						\

	{						\

	  X##_e = _FP_EXPMAX_##fs - 1;			\

	  _FP_FRAC_SET_##wc (X, _FP_MAXFRAC_##wc);	\

	}						\

      FP_SET_EXCEPTION (FP_EX_INEXACT);			\

      FP_SET_EXCEPTION (FP_EX_OVERFLOW);		\

    }							\

  while (0)

/* Check for a semi-raw value being a signaling NaN and raise the

   invalid exception if so.  */

#define _FP_CHECK_SIGNAN_SEMIRAW(fs, wc, X)			\

  do								\

    {								\

      if (X##_e == _FP_EXPMAX_##fs				\

	  && !_FP_FRAC_ZEROP_##wc (X)				\

	  && _FP_FRAC_SNANP_SEMIRAW (fs, X))			\

	FP_SET_EXCEPTION (FP_EX_INVALID | FP_EX_INVALID_SNAN);	\

    }								\

  while (0)

/* Choose a NaN result from an operation on two semi-raw NaN

   values.  */

#define _FP_CHOOSENAN_SEMIRAW(fs, wc, R, X, Y, OP)			\

  do									\

    {									\

      /* _FP_CHOOSENAN expects raw values, so shift as required.  */	\

      _FP_FRAC_SRL_##wc (X, _FP_WORKBITS);				\

      _FP_FRAC_SRL_##wc (Y, _FP_WORKBITS);				\

      _FP_CHOOSENAN (fs, wc, R, X, Y, OP);				\

      _FP_FRAC_SLL_##wc (R, _FP_WORKBITS);				\

    }									\

  while (0)

/* Make the fractional part a quiet NaN, preserving the payload

   if possible, otherwise make it the canonical quiet NaN and set

   the sign bit accordingly.  */

#define _FP_SETQNAN(fs, wc, X)					\

  do								\

    {								\

      if (_FP_QNANNEGATEDP)					\

	{							\

	  _FP_FRAC_HIGH_RAW_##fs (X) &= _FP_QNANBIT_##fs - 1;	\

	  if (_FP_FRAC_ZEROP_##wc (X))				\

	    {							\

	      X##_s = _FP_NANSIGN_##fs;				\

	      _FP_FRAC_SET_##wc (X, _FP_NANFRAC_##fs);		\

	    }							\

	}							\

      else							\

	_FP_FRAC_HIGH_RAW_##fs (X) |= _FP_QNANBIT_##fs;		\

    }								\

  while (0)

#define _FP_SETQNAN_SEMIRAW(fs, wc, X)				\

  do								\

    {								\

      if (_FP_QNANNEGATEDP)					\

	{							\

	  _FP_FRAC_HIGH_##fs (X) &= _FP_QNANBIT_SH_##fs - 1;	\

	  if (_FP_FRAC_ZEROP_##wc (X))				\

	    {							\

	      X##_s = _FP_NANSIGN_##fs;				\

	      _FP_FRAC_SET_##wc (X, _FP_NANFRAC_##fs);		\

	      _FP_FRAC_SLL_##wc (X, _FP_WORKBITS);		\

	    }							\

	}							\

      else							\

	_FP_FRAC_HIGH_##fs (X) |= _FP_QNANBIT_SH_##fs;		\

    }								\

  while (0)

/* Test whether a biased exponent is normal (not zero or maximum).  */

#define _FP_EXP_NORMAL(fs, wc, X)	(((X##_e + 1) & _FP_EXPMAX_##fs) > 1)

/* Prepare to pack an fp value in semi-raw mode: the mantissa is

   rounded and shifted right, with the rounding possibly increasing

   the exponent (including changing a finite value to infinity).  */

#define _FP_PACK_SEMIRAW(fs, wc, X)				\

  do								\

    {								\

      int _FP_PACK_SEMIRAW_is_tiny				\

	= X##_e == 0 && !_FP_FRAC_ZEROP_##wc (X);		\

      if (_FP_TININESS_AFTER_ROUNDING				\

	  && _FP_PACK_SEMIRAW_is_tiny)				\

	{							\

	  FP_DECL_##fs (_FP_PACK_SEMIRAW_T);			\

	  _FP_FRAC_COPY_##wc (_FP_PACK_SEMIRAW_T, X);		\

	  _FP_PACK_SEMIRAW_T##_s = X##_s;			\

	  _FP_PACK_SEMIRAW_T##_e = X##_e;			\

	  _FP_FRAC_SLL_##wc (_FP_PACK_SEMIRAW_T, 1);		\

	  _FP_ROUND (wc, _FP_PACK_SEMIRAW_T);			\

	  if (_FP_FRAC_OVERP_##wc (fs, _FP_PACK_SEMIRAW_T))	\

	    _FP_PACK_SEMIRAW_is_tiny = 0;			\

	}							\

      _FP_ROUND (wc, X);					\

      if (_FP_PACK_SEMIRAW_is_tiny)				\

	{							\

	  if ((FP_CUR_EXCEPTIONS & FP_EX_INEXACT)		\

	      || (FP_TRAPPING_EXCEPTIONS & FP_EX_UNDERFLOW))	\

	    FP_SET_EXCEPTION (FP_EX_UNDERFLOW);			\

	}							\

      if (_FP_FRAC_HIGH_##fs (X)				\

	  & (_FP_OVERFLOW_##fs >> 1))				\

	{							\

	  _FP_FRAC_HIGH_##fs (X) &= ~(_FP_OVERFLOW_##fs >> 1);	\

	  X##_e++;						\

	  if (X##_e == _FP_EXPMAX_##fs)				\

	    _FP_OVERFLOW_SEMIRAW (fs, wc, X);			\

	}							\

      _FP_FRAC_SRL_##wc (X, _FP_WORKBITS);			\

      if (X##_e == _FP_EXPMAX_##fs && !_FP_FRAC_ZEROP_##wc (X))	\

	{							\

	  if (!_FP_KEEPNANFRACP)				\

	    {							\

	      _FP_FRAC_SET_##wc (X, _FP_NANFRAC_##fs);		\

	      X##_s = _FP_NANSIGN_##fs;				\

	    }							\

	  else							\

	    _FP_SETQNAN (fs, wc, X);				\

	}							\

    }								\

  while (0)

/* Before packing the bits back into the native fp result, take care

   of such mundane things as rounding and overflow.  Also, for some

   kinds of fp values, the original parts may not have been fully

   extracted -- but that is ok, we can regenerate them now.  */

#define _FP_PACK_CANONICAL(fs, wc, X)					\

  do									\

    {									\

      switch (X##_c)							\

	{								\

	case FP_CLS_NORMAL:						\

	  X##_e += _FP_EXPBIAS_##fs;					\

	  if (X##_e > 0)						\

	    {								\

	      _FP_ROUND (wc, X);					\

	      if (_FP_FRAC_OVERP_##wc (fs, X))				\

		{							\

		  _FP_FRAC_CLEAR_OVERP_##wc (fs, X);			\

		  X##_e++;						\

		}							\

	      _FP_FRAC_SRL_##wc (X, _FP_WORKBITS);			\

	      if (X##_e >= _FP_EXPMAX_##fs)				\

		{							\

		  /* Overflow.  */					\

		  switch (FP_ROUNDMODE)					\

		    {							\

		    case FP_RND_NEAREST:				\

		      X##_c = FP_CLS_INF;				\

		      break;						\

		    case FP_RND_PINF:					\

		      if (!X##_s)					\

			X##_c = FP_CLS_INF;				\

		      break;						\

		    case FP_RND_MINF:					\

		      if (X##_s)					\

			X##_c = FP_CLS_INF;				\

		      break;						\

		    }							\

		  if (X##_c == FP_CLS_INF)				\

		    {							\

		      /* Overflow to infinity.  */			\

		      X##_e = _FP_EXPMAX_##fs;				\

		      _FP_FRAC_SET_##wc (X, _FP_ZEROFRAC_##wc);		\

		    }							\

		  else							\

		    {							\

		      /* Overflow to maximum normal.  */		\

		      X##_e = _FP_EXPMAX_##fs - 1;			\

		      _FP_FRAC_SET_##wc (X, _FP_MAXFRAC_##wc);		\

		    }							\

		  FP_SET_EXCEPTION (FP_EX_OVERFLOW);			\

		  FP_SET_EXCEPTION (FP_EX_INEXACT);			\

		}							\

	    }								\

	  else								\

	    {								\

	      /* We've got a denormalized number.  */			\

	      int _FP_PACK_CANONICAL_is_tiny = 1;			\

	      if (_FP_TININESS_AFTER_ROUNDING && X##_e == 0)		\

		{							\

		  FP_DECL_##fs (_FP_PACK_CANONICAL_T);			\

		  _FP_FRAC_COPY_##wc (_FP_PACK_CANONICAL_T, X);		\

		  _FP_PACK_CANONICAL_T##_s = X##_s;			\

		  _FP_PACK_CANONICAL_T##_e = X##_e;			\

		  _FP_ROUND (wc, _FP_PACK_CANONICAL_T);			\

		  if (_FP_FRAC_OVERP_##wc (fs, _FP_PACK_CANONICAL_T))	\

		    _FP_PACK_CANONICAL_is_tiny = 0;			\

		}							\

	      X##_e = -X##_e + 1;					\

	      if (X##_e <= _FP_WFRACBITS_##fs)				\

		{							\

		  _FP_FRAC_SRS_##wc (X, X##_e, _FP_WFRACBITS_##fs);	\

		  _FP_ROUND (wc, X);					\

		  if (_FP_FRAC_HIGH_##fs (X)				\

		      & (_FP_OVERFLOW_##fs >> 1))			\

		    {							\

		      X##_e = 1;					\

		      _FP_FRAC_SET_##wc (X, _FP_ZEROFRAC_##wc);		\

		      FP_SET_EXCEPTION (FP_EX_INEXACT);			\

		    }							\

		  else							\

		    {							\

		      X##_e = 0;					\

		      _FP_FRAC_SRL_##wc (X, _FP_WORKBITS);		\

		    }							\

		  if (_FP_PACK_CANONICAL_is_tiny			\

		      && ((FP_CUR_EXCEPTIONS & FP_EX_INEXACT)		\

			  || (FP_TRAPPING_EXCEPTIONS			\

			      & FP_EX_UNDERFLOW)))			\

		    FP_SET_EXCEPTION (FP_EX_UNDERFLOW);			\

		}							\

	      else							\

		{							\

		  /* Underflow to zero.  */				\

		  X##_e = 0;						\

		  if (!_FP_FRAC_ZEROP_##wc (X))				\

		    {							\

		      _FP_FRAC_SET_##wc (X, _FP_MINFRAC_##wc);		\

		      _FP_ROUND (wc, X);				\

		      _FP_FRAC_LOW_##wc (X) >>= (_FP_WORKBITS);		\

		    }							\

		  FP_SET_EXCEPTION (FP_EX_UNDERFLOW);			\

		}							\

	    }								\

	  break;							\

									\

	case FP_CLS_ZERO:						\

	  X##_e = 0;							\

	  _FP_FRAC_SET_##wc (X, _FP_ZEROFRAC_##wc);			\

	  break;							\

									\

	case FP_CLS_INF:						\

	  X##_e = _FP_EXPMAX_##fs;					\

	  _FP_FRAC_SET_##wc (X, _FP_ZEROFRAC_##wc);			\

	  break;							\

									\

	case FP_CLS_NAN:						\

	  X##_e = _FP_EXPMAX_##fs;					\

	  if (!_FP_KEEPNANFRACP)					\

	    {								\

	      _FP_FRAC_SET_##wc (X, _FP_NANFRAC_##fs);			\

	      X##_s = _FP_NANSIGN_##fs;					\

	    }								\

	  else								\

	    _FP_SETQNAN (fs, wc, X);					\

	  break;							\

	}								\

    }									\

  while (0)

/* This one accepts raw argument and not cooked,  returns

   1 if X is a signaling NaN.  */

#define _FP_ISSIGNAN(fs, wc, X)			\

  ({						\

    int _FP_ISSIGNAN_ret = 0;			\

    if (X##_e == _FP_EXPMAX_##fs)		\

      {						\

	if (!_FP_FRAC_ZEROP_##wc (X)		\

	    && _FP_FRAC_SNANP (fs, X))		\

	  _FP_ISSIGNAN_ret = 1;			\

      }						\

    _FP_ISSIGNAN_ret;				\

  })

/* Addition on semi-raw values.  */

#define _FP_ADD_INTERNAL(fs, wc, R, X, Y, OP)				\

  do									\

    {									\

      _FP_CHECK_FLUSH_ZERO (fs, wc, X);					\

      _FP_CHECK_FLUSH_ZERO (fs, wc, Y);					\

      if (X##_s == Y##_s)						\

	{								\

	  /* Addition.  */						\

	  __label__ add1, add2, add3, add_done;				\

	  R##_s = X##_s;						\

	  int _FP_ADD_INTERNAL_ediff = X##_e - Y##_e;			\

	  if (_FP_ADD_INTERNAL_ediff > 0)				\

	    {								\

	      R##_e = X##_e;						\

	      if (Y##_e == 0)						\

		{							\

		  /* Y is zero or denormalized.  */			\

		  if (_FP_FRAC_ZEROP_##wc (Y))				\

		    {							\

		      _FP_CHECK_SIGNAN_SEMIRAW (fs, wc, X);		\

		      _FP_FRAC_COPY_##wc (R, X);			\

		      goto add_done;					\

		    }							\

		  else							\

		    {							\

		      FP_SET_EXCEPTION (FP_EX_DENORM);			\

		      _FP_ADD_INTERNAL_ediff--;				\

		      if (_FP_ADD_INTERNAL_ediff == 0)			\

			{						\

			  _FP_FRAC_ADD_##wc (R, X, Y);			\

			  goto add3;					\

			}						\

		      if (X##_e == _FP_EXPMAX_##fs)			\

			{						\

			  _FP_CHECK_SIGNAN_SEMIRAW (fs, wc, X);		\

			  _FP_FRAC_COPY_##wc (R, X);			\

			  goto add_done;				\

			}						\

		      goto add1;					\

		    }							\

		}							\

	      else if (X##_e == _FP_EXPMAX_##fs)			\

		{							\

		  /* X is NaN or Inf, Y is normal.  */			\

		  _FP_CHECK_SIGNAN_SEMIRAW (fs, wc, X);			\

		  _FP_FRAC_COPY_##wc (R, X);				\

		  goto add_done;					\

		}							\

									\

	      /* Insert implicit MSB of Y.  */				\

	      _FP_FRAC_HIGH_##fs (Y) |= _FP_IMPLBIT_SH_##fs;		\

									\

	    add1:							\

	      /* Shift the mantissa of Y to the right			\

		 _FP_ADD_INTERNAL_EDIFF steps; remember to account	\

		 later for the implicit MSB of X.  */			\

	      if (_FP_ADD_INTERNAL_ediff <= _FP_WFRACBITS_##fs)		\

		_FP_FRAC_SRS_##wc (Y, _FP_ADD_INTERNAL_ediff,		\

				   _FP_WFRACBITS_##fs);			\

	      else if (!_FP_FRAC_ZEROP_##wc (Y))			\

		_FP_FRAC_SET_##wc (Y, _FP_MINFRAC_##wc);		\

	      _FP_FRAC_ADD_##wc (R, X, Y);				\

	    }								\

	  else if (_FP_ADD_INTERNAL_ediff < 0)				\

	    {								\

	      _FP_ADD_INTERNAL_ediff = -_FP_ADD_INTERNAL_ediff;		\

	      R##_e = Y##_e;						\

	      if (X##_e == 0)						\

		{							\

		  /* X is zero or denormalized.  */			\

		  if (_FP_FRAC_ZEROP_##wc (X))				\

		    {							\

		      _FP_CHECK_SIGNAN_SEMIRAW (fs, wc, Y);		\

		      _FP_FRAC_COPY_##wc (R, Y);			\

		      goto add_done;					\

		    }							\

		  else							\

		    {							\

		      FP_SET_EXCEPTION (FP_EX_DENORM);			\

		      _FP_ADD_INTERNAL_ediff--;				\

		      if (_FP_ADD_INTERNAL_ediff == 0)			\

			{						\

			  _FP_FRAC_ADD_##wc (R, Y, X);			\

			  goto add3;					\

			}						\

		      if (Y##_e == _FP_EXPMAX_##fs)			\

			{						\

			  _FP_CHECK_SIGNAN_SEMIRAW (fs, wc, Y);		\

			  _FP_FRAC_COPY_##wc (R, Y);			\

			  goto add_done;				\

			}						\

		      goto add2;					\

		    }							\

		}							\

	      else if (Y##_e == _FP_EXPMAX_##fs)			\

		{							\

		  /* Y is NaN or Inf, X is normal.  */			\

		  _FP_CHECK_SIGNAN_SEMIRAW (fs, wc, Y);			\

		  _FP_FRAC_COPY_##wc (R, Y);				\

		  goto add_done;					\

		}							\

									\

	      /* Insert implicit MSB of X.  */				\

	      _FP_FRAC_HIGH_##fs (X) |= _FP_IMPLBIT_SH_##fs;		\

									\

	    add2:							\

	      /* Shift the mantissa of X to the right			\

		 _FP_ADD_INTERNAL_EDIFF steps; remember to account	\

		 later for the implicit MSB of Y.  */			\

	      if (_FP_ADD_INTERNAL_ediff <= _FP_WFRACBITS_##fs)		\

		_FP_FRAC_SRS_##wc (X, _FP_ADD_INTERNAL_ediff,		\

				   _FP_WFRACBITS_##fs);			\

	      else if (!_FP_FRAC_ZEROP_##wc (X))			\

		_FP_FRAC_SET_##wc (X, _FP_MINFRAC_##wc);		\

	      _FP_FRAC_ADD_##wc (R, Y, X);				\

	    }								\

	  else								\

	    {								\

	      /* _FP_ADD_INTERNAL_ediff == 0.  */			\

	      if (!_FP_EXP_NORMAL (fs, wc, X))				\

		{							\

		  if (X##_e == 0)					\

		    {							\

		      /* X and Y are zero or denormalized.  */		\

		      R##_e = 0;					\

		      if (_FP_FRAC_ZEROP_##wc (X))			\

			{						\

			  if (!_FP_FRAC_ZEROP_##wc (Y))			\

			    FP_SET_EXCEPTION (FP_EX_DENORM);		\

			  _FP_FRAC_COPY_##wc (R, Y);			\

			  goto add_done;				\

			}						\

		      else if (_FP_FRAC_ZEROP_##wc (Y))			\

			{						\

			  FP_SET_EXCEPTION (FP_EX_DENORM);		\

			  _FP_FRAC_COPY_##wc (R, X);			\

			  goto add_done;				\

			}						\

		      else						\

			{						\

			  FP_SET_EXCEPTION (FP_EX_DENORM);		\

			  _FP_FRAC_ADD_##wc (R, X, Y);			\

			  if (_FP_FRAC_HIGH_##fs (R) & _FP_IMPLBIT_SH_##fs) \

			    {						\

			      /* Normalized result.  */			\

			      _FP_FRAC_HIGH_##fs (R)			\

				&= ~(_FP_W_TYPE) _FP_IMPLBIT_SH_##fs;	\

			      R##_e = 1;				\

			    }						\

			  goto add_done;				\

			}						\

		    }							\

		  else							\

		    {							\

		      /* X and Y are NaN or Inf.  */			\

		      _FP_CHECK_SIGNAN_SEMIRAW (fs, wc, X);		\

		      _FP_CHECK_SIGNAN_SEMIRAW (fs, wc, Y);		\

		      R##_e = _FP_EXPMAX_##fs;				\

		      if (_FP_FRAC_ZEROP_##wc (X))			\

			_FP_FRAC_COPY_##wc (R, Y);			\

		      else if (_FP_FRAC_ZEROP_##wc (Y))			\

			_FP_FRAC_COPY_##wc (R, X);			\

		      else						\

			_FP_CHOOSENAN_SEMIRAW (fs, wc, R, X, Y, OP);	\

		      goto add_done;					\

		    }							\

		}							\

	      /* The exponents of X and Y, both normal, are equal.  The	\

		 implicit MSBs will always add to increase the		\

		 exponent.  */						\

	      _FP_FRAC_ADD_##wc (R, X, Y);				\

	      R##_e = X##_e + 1;					\

	      _FP_FRAC_SRS_##wc (R, 1, _FP_WFRACBITS_##fs);		\

	      if (R##_e == _FP_EXPMAX_##fs)				\

		/* Overflow to infinity (depending on rounding mode).  */ \

		_FP_OVERFLOW_SEMIRAW (fs, wc, R);			\

	      goto add_done;						\

	    }								\

	add3:								\

	  if (_FP_FRAC_HIGH_##fs (R) & _FP_IMPLBIT_SH_##fs)		\

	    {								\

	      /* Overflow.  */						\

	      _FP_FRAC_HIGH_##fs (R) &= ~(_FP_W_TYPE) _FP_IMPLBIT_SH_##fs; \

	      R##_e++;							\

	      _FP_FRAC_SRS_##wc (R, 1, _FP_WFRACBITS_##fs);		\

	      if (R##_e == _FP_EXPMAX_##fs)				\

		/* Overflow to infinity (depending on rounding mode).  */ \

		_FP_OVERFLOW_SEMIRAW (fs, wc, R);			\

	    }								\

	add_done: ;							\

	}								\

      else								\

	{								\

	  /* Subtraction.  */						\

	  __label__ sub1, sub2, sub3, norm, sub_done;			\

	  int _FP_ADD_INTERNAL_ediff = X##_e - Y##_e;			\

	  if (_FP_ADD_INTERNAL_ediff > 0)				\

	    {								\

	      R##_e = X##_e;						\

	      R##_s = X##_s;						\

	      if (Y##_e == 0)						\

		{							\

		  /* Y is zero or denormalized.  */			\

		  if (_FP_FRAC_ZEROP_##wc (Y))				\

		    {							\

		      _FP_CHECK_SIGNAN_SEMIRAW (fs, wc, X);		\

		      _FP_FRAC_COPY_##wc (R, X);			\

		      goto sub_done;					\

		    }							\

		  else							\

		    {							\

		      FP_SET_EXCEPTION (FP_EX_DENORM);			\

		      _FP_ADD_INTERNAL_ediff--;				\

		      if (_FP_ADD_INTERNAL_ediff == 0)			\

			{						\

			  _FP_FRAC_SUB_##wc (R, X, Y);			\

			  goto sub3;					\

			}						\

		      if (X##_e == _FP_EXPMAX_##fs)			\

			{						\

			  _FP_CHECK_SIGNAN_SEMIRAW (fs, wc, X);		\

			  _FP_FRAC_COPY_##wc (R, X);			\

			  goto sub_done;				\

			}						\

		      goto sub1;					\

		    }							\

		}							\

	      else if (X##_e == _FP_EXPMAX_##fs)			\

		{							\

		  /* X is NaN or Inf, Y is normal.  */			\

		  _FP_CHECK_SIGNAN_SEMIRAW (fs, wc, X);			\

		  _FP_FRAC_COPY_##wc (R, X);				\

		  goto sub_done;					\

		}							\

									\

	      /* Insert implicit MSB of Y.  */				\

	      _FP_FRAC_HIGH_##fs (Y) |= _FP_IMPLBIT_SH_##fs;		\

									\

	    sub1:							\

	      /* Shift the mantissa of Y to the right			\

		 _FP_ADD_INTERNAL_EDIFF steps; remember to account	\

		 later for the implicit MSB of X.  */			\

	      if (_FP_ADD_INTERNAL_ediff <= _FP_WFRACBITS_##fs)		\

		_FP_FRAC_SRS_##wc (Y, _FP_ADD_INTERNAL_ediff,		\

				   _FP_WFRACBITS_##fs);			\

	      else if (!_FP_FRAC_ZEROP_##wc (Y))			\

		_FP_FRAC_SET_##wc (Y, _FP_MINFRAC_##wc);		\

	      _FP_FRAC_SUB_##wc (R, X, Y);				\

	    }								\

	  else if (_FP_ADD_INTERNAL_ediff < 0)				\

	    {								\

	      _FP_ADD_INTERNAL_ediff = -_FP_ADD_INTERNAL_ediff;		\

	      R##_e = Y##_e;						\

	      R##_s = Y##_s;						\

	      if (X##_e == 0)						\

		{							\

		  /* X is zero or denormalized.  */			\

		  if (_FP_FRAC_ZEROP_##wc (X))				\

		    {							\

		      _FP_CHECK_SIGNAN_SEMIRAW (fs, wc, Y);		\

		      _FP_FRAC_COPY_##wc (R, Y);			\

		      goto sub_done;					\

		    }							\

		  else							\

		    {							\

		      FP_SET_EXCEPTION (FP_EX_DENORM);			\

		      _FP_ADD_INTERNAL_ediff--;				\

		      if (_FP_ADD_INTERNAL_ediff == 0)			\

			{						\

			  _FP_FRAC_SUB_##wc (R, Y, X);			\

			  goto sub3;					\

			}						\

		      if (Y##_e == _FP_EXPMAX_##fs)			\

			{						\

			  _FP_CHECK_SIGNAN_SEMIRAW (fs, wc, Y);		\

			  _FP_FRAC_COPY_##wc (R, Y);			\

			  goto sub_done;				\

			}						\

		      goto sub2;					\

		    }							\

		}							\

	      else if (Y##_e == _FP_EXPMAX_##fs)			\

		{							\

		  /* Y is NaN or Inf, X is normal.  */			\

		  _FP_CHECK_SIGNAN_SEMIRAW (fs, wc, Y);			\

		  _FP_FRAC_COPY_##wc (R, Y);				\

		  goto sub_done;					\

		}							\

									\

	      /* Insert implicit MSB of X.  */				\

	      _FP_FRAC_HIGH_##fs (X) |= _FP_IMPLBIT_SH_##fs;		\

									\

	    sub2:							\

	      /* Shift the mantissa of X to the right			\

		 _FP_ADD_INTERNAL_EDIFF steps; remember to account	\

		 later for the implicit MSB of Y.  */			\

	      if (_FP_ADD_INTERNAL_ediff <= _FP_WFRACBITS_##fs)		\

		_FP_FRAC_SRS_##wc (X, _FP_ADD_INTERNAL_ediff,		\

				   _FP_WFRACBITS_##fs);			\

	      else if (!_FP_FRAC_ZEROP_##wc (X))			\

		_FP_FRAC_SET_##wc (X, _FP_MINFRAC_##wc);		\

	      _FP_FRAC_SUB_##wc (R, Y, X);				\

	    }								\

	  else								\

	    {								\

	      /* ediff == 0.  */					\

	      if (!_FP_EXP_NORMAL (fs, wc, X))				\

		{							\

		  if (X##_e == 0)					\

		    {							\

		      /* X and Y are zero or denormalized.  */		\

		      R##_e = 0;					\

		      if (_FP_FRAC_ZEROP_##wc (X))			\

			{						\

			  _FP_FRAC_COPY_##wc (R, Y);			\

			  if (_FP_FRAC_ZEROP_##wc (Y))			\

			    R##_s = (FP_ROUNDMODE == FP_RND_MINF);	\

			  else						\

			    {						\

			      FP_SET_EXCEPTION (FP_EX_DENORM);		\

			      R##_s = Y##_s;				\

			    }						\

			  goto sub_done;				\

			}						\

		      else if (_FP_FRAC_ZEROP_##wc (Y))			\

			{						\

			  FP_SET_EXCEPTION (FP_EX_DENORM);		\

			  _FP_FRAC_COPY_##wc (R, X);			\

			  R##_s = X##_s;				\

			  goto sub_done;				\

			}						\

		      else						\

			{						\

			  FP_SET_EXCEPTION (FP_EX_DENORM);		\

			  _FP_FRAC_SUB_##wc (R, X, Y);			\

			  R##_s = X##_s;				\

			  if (_FP_FRAC_HIGH_##fs (R) & _FP_IMPLBIT_SH_##fs) \

			    {						\

			      /* |X| < |Y|, negate result.  */		\

			      _FP_FRAC_SUB_##wc (R, Y, X);		\

			      R##_s = Y##_s;				\

			    }						\

			  else if (_FP_FRAC_ZEROP_##wc (R))		\

			    R##_s = (FP_ROUNDMODE == FP_RND_MINF);	\

			  goto sub_done;				\

			}						\

		    }							\

		  else							\

		    {							\

		      /* X and Y are NaN or Inf, of opposite signs.  */	\

		      _FP_CHECK_SIGNAN_SEMIRAW (fs, wc, X);		\

		      _FP_CHECK_SIGNAN_SEMIRAW (fs, wc, Y);		\

		      R##_e = _FP_EXPMAX_##fs;				\

		      if (_FP_FRAC_ZEROP_##wc (X))			\

			{						\

			  if (_FP_FRAC_ZEROP_##wc (Y))			\

			    {						\

			      /* Inf - Inf.  */				\

			      R##_s = _FP_NANSIGN_##fs;			\

			      _FP_FRAC_SET_##wc (R, _FP_NANFRAC_##fs);	\

			      _FP_FRAC_SLL_##wc (R, _FP_WORKBITS);	\

			      FP_SET_EXCEPTION (FP_EX_INVALID		\

						| FP_EX_INVALID_ISI);	\

			    }						\

			  else						\

			    {						\

			      /* Inf - NaN.  */				\

			      R##_s = Y##_s;				\

			      _FP_FRAC_COPY_##wc (R, Y);		\

			    }						\

			}						\

		      else						\

			{						\

			  if (_FP_FRAC_ZEROP_##wc (Y))			\

			    {						\

			      /* NaN - Inf.  */				\

			      R##_s = X##_s;				\

			      _FP_FRAC_COPY_##wc (R, X);		\

			    }						\

			  else						\

			    {						\

			      /* NaN - NaN.  */				\

			      _FP_CHOOSENAN_SEMIRAW (fs, wc, R, X, Y, OP); \

			    }						\

			}						\

		      goto sub_done;					\

		    }							\

		}							\

	      /* The exponents of X and Y, both normal, are equal.  The	\

		 implicit MSBs cancel.  */				\

	      R##_e = X##_e;						\

	      _FP_FRAC_SUB_##wc (R, X, Y);				\

	      R##_s = X##_s;						\

	      if (_FP_FRAC_HIGH_##fs (R) & _FP_IMPLBIT_SH_##fs)		\

		{							\

		  /* |X| < |Y|, negate result.  */			\

		  _FP_FRAC_SUB_##wc (R, Y, X);				\

		  R##_s = Y##_s;					\

		}							\

	      else if (_FP_FRAC_ZEROP_##wc (R))				\

		{							\

		  R##_e = 0;						\

		  R##_s = (FP_ROUNDMODE == FP_RND_MINF);		\

		  goto sub_done;					\

		}							\

	      goto norm;						\

	    }								\

	sub3:								\

	  if (_FP_FRAC_HIGH_##fs (R) & _FP_IMPLBIT_SH_##fs)		\

	    {								\

	      int _FP_ADD_INTERNAL_diff;				\

	      /* Carry into most significant bit of larger one of X and Y, \

		 canceling it; renormalize.  */				\

	      _FP_FRAC_HIGH_##fs (R) &= _FP_IMPLBIT_SH_##fs - 1;	\

	    norm:							\

	      _FP_FRAC_CLZ_##wc (_FP_ADD_INTERNAL_diff, R);		\

	      _FP_ADD_INTERNAL_diff -= _FP_WFRACXBITS_##fs;		\

	      _FP_FRAC_SLL_##wc (R, _FP_ADD_INTERNAL_diff);		\

	      if (R##_e <= _FP_ADD_INTERNAL_diff)			\

		{							\

		  /* R is denormalized.  */				\

		  _FP_ADD_INTERNAL_diff					\

		    = _FP_ADD_INTERNAL_diff - R##_e + 1;		\

		  _FP_FRAC_SRS_##wc (R, _FP_ADD_INTERNAL_diff,		\

				     _FP_WFRACBITS_##fs);		\

		  R##_e = 0;						\

		}							\

	      else							\

		{							\

		  R##_e -= _FP_ADD_INTERNAL_diff;			\

		  _FP_FRAC_HIGH_##fs (R) &= ~(_FP_W_TYPE) _FP_IMPLBIT_SH_##fs; \

		}							\

	    }								\

	sub_done: ;							\

	}								\

    }									\

  while (0)

#define _FP_ADD(fs, wc, R, X, Y) _FP_ADD_INTERNAL (fs, wc, R, X, Y, '+')

#define _FP_SUB(fs, wc, R, X, Y)					\

  do									\

    {									\

      if (!(Y##_e == _FP_EXPMAX_##fs && !_FP_FRAC_ZEROP_##wc (Y)))	\

	Y##_s ^= 1;							\

      _FP_ADD_INTERNAL (fs, wc, R, X, Y, '-');				\

    }									\

  while (0)

/* Main negation routine.  The input value is raw.  */

#define _FP_NEG(fs, wc, R, X)			\

  do						\

    {						\

      _FP_FRAC_COPY_##wc (R, X);		\

      R##_e = X##_e;				\

      R##_s = 1 ^ X##_s;			\

    }						\

  while (0)

/* Main multiplication routine.  The input values should be cooked.  */

#define _FP_MUL(fs, wc, R, X, Y)				\

  do								\

    {								\

      R##_s = X##_s ^ Y##_s;					\

      R##_e = X##_e + Y##_e + 1;				\

      switch (_FP_CLS_COMBINE (X##_c, Y##_c))			\