From 42177873f82a0530f4c3cc7ecbcc6e2f145630b6 Mon Sep 17 00:00:00 2001 From: Ed Schouten Date: Sat, 10 Jan 2015 09:41:32 +0100 Subject: [PATCH 1/6] Remove weak reference construct from fenv code. I grepped through the FreeBSD source tree and for me, it seems to be totally unclear why these two specific functions are weak references. Such a construct is commonly used by FreeBSD's threading library (libthr) to override certain functions, but I can't find any traces of that. Just use the function name directly. This fixes a compiler warning as well (-Wmissing-prototypes). --- amd64/fenv.c | 7 ++----- i387/fenv.c | 7 ++----- 2 files changed, 4 insertions(+), 10 deletions(-) diff --git a/amd64/fenv.c b/amd64/fenv.c index 63b0680..0ed84c2 100644 --- a/amd64/fenv.c +++ b/amd64/fenv.c @@ -128,7 +128,7 @@ feupdateenv(const fenv_t *envp) } int -__feenableexcept(int mask) +feenableexcept(int mask) { uint32_t mxcsr, omask; uint16_t control; @@ -145,7 +145,7 @@ __feenableexcept(int mask) } int -__fedisableexcept(int mask) +fedisableexcept(int mask) { uint32_t mxcsr, omask; uint16_t control; @@ -160,6 +160,3 @@ __fedisableexcept(int mask) __ldmxcsr(mxcsr); return (omask); } - -__weak_reference(__feenableexcept, feenableexcept); -__weak_reference(__fedisableexcept, fedisableexcept); diff --git a/i387/fenv.c b/i387/fenv.c index 5ad4de6..b6b26f7 100644 --- a/i387/fenv.c +++ b/i387/fenv.c @@ -182,7 +182,7 @@ feupdateenv(const fenv_t *envp) } int -__feenableexcept(int mask) +feenableexcept(int mask) { uint32_t mxcsr, omask; uint16_t control; @@ -204,7 +204,7 @@ __feenableexcept(int mask) } int -__fedisableexcept(int mask) +fedisableexcept(int mask) { uint32_t mxcsr, omask; uint16_t control; @@ -224,6 +224,3 @@ __fedisableexcept(int mask) } return (omask); } - -__weak_reference(__feenableexcept, feenableexcept); -__weak_reference(__fedisableexcept, fedisableexcept); From 9fdc4f9d9ec40a143e63a882cdb678ddcb252dcf Mon Sep 17 00:00:00 2001 From: Ed Schouten Date: Sat, 10 Jan 2015 09:44:31 +0100 Subject: [PATCH 2/6] Fix a small number of -Wmissing-prototypes compiler warnings in sincos(). - Add missing prototypes to openlibm.h for sincos() and sincosf(). - Mark the internal kernel functions static. --- src/openlibm.h | 15 +++++++++++++++ src/s_sincos.c | 2 +- src/s_sincosf.c | 2 +- 3 files changed, 17 insertions(+), 2 deletions(-) diff --git a/src/openlibm.h b/src/openlibm.h index 74fc3a7..513ad4d 100644 --- a/src/openlibm.h +++ b/src/openlibm.h @@ -315,6 +315,11 @@ int isnanf(float) __pure2; double gamma_r(double, int *); double lgamma_r(double, int *); +/* + * Single sine/cosine function. + */ +void sincos(double, double *, double *); + /* * IEEE Test Vector */ @@ -411,6 +416,11 @@ float ynf(int, float); float gammaf_r(float, int *); float lgammaf_r(float, int *); +/* + * Single sine/cosine function. + */ +void sincosf(float, float *, float *); + /* * float version of IEEE Test Vector */ @@ -485,6 +495,11 @@ long double truncl(long double); /* Reentrant version of lgammal. */ #if __BSD_VISIBLE long double lgammal_r(long double, int *); + +/* + * Single sine/cosine function. + */ +void sincosl(long double, long double *, long double *); #endif /* __BSD_VISIBLE */ #if defined(__cplusplus) diff --git a/src/s_sincos.c b/src/s_sincos.c index a6b7cab..9960ee6 100644 --- a/src/s_sincos.c +++ b/src/s_sincos.c @@ -58,7 +58,7 @@ C4 = -2.75573143513906633035e-07, /* 0xBE927E4F, 0x809C52AD */ C5 = 2.08757232129817482790e-09, /* 0x3E21EE9E, 0xBDB4B1C4 */ C6 = -1.13596475577881948265e-11; /* 0xBDA8FAE9, 0xBE8838D4 */ -DLLEXPORT void +static void __kernel_sincos( double x, double y, int iy, double * k_s, double * k_c ) { /* Inline calculation of sin/cos, as we can save diff --git a/src/s_sincosf.c b/src/s_sincosf.c index 8908ae6..6be7895 100644 --- a/src/s_sincosf.c +++ b/src/s_sincosf.c @@ -41,7 +41,7 @@ C1 = 0x155553e1053a42.0p-57, /* 0.0416666233237390631894 */ C2 = -0x16c087e80f1e27.0p-62, /* -0.00138867637746099294692 */ C3 = 0x199342e0ee5069.0p-68; /* 0.0000243904487962774090654 */ -DLLEXPORT void +static void __kernel_sincosdf( double x, float * s, float * c ) { double r, w, z, v; From c253db68caea45ee56b7d35e93bb2945b98ddf5b Mon Sep 17 00:00:00 2001 From: Ed Schouten Date: Sat, 10 Jan 2015 09:57:33 +0100 Subject: [PATCH 3/6] Add a new compilation flag: OPENLIBM_ONLY_THREAD_SAFE. The global signgam variable is only part of the X/Open System Interfaces. It is not part of the POSIX base definitions nor the C standard. I'd rather have it disabled for my specific use-case, so introduce a new compilation flag that we can use to disable it. --- src/e_gamma.c | 6 ++++-- src/e_gammaf.c | 6 ++++-- src/e_lgamma.c | 6 ++++-- src/e_lgammaf.c | 6 ++++-- src/e_lgammal.c | 5 +++-- src/openlibm.h | 3 +++ src/s_signgam.c | 2 ++ 7 files changed, 24 insertions(+), 10 deletions(-) diff --git a/src/e_gamma.c b/src/e_gamma.c index ff7b257..3c3e97c 100644 --- a/src/e_gamma.c +++ b/src/e_gamma.c @@ -25,10 +25,12 @@ #include "math_private.h" -extern int signgam; - DLLEXPORT double __ieee754_gamma(double x) { +#ifdef OPENLIBM_ONLY_THREAD_SAFE + int signgam; +#endif + return __ieee754_gamma_r(x,&signgam); } diff --git a/src/e_gammaf.c b/src/e_gammaf.c index 465efb4..1cb2c74 100644 --- a/src/e_gammaf.c +++ b/src/e_gammaf.c @@ -26,10 +26,12 @@ #include "math_private.h" -extern int signgam; - DLLEXPORT float __ieee754_gammaf(float x) { +#ifdef OPENLIBM_ONLY_THREAD_SAFE + int signgam; +#endif + return __ieee754_gammaf_r(x,&signgam); } diff --git a/src/e_lgamma.c b/src/e_lgamma.c index da25f44..4dd5a0d 100644 --- a/src/e_lgamma.c +++ b/src/e_lgamma.c @@ -25,10 +25,12 @@ #include "math_private.h" -extern int signgam; - DLLEXPORT double __ieee754_lgamma(double x) { +#ifdef OPENLIBM_ONLY_THREAD_SAFE + int signgam; +#endif + return __ieee754_lgamma_r(x,&signgam); } diff --git a/src/e_lgammaf.c b/src/e_lgammaf.c index 922be5a..40e7059 100644 --- a/src/e_lgammaf.c +++ b/src/e_lgammaf.c @@ -26,10 +26,12 @@ #include "math_private.h" -extern int signgam; - DLLEXPORT float __ieee754_lgammaf(float x) { +#ifdef OPENLIBM_ONLY_THREAD_SAFE + int signgam; +#endif + return __ieee754_lgammaf_r(x,&signgam); } diff --git a/src/e_lgammal.c b/src/e_lgammal.c index 2e68630..5ae5761 100644 --- a/src/e_lgammal.c +++ b/src/e_lgammal.c @@ -4,11 +4,12 @@ #include "math_private.h" -extern int signgam; - DLLEXPORT long double lgammal(long double x) { +#ifdef OPENLIBM_ONLY_THREAD_SAFE + int signgam; +#endif return (lgammal_r(x, &signgam)); } diff --git a/src/openlibm.h b/src/openlibm.h index 513ad4d..ca704c7 100644 --- a/src/openlibm.h +++ b/src/openlibm.h @@ -170,7 +170,10 @@ extern const union __nan_un { #define M_SQRT1_2 0.70710678118654752440 /* 1/sqrt(2) */ #define MAXFLOAT ((float)3.40282346638528860e+38) + +#ifndef OPENLIBM_ONLY_THREAD_SAFE extern int signgam; +#endif #endif /* __BSD_VISIBLE || __XSI_VISIBLE */ #if __BSD_VISIBLE diff --git a/src/s_signgam.c b/src/s_signgam.c index 7e197a0..1557899 100644 --- a/src/s_signgam.c +++ b/src/s_signgam.c @@ -2,4 +2,6 @@ #include "math_private.h" +#ifndef OPENLIBM_ONLY_THREAD_SAFE int signgam = 0; +#endif From 9ab9db387d84f7ae489fd87a04f0e13c0c63c0e3 Mon Sep 17 00:00:00 2001 From: Ed Schouten Date: Sat, 10 Jan 2015 10:04:11 +0100 Subject: [PATCH 4/6] Don't use __weak_reference() when a __strong_reference() is needed. OpenLibm uses the __weak_reference() macro for platforms where double and long double use the same layout. That way functions only need to be provided by the library once. The point is, in this specific case we want to use strong references; not weak references. Strong references can be used to give a symbol a second name. If you look at the resulting object file, you will have two symbols with the same offset and size. Weak references are different, in the sense that they are marked in such a way that they act as fallbacks. They are only used if an explicitly matching symbol is missing. --- src/e_acos.c | 2 +- src/e_asin.c | 2 +- src/e_atan2.c | 2 +- src/e_hypot.c | 2 +- src/e_remainder.c | 2 +- src/e_sqrt.c | 2 +- src/s_atan.c | 2 +- src/s_cbrt.c | 2 +- src/s_ceil.c | 2 +- src/s_cos.c | 2 +- src/s_cproj.c | 2 +- src/s_csqrt.c | 2 +- src/s_exp2.c | 2 +- src/s_floor.c | 2 +- src/s_fma.c | 2 +- src/s_frexp.c | 2 +- src/s_isinf.c | 2 +- src/s_isnan.c | 2 +- src/s_logb.c | 2 +- src/s_nan.c | 2 +- src/s_nextafter.c | 6 +++--- src/s_remquo.c | 2 +- src/s_rint.c | 2 +- src/s_scalbn.c | 4 ++-- src/s_sin.c | 2 +- src/s_sincos.c | 2 +- src/s_tan.c | 2 +- src/s_trunc.c | 2 +- src/w_cabs.c | 2 +- 29 files changed, 32 insertions(+), 32 deletions(-) diff --git a/src/e_acos.c b/src/e_acos.c index bf07b54..0d2d4df 100644 --- a/src/e_acos.c +++ b/src/e_acos.c @@ -107,5 +107,5 @@ __ieee754_acos(double x) } #if LDBL_MANT_DIG == 53 -__weak_reference(acos, acosl); +__strong_reference(acos, acosl); #endif diff --git a/src/e_asin.c b/src/e_asin.c index 67d1d0f..8da0628 100644 --- a/src/e_asin.c +++ b/src/e_asin.c @@ -113,5 +113,5 @@ __ieee754_asin(double x) } #if LDBL_MANT_DIG == 53 -__weak_reference(asin, asinl); +__strong_reference(asin, asinl); #endif diff --git a/src/e_atan2.c b/src/e_atan2.c index bf5b15c..df95b05 100644 --- a/src/e_atan2.c +++ b/src/e_atan2.c @@ -125,5 +125,5 @@ __ieee754_atan2(double y, double x) } #if LDBL_MANT_DIG == 53 -__weak_reference(atan2, atan2l); +__strong_reference(atan2, atan2l); #endif diff --git a/src/e_hypot.c b/src/e_hypot.c index 058a9fd..c33cf72 100644 --- a/src/e_hypot.c +++ b/src/e_hypot.c @@ -127,5 +127,5 @@ __ieee754_hypot(double x, double y) } #if LDBL_MANT_DIG == 53 -__weak_reference(hypot, hypotl); +__strong_reference(hypot, hypotl); #endif diff --git a/src/e_remainder.c b/src/e_remainder.c index cc1e4c5..6ac459c 100644 --- a/src/e_remainder.c +++ b/src/e_remainder.c @@ -75,5 +75,5 @@ __ieee754_remainder(double x, double p) } #if LDBL_MANT_DIG == 53 -__weak_reference(remainder, remainderl); +__strong_reference(remainder, remainderl); #endif diff --git a/src/e_sqrt.c b/src/e_sqrt.c index f89b852..9edbb58 100644 --- a/src/e_sqrt.c +++ b/src/e_sqrt.c @@ -189,7 +189,7 @@ __ieee754_sqrt(double x) } #if (LDBL_MANT_DIG == 53) -__weak_reference(sqrt, sqrtl); +__strong_reference(sqrt, sqrtl); #endif /* diff --git a/src/s_atan.c b/src/s_atan.c index 9a08b9f..075c730 100644 --- a/src/s_atan.c +++ b/src/s_atan.c @@ -120,5 +120,5 @@ atan(double x) } #if LDBL_MANT_DIG == 53 -__weak_reference(atan, atanl); +__strong_reference(atan, atanl); #endif diff --git a/src/s_cbrt.c b/src/s_cbrt.c index 17a64a4..8099e99 100644 --- a/src/s_cbrt.c +++ b/src/s_cbrt.c @@ -114,5 +114,5 @@ cbrt(double x) } #if (LDBL_MANT_DIG == 53) -__weak_reference(cbrt, cbrtl); +__strong_reference(cbrt, cbrtl); #endif diff --git a/src/s_ceil.c b/src/s_ceil.c index 93ce46b..e12204a 100644 --- a/src/s_ceil.c +++ b/src/s_ceil.c @@ -73,5 +73,5 @@ ceil(double x) } #if LDBL_MANT_DIG == 53 -__weak_reference(ceil, ceill); +__strong_reference(ceil, ceill); #endif diff --git a/src/s_cos.c b/src/s_cos.c index 63e52a3..7af2aa6 100644 --- a/src/s_cos.c +++ b/src/s_cos.c @@ -85,5 +85,5 @@ cos(double x) } #if (LDBL_MANT_DIG == 53) -__weak_reference(cos, cosl); +__strong_reference(cos, cosl); #endif diff --git a/src/s_cproj.c b/src/s_cproj.c index 7b9e131..4549961 100644 --- a/src/s_cproj.c +++ b/src/s_cproj.c @@ -43,5 +43,5 @@ cproj(double complex z) } #if LDBL_MANT_DIG == 53 -__weak_reference(cproj, cprojl); +__strong_reference(cproj, cprojl); #endif diff --git a/src/s_csqrt.c b/src/s_csqrt.c index e0633bd..09c01f3 100644 --- a/src/s_csqrt.c +++ b/src/s_csqrt.c @@ -110,5 +110,5 @@ csqrt(double complex z) } #if LDBL_MANT_DIG == 53 -__weak_reference(csqrt, csqrtl); +__strong_reference(csqrt, csqrtl); #endif diff --git a/src/s_exp2.c b/src/s_exp2.c index e1863f5..293117c 100644 --- a/src/s_exp2.c +++ b/src/s_exp2.c @@ -392,5 +392,5 @@ exp2(double x) } #if (LDBL_MANT_DIG == 53) -__weak_reference(exp2, exp2l); +__strong_reference(exp2, exp2l); #endif diff --git a/src/s_floor.c b/src/s_floor.c index 6825492..22d98ca 100644 --- a/src/s_floor.c +++ b/src/s_floor.c @@ -74,5 +74,5 @@ floor(double x) } #if LDBL_MANT_DIG == 53 -__weak_reference(floor, floorl); +__strong_reference(floor, floorl); #endif diff --git a/src/s_fma.c b/src/s_fma.c index 7fa8ba3..b24cb7d 100644 --- a/src/s_fma.c +++ b/src/s_fma.c @@ -280,5 +280,5 @@ fma(double x, double y, double z) } #if (LDBL_MANT_DIG == 53) -__weak_reference(fma, fmal); +__strong_reference(fma, fmal); #endif diff --git a/src/s_frexp.c b/src/s_frexp.c index c836375..2406c13 100644 --- a/src/s_frexp.c +++ b/src/s_frexp.c @@ -52,5 +52,5 @@ frexp(double x, int *eptr) } #if (LDBL_MANT_DIG == 53) -__weak_reference(frexp, frexpl); +__strong_reference(frexp, frexpl); #endif diff --git a/src/s_isinf.c b/src/s_isinf.c index 041c4ec..3a1c685 100644 --- a/src/s_isinf.c +++ b/src/s_isinf.c @@ -62,4 +62,4 @@ __isinfl(long double e) } #endif -__weak_reference(__isinff, isinff); +__strong_reference(__isinff, isinff); diff --git a/src/s_isnan.c b/src/s_isnan.c index 21f4f64..7482357 100644 --- a/src/s_isnan.c +++ b/src/s_isnan.c @@ -63,4 +63,4 @@ __isnanl(long double e) } #endif -__weak_reference(__isnanf, isnanf); +__strong_reference(__isnanf, isnanf); diff --git a/src/s_logb.c b/src/s_logb.c index 9549301..8fb4ea8 100644 --- a/src/s_logb.c +++ b/src/s_logb.c @@ -45,5 +45,5 @@ logb(double x) } #if (LDBL_MANT_DIG == 53) -__weak_reference(logb, logbl); +__strong_reference(logb, logbl); #endif diff --git a/src/s_nan.c b/src/s_nan.c index ef8aad7..5a5d8e6 100644 --- a/src/s_nan.c +++ b/src/s_nan.c @@ -120,5 +120,5 @@ nanf(const char *s) } #if (LDBL_MANT_DIG == 53) -__weak_reference(nan, nanl); +__strong_reference(nan, nanl); #endif diff --git a/src/s_nextafter.c b/src/s_nextafter.c index 2e02a32..c0c2f39 100644 --- a/src/s_nextafter.c +++ b/src/s_nextafter.c @@ -77,7 +77,7 @@ nextafter(double x, double y) } #if (LDBL_MANT_DIG == 53) -__weak_reference(nextafter, nexttoward); -__weak_reference(nextafter, nexttowardl); -__weak_reference(nextafter, nextafterl); +__strong_reference(nextafter, nexttoward); +__strong_reference(nextafter, nexttowardl); +__strong_reference(nextafter, nextafterl); #endif diff --git a/src/s_remquo.c b/src/s_remquo.c index ca62639..3e759aa 100644 --- a/src/s_remquo.c +++ b/src/s_remquo.c @@ -154,5 +154,5 @@ fixup: } #if LDBL_MANT_DIG == 53 -__weak_reference(remquo, remquol); +__strong_reference(remquo, remquol); #endif diff --git a/src/s_rint.c b/src/s_rint.c index ba0e104..749bde7 100644 --- a/src/s_rint.c +++ b/src/s_rint.c @@ -88,5 +88,5 @@ rint(double x) } #if (LDBL_MANT_DIG == 53) -__weak_reference(rint, rintl); +__strong_reference(rint, rintl); #endif diff --git a/src/s_scalbn.c b/src/s_scalbn.c index 1071ac3..6e41cba 100644 --- a/src/s_scalbn.c +++ b/src/s_scalbn.c @@ -59,8 +59,8 @@ scalbn (double x, int n) } #if (LDBL_MANT_DIG == 53) -__weak_reference(scalbn, ldexpl); -__weak_reference(scalbn, scalbnl); +__strong_reference(scalbn, ldexpl); +__strong_reference(scalbn, scalbnl); #endif __strong_reference(scalbn, ldexp); diff --git a/src/s_sin.c b/src/s_sin.c index 9f50764..602188d 100644 --- a/src/s_sin.c +++ b/src/s_sin.c @@ -85,5 +85,5 @@ sin(double x) } #if (LDBL_MANT_DIG == 53) -__weak_reference(sin, sinl); +__strong_reference(sin, sinl); #endif diff --git a/src/s_sincos.c b/src/s_sincos.c index 9960ee6..2b1509b 100644 --- a/src/s_sincos.c +++ b/src/s_sincos.c @@ -146,5 +146,5 @@ sincos(double x, double * s, double * c) } #if (LDBL_MANT_DIG == 53) -__weak_reference(sincos, sincosl); +__strong_reference(sincos, sincosl); #endif diff --git a/src/s_tan.c b/src/s_tan.c index e830a19..5063236 100644 --- a/src/s_tan.c +++ b/src/s_tan.c @@ -79,5 +79,5 @@ tan(double x) } #if (LDBL_MANT_DIG == 53) -__weak_reference(tan, tanl); +__strong_reference(tan, tanl); #endif diff --git a/src/s_trunc.c b/src/s_trunc.c index 7f59cf3..0830378 100644 --- a/src/s_trunc.c +++ b/src/s_trunc.c @@ -63,5 +63,5 @@ trunc(double x) } #if LDBL_MANT_DIG == 53 -__weak_reference(trunc, truncl); +__strong_reference(trunc, truncl); #endif diff --git a/src/w_cabs.c b/src/w_cabs.c index ff3fff7..4dd0703 100644 --- a/src/w_cabs.c +++ b/src/w_cabs.c @@ -21,5 +21,5 @@ cabs(double complex z) } #if LDBL_MANT_DIG == 53 -__weak_reference(cabs, cabsl); +__strong_reference(cabs, cabsl); #endif From d07820351bed7d16f1f0a1ae0596a2e2b6f50aaf Mon Sep 17 00:00:00 2001 From: Ed Schouten Date: Sat, 10 Jan 2015 10:21:57 +0100 Subject: [PATCH 5/6] Rename the fenv headers. I guess the idea would be to eventually also install all of the openlibm*.h headers, instead of just openlibm.h. Make openlibm_fenv.h suitable for this purpose by moving all of the $ARCH/fenv.h headers next to it. We actually need this change to make OPENLIBM_USE_HOST_FENV_H work. Right now it's still broken, because the "#include " performed by openlibm_fenv.h still pulls in $ARCH/fenv.h as $ARCH/ is added to the compiler include path. --- amd64/{fenv.h => openlibm_fenv.h} | 0 arm/{fenv.h => openlibm_fenv.h} | 0 i387/{fenv.h => openlibm_fenv.h} | 0 src/openlibm_fenv.h | 6 +- src/openlibm_fenv_amd64.h | 224 ++++++++++++++++++++++++++ src/openlibm_fenv_arm.h | 223 +++++++++++++++++++++++++ src/openlibm_fenv_i387.h | 259 ++++++++++++++++++++++++++++++ 7 files changed, 709 insertions(+), 3 deletions(-) rename amd64/{fenv.h => openlibm_fenv.h} (100%) rename arm/{fenv.h => openlibm_fenv.h} (100%) rename i387/{fenv.h => openlibm_fenv.h} (100%) create mode 100644 src/openlibm_fenv_amd64.h create mode 100644 src/openlibm_fenv_arm.h create mode 100644 src/openlibm_fenv_i387.h diff --git a/amd64/fenv.h b/amd64/openlibm_fenv.h similarity index 100% rename from amd64/fenv.h rename to amd64/openlibm_fenv.h diff --git a/arm/fenv.h b/arm/openlibm_fenv.h similarity index 100% rename from arm/fenv.h rename to arm/openlibm_fenv.h diff --git a/i387/fenv.h b/i387/openlibm_fenv.h similarity index 100% rename from i387/fenv.h rename to i387/openlibm_fenv.h diff --git a/src/openlibm_fenv.h b/src/openlibm_fenv.h index 478e458..4474861 100644 --- a/src/openlibm_fenv.h +++ b/src/openlibm_fenv.h @@ -3,11 +3,11 @@ #else /* !OPENLIBM_USE_HOST_FENV_H */ #if defined(__arm__) -#include "../arm/fenv.h" +#include #elif defined(__x86_64__) -#include "../amd64/fenv.h" +#include #elif defined(__i386__) -#include "../i387/fenv.h" +#include #else #error "Unsupported platform" #endif diff --git a/src/openlibm_fenv_amd64.h b/src/openlibm_fenv_amd64.h new file mode 100644 index 0000000..df3ceab --- /dev/null +++ b/src/openlibm_fenv_amd64.h @@ -0,0 +1,224 @@ +/*- + * Copyright (c) 2004-2005 David Schultz + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $FreeBSD: src/lib/msun/amd64/fenv.h,v 1.8 2011/10/10 15:43:09 das Exp $ + */ + +#ifndef _FENV_H_ +#define _FENV_H_ + +#include "cdefs-compat.h" +#include "types-compat.h" + +#include "math_private.h" + +#ifndef __fenv_static +#define __fenv_static static +#endif + +typedef struct { + struct { + uint32_t __control; + uint32_t __status; + uint32_t __tag; + char __other[16]; + } __x87; + uint32_t __mxcsr; +} fenv_t; + +typedef uint16_t fexcept_t; + +/* Exception flags */ +#define FE_INVALID 0x01 +#define FE_DENORMAL 0x02 +#define FE_DIVBYZERO 0x04 +#define FE_OVERFLOW 0x08 +#define FE_UNDERFLOW 0x10 +#define FE_INEXACT 0x20 +#define FE_ALL_EXCEPT (FE_DIVBYZERO | FE_DENORMAL | FE_INEXACT | \ + FE_INVALID | FE_OVERFLOW | FE_UNDERFLOW) + +/* Rounding modes */ +#define FE_TONEAREST 0x0000 +#define FE_DOWNWARD 0x0400 +#define FE_UPWARD 0x0800 +#define FE_TOWARDZERO 0x0c00 +#define _ROUND_MASK (FE_TONEAREST | FE_DOWNWARD | \ + FE_UPWARD | FE_TOWARDZERO) + +/* + * As compared to the x87 control word, the SSE unit's control word + * has the rounding control bits offset by 3 and the exception mask + * bits offset by 7. + */ +#define _SSE_ROUND_SHIFT 3 +#define _SSE_EMASK_SHIFT 7 + +__BEGIN_DECLS + +/* Default floating-point environment */ +extern const fenv_t __fe_dfl_env; +#define FE_DFL_ENV (&__fe_dfl_env) + +#define __fldcw(__cw) __asm __volatile("fldcw %0" : : "m" (__cw)) +#define __fldenv(__env) __asm __volatile("fldenv %0" : : "m" (__env)) +#define __fldenvx(__env) __asm __volatile("fldenv %0" : : "m" (__env) \ + : "st", "st(1)", "st(2)", "st(3)", "st(4)", \ + "st(5)", "st(6)", "st(7)") +#define __fnclex() __asm __volatile("fnclex") +#define __fnstenv(__env) __asm __volatile("fnstenv %0" : "=m" (*(__env))) +#define __fnstcw(__cw) __asm __volatile("fnstcw %0" : "=m" (*(__cw))) +#define __fnstsw(__sw) __asm __volatile("fnstsw %0" : "=am" (*(__sw))) +#define __fwait() __asm __volatile("fwait") +#define __ldmxcsr(__csr) __asm __volatile("ldmxcsr %0" : : "m" (__csr)) +#define __stmxcsr(__csr) __asm __volatile("stmxcsr %0" : "=m" (*(__csr))) + +__fenv_static __attribute__((always_inline)) DLLEXPORT inline int +feclearexcept(int __excepts) +{ + fenv_t __env; + + if (__excepts == FE_ALL_EXCEPT) { + __fnclex(); + } else { + __fnstenv(&__env.__x87); + __env.__x87.__status &= ~__excepts; + __fldenv(__env.__x87); + } + __stmxcsr(&__env.__mxcsr); + __env.__mxcsr &= ~__excepts; + __ldmxcsr(__env.__mxcsr); + return (0); +} + +__fenv_static DLLEXPORT inline int +fegetexceptflag(fexcept_t *__flagp, int __excepts) +{ + uint32_t __mxcsr; + uint16_t __status; + + __stmxcsr(&__mxcsr); + __fnstsw(&__status); + *__flagp = (__mxcsr | __status) & __excepts; + return (0); +} + +DLLEXPORT int fesetexceptflag(const fexcept_t *__flagp, int __excepts); +DLLEXPORT int feraiseexcept(int __excepts); + +__fenv_static __attribute__((always_inline)) DLLEXPORT inline int +fetestexcept(int __excepts) +{ + uint32_t __mxcsr; + uint16_t __status; + + __stmxcsr(&__mxcsr); + __fnstsw(&__status); + return ((__status | __mxcsr) & __excepts); +} + +__fenv_static DLLEXPORT inline int +fegetround(void) +{ + uint16_t __control; + + /* + * We assume that the x87 and the SSE unit agree on the + * rounding mode. Reading the control word on the x87 turns + * out to be about 5 times faster than reading it on the SSE + * unit on an Opteron 244. + */ + __fnstcw(&__control); + return (__control & _ROUND_MASK); +} + +__fenv_static DLLEXPORT inline int +fesetround(int __round) +{ + uint32_t __mxcsr; + uint16_t __control; + + if (__round & ~_ROUND_MASK) + return (-1); + + __fnstcw(&__control); + __control &= ~_ROUND_MASK; + __control |= __round; + __fldcw(__control); + + __stmxcsr(&__mxcsr); + __mxcsr &= ~(_ROUND_MASK << _SSE_ROUND_SHIFT); + __mxcsr |= __round << _SSE_ROUND_SHIFT; + __ldmxcsr(__mxcsr); + + return (0); +} + +DLLEXPORT int fegetenv(fenv_t *__envp); +DLLEXPORT int feholdexcept(fenv_t *__envp); + +__fenv_static DLLEXPORT inline int +fesetenv(const fenv_t *__envp) +{ + + /* + * XXX Using fldenvx() instead of fldenv() tells the compiler that this + * instruction clobbers the i387 register stack. This happens because + * we restore the tag word from the saved environment. Normally, this + * would happen anyway and we wouldn't care, because the ABI allows + * function calls to clobber the i387 regs. However, fesetenv() is + * inlined, so we need to be more careful. + */ + __fldenvx(__envp->__x87); + __ldmxcsr(__envp->__mxcsr); + return (0); +} + +DLLEXPORT int feupdateenv(const fenv_t *__envp); + +#if __BSD_VISIBLE + +DLLEXPORT int feenableexcept(int __mask); +DLLEXPORT int fedisableexcept(int __mask); + +/* We currently provide no external definition of fegetexcept(). */ +static inline DLLEXPORT int +fegetexcept(void) +{ + uint16_t __control; + + /* + * We assume that the masks for the x87 and the SSE unit are + * the same. + */ + __fnstcw(&__control); + return (~__control & FE_ALL_EXCEPT); +} + +#endif /* __BSD_VISIBLE */ + +__END_DECLS + +#endif /* !_FENV_H_ */ diff --git a/src/openlibm_fenv_arm.h b/src/openlibm_fenv_arm.h new file mode 100644 index 0000000..cd25ea9 --- /dev/null +++ b/src/openlibm_fenv_arm.h @@ -0,0 +1,223 @@ +/*- + * Copyright (c) 2004-2005 David Schultz + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $FreeBSD: src/lib/msun/arm/fenv.h,v 1.6 2011/10/10 15:43:09 das Exp $ + */ + +#ifndef _FENV_H_ +#define _FENV_H_ + +#include + +#ifndef __fenv_static +#define __fenv_static static +#endif + +typedef uint32_t fenv_t; +typedef uint32_t fexcept_t; + +/* Exception flags */ +#define FE_INVALID 0x0001 +#define FE_DIVBYZERO 0x0002 +#define FE_OVERFLOW 0x0004 +#define FE_UNDERFLOW 0x0008 +#define FE_INEXACT 0x0010 +#define FE_ALL_EXCEPT (FE_DIVBYZERO | FE_INEXACT | \ + FE_INVALID | FE_OVERFLOW | FE_UNDERFLOW) + +/* Rounding modes */ +#define FE_TONEAREST 0x0000 +#define FE_TOWARDZERO 0x0001 +#define FE_UPWARD 0x0002 +#define FE_DOWNWARD 0x0003 +#define _ROUND_MASK (FE_TONEAREST | FE_DOWNWARD | \ + FE_UPWARD | FE_TOWARDZERO) +__BEGIN_DECLS + +/* Default floating-point environment */ +extern const fenv_t __fe_dfl_env; +#define FE_DFL_ENV (&__fe_dfl_env) + +/* We need to be able to map status flag positions to mask flag positions */ +#define _FPUSW_SHIFT 16 +#define _ENABLE_MASK (FE_ALL_EXCEPT << _FPUSW_SHIFT) + +#ifdef ARM_HARD_FLOAT +#define __rfs(__fpsr) __asm __volatile("rfs %0" : "=r" (*(__fpsr))) +#define __wfs(__fpsr) __asm __volatile("wfs %0" : : "r" (__fpsr)) +#else +#define __rfs(__fpsr) +#define __wfs(__fpsr) +#endif + +__fenv_static inline int +feclearexcept(int __excepts) +{ + fexcept_t __fpsr; + + __rfs(&__fpsr); + __fpsr &= ~__excepts; + __wfs(__fpsr); + return (0); +} + +__fenv_static inline int +fegetexceptflag(fexcept_t *__flagp, int __excepts) +{ + fexcept_t __fpsr; + + __rfs(&__fpsr); + *__flagp = __fpsr & __excepts; + return (0); +} + +__fenv_static inline int +fesetexceptflag(const fexcept_t *__flagp, int __excepts) +{ + fexcept_t __fpsr; + + __rfs(&__fpsr); + __fpsr &= ~__excepts; + __fpsr |= *__flagp & __excepts; + __wfs(__fpsr); + return (0); +} + +__fenv_static inline int +feraiseexcept(int __excepts) +{ + fexcept_t __ex = __excepts; + + fesetexceptflag(&__ex, __excepts); /* XXX */ + return (0); +} + +__fenv_static inline int +fetestexcept(int __excepts) +{ + fexcept_t __fpsr; + + __rfs(&__fpsr); + return (__fpsr & __excepts); +} + +__fenv_static inline int +fegetround(void) +{ + + /* + * Apparently, the rounding mode is specified as part of the + * instruction format on ARM, so the dynamic rounding mode is + * indeterminate. Some FPUs may differ. + */ + return (-1); +} + +__fenv_static inline int +fesetround(int __round) +{ + + return (-1); +} + +__fenv_static inline int +fegetenv(fenv_t *__envp) +{ + + __rfs(__envp); + return (0); +} + +__fenv_static inline int +feholdexcept(fenv_t *__envp) +{ + fenv_t __env; + + __rfs(&__env); + *__envp = __env; + __env &= ~(FE_ALL_EXCEPT | _ENABLE_MASK); + __wfs(__env); + return (0); +} + +__fenv_static inline int +fesetenv(const fenv_t *__envp) +{ + + __wfs(*__envp); + return (0); +} + +__fenv_static inline int +feupdateenv(const fenv_t *__envp) +{ + fexcept_t __fpsr; + + __rfs(&__fpsr); + __wfs(*__envp); + feraiseexcept(__fpsr & FE_ALL_EXCEPT); + return (0); +} + +#if __BSD_VISIBLE + +/* We currently provide no external definitions of the functions below. */ + +static inline int +feenableexcept(int __mask) +{ + fenv_t __old_fpsr, __new_fpsr; + + __rfs(&__old_fpsr); + __new_fpsr = __old_fpsr | (__mask & FE_ALL_EXCEPT) << _FPUSW_SHIFT; + __wfs(__new_fpsr); + return ((__old_fpsr >> _FPUSW_SHIFT) & FE_ALL_EXCEPT); +} + +static inline int +fedisableexcept(int __mask) +{ + fenv_t __old_fpsr, __new_fpsr; + + __rfs(&__old_fpsr); + __new_fpsr = __old_fpsr & ~((__mask & FE_ALL_EXCEPT) << _FPUSW_SHIFT); + __wfs(__new_fpsr); + return ((__old_fpsr >> _FPUSW_SHIFT) & FE_ALL_EXCEPT); +} + +static inline int +fegetexcept(void) +{ + fenv_t __fpsr; + + __rfs(&__fpsr); + return ((__fpsr & _ENABLE_MASK) >> _FPUSW_SHIFT); +} + +#endif /* __BSD_VISIBLE */ + +__END_DECLS + +#endif /* !_FENV_H_ */ diff --git a/src/openlibm_fenv_i387.h b/src/openlibm_fenv_i387.h new file mode 100644 index 0000000..c3a987c --- /dev/null +++ b/src/openlibm_fenv_i387.h @@ -0,0 +1,259 @@ +/*- + * Copyright (c) 2004-2005 David Schultz + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $FreeBSD: src/lib/msun/i387/fenv.h,v 1.8 2011/10/10 15:43:09 das Exp $ + */ + +#ifndef _FENV_H_ +#define _FENV_H_ + +#include "cdefs-compat.h" +#include "types-compat.h" + +#ifndef __fenv_static +#define __fenv_static static +#endif + +/* + * To preserve binary compatibility with FreeBSD 5.3, we pack the + * mxcsr into some reserved fields, rather than changing sizeof(fenv_t). + */ +typedef struct { + uint16_t __control; + uint16_t __mxcsr_hi; + uint16_t __status; + uint16_t __mxcsr_lo; + uint32_t __tag; + char __other[16]; +} fenv_t; + +#define __get_mxcsr(env) (((env).__mxcsr_hi << 16) | \ + ((env).__mxcsr_lo)) +#define __set_mxcsr(env, x) do { \ + (env).__mxcsr_hi = (uint32_t)(x) >> 16; \ + (env).__mxcsr_lo = (uint16_t)(x); \ +} while (0) + +typedef uint16_t fexcept_t; + +/* Exception flags */ +#define FE_INVALID 0x01 +#define FE_DENORMAL 0x02 +#define FE_DIVBYZERO 0x04 +#define FE_OVERFLOW 0x08 +#define FE_UNDERFLOW 0x10 +#define FE_INEXACT 0x20 +#define FE_ALL_EXCEPT (FE_DIVBYZERO | FE_DENORMAL | FE_INEXACT | \ + FE_INVALID | FE_OVERFLOW | FE_UNDERFLOW) + +/* Rounding modes */ +#define FE_TONEAREST 0x0000 +#define FE_DOWNWARD 0x0400 +#define FE_UPWARD 0x0800 +#define FE_TOWARDZERO 0x0c00 +#define _ROUND_MASK (FE_TONEAREST | FE_DOWNWARD | \ + FE_UPWARD | FE_TOWARDZERO) + +/* + * As compared to the x87 control word, the SSE unit's control word + * has the rounding control bits offset by 3 and the exception mask + * bits offset by 7. + */ +#define _SSE_ROUND_SHIFT 3 +#define _SSE_EMASK_SHIFT 7 + +__BEGIN_DECLS + +/* After testing for SSE support once, we cache the result in __has_sse. */ +enum __sse_support { __SSE_YES, __SSE_NO, __SSE_UNK }; +extern enum __sse_support __has_sse; +int __test_sse(void); +#ifdef __SSE__ +#define __HAS_SSE() 1 +#else +#define __HAS_SSE() (__has_sse == __SSE_YES || \ + (__has_sse == __SSE_UNK && __test_sse())) +#endif + +/* Default floating-point environment */ +extern const fenv_t __fe_dfl_env; +#define FE_DFL_ENV (&__fe_dfl_env) + +#define __fldcw(__cw) __asm __volatile("fldcw %0" : : "m" (__cw)) +#define __fldenv(__env) __asm __volatile("fldenv %0" : : "m" (__env)) +#define __fldenvx(__env) __asm __volatile("fldenv %0" : : "m" (__env) \ + : "st", "st(1)", "st(2)", "st(3)", "st(4)", \ + "st(5)", "st(6)", "st(7)") +#define __fnclex() __asm __volatile("fnclex") +#define __fnstenv(__env) __asm __volatile("fnstenv %0" : "=m" (*(__env))) +#define __fnstcw(__cw) __asm __volatile("fnstcw %0" : "=m" (*(__cw))) +#define __fnstsw(__sw) __asm __volatile("fnstsw %0" : "=am" (*(__sw))) +#define __fwait() __asm __volatile("fwait") +#define __ldmxcsr(__csr) __asm __volatile("ldmxcsr %0" : : "m" (__csr)) +#define __stmxcsr(__csr) __asm __volatile("stmxcsr %0" : "=m" (*(__csr))) + +__fenv_static inline int +feclearexcept(int __excepts) +{ + fenv_t __env; + uint32_t __mxcsr; + + if (__excepts == FE_ALL_EXCEPT) { + __fnclex(); + } else { + __fnstenv(&__env); + __env.__status &= ~__excepts; + __fldenv(__env); + } + if (__HAS_SSE()) { + __stmxcsr(&__mxcsr); + __mxcsr &= ~__excepts; + __ldmxcsr(__mxcsr); + } + return (0); +} + +__fenv_static inline int +fegetexceptflag(fexcept_t *__flagp, int __excepts) +{ + uint32_t __mxcsr; + uint16_t __status; + + __fnstsw(&__status); + if (__HAS_SSE()) + __stmxcsr(&__mxcsr); + else + __mxcsr = 0; + *__flagp = (__mxcsr | __status) & __excepts; + return (0); +} + +int fesetexceptflag(const fexcept_t *__flagp, int __excepts); +int feraiseexcept(int __excepts); + +__fenv_static inline int +fetestexcept(int __excepts) +{ + uint32_t __mxcsr; + uint16_t __status; + + __fnstsw(&__status); + if (__HAS_SSE()) + __stmxcsr(&__mxcsr); + else + __mxcsr = 0; + return ((__status | __mxcsr) & __excepts); +} + +__fenv_static inline int +fegetround(void) +{ + uint16_t __control; + + /* + * We assume that the x87 and the SSE unit agree on the + * rounding mode. Reading the control word on the x87 turns + * out to be about 5 times faster than reading it on the SSE + * unit on an Opteron 244. + */ + __fnstcw(&__control); + return (__control & _ROUND_MASK); +} + +__fenv_static inline int +fesetround(int __round) +{ + uint32_t __mxcsr; + uint16_t __control; + + if (__round & ~_ROUND_MASK) + return (-1); + + __fnstcw(&__control); + __control &= ~_ROUND_MASK; + __control |= __round; + __fldcw(__control); + + if (__HAS_SSE()) { + __stmxcsr(&__mxcsr); + __mxcsr &= ~(_ROUND_MASK << _SSE_ROUND_SHIFT); + __mxcsr |= __round << _SSE_ROUND_SHIFT; + __ldmxcsr(__mxcsr); + } + + return (0); +} + +int fegetenv(fenv_t *__envp); +int feholdexcept(fenv_t *__envp); + +__fenv_static inline int +fesetenv(const fenv_t *__envp) +{ + fenv_t __env = *__envp; + uint32_t __mxcsr; + + __mxcsr = __get_mxcsr(__env); + __set_mxcsr(__env, 0xffffffff); + /* + * XXX Using fldenvx() instead of fldenv() tells the compiler that this + * instruction clobbers the i387 register stack. This happens because + * we restore the tag word from the saved environment. Normally, this + * would happen anyway and we wouldn't care, because the ABI allows + * function calls to clobber the i387 regs. However, fesetenv() is + * inlined, so we need to be more careful. + */ + __fldenvx(__env); + if (__HAS_SSE()) + __ldmxcsr(__mxcsr); + return (0); +} + +int feupdateenv(const fenv_t *__envp); + +#if __BSD_VISIBLE + +int feenableexcept(int __mask); +int fedisableexcept(int __mask); + +/* We currently provide no external definition of fegetexcept(). */ +static inline int +fegetexcept(void) +{ + uint16_t __control; + + /* + * We assume that the masks for the x87 and the SSE unit are + * the same. + */ + __fnstcw(&__control); + return (~__control & FE_ALL_EXCEPT); +} + +#endif /* __BSD_VISIBLE */ + +__END_DECLS + +#endif /* !_FENV_H_ */ From 23b8f663d4717cf7c266dc6911cce57d796cba16 Mon Sep 17 00:00:00 2001 From: Ed Schouten Date: Sat, 10 Jan 2015 19:24:06 +0100 Subject: [PATCH 6/6] Revert "Don't use __weak_reference() when a __strong_reference() is needed." Unlike the __weak_reference() macro, __strong_reference() does type checking. It can only create the reference if the type of the source and the destination function match exactly. Even if double == long double in practice, they remain unequal at the language level. --- src/e_acos.c | 2 +- src/e_asin.c | 2 +- src/e_atan2.c | 2 +- src/e_hypot.c | 2 +- src/e_remainder.c | 2 +- src/e_sqrt.c | 2 +- src/s_atan.c | 2 +- src/s_cbrt.c | 2 +- src/s_ceil.c | 2 +- src/s_cos.c | 2 +- src/s_cproj.c | 2 +- src/s_csqrt.c | 2 +- src/s_exp2.c | 2 +- src/s_floor.c | 2 +- src/s_fma.c | 2 +- src/s_frexp.c | 2 +- src/s_isinf.c | 2 +- src/s_isnan.c | 2 +- src/s_logb.c | 2 +- src/s_nan.c | 2 +- src/s_nextafter.c | 6 +++--- src/s_remquo.c | 2 +- src/s_rint.c | 2 +- src/s_scalbn.c | 4 ++-- src/s_sin.c | 2 +- src/s_sincos.c | 2 +- src/s_tan.c | 2 +- src/s_trunc.c | 2 +- src/w_cabs.c | 2 +- 29 files changed, 32 insertions(+), 32 deletions(-) diff --git a/src/e_acos.c b/src/e_acos.c index 0d2d4df..bf07b54 100644 --- a/src/e_acos.c +++ b/src/e_acos.c @@ -107,5 +107,5 @@ __ieee754_acos(double x) } #if LDBL_MANT_DIG == 53 -__strong_reference(acos, acosl); +__weak_reference(acos, acosl); #endif diff --git a/src/e_asin.c b/src/e_asin.c index 8da0628..67d1d0f 100644 --- a/src/e_asin.c +++ b/src/e_asin.c @@ -113,5 +113,5 @@ __ieee754_asin(double x) } #if LDBL_MANT_DIG == 53 -__strong_reference(asin, asinl); +__weak_reference(asin, asinl); #endif diff --git a/src/e_atan2.c b/src/e_atan2.c index df95b05..bf5b15c 100644 --- a/src/e_atan2.c +++ b/src/e_atan2.c @@ -125,5 +125,5 @@ __ieee754_atan2(double y, double x) } #if LDBL_MANT_DIG == 53 -__strong_reference(atan2, atan2l); +__weak_reference(atan2, atan2l); #endif diff --git a/src/e_hypot.c b/src/e_hypot.c index c33cf72..058a9fd 100644 --- a/src/e_hypot.c +++ b/src/e_hypot.c @@ -127,5 +127,5 @@ __ieee754_hypot(double x, double y) } #if LDBL_MANT_DIG == 53 -__strong_reference(hypot, hypotl); +__weak_reference(hypot, hypotl); #endif diff --git a/src/e_remainder.c b/src/e_remainder.c index 6ac459c..cc1e4c5 100644 --- a/src/e_remainder.c +++ b/src/e_remainder.c @@ -75,5 +75,5 @@ __ieee754_remainder(double x, double p) } #if LDBL_MANT_DIG == 53 -__strong_reference(remainder, remainderl); +__weak_reference(remainder, remainderl); #endif diff --git a/src/e_sqrt.c b/src/e_sqrt.c index 9edbb58..f89b852 100644 --- a/src/e_sqrt.c +++ b/src/e_sqrt.c @@ -189,7 +189,7 @@ __ieee754_sqrt(double x) } #if (LDBL_MANT_DIG == 53) -__strong_reference(sqrt, sqrtl); +__weak_reference(sqrt, sqrtl); #endif /* diff --git a/src/s_atan.c b/src/s_atan.c index 075c730..9a08b9f 100644 --- a/src/s_atan.c +++ b/src/s_atan.c @@ -120,5 +120,5 @@ atan(double x) } #if LDBL_MANT_DIG == 53 -__strong_reference(atan, atanl); +__weak_reference(atan, atanl); #endif diff --git a/src/s_cbrt.c b/src/s_cbrt.c index 8099e99..17a64a4 100644 --- a/src/s_cbrt.c +++ b/src/s_cbrt.c @@ -114,5 +114,5 @@ cbrt(double x) } #if (LDBL_MANT_DIG == 53) -__strong_reference(cbrt, cbrtl); +__weak_reference(cbrt, cbrtl); #endif diff --git a/src/s_ceil.c b/src/s_ceil.c index e12204a..93ce46b 100644 --- a/src/s_ceil.c +++ b/src/s_ceil.c @@ -73,5 +73,5 @@ ceil(double x) } #if LDBL_MANT_DIG == 53 -__strong_reference(ceil, ceill); +__weak_reference(ceil, ceill); #endif diff --git a/src/s_cos.c b/src/s_cos.c index 7af2aa6..63e52a3 100644 --- a/src/s_cos.c +++ b/src/s_cos.c @@ -85,5 +85,5 @@ cos(double x) } #if (LDBL_MANT_DIG == 53) -__strong_reference(cos, cosl); +__weak_reference(cos, cosl); #endif diff --git a/src/s_cproj.c b/src/s_cproj.c index 4549961..7b9e131 100644 --- a/src/s_cproj.c +++ b/src/s_cproj.c @@ -43,5 +43,5 @@ cproj(double complex z) } #if LDBL_MANT_DIG == 53 -__strong_reference(cproj, cprojl); +__weak_reference(cproj, cprojl); #endif diff --git a/src/s_csqrt.c b/src/s_csqrt.c index 09c01f3..e0633bd 100644 --- a/src/s_csqrt.c +++ b/src/s_csqrt.c @@ -110,5 +110,5 @@ csqrt(double complex z) } #if LDBL_MANT_DIG == 53 -__strong_reference(csqrt, csqrtl); +__weak_reference(csqrt, csqrtl); #endif diff --git a/src/s_exp2.c b/src/s_exp2.c index 293117c..e1863f5 100644 --- a/src/s_exp2.c +++ b/src/s_exp2.c @@ -392,5 +392,5 @@ exp2(double x) } #if (LDBL_MANT_DIG == 53) -__strong_reference(exp2, exp2l); +__weak_reference(exp2, exp2l); #endif diff --git a/src/s_floor.c b/src/s_floor.c index 22d98ca..6825492 100644 --- a/src/s_floor.c +++ b/src/s_floor.c @@ -74,5 +74,5 @@ floor(double x) } #if LDBL_MANT_DIG == 53 -__strong_reference(floor, floorl); +__weak_reference(floor, floorl); #endif diff --git a/src/s_fma.c b/src/s_fma.c index b24cb7d..7fa8ba3 100644 --- a/src/s_fma.c +++ b/src/s_fma.c @@ -280,5 +280,5 @@ fma(double x, double y, double z) } #if (LDBL_MANT_DIG == 53) -__strong_reference(fma, fmal); +__weak_reference(fma, fmal); #endif diff --git a/src/s_frexp.c b/src/s_frexp.c index 2406c13..c836375 100644 --- a/src/s_frexp.c +++ b/src/s_frexp.c @@ -52,5 +52,5 @@ frexp(double x, int *eptr) } #if (LDBL_MANT_DIG == 53) -__strong_reference(frexp, frexpl); +__weak_reference(frexp, frexpl); #endif diff --git a/src/s_isinf.c b/src/s_isinf.c index 3a1c685..041c4ec 100644 --- a/src/s_isinf.c +++ b/src/s_isinf.c @@ -62,4 +62,4 @@ __isinfl(long double e) } #endif -__strong_reference(__isinff, isinff); +__weak_reference(__isinff, isinff); diff --git a/src/s_isnan.c b/src/s_isnan.c index 7482357..21f4f64 100644 --- a/src/s_isnan.c +++ b/src/s_isnan.c @@ -63,4 +63,4 @@ __isnanl(long double e) } #endif -__strong_reference(__isnanf, isnanf); +__weak_reference(__isnanf, isnanf); diff --git a/src/s_logb.c b/src/s_logb.c index 8fb4ea8..9549301 100644 --- a/src/s_logb.c +++ b/src/s_logb.c @@ -45,5 +45,5 @@ logb(double x) } #if (LDBL_MANT_DIG == 53) -__strong_reference(logb, logbl); +__weak_reference(logb, logbl); #endif diff --git a/src/s_nan.c b/src/s_nan.c index 5a5d8e6..ef8aad7 100644 --- a/src/s_nan.c +++ b/src/s_nan.c @@ -120,5 +120,5 @@ nanf(const char *s) } #if (LDBL_MANT_DIG == 53) -__strong_reference(nan, nanl); +__weak_reference(nan, nanl); #endif diff --git a/src/s_nextafter.c b/src/s_nextafter.c index c0c2f39..2e02a32 100644 --- a/src/s_nextafter.c +++ b/src/s_nextafter.c @@ -77,7 +77,7 @@ nextafter(double x, double y) } #if (LDBL_MANT_DIG == 53) -__strong_reference(nextafter, nexttoward); -__strong_reference(nextafter, nexttowardl); -__strong_reference(nextafter, nextafterl); +__weak_reference(nextafter, nexttoward); +__weak_reference(nextafter, nexttowardl); +__weak_reference(nextafter, nextafterl); #endif diff --git a/src/s_remquo.c b/src/s_remquo.c index 3e759aa..ca62639 100644 --- a/src/s_remquo.c +++ b/src/s_remquo.c @@ -154,5 +154,5 @@ fixup: } #if LDBL_MANT_DIG == 53 -__strong_reference(remquo, remquol); +__weak_reference(remquo, remquol); #endif diff --git a/src/s_rint.c b/src/s_rint.c index 749bde7..ba0e104 100644 --- a/src/s_rint.c +++ b/src/s_rint.c @@ -88,5 +88,5 @@ rint(double x) } #if (LDBL_MANT_DIG == 53) -__strong_reference(rint, rintl); +__weak_reference(rint, rintl); #endif diff --git a/src/s_scalbn.c b/src/s_scalbn.c index 6e41cba..1071ac3 100644 --- a/src/s_scalbn.c +++ b/src/s_scalbn.c @@ -59,8 +59,8 @@ scalbn (double x, int n) } #if (LDBL_MANT_DIG == 53) -__strong_reference(scalbn, ldexpl); -__strong_reference(scalbn, scalbnl); +__weak_reference(scalbn, ldexpl); +__weak_reference(scalbn, scalbnl); #endif __strong_reference(scalbn, ldexp); diff --git a/src/s_sin.c b/src/s_sin.c index 602188d..9f50764 100644 --- a/src/s_sin.c +++ b/src/s_sin.c @@ -85,5 +85,5 @@ sin(double x) } #if (LDBL_MANT_DIG == 53) -__strong_reference(sin, sinl); +__weak_reference(sin, sinl); #endif diff --git a/src/s_sincos.c b/src/s_sincos.c index 2b1509b..9960ee6 100644 --- a/src/s_sincos.c +++ b/src/s_sincos.c @@ -146,5 +146,5 @@ sincos(double x, double * s, double * c) } #if (LDBL_MANT_DIG == 53) -__strong_reference(sincos, sincosl); +__weak_reference(sincos, sincosl); #endif diff --git a/src/s_tan.c b/src/s_tan.c index 5063236..e830a19 100644 --- a/src/s_tan.c +++ b/src/s_tan.c @@ -79,5 +79,5 @@ tan(double x) } #if (LDBL_MANT_DIG == 53) -__strong_reference(tan, tanl); +__weak_reference(tan, tanl); #endif diff --git a/src/s_trunc.c b/src/s_trunc.c index 0830378..7f59cf3 100644 --- a/src/s_trunc.c +++ b/src/s_trunc.c @@ -63,5 +63,5 @@ trunc(double x) } #if LDBL_MANT_DIG == 53 -__strong_reference(trunc, truncl); +__weak_reference(trunc, truncl); #endif diff --git a/src/w_cabs.c b/src/w_cabs.c index 4dd0703..ff3fff7 100644 --- a/src/w_cabs.c +++ b/src/w_cabs.c @@ -21,5 +21,5 @@ cabs(double complex z) } #if LDBL_MANT_DIG == 53 -__strong_reference(cabs, cabsl); +__weak_reference(cabs, cabsl); #endif