25  *	ix1 = *((1-n0)+(int*)&x);		* low word of x *
27  * value.  That is non-ANSI, and, moreover, the gcc instruction
136 /* Get a 64-bit int from a double. */
172 /* Set a double from a 64-bit int. */
310 /* The above works on non-i386 too, but we use this to check v. */
316  * Attempt to get strict C99 semantics for assignment with non-C99 compilers.
378 	__s = __w - (a);	\
379 	(b) = ((a) - (__w - __s)) + ((b) - __s); \
386  * "Normalize" the terms in the infinite-precision expression a + b for
399  * algorithm would be destroyed by non-null strict assignments.  (The
400  * compilers are correct to be broken -- the efficiency of all floating
405  * any extra precision into the type of 'a' -- 'a' should have type float_t,
408  * reduce their own extra-precision and efficiency problems.  In
421 	(b) = ((a) - __w) + (b);			\
427 	__r = __ia - __vw;				\
436 	(b) = ((a) - __w) + (b); \
458  * or by having |c| a few percent smaller than |a|.  Pre-normalization of
501 #define	nan_mix(x, y)		(nan_mix_op((x), (y), +))  argument
502 #define	nan_mix_op(x, y, op)	(((x) + 0.0L) op ((y) + 0))  argument
529  * The C99 standard intends x+I*y to be used for this, but x+I*y is
531  * underflow, sign and efficiency bugs by rewriting I*y as
532  * (0.0+I)*(y+0.0*I) and laboriously computing the full complex product.
533  * In particular, I*Inf is corrupted to NaN+I*Inf, and I*-0 is corrupted
534  * to -0.0+I*0.0.
543 CMPLXF(float x, float y)  in CMPLXF()  argument
548 	IMAGPART(z) = y;  in CMPLXF()
555 CMPLX(double x, double y)  in CMPLX()  argument
560 	IMAGPART(z) = y;  in CMPLX()
567 CMPLXL(long double x, long double y)  in CMPLXL()  argument
572 	IMAGPART(z) = y;  in CMPLXL()
607 	return ((double)(x + 0x1.8p52) - 0x1.8p52);  in rnint()
617 	return ((float)(x + 0x1.8p23F) - 0x1.8p23F);  in rnintf()
635 	return (x + __CONCAT(0x1.8p, LDBL_MANT_DIG) / 2 -  in rnintl()
690  * The following are fast floor macros for 0 <= |x| < 0x1p(N-1), where
692  * half-cycle trignometric functions (e.g., sinpi(x)).
695 	(j0) = (((ix) >> 23) & 0xff) - 0x7f;	\
701 	(j0) = (((ix) >> 20) & 0x7ff) - 0x3ff;			\
706 		(lx) &= ~((uint32_t)0xffffffff >> ((j0) - 20));	\
712 	j0 = ix - 0x3fff + 1;				\
715 		(lx) &= ~((((lx) << 32)-1) >> (j0));	\
718 		_m = (uint64_t)-1 >> (j0);		\
729 	e = u.bits.exp - 16383;				\
731 		m = ((1llu << 49) - 1) >> (e + 1);	\
735 		m = (uint64_t)-1 >> (e - 48);		\
739 	(ar) = (x) - (ai);				\
753 #define	RETURNSP(rp) do {		\  argument
754 	if (!(rp)->lo_set)		\
755 		RETURNF((rp)->hi);	\
756 	RETURNF((rp)->hi + (rp)->lo);	\
758 #define	RETURNSPI(rp) do {		\  argument
759 	if (!(rp)->lo_set)		\
760 		RETURNI((rp)->hi);	\
761 	RETURNI((rp)->hi + (rp)->lo);	\
765 #define	SUM2P(x, y) ({			\  argument
767 	const __typeof (y) __y = (y);	\