1/*
2 * ====================================================
3 * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
4 *
5 * Developed at SunPro, a Sun Microsystems, Inc. business.
6 * Permission to use, copy, modify, and distribute this
7 * software is freely granted, provided that this notice
8 * is preserved.
9 * ====================================================
10 */
11
12/*
13 * from: @(#)fdlibm.h 5.1 93/09/24
14 * $FreeBSD$
15 */
16
17#ifndef _MATH_PRIVATE_H_
18#define	_MATH_PRIVATE_H_
19
20#include <sys/types.h>
21#include <machine/endian.h>
22
23/*
24 * The original fdlibm code used statements like:
25 *	n0 = ((*(int*)&one)>>29)^1;		* index of high word *
26 *	ix0 = *(n0+(int*)&x);			* high word of x *
27 *	ix1 = *((1-n0)+(int*)&x);		* low word of x *
28 * to dig two 32 bit words out of the 64 bit IEEE floating point
29 * value.  That is non-ANSI, and, moreover, the gcc instruction
30 * scheduler gets it wrong.  We instead use the following macros.
31 * Unlike the original code, we determine the endianness at compile
32 * time, not at run time; I don't see much benefit to selecting
33 * endianness at run time.
34 */
35
36/*
37 * A union which permits us to convert between a double and two 32 bit
38 * ints.
39 */
40
41#ifdef __arm__
42#if defined(__VFP_FP__) || defined(__ARM_EABI__)
43#define	IEEE_WORD_ORDER	BYTE_ORDER
44#else
45#define	IEEE_WORD_ORDER	BIG_ENDIAN
46#endif
47#else /* __arm__ */
48#define	IEEE_WORD_ORDER	BYTE_ORDER
49#endif
50
51#if IEEE_WORD_ORDER == BIG_ENDIAN
52
53typedef union
54{
55  double value;
56  struct
57  {
58    u_int32_t msw;
59    u_int32_t lsw;
60  } parts;
61  struct
62  {
63    u_int64_t w;
64  } xparts;
65} ieee_double_shape_type;
66
67#endif
68
69#if IEEE_WORD_ORDER == LITTLE_ENDIAN
70
71typedef union
72{
73  double value;
74  struct
75  {
76    u_int32_t lsw;
77    u_int32_t msw;
78  } parts;
79  struct
80  {
81    u_int64_t w;
82  } xparts;
83} ieee_double_shape_type;
84
85#endif
86
87/* Get two 32 bit ints from a double.  */
88
89#define EXTRACT_WORDS(ix0,ix1,d)				\
90do {								\
91  ieee_double_shape_type ew_u;					\
92  ew_u.value = (d);						\
93  (ix0) = ew_u.parts.msw;					\
94  (ix1) = ew_u.parts.lsw;					\
95} while (0)
96
97/* Get a 64-bit int from a double. */
98#define EXTRACT_WORD64(ix,d)					\
99do {								\
100  ieee_double_shape_type ew_u;					\
101  ew_u.value = (d);						\
102  (ix) = ew_u.xparts.w;						\
103} while (0)
104
105/* Get the more significant 32 bit int from a double.  */
106
107#define GET_HIGH_WORD(i,d)					\
108do {								\
109  ieee_double_shape_type gh_u;					\
110  gh_u.value = (d);						\
111  (i) = gh_u.parts.msw;						\
112} while (0)
113
114/* Get the less significant 32 bit int from a double.  */
115
116#define GET_LOW_WORD(i,d)					\
117do {								\
118  ieee_double_shape_type gl_u;					\
119  gl_u.value = (d);						\
120  (i) = gl_u.parts.lsw;						\
121} while (0)
122
123/* Set a double from two 32 bit ints.  */
124
125#define INSERT_WORDS(d,ix0,ix1)					\
126do {								\
127  ieee_double_shape_type iw_u;					\
128  iw_u.parts.msw = (ix0);					\
129  iw_u.parts.lsw = (ix1);					\
130  (d) = iw_u.value;						\
131} while (0)
132
133/* Set a double from a 64-bit int. */
134#define INSERT_WORD64(d,ix)					\
135do {								\
136  ieee_double_shape_type iw_u;					\
137  iw_u.xparts.w = (ix);						\
138  (d) = iw_u.value;						\
139} while (0)
140
141/* Set the more significant 32 bits of a double from an int.  */
142
143#define SET_HIGH_WORD(d,v)					\
144do {								\
145  ieee_double_shape_type sh_u;					\
146  sh_u.value = (d);						\
147  sh_u.parts.msw = (v);						\
148  (d) = sh_u.value;						\
149} while (0)
150
151/* Set the less significant 32 bits of a double from an int.  */
152
153#define SET_LOW_WORD(d,v)					\
154do {								\
155  ieee_double_shape_type sl_u;					\
156  sl_u.value = (d);						\
157  sl_u.parts.lsw = (v);						\
158  (d) = sl_u.value;						\
159} while (0)
160
161/*
162 * A union which permits us to convert between a float and a 32 bit
163 * int.
164 */
165
166typedef union
167{
168  float value;
169  /* FIXME: Assumes 32 bit int.  */
170  unsigned int word;
171} ieee_float_shape_type;
172
173/* Get a 32 bit int from a float.  */
174
175#define GET_FLOAT_WORD(i,d)					\
176do {								\
177  ieee_float_shape_type gf_u;					\
178  gf_u.value = (d);						\
179  (i) = gf_u.word;						\
180} while (0)
181
182/* Set a float from a 32 bit int.  */
183
184#define SET_FLOAT_WORD(d,i)					\
185do {								\
186  ieee_float_shape_type sf_u;					\
187  sf_u.word = (i);						\
188  (d) = sf_u.value;						\
189} while (0)
190
191/*
192 * Get expsign and mantissa as 16 bit and 64 bit ints from an 80 bit long
193 * double.
194 */
195
196#define	EXTRACT_LDBL80_WORDS(ix0,ix1,d)				\
197do {								\
198  union IEEEl2bits ew_u;					\
199  ew_u.e = (d);							\
200  (ix0) = ew_u.xbits.expsign;					\
201  (ix1) = ew_u.xbits.man;					\
202} while (0)
203
204/*
205 * Get expsign and mantissa as one 16 bit and two 64 bit ints from a 128 bit
206 * long double.
207 */
208
209#define	EXTRACT_LDBL128_WORDS(ix0,ix1,ix2,d)			\
210do {								\
211  union IEEEl2bits ew_u;					\
212  ew_u.e = (d);							\
213  (ix0) = ew_u.xbits.expsign;					\
214  (ix1) = ew_u.xbits.manh;					\
215  (ix2) = ew_u.xbits.manl;					\
216} while (0)
217
218/* Get expsign as a 16 bit int from a long double.  */
219
220#define	GET_LDBL_EXPSIGN(i,d)					\
221do {								\
222  union IEEEl2bits ge_u;					\
223  ge_u.e = (d);							\
224  (i) = ge_u.xbits.expsign;					\
225} while (0)
226
227/*
228 * Set an 80 bit long double from a 16 bit int expsign and a 64 bit int
229 * mantissa.
230 */
231
232#define	INSERT_LDBL80_WORDS(d,ix0,ix1)				\
233do {								\
234  union IEEEl2bits iw_u;					\
235  iw_u.xbits.expsign = (ix0);					\
236  iw_u.xbits.man = (ix1);					\
237  (d) = iw_u.e;							\
238} while (0)
239
240/*
241 * Set a 128 bit long double from a 16 bit int expsign and two 64 bit ints
242 * comprising the mantissa.
243 */
244
245#define	INSERT_LDBL128_WORDS(d,ix0,ix1,ix2)			\
246do {								\
247  union IEEEl2bits iw_u;					\
248  iw_u.xbits.expsign = (ix0);					\
249  iw_u.xbits.manh = (ix1);					\
250  iw_u.xbits.manl = (ix2);					\
251  (d) = iw_u.e;							\
252} while (0)
253
254/* Set expsign of a long double from a 16 bit int.  */
255
256#define	SET_LDBL_EXPSIGN(d,v)					\
257do {								\
258  union IEEEl2bits se_u;					\
259  se_u.e = (d);							\
260  se_u.xbits.expsign = (v);					\
261  (d) = se_u.e;							\
262} while (0)
263
264#ifdef __i386__
265/* Long double constants are broken on i386. */
266#define	LD80C(m, ex, v) {						\
267	.xbits.man = __CONCAT(m, ULL),					\
268	.xbits.expsign = (0x3fff + (ex)) | ((v) < 0 ? 0x8000 : 0),	\
269}
270#else
271/* The above works on non-i386 too, but we use this to check v. */
272#define	LD80C(m, ex, v)	{ .e = (v), }
273#endif
274
275#ifdef FLT_EVAL_METHOD
276/*
277 * Attempt to get strict C99 semantics for assignment with non-C99 compilers.
278 */
279#if FLT_EVAL_METHOD == 0 || __GNUC__ == 0
280#define	STRICT_ASSIGN(type, lval, rval)	((lval) = (rval))
281#else
282#define	STRICT_ASSIGN(type, lval, rval) do {	\
283	volatile type __lval;			\
284						\
285	if (sizeof(type) >= sizeof(long double))	\
286		(lval) = (rval);		\
287	else {					\
288		__lval = (rval);		\
289		(lval) = __lval;		\
290	}					\
291} while (0)
292#endif
293#endif /* FLT_EVAL_METHOD */
294
295/* Support switching the mode to FP_PE if necessary. */
296#if defined(__i386__) && !defined(NO_FPSETPREC)
297#define	ENTERI()				\
298	long double __retval;			\
299	fp_prec_t __oprec;			\
300						\
301	if ((__oprec = fpgetprec()) != FP_PE)	\
302		fpsetprec(FP_PE)
303#define	RETURNI(x) do {				\
304	__retval = (x);				\
305	if (__oprec != FP_PE)			\
306		fpsetprec(__oprec);		\
307	RETURNF(__retval);			\
308} while (0)
309#else
310#define	ENTERI(x)
311#define	RETURNI(x)	RETURNF(x)
312#endif
313
314/* Default return statement if hack*_t() is not used. */
315#define      RETURNF(v)      return (v)
316
317/*
318 * 2sum gives the same result as 2sumF without requiring |a| >= |b| or
319 * a == 0, but is slower.
320 */
321#define	_2sum(a, b) do {	\
322	__typeof(a) __s, __w;	\
323				\
324	__w = (a) + (b);	\
325	__s = __w - (a);	\
326	(b) = ((a) - (__w - __s)) + ((b) - __s); \
327	(a) = __w;		\
328} while (0)
329
330/*
331 * 2sumF algorithm.
332 *
333 * "Normalize" the terms in the infinite-precision expression a + b for
334 * the sum of 2 floating point values so that b is as small as possible
335 * relative to 'a'.  (The resulting 'a' is the value of the expression in
336 * the same precision as 'a' and the resulting b is the rounding error.)
337 * |a| must be >= |b| or 0, b's type must be no larger than 'a's type, and
338 * exponent overflow or underflow must not occur.  This uses a Theorem of
339 * Dekker (1971).  See Knuth (1981) 4.2.2 Theorem C.  The name "TwoSum"
340 * is apparently due to Skewchuk (1997).
341 *
342 * For this to always work, assignment of a + b to 'a' must not retain any
343 * extra precision in a + b.  This is required by C standards but broken
344 * in many compilers.  The brokenness cannot be worked around using
345 * STRICT_ASSIGN() like we do elsewhere, since the efficiency of this
346 * algorithm would be destroyed by non-null strict assignments.  (The
347 * compilers are correct to be broken -- the efficiency of all floating
348 * point code calculations would be destroyed similarly if they forced the
349 * conversions.)
350 *
351 * Fortunately, a case that works well can usually be arranged by building
352 * any extra precision into the type of 'a' -- 'a' should have type float_t,
353 * double_t or long double.  b's type should be no larger than 'a's type.
354 * Callers should use these types with scopes as large as possible, to
355 * reduce their own extra-precision and efficiciency problems.  In
356 * particular, they shouldn't convert back and forth just to call here.
357 */
358#ifdef DEBUG
359#define	_2sumF(a, b) do {				\
360	__typeof(a) __w;				\
361	volatile __typeof(a) __ia, __ib, __r, __vw;	\
362							\
363	__ia = (a);					\
364	__ib = (b);					\
365	assert(__ia == 0 || fabsl(__ia) >= fabsl(__ib));	\
366							\
367	__w = (a) + (b);				\
368	(b) = ((a) - __w) + (b);			\
369	(a) = __w;					\
370							\
371	/* The next 2 assertions are weak if (a) is already long double. */ \
372	assert((long double)__ia + __ib == (long double)(a) + (b));	\
373	__vw = __ia + __ib;				\
374	__r = __ia - __vw;				\
375	__r += __ib;					\
376	assert(__vw == (a) && __r == (b));		\
377} while (0)
378#else /* !DEBUG */
379#define	_2sumF(a, b) do {	\
380	__typeof(a) __w;	\
381				\
382	__w = (a) + (b);	\
383	(b) = ((a) - __w) + (b); \
384	(a) = __w;		\
385} while (0)
386#endif /* DEBUG */
387
388/*
389 * Set x += c, where x is represented in extra precision as a + b.
390 * x must be sufficiently normalized and sufficiently larger than c,
391 * and the result is then sufficiently normalized.
392 *
393 * The details of ordering are that |a| must be >= |c| (so that (a, c)
394 * can be normalized without extra work to swap 'a' with c).  The details of
395 * the normalization are that b must be small relative to the normalized 'a'.
396 * Normalization of (a, c) makes the normalized c tiny relative to the
397 * normalized a, so b remains small relative to 'a' in the result.  However,
398 * b need not ever be tiny relative to 'a'.  For example, b might be about
399 * 2**20 times smaller than 'a' to give about 20 extra bits of precision.
400 * That is usually enough, and adding c (which by normalization is about
401 * 2**53 times smaller than a) cannot change b significantly.  However,
402 * cancellation of 'a' with c in normalization of (a, c) may reduce 'a'
403 * significantly relative to b.  The caller must ensure that significant
404 * cancellation doesn't occur, either by having c of the same sign as 'a',
405 * or by having |c| a few percent smaller than |a|.  Pre-normalization of
406 * (a, b) may help.
407 *
408 * This is is a variant of an algorithm of Kahan (see Knuth (1981) 4.2.2
409 * exercise 19).  We gain considerable efficiency by requiring the terms to
410 * be sufficiently normalized and sufficiently increasing.
411 */
412#define	_3sumF(a, b, c) do {	\
413	__typeof(a) __tmp;	\
414				\
415	__tmp = (c);		\
416	_2sumF(__tmp, (a));	\
417	(b) += (a);		\
418	(a) = __tmp;		\
419} while (0)
420
421/*
422 * Common routine to process the arguments to nan(), nanf(), and nanl().
423 */
424void _scan_nan(uint32_t *__words, int __num_words, const char *__s);
425
426#ifdef _COMPLEX_H
427
428/*
429 * C99 specifies that complex numbers have the same representation as
430 * an array of two elements, where the first element is the real part
431 * and the second element is the imaginary part.
432 */
433typedef union {
434	float complex f;
435	float a[2];
436} float_complex;
437typedef union {
438	double complex f;
439	double a[2];
440} double_complex;
441typedef union {
442	long double complex f;
443	long double a[2];
444} long_double_complex;
445#define	REALPART(z)	((z).a[0])
446#define	IMAGPART(z)	((z).a[1])
447
448/*
449 * Inline functions that can be used to construct complex values.
450 *
451 * The C99 standard intends x+I*y to be used for this, but x+I*y is
452 * currently unusable in general since gcc introduces many overflow,
453 * underflow, sign and efficiency bugs by rewriting I*y as
454 * (0.0+I)*(y+0.0*I) and laboriously computing the full complex product.
455 * In particular, I*Inf is corrupted to NaN+I*Inf, and I*-0 is corrupted
456 * to -0.0+I*0.0.
457 *
458 * The C11 standard introduced the macros CMPLX(), CMPLXF() and CMPLXL()
459 * to construct complex values.  Compilers that conform to the C99
460 * standard require the following functions to avoid the above issues.
461 */
462
463#ifndef CMPLXF
464static __inline float complex
465CMPLXF(float x, float y)
466{
467	float_complex z;
468
469	REALPART(z) = x;
470	IMAGPART(z) = y;
471	return (z.f);
472}
473#endif
474
475#ifndef CMPLX
476static __inline double complex
477CMPLX(double x, double y)
478{
479	double_complex z;
480
481	REALPART(z) = x;
482	IMAGPART(z) = y;
483	return (z.f);
484}
485#endif
486
487#ifndef CMPLXL
488static __inline long double complex
489CMPLXL(long double x, long double y)
490{
491	long_double_complex z;
492
493	REALPART(z) = x;
494	IMAGPART(z) = y;
495	return (z.f);
496}
497#endif
498
499#endif /* _COMPLEX_H */
500
501#ifdef __GNUCLIKE_ASM
502
503/* Asm versions of some functions. */
504
505#if defined(__amd64__) && !defined(__k1om__)
506static __inline int
507irint(double x)
508{
509	int n;
510
511	asm("cvtsd2si %1,%0" : "=r" (n) : "x" (x));
512	return (n);
513}
514#define	HAVE_EFFICIENT_IRINT
515#endif
516
517#if defined(__i386__) || defined(__k1om__)
518static __inline int
519irint(double x)
520{
521	int n;
522
523	asm("fistl %0" : "=m" (n) : "t" (x));
524	return (n);
525}
526#define	HAVE_EFFICIENT_IRINT
527#endif
528
529#if defined(__amd64__) || defined(__i386__)
530static __inline int
531irintl(long double x)
532{
533	int n;
534
535	asm("fistl %0" : "=m" (n) : "t" (x));
536	return (n);
537}
538#define	HAVE_EFFICIENT_IRINTL
539#endif
540
541#endif /* __GNUCLIKE_ASM */
542
543#ifdef DEBUG
544#if defined(__amd64__) || defined(__i386__)
545#define	breakpoint()	asm("int $3")
546#else
547#include <signal.h>
548
549#define	breakpoint()	raise(SIGTRAP)
550#endif
551#endif
552
553/* Write a pari script to test things externally. */
554#ifdef DOPRINT
555#include <stdio.h>
556
557#ifndef DOPRINT_SWIZZLE
558#define	DOPRINT_SWIZZLE		0
559#endif
560
561#ifdef DOPRINT_LD80
562
563#define	DOPRINT_START(xp) do {						\
564	uint64_t __lx;							\
565	uint16_t __hx;							\
566									\
567	/* Hack to give more-problematic args. */			\
568	EXTRACT_LDBL80_WORDS(__hx, __lx, *xp);				\
569	__lx ^= DOPRINT_SWIZZLE;					\
570	INSERT_LDBL80_WORDS(*xp, __hx, __lx);				\
571	printf("x = %.21Lg; ", (long double)*xp);			\
572} while (0)
573#define	DOPRINT_END1(v)							\
574	printf("y = %.21Lg; z = 0; show(x, y, z);\n", (long double)(v))
575#define	DOPRINT_END2(hi, lo)						\
576	printf("y = %.21Lg; z = %.21Lg; show(x, y, z);\n",		\
577	    (long double)(hi), (long double)(lo))
578
579#elif defined(DOPRINT_D64)
580
581#define	DOPRINT_START(xp) do {						\
582	uint32_t __hx, __lx;						\
583									\
584	EXTRACT_WORDS(__hx, __lx, *xp);					\
585	__lx ^= DOPRINT_SWIZZLE;					\
586	INSERT_WORDS(*xp, __hx, __lx);					\
587	printf("x = %.21Lg; ", (long double)*xp);			\
588} while (0)
589#define	DOPRINT_END1(v)							\
590	printf("y = %.21Lg; z = 0; show(x, y, z);\n", (long double)(v))
591#define	DOPRINT_END2(hi, lo)						\
592	printf("y = %.21Lg; z = %.21Lg; show(x, y, z);\n",		\
593	    (long double)(hi), (long double)(lo))
594
595#elif defined(DOPRINT_F32)
596
597#define	DOPRINT_START(xp) do {						\
598	uint32_t __hx;							\
599									\
600	GET_FLOAT_WORD(__hx, *xp);					\
601	__hx ^= DOPRINT_SWIZZLE;					\
602	SET_FLOAT_WORD(*xp, __hx);					\
603	printf("x = %.21Lg; ", (long double)*xp);			\
604} while (0)
605#define	DOPRINT_END1(v)							\
606	printf("y = %.21Lg; z = 0; show(x, y, z);\n", (long double)(v))
607#define	DOPRINT_END2(hi, lo)						\
608	printf("y = %.21Lg; z = %.21Lg; show(x, y, z);\n",		\
609	    (long double)(hi), (long double)(lo))
610
611#else /* !DOPRINT_LD80 && !DOPRINT_D64 (LD128 only) */
612
613#ifndef DOPRINT_SWIZZLE_HIGH
614#define	DOPRINT_SWIZZLE_HIGH	0
615#endif
616
617#define	DOPRINT_START(xp) do {						\
618	uint64_t __lx, __llx;						\
619	uint16_t __hx;							\
620									\
621	EXTRACT_LDBL128_WORDS(__hx, __lx, __llx, *xp);			\
622	__llx ^= DOPRINT_SWIZZLE;					\
623	__lx ^= DOPRINT_SWIZZLE_HIGH;					\
624	INSERT_LDBL128_WORDS(*xp, __hx, __lx, __llx);			\
625	printf("x = %.36Lg; ", (long double)*xp);					\
626} while (0)
627#define	DOPRINT_END1(v)							\
628	printf("y = %.36Lg; z = 0; show(x, y, z);\n", (long double)(v))
629#define	DOPRINT_END2(hi, lo)						\
630	printf("y = %.36Lg; z = %.36Lg; show(x, y, z);\n",		\
631	    (long double)(hi), (long double)(lo))
632
633#endif /* DOPRINT_LD80 */
634
635#else /* !DOPRINT */
636#define	DOPRINT_START(xp)
637#define	DOPRINT_END1(v)
638#define	DOPRINT_END2(hi, lo)
639#endif /* DOPRINT */
640
641#define	RETURNP(x) do {			\
642	DOPRINT_END1(x);		\
643	RETURNF(x);			\
644} while (0)
645#define	RETURNPI(x) do {		\
646	DOPRINT_END1(x);		\
647	RETURNI(x);			\
648} while (0)
649#define	RETURN2P(x, y) do {		\
650	DOPRINT_END2((x), (y));		\
651	RETURNF((x) + (y));		\
652} while (0)
653#define	RETURN2PI(x, y) do {		\
654	DOPRINT_END2((x), (y));		\
655	RETURNI((x) + (y));		\
656} while (0)
657#ifdef STRUCT_RETURN
658#define	RETURNSP(rp) do {		\
659	if (!(rp)->lo_set)		\
660		RETURNP((rp)->hi);	\
661	RETURN2P((rp)->hi, (rp)->lo);	\
662} while (0)
663#define	RETURNSPI(rp) do {		\
664	if (!(rp)->lo_set)		\
665		RETURNPI((rp)->hi);	\
666	RETURN2PI((rp)->hi, (rp)->lo);	\
667} while (0)
668#endif
669#define	SUM2P(x, y) ({			\
670	const __typeof (x) __x = (x);	\
671	const __typeof (y) __y = (y);	\
672					\
673	DOPRINT_END2(__x, __y);		\
674	__x + __y;			\
675})
676
677/*
678 * ieee style elementary functions
679 *
680 * We rename functions here to improve other sources' diffability
681 * against fdlibm.
682 */
683#define	__ieee754_sqrt	sqrt
684#define	__ieee754_acos	acos
685#define	__ieee754_acosh	acosh
686#define	__ieee754_log	log
687#define	__ieee754_log2	log2
688#define	__ieee754_atanh	atanh
689#define	__ieee754_asin	asin
690#define	__ieee754_atan2	atan2
691#define	__ieee754_exp	exp
692#define	__ieee754_cosh	cosh
693#define	__ieee754_fmod	fmod
694#define	__ieee754_pow	pow
695#define	__ieee754_lgamma lgamma
696#define	__ieee754_gamma	gamma
697#define	__ieee754_lgamma_r lgamma_r
698#define	__ieee754_gamma_r gamma_r
699#define	__ieee754_log10	log10
700#define	__ieee754_sinh	sinh
701#define	__ieee754_hypot	hypot
702#define	__ieee754_j0	j0
703#define	__ieee754_j1	j1
704#define	__ieee754_y0	y0
705#define	__ieee754_y1	y1
706#define	__ieee754_jn	jn
707#define	__ieee754_yn	yn
708#define	__ieee754_remainder remainder
709#define	__ieee754_scalb	scalb
710#define	__ieee754_sqrtf	sqrtf
711#define	__ieee754_acosf	acosf
712#define	__ieee754_acoshf acoshf
713#define	__ieee754_logf	logf
714#define	__ieee754_atanhf atanhf
715#define	__ieee754_asinf	asinf
716#define	__ieee754_atan2f atan2f
717#define	__ieee754_expf	expf
718#define	__ieee754_coshf	coshf
719#define	__ieee754_fmodf	fmodf
720#define	__ieee754_powf	powf
721#define	__ieee754_lgammaf lgammaf
722#define	__ieee754_gammaf gammaf
723#define	__ieee754_lgammaf_r lgammaf_r
724#define	__ieee754_gammaf_r gammaf_r
725#define	__ieee754_log10f log10f
726#define	__ieee754_log2f log2f
727#define	__ieee754_sinhf	sinhf
728#define	__ieee754_hypotf hypotf
729#define	__ieee754_j0f	j0f
730#define	__ieee754_j1f	j1f
731#define	__ieee754_y0f	y0f
732#define	__ieee754_y1f	y1f
733#define	__ieee754_jnf	jnf
734#define	__ieee754_ynf	ynf
735#define	__ieee754_remainderf remainderf
736#define	__ieee754_scalbf scalbf
737
738/* fdlibm kernel function */
739int	__kernel_rem_pio2(double*,double*,int,int,int);
740
741/* double precision kernel functions */
742#ifndef INLINE_REM_PIO2
743int	__ieee754_rem_pio2(double,double*);
744#endif
745double	__kernel_sin(double,double,int);
746double	__kernel_cos(double,double);
747double	__kernel_tan(double,double,int);
748double	__ldexp_exp(double,int);
749#ifdef _COMPLEX_H
750double complex __ldexp_cexp(double complex,int);
751#endif
752
753/* float precision kernel functions */
754#ifndef INLINE_REM_PIO2F
755int	__ieee754_rem_pio2f(float,double*);
756#endif
757#ifndef INLINE_KERNEL_SINDF
758float	__kernel_sindf(double);
759#endif
760#ifndef INLINE_KERNEL_COSDF
761float	__kernel_cosdf(double);
762#endif
763#ifndef INLINE_KERNEL_TANDF
764float	__kernel_tandf(double,int);
765#endif
766float	__ldexp_expf(float,int);
767#ifdef _COMPLEX_H
768float complex __ldexp_cexpf(float complex,int);
769#endif
770
771/* long double precision kernel functions */
772long double __kernel_sinl(long double, long double, int);
773long double __kernel_cosl(long double, long double);
774long double __kernel_tanl(long double, long double, int);
775
776#endif /* !_MATH_PRIVATE_H_ */
777