111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert/* 211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * ==================================================== 311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. 411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * 511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * Developed at SunPro, a Sun Microsystems, Inc. business. 611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * Permission to use, copy, modify, and distribute this 711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * software is freely granted, provided that this notice 811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * is preserved. 911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * ==================================================== 1011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert */ 1111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 1211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert/* 1311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * from: @(#)fdlibm.h 5.1 93/09/24 1411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * $FreeBSD$ 1511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert */ 1611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 1711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#ifndef _MATH_PRIVATE_H_ 1811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define _MATH_PRIVATE_H_ 1911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 2011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#include <sys/types.h> 2111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#include <endian.h> 2211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 2311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert/* 2411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * The original fdlibm code used statements like: 2511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * n0 = ((*(int*)&one)>>29)^1; * index of high word * 2611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * ix0 = *(n0+(int*)&x); * high word of x * 2711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * ix1 = *((1-n0)+(int*)&x); * low word of x * 2811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * to dig two 32 bit words out of the 64 bit IEEE floating point 2911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * value. That is non-ANSI, and, moreover, the gcc instruction 3011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * scheduler gets it wrong. We instead use the following macros. 3111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * Unlike the original code, we determine the endianness at compile 3211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * time, not at run time; I don't see much benefit to selecting 3311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * endianness at run time. 3411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert */ 3511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 3611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert/* 3711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * A union which permits us to convert between a double and two 32 bit 3811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * ints. 3911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert */ 4011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 4111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#ifdef __arm__ 4211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if defined(__VFP_FP__) 4311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define IEEE_WORD_ORDER BYTE_ORDER 4411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#else 4511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define IEEE_WORD_ORDER BIG_ENDIAN 4611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 4711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#else /* __arm__ */ 4811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define IEEE_WORD_ORDER BYTE_ORDER 4911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 5011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 5111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if IEEE_WORD_ORDER == BIG_ENDIAN 5211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 5311cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttypedef union 5411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert{ 5511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert double value; 5611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert struct 5711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert { 5811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert u_int32_t msw; 5911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert u_int32_t lsw; 6011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } parts; 6111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert struct 6211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert { 6311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert u_int64_t w; 6411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } xparts; 6511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} ieee_double_shape_type; 6611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 6711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 6811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 6911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if IEEE_WORD_ORDER == LITTLE_ENDIAN 7011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 7111cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttypedef union 7211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert{ 7311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert double value; 7411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert struct 7511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert { 7611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert u_int32_t lsw; 7711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert u_int32_t msw; 7811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } parts; 7911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert struct 8011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert { 8111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert u_int64_t w; 8211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } xparts; 8311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} ieee_double_shape_type; 8411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 8511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 8611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 8711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert/* Get two 32 bit ints from a double. */ 8811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 8911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define EXTRACT_WORDS(ix0,ix1,d) \ 9011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertdo { \ 9111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ieee_double_shape_type ew_u; \ 9211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ew_u.value = (d); \ 9311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert (ix0) = ew_u.parts.msw; \ 9411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert (ix1) = ew_u.parts.lsw; \ 9511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} while (0) 9611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 9711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert/* Get a 64-bit int from a double. */ 9811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define EXTRACT_WORD64(ix,d) \ 9911cd02dfb91661c65134cac258cf5924270e9d2Dan Albertdo { \ 10011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ieee_double_shape_type ew_u; \ 10111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ew_u.value = (d); \ 10211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert (ix) = ew_u.xparts.w; \ 10311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} while (0) 10411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 10511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert/* Get the more significant 32 bit int from a double. */ 10611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 10711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define GET_HIGH_WORD(i,d) \ 10811cd02dfb91661c65134cac258cf5924270e9d2Dan Albertdo { \ 10911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ieee_double_shape_type gh_u; \ 11011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert gh_u.value = (d); \ 11111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert (i) = gh_u.parts.msw; \ 11211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} while (0) 11311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 11411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert/* Get the less significant 32 bit int from a double. */ 11511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 11611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define GET_LOW_WORD(i,d) \ 11711cd02dfb91661c65134cac258cf5924270e9d2Dan Albertdo { \ 11811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ieee_double_shape_type gl_u; \ 11911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert gl_u.value = (d); \ 12011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert (i) = gl_u.parts.lsw; \ 12111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} while (0) 12211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 12311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert/* Set a double from two 32 bit ints. */ 12411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 12511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define INSERT_WORDS(d,ix0,ix1) \ 12611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertdo { \ 12711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ieee_double_shape_type iw_u; \ 12811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert iw_u.parts.msw = (ix0); \ 12911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert iw_u.parts.lsw = (ix1); \ 13011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert (d) = iw_u.value; \ 13111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} while (0) 13211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 13311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert/* Set a double from a 64-bit int. */ 13411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define INSERT_WORD64(d,ix) \ 13511cd02dfb91661c65134cac258cf5924270e9d2Dan Albertdo { \ 13611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ieee_double_shape_type iw_u; \ 13711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert iw_u.xparts.w = (ix); \ 13811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert (d) = iw_u.value; \ 13911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} while (0) 14011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 14111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert/* Set the more significant 32 bits of a double from an int. */ 14211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 14311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define SET_HIGH_WORD(d,v) \ 14411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertdo { \ 14511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ieee_double_shape_type sh_u; \ 14611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert sh_u.value = (d); \ 14711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert sh_u.parts.msw = (v); \ 14811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert (d) = sh_u.value; \ 14911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} while (0) 15011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 15111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert/* Set the less significant 32 bits of a double from an int. */ 15211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 15311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define SET_LOW_WORD(d,v) \ 15411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertdo { \ 15511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ieee_double_shape_type sl_u; \ 15611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert sl_u.value = (d); \ 15711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert sl_u.parts.lsw = (v); \ 15811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert (d) = sl_u.value; \ 15911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} while (0) 16011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 16111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert/* 16211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * A union which permits us to convert between a float and a 32 bit 16311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * int. 16411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert */ 16511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 16611cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttypedef union 16711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert{ 16811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert float value; 16911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert /* FIXME: Assumes 32 bit int. */ 17011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert unsigned int word; 17111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} ieee_float_shape_type; 17211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 17311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert/* Get a 32 bit int from a float. */ 17411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 17511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define GET_FLOAT_WORD(i,d) \ 17611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertdo { \ 17711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ieee_float_shape_type gf_u; \ 17811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert gf_u.value = (d); \ 17911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert (i) = gf_u.word; \ 18011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} while (0) 18111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 18211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert/* Set a float from a 32 bit int. */ 18311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 18411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define SET_FLOAT_WORD(d,i) \ 18511cd02dfb91661c65134cac258cf5924270e9d2Dan Albertdo { \ 18611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ieee_float_shape_type sf_u; \ 18711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert sf_u.word = (i); \ 18811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert (d) = sf_u.value; \ 18911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} while (0) 19011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 19111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert/* 19211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * Get expsign and mantissa as 16 bit and 64 bit ints from an 80 bit long 19311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * double. 19411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert */ 19511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 19611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define EXTRACT_LDBL80_WORDS(ix0,ix1,d) \ 19711cd02dfb91661c65134cac258cf5924270e9d2Dan Albertdo { \ 19811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert union IEEEl2bits ew_u; \ 19911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ew_u.e = (d); \ 20011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert (ix0) = ew_u.xbits.expsign; \ 20111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert (ix1) = ew_u.xbits.man; \ 20211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} while (0) 20311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 20411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert/* 20511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * Get expsign and mantissa as one 16 bit and two 64 bit ints from a 128 bit 20611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * long double. 20711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert */ 20811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 20911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define EXTRACT_LDBL128_WORDS(ix0,ix1,ix2,d) \ 21011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertdo { \ 21111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert union IEEEl2bits ew_u; \ 21211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ew_u.e = (d); \ 21311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert (ix0) = ew_u.xbits.expsign; \ 21411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert (ix1) = ew_u.xbits.manh; \ 21511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert (ix2) = ew_u.xbits.manl; \ 21611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} while (0) 21711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 21811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert/* Get expsign as a 16 bit int from a long double. */ 21911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 22011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define GET_LDBL_EXPSIGN(i,d) \ 22111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertdo { \ 22211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert union IEEEl2bits ge_u; \ 22311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ge_u.e = (d); \ 22411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert (i) = ge_u.xbits.expsign; \ 22511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} while (0) 22611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 22711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert/* 22811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * Set an 80 bit long double from a 16 bit int expsign and a 64 bit int 22911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * mantissa. 23011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert */ 23111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 23211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define INSERT_LDBL80_WORDS(d,ix0,ix1) \ 23311cd02dfb91661c65134cac258cf5924270e9d2Dan Albertdo { \ 23411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert union IEEEl2bits iw_u; \ 23511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert iw_u.xbits.expsign = (ix0); \ 23611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert iw_u.xbits.man = (ix1); \ 23711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert (d) = iw_u.e; \ 23811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} while (0) 23911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 24011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert/* 24111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * Set a 128 bit long double from a 16 bit int expsign and two 64 bit ints 24211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * comprising the mantissa. 24311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert */ 24411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 24511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define INSERT_LDBL128_WORDS(d,ix0,ix1,ix2) \ 24611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertdo { \ 24711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert union IEEEl2bits iw_u; \ 24811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert iw_u.xbits.expsign = (ix0); \ 24911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert iw_u.xbits.manh = (ix1); \ 25011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert iw_u.xbits.manl = (ix2); \ 25111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert (d) = iw_u.e; \ 25211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} while (0) 25311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 25411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert/* Set expsign of a long double from a 16 bit int. */ 25511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 25611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define SET_LDBL_EXPSIGN(d,v) \ 25711cd02dfb91661c65134cac258cf5924270e9d2Dan Albertdo { \ 25811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert union IEEEl2bits se_u; \ 25911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert se_u.e = (d); \ 26011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert se_u.xbits.expsign = (v); \ 26111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert (d) = se_u.e; \ 26211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} while (0) 26311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 26411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#ifdef __i386__ 26511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert/* Long double constants are broken on i386. */ 26611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define LD80C(m, ex, v) { \ 26711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert .xbits.man = __CONCAT(m, ULL), \ 26811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert .xbits.expsign = (0x3fff + (ex)) | ((v) < 0 ? 0x8000 : 0), \ 26911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 27011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#else 27111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert/* The above works on non-i386 too, but we use this to check v. */ 27211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define LD80C(m, ex, v) { .e = (v), } 27311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 27411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 27511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#ifdef FLT_EVAL_METHOD 27611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert/* 27711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * Attempt to get strict C99 semantics for assignment with non-C99 compilers. 27811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert */ 27911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if FLT_EVAL_METHOD == 0 || __GNUC__ == 0 28011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define STRICT_ASSIGN(type, lval, rval) ((lval) = (rval)) 28111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#else 28211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define STRICT_ASSIGN(type, lval, rval) do { \ 28311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert volatile type __lval; \ 28411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert \ 28511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (sizeof(type) >= sizeof(long double)) \ 28611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert (lval) = (rval); \ 28711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert else { \ 28811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __lval = (rval); \ 28911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert (lval) = __lval; \ 29011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } \ 29111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} while (0) 29211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 29311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif /* FLT_EVAL_METHOD */ 29411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 29511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert/* Support switching the mode to FP_PE if necessary. */ 29611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if defined(__i386__) && !defined(NO_FPSETPREC) 29711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define ENTERI() \ 29811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert long double __retval; \ 29911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert fp_prec_t __oprec; \ 30011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert \ 30111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if ((__oprec = fpgetprec()) != FP_PE) \ 30211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert fpsetprec(FP_PE) 30311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define RETURNI(x) do { \ 30411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __retval = (x); \ 30511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__oprec != FP_PE) \ 30611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert fpsetprec(__oprec); \ 30711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert RETURNF(__retval); \ 30811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} while (0) 30911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#else 31011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define ENTERI(x) 31111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define RETURNI(x) RETURNF(x) 31211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 31311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 31411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert/* Default return statement if hack*_t() is not used. */ 31511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define RETURNF(v) return (v) 31611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 31711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert/* 31811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * 2sum gives the same result as 2sumF without requiring |a| >= |b| or 31911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * a == 0, but is slower. 32011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert */ 32111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define _2sum(a, b) do { \ 32211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __typeof(a) __s, __w; \ 32311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert \ 32411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __w = (a) + (b); \ 32511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __s = __w - (a); \ 32611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert (b) = ((a) - (__w - __s)) + ((b) - __s); \ 32711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert (a) = __w; \ 32811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} while (0) 32911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 33011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert/* 33111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * 2sumF algorithm. 33211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * 33311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * "Normalize" the terms in the infinite-precision expression a + b for 33411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * the sum of 2 floating point values so that b is as small as possible 33511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * relative to 'a'. (The resulting 'a' is the value of the expression in 33611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * the same precision as 'a' and the resulting b is the rounding error.) 33711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * |a| must be >= |b| or 0, b's type must be no larger than 'a's type, and 33811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * exponent overflow or underflow must not occur. This uses a Theorem of 33911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * Dekker (1971). See Knuth (1981) 4.2.2 Theorem C. The name "TwoSum" 34011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * is apparently due to Skewchuk (1997). 34111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * 34211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * For this to always work, assignment of a + b to 'a' must not retain any 34311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * extra precision in a + b. This is required by C standards but broken 34411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * in many compilers. The brokenness cannot be worked around using 34511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * STRICT_ASSIGN() like we do elsewhere, since the efficiency of this 34611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * algorithm would be destroyed by non-null strict assignments. (The 34711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * compilers are correct to be broken -- the efficiency of all floating 34811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * point code calculations would be destroyed similarly if they forced the 34911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * conversions.) 35011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * 35111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * Fortunately, a case that works well can usually be arranged by building 35211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * any extra precision into the type of 'a' -- 'a' should have type float_t, 35311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * double_t or long double. b's type should be no larger than 'a's type. 35411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * Callers should use these types with scopes as large as possible, to 35511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * reduce their own extra-precision and efficiciency problems. In 35611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * particular, they shouldn't convert back and forth just to call here. 35711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert */ 35811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#ifdef DEBUG 35911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define _2sumF(a, b) do { \ 36011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __typeof(a) __w; \ 36111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert volatile __typeof(a) __ia, __ib, __r, __vw; \ 36211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert \ 36311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __ia = (a); \ 36411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __ib = (b); \ 36511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(__ia == 0 || fabsl(__ia) >= fabsl(__ib)); \ 36611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert \ 36711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __w = (a) + (b); \ 36811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert (b) = ((a) - __w) + (b); \ 36911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert (a) = __w; \ 37011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert \ 37111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert /* The next 2 assertions are weak if (a) is already long double. */ \ 37211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert((long double)__ia + __ib == (long double)(a) + (b)); \ 37311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __vw = __ia + __ib; \ 37411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __r = __ia - __vw; \ 37511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __r += __ib; \ 37611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(__vw == (a) && __r == (b)); \ 37711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} while (0) 37811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#else /* !DEBUG */ 37911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define _2sumF(a, b) do { \ 38011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __typeof(a) __w; \ 38111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert \ 38211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __w = (a) + (b); \ 38311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert (b) = ((a) - __w) + (b); \ 38411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert (a) = __w; \ 38511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} while (0) 38611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif /* DEBUG */ 38711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 38811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert/* 38911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * Set x += c, where x is represented in extra precision as a + b. 39011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * x must be sufficiently normalized and sufficiently larger than c, 39111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * and the result is then sufficiently normalized. 39211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * 39311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * The details of ordering are that |a| must be >= |c| (so that (a, c) 39411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * can be normalized without extra work to swap 'a' with c). The details of 39511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * the normalization are that b must be small relative to the normalized 'a'. 39611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * Normalization of (a, c) makes the normalized c tiny relative to the 39711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * normalized a, so b remains small relative to 'a' in the result. However, 39811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * b need not ever be tiny relative to 'a'. For example, b might be about 39911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * 2**20 times smaller than 'a' to give about 20 extra bits of precision. 40011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * That is usually enough, and adding c (which by normalization is about 40111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * 2**53 times smaller than a) cannot change b significantly. However, 40211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * cancellation of 'a' with c in normalization of (a, c) may reduce 'a' 40311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * significantly relative to b. The caller must ensure that significant 40411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * cancellation doesn't occur, either by having c of the same sign as 'a', 40511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * or by having |c| a few percent smaller than |a|. Pre-normalization of 40611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * (a, b) may help. 40711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * 40811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * This is is a variant of an algorithm of Kahan (see Knuth (1981) 4.2.2 40911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * exercise 19). We gain considerable efficiency by requiring the terms to 41011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * be sufficiently normalized and sufficiently increasing. 41111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert */ 41211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define _3sumF(a, b, c) do { \ 41311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __typeof(a) __tmp; \ 41411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert \ 41511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp = (c); \ 41611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _2sumF(__tmp, (a)); \ 41711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert (b) += (a); \ 41811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert (a) = __tmp; \ 41911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} while (0) 42011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 42111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert/* 42211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * Common routine to process the arguments to nan(), nanf(), and nanl(). 42311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert */ 42411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertvoid _scan_nan(uint32_t *__words, int __num_words, const char *__s); 42511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 42611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#ifdef _COMPLEX_H 42711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 42811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert/* 42911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * C99 specifies that complex numbers have the same representation as 43011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * an array of two elements, where the first element is the real part 43111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * and the second element is the imaginary part. 43211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert */ 43311cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttypedef union { 43411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert float complex f; 43511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert float a[2]; 43611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} float_complex; 43711cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttypedef union { 43811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert double complex f; 43911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert double a[2]; 44011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} double_complex; 44111cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttypedef union { 44211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert long double complex f; 44311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert long double a[2]; 44411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} long_double_complex; 44511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define REALPART(z) ((z).a[0]) 44611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define IMAGPART(z) ((z).a[1]) 44711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 44811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert/* 44911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * Inline functions that can be used to construct complex values. 45011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * 45111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * The C99 standard intends x+I*y to be used for this, but x+I*y is 45211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * currently unusable in general since gcc introduces many overflow, 45311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * underflow, sign and efficiency bugs by rewriting I*y as 45411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * (0.0+I)*(y+0.0*I) and laboriously computing the full complex product. 45511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * In particular, I*Inf is corrupted to NaN+I*Inf, and I*-0 is corrupted 45611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * to -0.0+I*0.0. 45711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert */ 45811cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic __inline float complex 45911cd02dfb91661c65134cac258cf5924270e9d2Dan Albertcpackf(float x, float y) 46011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert{ 46111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert float_complex z; 46211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 46311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert REALPART(z) = x; 46411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert IMAGPART(z) = y; 46511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return (z.f); 46611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 46711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 46811cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic __inline double complex 46911cd02dfb91661c65134cac258cf5924270e9d2Dan Albertcpack(double x, double y) 47011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert{ 47111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert double_complex z; 47211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 47311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert REALPART(z) = x; 47411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert IMAGPART(z) = y; 47511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return (z.f); 47611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 47711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 47811cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic __inline long double complex 47911cd02dfb91661c65134cac258cf5924270e9d2Dan Albertcpackl(long double x, long double y) 48011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert{ 48111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert long_double_complex z; 48211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 48311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert REALPART(z) = x; 48411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert IMAGPART(z) = y; 48511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return (z.f); 48611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 48711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif /* _COMPLEX_H */ 48811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 48911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#ifdef __GNUCLIKE_ASM 49011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 49111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert/* Asm versions of some functions. */ 49211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 49311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#ifdef __amd64__ 49411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic __inline int 49511cd02dfb91661c65134cac258cf5924270e9d2Dan Albertirint(double x) 49611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert{ 49711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int n; 49811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 49911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert asm("cvtsd2si %1,%0" : "=r" (n) : "x" (x)); 50011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return (n); 50111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 50211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define HAVE_EFFICIENT_IRINT 50311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 50411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 50511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#ifdef __i386__ 50611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic __inline int 50711cd02dfb91661c65134cac258cf5924270e9d2Dan Albertirint(double x) 50811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert{ 50911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int n; 51011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 51111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert asm("fistl %0" : "=m" (n) : "t" (x)); 51211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return (n); 51311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 51411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define HAVE_EFFICIENT_IRINT 51511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 51611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 51711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if defined(__amd64__) || defined(__i386__) 51811cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic __inline int 51911cd02dfb91661c65134cac258cf5924270e9d2Dan Albertirintl(long double x) 52011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert{ 52111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int n; 52211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 52311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert asm("fistl %0" : "=m" (n) : "t" (x)); 52411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return (n); 52511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 52611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define HAVE_EFFICIENT_IRINTL 52711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 52811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 52911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif /* __GNUCLIKE_ASM */ 53011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 53111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#ifdef DEBUG 53211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if defined(__amd64__) || defined(__i386__) 53311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define breakpoint() asm("int $3") 53411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#else 53511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#include <signal.h> 53611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 53711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define breakpoint() raise(SIGTRAP) 53811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 53911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 54011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 54111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert/* Write a pari script to test things externally. */ 54211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#ifdef DOPRINT 54311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#include <stdio.h> 54411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 54511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#ifndef DOPRINT_SWIZZLE 54611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define DOPRINT_SWIZZLE 0 54711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 54811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 54911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#ifdef DOPRINT_LD80 55011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 55111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define DOPRINT_START(xp) do { \ 55211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert uint64_t __lx; \ 55311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert uint16_t __hx; \ 55411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert \ 55511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert /* Hack to give more-problematic args. */ \ 55611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXTRACT_LDBL80_WORDS(__hx, __lx, *xp); \ 55711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __lx ^= DOPRINT_SWIZZLE; \ 55811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert INSERT_LDBL80_WORDS(*xp, __hx, __lx); \ 55911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert printf("x = %.21Lg; ", (long double)*xp); \ 56011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} while (0) 56111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define DOPRINT_END1(v) \ 56211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert printf("y = %.21Lg; z = 0; show(x, y, z);\n", (long double)(v)) 56311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define DOPRINT_END2(hi, lo) \ 56411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert printf("y = %.21Lg; z = %.21Lg; show(x, y, z);\n", \ 56511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert (long double)(hi), (long double)(lo)) 56611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 56711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#elif defined(DOPRINT_D64) 56811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 56911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define DOPRINT_START(xp) do { \ 57011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert uint32_t __hx, __lx; \ 57111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert \ 57211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXTRACT_WORDS(__hx, __lx, *xp); \ 57311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __lx ^= DOPRINT_SWIZZLE; \ 57411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert INSERT_WORDS(*xp, __hx, __lx); \ 57511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert printf("x = %.21Lg; ", (long double)*xp); \ 57611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} while (0) 57711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define DOPRINT_END1(v) \ 57811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert printf("y = %.21Lg; z = 0; show(x, y, z);\n", (long double)(v)) 57911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define DOPRINT_END2(hi, lo) \ 58011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert printf("y = %.21Lg; z = %.21Lg; show(x, y, z);\n", \ 58111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert (long double)(hi), (long double)(lo)) 58211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 58311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#elif defined(DOPRINT_F32) 58411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 58511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define DOPRINT_START(xp) do { \ 58611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert uint32_t __hx; \ 58711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert \ 58811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GET_FLOAT_WORD(__hx, *xp); \ 58911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __hx ^= DOPRINT_SWIZZLE; \ 59011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert SET_FLOAT_WORD(*xp, __hx); \ 59111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert printf("x = %.21Lg; ", (long double)*xp); \ 59211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} while (0) 59311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define DOPRINT_END1(v) \ 59411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert printf("y = %.21Lg; z = 0; show(x, y, z);\n", (long double)(v)) 59511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define DOPRINT_END2(hi, lo) \ 59611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert printf("y = %.21Lg; z = %.21Lg; show(x, y, z);\n", \ 59711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert (long double)(hi), (long double)(lo)) 59811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 59911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#else /* !DOPRINT_LD80 && !DOPRINT_D64 (LD128 only) */ 60011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 60111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#ifndef DOPRINT_SWIZZLE_HIGH 60211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define DOPRINT_SWIZZLE_HIGH 0 60311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 60411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 60511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define DOPRINT_START(xp) do { \ 60611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert uint64_t __lx, __llx; \ 60711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert uint16_t __hx; \ 60811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert \ 60911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXTRACT_LDBL128_WORDS(__hx, __lx, __llx, *xp); \ 61011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __llx ^= DOPRINT_SWIZZLE; \ 61111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __lx ^= DOPRINT_SWIZZLE_HIGH; \ 61211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert INSERT_LDBL128_WORDS(*xp, __hx, __lx, __llx); \ 61311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert printf("x = %.36Lg; ", (long double)*xp); \ 61411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} while (0) 61511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define DOPRINT_END1(v) \ 61611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert printf("y = %.36Lg; z = 0; show(x, y, z);\n", (long double)(v)) 61711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define DOPRINT_END2(hi, lo) \ 61811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert printf("y = %.36Lg; z = %.36Lg; show(x, y, z);\n", \ 61911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert (long double)(hi), (long double)(lo)) 62011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 62111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif /* DOPRINT_LD80 */ 62211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 62311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#else /* !DOPRINT */ 62411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define DOPRINT_START(xp) 62511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define DOPRINT_END1(v) 62611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define DOPRINT_END2(hi, lo) 62711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif /* DOPRINT */ 62811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 62911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define RETURNP(x) do { \ 63011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert DOPRINT_END1(x); \ 63111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert RETURNF(x); \ 63211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} while (0) 63311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define RETURNPI(x) do { \ 63411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert DOPRINT_END1(x); \ 63511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert RETURNI(x); \ 63611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} while (0) 63711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define RETURN2P(x, y) do { \ 63811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert DOPRINT_END2((x), (y)); \ 63911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert RETURNF((x) + (y)); \ 64011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} while (0) 64111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define RETURN2PI(x, y) do { \ 64211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert DOPRINT_END2((x), (y)); \ 64311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert RETURNI((x) + (y)); \ 64411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} while (0) 64511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#ifdef STRUCT_RETURN 64611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define RETURNSP(rp) do { \ 64711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (!(rp)->lo_set) \ 64811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert RETURNP((rp)->hi); \ 64911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert RETURN2P((rp)->hi, (rp)->lo); \ 65011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} while (0) 65111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define RETURNSPI(rp) do { \ 65211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (!(rp)->lo_set) \ 65311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert RETURNPI((rp)->hi); \ 65411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert RETURN2PI((rp)->hi, (rp)->lo); \ 65511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} while (0) 65611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 65711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define SUM2P(x, y) ({ \ 65811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const __typeof (x) __x = (x); \ 65911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const __typeof (y) __y = (y); \ 66011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert \ 66111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert DOPRINT_END2(__x, __y); \ 66211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __x + __y; \ 66311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}) 66411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 66511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert/* 66611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * ieee style elementary functions 66711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * 66811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * We rename functions here to improve other sources' diffability 66911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * against fdlibm. 67011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert */ 67111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define __ieee754_sqrt sqrt 67211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define __ieee754_acos acos 67311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define __ieee754_acosh acosh 67411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define __ieee754_log log 67511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define __ieee754_log2 log2 67611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define __ieee754_atanh atanh 67711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define __ieee754_asin asin 67811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define __ieee754_atan2 atan2 67911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define __ieee754_exp exp 68011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define __ieee754_cosh cosh 68111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define __ieee754_fmod fmod 68211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define __ieee754_pow pow 68311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define __ieee754_lgamma lgamma 68411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define __ieee754_gamma gamma 68511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define __ieee754_lgamma_r lgamma_r 68611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define __ieee754_gamma_r gamma_r 68711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define __ieee754_log10 log10 68811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define __ieee754_sinh sinh 68911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define __ieee754_hypot hypot 69011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define __ieee754_j0 j0 69111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define __ieee754_j1 j1 69211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define __ieee754_y0 y0 69311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define __ieee754_y1 y1 69411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define __ieee754_jn jn 69511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define __ieee754_yn yn 69611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define __ieee754_remainder remainder 69711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define __ieee754_scalb scalb 69811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define __ieee754_sqrtf sqrtf 69911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define __ieee754_acosf acosf 70011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define __ieee754_acoshf acoshf 70111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define __ieee754_logf logf 70211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define __ieee754_atanhf atanhf 70311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define __ieee754_asinf asinf 70411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define __ieee754_atan2f atan2f 70511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define __ieee754_expf expf 70611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define __ieee754_coshf coshf 70711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define __ieee754_fmodf fmodf 70811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define __ieee754_powf powf 70911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define __ieee754_lgammaf lgammaf 71011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define __ieee754_gammaf gammaf 71111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define __ieee754_lgammaf_r lgammaf_r 71211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define __ieee754_gammaf_r gammaf_r 71311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define __ieee754_log10f log10f 71411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define __ieee754_log2f log2f 71511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define __ieee754_sinhf sinhf 71611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define __ieee754_hypotf hypotf 71711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define __ieee754_j0f j0f 71811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define __ieee754_j1f j1f 71911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define __ieee754_y0f y0f 72011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define __ieee754_y1f y1f 72111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define __ieee754_jnf jnf 72211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define __ieee754_ynf ynf 72311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define __ieee754_remainderf remainderf 72411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define __ieee754_scalbf scalbf 72511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 72611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert/* fdlibm kernel function */ 72711cd02dfb91661c65134cac258cf5924270e9d2Dan Albertint __kernel_rem_pio2(double*,double*,int,int,int); 72811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 72911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert/* double precision kernel functions */ 73011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#ifndef INLINE_REM_PIO2 73111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertint __ieee754_rem_pio2(double,double*); 73211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 73311cd02dfb91661c65134cac258cf5924270e9d2Dan Albertdouble __kernel_sin(double,double,int); 73411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertdouble __kernel_cos(double,double); 73511cd02dfb91661c65134cac258cf5924270e9d2Dan Albertdouble __kernel_tan(double,double,int); 73611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertdouble __ldexp_exp(double,int); 73711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#ifdef _COMPLEX_H 73811cd02dfb91661c65134cac258cf5924270e9d2Dan Albertdouble complex __ldexp_cexp(double complex,int); 73911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 74011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 74111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert/* float precision kernel functions */ 74211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#ifndef INLINE_REM_PIO2F 74311cd02dfb91661c65134cac258cf5924270e9d2Dan Albertint __ieee754_rem_pio2f(float,double*); 74411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 74511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#ifndef INLINE_KERNEL_SINDF 74611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertfloat __kernel_sindf(double); 74711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 74811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#ifndef INLINE_KERNEL_COSDF 74911cd02dfb91661c65134cac258cf5924270e9d2Dan Albertfloat __kernel_cosdf(double); 75011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 75111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#ifndef INLINE_KERNEL_TANDF 75211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertfloat __kernel_tandf(double,int); 75311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 75411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertfloat __ldexp_expf(float,int); 75511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#ifdef _COMPLEX_H 75611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertfloat complex __ldexp_cexpf(float complex,int); 75711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 75811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 75911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert/* long double precision kernel functions */ 76011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertlong double __kernel_sinl(long double, long double, int); 76111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertlong double __kernel_cosl(long double, long double); 76211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertlong double __kernel_tanl(long double, long double, int); 76311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 76411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif /* !_MATH_PRIVATE_H_ */ 765