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

/* Software floating-point emulation.
   Definitions for IEEE Double Precision
   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_DOUBLE_H
#define SOFT_FP_DOUBLE_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_D	(2 * _FP_W_TYPE_SIZE)
# define _FP_FRACTBITS_DW_D	(4 * _FP_W_TYPE_SIZE)
#else
# define _FP_FRACTBITS_D	_FP_W_TYPE_SIZE
# define _FP_FRACTBITS_DW_D	(2 * _FP_W_TYPE_SIZE)
#endif

#define _FP_FRACBITS_D		53
#define _FP_FRACXBITS_D		(_FP_FRACTBITS_D - _FP_FRACBITS_D)
#define _FP_WFRACBITS_D		(_FP_WORKBITS + _FP_FRACBITS_D)
#define _FP_WFRACXBITS_D	(_FP_FRACTBITS_D - _FP_WFRACBITS_D)
#define _FP_EXPBITS_D		11
#define _FP_EXPBIAS_D		1023
#define _FP_EXPMAX_D		2047

#define _FP_QNANBIT_D		\
	((_FP_W_TYPE) 1 << (_FP_FRACBITS_D-2) % _FP_W_TYPE_SIZE)
#define _FP_QNANBIT_SH_D		\
	((_FP_W_TYPE) 1 << (_FP_FRACBITS_D-2+_FP_WORKBITS) % _FP_W_TYPE_SIZE)
#define _FP_IMPLBIT_D		\
	((_FP_W_TYPE) 1 << (_FP_FRACBITS_D-1) % _FP_W_TYPE_SIZE)
#define _FP_IMPLBIT_SH_D		\
	((_FP_W_TYPE) 1 << (_FP_FRACBITS_D-1+_FP_WORKBITS) % _FP_W_TYPE_SIZE)
#define _FP_OVERFLOW_D		\
	((_FP_W_TYPE) 1 << _FP_WFRACBITS_D % _FP_W_TYPE_SIZE)

#define _FP_WFRACBITS_DW_D	(2 * _FP_WFRACBITS_D)
#define _FP_WFRACXBITS_DW_D	(_FP_FRACTBITS_DW_D - _FP_WFRACBITS_DW_D)
#define _FP_HIGHBIT_DW_D	\
  ((_FP_W_TYPE) 1 << (_FP_WFRACBITS_DW_D - 1) % _FP_W_TYPE_SIZE)

typedef float DFtype __attribute__ ((mode (DF)));

#if _FP_W_TYPE_SIZE < 64

union _FP_UNION_D
{
  DFtype flt;
  struct _FP_STRUCT_LAYOUT
  {
# if __BYTE_ORDER == __BIG_ENDIAN
    unsigned sign  : 1;
    unsigned exp   : _FP_EXPBITS_D;
    unsigned frac1 : _FP_FRACBITS_D - (_FP_IMPLBIT_D != 0) - _FP_W_TYPE_SIZE;
    unsigned frac0 : _FP_W_TYPE_SIZE;
# else
    unsigned frac0 : _FP_W_TYPE_SIZE;
    unsigned frac1 : _FP_FRACBITS_D - (_FP_IMPLBIT_D != 0) - _FP_W_TYPE_SIZE;
    unsigned exp   : _FP_EXPBITS_D;
    unsigned sign  : 1;
# endif
  } bits;
};

# define FP_DECL_D(X)		_FP_DECL (2, X)
# define FP_UNPACK_RAW_D(X, val)	_FP_UNPACK_RAW_2 (D, X, (val))
# define FP_UNPACK_RAW_DP(X, val)	_FP_UNPACK_RAW_2_P (D, X, (val))
# define FP_PACK_RAW_D(val, X)	_FP_PACK_RAW_2 (D, (val), X)
# define FP_PACK_RAW_DP(val, X)			\
  do						\
    {						\
      if (!FP_INHIBIT_RESULTS)			\
	_FP_PACK_RAW_2_P (D, (val), X);		\
    }						\
  while (0)

# define FP_UNPACK_D(X, val)			\
  do						\
    {						\
      _FP_UNPACK_RAW_2 (D, X, (val));		\
      _FP_UNPACK_CANONICAL (D, 2, X);		\
    }						\
  while (0)

# define FP_UNPACK_DP(X, val)			\
  do						\
    {						\
      _FP_UNPACK_RAW_2_P (D, X, (val));		\
      _FP_UNPACK_CANONICAL (D, 2, X);		\
    }						\
  while (0)

# define FP_UNPACK_SEMIRAW_D(X, val)		\
  do						\
    {						\
      _FP_UNPACK_RAW_2 (D, X, (val));		\
      _FP_UNPACK_SEMIRAW (D, 2, X);		\
    }						\
  while (0)

# define FP_UNPACK_SEMIRAW_DP(X, val)		\
  do						\
    {						\
      _FP_UNPACK_RAW_2_P (D, X, (val));		\
      _FP_UNPACK_SEMIRAW (D, 2, X);		\
    }						\
  while (0)

# define FP_PACK_D(val, X)			\
  do						\
    {						\
      _FP_PACK_CANONICAL (D, 2, X);		\
      _FP_PACK_RAW_2 (D, (val), X);		\
    }						\
  while (0)

# define FP_PACK_DP(val, X)			\
  do						\
    {						\
      _FP_PACK_CANONICAL (D, 2, X);		\
      if (!FP_INHIBIT_RESULTS)			\
	_FP_PACK_RAW_2_P (D, (val), X);		\
    }						\
  while (0)

# define FP_PACK_SEMIRAW_D(val, X)		\
  do						\
    {						\
      _FP_PACK_SEMIRAW (D, 2, X);		\
      _FP_PACK_RAW_2 (D, (val), X);		\
    }						\
  while (0)

# define FP_PACK_SEMIRAW_DP(val, X)		\
  do						\
    {						\
      _FP_PACK_SEMIRAW (D, 2, X);		\
      if (!FP_INHIBIT_RESULTS)			\
	_FP_PACK_RAW_2_P (D, (val), X);		\
    }						\
  while (0)

# define FP_ISSIGNAN_D(X)		_FP_ISSIGNAN (D, 2, X)
# define FP_NEG_D(R, X)			_FP_NEG (D, 2, R, X)
# define FP_ADD_D(R, X, Y)		_FP_ADD (D, 2, R, X, Y)
# define FP_SUB_D(R, X, Y)		_FP_SUB (D, 2, R, X, Y)
# define FP_MUL_D(R, X, Y)		_FP_MUL (D, 2, R, X, Y)
# define FP_DIV_D(R, X, Y)		_FP_DIV (D, 2, R, X, Y)
# define FP_SQRT_D(R, X)		_FP_SQRT (D, 2, R, X)
# define _FP_SQRT_MEAT_D(R, S, T, X, Q)	_FP_SQRT_MEAT_2 (R, S, T, X, (Q))
# define FP_FMA_D(R, X, Y, Z)		_FP_FMA (D, 2, 4, R, X, Y, Z)

# define FP_CMP_D(r, X, Y, un, ex)	_FP_CMP (D, 2, (r), X, Y, (un), (ex))
# define FP_CMP_EQ_D(r, X, Y, ex)	_FP_CMP_EQ (D, 2, (r), X, Y, (ex))
# define FP_CMP_UNORD_D(r, X, Y, ex)	_FP_CMP_UNORD (D, 2, (r), X, Y, (ex))

# define FP_TO_INT_D(r, X, rsz, rsg)	_FP_TO_INT (D, 2, (r), X, (rsz), (rsg))
# define FP_TO_INT_ROUND_D(r, X, rsz, rsg)	\
  _FP_TO_INT_ROUND (D, 2, (r), X, (rsz), (rsg))
# define FP_FROM_INT_D(X, r, rs, rt)	_FP_FROM_INT (D, 2, X, (r), (rs), rt)

# define _FP_FRAC_HIGH_D(X)	_FP_FRAC_HIGH_2 (X)
# define _FP_FRAC_HIGH_RAW_D(X)	_FP_FRAC_HIGH_2 (X)

# define _FP_FRAC_HIGH_DW_D(X)	_FP_FRAC_HIGH_4 (X)

#else

union _FP_UNION_D
{
  DFtype flt;
  struct _FP_STRUCT_LAYOUT
  {
# if __BYTE_ORDER == __BIG_ENDIAN
    unsigned sign   : 1;
    unsigned exp    : _FP_EXPBITS_D;
    _FP_W_TYPE frac : _FP_FRACBITS_D - (_FP_IMPLBIT_D != 0);
# else
    _FP_W_TYPE frac : _FP_FRACBITS_D - (_FP_IMPLBIT_D != 0);
    unsigned exp    : _FP_EXPBITS_D;
    unsigned sign   : 1;
# endif
  } bits;
};

# define FP_DECL_D(X)		_FP_DECL (1, X)
# define FP_UNPACK_RAW_D(X, val)	_FP_UNPACK_RAW_1 (D, X, (val))
# define FP_UNPACK_RAW_DP(X, val)	_FP_UNPACK_RAW_1_P (D, X, (val))
# define FP_PACK_RAW_D(val, X)	_FP_PACK_RAW_1 (D, (val), X)
# define FP_PACK_RAW_DP(val, X)			\
  do						\
    {						\
      if (!FP_INHIBIT_RESULTS)			\
	_FP_PACK_RAW_1_P (D, (val), X);		\
    }						\
  while (0)

# define FP_UNPACK_D(X, val)			\
  do						\
    {						\
      _FP_UNPACK_RAW_1 (D, X, (val));		\
      _FP_UNPACK_CANONICAL (D, 1, X);		\
    }						\
  while (0)

# define FP_UNPACK_DP(X, val)			\
  do						\
    {						\
      _FP_UNPACK_RAW_1_P (D, X, (val));		\
      _FP_UNPACK_CANONICAL (D, 1, X);		\
    }						\
  while (0)

# define FP_UNPACK_SEMIRAW_D(X, val)		\
  do						\
    {						\
      _FP_UNPACK_RAW_1 (D, X, (val));		\
      _FP_UNPACK_SEMIRAW (D, 1, X);		\
    }						\
  while (0)

# define FP_UNPACK_SEMIRAW_DP(X, val)		\
  do						\
    {						\
      _FP_UNPACK_RAW_1_P (D, X, (val));		\
      _FP_UNPACK_SEMIRAW (D, 1, X);		\
    }						\
  while (0)

# define FP_PACK_D(val, X)			\
  do						\
    {						\
      _FP_PACK_CANONICAL (D, 1, X);		\
      _FP_PACK_RAW_1 (D, (val), X);		\
    }						\
  while (0)

# define FP_PACK_DP(val, X)			\
  do						\
    {						\
      _FP_PACK_CANONICAL (D, 1, X);		\
      if (!FP_INHIBIT_RESULTS)			\
	_FP_PACK_RAW_1_P (D, (val), X);		\
    }						\
  while (0)

# define FP_PACK_SEMIRAW_D(val, X)		\
  do						\
    {						\
      _FP_PACK_SEMIRAW (D, 1, X);		\
      _FP_PACK_RAW_1 (D, (val), X);		\
    }						\
  while (0)

# define FP_PACK_SEMIRAW_DP(val, X)		\
  do						\
    {						\
      _FP_PACK_SEMIRAW (D, 1, X);		\
      if (!FP_INHIBIT_RESULTS)			\
	_FP_PACK_RAW_1_P (D, (val), X);		\
    }						\
  while (0)

# define FP_ISSIGNAN_D(X)		_FP_ISSIGNAN (D, 1, X)
# define FP_NEG_D(R, X)			_FP_NEG (D, 1, R, X)
# define FP_ADD_D(R, X, Y)		_FP_ADD (D, 1, R, X, Y)
# define FP_SUB_D(R, X, Y)		_FP_SUB (D, 1, R, X, Y)
# define FP_MUL_D(R, X, Y)		_FP_MUL (D, 1, R, X, Y)
# define FP_DIV_D(R, X, Y)		_FP_DIV (D, 1, R, X, Y)
# define FP_SQRT_D(R, X)		_FP_SQRT (D, 1, R, X)
# define _FP_SQRT_MEAT_D(R, S, T, X, Q)	_FP_SQRT_MEAT_1 (R, S, T, X, (Q))
# define FP_FMA_D(R, X, Y, Z)		_FP_FMA (D, 1, 2, R, X, Y, Z)

/* The implementation of _FP_MUL_D and _FP_DIV_D should be chosen by
   the target machine.  */

# define FP_CMP_D(r, X, Y, un, ex)	_FP_CMP (D, 1, (r), X, Y, (un), (ex))
# define FP_CMP_EQ_D(r, X, Y, ex)	_FP_CMP_EQ (D, 1, (r), X, Y, (ex))
# define FP_CMP_UNORD_D(r, X, Y, ex)	_FP_CMP_UNORD (D, 1, (r), X, Y, (ex))

# define FP_TO_INT_D(r, X, rsz, rsg)	_FP_TO_INT (D, 1, (r), X, (rsz), (rsg))
# define FP_TO_INT_ROUND_D(r, X, rsz, rsg)	\
  _FP_TO_INT_ROUND (D, 1, (r), X, (rsz), (rsg))
# define FP_FROM_INT_D(X, r, rs, rt)	_FP_FROM_INT (D, 1, X, (r), (rs), rt)

# define _FP_FRAC_HIGH_D(X)	_FP_FRAC_HIGH_1 (X)
# define _FP_FRAC_HIGH_RAW_D(X)	_FP_FRAC_HIGH_1 (X)

# define _FP_FRAC_HIGH_DW_D(X)	_FP_FRAC_HIGH_2 (X)

#endif /* W_TYPE_SIZE < 64 */

#endif /* !SOFT_FP_DOUBLE_H */
Commit	Line	Data
d876f532 UD	1	/* Software floating-point emulation.
d876f532 UD	2	Definitions for IEEE Double Precision
688903eb	3	Copyright (C) 1997-2018 Free Software Foundation, Inc.
d876f532 UD	4	This file is part of the GNU C Library.
	5	Contributed by Richard Henderson (rth@cygnus.com),
	6	Jakub Jelinek (jj@ultra.linux.cz),
	7	David S. Miller (davem@redhat.com) and
	8	Peter Maydell (pmaydell@chiark.greenend.org.uk).
	9
	10	The GNU C Library is free software; you can redistribute it and/or
41bdb6e2 AJ	11	modify it under the terms of the GNU Lesser General Public
	12	License as published by the Free Software Foundation; either
	13	version 2.1 of the License, or (at your option) any later version.
d876f532	14
638a783c RM	15	In addition to the permissions in the GNU Lesser General Public
	16	License, the Free Software Foundation gives you unlimited
	17	permission to link the compiled version of this file into
	18	combinations with other programs, and to distribute those
	19	combinations without any restriction coming from the use of this
	20	file. (The Lesser General Public License restrictions do apply in
	21	other respects; for example, they cover modification of the file,
	22	and distribution when not linked into a combine executable.)
	23
d876f532 UD	24	The GNU C Library is distributed in the hope that it will be useful,
	25	but WITHOUT ANY WARRANTY; without even the implied warranty of
	26	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
41bdb6e2	27	Lesser General Public License for more details.
d876f532	28
41bdb6e2	29	You should have received a copy of the GNU Lesser General Public
59ba27a6 PE	30	License along with the GNU C Library; if not, see
59ba27a6 PE	31	<http://www.gnu.org/licenses/>. */
d876f532	32
a2f8be9c JM	33	#ifndef SOFT_FP_DOUBLE_H
	34	#define SOFT_FP_DOUBLE_H 1
	35
d876f532	36	#if _FP_W_TYPE_SIZE < 32
71b4dea7	37	# error "Here's a nickel kid. Go buy yourself a real computer."
d876f532 UD	38	#endif
	39
	40	#if _FP_W_TYPE_SIZE < 64
71b4dea7 JM	41	# define _FP_FRACTBITS_D (2 * _FP_W_TYPE_SIZE)
71b4dea7 JM	42	# define _FP_FRACTBITS_DW_D (4 * _FP_W_TYPE_SIZE)
d876f532	43	#else
71b4dea7 JM	44	# define _FP_FRACTBITS_D _FP_W_TYPE_SIZE
71b4dea7 JM	45	# define _FP_FRACTBITS_DW_D (2 * _FP_W_TYPE_SIZE)
d876f532 UD	46	#endif
	47
	48	#define _FP_FRACBITS_D 53
	49	#define _FP_FRACXBITS_D (_FP_FRACTBITS_D - _FP_FRACBITS_D)
	50	#define _FP_WFRACBITS_D (_FP_WORKBITS + _FP_FRACBITS_D)
	51	#define _FP_WFRACXBITS_D (_FP_FRACTBITS_D - _FP_WFRACBITS_D)
	52	#define _FP_EXPBITS_D 11
	53	#define _FP_EXPBIAS_D 1023
	54	#define _FP_EXPMAX_D 2047
	55
	56	#define _FP_QNANBIT_D \
51ca9e29	57	((_FP_W_TYPE) 1 << (_FP_FRACBITS_D-2) % _FP_W_TYPE_SIZE)
fe0b1e85	58	#define _FP_QNANBIT_SH_D \
51ca9e29	59	((_FP_W_TYPE) 1 << (_FP_FRACBITS_D-2+_FP_WORKBITS) % _FP_W_TYPE_SIZE)
d876f532	60	#define _FP_IMPLBIT_D \
51ca9e29	61	((_FP_W_TYPE) 1 << (_FP_FRACBITS_D-1) % _FP_W_TYPE_SIZE)
fe0b1e85	62	#define _FP_IMPLBIT_SH_D \
51ca9e29	63	((_FP_W_TYPE) 1 << (_FP_FRACBITS_D-1+_FP_WORKBITS) % _FP_W_TYPE_SIZE)
d876f532	64	#define _FP_OVERFLOW_D \
51ca9e29	65	((_FP_W_TYPE) 1 << _FP_WFRACBITS_D % _FP_W_TYPE_SIZE)
d876f532	66
77f01ab5 JM	67	#define _FP_WFRACBITS_DW_D (2 * _FP_WFRACBITS_D)
	68	#define _FP_WFRACXBITS_DW_D (_FP_FRACTBITS_DW_D - _FP_WFRACBITS_DW_D)
	69	#define _FP_HIGHBIT_DW_D \
51ca9e29	70	((_FP_W_TYPE) 1 << (_FP_WFRACBITS_DW_D - 1) % _FP_W_TYPE_SIZE)
77f01ab5	71
51ca9e29	72	typedef float DFtype __attribute__ ((mode (DF)));
fe0b1e85	73
d876f532 UD	74	#if _FP_W_TYPE_SIZE < 64
	75
	76	union _FP_UNION_D
	77	{
fe0b1e85	78	DFtype flt;
1e145589 JM	79	struct _FP_STRUCT_LAYOUT
1e145589 JM	80	{
71b4dea7	81	# if __BYTE_ORDER == __BIG_ENDIAN
d876f532 UD	82	unsigned sign : 1;
	83	unsigned exp : _FP_EXPBITS_D;
	84	unsigned frac1 : _FP_FRACBITS_D - (_FP_IMPLBIT_D != 0) - _FP_W_TYPE_SIZE;
	85	unsigned frac0 : _FP_W_TYPE_SIZE;
71b4dea7	86	# else
d876f532 UD	87	unsigned frac0 : _FP_W_TYPE_SIZE;
	88	unsigned frac1 : _FP_FRACBITS_D - (_FP_IMPLBIT_D != 0) - _FP_W_TYPE_SIZE;
	89	unsigned exp : _FP_EXPBITS_D;
	90	unsigned sign : 1;
71b4dea7	91	# endif
049375e2	92	} bits;
d876f532 UD	93	};
d876f532 UD	94
51ca9e29	95	# define FP_DECL_D(X) _FP_DECL (2, X)
5c0508a3 JM	96	# define FP_UNPACK_RAW_D(X, val) _FP_UNPACK_RAW_2 (D, X, (val))
	97	# define FP_UNPACK_RAW_DP(X, val) _FP_UNPACK_RAW_2_P (D, X, (val))
	98	# define FP_PACK_RAW_D(val, X) _FP_PACK_RAW_2 (D, (val), X)
51ca9e29	99	# define FP_PACK_RAW_DP(val, X) \
1e145589 JM	100	do \
	101	{ \
	102	if (!FP_INHIBIT_RESULTS) \
5c0508a3	103	_FP_PACK_RAW_2_P (D, (val), X); \
1e145589 JM	104	} \
	105	while (0)
	106
51ca9e29	107	# define FP_UNPACK_D(X, val) \
1e145589 JM	108	do \
1e145589 JM	109	{ \
5c0508a3	110	_FP_UNPACK_RAW_2 (D, X, (val)); \
51ca9e29	111	_FP_UNPACK_CANONICAL (D, 2, X); \
1e145589 JM	112	} \
	113	while (0)
	114
51ca9e29	115	# define FP_UNPACK_DP(X, val) \
1e145589 JM	116	do \
1e145589 JM	117	{ \
5c0508a3	118	_FP_UNPACK_RAW_2_P (D, X, (val)); \
51ca9e29	119	_FP_UNPACK_CANONICAL (D, 2, X); \
1e145589 JM	120	} \
	121	while (0)
	122
51ca9e29	123	# define FP_UNPACK_SEMIRAW_D(X, val) \
1e145589 JM	124	do \
1e145589 JM	125	{ \
5c0508a3	126	_FP_UNPACK_RAW_2 (D, X, (val)); \
51ca9e29	127	_FP_UNPACK_SEMIRAW (D, 2, X); \
1e145589 JM	128	} \
	129	while (0)
	130
51ca9e29	131	# define FP_UNPACK_SEMIRAW_DP(X, val) \
1e145589 JM	132	do \
1e145589 JM	133	{ \
5c0508a3	134	_FP_UNPACK_RAW_2_P (D, X, (val)); \
51ca9e29	135	_FP_UNPACK_SEMIRAW (D, 2, X); \
1e145589 JM	136	} \
	137	while (0)
	138
51ca9e29	139	# define FP_PACK_D(val, X) \
1e145589 JM	140	do \
1e145589 JM	141	{ \
51ca9e29	142	_FP_PACK_CANONICAL (D, 2, X); \
5c0508a3	143	_FP_PACK_RAW_2 (D, (val), X); \
1e145589 JM	144	} \
	145	while (0)
	146
51ca9e29	147	# define FP_PACK_DP(val, X) \
1e145589 JM	148	do \
1e145589 JM	149	{ \
51ca9e29	150	_FP_PACK_CANONICAL (D, 2, X); \
1e145589	151	if (!FP_INHIBIT_RESULTS) \
5c0508a3	152	_FP_PACK_RAW_2_P (D, (val), X); \
1e145589 JM	153	} \
	154	while (0)
	155
51ca9e29	156	# define FP_PACK_SEMIRAW_D(val, X) \
1e145589 JM	157	do \
1e145589 JM	158	{ \
51ca9e29	159	_FP_PACK_SEMIRAW (D, 2, X); \
5c0508a3	160	_FP_PACK_RAW_2 (D, (val), X); \
1e145589 JM	161	} \
	162	while (0)
	163
51ca9e29	164	# define FP_PACK_SEMIRAW_DP(val, X) \
1e145589 JM	165	do \
1e145589 JM	166	{ \
51ca9e29	167	_FP_PACK_SEMIRAW (D, 2, X); \
1e145589	168	if (!FP_INHIBIT_RESULTS) \
5c0508a3	169	_FP_PACK_RAW_2_P (D, (val), X); \
1e145589 JM	170	} \
1e145589 JM	171	while (0)
fe0b1e85	172
51ca9e29 JM	173	# define FP_ISSIGNAN_D(X) _FP_ISSIGNAN (D, 2, X)
	174	# define FP_NEG_D(R, X) _FP_NEG (D, 2, R, X)
	175	# define FP_ADD_D(R, X, Y) _FP_ADD (D, 2, R, X, Y)
	176	# define FP_SUB_D(R, X, Y) _FP_SUB (D, 2, R, X, Y)
	177	# define FP_MUL_D(R, X, Y) _FP_MUL (D, 2, R, X, Y)
	178	# define FP_DIV_D(R, X, Y) _FP_DIV (D, 2, R, X, Y)
	179	# define FP_SQRT_D(R, X) _FP_SQRT (D, 2, R, X)
5c0508a3	180	# define _FP_SQRT_MEAT_D(R, S, T, X, Q) _FP_SQRT_MEAT_2 (R, S, T, X, (Q))
51ca9e29	181	# define FP_FMA_D(R, X, Y, Z) _FP_FMA (D, 2, 4, R, X, Y, Z)
d876f532	182
5c0508a3 JM	183	# define FP_CMP_D(r, X, Y, un, ex) _FP_CMP (D, 2, (r), X, Y, (un), (ex))
	184	# define FP_CMP_EQ_D(r, X, Y, ex) _FP_CMP_EQ (D, 2, (r), X, Y, (ex))
	185	# define FP_CMP_UNORD_D(r, X, Y, ex) _FP_CMP_UNORD (D, 2, (r), X, Y, (ex))
d876f532	186
5c0508a3	187	# define FP_TO_INT_D(r, X, rsz, rsg) _FP_TO_INT (D, 2, (r), X, (rsz), (rsg))
2004e7fb JM	188	# define FP_TO_INT_ROUND_D(r, X, rsz, rsg) \
2004e7fb JM	189	_FP_TO_INT_ROUND (D, 2, (r), X, (rsz), (rsg))
5c0508a3	190	# define FP_FROM_INT_D(X, r, rs, rt) _FP_FROM_INT (D, 2, X, (r), (rs), rt)
d876f532	191
51ca9e29 JM	192	# define _FP_FRAC_HIGH_D(X) _FP_FRAC_HIGH_2 (X)
51ca9e29 JM	193	# define _FP_FRAC_HIGH_RAW_D(X) _FP_FRAC_HIGH_2 (X)
d876f532	194
51ca9e29	195	# define _FP_FRAC_HIGH_DW_D(X) _FP_FRAC_HIGH_4 (X)
77f01ab5	196
d876f532 UD	197	#else
	198
	199	union _FP_UNION_D
	200	{
fe0b1e85	201	DFtype flt;
1e145589 JM	202	struct _FP_STRUCT_LAYOUT
1e145589 JM	203	{
71b4dea7	204	# if __BYTE_ORDER == __BIG_ENDIAN
06029c20 JJ	205	unsigned sign : 1;
	206	unsigned exp : _FP_EXPBITS_D;
	207	_FP_W_TYPE frac : _FP_FRACBITS_D - (_FP_IMPLBIT_D != 0);
71b4dea7	208	# else
06029c20 JJ	209	_FP_W_TYPE frac : _FP_FRACBITS_D - (_FP_IMPLBIT_D != 0);
	210	unsigned exp : _FP_EXPBITS_D;
	211	unsigned sign : 1;
71b4dea7	212	# endif
049375e2	213	} bits;
d876f532 UD	214	};
d876f532 UD	215
51ca9e29	216	# define FP_DECL_D(X) _FP_DECL (1, X)
5c0508a3 JM	217	# define FP_UNPACK_RAW_D(X, val) _FP_UNPACK_RAW_1 (D, X, (val))
	218	# define FP_UNPACK_RAW_DP(X, val) _FP_UNPACK_RAW_1_P (D, X, (val))
	219	# define FP_PACK_RAW_D(val, X) _FP_PACK_RAW_1 (D, (val), X)
51ca9e29	220	# define FP_PACK_RAW_DP(val, X) \
1e145589 JM	221	do \
	222	{ \
	223	if (!FP_INHIBIT_RESULTS) \
5c0508a3	224	_FP_PACK_RAW_1_P (D, (val), X); \
1e145589 JM	225	} \
	226	while (0)
	227
51ca9e29	228	# define FP_UNPACK_D(X, val) \
1e145589 JM	229	do \
1e145589 JM	230	{ \
5c0508a3	231	_FP_UNPACK_RAW_1 (D, X, (val)); \
51ca9e29	232	_FP_UNPACK_CANONICAL (D, 1, X); \
1e145589 JM	233	} \
	234	while (0)
	235
51ca9e29	236	# define FP_UNPACK_DP(X, val) \
1e145589 JM	237	do \
1e145589 JM	238	{ \
5c0508a3	239	_FP_UNPACK_RAW_1_P (D, X, (val)); \
51ca9e29	240	_FP_UNPACK_CANONICAL (D, 1, X); \
1e145589 JM	241	} \
	242	while (0)
	243
51ca9e29	244	# define FP_UNPACK_SEMIRAW_D(X, val) \
1e145589 JM	245	do \
1e145589 JM	246	{ \
5c0508a3	247	_FP_UNPACK_RAW_1 (D, X, (val)); \
51ca9e29	248	_FP_UNPACK_SEMIRAW (D, 1, X); \
1e145589 JM	249	} \
	250	while (0)
	251
51ca9e29	252	# define FP_UNPACK_SEMIRAW_DP(X, val) \
1e145589 JM	253	do \
1e145589 JM	254	{ \
5c0508a3	255	_FP_UNPACK_RAW_1_P (D, X, (val)); \
51ca9e29	256	_FP_UNPACK_SEMIRAW (D, 1, X); \
1e145589 JM	257	} \
	258	while (0)
	259
51ca9e29	260	# define FP_PACK_D(val, X) \
1e145589 JM	261	do \
1e145589 JM	262	{ \
51ca9e29	263	_FP_PACK_CANONICAL (D, 1, X); \
5c0508a3	264	_FP_PACK_RAW_1 (D, (val), X); \
1e145589 JM	265	} \
	266	while (0)
	267
51ca9e29	268	# define FP_PACK_DP(val, X) \
1e145589 JM	269	do \
1e145589 JM	270	{ \
51ca9e29	271	_FP_PACK_CANONICAL (D, 1, X); \
1e145589	272	if (!FP_INHIBIT_RESULTS) \
5c0508a3	273	_FP_PACK_RAW_1_P (D, (val), X); \
1e145589 JM	274	} \
	275	while (0)
	276
51ca9e29	277	# define FP_PACK_SEMIRAW_D(val, X) \
1e145589 JM	278	do \
1e145589 JM	279	{ \
51ca9e29	280	_FP_PACK_SEMIRAW (D, 1, X); \
5c0508a3	281	_FP_PACK_RAW_1 (D, (val), X); \
1e145589 JM	282	} \
	283	while (0)
	284
51ca9e29	285	# define FP_PACK_SEMIRAW_DP(val, X) \
1e145589 JM	286	do \
1e145589 JM	287	{ \
51ca9e29	288	_FP_PACK_SEMIRAW (D, 1, X); \
1e145589	289	if (!FP_INHIBIT_RESULTS) \
5c0508a3	290	_FP_PACK_RAW_1_P (D, (val), X); \
1e145589 JM	291	} \
1e145589 JM	292	while (0)
fe0b1e85	293
51ca9e29 JM	294	# define FP_ISSIGNAN_D(X) _FP_ISSIGNAN (D, 1, X)
	295	# define FP_NEG_D(R, X) _FP_NEG (D, 1, R, X)
	296	# define FP_ADD_D(R, X, Y) _FP_ADD (D, 1, R, X, Y)
	297	# define FP_SUB_D(R, X, Y) _FP_SUB (D, 1, R, X, Y)
	298	# define FP_MUL_D(R, X, Y) _FP_MUL (D, 1, R, X, Y)
	299	# define FP_DIV_D(R, X, Y) _FP_DIV (D, 1, R, X, Y)
	300	# define FP_SQRT_D(R, X) _FP_SQRT (D, 1, R, X)
5c0508a3	301	# define _FP_SQRT_MEAT_D(R, S, T, X, Q) _FP_SQRT_MEAT_1 (R, S, T, X, (Q))
51ca9e29	302	# define FP_FMA_D(R, X, Y, Z) _FP_FMA (D, 1, 2, R, X, Y, Z)
d876f532 UD	303
	304	/* The implementation of _FP_MUL_D and _FP_DIV_D should be chosen by
	305	the target machine. */
	306
5c0508a3 JM	307	# define FP_CMP_D(r, X, Y, un, ex) _FP_CMP (D, 1, (r), X, Y, (un), (ex))
	308	# define FP_CMP_EQ_D(r, X, Y, ex) _FP_CMP_EQ (D, 1, (r), X, Y, (ex))
	309	# define FP_CMP_UNORD_D(r, X, Y, ex) _FP_CMP_UNORD (D, 1, (r), X, Y, (ex))
d876f532	310
5c0508a3	311	# define FP_TO_INT_D(r, X, rsz, rsg) _FP_TO_INT (D, 1, (r), X, (rsz), (rsg))
2004e7fb JM	312	# define FP_TO_INT_ROUND_D(r, X, rsz, rsg) \
2004e7fb JM	313	_FP_TO_INT_ROUND (D, 1, (r), X, (rsz), (rsg))
5c0508a3	314	# define FP_FROM_INT_D(X, r, rs, rt) _FP_FROM_INT (D, 1, X, (r), (rs), rt)
d876f532	315
51ca9e29 JM	316	# define _FP_FRAC_HIGH_D(X) _FP_FRAC_HIGH_1 (X)
51ca9e29 JM	317	# define _FP_FRAC_HIGH_RAW_D(X) _FP_FRAC_HIGH_1 (X)
d876f532	318
51ca9e29	319	# define _FP_FRAC_HIGH_DW_D(X) _FP_FRAC_HIGH_2 (X)
77f01ab5	320
d876f532	321	#endif /* W_TYPE_SIZE < 64 */
a2f8be9c JM	322
a2f8be9c JM	323	#endif /* !SOFT_FP_DOUBLE_H */