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

/* Software floating-point emulation.
   Definitions for IEEE Double Precision
   Copyright (C) 1997-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_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
dff8da6b	3	Copyright (C) 1997-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_DOUBLE_H
	30	#define SOFT_FP_DOUBLE_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_D (2 * _FP_W_TYPE_SIZE)
71b4dea7 JM	38	# define _FP_FRACTBITS_DW_D (4 * _FP_W_TYPE_SIZE)
d876f532	39	#else
71b4dea7 JM	40	# define _FP_FRACTBITS_D _FP_W_TYPE_SIZE
71b4dea7 JM	41	# define _FP_FRACTBITS_DW_D (2 * _FP_W_TYPE_SIZE)
d876f532 UD	42	#endif
	43
	44	#define _FP_FRACBITS_D 53
	45	#define _FP_FRACXBITS_D (_FP_FRACTBITS_D - _FP_FRACBITS_D)
	46	#define _FP_WFRACBITS_D (_FP_WORKBITS + _FP_FRACBITS_D)
	47	#define _FP_WFRACXBITS_D (_FP_FRACTBITS_D - _FP_WFRACBITS_D)
	48	#define _FP_EXPBITS_D 11
	49	#define _FP_EXPBIAS_D 1023
	50	#define _FP_EXPMAX_D 2047
	51
	52	#define _FP_QNANBIT_D \
51ca9e29	53	((_FP_W_TYPE) 1 << (_FP_FRACBITS_D-2) % _FP_W_TYPE_SIZE)
fe0b1e85	54	#define _FP_QNANBIT_SH_D \
51ca9e29	55	((_FP_W_TYPE) 1 << (_FP_FRACBITS_D-2+_FP_WORKBITS) % _FP_W_TYPE_SIZE)
d876f532	56	#define _FP_IMPLBIT_D \
51ca9e29	57	((_FP_W_TYPE) 1 << (_FP_FRACBITS_D-1) % _FP_W_TYPE_SIZE)
fe0b1e85	58	#define _FP_IMPLBIT_SH_D \
51ca9e29	59	((_FP_W_TYPE) 1 << (_FP_FRACBITS_D-1+_FP_WORKBITS) % _FP_W_TYPE_SIZE)
d876f532	60	#define _FP_OVERFLOW_D \
51ca9e29	61	((_FP_W_TYPE) 1 << _FP_WFRACBITS_D % _FP_W_TYPE_SIZE)
d876f532	62
77f01ab5 JM	63	#define _FP_WFRACBITS_DW_D (2 * _FP_WFRACBITS_D)
	64	#define _FP_WFRACXBITS_DW_D (_FP_FRACTBITS_DW_D - _FP_WFRACBITS_DW_D)
	65	#define _FP_HIGHBIT_DW_D \
51ca9e29	66	((_FP_W_TYPE) 1 << (_FP_WFRACBITS_DW_D - 1) % _FP_W_TYPE_SIZE)
77f01ab5	67
51ca9e29	68	typedef float DFtype __attribute__ ((mode (DF)));
fe0b1e85	69
d876f532 UD	70	#if _FP_W_TYPE_SIZE < 64
	71
	72	union _FP_UNION_D
	73	{
fe0b1e85	74	DFtype flt;
1e145589 JM	75	struct _FP_STRUCT_LAYOUT
1e145589 JM	76	{
71b4dea7	77	# if __BYTE_ORDER == __BIG_ENDIAN
d876f532 UD	78	unsigned sign : 1;
	79	unsigned exp : _FP_EXPBITS_D;
	80	unsigned frac1 : _FP_FRACBITS_D - (_FP_IMPLBIT_D != 0) - _FP_W_TYPE_SIZE;
	81	unsigned frac0 : _FP_W_TYPE_SIZE;
71b4dea7	82	# else
d876f532 UD	83	unsigned frac0 : _FP_W_TYPE_SIZE;
	84	unsigned frac1 : _FP_FRACBITS_D - (_FP_IMPLBIT_D != 0) - _FP_W_TYPE_SIZE;
	85	unsigned exp : _FP_EXPBITS_D;
	86	unsigned sign : 1;
71b4dea7	87	# endif
049375e2	88	} bits;
d876f532 UD	89	};
d876f532 UD	90
51ca9e29	91	# define FP_DECL_D(X) _FP_DECL (2, X)
5c0508a3 JM	92	# define FP_UNPACK_RAW_D(X, val) _FP_UNPACK_RAW_2 (D, X, (val))
	93	# define FP_UNPACK_RAW_DP(X, val) _FP_UNPACK_RAW_2_P (D, X, (val))
	94	# define FP_PACK_RAW_D(val, X) _FP_PACK_RAW_2 (D, (val), X)
51ca9e29	95	# define FP_PACK_RAW_DP(val, X) \
1e145589 JM	96	do \
	97	{ \
	98	if (!FP_INHIBIT_RESULTS) \
5c0508a3	99	_FP_PACK_RAW_2_P (D, (val), X); \
1e145589 JM	100	} \
	101	while (0)
	102
51ca9e29	103	# define FP_UNPACK_D(X, val) \
1e145589 JM	104	do \
1e145589 JM	105	{ \
5c0508a3	106	_FP_UNPACK_RAW_2 (D, X, (val)); \
51ca9e29	107	_FP_UNPACK_CANONICAL (D, 2, X); \
1e145589 JM	108	} \
	109	while (0)
	110
51ca9e29	111	# define FP_UNPACK_DP(X, val) \
1e145589 JM	112	do \
1e145589 JM	113	{ \
5c0508a3	114	_FP_UNPACK_RAW_2_P (D, X, (val)); \
51ca9e29	115	_FP_UNPACK_CANONICAL (D, 2, X); \
1e145589 JM	116	} \
	117	while (0)
	118
51ca9e29	119	# define FP_UNPACK_SEMIRAW_D(X, val) \
1e145589 JM	120	do \
1e145589 JM	121	{ \
5c0508a3	122	_FP_UNPACK_RAW_2 (D, X, (val)); \
51ca9e29	123	_FP_UNPACK_SEMIRAW (D, 2, X); \
1e145589 JM	124	} \
	125	while (0)
	126
51ca9e29	127	# define FP_UNPACK_SEMIRAW_DP(X, val) \
1e145589 JM	128	do \
1e145589 JM	129	{ \
5c0508a3	130	_FP_UNPACK_RAW_2_P (D, X, (val)); \
51ca9e29	131	_FP_UNPACK_SEMIRAW (D, 2, X); \
1e145589 JM	132	} \
	133	while (0)
	134
51ca9e29	135	# define FP_PACK_D(val, X) \
1e145589 JM	136	do \
1e145589 JM	137	{ \
51ca9e29	138	_FP_PACK_CANONICAL (D, 2, X); \
5c0508a3	139	_FP_PACK_RAW_2 (D, (val), X); \
1e145589 JM	140	} \
	141	while (0)
	142
51ca9e29	143	# define FP_PACK_DP(val, X) \
1e145589 JM	144	do \
1e145589 JM	145	{ \
51ca9e29	146	_FP_PACK_CANONICAL (D, 2, X); \
1e145589	147	if (!FP_INHIBIT_RESULTS) \
5c0508a3	148	_FP_PACK_RAW_2_P (D, (val), X); \
1e145589 JM	149	} \
	150	while (0)
	151
51ca9e29	152	# define FP_PACK_SEMIRAW_D(val, X) \
1e145589 JM	153	do \
1e145589 JM	154	{ \
51ca9e29	155	_FP_PACK_SEMIRAW (D, 2, X); \
5c0508a3	156	_FP_PACK_RAW_2 (D, (val), X); \
1e145589 JM	157	} \
	158	while (0)
	159
51ca9e29	160	# define FP_PACK_SEMIRAW_DP(val, X) \
1e145589 JM	161	do \
1e145589 JM	162	{ \
51ca9e29	163	_FP_PACK_SEMIRAW (D, 2, X); \
1e145589	164	if (!FP_INHIBIT_RESULTS) \
5c0508a3	165	_FP_PACK_RAW_2_P (D, (val), X); \
1e145589 JM	166	} \
1e145589 JM	167	while (0)
fe0b1e85	168
51ca9e29 JM	169	# define FP_ISSIGNAN_D(X) _FP_ISSIGNAN (D, 2, X)
	170	# define FP_NEG_D(R, X) _FP_NEG (D, 2, R, X)
	171	# define FP_ADD_D(R, X, Y) _FP_ADD (D, 2, R, X, Y)
	172	# define FP_SUB_D(R, X, Y) _FP_SUB (D, 2, R, X, Y)
	173	# define FP_MUL_D(R, X, Y) _FP_MUL (D, 2, R, X, Y)
	174	# define FP_DIV_D(R, X, Y) _FP_DIV (D, 2, R, X, Y)
	175	# define FP_SQRT_D(R, X) _FP_SQRT (D, 2, R, X)
5c0508a3	176	# define _FP_SQRT_MEAT_D(R, S, T, X, Q) _FP_SQRT_MEAT_2 (R, S, T, X, (Q))
51ca9e29	177	# define FP_FMA_D(R, X, Y, Z) _FP_FMA (D, 2, 4, R, X, Y, Z)
d876f532	178
5c0508a3 JM	179	# define FP_CMP_D(r, X, Y, un, ex) _FP_CMP (D, 2, (r), X, Y, (un), (ex))
	180	# define FP_CMP_EQ_D(r, X, Y, ex) _FP_CMP_EQ (D, 2, (r), X, Y, (ex))
	181	# define FP_CMP_UNORD_D(r, X, Y, ex) _FP_CMP_UNORD (D, 2, (r), X, Y, (ex))
d876f532	182
5c0508a3	183	# define FP_TO_INT_D(r, X, rsz, rsg) _FP_TO_INT (D, 2, (r), X, (rsz), (rsg))
2004e7fb JM	184	# define FP_TO_INT_ROUND_D(r, X, rsz, rsg) \
2004e7fb JM	185	_FP_TO_INT_ROUND (D, 2, (r), X, (rsz), (rsg))
5c0508a3	186	# define FP_FROM_INT_D(X, r, rs, rt) _FP_FROM_INT (D, 2, X, (r), (rs), rt)
d876f532	187
51ca9e29 JM	188	# define _FP_FRAC_HIGH_D(X) _FP_FRAC_HIGH_2 (X)
51ca9e29 JM	189	# define _FP_FRAC_HIGH_RAW_D(X) _FP_FRAC_HIGH_2 (X)
d876f532	190
51ca9e29	191	# define _FP_FRAC_HIGH_DW_D(X) _FP_FRAC_HIGH_4 (X)
77f01ab5	192
d876f532 UD	193	#else
	194
	195	union _FP_UNION_D
	196	{
fe0b1e85	197	DFtype flt;
1e145589 JM	198	struct _FP_STRUCT_LAYOUT
1e145589 JM	199	{
71b4dea7	200	# if __BYTE_ORDER == __BIG_ENDIAN
06029c20 JJ	201	unsigned sign : 1;
	202	unsigned exp : _FP_EXPBITS_D;
	203	_FP_W_TYPE frac : _FP_FRACBITS_D - (_FP_IMPLBIT_D != 0);
71b4dea7	204	# else
06029c20 JJ	205	_FP_W_TYPE frac : _FP_FRACBITS_D - (_FP_IMPLBIT_D != 0);
	206	unsigned exp : _FP_EXPBITS_D;
	207	unsigned sign : 1;
71b4dea7	208	# endif
049375e2	209	} bits;
d876f532 UD	210	};
d876f532 UD	211
51ca9e29	212	# define FP_DECL_D(X) _FP_DECL (1, X)
5c0508a3 JM	213	# define FP_UNPACK_RAW_D(X, val) _FP_UNPACK_RAW_1 (D, X, (val))
	214	# define FP_UNPACK_RAW_DP(X, val) _FP_UNPACK_RAW_1_P (D, X, (val))
	215	# define FP_PACK_RAW_D(val, X) _FP_PACK_RAW_1 (D, (val), X)
51ca9e29	216	# define FP_PACK_RAW_DP(val, X) \
1e145589 JM	217	do \
	218	{ \
	219	if (!FP_INHIBIT_RESULTS) \
5c0508a3	220	_FP_PACK_RAW_1_P (D, (val), X); \
1e145589 JM	221	} \
	222	while (0)
	223
51ca9e29	224	# define FP_UNPACK_D(X, val) \
1e145589 JM	225	do \
1e145589 JM	226	{ \
5c0508a3	227	_FP_UNPACK_RAW_1 (D, X, (val)); \
51ca9e29	228	_FP_UNPACK_CANONICAL (D, 1, X); \
1e145589 JM	229	} \
	230	while (0)
	231
51ca9e29	232	# define FP_UNPACK_DP(X, val) \
1e145589 JM	233	do \
1e145589 JM	234	{ \
5c0508a3	235	_FP_UNPACK_RAW_1_P (D, X, (val)); \
51ca9e29	236	_FP_UNPACK_CANONICAL (D, 1, X); \
1e145589 JM	237	} \
	238	while (0)
	239
51ca9e29	240	# define FP_UNPACK_SEMIRAW_D(X, val) \
1e145589 JM	241	do \
1e145589 JM	242	{ \
5c0508a3	243	_FP_UNPACK_RAW_1 (D, X, (val)); \
51ca9e29	244	_FP_UNPACK_SEMIRAW (D, 1, X); \
1e145589 JM	245	} \
	246	while (0)
	247
51ca9e29	248	# define FP_UNPACK_SEMIRAW_DP(X, val) \
1e145589 JM	249	do \
1e145589 JM	250	{ \
5c0508a3	251	_FP_UNPACK_RAW_1_P (D, X, (val)); \
51ca9e29	252	_FP_UNPACK_SEMIRAW (D, 1, X); \
1e145589 JM	253	} \
	254	while (0)
	255
51ca9e29	256	# define FP_PACK_D(val, X) \
1e145589 JM	257	do \
1e145589 JM	258	{ \
51ca9e29	259	_FP_PACK_CANONICAL (D, 1, X); \
5c0508a3	260	_FP_PACK_RAW_1 (D, (val), X); \
1e145589 JM	261	} \
	262	while (0)
	263
51ca9e29	264	# define FP_PACK_DP(val, X) \
1e145589 JM	265	do \
1e145589 JM	266	{ \
51ca9e29	267	_FP_PACK_CANONICAL (D, 1, X); \
1e145589	268	if (!FP_INHIBIT_RESULTS) \
5c0508a3	269	_FP_PACK_RAW_1_P (D, (val), X); \
1e145589 JM	270	} \
	271	while (0)
	272
51ca9e29	273	# define FP_PACK_SEMIRAW_D(val, X) \
1e145589 JM	274	do \
1e145589 JM	275	{ \
51ca9e29	276	_FP_PACK_SEMIRAW (D, 1, X); \
5c0508a3	277	_FP_PACK_RAW_1 (D, (val), X); \
1e145589 JM	278	} \
	279	while (0)
	280
51ca9e29	281	# define FP_PACK_SEMIRAW_DP(val, X) \
1e145589 JM	282	do \
1e145589 JM	283	{ \
51ca9e29	284	_FP_PACK_SEMIRAW (D, 1, X); \
1e145589	285	if (!FP_INHIBIT_RESULTS) \
5c0508a3	286	_FP_PACK_RAW_1_P (D, (val), X); \
1e145589 JM	287	} \
1e145589 JM	288	while (0)
fe0b1e85	289
51ca9e29 JM	290	# define FP_ISSIGNAN_D(X) _FP_ISSIGNAN (D, 1, X)
	291	# define FP_NEG_D(R, X) _FP_NEG (D, 1, R, X)
	292	# define FP_ADD_D(R, X, Y) _FP_ADD (D, 1, R, X, Y)
	293	# define FP_SUB_D(R, X, Y) _FP_SUB (D, 1, R, X, Y)
	294	# define FP_MUL_D(R, X, Y) _FP_MUL (D, 1, R, X, Y)
	295	# define FP_DIV_D(R, X, Y) _FP_DIV (D, 1, R, X, Y)
	296	# define FP_SQRT_D(R, X) _FP_SQRT (D, 1, R, X)
5c0508a3	297	# define _FP_SQRT_MEAT_D(R, S, T, X, Q) _FP_SQRT_MEAT_1 (R, S, T, X, (Q))
51ca9e29	298	# define FP_FMA_D(R, X, Y, Z) _FP_FMA (D, 1, 2, R, X, Y, Z)
d876f532 UD	299
	300	/* The implementation of _FP_MUL_D and _FP_DIV_D should be chosen by
	301	the target machine. */
	302
5c0508a3 JM	303	# define FP_CMP_D(r, X, Y, un, ex) _FP_CMP (D, 1, (r), X, Y, (un), (ex))
	304	# define FP_CMP_EQ_D(r, X, Y, ex) _FP_CMP_EQ (D, 1, (r), X, Y, (ex))
	305	# define FP_CMP_UNORD_D(r, X, Y, ex) _FP_CMP_UNORD (D, 1, (r), X, Y, (ex))
d876f532	306
5c0508a3	307	# define FP_TO_INT_D(r, X, rsz, rsg) _FP_TO_INT (D, 1, (r), X, (rsz), (rsg))
2004e7fb JM	308	# define FP_TO_INT_ROUND_D(r, X, rsz, rsg) \
2004e7fb JM	309	_FP_TO_INT_ROUND (D, 1, (r), X, (rsz), (rsg))
5c0508a3	310	# define FP_FROM_INT_D(X, r, rs, rt) _FP_FROM_INT (D, 1, X, (r), (rs), rt)
d876f532	311
51ca9e29 JM	312	# define _FP_FRAC_HIGH_D(X) _FP_FRAC_HIGH_1 (X)
51ca9e29 JM	313	# define _FP_FRAC_HIGH_RAW_D(X) _FP_FRAC_HIGH_1 (X)
d876f532	314
51ca9e29	315	# define _FP_FRAC_HIGH_DW_D(X) _FP_FRAC_HIGH_2 (X)
77f01ab5	316
d876f532	317	#endif /* W_TYPE_SIZE < 64 */
a2f8be9c JM	318
a2f8be9c JM	319	#endif /* !SOFT_FP_DOUBLE_H */