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

/* Software floating-point emulation.
   Definitions for IEEE Single Precision.
   Copyright (C) 1997-2019 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
   <https://www.gnu.org/licenses/>.  */

#ifndef SOFT_FP_SINGLE_H
#define SOFT_FP_SINGLE_H	1

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

#define _FP_FRACTBITS_S		_FP_W_TYPE_SIZE

#if _FP_W_TYPE_SIZE < 64
# define _FP_FRACTBITS_DW_S	(2 * _FP_W_TYPE_SIZE)
#else
# define _FP_FRACTBITS_DW_S	_FP_W_TYPE_SIZE
#endif

#define _FP_FRACBITS_S		24
#define _FP_FRACXBITS_S		(_FP_FRACTBITS_S - _FP_FRACBITS_S)
#define _FP_WFRACBITS_S		(_FP_WORKBITS + _FP_FRACBITS_S)
#define _FP_WFRACXBITS_S	(_FP_FRACTBITS_S - _FP_WFRACBITS_S)
#define _FP_EXPBITS_S		8
#define _FP_EXPBIAS_S		127
#define _FP_EXPMAX_S		255
#define _FP_QNANBIT_S		((_FP_W_TYPE) 1 << (_FP_FRACBITS_S-2))
#define _FP_QNANBIT_SH_S	((_FP_W_TYPE) 1 << (_FP_FRACBITS_S-2+_FP_WORKBITS))
#define _FP_IMPLBIT_S		((_FP_W_TYPE) 1 << (_FP_FRACBITS_S-1))
#define _FP_IMPLBIT_SH_S	((_FP_W_TYPE) 1 << (_FP_FRACBITS_S-1+_FP_WORKBITS))
#define _FP_OVERFLOW_S		((_FP_W_TYPE) 1 << (_FP_WFRACBITS_S))

#define _FP_WFRACBITS_DW_S	(2 * _FP_WFRACBITS_S)
#define _FP_WFRACXBITS_DW_S	(_FP_FRACTBITS_DW_S - _FP_WFRACBITS_DW_S)
#define _FP_HIGHBIT_DW_S	\
  ((_FP_W_TYPE) 1 << (_FP_WFRACBITS_DW_S - 1) % _FP_W_TYPE_SIZE)

/* The implementation of _FP_MUL_MEAT_S and _FP_DIV_MEAT_S should be
   chosen by the target machine.  */

typedef float SFtype __attribute__ ((mode (SF)));

union _FP_UNION_S
{
  SFtype flt;
  struct _FP_STRUCT_LAYOUT
  {
#if __BYTE_ORDER == __BIG_ENDIAN
    unsigned sign : 1;
    unsigned exp  : _FP_EXPBITS_S;
    unsigned frac : _FP_FRACBITS_S - (_FP_IMPLBIT_S != 0);
#else
    unsigned frac : _FP_FRACBITS_S - (_FP_IMPLBIT_S != 0);
    unsigned exp  : _FP_EXPBITS_S;
    unsigned sign : 1;
#endif
  } bits;
};

#define FP_DECL_S(X)		_FP_DECL (1, X)
#define FP_UNPACK_RAW_S(X, val)	_FP_UNPACK_RAW_1 (S, X, (val))
#define FP_UNPACK_RAW_SP(X, val)	_FP_UNPACK_RAW_1_P (S, X, (val))
#define FP_PACK_RAW_S(val, X)	_FP_PACK_RAW_1 (S, (val), X)
#define FP_PACK_RAW_SP(val, X)			\
  do						\
    {						\
      if (!FP_INHIBIT_RESULTS)			\
	_FP_PACK_RAW_1_P (S, (val), X);		\
    }						\
  while (0)

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

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

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

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

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

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

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

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

#define FP_ISSIGNAN_S(X)		_FP_ISSIGNAN (S, 1, X)
#define FP_NEG_S(R, X)			_FP_NEG (S, 1, R, X)
#define FP_ADD_S(R, X, Y)		_FP_ADD (S, 1, R, X, Y)
#define FP_SUB_S(R, X, Y)		_FP_SUB (S, 1, R, X, Y)
#define FP_MUL_S(R, X, Y)		_FP_MUL (S, 1, R, X, Y)
#define FP_DIV_S(R, X, Y)		_FP_DIV (S, 1, R, X, Y)
#define FP_SQRT_S(R, X)			_FP_SQRT (S, 1, R, X)
#define _FP_SQRT_MEAT_S(R, S, T, X, Q)	_FP_SQRT_MEAT_1 (R, S, T, X, (Q))

#if _FP_W_TYPE_SIZE < 64
# define FP_FMA_S(R, X, Y, Z)	_FP_FMA (S, 1, 2, R, X, Y, Z)
#else
# define FP_FMA_S(R, X, Y, Z)	_FP_FMA (S, 1, 1, R, X, Y, Z)
#endif

#define FP_CMP_S(r, X, Y, un, ex)	_FP_CMP (S, 1, (r), X, Y, (un), (ex))
#define FP_CMP_EQ_S(r, X, Y, ex)	_FP_CMP_EQ (S, 1, (r), X, Y, (ex))
#define FP_CMP_UNORD_S(r, X, Y, ex)	_FP_CMP_UNORD (S, 1, (r), X, Y, (ex))

#define FP_TO_INT_S(r, X, rsz, rsg)	_FP_TO_INT (S, 1, (r), X, (rsz), (rsg))
#define FP_TO_INT_ROUND_S(r, X, rsz, rsg)	\
  _FP_TO_INT_ROUND (S, 1, (r), X, (rsz), (rsg))
#define FP_FROM_INT_S(X, r, rs, rt)	_FP_FROM_INT (S, 1, X, (r), (rs), rt)

#define _FP_FRAC_HIGH_S(X)	_FP_FRAC_HIGH_1 (X)
#define _FP_FRAC_HIGH_RAW_S(X)	_FP_FRAC_HIGH_1 (X)

#if _FP_W_TYPE_SIZE < 64
# define _FP_FRAC_HIGH_DW_S(X)	_FP_FRAC_HIGH_2 (X)
#else
# define _FP_FRAC_HIGH_DW_S(X)	_FP_FRAC_HIGH_1 (X)
#endif

#endif /* !SOFT_FP_SINGLE_H */
Commit	Line	Data
d876f532 UD	1	/* Software floating-point emulation.
d876f532 UD	2	Definitions for IEEE Single Precision.
04277e02	3	Copyright (C) 1997-2019 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	30	License along with the GNU C Library; if not, see
5a82c748	31	<https://www.gnu.org/licenses/>. */
d876f532	32
a2f8be9c JM	33	#ifndef SOFT_FP_SINGLE_H
	34	#define SOFT_FP_SINGLE_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
d876f532 UD	39
fe0b1e85 RM	40	#define _FP_FRACTBITS_S _FP_W_TYPE_SIZE
fe0b1e85 RM	41
77f01ab5 JM	42	#if _FP_W_TYPE_SIZE < 64
	43	# define _FP_FRACTBITS_DW_S (2 * _FP_W_TYPE_SIZE)
	44	#else
	45	# define _FP_FRACTBITS_DW_S _FP_W_TYPE_SIZE
	46	#endif
	47
d876f532	48	#define _FP_FRACBITS_S 24
fe0b1e85	49	#define _FP_FRACXBITS_S (_FP_FRACTBITS_S - _FP_FRACBITS_S)
d876f532	50	#define _FP_WFRACBITS_S (_FP_WORKBITS + _FP_FRACBITS_S)
fe0b1e85	51	#define _FP_WFRACXBITS_S (_FP_FRACTBITS_S - _FP_WFRACBITS_S)
d876f532 UD	52	#define _FP_EXPBITS_S 8
	53	#define _FP_EXPBIAS_S 127
	54	#define _FP_EXPMAX_S 255
51ca9e29 JM	55	#define _FP_QNANBIT_S ((_FP_W_TYPE) 1 << (_FP_FRACBITS_S-2))
	56	#define _FP_QNANBIT_SH_S ((_FP_W_TYPE) 1 << (_FP_FRACBITS_S-2+_FP_WORKBITS))
	57	#define _FP_IMPLBIT_S ((_FP_W_TYPE) 1 << (_FP_FRACBITS_S-1))
	58	#define _FP_IMPLBIT_SH_S ((_FP_W_TYPE) 1 << (_FP_FRACBITS_S-1+_FP_WORKBITS))
	59	#define _FP_OVERFLOW_S ((_FP_W_TYPE) 1 << (_FP_WFRACBITS_S))
d876f532	60
77f01ab5 JM	61	#define _FP_WFRACBITS_DW_S (2 * _FP_WFRACBITS_S)
	62	#define _FP_WFRACXBITS_DW_S (_FP_FRACTBITS_DW_S - _FP_WFRACBITS_DW_S)
	63	#define _FP_HIGHBIT_DW_S \
51ca9e29	64	((_FP_W_TYPE) 1 << (_FP_WFRACBITS_DW_S - 1) % _FP_W_TYPE_SIZE)
77f01ab5	65
d876f532 UD	66	/* The implementation of _FP_MUL_MEAT_S and _FP_DIV_MEAT_S should be
	67	chosen by the target machine. */
	68
51ca9e29	69	typedef float SFtype __attribute__ ((mode (SF)));
fe0b1e85	70
d876f532 UD	71	union _FP_UNION_S
d876f532 UD	72	{
fe0b1e85	73	SFtype flt;
1e145589 JM	74	struct _FP_STRUCT_LAYOUT
1e145589 JM	75	{
d876f532 UD	76	#if __BYTE_ORDER == __BIG_ENDIAN
	77	unsigned sign : 1;
	78	unsigned exp : _FP_EXPBITS_S;
	79	unsigned frac : _FP_FRACBITS_S - (_FP_IMPLBIT_S != 0);
	80	#else
	81	unsigned frac : _FP_FRACBITS_S - (_FP_IMPLBIT_S != 0);
	82	unsigned exp : _FP_EXPBITS_S;
	83	unsigned sign : 1;
	84	#endif
049375e2	85	} bits;
d876f532 UD	86	};
d876f532 UD	87
51ca9e29	88	#define FP_DECL_S(X) _FP_DECL (1, X)
5c0508a3 JM	89	#define FP_UNPACK_RAW_S(X, val) _FP_UNPACK_RAW_1 (S, X, (val))
	90	#define FP_UNPACK_RAW_SP(X, val) _FP_UNPACK_RAW_1_P (S, X, (val))
	91	#define FP_PACK_RAW_S(val, X) _FP_PACK_RAW_1 (S, (val), X)
51ca9e29	92	#define FP_PACK_RAW_SP(val, X) \
1e145589 JM	93	do \
	94	{ \
	95	if (!FP_INHIBIT_RESULTS) \
5c0508a3	96	_FP_PACK_RAW_1_P (S, (val), X); \
1e145589 JM	97	} \
	98	while (0)
	99
51ca9e29	100	#define FP_UNPACK_S(X, val) \
1e145589 JM	101	do \
1e145589 JM	102	{ \
5c0508a3	103	_FP_UNPACK_RAW_1 (S, X, (val)); \
51ca9e29	104	_FP_UNPACK_CANONICAL (S, 1, X); \
1e145589 JM	105	} \
	106	while (0)
	107
51ca9e29	108	#define FP_UNPACK_SP(X, val) \
1e145589 JM	109	do \
1e145589 JM	110	{ \
5c0508a3	111	_FP_UNPACK_RAW_1_P (S, X, (val)); \
51ca9e29	112	_FP_UNPACK_CANONICAL (S, 1, X); \
1e145589 JM	113	} \
	114	while (0)
	115
51ca9e29	116	#define FP_UNPACK_SEMIRAW_S(X, val) \
1e145589 JM	117	do \
1e145589 JM	118	{ \
5c0508a3	119	_FP_UNPACK_RAW_1 (S, X, (val)); \
51ca9e29	120	_FP_UNPACK_SEMIRAW (S, 1, X); \
1e145589 JM	121	} \
	122	while (0)
	123
51ca9e29	124	#define FP_UNPACK_SEMIRAW_SP(X, val) \
1e145589 JM	125	do \
1e145589 JM	126	{ \
5c0508a3	127	_FP_UNPACK_RAW_1_P (S, X, (val)); \
51ca9e29	128	_FP_UNPACK_SEMIRAW (S, 1, X); \
1e145589 JM	129	} \
	130	while (0)
	131
51ca9e29	132	#define FP_PACK_S(val, X) \
1e145589 JM	133	do \
1e145589 JM	134	{ \
51ca9e29	135	_FP_PACK_CANONICAL (S, 1, X); \
5c0508a3	136	_FP_PACK_RAW_1 (S, (val), X); \
1e145589 JM	137	} \
	138	while (0)
	139
51ca9e29	140	#define FP_PACK_SP(val, X) \
1e145589 JM	141	do \
1e145589 JM	142	{ \
51ca9e29	143	_FP_PACK_CANONICAL (S, 1, X); \
1e145589	144	if (!FP_INHIBIT_RESULTS) \
5c0508a3	145	_FP_PACK_RAW_1_P (S, (val), X); \
1e145589 JM	146	} \
	147	while (0)
	148
51ca9e29	149	#define FP_PACK_SEMIRAW_S(val, X) \
1e145589 JM	150	do \
1e145589 JM	151	{ \
51ca9e29	152	_FP_PACK_SEMIRAW (S, 1, X); \
5c0508a3	153	_FP_PACK_RAW_1 (S, (val), X); \
1e145589 JM	154	} \
	155	while (0)
	156
51ca9e29	157	#define FP_PACK_SEMIRAW_SP(val, X) \
1e145589 JM	158	do \
1e145589 JM	159	{ \
51ca9e29	160	_FP_PACK_SEMIRAW (S, 1, X); \
1e145589	161	if (!FP_INHIBIT_RESULTS) \
5c0508a3	162	_FP_PACK_RAW_1_P (S, (val), X); \
1e145589 JM	163	} \
1e145589 JM	164	while (0)
fe0b1e85	165
51ca9e29 JM	166	#define FP_ISSIGNAN_S(X) _FP_ISSIGNAN (S, 1, X)
	167	#define FP_NEG_S(R, X) _FP_NEG (S, 1, R, X)
	168	#define FP_ADD_S(R, X, Y) _FP_ADD (S, 1, R, X, Y)
	169	#define FP_SUB_S(R, X, Y) _FP_SUB (S, 1, R, X, Y)
	170	#define FP_MUL_S(R, X, Y) _FP_MUL (S, 1, R, X, Y)
	171	#define FP_DIV_S(R, X, Y) _FP_DIV (S, 1, R, X, Y)
	172	#define FP_SQRT_S(R, X) _FP_SQRT (S, 1, R, X)
5c0508a3	173	#define _FP_SQRT_MEAT_S(R, S, T, X, Q) _FP_SQRT_MEAT_1 (R, S, T, X, (Q))
d876f532	174
77f01ab5	175	#if _FP_W_TYPE_SIZE < 64
51ca9e29	176	# define FP_FMA_S(R, X, Y, Z) _FP_FMA (S, 1, 2, R, X, Y, Z)
77f01ab5	177	#else
51ca9e29	178	# define FP_FMA_S(R, X, Y, Z) _FP_FMA (S, 1, 1, R, X, Y, Z)
77f01ab5 JM	179	#endif
77f01ab5 JM	180
5c0508a3 JM	181	#define FP_CMP_S(r, X, Y, un, ex) _FP_CMP (S, 1, (r), X, Y, (un), (ex))
	182	#define FP_CMP_EQ_S(r, X, Y, ex) _FP_CMP_EQ (S, 1, (r), X, Y, (ex))
	183	#define FP_CMP_UNORD_S(r, X, Y, ex) _FP_CMP_UNORD (S, 1, (r), X, Y, (ex))
d876f532	184
5c0508a3	185	#define FP_TO_INT_S(r, X, rsz, rsg) _FP_TO_INT (S, 1, (r), X, (rsz), (rsg))
2004e7fb JM	186	#define FP_TO_INT_ROUND_S(r, X, rsz, rsg) \
2004e7fb JM	187	_FP_TO_INT_ROUND (S, 1, (r), X, (rsz), (rsg))
5c0508a3	188	#define FP_FROM_INT_S(X, r, rs, rt) _FP_FROM_INT (S, 1, X, (r), (rs), rt)
d876f532	189
51ca9e29 JM	190	#define _FP_FRAC_HIGH_S(X) _FP_FRAC_HIGH_1 (X)
51ca9e29 JM	191	#define _FP_FRAC_HIGH_RAW_S(X) _FP_FRAC_HIGH_1 (X)
77f01ab5 JM	192
77f01ab5 JM	193	#if _FP_W_TYPE_SIZE < 64
51ca9e29	194	# define _FP_FRAC_HIGH_DW_S(X) _FP_FRAC_HIGH_2 (X)
77f01ab5	195	#else
51ca9e29	196	# define _FP_FRAC_HIGH_DW_S(X) _FP_FRAC_HIGH_1 (X)
77f01ab5	197	#endif
a2f8be9c JM	198
a2f8be9c JM	199	#endif /* !SOFT_FP_SINGLE_H */