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

/* Software floating-point emulation.
   Definitions for IEEE Extended Precision.
   Copyright (C) 1999-2024 Free Software Foundation, Inc.
   This file is part of the GNU C Library.

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