- move libm_hidden_proto to the corresponding headers. Remove from callsites.

  Note that gamma_r is not provided by glibc, perhaps add a SUN specific knob later

2 files changed, 102 insertions, 0 deletions

diff --git a/libc/sysdeps/linux/common/bits/cmathcalls.h b/libc/sysdeps/linux/common/bits/cmathcalls.h
index 35237b35d..762c1e3c1 100644
--- a/libc/sysdeps/linux/common/bits/cmathcalls.h
+++ b/libc/sysdeps/linux/common/bits/cmathcalls.h
@@ -52,81 +52,104 @@
 
 /* Arc cosine of Z.  */
 __MATHCALL (cacos, (_Mdouble_complex_ __z));
+libm_hidden_proto(cacos)
 /* Arc sine of Z.  */
 __MATHCALL (casin, (_Mdouble_complex_ __z));
+libm_hidden_proto(casin)
 /* Arc tangent of Z.  */
 __MATHCALL (catan, (_Mdouble_complex_ __z));
+libm_hidden_proto(catan)
 
 /* Cosine of Z.  */
 __MATHCALL (ccos, (_Mdouble_complex_ __z));
+libm_hidden_proto(ccos)
 /* Sine of Z.  */
 __MATHCALL (csin, (_Mdouble_complex_ __z));
+libm_hidden_proto(csin)
 /* Tangent of Z.  */
 __MATHCALL (ctan, (_Mdouble_complex_ __z));
+libm_hidden_proto(ctan)
 
 
 /* Hyperbolic functions.  */
 
 /* Hyperbolic arc cosine of Z.  */
 __MATHCALL (cacosh, (_Mdouble_complex_ __z));
+libm_hidden_proto(cacosh)
 /* Hyperbolic arc sine of Z.  */
 __MATHCALL (casinh, (_Mdouble_complex_ __z));
+libm_hidden_proto(casinh)
 /* Hyperbolic arc tangent of Z.  */
 __MATHCALL (catanh, (_Mdouble_complex_ __z));
+libm_hidden_proto(catanh)
 
 /* Hyperbolic cosine of Z.  */
 __MATHCALL (ccosh, (_Mdouble_complex_ __z));
+libm_hidden_proto(ccosh)
 /* Hyperbolic sine of Z.  */
 __MATHCALL (csinh, (_Mdouble_complex_ __z));
+libm_hidden_proto(ccosh)
 /* Hyperbolic tangent of Z.  */
 __MATHCALL (ctanh, (_Mdouble_complex_ __z));
+libm_hidden_proto(ctanh)
 
 
 /* Exponential and logarithmic functions.  */
 
 /* Exponential function of Z.  */
 __MATHCALL (cexp, (_Mdouble_complex_ __z));
+libm_hidden_proto(cexp)
 
 /* Natural logarithm of Z.  */
 __MATHCALL (clog, (_Mdouble_complex_ __z));
+libm_hidden_proto(clog)
 
 #ifdef __USE_GNU
 /* The base 10 logarithm is not defined by the standard but to implement
    the standard C++ library it is handy.  */
 __MATHCALL (clog10, (_Mdouble_complex_ __z));
+libm_hidden_proto(clog10)
 #endif
 
 /* Power functions.  */
 
 /* Return X to the Y power.  */
 __MATHCALL (cpow, (_Mdouble_complex_ __x, _Mdouble_complex_ __y));
+libm_hidden_proto(cpow)
 
 /* Return the square root of Z.  */
 __MATHCALL (csqrt, (_Mdouble_complex_ __z));
+libm_hidden_proto(csqrt)
 
 
 /* Absolute value, conjugates, and projection.  */
 
 /* Absolute value of Z.  */
 __MATHDECL (_Mdouble_,cabs, (_Mdouble_complex_ __z));
+libm_hidden_proto(cabs)
 
 /* Argument value of Z.  */
 __MATHDECL (_Mdouble_,carg, (_Mdouble_complex_ __z));
+libm_hidden_proto(carg)
 
 /* Complex conjugate of Z.  */
 __MATHCALL (conj, (_Mdouble_complex_ __z));
+libm_hidden_proto(conj)
 
 /* Projection of Z onto the Riemann sphere.  */
 __MATHCALL (cproj, (_Mdouble_complex_ __z));
+libm_hidden_proto(cproj)
 
 
 /* Decomposing complex values.  */
 
 /* Imaginary part of Z.  */
 __MATHDECL (_Mdouble_,cimag, (_Mdouble_complex_ __z));
+libm_hidden_proto(cimag)
 
 /* Real part of Z.  */
 __MATHDECL (_Mdouble_,creal, (_Mdouble_complex_ __z));
+libm_hidden_proto(creal)
 
 
 /* Now some optimized versions.  GCC has handy notations for these
diff --git a/libc/sysdeps/linux/common/bits/mathcalls.h b/libc/sysdeps/linux/common/bits/mathcalls.h
index c02007284..e30b04aed 100644
--- a/libc/sysdeps/linux/common/bits/mathcalls.h
+++ b/libc/sysdeps/linux/common/bits/mathcalls.h
@@ -53,44 +53,58 @@
 _Mdouble_BEGIN_NAMESPACE
 /* Arc cosine of X.  */
 __MATHCALL (acos,, (_Mdouble_ __x));
+libm_hidden_proto(acos)
 /* Arc sine of X.  */
 __MATHCALL (asin,, (_Mdouble_ __x));
+libm_hidden_proto(asin)
 /* Arc tangent of X.  */
 __MATHCALL (atan,, (_Mdouble_ __x));
+libm_hidden_proto(atan)
 /* Arc tangent of Y/X.  */
 __MATHCALL (atan2,, (_Mdouble_ __y, _Mdouble_ __x));
+libm_hidden_proto(atan2)
 
 /* Cosine of X.  */
 __MATHCALL (cos,, (_Mdouble_ __x));
+libm_hidden_proto(cos)
 /* Sine of X.  */
 __MATHCALL (sin,, (_Mdouble_ __x));
+libm_hidden_proto(sin)
 /* Tangent of X.  */
 __MATHCALL (tan,, (_Mdouble_ __x));
+libm_hidden_proto(tan)
 
 /* Hyperbolic functions.  */
 
 /* Hyperbolic cosine of X.  */
 __MATHCALL (cosh,, (_Mdouble_ __x));
+libm_hidden_proto(cosh)
 /* Hyperbolic sine of X.  */
 __MATHCALL (sinh,, (_Mdouble_ __x));
+libm_hidden_proto(sinh)
 /* Hyperbolic tangent of X.  */
 __MATHCALL (tanh,, (_Mdouble_ __x));
+libm_hidden_proto(tanh)
 _Mdouble_END_NAMESPACE
 
 #if 0 /*def __USE_GNU*/
 /* Cosine and sine of X.  */
 __MATHDECL (void,sincos,,
 	    (_Mdouble_ __x, _Mdouble_ *__sinx, _Mdouble_ *__cosx));
+libm_hidden_proto(sincos)
 #endif
 
 #if defined __USE_MISC || defined __USE_XOPEN_EXTENDED || defined __USE_ISOC99
 __BEGIN_NAMESPACE_C99
 /* Hyperbolic arc cosine of X.  */
 __MATHCALL (acosh,, (_Mdouble_ __x));
+libm_hidden_proto(acosh)
 /* Hyperbolic arc sine of X.  */
 __MATHCALL (asinh,, (_Mdouble_ __x));
+libm_hidden_proto(asinh)
 /* Hyperbolic arc tangent of X.  */
 __MATHCALL (atanh,, (_Mdouble_ __x));
+libm_hidden_proto(atanh)
 __END_NAMESPACE_C99
 #endif
 
@@ -99,40 +113,51 @@ __END_NAMESPACE_C99
 _Mdouble_BEGIN_NAMESPACE
 /* Exponential function of X.  */
 __MATHCALL (exp,, (_Mdouble_ __x));
+libm_hidden_proto(exp)
 
 /* Break VALUE into a normalized fraction and an integral power of 2.  */
 __MATHCALL (frexp,, (_Mdouble_ __x, int *__exponent));
+libm_hidden_proto(frexp)
 
 /* X times (two to the EXP power).  */
 __MATHCALL (ldexp,, (_Mdouble_ __x, int __exponent));
+libm_hidden_proto(ldexp)
 
 /* Natural logarithm of X.  */
 __MATHCALL (log,, (_Mdouble_ __x));
+libm_hidden_proto(log)
 
 /* Base-ten logarithm of X.  */
 __MATHCALL (log10,, (_Mdouble_ __x));
+libm_hidden_proto(log10)
 
 /* Break VALUE into integral and fractional parts.  */
 __MATHCALL (modf,, (_Mdouble_ __x, _Mdouble_ *__iptr));
+libm_hidden_proto(modf)
 _Mdouble_END_NAMESPACE
 
 #if 0 /*def __USE_GNU*/
 /* A function missing in all standards: compute exponent to base ten.  */
 __MATHCALL (exp10,, (_Mdouble_ __x));
+libm_hidden_proto(exp10)
 /* Another name occasionally used.  */
 __MATHCALL (pow10,, (_Mdouble_ __x));
+libm_hidden_proto(pow10)
 #endif
 
 #if defined __USE_MISC || defined __USE_XOPEN_EXTENDED || defined __USE_ISOC99
 __BEGIN_NAMESPACE_C99
 /* Return exp(X) - 1.  */
 __MATHCALL (expm1,, (_Mdouble_ __x));
+libm_hidden_proto(expm1)
 
 /* Return log(1 + X).  */
 __MATHCALL (log1p,, (_Mdouble_ __x));
+libm_hidden_proto(log1p)
 
 /* Return the base 2 signed integral exponent of X.  */
 __MATHCALL (logb,, (_Mdouble_ __x));
+libm_hidden_proto(logb)
 __END_NAMESPACE_C99
 #endif
 
@@ -140,9 +165,11 @@ __END_NAMESPACE_C99
 __BEGIN_NAMESPACE_C99
 /* Compute base-2 exponential of X.  */
 __MATHCALL (exp2,, (_Mdouble_ __x));
+libm_hidden_proto(exp2)
 
 /* Compute base-2 logarithm of X.  */
 __MATHCALL (log2,, (_Mdouble_ __x));
+libm_hidden_proto(log2)
 __END_NAMESPACE_C99
 #endif
 
@@ -152,15 +179,18 @@ __END_NAMESPACE_C99
 _Mdouble_BEGIN_NAMESPACE
 /* Return X to the Y power.  */
 __MATHCALL (pow,, (_Mdouble_ __x, _Mdouble_ __y));
+libm_hidden_proto(pow)
 
 /* Return the square root of X.  */
 __MATHCALL (sqrt,, (_Mdouble_ __x));
+libm_hidden_proto(sqrt)
 _Mdouble_END_NAMESPACE
 
 #if defined __USE_MISC || defined __USE_XOPEN || defined __USE_ISOC99
 __BEGIN_NAMESPACE_C99
 /* Return `sqrt(X*X + Y*Y)'.  */
 __MATHCALL (hypot,, (_Mdouble_ __x, _Mdouble_ __y));
+libm_hidden_proto(hypot)
 __END_NAMESPACE_C99
 #endif
 
@@ -168,6 +198,7 @@ __END_NAMESPACE_C99
 __BEGIN_NAMESPACE_C99
 /* Return the cube root of X.  */
 __MATHCALL (cbrt,, (_Mdouble_ __x));
+libm_hidden_proto(cbrt)
 __END_NAMESPACE_C99
 #endif
 
@@ -177,45 +208,56 @@ __END_NAMESPACE_C99
 _Mdouble_BEGIN_NAMESPACE
 /* Smallest integral value not less than X.  */
 __MATHCALLX (ceil,, (_Mdouble_ __x), (__const__));
+libm_hidden_proto(ceil)
 
 /* Absolute value of X.  */
 __MATHCALLX (fabs,, (_Mdouble_ __x), (__const__));
+libm_hidden_proto(fabs)
 
 /* Largest integer not greater than X.  */
 __MATHCALLX (floor,, (_Mdouble_ __x), (__const__));
+libm_hidden_proto(floor)
 
 /* Floating-point modulo remainder of X/Y.  */
 __MATHCALL (fmod,, (_Mdouble_ __x, _Mdouble_ __y));
+libm_hidden_proto(fmod)
 
 
 /* Return 0 if VALUE is finite or NaN, +1 if it
    is +Infinity, -1 if it is -Infinity.  */
 __MATHDECL_1 (int,__isinf,, (_Mdouble_ __value)) __attribute__ ((__const__));
+libm_hidden_proto(__isinf)
 
 /* Return nonzero if VALUE is finite and not NaN.  */
 __MATHDECL_1 (int,__finite,, (_Mdouble_ __value)) __attribute__ ((__const__));
+libm_hidden_proto(__finite)
 _Mdouble_END_NAMESPACE
 
 #ifdef __USE_MISC
 /* Return 0 if VALUE is finite or NaN, +1 if it
    is +Infinity, -1 if it is -Infinity.  */
 __MATHDECL_1 (int,isinf,, (_Mdouble_ __value)) __attribute__ ((__const__));
+libm_hidden_proto(isinf)
 
 /* Return nonzero if VALUE is finite and not NaN.  */
 __MATHDECL_1 (int,finite,, (_Mdouble_ __value)) __attribute__ ((__const__));
+libm_hidden_proto(finite)
 
 /* Return the remainder of X/Y.  */
 __MATHCALL (drem,, (_Mdouble_ __x, _Mdouble_ __y));
+libm_hidden_proto(drem)
 
 
 /* Return the fractional part of X after dividing out `ilogb (X)'.  */
 __MATHCALL (significand,, (_Mdouble_ __x));
+libm_hidden_proto(significand)
 #endif /* Use misc.  */
 
 #if defined __USE_MISC || defined __USE_ISOC99
 __BEGIN_NAMESPACE_C99
 /* Return X with its signed changed to Y's.  */
 __MATHCALLX (copysign,, (_Mdouble_ __x, _Mdouble_ __y), (__const__));
+libm_hidden_proto(copysign)
 __END_NAMESPACE_C99
 #endif
 
@@ -223,24 +265,33 @@ __END_NAMESPACE_C99
 __BEGIN_NAMESPACE_C99
 /* Return representation of NaN for double type.  */
 __MATHCALLX (nan,, (__const char *__tagb), (__const__));
+libm_hidden_proto(nan)
 __END_NAMESPACE_C99
 #endif
 
 
 /* Return nonzero if VALUE is not a number.  */
 __MATHDECL_1 (int,__isnan,, (_Mdouble_ __value)) __attribute__ ((__const__));
+libm_hidden_proto(__isnan)
 
 #if defined __USE_MISC || defined __USE_XOPEN
 /* Return nonzero if VALUE is not a number.  */
 __MATHDECL_1 (int,isnan,, (_Mdouble_ __value)) __attribute__ ((__const__));
+libm_hidden_proto(isnan)
 
 /* Bessel functions.  */
 __MATHCALL (j0,, (_Mdouble_));
+libm_hidden_proto(j0)
 __MATHCALL (j1,, (_Mdouble_));
+libm_hidden_proto(j1)
 __MATHCALL (jn,, (int, _Mdouble_));
+libm_hidden_proto(jn)
 __MATHCALL (y0,, (_Mdouble_));
+libm_hidden_proto(y0)
 __MATHCALL (y1,, (_Mdouble_));
+libm_hidden_proto(y1)
 __MATHCALL (yn,, (int, _Mdouble_));
+libm_hidden_proto(yn)
 #endif
 
 
@@ -248,8 +299,11 @@ __MATHCALL (yn,, (int, _Mdouble_));
 __BEGIN_NAMESPACE_C99
 /* Error and gamma functions.  */
 __MATHCALL (erf,, (_Mdouble_));
+libm_hidden_proto(erf)
 __MATHCALL (erfc,, (_Mdouble_));
+libm_hidden_proto(erfc)
 __MATHCALL (lgamma,, (_Mdouble_));
+libm_hidden_proto(lgamma)
 __END_NAMESPACE_C99
 #endif
 
@@ -257,12 +311,14 @@ __END_NAMESPACE_C99
 __BEGIN_NAMESPACE_C99
 /* True gamma function.  */
 __MATHCALL (tgamma,, (_Mdouble_));
+libm_hidden_proto(tgamma)
 __END_NAMESPACE_C99
 #endif
 
 #if defined __USE_MISC || defined __USE_XOPEN
 /* Obsolete alias for `lgamma'.  */
 __MATHCALL (gamma,, (_Mdouble_));
+libm_hidden_proto(gamma)
 #endif
 
 #ifdef __USE_MISC
@@ -270,6 +326,7 @@ __MATHCALL (gamma,, (_Mdouble_));
    `signgam'.  The reentrant version instead takes a pointer and stores
    the value through it.  */
 __MATHCALL (lgamma,_r, (_Mdouble_, int *__signgamp));
+libm_hidden_proto(lgamma_r)
 #endif
 
 
@@ -278,45 +335,56 @@ __BEGIN_NAMESPACE_C99
 /* Return the integer nearest X in the direction of the
    prevailing rounding mode.  */
 __MATHCALL (rint,, (_Mdouble_ __x));
+libm_hidden_proto(rint)
 
 /* Return X + epsilon if X < Y, X - epsilon if X > Y.  */
 __MATHCALLX (nextafter,, (_Mdouble_ __x, _Mdouble_ __y), (__const__));
+libm_hidden_proto(nextafter)
 # if defined __USE_ISOC99 && !defined __LDBL_COMPAT
 __MATHCALLX (nexttoward,, (_Mdouble_ __x, long double __y), (__const__));
+libm_hidden_proto(nexttoward)
 # endif
 
 /* Return the remainder of integer divison X / Y with infinite precision.  */
 __MATHCALL (remainder,, (_Mdouble_ __x, _Mdouble_ __y));
+libm_hidden_proto(remainder)
 
 # if defined __USE_MISC || defined __USE_ISOC99
 /* Return X times (2 to the Nth power).  */
 __MATHCALL (scalbn,, (_Mdouble_ __x, int __n));
+libm_hidden_proto(scalbn)
 # endif
 
 /* Return the binary exponent of X, which must be nonzero.  */
 __MATHDECL (int,ilogb,, (_Mdouble_ __x));
+libm_hidden_proto(ilogb)
 #endif
 
 #ifdef __USE_ISOC99
 /* Return X times (2 to the Nth power).  */
 __MATHCALL (scalbln,, (_Mdouble_ __x, long int __n));
+libm_hidden_proto(scalbln)
 
 /* Round X to integral value in floating-point format using current
    rounding direction, but do not raise inexact exception.  */
 __MATHCALL (nearbyint,, (_Mdouble_ __x));
+libm_hidden_proto(nearbyint)
 
 /* Round X to nearest integral value, rounding halfway cases away from
    zero.  */
 __MATHCALLX (round,, (_Mdouble_ __x), (__const__));
+libm_hidden_proto(round)
 
 /* Round X to the integral value in floating-point format nearest but
    not larger in magnitude.  */
 __MATHCALLX (trunc,, (_Mdouble_ __x), (__const__));
+libm_hidden_proto(trunc)
 
 /* Compute remainder of X and Y and put in *QUO a value with sign of x/y
    and magnitude congruent `mod 2^n' to the magnitude of the integral
    quotient x/y, with n >= 3.  */
 __MATHCALL (remquo,, (_Mdouble_ __x, _Mdouble_ __y, int *__quo));
+libm_hidden_proto(remquo)
 
 
 /* Conversion functions.  */
@@ -324,35 +392,45 @@ __MATHCALL (remquo,, (_Mdouble_ __x, _Mdouble_ __y, int *__quo));
 /* Round X to nearest integral value according to current rounding
    direction.  */
 __MATHDECL (long int,lrint,, (_Mdouble_ __x));
+libm_hidden_proto(lrint)
 __MATHDECL (long long int,llrint,, (_Mdouble_ __x));
+libm_hidden_proto(llrint)
 
 /* Round X to nearest integral value, rounding halfway cases away from
    zero.  */
 __MATHDECL (long int,lround,, (_Mdouble_ __x));
+libm_hidden_proto(lround)
 __MATHDECL (long long int,llround,, (_Mdouble_ __x));
+libm_hidden_proto(llround)
 
 
 /* Return positive difference between X and Y.  */
 __MATHCALL (fdim,, (_Mdouble_ __x, _Mdouble_ __y));
+libm_hidden_proto(fdim)
 
 /* Return maximum numeric value from X and Y.  */
 __MATHCALL (fmax,, (_Mdouble_ __x, _Mdouble_ __y));
+libm_hidden_proto(fmax)
 
 /* Return minimum numeric value from X and Y.  */
 __MATHCALL (fmin,, (_Mdouble_ __x, _Mdouble_ __y));
+libm_hidden_proto(fmin)
 
 
 /* Classify given number.  */
 __MATHDECL_1 (int, __fpclassify,, (_Mdouble_ __value))
      __attribute__ ((__const__));
+libm_hidden_proto(__fpclassify)
 
 /* Test for negative number.  */
 __MATHDECL_1 (int, __signbit,, (_Mdouble_ __value))
      __attribute__ ((__const__));
+libm_hidden_proto(__signbit)
 
 
 /* Multiply-add function computed as a ternary operation.  */
 __MATHCALL (fma,, (_Mdouble_ __x, _Mdouble_ __y, _Mdouble_ __z));
+libm_hidden_proto(fma)
 #endif /* Use ISO C99.  */
 
 #if defined __USE_MISC || defined __USE_XOPEN_EXTENDED || defined __USE_ISOC99
@@ -362,4 +440,5 @@ __END_NAMESPACE_C99
 #if defined __USE_MISC || defined __USE_XOPEN_EXTENDED
 /* Return X times (2 to the Nth power).  */
 __MATHCALL (scalb,, (_Mdouble_ __x, _Mdouble_ __n));
+libm_hidden_proto(scalb)
 #endif