[thirdparty/glibc.git] / soft-fp / extended.h

/* Software floating-point emulation.
   Definitions for IEEE Extended Precision.
   Copyright (C) 1999-2018 Free Software Foundation, Inc.
   This file is part of the GNU C Library.
   Contributed by Jakub Jelinek (jj@ultra.linux.cz).

   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_EXTENDED_H
#define SOFT_FP_EXTENDED_H	1

#if _FP_W_TYPE_SIZE < 32
# error "Here's a nickel, kid. Go buy yourself a real computer."
#endif

#if _FP_W_TYPE_SIZE < 64
# define _FP_FRACTBITS_E	(4*_FP_W_TYPE_SIZE)
# define _FP_FRACTBITS_DW_E	(8*_FP_W_TYPE_SIZE)
#else
# define _FP_FRACTBITS_E	(2*_FP_W_TYPE_SIZE)
# define _FP_FRACTBITS_DW_E	(4*_FP_W_TYPE_SIZE)
#endif

#define _FP_FRACBITS_E		64
#define _FP_FRACXBITS_E		(_FP_FRACTBITS_E - _FP_FRACBITS_E)
#define _FP_WFRACBITS_E		(_FP_WORKBITS + _FP_FRACBITS_E)
#define _FP_WFRACXBITS_E	(_FP_FRACTBITS_E - _FP_WFRACBITS_E)
#define _FP_EXPBITS_E		15
#define _FP_EXPBIAS_E		16383
#define _FP_EXPMAX_E		32767

#define _FP_QNANBIT_E		\
	((_FP_W_TYPE) 1 << (_FP_FRACBITS_E-2) % _FP_W_TYPE_SIZE)
#define _FP_QNANBIT_SH_E		\
	((_FP_W_TYPE) 1 << (_FP_FRACBITS_E-2+_FP_WORKBITS) % _FP_W_TYPE_SIZE)
#define _FP_IMPLBIT_E		\
	((_FP_W_TYPE) 1 << (_FP_FRACBITS_E-1) % _FP_W_TYPE_SIZE)
#define _FP_IMPLBIT_SH_E		\
	((_FP_W_TYPE) 1 << (_FP_FRACBITS_E-1+_FP_WORKBITS) % _FP_W_TYPE_SIZE)
#define _FP_OVERFLOW_E		\
	((_FP_W_TYPE) 1 << (_FP_WFRACBITS_E % _FP_W_TYPE_SIZE))

#define _FP_WFRACBITS_DW_E	(2 * _FP_WFRACBITS_E)
#define _FP_WFRACXBITS_DW_E	(_FP_FRACTBITS_DW_E - _FP_WFRACBITS_DW_E)
#define _FP_HIGHBIT_DW_E	\
  ((_FP_W_TYPE) 1 << (_FP_WFRACBITS_DW_E - 1) % _FP_W_TYPE_SIZE)

typedef float XFtype __attribute__ ((mode (XF)));

#if _FP_W_TYPE_SIZE < 64

union _FP_UNION_E
{
  XFtype flt;
  struct _FP_STRUCT_LAYOUT
  {
# if __BYTE_ORDER == __BIG_ENDIAN
    unsigned long pad1 : _FP_W_TYPE_SIZE;
    unsigned long pad2 : (_FP_W_TYPE_SIZE - 1 - _FP_EXPBITS_E);
    unsigned long sign : 1;
    unsigned long exp : _FP_EXPBITS_E;
    unsigned long frac1 : _FP_W_TYPE_SIZE;
    unsigned long frac0 : _FP_W_TYPE_SIZE;
# else
    unsigned long frac0 : _FP_W_TYPE_SIZE;
    unsigned long frac1 : _FP_W_TYPE_SIZE;
    unsigned exp : _FP_EXPBITS_E;
    unsigned sign : 1;
# endif /* not bigendian */
  } bits;
};


# define FP_DECL_E(X)		_FP_DECL (4, X)

# define FP_UNPACK_RAW_E(X, val)			\
  do							\
    {							\
      union _FP_UNION_E FP_UNPACK_RAW_E_flo;		\
      FP_UNPACK_RAW_E_flo.flt = (val);			\
							\
      X##_f[2] = 0;					\
      X##_f[3] = 0;					\
      X##_f[0] = FP_UNPACK_RAW_E_flo.bits.frac0;	\
      X##_f[1] = FP_UNPACK_RAW_E_flo.bits.frac1;	\
      X##_f[1] &= ~_FP_IMPLBIT_E;			\
      X##_e  = FP_UNPACK_RAW_E_flo.bits.exp;		\
      X##_s  = FP_UNPACK_RAW_E_flo.bits.sign;		\
    }							\
  while (0)

# define FP_UNPACK_RAW_EP(X, val)			\
  do							\
    {							\
      union _FP_UNION_E *FP_UNPACK_RAW_EP_flo		\
	= (union _FP_UNION_E *) (val);			\
							\
      X##_f[2] = 0;					\
      X##_f[3] = 0;					\
      X##_f[0] = FP_UNPACK_RAW_EP_flo->bits.frac0;	\
      X##_f[1] = FP_UNPACK_RAW_EP_flo->bits.frac1;	\
      X##_f[1] &= ~_FP_IMPLBIT_E;			\
      X##_e  = FP_UNPACK_RAW_EP_flo->bits.exp;		\
      X##_s  = FP_UNPACK_RAW_EP_flo->bits.sign;		\
    }							\
  while (0)

# define FP_PACK_RAW_E(val, X)			\
  do						\
    {						\
      union _FP_UNION_E FP_PACK_RAW_E_flo;	\
						\
      if (X##_e)				\
	X##_f[1] |= _FP_IMPLBIT_E;		\
      else					\
	X##_f[1] &= ~(_FP_IMPLBIT_E);		\
      FP_PACK_RAW_E_flo.bits.frac0 = X##_f[0];	\
      FP_PACK_RAW_E_flo.bits.frac1 = X##_f[1];	\
      FP_PACK_RAW_E_flo.bits.exp   = X##_e;	\
      FP_PACK_RAW_E_flo.bits.sign  = X##_s;	\
						\
      (val) = FP_PACK_RAW_E_flo.flt;		\
    }						\
  while (0)

# define FP_PACK_RAW_EP(val, X)				\
  do							\
    {							\
      if (!FP_INHIBIT_RESULTS)				\
	{						\
	  union _FP_UNION_E *FP_PACK_RAW_EP_flo		\
	    = (union _FP_UNION_E *) (val);		\
							\
	  if (X##_e)					\
	    X##_f[1] |= _FP_IMPLBIT_E;			\
	  else						\
	    X##_f[1] &= ~(_FP_IMPLBIT_E);		\
	  FP_PACK_RAW_EP_flo->bits.frac0 = X##_f[0];	\
	  FP_PACK_RAW_EP_flo->bits.frac1 = X##_f[1];	\
	  FP_PACK_RAW_EP_flo->bits.exp   = X##_e;	\
	  FP_PACK_RAW_EP_flo->bits.sign  = X##_s;	\
	}						\
    }							\
  while (0)

# define FP_UNPACK_E(X, val)			\
  do						\
    {						\
      FP_UNPACK_RAW_E (X, (val));		\
      _FP_UNPACK_CANONICAL (E, 4, X);		\
    }						\
  while (0)

# define FP_UNPACK_EP(X, val)			\
  do						\
    {						\
      FP_UNPACK_RAW_EP (X, (val));		\
      _FP_UNPACK_CANONICAL (E, 4, X);		\
    }						\
  while (0)

# define FP_UNPACK_SEMIRAW_E(X, val)		\
  do						\
    {						\
      FP_UNPACK_RAW_E (X, (val));		\
      _FP_UNPACK_SEMIRAW (E, 4, X);		\
    }						\
  while (0)

# define FP_UNPACK_SEMIRAW_EP(X, val)		\
  do						\
    {						\
      FP_UNPACK_RAW_EP (X, (val));		\
      _FP_UNPACK_SEMIRAW (E, 4, X);		\
    }						\
  while (0)

# define FP_PACK_E(val, X)			\
  do						\
    {						\
      _FP_PACK_CANONICAL (E, 4, X);		\
      FP_PACK_RAW_E ((val), X);			\
    }						\
  while (0)

# define FP_PACK_EP(val, X)			\
  do						\
    {						\
      _FP_PACK_CANONICAL (E, 4, X);		\
      FP_PACK_RAW_EP ((val), X);		\
    }						\
  while (0)

# define FP_PACK_SEMIRAW_E(val, X)		\
  do						\
    {						\
      _FP_PACK_SEMIRAW (E, 4, X);		\
      FP_PACK_RAW_E ((val), X);			\
    }						\
  while (0)

# define FP_PACK_SEMIRAW_EP(val, X)		\
  do						\
    {						\
      _FP_PACK_SEMIRAW (E, 4, X);		\
      FP_PACK_RAW_EP ((val), X);		\
    }						\
  while (0)

# define FP_ISSIGNAN_E(X)	_FP_ISSIGNAN (E, 4, X)
# define FP_NEG_E(R, X)		_FP_NEG (E, 4, R, X)
# define FP_ADD_E(R, X, Y)	_FP_ADD (E, 4, R, X, Y)
# define FP_SUB_E(R, X, Y)	_FP_SUB (E, 4, R, X, Y)
# define FP_MUL_E(R, X, Y)	_FP_MUL (E, 4, R, X, Y)
# define FP_DIV_E(R, X, Y)	_FP_DIV (E, 4, R, X, Y)
# define FP_SQRT_E(R, X)	_FP_SQRT (E, 4, R, X)
# define FP_FMA_E(R, X, Y, Z)	_FP_FMA (E, 4, 8, R, X, Y, Z)

/* Square root algorithms:
   We have just one right now, maybe Newton approximation
   should be added for those machines where division is fast.
   This has special _E version because standard _4 square
   root would not work (it has to start normally with the
   second word and not the first), but as we have to do it
   anyway, we optimize it by doing most of the calculations
   in two UWtype registers instead of four.  */

# define _FP_SQRT_MEAT_E(R, S, T, X, q)			\
  do							\
    {							\
      (q) = (_FP_W_TYPE) 1 << (_FP_W_TYPE_SIZE - 1);	\
      _FP_FRAC_SRL_4 (X, (_FP_WORKBITS));		\
      while (q)						\
	{						\
	  T##_f[1] = S##_f[1] + (q);			\
	  if (T##_f[1] <= X##_f[1])			\
	    {						\
	      S##_f[1] = T##_f[1] + (q);		\
	      X##_f[1] -= T##_f[1];			\
	      R##_f[1] += (q);				\
	    }						\
	  _FP_FRAC_SLL_2 (X, 1);			\
	  (q) >>= 1;					\
	}						\
      (q) = (_FP_W_TYPE) 1 << (_FP_W_TYPE_SIZE - 1);	\
      while (q)						\
	{						\
	  T##_f[0] = S##_f[0] + (q);			\
	  T##_f[1] = S##_f[1];				\
	  if (T##_f[1] < X##_f[1]			\
	      || (T##_f[1] == X##_f[1]			\
		  && T##_f[0] <= X##_f[0]))		\
	    {						\
	      S##_f[0] = T##_f[0] + (q);		\
	      S##_f[1] += (T##_f[0] > S##_f[0]);	\
	      _FP_FRAC_DEC_2 (X, T);			\
	      R##_f[0] += (q);				\
	    }						\
	  _FP_FRAC_SLL_2 (X, 1);			\
	  (q) >>= 1;					\
	}						\
      _FP_FRAC_SLL_4 (R, (_FP_WORKBITS));		\
      if (X##_f[0] | X##_f[1])				\
	{						\
	  if (S##_f[1] < X##_f[1]			\
	      || (S##_f[1] == X##_f[1]			\
		  && S##_f[0] < X##_f[0]))		\
	    R##_f[0] |= _FP_WORK_ROUND;			\
	  R##_f[0] |= _FP_WORK_STICKY;			\
	}						\
    }							\
  while (0)

# define FP_CMP_E(r, X, Y, un, ex)	_FP_CMP (E, 4, (r), X, Y, (un), (ex))
# define FP_CMP_EQ_E(r, X, Y, ex)	_FP_CMP_EQ (E, 4, (r), X, Y, (ex))
# define FP_CMP_UNORD_E(r, X, Y, ex)	_FP_CMP_UNORD (E, 4, (r), X, Y, (ex))

# define FP_TO_INT_E(r, X, rsz, rsg)	_FP_TO_INT (E, 4, (r), X, (rsz), (rsg))
# define FP_TO_INT_ROUND_E(r, X, rsz, rsg)	\
  _FP_TO_INT_ROUND (E, 4, (r), X, (rsz), (rsg))
# define FP_FROM_INT_E(X, r, rs, rt)	_FP_FROM_INT (E, 4, X, (r), (rs), rt)

# define _FP_FRAC_HIGH_E(X)	(X##_f[2])
# define _FP_FRAC_HIGH_RAW_E(X)	(X##_f[1])

# define _FP_FRAC_HIGH_DW_E(X)	(X##_f[4])

#else   /* not _FP_W_TYPE_SIZE < 64 */
union _FP_UNION_E
{
  XFtype flt;
  struct _FP_STRUCT_LAYOUT
  {
# if __BYTE_ORDER == __BIG_ENDIAN
    _FP_W_TYPE pad  : (_FP_W_TYPE_SIZE - 1 - _FP_EXPBITS_E);
    unsigned sign   : 1;
    unsigned exp    : _FP_EXPBITS_E;
    _FP_W_TYPE frac : _FP_W_TYPE_SIZE;
# else
    _FP_W_TYPE frac : _FP_W_TYPE_SIZE;
    unsigned exp    : _FP_EXPBITS_E;
    unsigned sign   : 1;
# endif
  } bits;
};

# define FP_DECL_E(X)		_FP_DECL (2, X)

# define FP_UNPACK_RAW_E(X, val)		\
  do						\
    {						\
      union _FP_UNION_E FP_UNPACK_RAW_E_flo;	\
      FP_UNPACK_RAW_E_flo.flt = (val);		\
						\
      X##_f0 = FP_UNPACK_RAW_E_flo.bits.frac;	\
      X##_f0 &= ~_FP_IMPLBIT_E;			\
      X##_f1 = 0;				\
      X##_e = FP_UNPACK_RAW_E_flo.bits.exp;	\
      X##_s = FP_UNPACK_RAW_E_flo.bits.sign;	\
    }						\
  while (0)

# define FP_UNPACK_RAW_EP(X, val)		\
  do						\
    {						\
      union _FP_UNION_E *FP_UNPACK_RAW_EP_flo	\
	= (union _FP_UNION_E *) (val);		\
						\
      X##_f0 = FP_UNPACK_RAW_EP_flo->bits.frac;	\
      X##_f0 &= ~_FP_IMPLBIT_E;			\
      X##_f1 = 0;				\
      X##_e = FP_UNPACK_RAW_EP_flo->bits.exp;	\
      X##_s = FP_UNPACK_RAW_EP_flo->bits.sign;	\
    }						\
  while (0)

# define FP_PACK_RAW_E(val, X)			\
  do						\
    {						\
      union _FP_UNION_E FP_PACK_RAW_E_flo;	\
						\
      if (X##_e)				\
	X##_f0 |= _FP_IMPLBIT_E;		\
      else					\
	X##_f0 &= ~(_FP_IMPLBIT_E);		\
      FP_PACK_RAW_E_flo.bits.frac = X##_f0;	\
      FP_PACK_RAW_E_flo.bits.exp  = X##_e;	\
      FP_PACK_RAW_E_flo.bits.sign = X##_s;	\
						\
      (val) = FP_PACK_RAW_E_flo.flt;		\
    }						\
  while (0)

# define FP_PACK_RAW_EP(fs, val, X)			\
  do							\
    {							\
      if (!FP_INHIBIT_RESULTS)				\
	{						\
	  union _FP_UNION_E *FP_PACK_RAW_EP_flo		\
	    = (union _FP_UNION_E *) (val);		\
							\
	  if (X##_e)					\
	    X##_f0 |= _FP_IMPLBIT_E;			\
	  else						\
	    X##_f0 &= ~(_FP_IMPLBIT_E);			\
	  FP_PACK_RAW_EP_flo->bits.frac = X##_f0;	\
	  FP_PACK_RAW_EP_flo->bits.exp  = X##_e;	\
	  FP_PACK_RAW_EP_flo->bits.sign = X##_s;	\
	}						\
    }							\
  while (0)


# define FP_UNPACK_E(X, val)			\
  do						\
    {						\
      FP_UNPACK_RAW_E (X, (val));		\
      _FP_UNPACK_CANONICAL (E, 2, X);		\
    }						\
  while (0)

# define FP_UNPACK_EP(X, val)			\
  do						\
    {						\
      FP_UNPACK_RAW_EP (X, (val));		\
      _FP_UNPACK_CANONICAL (E, 2, X);		\
    }						\
  while (0)

# define FP_UNPACK_SEMIRAW_E(X, val)		\
  do						\
    {						\
      FP_UNPACK_RAW_E (X, (val));		\
      _FP_UNPACK_SEMIRAW (E, 2, X);		\
    }						\
  while (0)

# define FP_UNPACK_SEMIRAW_EP(X, val)		\
  do						\
    {						\
      FP_UNPACK_RAW_EP (X, (val));		\
      _FP_UNPACK_SEMIRAW (E, 2, X);		\
    }						\
  while (0)

# define FP_PACK_E(val, X)			\
  do						\
    {						\
      _FP_PACK_CANONICAL (E, 2, X);		\
      FP_PACK_RAW_E ((val), X);			\
    }						\
  while (0)

# define FP_PACK_EP(val, X)			\
  do						\
    {						\
      _FP_PACK_CANONICAL (E, 2, X);		\
      FP_PACK_RAW_EP ((val), X);		\
    }						\
  while (0)

# define FP_PACK_SEMIRAW_E(val, X)		\
  do						\
    {						\
      _FP_PACK_SEMIRAW (E, 2, X);		\
      FP_PACK_RAW_E ((val), X);			\
    }						\
  while (0)

# define FP_PACK_SEMIRAW_EP(val, X)		\
  do						\
    {						\
      _FP_PACK_SEMIRAW (E, 2, X);		\
      FP_PACK_RAW_EP ((val), X);		\
    }						\
  while (0)

# define FP_ISSIGNAN_E(X)	_FP_ISSIGNAN (E, 2, X)
# define FP_NEG_E(R, X)		_FP_NEG (E, 2, R, X)
# define FP_ADD_E(R, X, Y)	_FP_ADD (E, 2, R, X, Y)
# define FP_SUB_E(R, X, Y)	_FP_SUB (E, 2, R, X, Y)
# define FP_MUL_E(R, X, Y)	_FP_MUL (E, 2, R, X, Y)
# define FP_DIV_E(R, X, Y)	_FP_DIV (E, 2, R, X, Y)
# define FP_SQRT_E(R, X)	_FP_SQRT (E, 2, R, X)
# define FP_FMA_E(R, X, Y, Z)	_FP_FMA (E, 2, 4, R, X, Y, Z)

/* Square root algorithms:
   We have just one right now, maybe Newton approximation
   should be added for those machines where division is fast.
   We optimize it by doing most of the calculations
   in one UWtype registers instead of two, although we don't
   have to.  */
# define _FP_SQRT_MEAT_E(R, S, T, X, q)			\
  do							\
    {							\
      (q) = (_FP_W_TYPE) 1 << (_FP_W_TYPE_SIZE - 1);	\
      _FP_FRAC_SRL_2 (X, (_FP_WORKBITS));		\
      while (q)						\
	{						\
	  T##_f0 = S##_f0 + (q);			\
	  if (T##_f0 <= X##_f0)				\
	    {						\
	      S##_f0 = T##_f0 + (q);			\
	      X##_f0 -= T##_f0;				\
	      R##_f0 += (q);				\
	    }						\
	  _FP_FRAC_SLL_1 (X, 1);			\
	  (q) >>= 1;					\
	}						\
      _FP_FRAC_SLL_2 (R, (_FP_WORKBITS));		\
      if (X##_f0)					\
	{						\
	  if (S##_f0 < X##_f0)				\
	    R##_f0 |= _FP_WORK_ROUND;			\
	  R##_f0 |= _FP_WORK_STICKY;			\
	}						\
    }							\
  while (0)

# define FP_CMP_E(r, X, Y, un, ex)	_FP_CMP (E, 2, (r), X, Y, (un), (ex))
# define FP_CMP_EQ_E(r, X, Y, ex)	_FP_CMP_EQ (E, 2, (r), X, Y, (ex))
# define FP_CMP_UNORD_E(r, X, Y, ex)	_FP_CMP_UNORD (E, 2, (r), X, Y, (ex))

# define FP_TO_INT_E(r, X, rsz, rsg)	_FP_TO_INT (E, 2, (r), X, (rsz), (rsg))
# define FP_TO_INT_ROUND_E(r, X, rsz, rsg)	\
  _FP_TO_INT_ROUND (E, 2, (r), X, (rsz), (rsg))
# define FP_FROM_INT_E(X, r, rs, rt)	_FP_FROM_INT (E, 2, X, (r), (rs), rt)

# define _FP_FRAC_HIGH_E(X)	(X##_f1)
# define _FP_FRAC_HIGH_RAW_E(X)	(X##_f0)

# define _FP_FRAC_HIGH_DW_E(X)	(X##_f[2])

#endif /* not _FP_W_TYPE_SIZE < 64 */

#endif /* !SOFT_FP_EXTENDED_H */
Commit	Line	Data
d876f532 UD	1	/* Software floating-point emulation.
d876f532 UD	2	Definitions for IEEE Extended Precision.
688903eb	3	Copyright (C) 1999-2018 Free Software Foundation, Inc.
d876f532 UD	4	This file is part of the GNU C Library.
	5	Contributed by Jakub Jelinek (jj@ultra.linux.cz).
	6
	7	The GNU C Library is free software; you can redistribute it and/or
41bdb6e2 AJ	8	modify it under the terms of the GNU Lesser General Public
	9	License as published by the Free Software Foundation; either
	10	version 2.1 of the License, or (at your option) any later version.
d876f532	11
638a783c RM	12	In addition to the permissions in the GNU Lesser General Public
	13	License, the Free Software Foundation gives you unlimited
	14	permission to link the compiled version of this file into
	15	combinations with other programs, and to distribute those
	16	combinations without any restriction coming from the use of this
	17	file. (The Lesser General Public License restrictions do apply in
	18	other respects; for example, they cover modification of the file,
	19	and distribution when not linked into a combine executable.)
	20
d876f532 UD	21	The GNU C Library is distributed in the hope that it will be useful,
	22	but WITHOUT ANY WARRANTY; without even the implied warranty of
	23	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
41bdb6e2	24	Lesser General Public License for more details.
d876f532	25
41bdb6e2	26	You should have received a copy of the GNU Lesser General Public
59ba27a6 PE	27	License along with the GNU C Library; if not, see
59ba27a6 PE	28	<http://www.gnu.org/licenses/>. */
d876f532	29
a2f8be9c JM	30	#ifndef SOFT_FP_EXTENDED_H
	31	#define SOFT_FP_EXTENDED_H 1
	32
d876f532	33	#if _FP_W_TYPE_SIZE < 32
71b4dea7	34	# error "Here's a nickel, kid. Go buy yourself a real computer."
d876f532 UD	35	#endif
	36
	37	#if _FP_W_TYPE_SIZE < 64
71b4dea7 JM	38	# define _FP_FRACTBITS_E (4*_FP_W_TYPE_SIZE)
71b4dea7 JM	39	# define _FP_FRACTBITS_DW_E (8*_FP_W_TYPE_SIZE)
d876f532	40	#else
71b4dea7 JM	41	# define _FP_FRACTBITS_E (2*_FP_W_TYPE_SIZE)
71b4dea7 JM	42	# define _FP_FRACTBITS_DW_E (4*_FP_W_TYPE_SIZE)
d876f532 UD	43	#endif
	44
	45	#define _FP_FRACBITS_E 64
	46	#define _FP_FRACXBITS_E (_FP_FRACTBITS_E - _FP_FRACBITS_E)
	47	#define _FP_WFRACBITS_E (_FP_WORKBITS + _FP_FRACBITS_E)
	48	#define _FP_WFRACXBITS_E (_FP_FRACTBITS_E - _FP_WFRACBITS_E)
	49	#define _FP_EXPBITS_E 15
	50	#define _FP_EXPBIAS_E 16383
	51	#define _FP_EXPMAX_E 32767
	52
	53	#define _FP_QNANBIT_E \
51ca9e29	54	((_FP_W_TYPE) 1 << (_FP_FRACBITS_E-2) % _FP_W_TYPE_SIZE)
fe0b1e85	55	#define _FP_QNANBIT_SH_E \
51ca9e29	56	((_FP_W_TYPE) 1 << (_FP_FRACBITS_E-2+_FP_WORKBITS) % _FP_W_TYPE_SIZE)
d876f532	57	#define _FP_IMPLBIT_E \
51ca9e29	58	((_FP_W_TYPE) 1 << (_FP_FRACBITS_E-1) % _FP_W_TYPE_SIZE)
fe0b1e85	59	#define _FP_IMPLBIT_SH_E \
51ca9e29	60	((_FP_W_TYPE) 1 << (_FP_FRACBITS_E-1+_FP_WORKBITS) % _FP_W_TYPE_SIZE)
d876f532	61	#define _FP_OVERFLOW_E \
51ca9e29	62	((_FP_W_TYPE) 1 << (_FP_WFRACBITS_E % _FP_W_TYPE_SIZE))
d876f532	63
77f01ab5 JM	64	#define _FP_WFRACBITS_DW_E (2 * _FP_WFRACBITS_E)
	65	#define _FP_WFRACXBITS_DW_E (_FP_FRACTBITS_DW_E - _FP_WFRACBITS_DW_E)
	66	#define _FP_HIGHBIT_DW_E \
51ca9e29	67	((_FP_W_TYPE) 1 << (_FP_WFRACBITS_DW_E - 1) % _FP_W_TYPE_SIZE)
77f01ab5	68
51ca9e29	69	typedef float XFtype __attribute__ ((mode (XF)));
fe0b1e85	70
d876f532 UD	71	#if _FP_W_TYPE_SIZE < 64
	72
	73	union _FP_UNION_E
	74	{
1e145589 JM	75	XFtype flt;
	76	struct _FP_STRUCT_LAYOUT
	77	{
71b4dea7	78	# if __BYTE_ORDER == __BIG_ENDIAN
1e145589 JM	79	unsigned long pad1 : _FP_W_TYPE_SIZE;
	80	unsigned long pad2 : (_FP_W_TYPE_SIZE - 1 - _FP_EXPBITS_E);
	81	unsigned long sign : 1;
	82	unsigned long exp : _FP_EXPBITS_E;
	83	unsigned long frac1 : _FP_W_TYPE_SIZE;
	84	unsigned long frac0 : _FP_W_TYPE_SIZE;
71b4dea7	85	# else
1e145589 JM	86	unsigned long frac0 : _FP_W_TYPE_SIZE;
	87	unsigned long frac1 : _FP_W_TYPE_SIZE;
	88	unsigned exp : _FP_EXPBITS_E;
	89	unsigned sign : 1;
71b4dea7	90	# endif /* not bigendian */
049375e2	91	} bits;
d876f532 UD	92	};
	93
	94
51ca9e29	95	# define FP_DECL_E(X) _FP_DECL (4, X)
d876f532	96
9c37ec0b JM	97	# define FP_UNPACK_RAW_E(X, val) \
	98	do \
	99	{ \
	100	union _FP_UNION_E FP_UNPACK_RAW_E_flo; \
	101	FP_UNPACK_RAW_E_flo.flt = (val); \
	102	\
	103	X##_f[2] = 0; \
	104	X##_f[3] = 0; \
	105	X##_f[0] = FP_UNPACK_RAW_E_flo.bits.frac0; \
	106	X##_f[1] = FP_UNPACK_RAW_E_flo.bits.frac1; \
c2080970	107	X##_f[1] &= ~_FP_IMPLBIT_E; \
9c37ec0b JM	108	X##_e = FP_UNPACK_RAW_E_flo.bits.exp; \
	109	X##_s = FP_UNPACK_RAW_E_flo.bits.sign; \
	110	} \
1e145589 JM	111	while (0)
1e145589 JM	112
9c37ec0b JM	113	# define FP_UNPACK_RAW_EP(X, val) \
	114	do \
	115	{ \
	116	union _FP_UNION_E *FP_UNPACK_RAW_EP_flo \
	117	= (union _FP_UNION_E *) (val); \
	118	\
	119	X##_f[2] = 0; \
	120	X##_f[3] = 0; \
	121	X##_f[0] = FP_UNPACK_RAW_EP_flo->bits.frac0; \
	122	X##_f[1] = FP_UNPACK_RAW_EP_flo->bits.frac1; \
c2080970	123	X##_f[1] &= ~_FP_IMPLBIT_E; \
9c37ec0b JM	124	X##_e = FP_UNPACK_RAW_EP_flo->bits.exp; \
	125	X##_s = FP_UNPACK_RAW_EP_flo->bits.sign; \
	126	} \
1e145589 JM	127	while (0)
	128
	129	# define FP_PACK_RAW_E(val, X) \
	130	do \
	131	{ \
9c37ec0b	132	union _FP_UNION_E FP_PACK_RAW_E_flo; \
1e145589 JM	133	\
	134	if (X##_e) \
	135	X##_f[1] \|= _FP_IMPLBIT_E; \
	136	else \
	137	X##_f[1] &= ~(_FP_IMPLBIT_E); \
9c37ec0b JM	138	FP_PACK_RAW_E_flo.bits.frac0 = X##_f[0]; \
	139	FP_PACK_RAW_E_flo.bits.frac1 = X##_f[1]; \
	140	FP_PACK_RAW_E_flo.bits.exp = X##_e; \
	141	FP_PACK_RAW_E_flo.bits.sign = X##_s; \
1e145589	142	\
9c37ec0b	143	(val) = FP_PACK_RAW_E_flo.flt; \
1e145589 JM	144	} \
	145	while (0)
	146
9c37ec0b JM	147	# define FP_PACK_RAW_EP(val, X) \
	148	do \
	149	{ \
	150	if (!FP_INHIBIT_RESULTS) \
	151	{ \
	152	union _FP_UNION_E *FP_PACK_RAW_EP_flo \
	153	= (union _FP_UNION_E *) (val); \
	154	\
	155	if (X##_e) \
	156	X##_f[1] \|= _FP_IMPLBIT_E; \
	157	else \
	158	X##_f[1] &= ~(_FP_IMPLBIT_E); \
	159	FP_PACK_RAW_EP_flo->bits.frac0 = X##_f[0]; \
	160	FP_PACK_RAW_EP_flo->bits.frac1 = X##_f[1]; \
	161	FP_PACK_RAW_EP_flo->bits.exp = X##_e; \
	162	FP_PACK_RAW_EP_flo->bits.sign = X##_s; \
	163	} \
	164	} \
1e145589 JM	165	while (0)
1e145589 JM	166
51ca9e29	167	# define FP_UNPACK_E(X, val) \
1e145589 JM	168	do \
1e145589 JM	169	{ \
5c0508a3	170	FP_UNPACK_RAW_E (X, (val)); \
51ca9e29	171	_FP_UNPACK_CANONICAL (E, 4, X); \
1e145589 JM	172	} \
	173	while (0)
	174
51ca9e29	175	# define FP_UNPACK_EP(X, val) \
1e145589 JM	176	do \
1e145589 JM	177	{ \
5c0508a3	178	FP_UNPACK_RAW_EP (X, (val)); \
51ca9e29	179	_FP_UNPACK_CANONICAL (E, 4, X); \
1e145589 JM	180	} \
	181	while (0)
	182
51ca9e29	183	# define FP_UNPACK_SEMIRAW_E(X, val) \
1e145589 JM	184	do \
1e145589 JM	185	{ \
5c0508a3	186	FP_UNPACK_RAW_E (X, (val)); \
51ca9e29	187	_FP_UNPACK_SEMIRAW (E, 4, X); \
1e145589 JM	188	} \
	189	while (0)
	190
51ca9e29	191	# define FP_UNPACK_SEMIRAW_EP(X, val) \
1e145589 JM	192	do \
1e145589 JM	193	{ \
5c0508a3	194	FP_UNPACK_RAW_EP (X, (val)); \
51ca9e29	195	_FP_UNPACK_SEMIRAW (E, 4, X); \
1e145589 JM	196	} \
	197	while (0)
	198
51ca9e29	199	# define FP_PACK_E(val, X) \
1e145589 JM	200	do \
1e145589 JM	201	{ \
51ca9e29	202	_FP_PACK_CANONICAL (E, 4, X); \
5c0508a3	203	FP_PACK_RAW_E ((val), X); \
1e145589 JM	204	} \
	205	while (0)
	206
51ca9e29	207	# define FP_PACK_EP(val, X) \
1e145589 JM	208	do \
1e145589 JM	209	{ \
51ca9e29	210	_FP_PACK_CANONICAL (E, 4, X); \
5c0508a3	211	FP_PACK_RAW_EP ((val), X); \
1e145589 JM	212	} \
	213	while (0)
	214
51ca9e29	215	# define FP_PACK_SEMIRAW_E(val, X) \
1e145589 JM	216	do \
1e145589 JM	217	{ \
51ca9e29	218	_FP_PACK_SEMIRAW (E, 4, X); \
5c0508a3	219	FP_PACK_RAW_E ((val), X); \
1e145589 JM	220	} \
	221	while (0)
	222
51ca9e29	223	# define FP_PACK_SEMIRAW_EP(val, X) \
1e145589 JM	224	do \
1e145589 JM	225	{ \
51ca9e29	226	_FP_PACK_SEMIRAW (E, 4, X); \
5c0508a3	227	FP_PACK_RAW_EP ((val), X); \
1e145589 JM	228	} \
1e145589 JM	229	while (0)
fe0b1e85	230
51ca9e29 JM	231	# define FP_ISSIGNAN_E(X) _FP_ISSIGNAN (E, 4, X)
	232	# define FP_NEG_E(R, X) _FP_NEG (E, 4, R, X)
	233	# define FP_ADD_E(R, X, Y) _FP_ADD (E, 4, R, X, Y)
	234	# define FP_SUB_E(R, X, Y) _FP_SUB (E, 4, R, X, Y)
	235	# define FP_MUL_E(R, X, Y) _FP_MUL (E, 4, R, X, Y)
	236	# define FP_DIV_E(R, X, Y) _FP_DIV (E, 4, R, X, Y)
	237	# define FP_SQRT_E(R, X) _FP_SQRT (E, 4, R, X)
	238	# define FP_FMA_E(R, X, Y, Z) _FP_FMA (E, 4, 8, R, X, Y, Z)
d876f532	239
c4fe3ea7 JM	240	/* Square root algorithms:
	241	We have just one right now, maybe Newton approximation
	242	should be added for those machines where division is fast.
	243	This has special _E version because standard _4 square
	244	root would not work (it has to start normally with the
	245	second word and not the first), but as we have to do it
	246	anyway, we optimize it by doing most of the calculations
	247	in two UWtype registers instead of four. */
9c84384c	248
71b4dea7	249	# define _FP_SQRT_MEAT_E(R, S, T, X, q) \
1e145589 JM	250	do \
1e145589 JM	251	{ \
5c0508a3	252	(q) = (_FP_W_TYPE) 1 << (_FP_W_TYPE_SIZE - 1); \
51ca9e29	253	_FP_FRAC_SRL_4 (X, (_FP_WORKBITS)); \
1e145589 JM	254	while (q) \
1e145589 JM	255	{ \
5c0508a3	256	T##_f[1] = S##_f[1] + (q); \
1e145589 JM	257	if (T##_f[1] <= X##_f[1]) \
1e145589 JM	258	{ \
5c0508a3	259	S##_f[1] = T##_f[1] + (q); \
1e145589	260	X##_f[1] -= T##_f[1]; \
5c0508a3	261	R##_f[1] += (q); \
1e145589	262	} \
51ca9e29	263	_FP_FRAC_SLL_2 (X, 1); \
5c0508a3	264	(q) >>= 1; \
1e145589	265	} \
5c0508a3	266	(q) = (_FP_W_TYPE) 1 << (_FP_W_TYPE_SIZE - 1); \
1e145589 JM	267	while (q) \
1e145589 JM	268	{ \
5c0508a3	269	T##_f[0] = S##_f[0] + (q); \
1e145589 JM	270	T##_f[1] = S##_f[1]; \
	271	if (T##_f[1] < X##_f[1] \
	272	\|\| (T##_f[1] == X##_f[1] \
	273	&& T##_f[0] <= X##_f[0])) \
	274	{ \
5c0508a3	275	S##_f[0] = T##_f[0] + (q); \
1e145589	276	S##_f[1] += (T##_f[0] > S##_f[0]); \
51ca9e29	277	_FP_FRAC_DEC_2 (X, T); \
5c0508a3	278	R##_f[0] += (q); \
1e145589	279	} \
51ca9e29	280	_FP_FRAC_SLL_2 (X, 1); \
5c0508a3	281	(q) >>= 1; \
1e145589	282	} \
51ca9e29	283	_FP_FRAC_SLL_4 (R, (_FP_WORKBITS)); \
1e145589 JM	284	if (X##_f[0] \| X##_f[1]) \
	285	{ \
	286	if (S##_f[1] < X##_f[1] \
	287	\|\| (S##_f[1] == X##_f[1] \
	288	&& S##_f[0] < X##_f[0])) \
	289	R##_f[0] \|= _FP_WORK_ROUND; \
	290	R##_f[0] \|= _FP_WORK_STICKY; \
	291	} \
	292	} \
	293	while (0)
d876f532	294
5c0508a3 JM	295	# define FP_CMP_E(r, X, Y, un, ex) _FP_CMP (E, 4, (r), X, Y, (un), (ex))
	296	# define FP_CMP_EQ_E(r, X, Y, ex) _FP_CMP_EQ (E, 4, (r), X, Y, (ex))
	297	# define FP_CMP_UNORD_E(r, X, Y, ex) _FP_CMP_UNORD (E, 4, (r), X, Y, (ex))
d876f532	298
5c0508a3	299	# define FP_TO_INT_E(r, X, rsz, rsg) _FP_TO_INT (E, 4, (r), X, (rsz), (rsg))
2004e7fb JM	300	# define FP_TO_INT_ROUND_E(r, X, rsz, rsg) \
2004e7fb JM	301	_FP_TO_INT_ROUND (E, 4, (r), X, (rsz), (rsg))
5c0508a3	302	# define FP_FROM_INT_E(X, r, rs, rt) _FP_FROM_INT (E, 4, X, (r), (rs), rt)
d876f532	303
71b4dea7 JM	304	# define _FP_FRAC_HIGH_E(X) (X##_f[2])
71b4dea7 JM	305	# define _FP_FRAC_HIGH_RAW_E(X) (X##_f[1])
d876f532	306
71b4dea7	307	# define _FP_FRAC_HIGH_DW_E(X) (X##_f[4])
77f01ab5	308
d876f532 UD	309	#else /* not _FP_W_TYPE_SIZE < 64 */
	310	union _FP_UNION_E
	311	{
fe0b1e85	312	XFtype flt;
1e145589 JM	313	struct _FP_STRUCT_LAYOUT
1e145589 JM	314	{
71b4dea7	315	# if __BYTE_ORDER == __BIG_ENDIAN
06029c20 JJ	316	_FP_W_TYPE pad : (_FP_W_TYPE_SIZE - 1 - _FP_EXPBITS_E);
	317	unsigned sign : 1;
	318	unsigned exp : _FP_EXPBITS_E;
	319	_FP_W_TYPE frac : _FP_W_TYPE_SIZE;
71b4dea7	320	# else
06029c20 JJ	321	_FP_W_TYPE frac : _FP_W_TYPE_SIZE;
	322	unsigned exp : _FP_EXPBITS_E;
	323	unsigned sign : 1;
71b4dea7	324	# endif
d876f532 UD	325	} bits;
	326	};
	327
51ca9e29	328	# define FP_DECL_E(X) _FP_DECL (2, X)
d876f532	329
1e145589 JM	330	# define FP_UNPACK_RAW_E(X, val) \
	331	do \
	332	{ \
9c37ec0b JM	333	union _FP_UNION_E FP_UNPACK_RAW_E_flo; \
9c37ec0b JM	334	FP_UNPACK_RAW_E_flo.flt = (val); \
1e145589	335	\
9c37ec0b	336	X##_f0 = FP_UNPACK_RAW_E_flo.bits.frac; \
c2080970	337	X##_f0 &= ~_FP_IMPLBIT_E; \
1e145589	338	X##_f1 = 0; \
9c37ec0b JM	339	X##_e = FP_UNPACK_RAW_E_flo.bits.exp; \
9c37ec0b JM	340	X##_s = FP_UNPACK_RAW_E_flo.bits.sign; \
1e145589 JM	341	} \
1e145589 JM	342	while (0)
d876f532	343
9c37ec0b JM	344	# define FP_UNPACK_RAW_EP(X, val) \
	345	do \
	346	{ \
	347	union _FP_UNION_E *FP_UNPACK_RAW_EP_flo \
	348	= (union _FP_UNION_E *) (val); \
	349	\
	350	X##_f0 = FP_UNPACK_RAW_EP_flo->bits.frac; \
c2080970	351	X##_f0 &= ~_FP_IMPLBIT_E; \
9c37ec0b JM	352	X##_f1 = 0; \
	353	X##_e = FP_UNPACK_RAW_EP_flo->bits.exp; \
	354	X##_s = FP_UNPACK_RAW_EP_flo->bits.sign; \
	355	} \
1e145589 JM	356	while (0)
	357
	358	# define FP_PACK_RAW_E(val, X) \
	359	do \
	360	{ \
9c37ec0b	361	union _FP_UNION_E FP_PACK_RAW_E_flo; \
1e145589 JM	362	\
	363	if (X##_e) \
	364	X##_f0 \|= _FP_IMPLBIT_E; \
	365	else \
	366	X##_f0 &= ~(_FP_IMPLBIT_E); \
9c37ec0b JM	367	FP_PACK_RAW_E_flo.bits.frac = X##_f0; \
	368	FP_PACK_RAW_E_flo.bits.exp = X##_e; \
	369	FP_PACK_RAW_E_flo.bits.sign = X##_s; \
1e145589	370	\
9c37ec0b	371	(val) = FP_PACK_RAW_E_flo.flt; \
1e145589 JM	372	} \
1e145589 JM	373	while (0)
d876f532	374
9c37ec0b JM	375	# define FP_PACK_RAW_EP(fs, val, X) \
	376	do \
	377	{ \
	378	if (!FP_INHIBIT_RESULTS) \
	379	{ \
	380	union _FP_UNION_E *FP_PACK_RAW_EP_flo \
	381	= (union _FP_UNION_E *) (val); \
	382	\
	383	if (X##_e) \
	384	X##_f0 \|= _FP_IMPLBIT_E; \
	385	else \
	386	X##_f0 &= ~(_FP_IMPLBIT_E); \
	387	FP_PACK_RAW_EP_flo->bits.frac = X##_f0; \
	388	FP_PACK_RAW_EP_flo->bits.exp = X##_e; \
	389	FP_PACK_RAW_EP_flo->bits.sign = X##_s; \
	390	} \
	391	} \
1e145589 JM	392	while (0)
	393
	394
51ca9e29	395	# define FP_UNPACK_E(X, val) \
1e145589 JM	396	do \
1e145589 JM	397	{ \
5c0508a3	398	FP_UNPACK_RAW_E (X, (val)); \
51ca9e29	399	_FP_UNPACK_CANONICAL (E, 2, X); \
1e145589 JM	400	} \
	401	while (0)
	402
51ca9e29	403	# define FP_UNPACK_EP(X, val) \
1e145589 JM	404	do \
1e145589 JM	405	{ \
5c0508a3	406	FP_UNPACK_RAW_EP (X, (val)); \
51ca9e29	407	_FP_UNPACK_CANONICAL (E, 2, X); \
1e145589 JM	408	} \
	409	while (0)
	410
51ca9e29	411	# define FP_UNPACK_SEMIRAW_E(X, val) \
1e145589 JM	412	do \
1e145589 JM	413	{ \
5c0508a3	414	FP_UNPACK_RAW_E (X, (val)); \
51ca9e29	415	_FP_UNPACK_SEMIRAW (E, 2, X); \
1e145589 JM	416	} \
	417	while (0)
	418
51ca9e29	419	# define FP_UNPACK_SEMIRAW_EP(X, val) \
1e145589 JM	420	do \
1e145589 JM	421	{ \
5c0508a3	422	FP_UNPACK_RAW_EP (X, (val)); \
51ca9e29	423	_FP_UNPACK_SEMIRAW (E, 2, X); \
1e145589 JM	424	} \
	425	while (0)
	426
51ca9e29	427	# define FP_PACK_E(val, X) \
1e145589 JM	428	do \
1e145589 JM	429	{ \
51ca9e29	430	_FP_PACK_CANONICAL (E, 2, X); \
5c0508a3	431	FP_PACK_RAW_E ((val), X); \
1e145589 JM	432	} \
	433	while (0)
	434
51ca9e29	435	# define FP_PACK_EP(val, X) \
1e145589 JM	436	do \
1e145589 JM	437	{ \
51ca9e29	438	_FP_PACK_CANONICAL (E, 2, X); \
5c0508a3	439	FP_PACK_RAW_EP ((val), X); \
1e145589 JM	440	} \
	441	while (0)
	442
51ca9e29	443	# define FP_PACK_SEMIRAW_E(val, X) \
1e145589 JM	444	do \
1e145589 JM	445	{ \
51ca9e29	446	_FP_PACK_SEMIRAW (E, 2, X); \
5c0508a3	447	FP_PACK_RAW_E ((val), X); \
1e145589 JM	448	} \
	449	while (0)
	450
51ca9e29	451	# define FP_PACK_SEMIRAW_EP(val, X) \
1e145589 JM	452	do \
1e145589 JM	453	{ \
51ca9e29	454	_FP_PACK_SEMIRAW (E, 2, X); \
5c0508a3	455	FP_PACK_RAW_EP ((val), X); \
1e145589 JM	456	} \
1e145589 JM	457	while (0)
fe0b1e85	458
51ca9e29 JM	459	# define FP_ISSIGNAN_E(X) _FP_ISSIGNAN (E, 2, X)
	460	# define FP_NEG_E(R, X) _FP_NEG (E, 2, R, X)
	461	# define FP_ADD_E(R, X, Y) _FP_ADD (E, 2, R, X, Y)
	462	# define FP_SUB_E(R, X, Y) _FP_SUB (E, 2, R, X, Y)
	463	# define FP_MUL_E(R, X, Y) _FP_MUL (E, 2, R, X, Y)
	464	# define FP_DIV_E(R, X, Y) _FP_DIV (E, 2, R, X, Y)
	465	# define FP_SQRT_E(R, X) _FP_SQRT (E, 2, R, X)
	466	# define FP_FMA_E(R, X, Y, Z) _FP_FMA (E, 2, 4, R, X, Y, Z)
d876f532	467
c4fe3ea7 JM	468	/* Square root algorithms:
	469	We have just one right now, maybe Newton approximation
	470	should be added for those machines where division is fast.
	471	We optimize it by doing most of the calculations
	472	in one UWtype registers instead of two, although we don't
	473	have to. */
71b4dea7	474	# define _FP_SQRT_MEAT_E(R, S, T, X, q) \
1e145589 JM	475	do \
1e145589 JM	476	{ \
5c0508a3	477	(q) = (_FP_W_TYPE) 1 << (_FP_W_TYPE_SIZE - 1); \
51ca9e29	478	_FP_FRAC_SRL_2 (X, (_FP_WORKBITS)); \
1e145589 JM	479	while (q) \
1e145589 JM	480	{ \
5c0508a3	481	T##_f0 = S##_f0 + (q); \
1e145589 JM	482	if (T##_f0 <= X##_f0) \
1e145589 JM	483	{ \
5c0508a3	484	S##_f0 = T##_f0 + (q); \
1e145589	485	X##_f0 -= T##_f0; \
5c0508a3	486	R##_f0 += (q); \
1e145589	487	} \
51ca9e29	488	_FP_FRAC_SLL_1 (X, 1); \
5c0508a3	489	(q) >>= 1; \
1e145589	490	} \
51ca9e29	491	_FP_FRAC_SLL_2 (R, (_FP_WORKBITS)); \
1e145589 JM	492	if (X##_f0) \
	493	{ \
	494	if (S##_f0 < X##_f0) \
	495	R##_f0 \|= _FP_WORK_ROUND; \
	496	R##_f0 \|= _FP_WORK_STICKY; \
	497	} \
	498	} \
	499	while (0)
9c84384c	500
5c0508a3 JM	501	# define FP_CMP_E(r, X, Y, un, ex) _FP_CMP (E, 2, (r), X, Y, (un), (ex))
	502	# define FP_CMP_EQ_E(r, X, Y, ex) _FP_CMP_EQ (E, 2, (r), X, Y, (ex))
	503	# define FP_CMP_UNORD_E(r, X, Y, ex) _FP_CMP_UNORD (E, 2, (r), X, Y, (ex))
d876f532	504
5c0508a3	505	# define FP_TO_INT_E(r, X, rsz, rsg) _FP_TO_INT (E, 2, (r), X, (rsz), (rsg))
2004e7fb JM	506	# define FP_TO_INT_ROUND_E(r, X, rsz, rsg) \
2004e7fb JM	507	_FP_TO_INT_ROUND (E, 2, (r), X, (rsz), (rsg))
5c0508a3	508	# define FP_FROM_INT_E(X, r, rs, rt) _FP_FROM_INT (E, 2, X, (r), (rs), rt)
d876f532	509
71b4dea7 JM	510	# define _FP_FRAC_HIGH_E(X) (X##_f1)
71b4dea7 JM	511	# define _FP_FRAC_HIGH_RAW_E(X) (X##_f0)
d876f532	512
71b4dea7	513	# define _FP_FRAC_HIGH_DW_E(X) (X##_f[2])
77f01ab5	514
d876f532	515	#endif /* not _FP_W_TYPE_SIZE < 64 */
a2f8be9c JM	516
a2f8be9c JM	517	#endif /* !SOFT_FP_EXTENDED_H */