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

/* Software floating-point emulation.
   Definitions for IEEE Extended Precision.
   Copyright (C) 1999-2013 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/>.  */

#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 __attribute__((packed));
};


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

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

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

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

#define FP_PACK_RAW_EP(val, X)				\
  do {							\
    if (!FP_INHIBIT_RESULTS)				\
      {							\
	union _FP_UNION_E *_flo =			\
	  (union _FP_UNION_E *)(val);			\
							\
	if (X##_e) X##_f[1] |= _FP_IMPLBIT_E;		\
	else X##_f[1] &= ~(_FP_IMPLBIT_E);		\
	_flo->bits.frac0 = X##_f[0];			\
	_flo->bits.frac1 = X##_f[1];			\
	_flo->bits.exp   = X##_e;			\
	_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)	_FP_CMP(E,4,r,X,Y,un)
#define FP_CMP_EQ_E(r,X,Y)	_FP_CMP_EQ(E,4,r,X,Y)
#define FP_CMP_UNORD_E(r,X,Y)	_FP_CMP_UNORD(E,4,r,X,Y)

#define FP_TO_INT_E(r,X,rsz,rsg)	_FP_TO_INT(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 _flo; _flo.flt = (val);			\
								\
    X##_f0 = _flo.bits.frac;					\
    X##_f1 = 0;							\
    X##_e = _flo.bits.exp;					\
    X##_s = _flo.bits.sign;					\
  } while (0)

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

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

#define FP_PACK_RAW_EP(fs, val, X)				\
  do {								\
    if (!FP_INHIBIT_RESULTS)					\
      {								\
	union _FP_UNION_E *_flo =				\
	  (union _FP_UNION_E *)(val);				\
								\
	if (X##_e) X##_f0 |= _FP_IMPLBIT_E;			\
	else X##_f0 &= ~(_FP_IMPLBIT_E);			\
	_flo->bits.frac = X##_f0;				\
	_flo->bits.exp  = X##_e;				\
	_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)	_FP_CMP(E,2,r,X,Y,un)
#define FP_CMP_EQ_E(r,X,Y)	_FP_CMP_EQ(E,2,r,X,Y)
#define FP_CMP_UNORD_E(r,X,Y)	_FP_CMP_UNORD(E,2,r,X,Y)

#define FP_TO_INT_E(r,X,rsz,rsg)	_FP_TO_INT(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 */
Commit	Line	Data
d876f532 UD	1	/* Software floating-point emulation.
d876f532 UD	2	Definitions for IEEE Extended Precision.
568035b7	3	Copyright (C) 1999-2013 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 UD	29
	30	#if _FP_W_TYPE_SIZE < 32
	31	#error "Here's a nickel, kid. Go buy yourself a real computer."
	32	#endif
	33
	34	#if _FP_W_TYPE_SIZE < 64
	35	#define _FP_FRACTBITS_E (4*_FP_W_TYPE_SIZE)
77f01ab5	36	#define _FP_FRACTBITS_DW_E (8*_FP_W_TYPE_SIZE)
d876f532 UD	37	#else
d876f532 UD	38	#define _FP_FRACTBITS_E (2*_FP_W_TYPE_SIZE)
77f01ab5	39	#define _FP_FRACTBITS_DW_E (4*_FP_W_TYPE_SIZE)
d876f532 UD	40	#endif
	41
	42	#define _FP_FRACBITS_E 64
	43	#define _FP_FRACXBITS_E (_FP_FRACTBITS_E - _FP_FRACBITS_E)
	44	#define _FP_WFRACBITS_E (_FP_WORKBITS + _FP_FRACBITS_E)
	45	#define _FP_WFRACXBITS_E (_FP_FRACTBITS_E - _FP_WFRACBITS_E)
	46	#define _FP_EXPBITS_E 15
	47	#define _FP_EXPBIAS_E 16383
	48	#define _FP_EXPMAX_E 32767
	49
	50	#define _FP_QNANBIT_E \
	51	((_FP_W_TYPE)1 << (_FP_FRACBITS_E-2) % _FP_W_TYPE_SIZE)
fe0b1e85 RM	52	#define _FP_QNANBIT_SH_E \
fe0b1e85 RM	53	((_FP_W_TYPE)1 << (_FP_FRACBITS_E-2+_FP_WORKBITS) % _FP_W_TYPE_SIZE)
d876f532 UD	54	#define _FP_IMPLBIT_E \
d876f532 UD	55	((_FP_W_TYPE)1 << (_FP_FRACBITS_E-1) % _FP_W_TYPE_SIZE)
fe0b1e85 RM	56	#define _FP_IMPLBIT_SH_E \
fe0b1e85 RM	57	((_FP_W_TYPE)1 << (_FP_FRACBITS_E-1+_FP_WORKBITS) % _FP_W_TYPE_SIZE)
d876f532 UD	58	#define _FP_OVERFLOW_E \
	59	((_FP_W_TYPE)1 << (_FP_WFRACBITS_E % _FP_W_TYPE_SIZE))
	60
77f01ab5 JM	61	#define _FP_WFRACBITS_DW_E (2 * _FP_WFRACBITS_E)
	62	#define _FP_WFRACXBITS_DW_E (_FP_FRACTBITS_DW_E - _FP_WFRACBITS_DW_E)
	63	#define _FP_HIGHBIT_DW_E \
	64	((_FP_W_TYPE)1 << (_FP_WFRACBITS_DW_E - 1) % _FP_W_TYPE_SIZE)
	65
fe0b1e85 RM	66	typedef float XFtype __attribute__((mode(XF)));
fe0b1e85 RM	67
d876f532 UD	68	#if _FP_W_TYPE_SIZE < 64
	69
	70	union _FP_UNION_E
	71	{
fe0b1e85	72	XFtype flt;
f775c276	73	struct _FP_STRUCT_LAYOUT
d876f532 UD	74	{
	75	#if __BYTE_ORDER == __BIG_ENDIAN
	76	unsigned long pad1 : _FP_W_TYPE_SIZE;
	77	unsigned long pad2 : (_FP_W_TYPE_SIZE - 1 - _FP_EXPBITS_E);
	78	unsigned long sign : 1;
	79	unsigned long exp : _FP_EXPBITS_E;
	80	unsigned long frac1 : _FP_W_TYPE_SIZE;
	81	unsigned long frac0 : _FP_W_TYPE_SIZE;
	82	#else
	83	unsigned long frac0 : _FP_W_TYPE_SIZE;
	84	unsigned long frac1 : _FP_W_TYPE_SIZE;
	85	unsigned exp : _FP_EXPBITS_E;
	86	unsigned sign : 1;
	87	#endif /* not bigendian */
	88	} bits __attribute__((packed));
	89	};
	90
	91
	92	#define FP_DECL_E(X) _FP_DECL(4,X)
	93
	94	#define FP_UNPACK_RAW_E(X, val) \
	95	do { \
	96	union _FP_UNION_E _flo; _flo.flt = (val); \
	97	\
	98	X##_f[2] = 0; X##_f[3] = 0; \
	99	X##_f[0] = _flo.bits.frac0; \
	100	X##_f[1] = _flo.bits.frac1; \
	101	X##_e = _flo.bits.exp; \
	102	X##_s = _flo.bits.sign; \
d876f532 UD	103	} while (0)
	104
	105	#define FP_UNPACK_RAW_EP(X, val) \
	106	do { \
	107	union _FP_UNION_E *_flo = \
	108	(union _FP_UNION_E *)(val); \
	109	\
	110	X##_f[2] = 0; X##_f[3] = 0; \
	111	X##_f[0] = _flo->bits.frac0; \
	112	X##_f[1] = _flo->bits.frac1; \
	113	X##_e = _flo->bits.exp; \
	114	X##_s = _flo->bits.sign; \
d876f532 UD	115	} while (0)
	116
	117	#define FP_PACK_RAW_E(val, X) \
	118	do { \
	119	union _FP_UNION_E _flo; \
	120	\
	121	if (X##_e) X##_f[1] \|= _FP_IMPLBIT_E; \
	122	else X##_f[1] &= ~(_FP_IMPLBIT_E); \
	123	_flo.bits.frac0 = X##_f[0]; \
	124	_flo.bits.frac1 = X##_f[1]; \
	125	_flo.bits.exp = X##_e; \
	126	_flo.bits.sign = X##_s; \
	127	\
	128	(val) = _flo.flt; \
	129	} while (0)
	130
	131	#define FP_PACK_RAW_EP(val, X) \
	132	do { \
	133	if (!FP_INHIBIT_RESULTS) \
	134	{ \
	135	union _FP_UNION_E *_flo = \
	136	(union _FP_UNION_E *)(val); \
	137	\
	138	if (X##_e) X##_f[1] \|= _FP_IMPLBIT_E; \
	139	else X##_f[1] &= ~(_FP_IMPLBIT_E); \
	140	_flo->bits.frac0 = X##_f[0]; \
	141	_flo->bits.frac1 = X##_f[1]; \
	142	_flo->bits.exp = X##_e; \
	143	_flo->bits.sign = X##_s; \
	144	} \
	145	} while (0)
	146
	147	#define FP_UNPACK_E(X,val) \
	148	do { \
	149	FP_UNPACK_RAW_E(X,val); \
	150	_FP_UNPACK_CANONICAL(E,4,X); \
	151	} while (0)
	152
	153	#define FP_UNPACK_EP(X,val) \
	154	do { \
fe0b1e85	155	FP_UNPACK_RAW_EP(X,val); \
d876f532 UD	156	_FP_UNPACK_CANONICAL(E,4,X); \
	157	} while (0)
	158
fe0b1e85 RM	159	#define FP_UNPACK_SEMIRAW_E(X,val) \
fe0b1e85 RM	160	do { \
37002cbc	161	FP_UNPACK_RAW_E(X,val); \
fe0b1e85 RM	162	_FP_UNPACK_SEMIRAW(E,4,X); \
	163	} while (0)
	164
	165	#define FP_UNPACK_SEMIRAW_EP(X,val) \
	166	do { \
37002cbc	167	FP_UNPACK_RAW_EP(X,val); \
fe0b1e85 RM	168	_FP_UNPACK_SEMIRAW(E,4,X); \
	169	} while (0)
	170
d876f532 UD	171	#define FP_PACK_E(val,X) \
	172	do { \
	173	_FP_PACK_CANONICAL(E,4,X); \
	174	FP_PACK_RAW_E(val,X); \
	175	} while (0)
	176
	177	#define FP_PACK_EP(val,X) \
	178	do { \
	179	_FP_PACK_CANONICAL(E,4,X); \
	180	FP_PACK_RAW_EP(val,X); \
	181	} while (0)
	182
fe0b1e85 RM	183	#define FP_PACK_SEMIRAW_E(val,X) \
	184	do { \
	185	_FP_PACK_SEMIRAW(E,4,X); \
37002cbc	186	FP_PACK_RAW_E(val,X); \
fe0b1e85 RM	187	} while (0)
	188
	189	#define FP_PACK_SEMIRAW_EP(val,X) \
	190	do { \
	191	_FP_PACK_SEMIRAW(E,4,X); \
37002cbc	192	FP_PACK_RAW_EP(val,X); \
fe0b1e85 RM	193	} while (0)
fe0b1e85 RM	194
d876f532 UD	195	#define FP_ISSIGNAN_E(X) _FP_ISSIGNAN(E,4,X)
	196	#define FP_NEG_E(R,X) _FP_NEG(E,4,R,X)
	197	#define FP_ADD_E(R,X,Y) _FP_ADD(E,4,R,X,Y)
	198	#define FP_SUB_E(R,X,Y) _FP_SUB(E,4,R,X,Y)
	199	#define FP_MUL_E(R,X,Y) _FP_MUL(E,4,R,X,Y)
	200	#define FP_DIV_E(R,X,Y) _FP_DIV(E,4,R,X,Y)
	201	#define FP_SQRT_E(R,X) _FP_SQRT(E,4,R,X)
77f01ab5	202	#define FP_FMA_E(R,X,Y,Z) _FP_FMA(E,4,8,R,X,Y,Z)
d876f532 UD	203
	204	/*
	205	* Square root algorithms:
	206	* We have just one right now, maybe Newton approximation
	207	* should be added for those machines where division is fast.
	208	* This has special _E version because standard _4 square
	209	* root would not work (it has to start normally with the
	210	* second word and not the first), but as we have to do it
	211	* anyway, we optimize it by doing most of the calculations
	212	* in two UWtype registers instead of four.
	213	*/
9c84384c	214
d876f532 UD	215	#define _FP_SQRT_MEAT_E(R, S, T, X, q) \
	216	do { \
	217	q = (_FP_W_TYPE)1 << (_FP_W_TYPE_SIZE - 1); \
	218	_FP_FRAC_SRL_4(X, (_FP_WORKBITS)); \
	219	while (q) \
	220	{ \
	221	T##_f[1] = S##_f[1] + q; \
	222	if (T##_f[1] <= X##_f[1]) \
	223	{ \
	224	S##_f[1] = T##_f[1] + q; \
	225	X##_f[1] -= T##_f[1]; \
	226	R##_f[1] += q; \
	227	} \
	228	_FP_FRAC_SLL_2(X, 1); \
	229	q >>= 1; \
	230	} \
	231	q = (_FP_W_TYPE)1 << (_FP_W_TYPE_SIZE - 1); \
	232	while (q) \
	233	{ \
	234	T##_f[0] = S##_f[0] + q; \
	235	T##_f[1] = S##_f[1]; \
	236	if (T##_f[1] < X##_f[1] \|\| \
	237	(T##_f[1] == X##_f[1] && \
	238	T##_f[0] <= X##_f[0])) \
	239	{ \
	240	S##_f[0] = T##_f[0] + q; \
	241	S##_f[1] += (T##_f[0] > S##_f[0]); \
	242	_FP_FRAC_DEC_2(X, T); \
	243	R##_f[0] += q; \
	244	} \
	245	_FP_FRAC_SLL_2(X, 1); \
	246	q >>= 1; \
	247	} \
	248	_FP_FRAC_SLL_4(R, (_FP_WORKBITS)); \
	249	if (X##_f[0] \| X##_f[1]) \
	250	{ \
	251	if (S##_f[1] < X##_f[1] \|\| \
	252	(S##_f[1] == X##_f[1] && \
	253	S##_f[0] < X##_f[0])) \
	254	R##_f[0] \|= _FP_WORK_ROUND; \
	255	R##_f[0] \|= _FP_WORK_STICKY; \
	256	} \
	257	} while (0)
	258
	259	#define FP_CMP_E(r,X,Y,un) _FP_CMP(E,4,r,X,Y,un)
	260	#define FP_CMP_EQ_E(r,X,Y) _FP_CMP_EQ(E,4,r,X,Y)
e7b8c7bc	261	#define FP_CMP_UNORD_E(r,X,Y) _FP_CMP_UNORD(E,4,r,X,Y)
d876f532 UD	262
	263	#define FP_TO_INT_E(r,X,rsz,rsg) _FP_TO_INT(E,4,r,X,rsz,rsg)
	264	#define FP_FROM_INT_E(X,r,rs,rt) _FP_FROM_INT(E,4,X,r,rs,rt)
	265
	266	#define _FP_FRAC_HIGH_E(X) (X##_f[2])
	267	#define _FP_FRAC_HIGH_RAW_E(X) (X##_f[1])
	268
77f01ab5 JM	269	#define _FP_FRAC_HIGH_DW_E(X) (X##_f[4])
77f01ab5 JM	270
d876f532 UD	271	#else /* not _FP_W_TYPE_SIZE < 64 */
	272	union _FP_UNION_E
	273	{
fe0b1e85	274	XFtype flt;
f775c276	275	struct _FP_STRUCT_LAYOUT {
d876f532	276	#if __BYTE_ORDER == __BIG_ENDIAN
06029c20 JJ	277	_FP_W_TYPE pad : (_FP_W_TYPE_SIZE - 1 - _FP_EXPBITS_E);
	278	unsigned sign : 1;
	279	unsigned exp : _FP_EXPBITS_E;
	280	_FP_W_TYPE frac : _FP_W_TYPE_SIZE;
d876f532	281	#else
06029c20 JJ	282	_FP_W_TYPE frac : _FP_W_TYPE_SIZE;
	283	unsigned exp : _FP_EXPBITS_E;
	284	unsigned sign : 1;
d876f532 UD	285	#endif
	286	} bits;
	287	};
	288
	289	#define FP_DECL_E(X) _FP_DECL(2,X)
	290
	291	#define FP_UNPACK_RAW_E(X, val) \
	292	do { \
	293	union _FP_UNION_E _flo; _flo.flt = (val); \
	294	\
	295	X##_f0 = _flo.bits.frac; \
	296	X##_f1 = 0; \
	297	X##_e = _flo.bits.exp; \
	298	X##_s = _flo.bits.sign; \
d876f532 UD	299	} while (0)
	300
	301	#define FP_UNPACK_RAW_EP(X, val) \
	302	do { \
	303	union _FP_UNION_E *_flo = \
	304	(union _FP_UNION_E *)(val); \
	305	\
	306	X##_f0 = _flo->bits.frac; \
	307	X##_f1 = 0; \
	308	X##_e = _flo->bits.exp; \
	309	X##_s = _flo->bits.sign; \
d876f532 UD	310	} while (0)
	311
	312	#define FP_PACK_RAW_E(val, X) \
	313	do { \
	314	union _FP_UNION_E _flo; \
	315	\
	316	if (X##_e) X##_f0 \|= _FP_IMPLBIT_E; \
	317	else X##_f0 &= ~(_FP_IMPLBIT_E); \
	318	_flo.bits.frac = X##_f0; \
	319	_flo.bits.exp = X##_e; \
	320	_flo.bits.sign = X##_s; \
	321	\
	322	(val) = _flo.flt; \
	323	} while (0)
	324
	325	#define FP_PACK_RAW_EP(fs, val, X) \
	326	do { \
	327	if (!FP_INHIBIT_RESULTS) \
	328	{ \
	329	union _FP_UNION_E *_flo = \
	330	(union _FP_UNION_E *)(val); \
	331	\
	332	if (X##_e) X##_f0 \|= _FP_IMPLBIT_E; \
	333	else X##_f0 &= ~(_FP_IMPLBIT_E); \
	334	_flo->bits.frac = X##_f0; \
	335	_flo->bits.exp = X##_e; \
	336	_flo->bits.sign = X##_s; \
	337	} \
	338	} while (0)
	339
	340
	341	#define FP_UNPACK_E(X,val) \
	342	do { \
	343	FP_UNPACK_RAW_E(X,val); \
	344	_FP_UNPACK_CANONICAL(E,2,X); \
	345	} while (0)
	346
	347	#define FP_UNPACK_EP(X,val) \
	348	do { \
	349	FP_UNPACK_RAW_EP(X,val); \
	350	_FP_UNPACK_CANONICAL(E,2,X); \
	351	} while (0)
	352
fe0b1e85 RM	353	#define FP_UNPACK_SEMIRAW_E(X,val) \
fe0b1e85 RM	354	do { \
37002cbc	355	FP_UNPACK_RAW_E(X,val); \
fe0b1e85 RM	356	_FP_UNPACK_SEMIRAW(E,2,X); \
	357	} while (0)
	358
	359	#define FP_UNPACK_SEMIRAW_EP(X,val) \
	360	do { \
37002cbc	361	FP_UNPACK_RAW_EP(X,val); \
fe0b1e85 RM	362	_FP_UNPACK_SEMIRAW(E,2,X); \
	363	} while (0)
	364
d876f532 UD	365	#define FP_PACK_E(val,X) \
	366	do { \
	367	_FP_PACK_CANONICAL(E,2,X); \
	368	FP_PACK_RAW_E(val,X); \
	369	} while (0)
	370
	371	#define FP_PACK_EP(val,X) \
	372	do { \
	373	_FP_PACK_CANONICAL(E,2,X); \
	374	FP_PACK_RAW_EP(val,X); \
	375	} while (0)
	376
fe0b1e85 RM	377	#define FP_PACK_SEMIRAW_E(val,X) \
	378	do { \
	379	_FP_PACK_SEMIRAW(E,2,X); \
37002cbc	380	FP_PACK_RAW_E(val,X); \
fe0b1e85 RM	381	} while (0)
	382
	383	#define FP_PACK_SEMIRAW_EP(val,X) \
	384	do { \
	385	_FP_PACK_SEMIRAW(E,2,X); \
37002cbc	386	FP_PACK_RAW_EP(val,X); \
fe0b1e85 RM	387	} while (0)
fe0b1e85 RM	388
d876f532 UD	389	#define FP_ISSIGNAN_E(X) _FP_ISSIGNAN(E,2,X)
	390	#define FP_NEG_E(R,X) _FP_NEG(E,2,R,X)
	391	#define FP_ADD_E(R,X,Y) _FP_ADD(E,2,R,X,Y)
	392	#define FP_SUB_E(R,X,Y) _FP_SUB(E,2,R,X,Y)
	393	#define FP_MUL_E(R,X,Y) _FP_MUL(E,2,R,X,Y)
	394	#define FP_DIV_E(R,X,Y) _FP_DIV(E,2,R,X,Y)
	395	#define FP_SQRT_E(R,X) _FP_SQRT(E,2,R,X)
77f01ab5	396	#define FP_FMA_E(R,X,Y,Z) _FP_FMA(E,2,4,R,X,Y,Z)
d876f532 UD	397
	398	/*
	399	* Square root algorithms:
	400	* We have just one right now, maybe Newton approximation
	401	* should be added for those machines where division is fast.
	402	* We optimize it by doing most of the calculations
	403	* in one UWtype registers instead of two, although we don't
	404	* have to.
	405	*/
	406	#define _FP_SQRT_MEAT_E(R, S, T, X, q) \
	407	do { \
	408	q = (_FP_W_TYPE)1 << (_FP_W_TYPE_SIZE - 1); \
	409	_FP_FRAC_SRL_2(X, (_FP_WORKBITS)); \
	410	while (q) \
	411	{ \
	412	T##_f0 = S##_f0 + q; \
	413	if (T##_f0 <= X##_f0) \
	414	{ \
	415	S##_f0 = T##_f0 + q; \
	416	X##_f0 -= T##_f0; \
	417	R##_f0 += q; \
	418	} \
	419	_FP_FRAC_SLL_1(X, 1); \
	420	q >>= 1; \
	421	} \
	422	_FP_FRAC_SLL_2(R, (_FP_WORKBITS)); \
	423	if (X##_f0) \
	424	{ \
	425	if (S##_f0 < X##_f0) \
	426	R##_f0 \|= _FP_WORK_ROUND; \
	427	R##_f0 \|= _FP_WORK_STICKY; \
	428	} \
	429	} while (0)
9c84384c	430
d876f532 UD	431	#define FP_CMP_E(r,X,Y,un) _FP_CMP(E,2,r,X,Y,un)
d876f532 UD	432	#define FP_CMP_EQ_E(r,X,Y) _FP_CMP_EQ(E,2,r,X,Y)
1e832e37	433	#define FP_CMP_UNORD_E(r,X,Y) _FP_CMP_UNORD(E,2,r,X,Y)
d876f532 UD	434
	435	#define FP_TO_INT_E(r,X,rsz,rsg) _FP_TO_INT(E,2,r,X,rsz,rsg)
	436	#define FP_FROM_INT_E(X,r,rs,rt) _FP_FROM_INT(E,2,X,r,rs,rt)
	437
	438	#define _FP_FRAC_HIGH_E(X) (X##_f1)
	439	#define _FP_FRAC_HIGH_RAW_E(X) (X##_f0)
	440
77f01ab5 JM	441	#define _FP_FRAC_HIGH_DW_E(X) (X##_f[2])
77f01ab5 JM	442
d876f532	443	#endif /* not _FP_W_TYPE_SIZE < 64 */