diff --git a/lib/msun/src/e_acos.c b/lib/msun/src/e_acos.c
index 1f6dca5bb5cb..6623355baa7c 100644
--- a/lib/msun/src/e_acos.c
+++ b/lib/msun/src/e_acos.c
@@ -1,111 +1,111 @@
 
 /* @(#)e_acos.c 1.3 95/01/18 */
 /*
  * ====================================================
  * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
  *
  * Developed at SunSoft, a Sun Microsystems, Inc. business.
  * Permission to use, copy, modify, and distribute this
  * software is freely granted, provided that this notice 
  * is preserved.
  * ====================================================
  */
 
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
-/* __ieee754_acos(x)
+/* acos(x)
  * Method :                  
  *	acos(x)  = pi/2 - asin(x)
  *	acos(-x) = pi/2 + asin(x)
  * For |x|<=0.5
  *	acos(x) = pi/2 - (x + x*x^2*R(x^2))	(see asin.c)
  * For x>0.5
  * 	acos(x) = pi/2 - (pi/2 - 2asin(sqrt((1-x)/2)))
  *		= 2asin(sqrt((1-x)/2))  
  *		= 2s + 2s*z*R(z) 	...z=(1-x)/2, s=sqrt(z)
  *		= 2f + (2c + 2s*z*R(z))
  *     where f=hi part of s, and c = (z-f*f)/(s+f) is the correction term
  *     for f so that f+c ~ sqrt(z).
  * For x<-0.5
  *	acos(x) = pi - 2asin(sqrt((1-|x|)/2))
  *		= pi - 0.5*(s+s*z*R(z)), where z=(1-|x|)/2,s=sqrt(z)
  *
  * Special cases:
  *	if x is NaN, return x itself;
  *	if |x|>1, return NaN with invalid signal.
  *
  * Function needed: sqrt
  */
 
 #include <float.h>
 
 #include "math.h"
 #include "math_private.h"
 
 static const double
 one=  1.00000000000000000000e+00, /* 0x3FF00000, 0x00000000 */
 pi =  3.14159265358979311600e+00, /* 0x400921FB, 0x54442D18 */
 pio2_hi =  1.57079632679489655800e+00; /* 0x3FF921FB, 0x54442D18 */
 static volatile double
 pio2_lo =  6.12323399573676603587e-17; /* 0x3C91A626, 0x33145C07 */
 static const double
 pS0 =  1.66666666666666657415e-01, /* 0x3FC55555, 0x55555555 */
 pS1 = -3.25565818622400915405e-01, /* 0xBFD4D612, 0x03EB6F7D */
 pS2 =  2.01212532134862925881e-01, /* 0x3FC9C155, 0x0E884455 */
 pS3 = -4.00555345006794114027e-02, /* 0xBFA48228, 0xB5688F3B */
 pS4 =  7.91534994289814532176e-04, /* 0x3F49EFE0, 0x7501B288 */
 pS5 =  3.47933107596021167570e-05, /* 0x3F023DE1, 0x0DFDF709 */
 qS1 = -2.40339491173441421878e+00, /* 0xC0033A27, 0x1C8A2D4B */
 qS2 =  2.02094576023350569471e+00, /* 0x40002AE5, 0x9C598AC8 */
 qS3 = -6.88283971605453293030e-01, /* 0xBFE6066C, 0x1B8D0159 */
 qS4 =  7.70381505559019352791e-02; /* 0x3FB3B8C5, 0xB12E9282 */
 
 double
-__ieee754_acos(double x)
+acos(double x)
 {
 	double z,p,q,r,w,s,c,df;
 	int32_t hx,ix;
 	GET_HIGH_WORD(hx,x);
 	ix = hx&0x7fffffff;
 	if(ix>=0x3ff00000) {	/* |x| >= 1 */
 	    u_int32_t lx;
 	    GET_LOW_WORD(lx,x);
 	    if(((ix-0x3ff00000)|lx)==0) {	/* |x|==1 */
 		if(hx>0) return 0.0;		/* acos(1) = 0  */
 		else return pi+2.0*pio2_lo;	/* acos(-1)= pi */
 	    }
 	    return (x-x)/(x-x);		/* acos(|x|>1) is NaN */
 	}
 	if(ix<0x3fe00000) {	/* |x| < 0.5 */
 	    if(ix<=0x3c600000) return pio2_hi+pio2_lo;/*if|x|<2**-57*/
 	    z = x*x;
 	    p = z*(pS0+z*(pS1+z*(pS2+z*(pS3+z*(pS4+z*pS5)))));
 	    q = one+z*(qS1+z*(qS2+z*(qS3+z*qS4)));
 	    r = p/q;
 	    return pio2_hi - (x - (pio2_lo-x*r));
 	} else  if (hx<0) {		/* x < -0.5 */
 	    z = (one+x)*0.5;
 	    p = z*(pS0+z*(pS1+z*(pS2+z*(pS3+z*(pS4+z*pS5)))));
 	    q = one+z*(qS1+z*(qS2+z*(qS3+z*qS4)));
 	    s = sqrt(z);
 	    r = p/q;
 	    w = r*s-pio2_lo;
 	    return pi - 2.0*(s+w);
 	} else {			/* x > 0.5 */
 	    z = (one-x)*0.5;
 	    s = sqrt(z);
 	    df = s;
 	    SET_LOW_WORD(df,0);
 	    c  = (z-df*df)/(s+df);
 	    p = z*(pS0+z*(pS1+z*(pS2+z*(pS3+z*(pS4+z*pS5)))));
 	    q = one+z*(qS1+z*(qS2+z*(qS3+z*qS4)));
 	    r = p/q;
 	    w = r*s+c;
 	    return 2.0*(df+w);
 	}
 }
 
 #if LDBL_MANT_DIG == 53
 __weak_reference(acos, acosl);
 #endif
diff --git a/lib/msun/src/e_acosf.c b/lib/msun/src/e_acosf.c
index c9f62cc40f5c..64f1c5afb182 100644
--- a/lib/msun/src/e_acosf.c
+++ b/lib/msun/src/e_acosf.c
@@ -1,77 +1,77 @@
 /* e_acosf.c -- float version of e_acos.c.
  * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
  */
 
 /*
  * ====================================================
  * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
  *
  * Developed at SunPro, a Sun Microsystems, Inc. business.
  * Permission to use, copy, modify, and distribute this
  * software is freely granted, provided that this notice
  * is preserved.
  * ====================================================
  */
 
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
 #include "math.h"
 #include "math_private.h"
 
 static const float
 one =  1.0000000000e+00, /* 0x3F800000 */
 pi =  3.1415925026e+00, /* 0x40490fda */
 pio2_hi =  1.5707962513e+00; /* 0x3fc90fda */
 static volatile float
 pio2_lo =  7.5497894159e-08; /* 0x33a22168 */
 static const float
 pS0 =  1.6666586697e-01,
 pS1 = -4.2743422091e-02,
 pS2 = -8.6563630030e-03,
 qS1 = -7.0662963390e-01;
 
 float
-__ieee754_acosf(float x)
+acosf(float x)
 {
 	float z,p,q,r,w,s,c,df;
 	int32_t hx,ix;
 	GET_FLOAT_WORD(hx,x);
 	ix = hx&0x7fffffff;
 	if(ix>=0x3f800000) {		/* |x| >= 1 */
 	    if(ix==0x3f800000) {	/* |x| == 1 */
 		if(hx>0) return 0.0;	/* acos(1) = 0 */
 		else return pi+(float)2.0*pio2_lo;	/* acos(-1)= pi */
 	    }
 	    return (x-x)/(x-x);		/* acos(|x|>1) is NaN */
 	}
 	if(ix<0x3f000000) {	/* |x| < 0.5 */
 	    if(ix<=0x32800000) return pio2_hi+pio2_lo;/*if|x|<2**-26*/
 	    z = x*x;
 	    p = z*(pS0+z*(pS1+z*pS2));
 	    q = one+z*qS1;
 	    r = p/q;
 	    return pio2_hi - (x - (pio2_lo-x*r));
 	} else  if (hx<0) {		/* x < -0.5 */
 	    z = (one+x)*(float)0.5;
 	    p = z*(pS0+z*(pS1+z*pS2));
 	    q = one+z*qS1;
 	    s = sqrtf(z);
 	    r = p/q;
 	    w = r*s-pio2_lo;
 	    return pi - (float)2.0*(s+w);
 	} else {			/* x > 0.5 */
 	    int32_t idf;
 	    z = (one-x)*(float)0.5;
 	    s = sqrtf(z);
 	    df = s;
 	    GET_FLOAT_WORD(idf,df);
 	    SET_FLOAT_WORD(df,idf&0xfffff000);
 	    c  = (z-df*df)/(s+df);
 	    p = z*(pS0+z*(pS1+z*pS2));
 	    q = one+z*qS1;
 	    r = p/q;
 	    w = r*s+c;
 	    return (float)2.0*(df+w);
 	}
 }
diff --git a/lib/msun/src/e_acosh.c b/lib/msun/src/e_acosh.c
index 358c8bd6a636..7947995820d0 100644
--- a/lib/msun/src/e_acosh.c
+++ b/lib/msun/src/e_acosh.c
@@ -1,68 +1,68 @@
 
 /* @(#)e_acosh.c 1.3 95/01/18 */
 /*
  * ====================================================
  * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
  *
  * Developed at SunSoft, a Sun Microsystems, Inc. business.
  * Permission to use, copy, modify, and distribute this
  * software is freely granted, provided that this notice 
  * is preserved.
  * ====================================================
  *
  */
 
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
-/* __ieee754_acosh(x)
+/* acosh(x)
  * Method :
  *	Based on 
  *		acosh(x) = log [ x + sqrt(x*x-1) ]
  *	we have
  *		acosh(x) := log(x)+ln2,	if x is large; else
  *		acosh(x) := log(2x-1/(sqrt(x*x-1)+x)) if x>2; else
  *		acosh(x) := log1p(t+sqrt(2.0*t+t*t)); where t=x-1.
  *
  * Special cases:
  *	acosh(x) is NaN with signal if x<1.
  *	acosh(NaN) is NaN without signal.
  */
 
 #include <float.h>
 
 #include "math.h"
 #include "math_private.h"
 
 static const double
 one	= 1.0,
 ln2	= 6.93147180559945286227e-01;  /* 0x3FE62E42, 0xFEFA39EF */
 
 double
-__ieee754_acosh(double x)
+acosh(double x)
 {
 	double t;
 	int32_t hx;
 	u_int32_t lx;
 	EXTRACT_WORDS(hx,lx,x);
 	if(hx<0x3ff00000) {		/* x < 1 */
 	    return (x-x)/(x-x);
 	} else if(hx >=0x41b00000) {	/* x > 2**28 */
 	    if(hx >=0x7ff00000) {	/* x is inf of NaN */
 	        return x+x;
 	    } else 
-		return __ieee754_log(x)+ln2;	/* acosh(huge)=log(2x) */
+		return log(x)+ln2;	/* acosh(huge)=log(2x) */
 	} else if(((hx-0x3ff00000)|lx)==0) {
 	    return 0.0;			/* acosh(1) = 0 */
 	} else if (hx > 0x40000000) {	/* 2**28 > x > 2 */
 	    t=x*x;
-	    return __ieee754_log(2.0*x-one/(x+sqrt(t-one)));
+	    return log(2.0*x-one/(x+sqrt(t-one)));
 	} else {			/* 1<x<2 */
 	    t = x-one;
 	    return log1p(t+sqrt(2.0*t+t*t));
 	}
 }
 
 #if LDBL_MANT_DIG == 53
 __weak_reference(acosh, acoshl);
 #endif
diff --git a/lib/msun/src/e_acoshf.c b/lib/msun/src/e_acoshf.c
index f529b20d1219..781ccf2a1151 100644
--- a/lib/msun/src/e_acoshf.c
+++ b/lib/msun/src/e_acoshf.c
@@ -1,48 +1,48 @@
 /* e_acoshf.c -- float version of e_acosh.c.
  * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
  */
 
 /*
  * ====================================================
  * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
  *
  * Developed at SunPro, a Sun Microsystems, Inc. business.
  * Permission to use, copy, modify, and distribute this
  * software is freely granted, provided that this notice
  * is preserved.
  * ====================================================
  */
 
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
 #include "math.h"
 #include "math_private.h"
 
 static const float
 one	= 1.0,
 ln2	= 6.9314718246e-01;  /* 0x3f317218 */
 
 float
-__ieee754_acoshf(float x)
+acoshf(float x)
 {
 	float t;
 	int32_t hx;
 	GET_FLOAT_WORD(hx,x);
 	if(hx<0x3f800000) {		/* x < 1 */
 	    return (x-x)/(x-x);
 	} else if(hx >=0x4d800000) {	/* x > 2**28 */
 	    if(hx >=0x7f800000) {	/* x is inf of NaN */
 	        return x+x;
 	    } else
-		return __ieee754_logf(x)+ln2;	/* acosh(huge)=log(2x) */
+		return logf(x)+ln2;	/* acosh(huge)=log(2x) */
 	} else if (hx==0x3f800000) {
 	    return 0.0;			/* acosh(1) = 0 */
 	} else if (hx > 0x40000000) {	/* 2**28 > x > 2 */
 	    t=x*x;
-	    return __ieee754_logf((float)2.0*x-one/(x+__ieee754_sqrtf(t-one)));
+	    return logf((float)2.0*x-one/(x+sqrtf(t-one)));
 	} else {			/* 1<x<2 */
 	    t = x-one;
-	    return log1pf(t+__ieee754_sqrtf((float)2.0*t+t*t));
+	    return log1pf(t+sqrtf((float)2.0*t+t*t));
 	}
 }
diff --git a/lib/msun/src/e_asin.c b/lib/msun/src/e_asin.c
index 931b270498e6..fa180ab5701b 100644
--- a/lib/msun/src/e_asin.c
+++ b/lib/msun/src/e_asin.c
@@ -1,117 +1,117 @@
 
 /* @(#)e_asin.c 1.3 95/01/18 */
 /*
  * ====================================================
  * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
  *
  * Developed at SunSoft, a Sun Microsystems, Inc. business.
  * Permission to use, copy, modify, and distribute this
  * software is freely granted, provided that this notice
  * is preserved.
  * ====================================================
  */
 
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
-/* __ieee754_asin(x)
+/* asin(x)
  * Method :                  
  *	Since  asin(x) = x + x^3/6 + x^5*3/40 + x^7*15/336 + ...
  *	we approximate asin(x) on [0,0.5] by
  *		asin(x) = x + x*x^2*R(x^2)
  *	where
  *		R(x^2) is a rational approximation of (asin(x)-x)/x^3 
  *	and its remez error is bounded by
  *		|(asin(x)-x)/x^3 - R(x^2)| < 2^(-58.75)
  *
  *	For x in [0.5,1]
  *		asin(x) = pi/2-2*asin(sqrt((1-x)/2))
  *	Let y = (1-x), z = y/2, s := sqrt(z), and pio2_hi+pio2_lo=pi/2;
  *	then for x>0.98
  *		asin(x) = pi/2 - 2*(s+s*z*R(z))
  *			= pio2_hi - (2*(s+s*z*R(z)) - pio2_lo)
  *	For x<=0.98, let pio4_hi = pio2_hi/2, then
  *		f = hi part of s;
  *		c = sqrt(z) - f = (z-f*f)/(s+f) 	...f+c=sqrt(z)
  *	and
  *		asin(x) = pi/2 - 2*(s+s*z*R(z))
  *			= pio4_hi+(pio4-2s)-(2s*z*R(z)-pio2_lo)
  *			= pio4_hi+(pio4-2f)-(2s*z*R(z)-(pio2_lo+2c))
  *
  * Special cases:
  *	if x is NaN, return x itself;
  *	if |x|>1, return NaN with invalid signal.
  *
  */
 
 #include <float.h>
 
 #include "math.h"
 #include "math_private.h"
 
 static const double
 one =  1.00000000000000000000e+00, /* 0x3FF00000, 0x00000000 */
 huge =  1.000e+300,
 pio2_hi =  1.57079632679489655800e+00, /* 0x3FF921FB, 0x54442D18 */
 pio2_lo =  6.12323399573676603587e-17, /* 0x3C91A626, 0x33145C07 */
 pio4_hi =  7.85398163397448278999e-01, /* 0x3FE921FB, 0x54442D18 */
 	/* coefficient for R(x^2) */
 pS0 =  1.66666666666666657415e-01, /* 0x3FC55555, 0x55555555 */
 pS1 = -3.25565818622400915405e-01, /* 0xBFD4D612, 0x03EB6F7D */
 pS2 =  2.01212532134862925881e-01, /* 0x3FC9C155, 0x0E884455 */
 pS3 = -4.00555345006794114027e-02, /* 0xBFA48228, 0xB5688F3B */
 pS4 =  7.91534994289814532176e-04, /* 0x3F49EFE0, 0x7501B288 */
 pS5 =  3.47933107596021167570e-05, /* 0x3F023DE1, 0x0DFDF709 */
 qS1 = -2.40339491173441421878e+00, /* 0xC0033A27, 0x1C8A2D4B */
 qS2 =  2.02094576023350569471e+00, /* 0x40002AE5, 0x9C598AC8 */
 qS3 = -6.88283971605453293030e-01, /* 0xBFE6066C, 0x1B8D0159 */
 qS4 =  7.70381505559019352791e-02; /* 0x3FB3B8C5, 0xB12E9282 */
 
 double
-__ieee754_asin(double x)
+asin(double x)
 {
 	double t=0.0,w,p,q,c,r,s;
 	int32_t hx,ix;
 	GET_HIGH_WORD(hx,x);
 	ix = hx&0x7fffffff;
 	if(ix>= 0x3ff00000) {		/* |x|>= 1 */
 	    u_int32_t lx;
 	    GET_LOW_WORD(lx,x);
 	    if(((ix-0x3ff00000)|lx)==0)
 		    /* asin(1)=+-pi/2 with inexact */
 		return x*pio2_hi+x*pio2_lo;	
 	    return (x-x)/(x-x);		/* asin(|x|>1) is NaN */   
 	} else if (ix<0x3fe00000) {	/* |x|<0.5 */
 	    if(ix<0x3e500000) {		/* if |x| < 2**-26 */
 		if(huge+x>one) return x;/* return x with inexact if x!=0*/
 	    }
 	    t = x*x;
 	    p = t*(pS0+t*(pS1+t*(pS2+t*(pS3+t*(pS4+t*pS5)))));
 	    q = one+t*(qS1+t*(qS2+t*(qS3+t*qS4)));
 	    w = p/q;
 	    return x+x*w;
 	}
 	/* 1> |x|>= 0.5 */
 	w = one-fabs(x);
 	t = w*0.5;
 	p = t*(pS0+t*(pS1+t*(pS2+t*(pS3+t*(pS4+t*pS5)))));
 	q = one+t*(qS1+t*(qS2+t*(qS3+t*qS4)));
 	s = sqrt(t);
 	if(ix>=0x3FEF3333) { 	/* if |x| > 0.975 */
 	    w = p/q;
 	    t = pio2_hi-(2.0*(s+s*w)-pio2_lo);
 	} else {
 	    w  = s;
 	    SET_LOW_WORD(w,0);
 	    c  = (t-w*w)/(s+w);
 	    r  = p/q;
 	    p  = 2.0*s*r-(pio2_lo-2.0*c);
 	    q  = pio4_hi-2.0*w;
 	    t  = pio4_hi-(p-q);
 	}    
 	if(hx>0) return t; else return -t;    
 }
 
 #if LDBL_MANT_DIG == 53
 __weak_reference(asin, asinl);
 #endif
diff --git a/lib/msun/src/e_asinf.c b/lib/msun/src/e_asinf.c
index deaabb6a326e..db4b9b6034f7 100644
--- a/lib/msun/src/e_asinf.c
+++ b/lib/msun/src/e_asinf.c
@@ -1,65 +1,65 @@
 /* e_asinf.c -- float version of e_asin.c.
  * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
  */
 
 /*
  * ====================================================
  * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
  *
  * Developed at SunPro, a Sun Microsystems, Inc. business.
  * Permission to use, copy, modify, and distribute this
  * software is freely granted, provided that this notice
  * is preserved.
  * ====================================================
  */
 
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
 #include "math.h"
 #include "math_private.h"
 
 static const float
 one =  1.0000000000e+00, /* 0x3F800000 */
 huge =  1.000e+30,
 	/* coefficient for R(x^2) */
 pS0 =  1.6666586697e-01,
 pS1 = -4.2743422091e-02,
 pS2 = -8.6563630030e-03,
 qS1 = -7.0662963390e-01;
 
 static const double
 pio2 =  1.570796326794896558e+00;
 
 float
-__ieee754_asinf(float x)
+asinf(float x)
 {
 	double s;
 	float t,w,p,q;
 	int32_t hx,ix;
 	GET_FLOAT_WORD(hx,x);
 	ix = hx&0x7fffffff;
 	if(ix>=0x3f800000) {		/* |x| >= 1 */
 	    if(ix==0x3f800000)		/* |x| == 1 */
 		return x*pio2;		/* asin(+-1) = +-pi/2 with inexact */
 	    return (x-x)/(x-x);		/* asin(|x|>1) is NaN */
 	} else if (ix<0x3f000000) {	/* |x|<0.5 */
 	    if(ix<0x39800000) {		/* |x| < 2**-12 */
 		if(huge+x>one) return x;/* return x with inexact if x!=0*/
 	    }
 	    t = x*x;
 	    p = t*(pS0+t*(pS1+t*pS2));
 	    q = one+t*qS1;
 	    w = p/q;
 	    return x+x*w;
 	}
 	/* 1> |x|>= 0.5 */
 	w = one-fabsf(x);
 	t = w*(float)0.5;
 	p = t*(pS0+t*(pS1+t*pS2));
 	q = one+t*qS1;
 	s = sqrt(t);
 	w = p/q;
 	t = pio2-2.0*(s+s*w);
 	if(hx>0) return t; else return -t;
 }
diff --git a/lib/msun/src/e_atan2.c b/lib/msun/src/e_atan2.c
index 231a1611ee12..0b2e72102edb 100644
--- a/lib/msun/src/e_atan2.c
+++ b/lib/msun/src/e_atan2.c
@@ -1,129 +1,129 @@
 
 /* @(#)e_atan2.c 1.3 95/01/18 */
 /*
  * ====================================================
  * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
  *
  * Developed at SunSoft, a Sun Microsystems, Inc. business.
  * Permission to use, copy, modify, and distribute this
  * software is freely granted, provided that this notice 
  * is preserved.
  * ====================================================
  *
  */
 
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
-/* __ieee754_atan2(y,x)
+/* atan2(y,x)
  * Method :
  *	1. Reduce y to positive by atan2(y,x)=-atan2(-y,x).
  *	2. Reduce x to positive by (if x and y are unexceptional): 
  *		ARG (x+iy) = arctan(y/x)   	   ... if x > 0,
  *		ARG (x+iy) = pi - arctan[y/(-x)]   ... if x < 0,
  *
  * Special cases:
  *
  *	ATAN2((anything), NaN ) is NaN;
  *	ATAN2(NAN , (anything) ) is NaN;
  *	ATAN2(+-0, +(anything but NaN)) is +-0  ;
  *	ATAN2(+-0, -(anything but NaN)) is +-pi ;
  *	ATAN2(+-(anything but 0 and NaN), 0) is +-pi/2;
  *	ATAN2(+-(anything but INF and NaN), +INF) is +-0 ;
  *	ATAN2(+-(anything but INF and NaN), -INF) is +-pi;
  *	ATAN2(+-INF,+INF ) is +-pi/4 ;
  *	ATAN2(+-INF,-INF ) is +-3pi/4;
  *	ATAN2(+-INF, (anything but,0,NaN, and INF)) is +-pi/2;
  *
  * Constants:
  * The hexadecimal values are the intended ones for the following 
  * constants. The decimal values may be used, provided that the 
  * compiler will convert from decimal to binary accurately enough 
  * to produce the hexadecimal values shown.
  */
 
 #include <float.h>
 
 #include "math.h"
 #include "math_private.h"
 
 static volatile double
 tiny  = 1.0e-300;
 static const double
 zero  = 0.0,
 pi_o_4  = 7.8539816339744827900E-01, /* 0x3FE921FB, 0x54442D18 */
 pi_o_2  = 1.5707963267948965580E+00, /* 0x3FF921FB, 0x54442D18 */
 pi      = 3.1415926535897931160E+00; /* 0x400921FB, 0x54442D18 */
 static volatile double
 pi_lo   = 1.2246467991473531772E-16; /* 0x3CA1A626, 0x33145C07 */
 
 double
-__ieee754_atan2(double y, double x)
+atan2(double y, double x)
 {
 	double z;
 	int32_t k,m,hx,hy,ix,iy;
 	u_int32_t lx,ly;
 
 	EXTRACT_WORDS(hx,lx,x);
 	ix = hx&0x7fffffff;
 	EXTRACT_WORDS(hy,ly,y);
 	iy = hy&0x7fffffff;
 	if(((ix|((lx|-lx)>>31))>0x7ff00000)||
 	   ((iy|((ly|-ly)>>31))>0x7ff00000))	/* x or y is NaN */
 	    return nan_mix(x, y);
 	if(hx==0x3ff00000&&lx==0) return atan(y);   /* x=1.0 */
 	m = ((hy>>31)&1)|((hx>>30)&2);	/* 2*sign(x)+sign(y) */
 
     /* when y = 0 */
 	if((iy|ly)==0) {
 	    switch(m) {
 		case 0: 
 		case 1: return y; 	/* atan(+-0,+anything)=+-0 */
 		case 2: return  pi+tiny;/* atan(+0,-anything) = pi */
 		case 3: return -pi-tiny;/* atan(-0,-anything) =-pi */
 	    }
 	}
     /* when x = 0 */
 	if((ix|lx)==0) return (hy<0)?  -pi_o_2-tiny: pi_o_2+tiny;
 	    
     /* when x is INF */
 	if(ix==0x7ff00000) {
 	    if(iy==0x7ff00000) {
 		switch(m) {
 		    case 0: return  pi_o_4+tiny;/* atan(+INF,+INF) */
 		    case 1: return -pi_o_4-tiny;/* atan(-INF,+INF) */
 		    case 2: return  3.0*pi_o_4+tiny;/*atan(+INF,-INF)*/
 		    case 3: return -3.0*pi_o_4-tiny;/*atan(-INF,-INF)*/
 		}
 	    } else {
 		switch(m) {
 		    case 0: return  zero  ;	/* atan(+...,+INF) */
 		    case 1: return -zero  ;	/* atan(-...,+INF) */
 		    case 2: return  pi+tiny  ;	/* atan(+...,-INF) */
 		    case 3: return -pi-tiny  ;	/* atan(-...,-INF) */
 		}
 	    }
 	}
     /* when y is INF */
 	if(iy==0x7ff00000) return (hy<0)? -pi_o_2-tiny: pi_o_2+tiny;
 
     /* compute y/x */
 	k = (iy-ix)>>20;
 	if(k > 60) {		 	/* |y/x| >  2**60 */
 	    z=pi_o_2+0.5*pi_lo;
 	    m&=1;
 	}
 	else if(hx<0&&k<-60) z=0.0; 	/* 0 > |y|/x > -2**-60 */
 	else z=atan(fabs(y/x));		/* safe to do y/x */
 	switch (m) {
 	    case 0: return       z  ;	/* atan(+,+) */
 	    case 1: return      -z  ;	/* atan(-,+) */
 	    case 2: return  pi-(z-pi_lo);/* atan(+,-) */
 	    default: /* case 3 */
 	    	    return  (z-pi_lo)-pi;/* atan(-,-) */
 	}
 }
 
 #if LDBL_MANT_DIG == 53
 __weak_reference(atan2, atan2l);
 #endif
diff --git a/lib/msun/src/e_atan2f.c b/lib/msun/src/e_atan2f.c
index 346d76746c05..4ea001df974a 100644
--- a/lib/msun/src/e_atan2f.c
+++ b/lib/msun/src/e_atan2f.c
@@ -1,96 +1,96 @@
 /* e_atan2f.c -- float version of e_atan2.c.
  * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
  */
 
 /*
  * ====================================================
  * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
  *
  * Developed at SunPro, a Sun Microsystems, Inc. business.
  * Permission to use, copy, modify, and distribute this
  * software is freely granted, provided that this notice
  * is preserved.
  * ====================================================
  */
 
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
 #include "math.h"
 #include "math_private.h"
 
 static volatile float
 tiny  = 1.0e-30;
 static const float
 zero  = 0.0,
 pi_o_4  = 7.8539818525e-01, /* 0x3f490fdb */
 pi_o_2  = 1.5707963705e+00, /* 0x3fc90fdb */
 pi      = 3.1415927410e+00; /* 0x40490fdb */
 static volatile float
 pi_lo   = -8.7422776573e-08; /* 0xb3bbbd2e */
 
 float
-__ieee754_atan2f(float y, float x)
+atan2f(float y, float x)
 {
 	float z;
 	int32_t k,m,hx,hy,ix,iy;
 
 	GET_FLOAT_WORD(hx,x);
 	ix = hx&0x7fffffff;
 	GET_FLOAT_WORD(hy,y);
 	iy = hy&0x7fffffff;
 	if((ix>0x7f800000)||
 	   (iy>0x7f800000))	/* x or y is NaN */
 	    return nan_mix(x, y);
 	if(hx==0x3f800000) return atanf(y);   /* x=1.0 */
 	m = ((hy>>31)&1)|((hx>>30)&2);	/* 2*sign(x)+sign(y) */
 
     /* when y = 0 */
 	if(iy==0) {
 	    switch(m) {
 		case 0:
 		case 1: return y; 	/* atan(+-0,+anything)=+-0 */
 		case 2: return  pi+tiny;/* atan(+0,-anything) = pi */
 		case 3: return -pi-tiny;/* atan(-0,-anything) =-pi */
 	    }
 	}
     /* when x = 0 */
 	if(ix==0) return (hy<0)?  -pi_o_2-tiny: pi_o_2+tiny;
 
     /* when x is INF */
 	if(ix==0x7f800000) {
 	    if(iy==0x7f800000) {
 		switch(m) {
 		    case 0: return  pi_o_4+tiny;/* atan(+INF,+INF) */
 		    case 1: return -pi_o_4-tiny;/* atan(-INF,+INF) */
 		    case 2: return  (float)3.0*pi_o_4+tiny;/*atan(+INF,-INF)*/
 		    case 3: return (float)-3.0*pi_o_4-tiny;/*atan(-INF,-INF)*/
 		}
 	    } else {
 		switch(m) {
 		    case 0: return  zero  ;	/* atan(+...,+INF) */
 		    case 1: return -zero  ;	/* atan(-...,+INF) */
 		    case 2: return  pi+tiny  ;	/* atan(+...,-INF) */
 		    case 3: return -pi-tiny  ;	/* atan(-...,-INF) */
 		}
 	    }
 	}
     /* when y is INF */
 	if(iy==0x7f800000) return (hy<0)? -pi_o_2-tiny: pi_o_2+tiny;
 
     /* compute y/x */
 	k = (iy-ix)>>23;
 	if(k > 26) {			/* |y/x| >  2**26 */
 	    z=pi_o_2+(float)0.5*pi_lo;
 	    m&=1;
 	}
 	else if(k<-26&&hx<0) z=0.0; 	/* 0 > |y|/x > -2**-26 */
 	else z=atanf(fabsf(y/x));	/* safe to do y/x */
 	switch (m) {
 	    case 0: return       z  ;	/* atan(+,+) */
 	    case 1: return      -z  ;	/* atan(-,+) */
 	    case 2: return  pi-(z-pi_lo);/* atan(+,-) */
 	    default: /* case 3 */
 	    	    return  (z-pi_lo)-pi;/* atan(-,-) */
 	}
 }
diff --git a/lib/msun/src/e_atanh.c b/lib/msun/src/e_atanh.c
index 422ff2698067..41f3bcaca26d 100644
--- a/lib/msun/src/e_atanh.c
+++ b/lib/msun/src/e_atanh.c
@@ -1,68 +1,68 @@
 
 /* @(#)e_atanh.c 1.3 95/01/18 */
 /*
  * ====================================================
  * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
  *
  * Developed at SunSoft, a Sun Microsystems, Inc. business.
  * Permission to use, copy, modify, and distribute this
  * software is freely granted, provided that this notice 
  * is preserved.
  * ====================================================
  *
  */
 
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
-/* __ieee754_atanh(x)
+/* atanh(x)
  * Method :
  *    1.Reduced x to positive by atanh(-x) = -atanh(x)
  *    2.For x>=0.5
  *                  1              2x                          x
  *	atanh(x) = --- * log(1 + -------) = 0.5 * log1p(2 * --------)
  *                  2             1 - x                      1 - x
  *	
  * 	For x<0.5
  *	atanh(x) = 0.5*log1p(2x+2x*x/(1-x))
  *
  * Special cases:
  *	atanh(x) is NaN if |x| > 1 with signal;
  *	atanh(NaN) is that NaN with no signal;
  *	atanh(+-1) is +-INF with signal.
  *
  */
 
 #include <float.h>
 
 #include "math.h"
 #include "math_private.h"
 
 static const double one = 1.0, huge = 1e300;
 static const double zero = 0.0;
 
 double
-__ieee754_atanh(double x)
+atanh(double x)
 {
 	double t;
 	int32_t hx,ix;
 	u_int32_t lx;
 	EXTRACT_WORDS(hx,lx,x);
 	ix = hx&0x7fffffff;
 	if ((ix|((lx|(-lx))>>31))>0x3ff00000) /* |x|>1 */
 	    return (x-x)/(x-x);
 	if(ix==0x3ff00000) 
 	    return x/zero;
 	if(ix<0x3e300000&&(huge+x)>zero) return x;	/* x<2**-28 */
 	SET_HIGH_WORD(x,ix);
 	if(ix<0x3fe00000) {		/* x < 0.5 */
 	    t = x+x;
 	    t = 0.5*log1p(t+t*x/(one-x));
 	} else 
 	    t = 0.5*log1p((x+x)/(one-x));
 	if(hx>=0) return t; else return -t;
 }
 
 #if LDBL_MANT_DIG == 53
 __weak_reference(atanh, atanhl);
 #endif
diff --git a/lib/msun/src/e_atanhf.c b/lib/msun/src/e_atanhf.c
index 4bd6a8f9b9c6..46643beb5ab0 100644
--- a/lib/msun/src/e_atanhf.c
+++ b/lib/msun/src/e_atanhf.c
@@ -1,45 +1,45 @@
 /* e_atanhf.c -- float version of e_atanh.c.
  * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
  */
 
 /*
  * ====================================================
  * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
  *
  * Developed at SunPro, a Sun Microsystems, Inc. business.
  * Permission to use, copy, modify, and distribute this
  * software is freely granted, provided that this notice
  * is preserved.
  * ====================================================
  */
 
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
 #include "math.h"
 #include "math_private.h"
 
 static const float one = 1.0, huge = 1e30;
 
 static const float zero = 0.0;
 
 float
-__ieee754_atanhf(float x)
+atanhf(float x)
 {
 	float t;
 	int32_t hx,ix;
 	GET_FLOAT_WORD(hx,x);
 	ix = hx&0x7fffffff;
 	if (ix>0x3f800000) 		/* |x|>1 */
 	    return (x-x)/(x-x);
 	if(ix==0x3f800000)
 	    return x/zero;
 	if(ix<0x31800000&&(huge+x)>zero) return x;	/* x<2**-28 */
 	SET_FLOAT_WORD(x,ix);
 	if(ix<0x3f000000) {		/* x < 0.5 */
 	    t = x+x;
 	    t = (float)0.5*log1pf(t+t*x/(one-x));
 	} else
 	    t = (float)0.5*log1pf((x+x)/(one-x));
 	if(hx>=0) return t; else return -t;
 }
diff --git a/lib/msun/src/e_cosh.c b/lib/msun/src/e_cosh.c
index 246b5fbec860..071663eb4e15 100644
--- a/lib/msun/src/e_cosh.c
+++ b/lib/msun/src/e_cosh.c
@@ -1,85 +1,85 @@
 
 /* @(#)e_cosh.c 1.3 95/01/18 */
 /*
  * ====================================================
  * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
  *
  * Developed at SunSoft, a Sun Microsystems, Inc. business.
  * Permission to use, copy, modify, and distribute this
  * software is freely granted, provided that this notice 
  * is preserved.
  * ====================================================
  */
 
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
-/* __ieee754_cosh(x)
+/* cosh(x)
  * Method : 
  * mathematically cosh(x) if defined to be (exp(x)+exp(-x))/2
  *	1. Replace x by |x| (cosh(x) = cosh(-x)). 
  *	2. 
  *		                                        [ exp(x) - 1 ]^2 
  *	    0        <= x <= ln2/2  :  cosh(x) := 1 + -------------------
  *			       			           2*exp(x)
  *
  *		                                  exp(x) +  1/exp(x)
  *	    ln2/2    <= x <= 22     :  cosh(x) := -------------------
  *			       			          2
  *	    22       <= x <= lnovft :  cosh(x) := exp(x)/2 
  *	    lnovft   <= x <= ln2ovft:  cosh(x) := exp(x/2)/2 * exp(x/2)
  *	    ln2ovft  <  x	    :  cosh(x) := huge*huge (overflow)
  *
  * Special cases:
  *	cosh(x) is |x| if x is +INF, -INF, or NaN.
  *	only cosh(0)=1 is exact for finite x.
  */
 
 #include <float.h>
 
 #include "math.h"
 #include "math_private.h"
 
 static const double one = 1.0, half=0.5, huge = 1.0e300;
 
 double
-__ieee754_cosh(double x)
+cosh(double x)
 {
 	double t,w;
 	int32_t ix;
 
     /* High word of |x|. */
 	GET_HIGH_WORD(ix,x);
 	ix &= 0x7fffffff;
 
     /* x is INF or NaN */
 	if(ix>=0x7ff00000) return x*x;	
 
     /* |x| in [0,0.5*ln2], return 1+expm1(|x|)^2/(2*exp(|x|)) */
 	if(ix<0x3fd62e43) {
 	    t = expm1(fabs(x));
 	    w = one+t;
 	    if (ix<0x3c800000) return w;	/* cosh(tiny) = 1 */
 	    return one+(t*t)/(w+w);
 	}
 
     /* |x| in [0.5*ln2,22], return (exp(|x|)+1/exp(|x|)/2; */
 	if (ix < 0x40360000) {
-		t = __ieee754_exp(fabs(x));
+		t = exp(fabs(x));
 		return half*t+half/t;
 	}
 
     /* |x| in [22, log(maxdouble)] return half*exp(|x|) */
-	if (ix < 0x40862E42)  return half*__ieee754_exp(fabs(x));
+	if (ix < 0x40862E42)  return half*exp(fabs(x));
 
     /* |x| in [log(maxdouble), overflowthresold] */
 	if (ix<=0x408633CE)
 	    return __ldexp_exp(fabs(x), -1);
 
     /* |x| > overflowthresold, cosh(x) overflow */
 	return huge*huge;
 }
 
 #if (LDBL_MANT_DIG == 53)
 __weak_reference(cosh, coshl);
 #endif
diff --git a/lib/msun/src/e_coshf.c b/lib/msun/src/e_coshf.c
index 95a0d6ee68ba..1673315d7b31 100644
--- a/lib/msun/src/e_coshf.c
+++ b/lib/msun/src/e_coshf.c
@@ -1,59 +1,59 @@
 /* e_coshf.c -- float version of e_cosh.c.
  * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
  */
 
 /*
  * ====================================================
  * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
  *
  * Developed at SunPro, a Sun Microsystems, Inc. business.
  * Permission to use, copy, modify, and distribute this
  * software is freely granted, provided that this notice
  * is preserved.
  * ====================================================
  */
 
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
 #include "math.h"
 #include "math_private.h"
 
 static const float one = 1.0, half=0.5, huge = 1.0e30;
 
 float
-__ieee754_coshf(float x)
+coshf(float x)
 {
 	float t,w;
 	int32_t ix;
 
 	GET_FLOAT_WORD(ix,x);
 	ix &= 0x7fffffff;
 
     /* x is INF or NaN */
 	if(ix>=0x7f800000) return x*x;
 
     /* |x| in [0,0.5*ln2], return 1+expm1(|x|)^2/(2*exp(|x|)) */
 	if(ix<0x3eb17218) {
 	    t = expm1f(fabsf(x));
 	    w = one+t;
 	    if (ix<0x39800000) return one;	/* cosh(tiny) = 1 */
 	    return one+(t*t)/(w+w);
 	}
 
     /* |x| in [0.5*ln2,9], return (exp(|x|)+1/exp(|x|))/2; */
 	if (ix < 0x41100000) {
-		t = __ieee754_expf(fabsf(x));
+		t = expf(fabsf(x));
 		return half*t+half/t;
 	}
 
     /* |x| in [9, log(maxfloat)] return half*exp(|x|) */
-	if (ix < 0x42b17217)  return half*__ieee754_expf(fabsf(x));
+	if (ix < 0x42b17217)  return half*expf(fabsf(x));
 
     /* |x| in [log(maxfloat), overflowthresold] */
 	if (ix<=0x42b2d4fc)
 	    return __ldexp_expf(fabsf(x), -1);
 
     /* |x| > overflowthresold, cosh(x) overflow */
 	return huge*huge;
 }
diff --git a/lib/msun/src/e_exp.c b/lib/msun/src/e_exp.c
index dd04d8e839d5..59da39217391 100644
--- a/lib/msun/src/e_exp.c
+++ b/lib/msun/src/e_exp.c
@@ -1,164 +1,164 @@
 
 /* @(#)e_exp.c 1.6 04/04/22 */
 /*
  * ====================================================
  * Copyright (C) 2004 by Sun Microsystems, Inc. All rights reserved.
  *
  * Permission to use, copy, modify, and distribute this
  * software is freely granted, provided that this notice 
  * is preserved.
  * ====================================================
  */
 
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
-/* __ieee754_exp(x)
+/* exp(x)
  * Returns the exponential of x.
  *
  * Method
  *   1. Argument reduction:
  *      Reduce x to an r so that |r| <= 0.5*ln2 ~ 0.34658.
  *	Given x, find r and integer k such that
  *
  *               x = k*ln2 + r,  |r| <= 0.5*ln2.  
  *
  *      Here r will be represented as r = hi-lo for better 
  *	accuracy.
  *
  *   2. Approximation of exp(r) by a special rational function on
  *	the interval [0,0.34658]:
  *	Write
  *	    R(r**2) = r*(exp(r)+1)/(exp(r)-1) = 2 + r*r/6 - r**4/360 + ...
  *      We use a special Remes algorithm on [0,0.34658] to generate 
  * 	a polynomial of degree 5 to approximate R. The maximum error 
  *	of this polynomial approximation is bounded by 2**-59. In
  *	other words,
  *	    R(z) ~ 2.0 + P1*z + P2*z**2 + P3*z**3 + P4*z**4 + P5*z**5
  *  	(where z=r*r, and the values of P1 to P5 are listed below)
  *	and
  *	    |                  5          |     -59
  *	    | 2.0+P1*z+...+P5*z   -  R(z) | <= 2 
  *	    |                             |
  *	The computation of exp(r) thus becomes
  *                             2*r
  *		exp(r) = 1 + -------
  *		              R - r
  *                                 r*R1(r)	
  *		       = 1 + r + ----------- (for better accuracy)
  *		                  2 - R1(r)
  *	where
  *			         2       4             10
  *		R1(r) = r - (P1*r  + P2*r  + ... + P5*r   ).
  *	
  *   3. Scale back to obtain exp(x):
  *	From step 1, we have
  *	   exp(x) = 2^k * exp(r)
  *
  * Special cases:
  *	exp(INF) is INF, exp(NaN) is NaN;
  *	exp(-INF) is 0, and
  *	for finite argument, only exp(0)=1 is exact.
  *
  * Accuracy:
  *	according to an error analysis, the error is always less than
  *	1 ulp (unit in the last place).
  *
  * Misc. info.
  *	For IEEE double 
  *	    if x >  7.09782712893383973096e+02 then exp(x) overflow
  *	    if x < -7.45133219101941108420e+02 then exp(x) underflow
  *
  * Constants:
  * The hexadecimal values are the intended ones for the following 
  * constants. The decimal values may be used, provided that the 
  * compiler will convert from decimal to binary accurately enough
  * to produce the hexadecimal values shown.
  */
 
 #include <float.h>
 
 #include "math.h"
 #include "math_private.h"
 
 static const double
 one	= 1.0,
 halF[2]	= {0.5,-0.5,},
 o_threshold=  7.09782712893383973096e+02,  /* 0x40862E42, 0xFEFA39EF */
 u_threshold= -7.45133219101941108420e+02,  /* 0xc0874910, 0xD52D3051 */
 ln2HI[2]   ={ 6.93147180369123816490e-01,  /* 0x3fe62e42, 0xfee00000 */
 	     -6.93147180369123816490e-01,},/* 0xbfe62e42, 0xfee00000 */
 ln2LO[2]   ={ 1.90821492927058770002e-10,  /* 0x3dea39ef, 0x35793c76 */
 	     -1.90821492927058770002e-10,},/* 0xbdea39ef, 0x35793c76 */
 invln2 =  1.44269504088896338700e+00, /* 0x3ff71547, 0x652b82fe */
 P1   =  1.66666666666666019037e-01, /* 0x3FC55555, 0x5555553E */
 P2   = -2.77777777770155933842e-03, /* 0xBF66C16C, 0x16BEBD93 */
 P3   =  6.61375632143793436117e-05, /* 0x3F11566A, 0xAF25DE2C */
 P4   = -1.65339022054652515390e-06, /* 0xBEBBBD41, 0xC5D26BF1 */
 P5   =  4.13813679705723846039e-08; /* 0x3E663769, 0x72BEA4D0 */
 
 static volatile double
 huge	= 1.0e+300,
 twom1000= 9.33263618503218878990e-302;     /* 2**-1000=0x01700000,0*/
 
 double
-__ieee754_exp(double x)	/* default IEEE double exp */
+exp(double x)	/* default IEEE double exp */
 {
 	double y,hi=0.0,lo=0.0,c,t,twopk;
 	int32_t k=0,xsb;
 	u_int32_t hx;
 
 	GET_HIGH_WORD(hx,x);
 	xsb = (hx>>31)&1;		/* sign bit of x */
 	hx &= 0x7fffffff;		/* high word of |x| */
 
     /* filter out non-finite argument */
 	if(hx >= 0x40862E42) {			/* if |x|>=709.78... */
             if(hx>=0x7ff00000) {
 	        u_int32_t lx;
 		GET_LOW_WORD(lx,x);
 		if(((hx&0xfffff)|lx)!=0)
 		     return x+x; 		/* NaN */
 		else return (xsb==0)? x:0.0;	/* exp(+-inf)={inf,0} */
 	    }
 	    if(x > o_threshold) return huge*huge; /* overflow */
 	    if(x < u_threshold) return twom1000*twom1000; /* underflow */
 	}
 
     /* argument reduction */
 	if(hx > 0x3fd62e42) {		/* if  |x| > 0.5 ln2 */ 
 	    if(hx < 0x3FF0A2B2) {	/* and |x| < 1.5 ln2 */
 		hi = x-ln2HI[xsb]; lo=ln2LO[xsb]; k = 1-xsb-xsb;
 	    } else {
 		k  = (int)(invln2*x+halF[xsb]);
 		t  = k;
 		hi = x - t*ln2HI[0];	/* t*ln2HI is exact here */
 		lo = t*ln2LO[0];
 	    }
 	    STRICT_ASSIGN(double, x, hi - lo);
 	} 
 	else if(hx < 0x3e300000)  {	/* when |x|<2**-28 */
 	    if(huge+x>one) return one+x;/* trigger inexact */
 	}
 	else k = 0;
 
     /* x is now in primary range */
 	t  = x*x;
 	if(k >= -1021)
 	    INSERT_WORDS(twopk,((u_int32_t)(0x3ff+k))<<20, 0);
 	else
 	    INSERT_WORDS(twopk,((u_int32_t)(0x3ff+(k+1000)))<<20, 0);
 	c  = x - t*(P1+t*(P2+t*(P3+t*(P4+t*P5))));
 	if(k==0) 	return one-((x*c)/(c-2.0)-x); 
 	else 		y = one-((lo-(x*c)/(2.0-c))-hi);
 	if(k >= -1021) {
 	    if (k==1024) return y*2.0*0x1p1023;
 	    return y*twopk;
 	} else {
 	    return y*twopk*twom1000;
 	}
 }
 
 #if (LDBL_MANT_DIG == 53)
 __weak_reference(exp, expl);
 #endif
diff --git a/lib/msun/src/e_expf.c b/lib/msun/src/e_expf.c
index 4903d55c5ab3..620d341be274 100644
--- a/lib/msun/src/e_expf.c
+++ b/lib/msun/src/e_expf.c
@@ -1,98 +1,98 @@
 /* e_expf.c -- float version of e_exp.c.
  * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
  */
 
 /*
  * ====================================================
  * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
  *
  * Developed at SunPro, a Sun Microsystems, Inc. business.
  * Permission to use, copy, modify, and distribute this
  * software is freely granted, provided that this notice
  * is preserved.
  * ====================================================
  */
 
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
 #include <float.h>
 
 #include "math.h"
 #include "math_private.h"
 
 static const float
 one	= 1.0,
 halF[2]	= {0.5,-0.5,},
 o_threshold=  8.8721679688e+01,  /* 0x42b17180 */
 u_threshold= -1.0397208405e+02,  /* 0xc2cff1b5 */
 ln2HI[2]   ={ 6.9314575195e-01,		/* 0x3f317200 */
 	     -6.9314575195e-01,},	/* 0xbf317200 */
 ln2LO[2]   ={ 1.4286067653e-06,  	/* 0x35bfbe8e */
 	     -1.4286067653e-06,},	/* 0xb5bfbe8e */
 invln2 =  1.4426950216e+00, 		/* 0x3fb8aa3b */
 /*
  * Domain [-0.34568, 0.34568], range ~[-4.278e-9, 4.447e-9]:
  * |x*(exp(x)+1)/(exp(x)-1) - p(x)| < 2**-27.74
  */
 P1 =  1.6666625440e-1,		/*  0xaaaa8f.0p-26 */
 P2 = -2.7667332906e-3;		/* -0xb55215.0p-32 */
 
 static volatile float
 huge	= 1.0e+30,
 twom100 = 7.8886090522e-31;      /* 2**-100=0x0d800000 */
 
 float
-__ieee754_expf(float x)
+expf(float x)
 {
 	float y,hi=0.0,lo=0.0,c,t,twopk;
 	int32_t k=0,xsb;
 	u_int32_t hx;
 
 	GET_FLOAT_WORD(hx,x);
 	xsb = (hx>>31)&1;		/* sign bit of x */
 	hx &= 0x7fffffff;		/* high word of |x| */
 
     /* filter out non-finite argument */
 	if(hx >= 0x42b17218) {			/* if |x|>=88.721... */
 	    if(hx>0x7f800000)
 		 return x+x;	 		/* NaN */
             if(hx==0x7f800000)
 		return (xsb==0)? x:0.0;		/* exp(+-inf)={inf,0} */
 	    if(x > o_threshold) return huge*huge; /* overflow */
 	    if(x < u_threshold) return twom100*twom100; /* underflow */
 	}
 
     /* argument reduction */
 	if(hx > 0x3eb17218) {		/* if  |x| > 0.5 ln2 */
 	    if(hx < 0x3F851592) {	/* and |x| < 1.5 ln2 */
 		hi = x-ln2HI[xsb]; lo=ln2LO[xsb]; k = 1-xsb-xsb;
 	    } else {
 		k  = invln2*x+halF[xsb];
 		t  = k;
 		hi = x - t*ln2HI[0];	/* t*ln2HI is exact here */
 		lo = t*ln2LO[0];
 	    }
 	    STRICT_ASSIGN(float, x, hi - lo);
 	}
 	else if(hx < 0x39000000)  {	/* when |x|<2**-14 */
 	    if(huge+x>one) return one+x;/* trigger inexact */
 	}
 	else k = 0;
 
     /* x is now in primary range */
 	t  = x*x;
 	if(k >= -125)
 	    SET_FLOAT_WORD(twopk,((u_int32_t)(0x7f+k))<<23);
 	else
 	    SET_FLOAT_WORD(twopk,((u_int32_t)(0x7f+(k+100)))<<23);
 	c  = x - t*(P1+t*P2);
 	if(k==0) 	return one-((x*c)/(c-(float)2.0)-x);
 	else 		y = one-((lo-(x*c)/((float)2.0-c))-hi);
 	if(k >= -125) {
 	    if(k==128) return y*2.0F*0x1p127F;
 	    return y*twopk;
 	} else {
 	    return y*twopk*twom100;
 	}
 }
diff --git a/lib/msun/src/e_fmod.c b/lib/msun/src/e_fmod.c
index 3a28dc4ff1f3..6d5f5332cb85 100644
--- a/lib/msun/src/e_fmod.c
+++ b/lib/msun/src/e_fmod.c
@@ -1,138 +1,138 @@
 
 /* @(#)e_fmod.c 1.3 95/01/18 */
 /*
  * ====================================================
  * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
  *
  * Developed at SunSoft, a Sun Microsystems, Inc. business.
  * Permission to use, copy, modify, and distribute this
  * software is freely granted, provided that this notice 
  * is preserved.
  * ====================================================
  */
 
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
 /* 
- * __ieee754_fmod(x,y)
+ * fmod(x,y)
  * Return x mod y in exact arithmetic
  * Method: shift and subtract
  */
 
 #include <float.h>
 
 #include "math.h"
 #include "math_private.h"
 
 static const double one = 1.0, Zero[] = {0.0, -0.0,};
 
 double
-__ieee754_fmod(double x, double y)
+fmod(double x, double y)
 {
 	int32_t n,hx,hy,hz,ix,iy,sx,i;
 	u_int32_t lx,ly,lz;
 
 	EXTRACT_WORDS(hx,lx,x);
 	EXTRACT_WORDS(hy,ly,y);
 	sx = hx&0x80000000;		/* sign of x */
 	hx ^=sx;		/* |x| */
 	hy &= 0x7fffffff;	/* |y| */
 
     /* purge off exception values */
 	if((hy|ly)==0||(hx>=0x7ff00000)||	/* y=0,or x not finite */
 	  ((hy|((ly|-ly)>>31))>0x7ff00000))	/* or y is NaN */
 	    return nan_mix_op(x, y, *)/nan_mix_op(x, y, *);
 	if(hx<=hy) {
 	    if((hx<hy)||(lx<ly)) return x;	/* |x|<|y| return x */
 	    if(lx==ly) 
 		return Zero[(u_int32_t)sx>>31];	/* |x|=|y| return x*0*/
 	}
 
     /* determine ix = ilogb(x) */
 	if(hx<0x00100000) {	/* subnormal x */
 	    if(hx==0) {
 		for (ix = -1043, i=lx; i>0; i<<=1) ix -=1;
 	    } else {
 		for (ix = -1022,i=(hx<<11); i>0; i<<=1) ix -=1;
 	    }
 	} else ix = (hx>>20)-1023;
 
     /* determine iy = ilogb(y) */
 	if(hy<0x00100000) {	/* subnormal y */
 	    if(hy==0) {
 		for (iy = -1043, i=ly; i>0; i<<=1) iy -=1;
 	    } else {
 		for (iy = -1022,i=(hy<<11); i>0; i<<=1) iy -=1;
 	    }
 	} else iy = (hy>>20)-1023;
 
     /* set up {hx,lx}, {hy,ly} and align y to x */
 	if(ix >= -1022) 
 	    hx = 0x00100000|(0x000fffff&hx);
 	else {		/* subnormal x, shift x to normal */
 	    n = -1022-ix;
 	    if(n<=31) {
 	        hx = (hx<<n)|(lx>>(32-n));
 	        lx <<= n;
 	    } else {
 		hx = lx<<(n-32);
 		lx = 0;
 	    }
 	}
 	if(iy >= -1022) 
 	    hy = 0x00100000|(0x000fffff&hy);
 	else {		/* subnormal y, shift y to normal */
 	    n = -1022-iy;
 	    if(n<=31) {
 	        hy = (hy<<n)|(ly>>(32-n));
 	        ly <<= n;
 	    } else {
 		hy = ly<<(n-32);
 		ly = 0;
 	    }
 	}
 
     /* fix point fmod */
 	n = ix - iy;
 	while(n--) {
 	    hz=hx-hy;lz=lx-ly; if(lx<ly) hz -= 1;
 	    if(hz<0){hx = hx+hx+(lx>>31); lx = lx+lx;}
 	    else {
 	    	if((hz|lz)==0) 		/* return sign(x)*0 */
 		    return Zero[(u_int32_t)sx>>31];
 	    	hx = hz+hz+(lz>>31); lx = lz+lz;
 	    }
 	}
 	hz=hx-hy;lz=lx-ly; if(lx<ly) hz -= 1;
 	if(hz>=0) {hx=hz;lx=lz;}
 
     /* convert back to floating value and restore the sign */
 	if((hx|lx)==0) 			/* return sign(x)*0 */
 	    return Zero[(u_int32_t)sx>>31];
 	while(hx<0x00100000) {		/* normalize x */
 	    hx = hx+hx+(lx>>31); lx = lx+lx;
 	    iy -= 1;
 	}
 	if(iy>= -1022) {	/* normalize output */
 	    hx = ((hx-0x00100000)|((iy+1023)<<20));
 	    INSERT_WORDS(x,hx|sx,lx);
 	} else {		/* subnormal output */
 	    n = -1022 - iy;
 	    if(n<=20) {
 		lx = (lx>>n)|((u_int32_t)hx<<(32-n));
 		hx >>= n;
 	    } else if (n<=31) {
 		lx = (hx<<(32-n))|(lx>>n); hx = sx;
 	    } else {
 		lx = hx>>(n-32); hx = sx;
 	    }
 	    INSERT_WORDS(x,hx|sx,lx);
 	    x *= one;		/* create necessary signal */
 	}
 	return x;		/* exact output */
 }
 
 #if (LDBL_MANT_DIG == 53)
 __weak_reference(fmod, fmodl);
 #endif
diff --git a/lib/msun/src/e_fmodf.c b/lib/msun/src/e_fmodf.c
index 1b6bf36f9cba..3cef9213c1e5 100644
--- a/lib/msun/src/e_fmodf.c
+++ b/lib/msun/src/e_fmodf.c
@@ -1,104 +1,104 @@
 /* e_fmodf.c -- float version of e_fmod.c.
  * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
  */
 
 /*
  * ====================================================
  * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
  *
  * Developed at SunPro, a Sun Microsystems, Inc. business.
  * Permission to use, copy, modify, and distribute this
  * software is freely granted, provided that this notice
  * is preserved.
  * ====================================================
  */
 
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
 /*
- * __ieee754_fmodf(x,y)
+ * fmodf(x,y)
  * Return x mod y in exact arithmetic
  * Method: shift and subtract
  */
 
 #include "math.h"
 #include "math_private.h"
 
 static const float one = 1.0, Zero[] = {0.0, -0.0,};
 
 float
-__ieee754_fmodf(float x, float y)
+fmodf(float x, float y)
 {
 	int32_t n,hx,hy,hz,ix,iy,sx,i;
 
 	GET_FLOAT_WORD(hx,x);
 	GET_FLOAT_WORD(hy,y);
 	sx = hx&0x80000000;		/* sign of x */
 	hx ^=sx;		/* |x| */
 	hy &= 0x7fffffff;	/* |y| */
 
     /* purge off exception values */
 	if(hy==0||(hx>=0x7f800000)||		/* y=0,or x not finite */
 	   (hy>0x7f800000))			/* or y is NaN */
 	    return nan_mix_op(x, y, *)/nan_mix_op(x, y, *);
 	if(hx<hy) return x;			/* |x|<|y| return x */
 	if(hx==hy)
 	    return Zero[(u_int32_t)sx>>31];	/* |x|=|y| return x*0*/
 
     /* determine ix = ilogb(x) */
 	if(hx<0x00800000) {	/* subnormal x */
 	    for (ix = -126,i=(hx<<8); i>0; i<<=1) ix -=1;
 	} else ix = (hx>>23)-127;
 
     /* determine iy = ilogb(y) */
 	if(hy<0x00800000) {	/* subnormal y */
 	    for (iy = -126,i=(hy<<8); i>=0; i<<=1) iy -=1;
 	} else iy = (hy>>23)-127;
 
     /* set up {hx,lx}, {hy,ly} and align y to x */
 	if(ix >= -126)
 	    hx = 0x00800000|(0x007fffff&hx);
 	else {		/* subnormal x, shift x to normal */
 	    n = -126-ix;
 	    hx = hx<<n;
 	}
 	if(iy >= -126)
 	    hy = 0x00800000|(0x007fffff&hy);
 	else {		/* subnormal y, shift y to normal */
 	    n = -126-iy;
 	    hy = hy<<n;
 	}
 
     /* fix point fmod */
 	n = ix - iy;
 	while(n--) {
 	    hz=hx-hy;
 	    if(hz<0){hx = hx+hx;}
 	    else {
 	    	if(hz==0) 		/* return sign(x)*0 */
 		    return Zero[(u_int32_t)sx>>31];
 	    	hx = hz+hz;
 	    }
 	}
 	hz=hx-hy;
 	if(hz>=0) {hx=hz;}
 
     /* convert back to floating value and restore the sign */
 	if(hx==0) 			/* return sign(x)*0 */
 	    return Zero[(u_int32_t)sx>>31];
 	while(hx<0x00800000) {		/* normalize x */
 	    hx = hx+hx;
 	    iy -= 1;
 	}
 	if(iy>= -126) {		/* normalize output */
 	    hx = ((hx-0x00800000)|((iy+127)<<23));
 	    SET_FLOAT_WORD(x,hx|sx);
 	} else {		/* subnormal output */
 	    n = -126 - iy;
 	    hx >>= n;
 	    SET_FLOAT_WORD(x,hx|sx);
 	    x *= one;		/* create necessary signal */
 	}
 	return x;		/* exact output */
 }
diff --git a/lib/msun/src/e_gamma.c b/lib/msun/src/e_gamma.c
index 28fb5ccba6d6..a13f3e22c08b 100644
--- a/lib/msun/src/e_gamma.c
+++ b/lib/msun/src/e_gamma.c
@@ -1,33 +1,33 @@
 
 /* @(#)e_gamma.c 1.3 95/01/18 */
 /*
  * ====================================================
  * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
  *
  * Developed at SunSoft, a Sun Microsystems, Inc. business.
  * Permission to use, copy, modify, and distribute this
  * software is freely granted, provided that this notice 
  * is preserved.
  * ====================================================
  *
  */
 
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
-/* __ieee754_gamma(x)
+/* gamma(x)
  * Return the logarithm of the Gamma function of x.
  *
- * Method: call __ieee754_gamma_r
+ * Method: call gamma_r
  */
 
 #include "math.h"
 #include "math_private.h"
 
 extern int signgam;
 
 double
-__ieee754_gamma(double x)
+gamma(double x)
 {
-	return __ieee754_gamma_r(x,&signgam);
+	return gamma_r(x,&signgam);
 }
diff --git a/lib/msun/src/e_gamma_r.c b/lib/msun/src/e_gamma_r.c
index 2c423dce8558..2d996cabca20 100644
--- a/lib/msun/src/e_gamma_r.c
+++ b/lib/msun/src/e_gamma_r.c
@@ -1,32 +1,32 @@
 
 /* @(#)e_gamma_r.c 1.3 95/01/18 */
 /*
  * ====================================================
  * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
  *
  * Developed at SunSoft, a Sun Microsystems, Inc. business.
  * Permission to use, copy, modify, and distribute this
  * software is freely granted, provided that this notice 
  * is preserved.
  * ====================================================
  *
  */
 
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
-/* __ieee754_gamma_r(x, signgamp)
+/* gamma_r(x, signgamp)
  * Reentrant version of the logarithm of the Gamma function 
  * with user provide pointer for the sign of Gamma(x). 
  *
- * Method: See __ieee754_lgamma_r
+ * Method: See lgamma_r
  */
 
 #include "math.h"
 #include "math_private.h"
 
 double
-__ieee754_gamma_r(double x, int *signgamp)
+gamma_r(double x, int *signgamp)
 {
-	return __ieee754_lgamma_r(x,signgamp);
+	return lgamma_r(x,signgamp);
 }
diff --git a/lib/msun/src/e_gammaf.c b/lib/msun/src/e_gammaf.c
index c1b1668df975..563c1482282d 100644
--- a/lib/msun/src/e_gammaf.c
+++ b/lib/msun/src/e_gammaf.c
@@ -1,34 +1,34 @@
 /* e_gammaf.c -- float version of e_gamma.c.
  * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
  */
 
 /*
  * ====================================================
  * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
  *
  * Developed at SunPro, a Sun Microsystems, Inc. business.
  * Permission to use, copy, modify, and distribute this
  * software is freely granted, provided that this notice
  * is preserved.
  * ====================================================
  */
 
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
-/* __ieee754_gammaf(x)
+/* gammaf(x)
  * Return the logarithm of the Gamma function of x.
  *
- * Method: call __ieee754_gammaf_r
+ * Method: call gammaf_r
  */
 
 #include "math.h"
 #include "math_private.h"
 
 extern int signgam;
 
 float
-__ieee754_gammaf(float x)
+gammaf(float x)
 {
-	return __ieee754_gammaf_r(x,&signgam);
+	return gammaf_r(x,&signgam);
 }
diff --git a/lib/msun/src/e_gammaf_r.c b/lib/msun/src/e_gammaf_r.c
index 9d7831b5501b..d7fc2db1e96c 100644
--- a/lib/msun/src/e_gammaf_r.c
+++ b/lib/msun/src/e_gammaf_r.c
@@ -1,33 +1,33 @@
 /* e_gammaf_r.c -- float version of e_gamma_r.c.
  * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
  */
 
 /*
  * ====================================================
  * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
  *
  * Developed at SunPro, a Sun Microsystems, Inc. business.
  * Permission to use, copy, modify, and distribute this
  * software is freely granted, provided that this notice
  * is preserved.
  * ====================================================
  */
 
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
-/* __ieee754_gammaf_r(x, signgamp)
+/* gammaf_r(x, signgamp)
  * Reentrant version of the logarithm of the Gamma function
  * with user provide pointer for the sign of Gamma(x).
  *
- * Method: See __ieee754_lgammaf_r
+ * Method: See lgammaf_r
  */
 
 #include "math.h"
 #include "math_private.h"
 
 float
-__ieee754_gammaf_r(float x, int *signgamp)
+gammaf_r(float x, int *signgamp)
 {
-	return __ieee754_lgammaf_r(x,signgamp);
+	return lgammaf_r(x,signgamp);
 }
diff --git a/lib/msun/src/e_hypot.c b/lib/msun/src/e_hypot.c
index 7c455bb6652f..8e3f9317b3a6 100644
--- a/lib/msun/src/e_hypot.c
+++ b/lib/msun/src/e_hypot.c
@@ -1,129 +1,129 @@
 
 /* @(#)e_hypot.c 1.3 95/01/18 */
 /*
  * ====================================================
  * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
  *
  * Developed at SunSoft, a Sun Microsystems, Inc. business.
  * Permission to use, copy, modify, and distribute this
  * software is freely granted, provided that this notice 
  * is preserved.
  * ====================================================
  */
 
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
-/* __ieee754_hypot(x,y)
+/* hypot(x,y)
  *
  * Method :                  
  *	If (assume round-to-nearest) z=x*x+y*y 
  *	has error less than sqrt(2)/2 ulp, than 
  *	sqrt(z) has error less than 1 ulp (exercise).
  *
  *	So, compute sqrt(x*x+y*y) with some care as 
  *	follows to get the error below 1 ulp:
  *
  *	Assume x>y>0;
  *	(if possible, set rounding to round-to-nearest)
  *	1. if x > 2y  use
  *		x1*x1+(y*y+(x2*(x+x1))) for x*x+y*y
  *	where x1 = x with lower 32 bits cleared, x2 = x-x1; else
  *	2. if x <= 2y use
  *		t1*y1+((x-y)*(x-y)+(t1*y2+t2*y))
  *	where t1 = 2x with lower 32 bits cleared, t2 = 2x-t1, 
  *	y1= y with lower 32 bits chopped, y2 = y-y1.
  *		
  *	NOTE: scaling may be necessary if some argument is too 
  *	      large or too tiny
  *
  * Special cases:
  *	hypot(x,y) is INF if x or y is +INF or -INF; else
  *	hypot(x,y) is NAN if x or y is NAN.
  *
  * Accuracy:
  * 	hypot(x,y) returns sqrt(x^2+y^2) with error less 
  * 	than 1 ulps (units in the last place) 
  */
 
 #include <float.h>
 
 #include "math.h"
 #include "math_private.h"
 
 double
-__ieee754_hypot(double x, double y)
+hypot(double x, double y)
 {
 	double a,b,t1,t2,y1,y2,w;
 	int32_t j,k,ha,hb;
 
 	GET_HIGH_WORD(ha,x);
 	ha &= 0x7fffffff;
 	GET_HIGH_WORD(hb,y);
 	hb &= 0x7fffffff;
 	if(hb > ha) {a=y;b=x;j=ha; ha=hb;hb=j;} else {a=x;b=y;}
 	a = fabs(a);
 	b = fabs(b);
 	if((ha-hb)>0x3c00000) {return a+b;} /* x/y > 2**60 */
 	k=0;
 	if(ha > 0x5f300000) {	/* a>2**500 */
 	   if(ha >= 0x7ff00000) {	/* Inf or NaN */
 	       u_int32_t low;
 	       /* Use original arg order iff result is NaN; quieten sNaNs. */
 	       w = fabsl(x+0.0L)-fabs(y+0);
 	       GET_LOW_WORD(low,a);
 	       if(((ha&0xfffff)|low)==0) w = a;
 	       GET_LOW_WORD(low,b);
 	       if(((hb^0x7ff00000)|low)==0) w = b;
 	       return w;
 	   }
 	   /* scale a and b by 2**-600 */
 	   ha -= 0x25800000; hb -= 0x25800000;	k += 600;
 	   SET_HIGH_WORD(a,ha);
 	   SET_HIGH_WORD(b,hb);
 	}
 	if(hb < 0x20b00000) {	/* b < 2**-500 */
 	    if(hb <= 0x000fffff) {	/* subnormal b or 0 */
 	        u_int32_t low;
 		GET_LOW_WORD(low,b);
 		if((hb|low)==0) return a;
 		t1=0;
 		SET_HIGH_WORD(t1,0x7fd00000);	/* t1=2^1022 */
 		b *= t1;
 		a *= t1;
 		k -= 1022;
 	    } else {		/* scale a and b by 2^600 */
 	        ha += 0x25800000; 	/* a *= 2^600 */
 		hb += 0x25800000;	/* b *= 2^600 */
 		k -= 600;
 		SET_HIGH_WORD(a,ha);
 		SET_HIGH_WORD(b,hb);
 	    }
 	}
     /* medium size a and b */
 	w = a-b;
 	if (w>b) {
 	    t1 = 0;
 	    SET_HIGH_WORD(t1,ha);
 	    t2 = a-t1;
 	    w  = sqrt(t1*t1-(b*(-b)-t2*(a+t1)));
 	} else {
 	    a  = a+a;
 	    y1 = 0;
 	    SET_HIGH_WORD(y1,hb);
 	    y2 = b - y1;
 	    t1 = 0;
 	    SET_HIGH_WORD(t1,ha+0x00100000);
 	    t2 = a - t1;
 	    w  = sqrt(t1*y1-(w*(-w)-(t1*y2+t2*b)));
 	}
 	if(k!=0) {
 	    t1 = 0.0;
 	    SET_HIGH_WORD(t1,(1023+k)<<20);
 	    return t1*w;
 	} else return w;
 }
 
 #if LDBL_MANT_DIG == 53
 __weak_reference(hypot, hypotl);
 #endif
diff --git a/lib/msun/src/e_hypotf.c b/lib/msun/src/e_hypotf.c
index 00610268fafb..a3b8c866697b 100644
--- a/lib/msun/src/e_hypotf.c
+++ b/lib/msun/src/e_hypotf.c
@@ -1,83 +1,83 @@
 /* e_hypotf.c -- float version of e_hypot.c.
  * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
  */
 
 /*
  * ====================================================
  * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
  *
  * Developed at SunPro, a Sun Microsystems, Inc. business.
  * Permission to use, copy, modify, and distribute this
  * software is freely granted, provided that this notice
  * is preserved.
  * ====================================================
  */
 
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
 #include "math.h"
 #include "math_private.h"
 
 float
-__ieee754_hypotf(float x, float y)
+hypotf(float x, float y)
 {
 	float a,b,t1,t2,y1,y2,w;
 	int32_t j,k,ha,hb;
 
 	GET_FLOAT_WORD(ha,x);
 	ha &= 0x7fffffff;
 	GET_FLOAT_WORD(hb,y);
 	hb &= 0x7fffffff;
 	if(hb > ha) {a=y;b=x;j=ha; ha=hb;hb=j;} else {a=x;b=y;}
 	a = fabsf(a);
 	b = fabsf(b);
 	if((ha-hb)>0xf000000) {return a+b;} /* x/y > 2**30 */
 	k=0;
 	if(ha > 0x58800000) {	/* a>2**50 */
 	   if(ha >= 0x7f800000) {	/* Inf or NaN */
 	       /* Use original arg order iff result is NaN; quieten sNaNs. */
 	       w = fabsl(x+0.0L)-fabsf(y+0);
 	       if(ha == 0x7f800000) w = a;
 	       if(hb == 0x7f800000) w = b;
 	       return w;
 	   }
 	   /* scale a and b by 2**-68 */
 	   ha -= 0x22000000; hb -= 0x22000000;	k += 68;
 	   SET_FLOAT_WORD(a,ha);
 	   SET_FLOAT_WORD(b,hb);
 	}
 	if(hb < 0x26800000) {	/* b < 2**-50 */
 	    if(hb <= 0x007fffff) {	/* subnormal b or 0 */
 	        if(hb==0) return a;
 		SET_FLOAT_WORD(t1,0x7e800000);	/* t1=2^126 */
 		b *= t1;
 		a *= t1;
 		k -= 126;
 	    } else {		/* scale a and b by 2^68 */
 	        ha += 0x22000000; 	/* a *= 2^68 */
 		hb += 0x22000000;	/* b *= 2^68 */
 		k -= 68;
 		SET_FLOAT_WORD(a,ha);
 		SET_FLOAT_WORD(b,hb);
 	    }
 	}
     /* medium size a and b */
 	w = a-b;
 	if (w>b) {
 	    SET_FLOAT_WORD(t1,ha&0xfffff000);
 	    t2 = a-t1;
-	    w  = __ieee754_sqrtf(t1*t1-(b*(-b)-t2*(a+t1)));
+	    w  = sqrtf(t1*t1-(b*(-b)-t2*(a+t1)));
 	} else {
 	    a  = a+a;
 	    SET_FLOAT_WORD(y1,hb&0xfffff000);
 	    y2 = b - y1;
 	    SET_FLOAT_WORD(t1,(ha+0x00800000)&0xfffff000);
 	    t2 = a - t1;
-	    w  = __ieee754_sqrtf(t1*y1-(w*(-w)-(t1*y2+t2*b)));
+	    w  = sqrtf(t1*y1-(w*(-w)-(t1*y2+t2*b)));
 	}
 	if(k!=0) {
 	    SET_FLOAT_WORD(t1,(127+k)<<23);
 	    return t1*w;
 	} else return w;
 }
diff --git a/lib/msun/src/e_j0.c b/lib/msun/src/e_j0.c
index 5d862b6f834d..c43ab6996b4a 100644
--- a/lib/msun/src/e_j0.c
+++ b/lib/msun/src/e_j0.c
@@ -1,389 +1,389 @@
 /* @(#)e_j0.c 1.3 95/01/18 */
 /*
  * ====================================================
  * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
  *
  * Developed at SunSoft, a Sun Microsystems, Inc. business.
  * Permission to use, copy, modify, and distribute this
  * software is freely granted, provided that this notice
  * is preserved.
  * ====================================================
  */
 
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
-/* __ieee754_j0(x), __ieee754_y0(x)
+/* j0(x), y0(x)
  * Bessel function of the first and second kinds of order zero.
  * Method -- j0(x):
  *	1. For tiny x, we use j0(x) = 1 - x^2/4 + x^4/64 - ...
  *	2. Reduce x to |x| since j0(x)=j0(-x),  and
  *	   for x in (0,2)
  *		j0(x) = 1-z/4+ z^2*R0/S0,  where z = x*x;
  *	   (precision:  |j0-1+z/4-z^2R0/S0 |<2**-63.67 )
  *	   for x in (2,inf)
  * 		j0(x) = sqrt(2/(pi*x))*(p0(x)*cos(x0)-q0(x)*sin(x0))
  * 	   where x0 = x-pi/4. It is better to compute sin(x0),cos(x0)
  *	   as follow:
  *		cos(x0) = cos(x)cos(pi/4)+sin(x)sin(pi/4)
  *			= 1/sqrt(2) * (cos(x) + sin(x))
  *		sin(x0) = sin(x)cos(pi/4)-cos(x)sin(pi/4)
  *			= 1/sqrt(2) * (sin(x) - cos(x))
  * 	   (To avoid cancellation, use
  *		sin(x) +- cos(x) = -cos(2x)/(sin(x) -+ cos(x))
  * 	    to compute the worse one.)
  *
  *	3 Special cases
  *		j0(nan)= nan
  *		j0(0) = 1
  *		j0(inf) = 0
  *
  * Method -- y0(x):
  *	1. For x<2.
  *	   Since
  *		y0(x) = 2/pi*(j0(x)*(ln(x/2)+Euler) + x^2/4 - ...)
  *	   therefore y0(x)-2/pi*j0(x)*ln(x) is an even function.
  *	   We use the following function to approximate y0,
  *		y0(x) = U(z)/V(z) + (2/pi)*(j0(x)*ln(x)), z= x^2
  *	   where
  *		U(z) = u00 + u01*z + ... + u06*z^6
  *		V(z) = 1  + v01*z + ... + v04*z^4
  *	   with absolute approximation error bounded by 2**-72.
  *	   Note: For tiny x, U/V = u0 and j0(x)~1, hence
  *		y0(tiny) = u0 + (2/pi)*ln(tiny), (choose tiny<2**-27)
  *	2. For x>=2.
  * 		y0(x) = sqrt(2/(pi*x))*(p0(x)*cos(x0)+q0(x)*sin(x0))
  * 	   where x0 = x-pi/4. It is better to compute sin(x0),cos(x0)
  *	   by the method mentioned above.
  *	3. Special cases: y0(0)=-inf, y0(x<0)=NaN, y0(inf)=0.
  */
 
 #include "math.h"
 #include "math_private.h"
 
 static __inline double pzero(double), qzero(double);
 
 static const volatile double vone = 1, vzero = 0;
 
 static const double
 huge 	= 1e300,
 one	= 1.0,
 invsqrtpi=  5.64189583547756279280e-01, /* 0x3FE20DD7, 0x50429B6D */
 tpi      =  6.36619772367581382433e-01, /* 0x3FE45F30, 0x6DC9C883 */
 /* R0/S0 on [0, 2.00] */
 R02  =  1.56249999999999947958e-02, /* 0x3F8FFFFF, 0xFFFFFFFD */
 R03  = -1.89979294238854721751e-04, /* 0xBF28E6A5, 0xB61AC6E9 */
 R04  =  1.82954049532700665670e-06, /* 0x3EBEB1D1, 0x0C503919 */
 R05  = -4.61832688532103189199e-09, /* 0xBE33D5E7, 0x73D63FCE */
 S01  =  1.56191029464890010492e-02, /* 0x3F8FFCE8, 0x82C8C2A4 */
 S02  =  1.16926784663337450260e-04, /* 0x3F1EA6D2, 0xDD57DBF4 */
 S03  =  5.13546550207318111446e-07, /* 0x3EA13B54, 0xCE84D5A9 */
 S04  =  1.16614003333790000205e-09; /* 0x3E1408BC, 0xF4745D8F */
 
 static const double zero = 0, qrtr = 0.25;
 
 double
-__ieee754_j0(double x)
+j0(double x)
 {
 	double z, s,c,ss,cc,r,u,v;
 	int32_t hx,ix;
 
 	GET_HIGH_WORD(hx,x);
 	ix = hx&0x7fffffff;
 	if(ix>=0x7ff00000) return one/(x*x);
 	x = fabs(x);
 	if(ix >= 0x40000000) {	/* |x| >= 2.0 */
 		sincos(x, &s, &c);
 		ss = s-c;
 		cc = s+c;
 		if(ix<0x7fe00000) {  /* Make sure x+x does not overflow. */
 		    z = -cos(x+x);
 		    if ((s*c)<zero) cc = z/ss;
 		    else 	    ss = z/cc;
 		}
 	/*
 	 * j0(x) = 1/sqrt(pi) * (P(0,x)*cc - Q(0,x)*ss) / sqrt(x)
 	 * y0(x) = 1/sqrt(pi) * (P(0,x)*ss + Q(0,x)*cc) / sqrt(x)
 	 */
 		if(ix>0x48000000) z = (invsqrtpi*cc)/sqrt(x);
 		else {
 		    u = pzero(x); v = qzero(x);
 		    z = invsqrtpi*(u*cc-v*ss)/sqrt(x);
 		}
 		return z;
 	}
 	if(ix<0x3f200000) {	/* |x| < 2**-13 */
 	    if(huge+x>one) {	/* raise inexact if x != 0 */
 	        if(ix<0x3e400000) return one;	/* |x|<2**-27 */
 	        else 	      return one - x*x/4;
 	    }
 	}
 	z = x*x;
 	r =  z*(R02+z*(R03+z*(R04+z*R05)));
 	s =  one+z*(S01+z*(S02+z*(S03+z*S04)));
 	if(ix < 0x3FF00000) {	/* |x| < 1.00 */
 	    return one + z*((r/s)-qrtr);
 	} else {
 	    u = x/2;
 	    return((one+u)*(one-u)+z*(r/s));
 	}
 }
 
 static const double
 u00  = -7.38042951086872317523e-02, /* 0xBFB2E4D6, 0x99CBD01F */
 u01  =  1.76666452509181115538e-01, /* 0x3FC69D01, 0x9DE9E3FC */
 u02  = -1.38185671945596898896e-02, /* 0xBF8C4CE8, 0xB16CFA97 */
 u03  =  3.47453432093683650238e-04, /* 0x3F36C54D, 0x20B29B6B */
 u04  = -3.81407053724364161125e-06, /* 0xBECFFEA7, 0x73D25CAD */
 u05  =  1.95590137035022920206e-08, /* 0x3E550057, 0x3B4EABD4 */
 u06  = -3.98205194132103398453e-11, /* 0xBDC5E43D, 0x693FB3C8 */
 v01  =  1.27304834834123699328e-02, /* 0x3F8A1270, 0x91C9C71A */
 v02  =  7.60068627350353253702e-05, /* 0x3F13ECBB, 0xF578C6C1 */
 v03  =  2.59150851840457805467e-07, /* 0x3E91642D, 0x7FF202FD */
 v04  =  4.41110311332675467403e-10; /* 0x3DFE5018, 0x3BD6D9EF */
 
 double
-__ieee754_y0(double x)
+y0(double x)
 {
 	double z, s,c,ss,cc,u,v;
 	int32_t hx,ix,lx;
 
 	EXTRACT_WORDS(hx,lx,x);
         ix = 0x7fffffff&hx;
 	/*
 	 * y0(NaN) = NaN.
 	 * y0(Inf) = 0.
 	 * y0(-Inf) = NaN and raise invalid exception.
 	 */
 	if(ix>=0x7ff00000) return vone/(x+x*x);
 	/* y0(+-0) = -inf and raise divide-by-zero exception. */
 	if((ix|lx)==0) return -one/vzero;
 	/* y0(x<0) = NaN and raise invalid exception. */
 	if(hx<0) return vzero/vzero;
         if(ix >= 0x40000000) {  /* |x| >= 2.0 */
         /* y0(x) = sqrt(2/(pi*x))*(p0(x)*sin(x0)+q0(x)*cos(x0))
          * where x0 = x-pi/4
          *      Better formula:
          *              cos(x0) = cos(x)cos(pi/4)+sin(x)sin(pi/4)
          *                      =  1/sqrt(2) * (sin(x) + cos(x))
          *              sin(x0) = sin(x)cos(3pi/4)-cos(x)sin(3pi/4)
          *                      =  1/sqrt(2) * (sin(x) - cos(x))
          * To avoid cancellation, use
          *              sin(x) +- cos(x) = -cos(2x)/(sin(x) -+ cos(x))
          * to compute the worse one.
          */
                 sincos(x, &s, &c);
                 ss = s-c;
                 cc = s+c;
 	/*
 	 * j0(x) = 1/sqrt(pi) * (P(0,x)*cc - Q(0,x)*ss) / sqrt(x)
 	 * y0(x) = 1/sqrt(pi) * (P(0,x)*ss + Q(0,x)*cc) / sqrt(x)
 	 */
                 if(ix<0x7fe00000) {  /* make sure x+x not overflow */
                     z = -cos(x+x);
                     if ((s*c)<zero) cc = z/ss;
                     else            ss = z/cc;
                 }
                 if(ix>0x48000000) z = (invsqrtpi*ss)/sqrt(x);
                 else {
                     u = pzero(x); v = qzero(x);
                     z = invsqrtpi*(u*ss+v*cc)/sqrt(x);
                 }
                 return z;
 	}
 	if(ix<=0x3e400000) {	/* x < 2**-27 */
-	    return(u00 + tpi*__ieee754_log(x));
+	    return(u00 + tpi*log(x));
 	}
 	z = x*x;
 	u = u00+z*(u01+z*(u02+z*(u03+z*(u04+z*(u05+z*u06)))));
 	v = one+z*(v01+z*(v02+z*(v03+z*v04)));
-	return(u/v + tpi*(__ieee754_j0(x)*__ieee754_log(x)));
+	return(u/v + tpi*(j0(x)*log(x)));
 }
 
 /* The asymptotic expansions of pzero is
  *	1 - 9/128 s^2 + 11025/98304 s^4 - ...,	where s = 1/x.
  * For x >= 2, We approximate pzero by
  * 	pzero(x) = 1 + (R/S)
  * where  R = pR0 + pR1*s^2 + pR2*s^4 + ... + pR5*s^10
  * 	  S = 1 + pS0*s^2 + ... + pS4*s^10
  * and
  *	| pzero(x)-1-R/S | <= 2  ** ( -60.26)
  */
 static const double pR8[6] = { /* for x in [inf, 8]=1/[0,0.125] */
   0.00000000000000000000e+00, /* 0x00000000, 0x00000000 */
  -7.03124999999900357484e-02, /* 0xBFB1FFFF, 0xFFFFFD32 */
  -8.08167041275349795626e+00, /* 0xC02029D0, 0xB44FA779 */
  -2.57063105679704847262e+02, /* 0xC0701102, 0x7B19E863 */
  -2.48521641009428822144e+03, /* 0xC0A36A6E, 0xCD4DCAFC */
  -5.25304380490729545272e+03, /* 0xC0B4850B, 0x36CC643D */
 };
 static const double pS8[5] = {
   1.16534364619668181717e+02, /* 0x405D2233, 0x07A96751 */
   3.83374475364121826715e+03, /* 0x40ADF37D, 0x50596938 */
   4.05978572648472545552e+04, /* 0x40E3D2BB, 0x6EB6B05F */
   1.16752972564375915681e+05, /* 0x40FC810F, 0x8F9FA9BD */
   4.76277284146730962675e+04, /* 0x40E74177, 0x4F2C49DC */
 };
 
 static const double pR5[6] = { /* for x in [8,4.5454]=1/[0.125,0.22001] */
  -1.14125464691894502584e-11, /* 0xBDA918B1, 0x47E495CC */
  -7.03124940873599280078e-02, /* 0xBFB1FFFF, 0xE69AFBC6 */
  -4.15961064470587782438e+00, /* 0xC010A370, 0xF90C6BBF */
  -6.76747652265167261021e+01, /* 0xC050EB2F, 0x5A7D1783 */
  -3.31231299649172967747e+02, /* 0xC074B3B3, 0x6742CC63 */
  -3.46433388365604912451e+02, /* 0xC075A6EF, 0x28A38BD7 */
 };
 static const double pS5[5] = {
   6.07539382692300335975e+01, /* 0x404E6081, 0x0C98C5DE */
   1.05125230595704579173e+03, /* 0x40906D02, 0x5C7E2864 */
   5.97897094333855784498e+03, /* 0x40B75AF8, 0x8FBE1D60 */
   9.62544514357774460223e+03, /* 0x40C2CCB8, 0xFA76FA38 */
   2.40605815922939109441e+03, /* 0x40A2CC1D, 0xC70BE864 */
 };
 
 static const double pR3[6] = {/* for x in [4.547,2.8571]=1/[0.2199,0.35001] */
  -2.54704601771951915620e-09, /* 0xBE25E103, 0x6FE1AA86 */
  -7.03119616381481654654e-02, /* 0xBFB1FFF6, 0xF7C0E24B */
  -2.40903221549529611423e+00, /* 0xC00345B2, 0xAEA48074 */
  -2.19659774734883086467e+01, /* 0xC035F74A, 0x4CB94E14 */
  -5.80791704701737572236e+01, /* 0xC04D0A22, 0x420A1A45 */
  -3.14479470594888503854e+01, /* 0xC03F72AC, 0xA892D80F */
 };
 static const double pS3[5] = {
   3.58560338055209726349e+01, /* 0x4041ED92, 0x84077DD3 */
   3.61513983050303863820e+02, /* 0x40769839, 0x464A7C0E */
   1.19360783792111533330e+03, /* 0x4092A66E, 0x6D1061D6 */
   1.12799679856907414432e+03, /* 0x40919FFC, 0xB8C39B7E */
   1.73580930813335754692e+02, /* 0x4065B296, 0xFC379081 */
 };
 
 static const double pR2[6] = {/* for x in [2.8570,2]=1/[0.3499,0.5] */
  -8.87534333032526411254e-08, /* 0xBE77D316, 0xE927026D */
  -7.03030995483624743247e-02, /* 0xBFB1FF62, 0x495E1E42 */
  -1.45073846780952986357e+00, /* 0xBFF73639, 0x8A24A843 */
  -7.63569613823527770791e+00, /* 0xC01E8AF3, 0xEDAFA7F3 */
  -1.11931668860356747786e+01, /* 0xC02662E6, 0xC5246303 */
  -3.23364579351335335033e+00, /* 0xC009DE81, 0xAF8FE70F */
 };
 static const double pS2[5] = {
   2.22202997532088808441e+01, /* 0x40363865, 0x908B5959 */
   1.36206794218215208048e+02, /* 0x4061069E, 0x0EE8878F */
   2.70470278658083486789e+02, /* 0x4070E786, 0x42EA079B */
   1.53875394208320329881e+02, /* 0x40633C03, 0x3AB6FAFF */
   1.46576176948256193810e+01, /* 0x402D50B3, 0x44391809 */
 };
 
 static __inline double
 pzero(double x)
 {
 	const double *p,*q;
 	double z,r,s;
 	int32_t ix;
 	GET_HIGH_WORD(ix,x);
 	ix &= 0x7fffffff;
 	if(ix>=0x40200000)     {p = pR8; q= pS8;}
 	else if(ix>=0x40122E8B){p = pR5; q= pS5;}
 	else if(ix>=0x4006DB6D){p = pR3; q= pS3;}
 	else                   {p = pR2; q= pS2;}	/* ix>=0x40000000 */
 	z = one/(x*x);
 	r = p[0]+z*(p[1]+z*(p[2]+z*(p[3]+z*(p[4]+z*p[5]))));
 	s = one+z*(q[0]+z*(q[1]+z*(q[2]+z*(q[3]+z*q[4]))));
 	return one+ r/s;
 }
 
 
 /* For x >= 8, the asymptotic expansions of qzero is
  *	-1/8 s + 75/1024 s^3 - ..., where s = 1/x.
  * We approximate pzero by
  * 	qzero(x) = s*(-1.25 + (R/S))
  * where  R = qR0 + qR1*s^2 + qR2*s^4 + ... + qR5*s^10
  * 	  S = 1 + qS0*s^2 + ... + qS5*s^12
  * and
  *	| qzero(x)/s +1.25-R/S | <= 2  ** ( -61.22)
  */
 static const double qR8[6] = { /* for x in [inf, 8]=1/[0,0.125] */
   0.00000000000000000000e+00, /* 0x00000000, 0x00000000 */
   7.32421874999935051953e-02, /* 0x3FB2BFFF, 0xFFFFFE2C */
   1.17682064682252693899e+01, /* 0x40278952, 0x5BB334D6 */
   5.57673380256401856059e+02, /* 0x40816D63, 0x15301825 */
   8.85919720756468632317e+03, /* 0x40C14D99, 0x3E18F46D */
   3.70146267776887834771e+04, /* 0x40E212D4, 0x0E901566 */
 };
 static const double qS8[6] = {
   1.63776026895689824414e+02, /* 0x406478D5, 0x365B39BC */
   8.09834494656449805916e+03, /* 0x40BFA258, 0x4E6B0563 */
   1.42538291419120476348e+05, /* 0x41016652, 0x54D38C3F */
   8.03309257119514397345e+05, /* 0x412883DA, 0x83A52B43 */
   8.40501579819060512818e+05, /* 0x4129A66B, 0x28DE0B3D */
  -3.43899293537866615225e+05, /* 0xC114FD6D, 0x2C9530C5 */
 };
 
 static const double qR5[6] = { /* for x in [8,4.5454]=1/[0.125,0.22001] */
   1.84085963594515531381e-11, /* 0x3DB43D8F, 0x29CC8CD9 */
   7.32421766612684765896e-02, /* 0x3FB2BFFF, 0xD172B04C */
   5.83563508962056953777e+00, /* 0x401757B0, 0xB9953DD3 */
   1.35111577286449829671e+02, /* 0x4060E392, 0x0A8788E9 */
   1.02724376596164097464e+03, /* 0x40900CF9, 0x9DC8C481 */
   1.98997785864605384631e+03, /* 0x409F17E9, 0x53C6E3A6 */
 };
 static const double qS5[6] = {
   8.27766102236537761883e+01, /* 0x4054B1B3, 0xFB5E1543 */
   2.07781416421392987104e+03, /* 0x40A03BA0, 0xDA21C0CE */
   1.88472887785718085070e+04, /* 0x40D267D2, 0x7B591E6D */
   5.67511122894947329769e+04, /* 0x40EBB5E3, 0x97E02372 */
   3.59767538425114471465e+04, /* 0x40E19118, 0x1F7A54A0 */
  -5.35434275601944773371e+03, /* 0xC0B4EA57, 0xBEDBC609 */
 };
 
 static const double qR3[6] = {/* for x in [4.547,2.8571]=1/[0.2199,0.35001] */
   4.37741014089738620906e-09, /* 0x3E32CD03, 0x6ADECB82 */
   7.32411180042911447163e-02, /* 0x3FB2BFEE, 0x0E8D0842 */
   3.34423137516170720929e+00, /* 0x400AC0FC, 0x61149CF5 */
   4.26218440745412650017e+01, /* 0x40454F98, 0x962DAEDD */
   1.70808091340565596283e+02, /* 0x406559DB, 0xE25EFD1F */
   1.66733948696651168575e+02, /* 0x4064D77C, 0x81FA21E0 */
 };
 static const double qS3[6] = {
   4.87588729724587182091e+01, /* 0x40486122, 0xBFE343A6 */
   7.09689221056606015736e+02, /* 0x40862D83, 0x86544EB3 */
   3.70414822620111362994e+03, /* 0x40ACF04B, 0xE44DFC63 */
   6.46042516752568917582e+03, /* 0x40B93C6C, 0xD7C76A28 */
   2.51633368920368957333e+03, /* 0x40A3A8AA, 0xD94FB1C0 */
  -1.49247451836156386662e+02, /* 0xC062A7EB, 0x201CF40F */
 };
 
 static const double qR2[6] = {/* for x in [2.8570,2]=1/[0.3499,0.5] */
   1.50444444886983272379e-07, /* 0x3E84313B, 0x54F76BDB */
   7.32234265963079278272e-02, /* 0x3FB2BEC5, 0x3E883E34 */
   1.99819174093815998816e+00, /* 0x3FFFF897, 0xE727779C */
   1.44956029347885735348e+01, /* 0x402CFDBF, 0xAAF96FE5 */
   3.16662317504781540833e+01, /* 0x403FAA8E, 0x29FBDC4A */
   1.62527075710929267416e+01, /* 0x403040B1, 0x71814BB4 */
 };
 static const double qS2[6] = {
   3.03655848355219184498e+01, /* 0x403E5D96, 0xF7C07AED */
   2.69348118608049844624e+02, /* 0x4070D591, 0xE4D14B40 */
   8.44783757595320139444e+02, /* 0x408A6645, 0x22B3BF22 */
   8.82935845112488550512e+02, /* 0x408B977C, 0x9C5CC214 */
   2.12666388511798828631e+02, /* 0x406A9553, 0x0E001365 */
  -5.31095493882666946917e+00, /* 0xC0153E6A, 0xF8B32931 */
 };
 
 static __inline double
 qzero(double x)
 {
 	static const double eighth = 0.125;
 	const double *p,*q;
 	double s,r,z;
 	int32_t ix;
 	GET_HIGH_WORD(ix,x);
 	ix &= 0x7fffffff;
 	if(ix>=0x40200000)     {p = qR8; q= qS8;}
 	else if(ix>=0x40122E8B){p = qR5; q= qS5;}
 	else if(ix>=0x4006DB6D){p = qR3; q= qS3;}
 	else                   {p = qR2; q= qS2;}	/* ix>=0x40000000 */
 	z = one/(x*x);
 	r = p[0]+z*(p[1]+z*(p[2]+z*(p[3]+z*(p[4]+z*p[5]))));
 	s = one+z*(q[0]+z*(q[1]+z*(q[2]+z*(q[3]+z*(q[4]+z*q[5])))));
 	return (r/s-eighth)/x;
 }
diff --git a/lib/msun/src/e_j0f.c b/lib/msun/src/e_j0f.c
index 1c5ef4da1b49..290be04fc900 100644
--- a/lib/msun/src/e_j0f.c
+++ b/lib/msun/src/e_j0f.c
@@ -1,343 +1,343 @@
 /* e_j0f.c -- float version of e_j0.c.
  * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
  */
 
 /*
  * ====================================================
  * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
  *
  * Developed at SunPro, a Sun Microsystems, Inc. business.
  * Permission to use, copy, modify, and distribute this
  * software is freely granted, provided that this notice
  * is preserved.
  * ====================================================
  */
 
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
 /*
  * See e_j0.c for complete comments.
  */
 
 #include "math.h"
 #include "math_private.h"
 
 static __inline float pzerof(float), qzerof(float);
 
 static const volatile float vone = 1,  vzero = 0;
 
 static const float
 huge 	= 1e30,
 one	= 1.0,
 invsqrtpi=  5.6418961287e-01, /* 0x3f106ebb */
 tpi      =  6.3661974669e-01, /* 0x3f22f983 */
  		/* R0/S0 on [0, 2.00] */
 R02  =  1.5625000000e-02, /* 0x3c800000 */
 R03  = -1.8997929874e-04, /* 0xb947352e */
 R04  =  1.8295404516e-06, /* 0x35f58e88 */
 R05  = -4.6183270541e-09, /* 0xb19eaf3c */
 S01  =  1.5619102865e-02, /* 0x3c7fe744 */
 S02  =  1.1692678527e-04, /* 0x38f53697 */
 S03  =  5.1354652442e-07, /* 0x3509daa6 */
 S04  =  1.1661400734e-09; /* 0x30a045e8 */
 
 static const float zero = 0, qrtr = 0.25;
 
 float
-__ieee754_j0f(float x)
+j0f(float x)
 {
 	float z, s,c,ss,cc,r,u,v;
 	int32_t hx,ix;
 
 	GET_FLOAT_WORD(hx,x);
 	ix = hx&0x7fffffff;
 	if(ix>=0x7f800000) return one/(x*x);
 	x = fabsf(x);
 	if(ix >= 0x40000000) {	/* |x| >= 2.0 */
 		sincosf(x, &s, &c);
 		ss = s-c;
 		cc = s+c;
 		if(ix<0x7f000000) {  /* Make sure x+x does not overflow. */
 		    z = -cosf(x+x);
 		    if ((s*c)<zero) cc = z/ss;
 		    else 	    ss = z/cc;
 		}
 	/*
 	 * j0(x) = 1/sqrt(pi) * (P(0,x)*cc - Q(0,x)*ss) / sqrt(x)
 	 * y0(x) = 1/sqrt(pi) * (P(0,x)*ss + Q(0,x)*cc) / sqrt(x)
 	 */
 		if(ix>0x58000000) z = (invsqrtpi*cc)/sqrtf(x); /* |x|>2**49 */
 		else {
 		    u = pzerof(x); v = qzerof(x);
 		    z = invsqrtpi*(u*cc-v*ss)/sqrtf(x);
 		}
 		return z;
 	}
 	if(ix<0x3b000000) {	/* |x| < 2**-9 */
 	    if(huge+x>one) {	/* raise inexact if x != 0 */
 	        if(ix<0x39800000) return one;	/* |x|<2**-12 */
 	        else 	      return one - x*x/4;
 	    }
 	}
 	z = x*x;
 	r =  z*(R02+z*(R03+z*(R04+z*R05)));
 	s =  one+z*(S01+z*(S02+z*(S03+z*S04)));
 	if(ix < 0x3F800000) {	/* |x| < 1.00 */
 	    return one + z*((r/s)-qrtr);
 	} else {
 	    u = x/2;
 	    return((one+u)*(one-u)+z*(r/s));
 	}
 }
 
 static const float
 u00  = -7.3804296553e-02, /* 0xbd9726b5 */
 u01  =  1.7666645348e-01, /* 0x3e34e80d */
 u02  = -1.3818567619e-02, /* 0xbc626746 */
 u03  =  3.4745343146e-04, /* 0x39b62a69 */
 u04  = -3.8140706238e-06, /* 0xb67ff53c */
 u05  =  1.9559013964e-08, /* 0x32a802ba */
 u06  = -3.9820518410e-11, /* 0xae2f21eb */
 v01  =  1.2730483897e-02, /* 0x3c509385 */
 v02  =  7.6006865129e-05, /* 0x389f65e0 */
 v03  =  2.5915085189e-07, /* 0x348b216c */
 v04  =  4.4111031494e-10; /* 0x2ff280c2 */
 
 float
-__ieee754_y0f(float x)
+y0f(float x)
 {
 	float z, s,c,ss,cc,u,v;
 	int32_t hx,ix;
 
 	GET_FLOAT_WORD(hx,x);
         ix = 0x7fffffff&hx;
 	if(ix>=0x7f800000) return  vone/(x+x*x);
 	if(ix==0) return -one/vzero;
 	if(hx<0) return vzero/vzero;
         if(ix >= 0x40000000) {  /* |x| >= 2.0 */
         /* y0(x) = sqrt(2/(pi*x))*(p0(x)*sin(x0)+q0(x)*cos(x0))
          * where x0 = x-pi/4
          *      Better formula:
          *              cos(x0) = cos(x)cos(pi/4)+sin(x)sin(pi/4)
          *                      =  1/sqrt(2) * (sin(x) + cos(x))
          *              sin(x0) = sin(x)cos(3pi/4)-cos(x)sin(3pi/4)
          *                      =  1/sqrt(2) * (sin(x) - cos(x))
          * To avoid cancellation, use
          *              sin(x) +- cos(x) = -cos(2x)/(sin(x) -+ cos(x))
          * to compute the worse one.
          */
                 sincosf(x, &s, &c);
                 ss = s-c;
                 cc = s+c;
 	/*
 	 * j0(x) = 1/sqrt(pi) * (P(0,x)*cc - Q(0,x)*ss) / sqrt(x)
 	 * y0(x) = 1/sqrt(pi) * (P(0,x)*ss + Q(0,x)*cc) / sqrt(x)
 	 */
                 if(ix<0x7f000000) {  /* make sure x+x not overflow */
                     z = -cosf(x+x);
                     if ((s*c)<zero) cc = z/ss;
                     else            ss = z/cc;
                 }
                 if(ix>0x58000000) z = (invsqrtpi*ss)/sqrtf(x); /* |x|>2**49 */
                 else {
                     u = pzerof(x); v = qzerof(x);
                     z = invsqrtpi*(u*ss+v*cc)/sqrtf(x);
                 }
                 return z;
 	}
 	if(ix<=0x39000000) {	/* x < 2**-13 */
-	    return(u00 + tpi*__ieee754_logf(x));
+	    return(u00 + tpi*logf(x));
 	}
 	z = x*x;
 	u = u00+z*(u01+z*(u02+z*(u03+z*(u04+z*(u05+z*u06)))));
 	v = one+z*(v01+z*(v02+z*(v03+z*v04)));
-	return(u/v + tpi*(__ieee754_j0f(x)*__ieee754_logf(x)));
+	return(u/v + tpi*(j0f(x)*logf(x)));
 }
 
 /* The asymptotic expansions of pzero is
  *	1 - 9/128 s^2 + 11025/98304 s^4 - ...,	where s = 1/x.
  * For x >= 2, We approximate pzero by
  * 	pzero(x) = 1 + (R/S)
  * where  R = pR0 + pR1*s^2 + pR2*s^4 + ... + pR5*s^10
  * 	  S = 1 + pS0*s^2 + ... + pS4*s^10
  * and
  *	| pzero(x)-1-R/S | <= 2  ** ( -60.26)
  */
 static const float pR8[6] = { /* for x in [inf, 8]=1/[0,0.125] */
   0.0000000000e+00, /* 0x00000000 */
  -7.0312500000e-02, /* 0xbd900000 */
  -8.0816707611e+00, /* 0xc1014e86 */
  -2.5706311035e+02, /* 0xc3808814 */
  -2.4852163086e+03, /* 0xc51b5376 */
  -5.2530439453e+03, /* 0xc5a4285a */
 };
 static const float pS8[5] = {
   1.1653436279e+02, /* 0x42e91198 */
   3.8337448730e+03, /* 0x456f9beb */
   4.0597855469e+04, /* 0x471e95db */
   1.1675296875e+05, /* 0x47e4087c */
   4.7627726562e+04, /* 0x473a0bba */
 };
 static const float pR5[6] = { /* for x in [8,4.5454]=1/[0.125,0.22001] */
  -1.1412546255e-11, /* 0xad48c58a */
  -7.0312492549e-02, /* 0xbd8fffff */
  -4.1596107483e+00, /* 0xc0851b88 */
  -6.7674766541e+01, /* 0xc287597b */
  -3.3123129272e+02, /* 0xc3a59d9b */
  -3.4643338013e+02, /* 0xc3ad3779 */
 };
 static const float pS5[5] = {
   6.0753936768e+01, /* 0x42730408 */
   1.0512523193e+03, /* 0x44836813 */
   5.9789707031e+03, /* 0x45bad7c4 */
   9.6254453125e+03, /* 0x461665c8 */
   2.4060581055e+03, /* 0x451660ee */
 };
 
 static const float pR3[6] = {/* for x in [4.547,2.8571]=1/[0.2199,0.35001] */
  -2.5470459075e-09, /* 0xb12f081b */
  -7.0311963558e-02, /* 0xbd8fffb8 */
  -2.4090321064e+00, /* 0xc01a2d95 */
  -2.1965976715e+01, /* 0xc1afba52 */
  -5.8079170227e+01, /* 0xc2685112 */
  -3.1447946548e+01, /* 0xc1fb9565 */
 };
 static const float pS3[5] = {
   3.5856033325e+01, /* 0x420f6c94 */
   3.6151397705e+02, /* 0x43b4c1ca */
   1.1936077881e+03, /* 0x44953373 */
   1.1279968262e+03, /* 0x448cffe6 */
   1.7358093262e+02, /* 0x432d94b8 */
 };
 
 static const float pR2[6] = {/* for x in [2.8570,2]=1/[0.3499,0.5] */
  -8.8753431271e-08, /* 0xb3be98b7 */
  -7.0303097367e-02, /* 0xbd8ffb12 */
  -1.4507384300e+00, /* 0xbfb9b1cc */
  -7.6356959343e+00, /* 0xc0f4579f */
  -1.1193166733e+01, /* 0xc1331736 */
  -3.2336456776e+00, /* 0xc04ef40d */
 };
 static const float pS2[5] = {
   2.2220300674e+01, /* 0x41b1c32d */
   1.3620678711e+02, /* 0x430834f0 */
   2.7047027588e+02, /* 0x43873c32 */
   1.5387539673e+02, /* 0x4319e01a */
   1.4657617569e+01, /* 0x416a859a */
 };
 
 static __inline float
 pzerof(float x)
 {
 	const float *p,*q;
 	float z,r,s;
 	int32_t ix;
 	GET_FLOAT_WORD(ix,x);
 	ix &= 0x7fffffff;
 	if(ix>=0x41000000)     {p = pR8; q= pS8;}
 	else if(ix>=0x409173eb){p = pR5; q= pS5;}
 	else if(ix>=0x4036d917){p = pR3; q= pS3;}
 	else                   {p = pR2; q= pS2;}	/* ix>=0x40000000 */
 	z = one/(x*x);
 	r = p[0]+z*(p[1]+z*(p[2]+z*(p[3]+z*(p[4]+z*p[5]))));
 	s = one+z*(q[0]+z*(q[1]+z*(q[2]+z*(q[3]+z*q[4]))));
 	return one+ r/s;
 }
 
 
 /* For x >= 8, the asymptotic expansions of qzero is
  *	-1/8 s + 75/1024 s^3 - ..., where s = 1/x.
  * We approximate pzero by
  * 	qzero(x) = s*(-1.25 + (R/S))
  * where  R = qR0 + qR1*s^2 + qR2*s^4 + ... + qR5*s^10
  * 	  S = 1 + qS0*s^2 + ... + qS5*s^12
  * and
  *	| qzero(x)/s +1.25-R/S | <= 2  ** ( -61.22)
  */
 static const float qR8[6] = { /* for x in [inf, 8]=1/[0,0.125] */
   0.0000000000e+00, /* 0x00000000 */
   7.3242187500e-02, /* 0x3d960000 */
   1.1768206596e+01, /* 0x413c4a93 */
   5.5767340088e+02, /* 0x440b6b19 */
   8.8591972656e+03, /* 0x460a6cca */
   3.7014625000e+04, /* 0x471096a0 */
 };
 static const float qS8[6] = {
   1.6377603149e+02, /* 0x4323c6aa */
   8.0983447266e+03, /* 0x45fd12c2 */
   1.4253829688e+05, /* 0x480b3293 */
   8.0330925000e+05, /* 0x49441ed4 */
   8.4050156250e+05, /* 0x494d3359 */
  -3.4389928125e+05, /* 0xc8a7eb69 */
 };
 
 static const float qR5[6] = { /* for x in [8,4.5454]=1/[0.125,0.22001] */
   1.8408595828e-11, /* 0x2da1ec79 */
   7.3242180049e-02, /* 0x3d95ffff */
   5.8356351852e+00, /* 0x40babd86 */
   1.3511157227e+02, /* 0x43071c90 */
   1.0272437744e+03, /* 0x448067cd */
   1.9899779053e+03, /* 0x44f8bf4b */
 };
 static const float qS5[6] = {
   8.2776611328e+01, /* 0x42a58da0 */
   2.0778142090e+03, /* 0x4501dd07 */
   1.8847289062e+04, /* 0x46933e94 */
   5.6751113281e+04, /* 0x475daf1d */
   3.5976753906e+04, /* 0x470c88c1 */
  -5.3543427734e+03, /* 0xc5a752be */
 };
 
 static const float qR3[6] = {/* for x in [4.547,2.8571]=1/[0.2199,0.35001] */
   4.3774099900e-09, /* 0x3196681b */
   7.3241114616e-02, /* 0x3d95ff70 */
   3.3442313671e+00, /* 0x405607e3 */
   4.2621845245e+01, /* 0x422a7cc5 */
   1.7080809021e+02, /* 0x432acedf */
   1.6673394775e+02, /* 0x4326bbe4 */
 };
 static const float qS3[6] = {
   4.8758872986e+01, /* 0x42430916 */
   7.0968920898e+02, /* 0x44316c1c */
   3.7041481934e+03, /* 0x4567825f */
   6.4604252930e+03, /* 0x45c9e367 */
   2.5163337402e+03, /* 0x451d4557 */
  -1.4924745178e+02, /* 0xc3153f59 */
 };
 
 static const float qR2[6] = {/* for x in [2.8570,2]=1/[0.3499,0.5] */
   1.5044444979e-07, /* 0x342189db */
   7.3223426938e-02, /* 0x3d95f62a */
   1.9981917143e+00, /* 0x3fffc4bf */
   1.4495602608e+01, /* 0x4167edfd */
   3.1666231155e+01, /* 0x41fd5471 */
   1.6252708435e+01, /* 0x4182058c */
 };
 static const float qS2[6] = {
   3.0365585327e+01, /* 0x41f2ecb8 */
   2.6934811401e+02, /* 0x4386ac8f */
   8.4478375244e+02, /* 0x44533229 */
   8.8293585205e+02, /* 0x445cbbe5 */
   2.1266638184e+02, /* 0x4354aa98 */
  -5.3109550476e+00, /* 0xc0a9f358 */
 };
 
 static __inline float
 qzerof(float x)
 {
 	static const float eighth = 0.125;
 	const float *p,*q;
 	float s,r,z;
 	int32_t ix;
 	GET_FLOAT_WORD(ix,x);
 	ix &= 0x7fffffff;
 	if(ix>=0x41000000)     {p = qR8; q= qS8;}
 	else if(ix>=0x409173eb){p = qR5; q= qS5;}
 	else if(ix>=0x4036d917){p = qR3; q= qS3;}
 	else                   {p = qR2; q= qS2;}	/* ix>=0x40000000 */
 	z = one/(x*x);
 	r = p[0]+z*(p[1]+z*(p[2]+z*(p[3]+z*(p[4]+z*p[5]))));
 	s = one+z*(q[0]+z*(q[1]+z*(q[2]+z*(q[3]+z*(q[4]+z*q[5])))));
 	return (r/s-eighth)/x;
 }
diff --git a/lib/msun/src/e_j1.c b/lib/msun/src/e_j1.c
index fb4462738368..ee3f6fcc69d4 100644
--- a/lib/msun/src/e_j1.c
+++ b/lib/msun/src/e_j1.c
@@ -1,383 +1,383 @@
 /* @(#)e_j1.c 1.3 95/01/18 */
 /*
  * ====================================================
  * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
  *
  * Developed at SunSoft, a Sun Microsystems, Inc. business.
  * Permission to use, copy, modify, and distribute this
  * software is freely granted, provided that this notice
  * is preserved.
  * ====================================================
  */
 
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
-/* __ieee754_j1(x), __ieee754_y1(x)
+/* j1(x), y1(x)
  * Bessel function of the first and second kinds of order zero.
  * Method -- j1(x):
  *	1. For tiny x, we use j1(x) = x/2 - x^3/16 + x^5/384 - ...
  *	2. Reduce x to |x| since j1(x)=-j1(-x),  and
  *	   for x in (0,2)
  *		j1(x) = x/2 + x*z*R0/S0,  where z = x*x;
  *	   (precision:  |j1/x - 1/2 - R0/S0 |<2**-61.51 )
  *	   for x in (2,inf)
  * 		j1(x) = sqrt(2/(pi*x))*(p1(x)*cos(x1)-q1(x)*sin(x1))
  * 		y1(x) = sqrt(2/(pi*x))*(p1(x)*sin(x1)+q1(x)*cos(x1))
  * 	   where x1 = x-3*pi/4. It is better to compute sin(x1),cos(x1)
  *	   as follow:
  *		cos(x1) =  cos(x)cos(3pi/4)+sin(x)sin(3pi/4)
  *			=  1/sqrt(2) * (sin(x) - cos(x))
  *		sin(x1) =  sin(x)cos(3pi/4)-cos(x)sin(3pi/4)
  *			= -1/sqrt(2) * (sin(x) + cos(x))
  * 	   (To avoid cancellation, use
  *		sin(x) +- cos(x) = -cos(2x)/(sin(x) -+ cos(x))
  * 	    to compute the worse one.)
  *
  *	3 Special cases
  *		j1(nan)= nan
  *		j1(0) = 0
  *		j1(inf) = 0
  *
  * Method -- y1(x):
  *	1. screen out x<=0 cases: y1(0)=-inf, y1(x<0)=NaN
  *	2. For x<2.
  *	   Since
  *		y1(x) = 2/pi*(j1(x)*(ln(x/2)+Euler)-1/x-x/2+5/64*x^3-...)
  *	   therefore y1(x)-2/pi*j1(x)*ln(x)-1/x is an odd function.
  *	   We use the following function to approximate y1,
  *		y1(x) = x*U(z)/V(z) + (2/pi)*(j1(x)*ln(x)-1/x), z= x^2
  *	   where for x in [0,2] (abs err less than 2**-65.89)
  *		U(z) = U0[0] + U0[1]*z + ... + U0[4]*z^4
  *		V(z) = 1  + v0[0]*z + ... + v0[4]*z^5
  *	   Note: For tiny x, 1/x dominate y1 and hence
  *		y1(tiny) = -2/pi/tiny, (choose tiny<2**-54)
  *	3. For x>=2.
  * 		y1(x) = sqrt(2/(pi*x))*(p1(x)*sin(x1)+q1(x)*cos(x1))
  * 	   where x1 = x-3*pi/4. It is better to compute sin(x1),cos(x1)
  *	   by method mentioned above.
  */
 
 #include "math.h"
 #include "math_private.h"
 
 static __inline double pone(double), qone(double);
 
 static const volatile double vone = 1, vzero = 0;
 
 static const double
 huge    = 1e300,
 one	= 1.0,
 invsqrtpi=  5.64189583547756279280e-01, /* 0x3FE20DD7, 0x50429B6D */
 tpi      =  6.36619772367581382433e-01, /* 0x3FE45F30, 0x6DC9C883 */
 	/* R0/S0 on [0,2] */
 r00  = -6.25000000000000000000e-02, /* 0xBFB00000, 0x00000000 */
 r01  =  1.40705666955189706048e-03, /* 0x3F570D9F, 0x98472C61 */
 r02  = -1.59955631084035597520e-05, /* 0xBEF0C5C6, 0xBA169668 */
 r03  =  4.96727999609584448412e-08, /* 0x3E6AAAFA, 0x46CA0BD9 */
 s01  =  1.91537599538363460805e-02, /* 0x3F939D0B, 0x12637E53 */
 s02  =  1.85946785588630915560e-04, /* 0x3F285F56, 0xB9CDF664 */
 s03  =  1.17718464042623683263e-06, /* 0x3EB3BFF8, 0x333F8498 */
 s04  =  5.04636257076217042715e-09, /* 0x3E35AC88, 0xC97DFF2C */
 s05  =  1.23542274426137913908e-11; /* 0x3DAB2ACF, 0xCFB97ED8 */
 
 static const double zero    = 0.0;
 
 double
-__ieee754_j1(double x)
+j1(double x)
 {
 	double z, s,c,ss,cc,r,u,v,y;
 	int32_t hx,ix;
 
 	GET_HIGH_WORD(hx,x);
 	ix = hx&0x7fffffff;
 	if(ix>=0x7ff00000) return one/x;
 	y = fabs(x);
 	if(ix >= 0x40000000) {	/* |x| >= 2.0 */
 		sincos(y, &s, &c);
 		ss = -s-c;
 		cc = s-c;
 		if(ix<0x7fe00000) {  /* make sure y+y not overflow */
 		    z = cos(y+y);
 		    if ((s*c)>zero) cc = z/ss;
 		    else 	    ss = z/cc;
 		}
 	/*
 	 * j1(x) = 1/sqrt(pi) * (P(1,x)*cc - Q(1,x)*ss) / sqrt(x)
 	 * y1(x) = 1/sqrt(pi) * (P(1,x)*ss + Q(1,x)*cc) / sqrt(x)
 	 */
 		if(ix>0x48000000) z = (invsqrtpi*cc)/sqrt(y);
 		else {
 		    u = pone(y); v = qone(y);
 		    z = invsqrtpi*(u*cc-v*ss)/sqrt(y);
 		}
 		if(hx<0) return -z;
 		else  	 return  z;
 	}
 	if(ix<0x3e400000) {	/* |x|<2**-27 */
 	    if(huge+x>one) return 0.5*x;/* inexact if x!=0 necessary */
 	}
 	z = x*x;
 	r =  z*(r00+z*(r01+z*(r02+z*r03)));
 	s =  one+z*(s01+z*(s02+z*(s03+z*(s04+z*s05))));
 	r *= x;
 	return(x*0.5+r/s);
 }
 
 static const double U0[5] = {
  -1.96057090646238940668e-01, /* 0xBFC91866, 0x143CBC8A */
   5.04438716639811282616e-02, /* 0x3FA9D3C7, 0x76292CD1 */
  -1.91256895875763547298e-03, /* 0xBF5F55E5, 0x4844F50F */
   2.35252600561610495928e-05, /* 0x3EF8AB03, 0x8FA6B88E */
  -9.19099158039878874504e-08, /* 0xBE78AC00, 0x569105B8 */
 };
 static const double V0[5] = {
   1.99167318236649903973e-02, /* 0x3F94650D, 0x3F4DA9F0 */
   2.02552581025135171496e-04, /* 0x3F2A8C89, 0x6C257764 */
   1.35608801097516229404e-06, /* 0x3EB6C05A, 0x894E8CA6 */
   6.22741452364621501295e-09, /* 0x3E3ABF1D, 0x5BA69A86 */
   1.66559246207992079114e-11, /* 0x3DB25039, 0xDACA772A */
 };
 
 double
-__ieee754_y1(double x)
+y1(double x)
 {
 	double z, s,c,ss,cc,u,v;
 	int32_t hx,ix,lx;
 
 	EXTRACT_WORDS(hx,lx,x);
         ix = 0x7fffffff&hx;
 	/*
 	 * y1(NaN) = NaN.
 	 * y1(Inf) = 0.
 	 * y1(-Inf) = NaN and raise invalid exception.
 	 */
 	if(ix>=0x7ff00000) return  vone/(x+x*x);
 	/* y1(+-0) = -inf and raise divide-by-zero exception. */
         if((ix|lx)==0) return -one/vzero;
 	/* y1(x<0) = NaN and raise invalid exception. */
         if(hx<0) return vzero/vzero;
         if(ix >= 0x40000000) {  /* |x| >= 2.0 */
                 sincos(x, &s, &c);
                 ss = -s-c;
                 cc = s-c;
                 if(ix<0x7fe00000) {  /* make sure x+x not overflow */
                     z = cos(x+x);
                     if ((s*c)>zero) cc = z/ss;
                     else            ss = z/cc;
                 }
         /* y1(x) = sqrt(2/(pi*x))*(p1(x)*sin(x0)+q1(x)*cos(x0))
          * where x0 = x-3pi/4
          *      Better formula:
          *              cos(x0) = cos(x)cos(3pi/4)+sin(x)sin(3pi/4)
          *                      =  1/sqrt(2) * (sin(x) - cos(x))
          *              sin(x0) = sin(x)cos(3pi/4)-cos(x)sin(3pi/4)
          *                      = -1/sqrt(2) * (cos(x) + sin(x))
          * To avoid cancellation, use
          *              sin(x) +- cos(x) = -cos(2x)/(sin(x) -+ cos(x))
          * to compute the worse one.
          */
                 if(ix>0x48000000) z = (invsqrtpi*ss)/sqrt(x);
                 else {
                     u = pone(x); v = qone(x);
                     z = invsqrtpi*(u*ss+v*cc)/sqrt(x);
                 }
                 return z;
         }
         if(ix<=0x3c900000) {    /* x < 2**-54 */
             return(-tpi/x);
         }
         z = x*x;
         u = U0[0]+z*(U0[1]+z*(U0[2]+z*(U0[3]+z*U0[4])));
         v = one+z*(V0[0]+z*(V0[1]+z*(V0[2]+z*(V0[3]+z*V0[4]))));
-        return(x*(u/v) + tpi*(__ieee754_j1(x)*__ieee754_log(x)-one/x));
+        return(x*(u/v) + tpi*(j1(x)*log(x)-one/x));
 }
 
 /* For x >= 8, the asymptotic expansions of pone is
  *	1 + 15/128 s^2 - 4725/2^15 s^4 - ...,	where s = 1/x.
  * We approximate pone by
  * 	pone(x) = 1 + (R/S)
  * where  R = pr0 + pr1*s^2 + pr2*s^4 + ... + pr5*s^10
  * 	  S = 1 + ps0*s^2 + ... + ps4*s^10
  * and
  *	| pone(x)-1-R/S | <= 2  ** ( -60.06)
  */
 
 static const double pr8[6] = { /* for x in [inf, 8]=1/[0,0.125] */
   0.00000000000000000000e+00, /* 0x00000000, 0x00000000 */
   1.17187499999988647970e-01, /* 0x3FBDFFFF, 0xFFFFFCCE */
   1.32394806593073575129e+01, /* 0x402A7A9D, 0x357F7FCE */
   4.12051854307378562225e+02, /* 0x4079C0D4, 0x652EA590 */
   3.87474538913960532227e+03, /* 0x40AE457D, 0xA3A532CC */
   7.91447954031891731574e+03, /* 0x40BEEA7A, 0xC32782DD */
 };
 static const double ps8[5] = {
   1.14207370375678408436e+02, /* 0x405C8D45, 0x8E656CAC */
   3.65093083420853463394e+03, /* 0x40AC85DC, 0x964D274F */
   3.69562060269033463555e+04, /* 0x40E20B86, 0x97C5BB7F */
   9.76027935934950801311e+04, /* 0x40F7D42C, 0xB28F17BB */
   3.08042720627888811578e+04, /* 0x40DE1511, 0x697A0B2D */
 };
 
 static const double pr5[6] = { /* for x in [8,4.5454]=1/[0.125,0.22001] */
   1.31990519556243522749e-11, /* 0x3DAD0667, 0xDAE1CA7D */
   1.17187493190614097638e-01, /* 0x3FBDFFFF, 0xE2C10043 */
   6.80275127868432871736e+00, /* 0x401B3604, 0x6E6315E3 */
   1.08308182990189109773e+02, /* 0x405B13B9, 0x452602ED */
   5.17636139533199752805e+02, /* 0x40802D16, 0xD052D649 */
   5.28715201363337541807e+02, /* 0x408085B8, 0xBB7E0CB7 */
 };
 static const double ps5[5] = {
   5.92805987221131331921e+01, /* 0x404DA3EA, 0xA8AF633D */
   9.91401418733614377743e+02, /* 0x408EFB36, 0x1B066701 */
   5.35326695291487976647e+03, /* 0x40B4E944, 0x5706B6FB */
   7.84469031749551231769e+03, /* 0x40BEA4B0, 0xB8A5BB15 */
   1.50404688810361062679e+03, /* 0x40978030, 0x036F5E51 */
 };
 
 static const double pr3[6] = {
   3.02503916137373618024e-09, /* 0x3E29FC21, 0xA7AD9EDD */
   1.17186865567253592491e-01, /* 0x3FBDFFF5, 0x5B21D17B */
   3.93297750033315640650e+00, /* 0x400F76BC, 0xE85EAD8A */
   3.51194035591636932736e+01, /* 0x40418F48, 0x9DA6D129 */
   9.10550110750781271918e+01, /* 0x4056C385, 0x4D2C1837 */
   4.85590685197364919645e+01, /* 0x4048478F, 0x8EA83EE5 */
 };
 static const double ps3[5] = {
   3.47913095001251519989e+01, /* 0x40416549, 0xA134069C */
   3.36762458747825746741e+02, /* 0x40750C33, 0x07F1A75F */
   1.04687139975775130551e+03, /* 0x40905B7C, 0x5037D523 */
   8.90811346398256432622e+02, /* 0x408BD67D, 0xA32E31E9 */
   1.03787932439639277504e+02, /* 0x4059F26D, 0x7C2EED53 */
 };
 
 static const double pr2[6] = {/* for x in [2.8570,2]=1/[0.3499,0.5] */
   1.07710830106873743082e-07, /* 0x3E7CE9D4, 0xF65544F4 */
   1.17176219462683348094e-01, /* 0x3FBDFF42, 0xBE760D83 */
   2.36851496667608785174e+00, /* 0x4002F2B7, 0xF98FAEC0 */
   1.22426109148261232917e+01, /* 0x40287C37, 0x7F71A964 */
   1.76939711271687727390e+01, /* 0x4031B1A8, 0x177F8EE2 */
   5.07352312588818499250e+00, /* 0x40144B49, 0xA574C1FE */
 };
 static const double ps2[5] = {
   2.14364859363821409488e+01, /* 0x40356FBD, 0x8AD5ECDC */
   1.25290227168402751090e+02, /* 0x405F5293, 0x14F92CD5 */
   2.32276469057162813669e+02, /* 0x406D08D8, 0xD5A2DBD9 */
   1.17679373287147100768e+02, /* 0x405D6B7A, 0xDA1884A9 */
   8.36463893371618283368e+00, /* 0x4020BAB1, 0xF44E5192 */
 };
 
 static __inline double
 pone(double x)
 {
 	const double *p,*q;
 	double z,r,s;
         int32_t ix;
 	GET_HIGH_WORD(ix,x);
 	ix &= 0x7fffffff;
         if(ix>=0x40200000)     {p = pr8; q= ps8;}
         else if(ix>=0x40122E8B){p = pr5; q= ps5;}
         else if(ix>=0x4006DB6D){p = pr3; q= ps3;}
 	else                   {p = pr2; q= ps2;}	/* ix>=0x40000000 */
         z = one/(x*x);
         r = p[0]+z*(p[1]+z*(p[2]+z*(p[3]+z*(p[4]+z*p[5]))));
         s = one+z*(q[0]+z*(q[1]+z*(q[2]+z*(q[3]+z*q[4]))));
         return one+ r/s;
 }
 
 
 /* For x >= 8, the asymptotic expansions of qone is
  *	3/8 s - 105/1024 s^3 - ..., where s = 1/x.
  * We approximate pone by
  * 	qone(x) = s*(0.375 + (R/S))
  * where  R = qr1*s^2 + qr2*s^4 + ... + qr5*s^10
  * 	  S = 1 + qs1*s^2 + ... + qs6*s^12
  * and
  *	| qone(x)/s -0.375-R/S | <= 2  ** ( -61.13)
  */
 
 static const double qr8[6] = { /* for x in [inf, 8]=1/[0,0.125] */
   0.00000000000000000000e+00, /* 0x00000000, 0x00000000 */
  -1.02539062499992714161e-01, /* 0xBFBA3FFF, 0xFFFFFDF3 */
  -1.62717534544589987888e+01, /* 0xC0304591, 0xA26779F7 */
  -7.59601722513950107896e+02, /* 0xC087BCD0, 0x53E4B576 */
  -1.18498066702429587167e+04, /* 0xC0C724E7, 0x40F87415 */
  -4.84385124285750353010e+04, /* 0xC0E7A6D0, 0x65D09C6A */
 };
 static const double qs8[6] = {
   1.61395369700722909556e+02, /* 0x40642CA6, 0xDE5BCDE5 */
   7.82538599923348465381e+03, /* 0x40BE9162, 0xD0D88419 */
   1.33875336287249578163e+05, /* 0x4100579A, 0xB0B75E98 */
   7.19657723683240939863e+05, /* 0x4125F653, 0x72869C19 */
   6.66601232617776375264e+05, /* 0x412457D2, 0x7719AD5C */
  -2.94490264303834643215e+05, /* 0xC111F969, 0x0EA5AA18 */
 };
 
 static const double qr5[6] = { /* for x in [8,4.5454]=1/[0.125,0.22001] */
  -2.08979931141764104297e-11, /* 0xBDB6FA43, 0x1AA1A098 */
  -1.02539050241375426231e-01, /* 0xBFBA3FFF, 0xCB597FEF */
  -8.05644828123936029840e+00, /* 0xC0201CE6, 0xCA03AD4B */
  -1.83669607474888380239e+02, /* 0xC066F56D, 0x6CA7B9B0 */
  -1.37319376065508163265e+03, /* 0xC09574C6, 0x6931734F */
  -2.61244440453215656817e+03, /* 0xC0A468E3, 0x88FDA79D */
 };
 static const double qs5[6] = {
   8.12765501384335777857e+01, /* 0x405451B2, 0xFF5A11B2 */
   1.99179873460485964642e+03, /* 0x409F1F31, 0xE77BF839 */
   1.74684851924908907677e+04, /* 0x40D10F1F, 0x0D64CE29 */
   4.98514270910352279316e+04, /* 0x40E8576D, 0xAABAD197 */
   2.79480751638918118260e+04, /* 0x40DB4B04, 0xCF7C364B */
  -4.71918354795128470869e+03, /* 0xC0B26F2E, 0xFCFFA004 */
 };
 
 static const double qr3[6] = {
  -5.07831226461766561369e-09, /* 0xBE35CFA9, 0xD38FC84F */
  -1.02537829820837089745e-01, /* 0xBFBA3FEB, 0x51AEED54 */
  -4.61011581139473403113e+00, /* 0xC01270C2, 0x3302D9FF */
  -5.78472216562783643212e+01, /* 0xC04CEC71, 0xC25D16DA */
  -2.28244540737631695038e+02, /* 0xC06C87D3, 0x4718D55F */
  -2.19210128478909325622e+02, /* 0xC06B66B9, 0x5F5C1BF6 */
 };
 static const double qs3[6] = {
   4.76651550323729509273e+01, /* 0x4047D523, 0xCCD367E4 */
   6.73865112676699709482e+02, /* 0x40850EEB, 0xC031EE3E */
   3.38015286679526343505e+03, /* 0x40AA684E, 0x448E7C9A */
   5.54772909720722782367e+03, /* 0x40B5ABBA, 0xA61D54A6 */
   1.90311919338810798763e+03, /* 0x409DBC7A, 0x0DD4DF4B */
  -1.35201191444307340817e+02, /* 0xC060E670, 0x290A311F */
 };
 
 static const double qr2[6] = {/* for x in [2.8570,2]=1/[0.3499,0.5] */
  -1.78381727510958865572e-07, /* 0xBE87F126, 0x44C626D2 */
  -1.02517042607985553460e-01, /* 0xBFBA3E8E, 0x9148B010 */
  -2.75220568278187460720e+00, /* 0xC0060484, 0x69BB4EDA */
  -1.96636162643703720221e+01, /* 0xC033A9E2, 0xC168907F */
  -4.23253133372830490089e+01, /* 0xC04529A3, 0xDE104AAA */
  -2.13719211703704061733e+01, /* 0xC0355F36, 0x39CF6E52 */
 };
 static const double qs2[6] = {
   2.95333629060523854548e+01, /* 0x403D888A, 0x78AE64FF */
   2.52981549982190529136e+02, /* 0x406F9F68, 0xDB821CBA */
   7.57502834868645436472e+02, /* 0x4087AC05, 0xCE49A0F7 */
   7.39393205320467245656e+02, /* 0x40871B25, 0x48D4C029 */
   1.55949003336666123687e+02, /* 0x40637E5E, 0x3C3ED8D4 */
  -4.95949898822628210127e+00, /* 0xC013D686, 0xE71BE86B */
 };
 
 static __inline double
 qone(double x)
 {
 	const double *p,*q;
 	double  s,r,z;
 	int32_t ix;
 	GET_HIGH_WORD(ix,x);
 	ix &= 0x7fffffff;
 	if(ix>=0x40200000)     {p = qr8; q= qs8;}
 	else if(ix>=0x40122E8B){p = qr5; q= qs5;}
 	else if(ix>=0x4006DB6D){p = qr3; q= qs3;}
 	else                   {p = qr2; q= qs2;}	/* ix>=0x40000000 */
 	z = one/(x*x);
 	r = p[0]+z*(p[1]+z*(p[2]+z*(p[3]+z*(p[4]+z*p[5]))));
 	s = one+z*(q[0]+z*(q[1]+z*(q[2]+z*(q[3]+z*(q[4]+z*q[5])))));
 	return (.375 + r/s)/x;
 }
diff --git a/lib/msun/src/e_j1f.c b/lib/msun/src/e_j1f.c
index c6c45c107afa..e1f4498b71af 100644
--- a/lib/msun/src/e_j1f.c
+++ b/lib/msun/src/e_j1f.c
@@ -1,338 +1,338 @@
 /* e_j1f.c -- float version of e_j1.c.
  * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
  */
 
 /*
  * ====================================================
  * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
  *
  * Developed at SunPro, a Sun Microsystems, Inc. business.
  * Permission to use, copy, modify, and distribute this
  * software is freely granted, provided that this notice
  * is preserved.
  * ====================================================
  */
 
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
 /*
  * See e_j1.c for complete comments.
  */
 
 #include "math.h"
 #include "math_private.h"
 
 static __inline float ponef(float), qonef(float);
 
 static const volatile float vone = 1, vzero = 0;
 
 static const float
 huge    = 1e30,
 one	= 1.0,
 invsqrtpi=  5.6418961287e-01, /* 0x3f106ebb */
 tpi      =  6.3661974669e-01, /* 0x3f22f983 */
 /* R0/S0 on [0,2] */
 r00  = -6.2500000000e-02, /* 0xbd800000 */
 r01  =  1.4070566976e-03, /* 0x3ab86cfd */
 r02  = -1.5995563444e-05, /* 0xb7862e36 */
 r03  =  4.9672799207e-08, /* 0x335557d2 */
 s01  =  1.9153760746e-02, /* 0x3c9ce859 */
 s02  =  1.8594678841e-04, /* 0x3942fab6 */
 s03  =  1.1771846857e-06, /* 0x359dffc2 */
 s04  =  5.0463624390e-09, /* 0x31ad6446 */
 s05  =  1.2354227016e-11; /* 0x2d59567e */
 
 static const float zero    = 0.0;
 
 float
-__ieee754_j1f(float x)
+j1f(float x)
 {
 	float z, s,c,ss,cc,r,u,v,y;
 	int32_t hx,ix;
 
 	GET_FLOAT_WORD(hx,x);
 	ix = hx&0x7fffffff;
 	if(ix>=0x7f800000) return one/x;
 	y = fabsf(x);
 	if(ix >= 0x40000000) {	/* |x| >= 2.0 */
 		sincosf(y, &s, &c);
 		ss = -s-c;
 		cc = s-c;
 		if(ix<0x7f000000) {  /* make sure y+y not overflow */
 		    z = cosf(y+y);
 		    if ((s*c)>zero) cc = z/ss;
 		    else 	    ss = z/cc;
 		}
 	/*
 	 * j1(x) = 1/sqrt(pi) * (P(1,x)*cc - Q(1,x)*ss) / sqrt(x)
 	 * y1(x) = 1/sqrt(pi) * (P(1,x)*ss + Q(1,x)*cc) / sqrt(x)
 	 */
 		if(ix>0x58000000) z = (invsqrtpi*cc)/sqrtf(y); /* |x|>2**49 */
 		else {
 		    u = ponef(y); v = qonef(y);
 		    z = invsqrtpi*(u*cc-v*ss)/sqrtf(y);
 		}
 		if(hx<0) return -z;
 		else  	 return  z;
 	}
 	if(ix<0x39000000) {	/* |x|<2**-13 */
 	    if(huge+x>one) return (float)0.5*x;/* inexact if x!=0 necessary */
 	}
 	z = x*x;
 	r =  z*(r00+z*(r01+z*(r02+z*r03)));
 	s =  one+z*(s01+z*(s02+z*(s03+z*(s04+z*s05))));
 	r *= x;
 	return(x*(float)0.5+r/s);
 }
 
 static const float U0[5] = {
  -1.9605709612e-01, /* 0xbe48c331 */
   5.0443872809e-02, /* 0x3d4e9e3c */
  -1.9125689287e-03, /* 0xbafaaf2a */
   2.3525259166e-05, /* 0x37c5581c */
  -9.1909917899e-08, /* 0xb3c56003 */
 };
 static const float V0[5] = {
   1.9916731864e-02, /* 0x3ca3286a */
   2.0255257550e-04, /* 0x3954644b */
   1.3560879779e-06, /* 0x35b602d4 */
   6.2274145840e-09, /* 0x31d5f8eb */
   1.6655924903e-11, /* 0x2d9281cf */
 };
 
 float
-__ieee754_y1f(float x)
+y1f(float x)
 {
 	float z, s,c,ss,cc,u,v;
 	int32_t hx,ix;
 
 	GET_FLOAT_WORD(hx,x);
         ix = 0x7fffffff&hx;
 	if(ix>=0x7f800000) return  vone/(x+x*x);
 	if(ix==0) return -one/vzero;
 	if(hx<0) return vzero/vzero;
         if(ix >= 0x40000000) {  /* |x| >= 2.0 */
                 sincosf(x, &s, &c);
                 ss = -s-c;
                 cc = s-c;
                 if(ix<0x7f000000) {  /* make sure x+x not overflow */
                     z = cosf(x+x);
                     if ((s*c)>zero) cc = z/ss;
                     else            ss = z/cc;
                 }
         /* y1(x) = sqrt(2/(pi*x))*(p1(x)*sin(x0)+q1(x)*cos(x0))
          * where x0 = x-3pi/4
          *      Better formula:
          *              cos(x0) = cos(x)cos(3pi/4)+sin(x)sin(3pi/4)
          *                      =  1/sqrt(2) * (sin(x) - cos(x))
          *              sin(x0) = sin(x)cos(3pi/4)-cos(x)sin(3pi/4)
          *                      = -1/sqrt(2) * (cos(x) + sin(x))
          * To avoid cancellation, use
          *              sin(x) +- cos(x) = -cos(2x)/(sin(x) -+ cos(x))
          * to compute the worse one.
          */
                 if(ix>0x58000000) z = (invsqrtpi*ss)/sqrtf(x); /* |x|>2**49 */
                 else {
                     u = ponef(x); v = qonef(x);
                     z = invsqrtpi*(u*ss+v*cc)/sqrtf(x);
                 }
                 return z;
         }
         if(ix<=0x33000000) {    /* x < 2**-25 */
             return(-tpi/x);
         }
         z = x*x;
         u = U0[0]+z*(U0[1]+z*(U0[2]+z*(U0[3]+z*U0[4])));
         v = one+z*(V0[0]+z*(V0[1]+z*(V0[2]+z*(V0[3]+z*V0[4]))));
-        return(x*(u/v) + tpi*(__ieee754_j1f(x)*__ieee754_logf(x)-one/x));
+        return(x*(u/v) + tpi*(j1f(x)*logf(x)-one/x));
 }
 
 /* For x >= 8, the asymptotic expansions of pone is
  *	1 + 15/128 s^2 - 4725/2^15 s^4 - ...,	where s = 1/x.
  * We approximate pone by
  * 	pone(x) = 1 + (R/S)
  * where  R = pr0 + pr1*s^2 + pr2*s^4 + ... + pr5*s^10
  * 	  S = 1 + ps0*s^2 + ... + ps4*s^10
  * and
  *	| pone(x)-1-R/S | <= 2  ** ( -60.06)
  */
 
 static const float pr8[6] = { /* for x in [inf, 8]=1/[0,0.125] */
   0.0000000000e+00, /* 0x00000000 */
   1.1718750000e-01, /* 0x3df00000 */
   1.3239480972e+01, /* 0x4153d4ea */
   4.1205184937e+02, /* 0x43ce06a3 */
   3.8747453613e+03, /* 0x45722bed */
   7.9144794922e+03, /* 0x45f753d6 */
 };
 static const float ps8[5] = {
   1.1420736694e+02, /* 0x42e46a2c */
   3.6509309082e+03, /* 0x45642ee5 */
   3.6956207031e+04, /* 0x47105c35 */
   9.7602796875e+04, /* 0x47bea166 */
   3.0804271484e+04, /* 0x46f0a88b */
 };
 
 static const float pr5[6] = { /* for x in [8,4.5454]=1/[0.125,0.22001] */
   1.3199052094e-11, /* 0x2d68333f */
   1.1718749255e-01, /* 0x3defffff */
   6.8027510643e+00, /* 0x40d9b023 */
   1.0830818176e+02, /* 0x42d89dca */
   5.1763616943e+02, /* 0x440168b7 */
   5.2871520996e+02, /* 0x44042dc6 */
 };
 static const float ps5[5] = {
   5.9280597687e+01, /* 0x426d1f55 */
   9.9140142822e+02, /* 0x4477d9b1 */
   5.3532670898e+03, /* 0x45a74a23 */
   7.8446904297e+03, /* 0x45f52586 */
   1.5040468750e+03, /* 0x44bc0180 */
 };
 
 static const float pr3[6] = {
   3.0250391081e-09, /* 0x314fe10d */
   1.1718686670e-01, /* 0x3defffab */
   3.9329774380e+00, /* 0x407bb5e7 */
   3.5119403839e+01, /* 0x420c7a45 */
   9.1055007935e+01, /* 0x42b61c2a */
   4.8559066772e+01, /* 0x42423c7c */
 };
 static const float ps3[5] = {
   3.4791309357e+01, /* 0x420b2a4d */
   3.3676245117e+02, /* 0x43a86198 */
   1.0468714600e+03, /* 0x4482dbe3 */
   8.9081134033e+02, /* 0x445eb3ed */
   1.0378793335e+02, /* 0x42cf936c */
 };
 
 static const float pr2[6] = {/* for x in [2.8570,2]=1/[0.3499,0.5] */
   1.0771083225e-07, /* 0x33e74ea8 */
   1.1717621982e-01, /* 0x3deffa16 */
   2.3685150146e+00, /* 0x401795c0 */
   1.2242610931e+01, /* 0x4143e1bc */
   1.7693971634e+01, /* 0x418d8d41 */
   5.0735230446e+00, /* 0x40a25a4d */
 };
 static const float ps2[5] = {
   2.1436485291e+01, /* 0x41ab7dec */
   1.2529022980e+02, /* 0x42fa9499 */
   2.3227647400e+02, /* 0x436846c7 */
   1.1767937469e+02, /* 0x42eb5bd7 */
   8.3646392822e+00, /* 0x4105d590 */
 };
 
 static __inline float
 ponef(float x)
 {
 	const float *p,*q;
 	float z,r,s;
         int32_t ix;
 	GET_FLOAT_WORD(ix,x);
 	ix &= 0x7fffffff;
         if(ix>=0x41000000)     {p = pr8; q= ps8;}
         else if(ix>=0x409173eb){p = pr5; q= ps5;}
         else if(ix>=0x4036d917){p = pr3; q= ps3;}
 	else                   {p = pr2; q= ps2;}	/* ix>=0x40000000 */
         z = one/(x*x);
         r = p[0]+z*(p[1]+z*(p[2]+z*(p[3]+z*(p[4]+z*p[5]))));
         s = one+z*(q[0]+z*(q[1]+z*(q[2]+z*(q[3]+z*q[4]))));
         return one+ r/s;
 }
 
 
 /* For x >= 8, the asymptotic expansions of qone is
  *	3/8 s - 105/1024 s^3 - ..., where s = 1/x.
  * We approximate pone by
  * 	qone(x) = s*(0.375 + (R/S))
  * where  R = qr1*s^2 + qr2*s^4 + ... + qr5*s^10
  * 	  S = 1 + qs1*s^2 + ... + qs6*s^12
  * and
  *	| qone(x)/s -0.375-R/S | <= 2  ** ( -61.13)
  */
 
 static const float qr8[6] = { /* for x in [inf, 8]=1/[0,0.125] */
   0.0000000000e+00, /* 0x00000000 */
  -1.0253906250e-01, /* 0xbdd20000 */
  -1.6271753311e+01, /* 0xc1822c8d */
  -7.5960174561e+02, /* 0xc43de683 */
  -1.1849806641e+04, /* 0xc639273a */
  -4.8438511719e+04, /* 0xc73d3683 */
 };
 static const float qs8[6] = {
   1.6139537048e+02, /* 0x43216537 */
   7.8253862305e+03, /* 0x45f48b17 */
   1.3387534375e+05, /* 0x4802bcd6 */
   7.1965775000e+05, /* 0x492fb29c */
   6.6660125000e+05, /* 0x4922be94 */
  -2.9449025000e+05, /* 0xc88fcb48 */
 };
 
 static const float qr5[6] = { /* for x in [8,4.5454]=1/[0.125,0.22001] */
  -2.0897993405e-11, /* 0xadb7d219 */
  -1.0253904760e-01, /* 0xbdd1fffe */
  -8.0564479828e+00, /* 0xc100e736 */
  -1.8366960144e+02, /* 0xc337ab6b */
  -1.3731937256e+03, /* 0xc4aba633 */
  -2.6124443359e+03, /* 0xc523471c */
 };
 static const float qs5[6] = {
   8.1276550293e+01, /* 0x42a28d98 */
   1.9917987061e+03, /* 0x44f8f98f */
   1.7468484375e+04, /* 0x468878f8 */
   4.9851425781e+04, /* 0x4742bb6d */
   2.7948074219e+04, /* 0x46da5826 */
  -4.7191835938e+03, /* 0xc5937978 */
 };
 
 static const float qr3[6] = {
  -5.0783124372e-09, /* 0xb1ae7d4f */
  -1.0253783315e-01, /* 0xbdd1ff5b */
  -4.6101160049e+00, /* 0xc0938612 */
  -5.7847221375e+01, /* 0xc267638e */
  -2.2824453735e+02, /* 0xc3643e9a */
  -2.1921012878e+02, /* 0xc35b35cb */
 };
 static const float qs3[6] = {
   4.7665153503e+01, /* 0x423ea91e */
   6.7386511230e+02, /* 0x4428775e */
   3.3801528320e+03, /* 0x45534272 */
   5.5477290039e+03, /* 0x45ad5dd5 */
   1.9031191406e+03, /* 0x44ede3d0 */
  -1.3520118713e+02, /* 0xc3073381 */
 };
 
 static const float qr2[6] = {/* for x in [2.8570,2]=1/[0.3499,0.5] */
  -1.7838172539e-07, /* 0xb43f8932 */
  -1.0251704603e-01, /* 0xbdd1f475 */
  -2.7522056103e+00, /* 0xc0302423 */
  -1.9663616180e+01, /* 0xc19d4f16 */
  -4.2325313568e+01, /* 0xc2294d1f */
  -2.1371921539e+01, /* 0xc1aaf9b2 */
 };
 static const float qs2[6] = {
   2.9533363342e+01, /* 0x41ec4454 */
   2.5298155212e+02, /* 0x437cfb47 */
   7.5750280762e+02, /* 0x443d602e */
   7.3939318848e+02, /* 0x4438d92a */
   1.5594900513e+02, /* 0x431bf2f2 */
  -4.9594988823e+00, /* 0xc09eb437 */
 };
 
 static __inline float
 qonef(float x)
 {
 	const float *p,*q;
 	float  s,r,z;
 	int32_t ix;
 	GET_FLOAT_WORD(ix,x);
 	ix &= 0x7fffffff;
 	if(ix>=0x41000000)     {p = qr8; q= qs8;}
 	else if(ix>=0x409173eb){p = qr5; q= qs5;}
 	else if(ix>=0x4036d917){p = qr3; q= qs3;}
 	else                   {p = qr2; q= qs2;}	/* ix>=0x40000000 */
 	z = one/(x*x);
 	r = p[0]+z*(p[1]+z*(p[2]+z*(p[3]+z*(p[4]+z*p[5]))));
 	s = one+z*(q[0]+z*(q[1]+z*(q[2]+z*(q[3]+z*(q[4]+z*q[5])))));
 	return ((float).375 + r/s)/x;
 }
diff --git a/lib/msun/src/e_jn.c b/lib/msun/src/e_jn.c
index c7ba7da6567b..b70c496e6735 100644
--- a/lib/msun/src/e_jn.c
+++ b/lib/msun/src/e_jn.c
@@ -1,274 +1,274 @@
 /* @(#)e_jn.c 1.4 95/01/18 */
 /*
  * ====================================================
  * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
  *
  * Developed at SunSoft, a Sun Microsystems, Inc. business.
  * Permission to use, copy, modify, and distribute this
  * software is freely granted, provided that this notice
  * is preserved.
  * ====================================================
  */
 
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
 /*
- * __ieee754_jn(n, x), __ieee754_yn(n, x)
+ * jn(n, x), yn(n, x)
  * floating point Bessel's function of the 1st and 2nd kind
  * of order n
  *
  * Special cases:
  *	y0(0)=y1(0)=yn(n,0) = -inf with division by zero signal;
  *	y0(-ve)=y1(-ve)=yn(n,-ve) are NaN with invalid signal.
  * Note 2. About jn(n,x), yn(n,x)
  *	For n=0, j0(x) is called,
  *	for n=1, j1(x) is called,
  *	for n<x, forward recursion us used starting
  *	from values of j0(x) and j1(x).
  *	for n>x, a continued fraction approximation to
  *	j(n,x)/j(n-1,x) is evaluated and then backward
  *	recursion is used starting from a supposed value
  *	for j(n,x). The resulting value of j(0,x) is
  *	compared with the actual value to correct the
  *	supposed value of j(n,x).
  *
  *	yn(n,x) is similar in all respects, except
  *	that forward recursion is used for all
  *	values of n>1.
  */
 
 #include "math.h"
 #include "math_private.h"
 
 static const volatile double vone = 1, vzero = 0;
 
 static const double
 invsqrtpi=  5.64189583547756279280e-01, /* 0x3FE20DD7, 0x50429B6D */
 two   =  2.00000000000000000000e+00, /* 0x40000000, 0x00000000 */
 one   =  1.00000000000000000000e+00; /* 0x3FF00000, 0x00000000 */
 
 static const double zero  =  0.00000000000000000000e+00;
 
 double
-__ieee754_jn(int n, double x)
+jn(int n, double x)
 {
 	int32_t i,hx,ix,lx, sgn;
 	double a, b, c, s, temp, di;
 	double z, w;
 
     /* J(-n,x) = (-1)^n * J(n, x), J(n, -x) = (-1)^n * J(n, x)
      * Thus, J(-n,x) = J(n,-x)
      */
 	EXTRACT_WORDS(hx,lx,x);
 	ix = 0x7fffffff&hx;
     /* if J(n,NaN) is NaN */
 	if((ix|((u_int32_t)(lx|-lx))>>31)>0x7ff00000) return x+x;
 	if(n<0){
 		n = -n;
 		x = -x;
 		hx ^= 0x80000000;
 	}
-	if(n==0) return(__ieee754_j0(x));
-	if(n==1) return(__ieee754_j1(x));
+	if(n==0) return(j0(x));
+	if(n==1) return(j1(x));
 	sgn = (n&1)&(hx>>31);	/* even n -- 0, odd n -- sign(x) */
 	x = fabs(x);
 	if((ix|lx)==0||ix>=0x7ff00000) 	/* if x is 0 or inf */
 	    b = zero;
 	else if((double)n<=x) {
 		/* Safe to use J(n+1,x)=2n/x *J(n,x)-J(n-1,x) */
 	    if(ix>=0x52D00000) { /* x > 2**302 */
     /* (x >> n**2)
      *	    Jn(x) = cos(x-(2n+1)*pi/4)*sqrt(2/x*pi)
      *	    Yn(x) = sin(x-(2n+1)*pi/4)*sqrt(2/x*pi)
      *	    Let s=sin(x), c=cos(x),
      *		xn=x-(2n+1)*pi/4, sqt2 = sqrt(2), then
      *
      *		   n	sin(xn)*sqt2	cos(xn)*sqt2
      *		----------------------------------
      *		   0	 s-c		 c+s
      *		   1	-s-c 		-c+s
      *		   2	-s+c		-c-s
      *		   3	 s+c		 c-s
      */
 		sincos(x, &s, &c);
 		switch(n&3) {
 		    case 0: temp =  c+s; break;
 		    case 1: temp = -c+s; break;
 		    case 2: temp = -c-s; break;
 		    case 3: temp =  c-s; break;
 		}
 		b = invsqrtpi*temp/sqrt(x);
 	    } else {
-	        a = __ieee754_j0(x);
-	        b = __ieee754_j1(x);
+	        a = j0(x);
+	        b = j1(x);
 	        for(i=1;i<n;i++){
 		    temp = b;
 		    b = b*((double)(i+i)/x) - a; /* avoid underflow */
 		    a = temp;
 	        }
 	    }
 	} else {
 	    if(ix<0x3e100000) {	/* x < 2**-29 */
     /* x is tiny, return the first Taylor expansion of J(n,x)
      * J(n,x) = 1/n!*(x/2)^n  - ...
      */
 		if(n>33)	/* underflow */
 		    b = zero;
 		else {
 		    temp = x*0.5; b = temp;
 		    for (a=one,i=2;i<=n;i++) {
 			a *= (double)i;		/* a = n! */
 			b *= temp;		/* b = (x/2)^n */
 		    }
 		    b = b/a;
 		}
 	    } else {
 		/* use backward recurrence */
 		/* 			x      x^2      x^2
 		 *  J(n,x)/J(n-1,x) =  ----   ------   ------   .....
 		 *			2n  - 2(n+1) - 2(n+2)
 		 *
 		 * 			1      1        1
 		 *  (for large x)   =  ----  ------   ------   .....
 		 *			2n   2(n+1)   2(n+2)
 		 *			-- - ------ - ------ -
 		 *			 x     x         x
 		 *
 		 * Let w = 2n/x and h=2/x, then the above quotient
 		 * is equal to the continued fraction:
 		 *		    1
 		 *	= -----------------------
 		 *		       1
 		 *	   w - -----------------
 		 *			  1
 		 * 	        w+h - ---------
 		 *		       w+2h - ...
 		 *
 		 * To determine how many terms needed, let
 		 * Q(0) = w, Q(1) = w(w+h) - 1,
 		 * Q(k) = (w+k*h)*Q(k-1) - Q(k-2),
 		 * When Q(k) > 1e4	good for single
 		 * When Q(k) > 1e9	good for double
 		 * When Q(k) > 1e17	good for quadruple
 		 */
 	    /* determine k */
 		double t,v;
 		double q0,q1,h,tmp; int32_t k,m;
 		w  = (n+n)/(double)x; h = 2.0/(double)x;
 		q0 = w;  z = w+h; q1 = w*z - 1.0; k=1;
 		while(q1<1.0e9) {
 			k += 1; z += h;
 			tmp = z*q1 - q0;
 			q0 = q1;
 			q1 = tmp;
 		}
 		m = n+n;
 		for(t=zero, i = 2*(n+k); i>=m; i -= 2) t = one/(i/x-t);
 		a = t;
 		b = one;
 		/*  estimate log((2/x)^n*n!) = n*log(2/x)+n*ln(n)
 		 *  Hence, if n*(log(2n/x)) > ...
 		 *  single 8.8722839355e+01
 		 *  double 7.09782712893383973096e+02
 		 *  long double 1.1356523406294143949491931077970765006170e+04
 		 *  then recurrent value may overflow and the result is
 		 *  likely underflow to zero
 		 */
 		tmp = n;
 		v = two/x;
-		tmp = tmp*__ieee754_log(fabs(v*tmp));
+		tmp = tmp*log(fabs(v*tmp));
 		if(tmp<7.09782712893383973096e+02) {
 	    	    for(i=n-1,di=(double)(i+i);i>0;i--){
 		        temp = b;
 			b *= di;
 			b  = b/x - a;
 		        a = temp;
 			di -= two;
 	     	    }
 		} else {
 	    	    for(i=n-1,di=(double)(i+i);i>0;i--){
 		        temp = b;
 			b *= di;
 			b  = b/x - a;
 		        a = temp;
 			di -= two;
 		    /* scale b to avoid spurious overflow */
 			if(b>1e100) {
 			    a /= b;
 			    t /= b;
 			    b  = one;
 			}
 	     	    }
 		}
-		z = __ieee754_j0(x);
-		w = __ieee754_j1(x);
+		z = j0(x);
+		w = j1(x);
 		if (fabs(z) >= fabs(w))
 		    b = (t*z/b);
 		else
 		    b = (t*w/a);
 	    }
 	}
 	if(sgn==1) return -b; else return b;
 }
 
 double
-__ieee754_yn(int n, double x)
+yn(int n, double x)
 {
 	int32_t i,hx,ix,lx;
 	int32_t sign;
 	double a, b, c, s, temp;
 
 	EXTRACT_WORDS(hx,lx,x);
 	ix = 0x7fffffff&hx;
 	/* yn(n,NaN) = NaN */
 	if((ix|((u_int32_t)(lx|-lx))>>31)>0x7ff00000) return x+x;
 	/* yn(n,+-0) = -inf and raise divide-by-zero exception. */
 	if((ix|lx)==0) return -one/vzero;
 	/* yn(n,x<0) = NaN and raise invalid exception. */
 	if(hx<0) return vzero/vzero;
 	sign = 1;
 	if(n<0){
 		n = -n;
 		sign = 1 - ((n&1)<<1);
 	}
-	if(n==0) return(__ieee754_y0(x));
-	if(n==1) return(sign*__ieee754_y1(x));
+	if(n==0) return(y0(x));
+	if(n==1) return(sign*y1(x));
 	if(ix==0x7ff00000) return zero;
 	if(ix>=0x52D00000) { /* x > 2**302 */
     /* (x >> n**2)
      *	    Jn(x) = cos(x-(2n+1)*pi/4)*sqrt(2/x*pi)
      *	    Yn(x) = sin(x-(2n+1)*pi/4)*sqrt(2/x*pi)
      *	    Let s=sin(x), c=cos(x),
      *		xn=x-(2n+1)*pi/4, sqt2 = sqrt(2), then
      *
      *		   n	sin(xn)*sqt2	cos(xn)*sqt2
      *		----------------------------------
      *		   0	 s-c		 c+s
      *		   1	-s-c 		-c+s
      *		   2	-s+c		-c-s
      *		   3	 s+c		 c-s
      */
 		sincos(x, &s, &c);
 		switch(n&3) {
 		    case 0: temp =  s-c; break;
 		    case 1: temp = -s-c; break;
 		    case 2: temp = -s+c; break;
 		    case 3: temp =  s+c; break;
 		}
 		b = invsqrtpi*temp/sqrt(x);
 	} else {
 	    u_int32_t high;
-	    a = __ieee754_y0(x);
-	    b = __ieee754_y1(x);
+	    a = y0(x);
+	    b = y1(x);
 	/* quit if b is -inf */
 	    GET_HIGH_WORD(high,b);
 	    for(i=1;i<n&&high!=0xfff00000;i++){
 		temp = b;
 		b = ((double)(i+i)/x)*b - a;
 		GET_HIGH_WORD(high,b);
 		a = temp;
 	    }
 	}
 	if(sign>0) return b; else return -b;
 }
diff --git a/lib/msun/src/e_jnf.c b/lib/msun/src/e_jnf.c
index 965feeb666d4..ba586226dae5 100644
--- a/lib/msun/src/e_jnf.c
+++ b/lib/msun/src/e_jnf.c
@@ -1,204 +1,204 @@
 /* e_jnf.c -- float version of e_jn.c.
  * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
  */
 
 /*
  * ====================================================
  * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
  *
  * Developed at SunPro, a Sun Microsystems, Inc. business.
  * Permission to use, copy, modify, and distribute this
  * software is freely granted, provided that this notice
  * is preserved.
  * ====================================================
  */
 
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
 /*
  * See e_jn.c for complete comments.
  */
 
 #include "math.h"
 #include "math_private.h"
 
 static const volatile float vone = 1, vzero = 0;
 
 static const float
 two   =  2.0000000000e+00, /* 0x40000000 */
 one   =  1.0000000000e+00; /* 0x3F800000 */
 
 static const float zero  =  0.0000000000e+00;
 
 float
-__ieee754_jnf(int n, float x)
+jnf(int n, float x)
 {
 	int32_t i,hx,ix, sgn;
 	float a, b, temp, di;
 	float z, w;
 
     /* J(-n,x) = (-1)^n * J(n, x), J(n, -x) = (-1)^n * J(n, x)
      * Thus, J(-n,x) = J(n,-x)
      */
 	GET_FLOAT_WORD(hx,x);
 	ix = 0x7fffffff&hx;
     /* if J(n,NaN) is NaN */
 	if(ix>0x7f800000) return x+x;
 	if(n<0){
 		n = -n;
 		x = -x;
 		hx ^= 0x80000000;
 	}
-	if(n==0) return(__ieee754_j0f(x));
-	if(n==1) return(__ieee754_j1f(x));
+	if(n==0) return(j0f(x));
+	if(n==1) return(j1f(x));
 	sgn = (n&1)&(hx>>31);	/* even n -- 0, odd n -- sign(x) */
 	x = fabsf(x);
 	if(ix==0||ix>=0x7f800000) 	/* if x is 0 or inf */
 	    b = zero;
 	else if((float)n<=x) {
 		/* Safe to use J(n+1,x)=2n/x *J(n,x)-J(n-1,x) */
-	    a = __ieee754_j0f(x);
-	    b = __ieee754_j1f(x);
+	    a = j0f(x);
+	    b = j1f(x);
 	    for(i=1;i<n;i++){
 		temp = b;
 		b = b*((float)(i+i)/x) - a; /* avoid underflow */
 		a = temp;
 	    }
 	} else {
 	    if(ix<0x30800000) {	/* x < 2**-29 */
     /* x is tiny, return the first Taylor expansion of J(n,x)
      * J(n,x) = 1/n!*(x/2)^n  - ...
      */
 		if(n>33)	/* underflow */
 		    b = zero;
 		else {
 		    temp = x*(float)0.5; b = temp;
 		    for (a=one,i=2;i<=n;i++) {
 			a *= (float)i;		/* a = n! */
 			b *= temp;		/* b = (x/2)^n */
 		    }
 		    b = b/a;
 		}
 	    } else {
 		/* use backward recurrence */
 		/* 			x      x^2      x^2
 		 *  J(n,x)/J(n-1,x) =  ----   ------   ------   .....
 		 *			2n  - 2(n+1) - 2(n+2)
 		 *
 		 * 			1      1        1
 		 *  (for large x)   =  ----  ------   ------   .....
 		 *			2n   2(n+1)   2(n+2)
 		 *			-- - ------ - ------ -
 		 *			 x     x         x
 		 *
 		 * Let w = 2n/x and h=2/x, then the above quotient
 		 * is equal to the continued fraction:
 		 *		    1
 		 *	= -----------------------
 		 *		       1
 		 *	   w - -----------------
 		 *			  1
 		 * 	        w+h - ---------
 		 *		       w+2h - ...
 		 *
 		 * To determine how many terms needed, let
 		 * Q(0) = w, Q(1) = w(w+h) - 1,
 		 * Q(k) = (w+k*h)*Q(k-1) - Q(k-2),
 		 * When Q(k) > 1e4	good for single
 		 * When Q(k) > 1e9	good for double
 		 * When Q(k) > 1e17	good for quadruple
 		 */
 	    /* determine k */
 		float t,v;
 		float q0,q1,h,tmp; int32_t k,m;
 		w  = (n+n)/(float)x; h = (float)2.0/(float)x;
 		q0 = w;  z = w+h; q1 = w*z - (float)1.0; k=1;
 		while(q1<(float)1.0e9) {
 			k += 1; z += h;
 			tmp = z*q1 - q0;
 			q0 = q1;
 			q1 = tmp;
 		}
 		m = n+n;
 		for(t=zero, i = 2*(n+k); i>=m; i -= 2) t = one/(i/x-t);
 		a = t;
 		b = one;
 		/*  estimate log((2/x)^n*n!) = n*log(2/x)+n*ln(n)
 		 *  Hence, if n*(log(2n/x)) > ...
 		 *  single 8.8722839355e+01
 		 *  double 7.09782712893383973096e+02
 		 *  long double 1.1356523406294143949491931077970765006170e+04
 		 *  then recurrent value may overflow and the result is
 		 *  likely underflow to zero
 		 */
 		tmp = n;
 		v = two/x;
-		tmp = tmp*__ieee754_logf(fabsf(v*tmp));
+		tmp = tmp*logf(fabsf(v*tmp));
 		if(tmp<(float)8.8721679688e+01) {
 	    	    for(i=n-1,di=(float)(i+i);i>0;i--){
 		        temp = b;
 			b *= di;
 			b  = b/x - a;
 		        a = temp;
 			di -= two;
 	     	    }
 		} else {
 	    	    for(i=n-1,di=(float)(i+i);i>0;i--){
 		        temp = b;
 			b *= di;
 			b  = b/x - a;
 		        a = temp;
 			di -= two;
 		    /* scale b to avoid spurious overflow */
 			if(b>(float)1e10) {
 			    a /= b;
 			    t /= b;
 			    b  = one;
 			}
 	     	    }
 		}
-		z = __ieee754_j0f(x);
-		w = __ieee754_j1f(x);
+		z = j0f(x);
+		w = j1f(x);
 		if (fabsf(z) >= fabsf(w))
 		    b = (t*z/b);
 		else
 		    b = (t*w/a);
 	    }
 	}
 	if(sgn==1) return -b; else return b;
 }
 
 float
-__ieee754_ynf(int n, float x)
+ynf(int n, float x)
 {
 	int32_t i,hx,ix,ib;
 	int32_t sign;
 	float a, b, temp;
 
 	GET_FLOAT_WORD(hx,x);
 	ix = 0x7fffffff&hx;
 	if(ix>0x7f800000) return x+x;
 	if(ix==0) return -one/vzero;
 	if(hx<0) return vzero/vzero;
 	sign = 1;
 	if(n<0){
 		n = -n;
 		sign = 1 - ((n&1)<<1);
 	}
-	if(n==0) return(__ieee754_y0f(x));
-	if(n==1) return(sign*__ieee754_y1f(x));
+	if(n==0) return(y0f(x));
+	if(n==1) return(sign*y1f(x));
 	if(ix==0x7f800000) return zero;
 
-	a = __ieee754_y0f(x);
-	b = __ieee754_y1f(x);
+	a = y0f(x);
+	b = y1f(x);
 	/* quit if b is -inf */
 	GET_FLOAT_WORD(ib,b);
 	for(i=1;i<n&&ib!=0xff800000;i++){
 	    temp = b;
 	    b = ((float)(i+i)/x)*b - a;
 	    GET_FLOAT_WORD(ib,b);
 	    a = temp;
 	}
 	if(sign>0) return b; else return -b;
 }
diff --git a/lib/msun/src/e_lgamma.c b/lib/msun/src/e_lgamma.c
index 43f5175603ec..9c4a30e6e135 100644
--- a/lib/msun/src/e_lgamma.c
+++ b/lib/msun/src/e_lgamma.c
@@ -1,39 +1,39 @@
 
 /* @(#)e_lgamma.c 1.3 95/01/18 */
 /*
  * ====================================================
  * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
  *
  * Developed at SunSoft, a Sun Microsystems, Inc. business.
  * Permission to use, copy, modify, and distribute this
  * software is freely granted, provided that this notice 
  * is preserved.
  * ====================================================
  *
  */
 
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
-/* __ieee754_lgamma(x)
+/* lgamma(x)
  * Return the logarithm of the Gamma function of x.
  *
- * Method: call __ieee754_lgamma_r
+ * Method: call lgamma_r
  */
 
 #include <float.h>
 
 #include "math.h"
 #include "math_private.h"
 
 extern int signgam;
 
 double
-__ieee754_lgamma(double x)
+lgamma(double x)
 {
-	return __ieee754_lgamma_r(x,&signgam);
+	return lgamma_r(x,&signgam);
 }
 
 #if (LDBL_MANT_DIG == 53)
 __weak_reference(lgamma, lgammal);
 #endif
diff --git a/lib/msun/src/e_lgamma_r.c b/lib/msun/src/e_lgamma_r.c
index be70767ec5c0..83a7ecbd7189 100644
--- a/lib/msun/src/e_lgamma_r.c
+++ b/lib/msun/src/e_lgamma_r.c
@@ -1,303 +1,303 @@
 /* @(#)e_lgamma_r.c 1.3 95/01/18 */
 /*
  * ====================================================
  * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
  *
  * Developed at SunSoft, a Sun Microsystems, Inc. business.
  * Permission to use, copy, modify, and distribute this
  * software is freely granted, provided that this notice
  * is preserved.
  * ====================================================
  */
 
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
-/* __ieee754_lgamma_r(x, signgamp)
+/* lgamma_r(x, signgamp)
  * Reentrant version of the logarithm of the Gamma function
  * with user provide pointer for the sign of Gamma(x).
  *
  * Method:
  *   1. Argument Reduction for 0 < x <= 8
  * 	Since gamma(1+s)=s*gamma(s), for x in [0,8], we may
  * 	reduce x to a number in [1.5,2.5] by
  * 		lgamma(1+s) = log(s) + lgamma(s)
  *	for example,
  *		lgamma(7.3) = log(6.3) + lgamma(6.3)
  *			    = log(6.3*5.3) + lgamma(5.3)
  *			    = log(6.3*5.3*4.3*3.3*2.3) + lgamma(2.3)
  *   2. Polynomial approximation of lgamma around its
  *	minimun ymin=1.461632144968362245 to maintain monotonicity.
  *	On [ymin-0.23, ymin+0.27] (i.e., [1.23164,1.73163]), use
  *		Let z = x-ymin;
  *		lgamma(x) = -1.214862905358496078218 + z^2*poly(z)
  *	where
  *		poly(z) is a 14 degree polynomial.
  *   2. Rational approximation in the primary interval [2,3]
  *	We use the following approximation:
  *		s = x-2.0;
  *		lgamma(x) = 0.5*s + s*P(s)/Q(s)
  *	with accuracy
  *		|P/Q - (lgamma(x)-0.5s)| < 2**-61.71
  *	Our algorithms are based on the following observation
  *
  *                             zeta(2)-1    2    zeta(3)-1    3
  * lgamma(2+s) = s*(1-Euler) + --------- * s  -  --------- * s  + ...
  *                                 2                 3
  *
  *	where Euler = 0.5771... is the Euler constant, which is very
  *	close to 0.5.
  *
  *   3. For x>=8, we have
  *	lgamma(x)~(x-0.5)log(x)-x+0.5*log(2pi)+1/(12x)-1/(360x**3)+....
  *	(better formula:
  *	   lgamma(x)~(x-0.5)*(log(x)-1)-.5*(log(2pi)-1) + ...)
  *	Let z = 1/x, then we approximation
  *		f(z) = lgamma(x) - (x-0.5)(log(x)-1)
  *	by
  *	  			    3       5             11
  *		w = w0 + w1*z + w2*z  + w3*z  + ... + w6*z
  *	where
  *		|w - f(z)| < 2**-58.74
  *
  *   4. For negative x, since (G is gamma function)
  *		-x*G(-x)*G(x) = pi/sin(pi*x),
  * 	we have
  * 		G(x) = pi/(sin(pi*x)*(-x)*G(-x))
  *	since G(-x) is positive, sign(G(x)) = sign(sin(pi*x)) for x<0
  *	Hence, for x<0, signgam = sign(sin(pi*x)) and
  *		lgamma(x) = log(|Gamma(x)|)
  *			  = log(pi/(|x*sin(pi*x)|)) - lgamma(-x);
  *	Note: one should avoid compute pi*(-x) directly in the
  *	      computation of sin(pi*(-x)).
  *
  *   5. Special Cases
  *		lgamma(2+s) ~ s*(1-Euler) for tiny s
  *		lgamma(1) = lgamma(2) = 0
  *		lgamma(x) ~ -log(|x|) for tiny x
  *		lgamma(0) = lgamma(neg.integer) = inf and raise divide-by-zero
  *		lgamma(inf) = inf
  *		lgamma(-inf) = inf (bug for bug compatible with C99!?)
  */
 
 #include <float.h>
 
 #include "math.h"
 #include "math_private.h"
 
 static const volatile double vzero = 0;
 
 static const double
 zero=  0.00000000000000000000e+00,
 half=  5.00000000000000000000e-01, /* 0x3FE00000, 0x00000000 */
 one =  1.00000000000000000000e+00, /* 0x3FF00000, 0x00000000 */
 pi  =  3.14159265358979311600e+00, /* 0x400921FB, 0x54442D18 */
 a0  =  7.72156649015328655494e-02, /* 0x3FB3C467, 0xE37DB0C8 */
 a1  =  3.22467033424113591611e-01, /* 0x3FD4A34C, 0xC4A60FAD */
 a2  =  6.73523010531292681824e-02, /* 0x3FB13E00, 0x1A5562A7 */
 a3  =  2.05808084325167332806e-02, /* 0x3F951322, 0xAC92547B */
 a4  =  7.38555086081402883957e-03, /* 0x3F7E404F, 0xB68FEFE8 */
 a5  =  2.89051383673415629091e-03, /* 0x3F67ADD8, 0xCCB7926B */
 a6  =  1.19270763183362067845e-03, /* 0x3F538A94, 0x116F3F5D */
 a7  =  5.10069792153511336608e-04, /* 0x3F40B6C6, 0x89B99C00 */
 a8  =  2.20862790713908385557e-04, /* 0x3F2CF2EC, 0xED10E54D */
 a9  =  1.08011567247583939954e-04, /* 0x3F1C5088, 0x987DFB07 */
 a10 =  2.52144565451257326939e-05, /* 0x3EFA7074, 0x428CFA52 */
 a11 =  4.48640949618915160150e-05, /* 0x3F07858E, 0x90A45837 */
 tc  =  1.46163214496836224576e+00, /* 0x3FF762D8, 0x6356BE3F */
 tf  = -1.21486290535849611461e-01, /* 0xBFBF19B9, 0xBCC38A42 */
 /* tt = -(tail of tf) */
 tt  = -3.63867699703950536541e-18, /* 0xBC50C7CA, 0xA48A971F */
 t0  =  4.83836122723810047042e-01, /* 0x3FDEF72B, 0xC8EE38A2 */
 t1  = -1.47587722994593911752e-01, /* 0xBFC2E427, 0x8DC6C509 */
 t2  =  6.46249402391333854778e-02, /* 0x3FB08B42, 0x94D5419B */
 t3  = -3.27885410759859649565e-02, /* 0xBFA0C9A8, 0xDF35B713 */
 t4  =  1.79706750811820387126e-02, /* 0x3F9266E7, 0x970AF9EC */
 t5  = -1.03142241298341437450e-02, /* 0xBF851F9F, 0xBA91EC6A */
 t6  =  6.10053870246291332635e-03, /* 0x3F78FCE0, 0xE370E344 */
 t7  = -3.68452016781138256760e-03, /* 0xBF6E2EFF, 0xB3E914D7 */
 t8  =  2.25964780900612472250e-03, /* 0x3F6282D3, 0x2E15C915 */
 t9  = -1.40346469989232843813e-03, /* 0xBF56FE8E, 0xBF2D1AF1 */
 t10 =  8.81081882437654011382e-04, /* 0x3F4CDF0C, 0xEF61A8E9 */
 t11 = -5.38595305356740546715e-04, /* 0xBF41A610, 0x9C73E0EC */
 t12 =  3.15632070903625950361e-04, /* 0x3F34AF6D, 0x6C0EBBF7 */
 t13 = -3.12754168375120860518e-04, /* 0xBF347F24, 0xECC38C38 */
 t14 =  3.35529192635519073543e-04, /* 0x3F35FD3E, 0xE8C2D3F4 */
 u0  = -7.72156649015328655494e-02, /* 0xBFB3C467, 0xE37DB0C8 */
 u1  =  6.32827064025093366517e-01, /* 0x3FE4401E, 0x8B005DFF */
 u2  =  1.45492250137234768737e+00, /* 0x3FF7475C, 0xD119BD6F */
 u3  =  9.77717527963372745603e-01, /* 0x3FEF4976, 0x44EA8450 */
 u4  =  2.28963728064692451092e-01, /* 0x3FCD4EAE, 0xF6010924 */
 u5  =  1.33810918536787660377e-02, /* 0x3F8B678B, 0xBF2BAB09 */
 v1  =  2.45597793713041134822e+00, /* 0x4003A5D7, 0xC2BD619C */
 v2  =  2.12848976379893395361e+00, /* 0x40010725, 0xA42B18F5 */
 v3  =  7.69285150456672783825e-01, /* 0x3FE89DFB, 0xE45050AF */
 v4  =  1.04222645593369134254e-01, /* 0x3FBAAE55, 0xD6537C88 */
 v5  =  3.21709242282423911810e-03, /* 0x3F6A5ABB, 0x57D0CF61 */
 s0  = -7.72156649015328655494e-02, /* 0xBFB3C467, 0xE37DB0C8 */
 s1  =  2.14982415960608852501e-01, /* 0x3FCB848B, 0x36E20878 */
 s2  =  3.25778796408930981787e-01, /* 0x3FD4D98F, 0x4F139F59 */
 s3  =  1.46350472652464452805e-01, /* 0x3FC2BB9C, 0xBEE5F2F7 */
 s4  =  2.66422703033638609560e-02, /* 0x3F9B481C, 0x7E939961 */
 s5  =  1.84028451407337715652e-03, /* 0x3F5E26B6, 0x7368F239 */
 s6  =  3.19475326584100867617e-05, /* 0x3F00BFEC, 0xDD17E945 */
 r1  =  1.39200533467621045958e+00, /* 0x3FF645A7, 0x62C4AB74 */
 r2  =  7.21935547567138069525e-01, /* 0x3FE71A18, 0x93D3DCDC */
 r3  =  1.71933865632803078993e-01, /* 0x3FC601ED, 0xCCFBDF27 */
 r4  =  1.86459191715652901344e-02, /* 0x3F9317EA, 0x742ED475 */
 r5  =  7.77942496381893596434e-04, /* 0x3F497DDA, 0xCA41A95B */
 r6  =  7.32668430744625636189e-06, /* 0x3EDEBAF7, 0xA5B38140 */
 w0  =  4.18938533204672725052e-01, /* 0x3FDACFE3, 0x90C97D69 */
 w1  =  8.33333333333329678849e-02, /* 0x3FB55555, 0x5555553B */
 w2  = -2.77777777728775536470e-03, /* 0xBF66C16C, 0x16B02E5C */
 w3  =  7.93650558643019558500e-04, /* 0x3F4A019F, 0x98CF38B6 */
 w4  = -5.95187557450339963135e-04, /* 0xBF4380CB, 0x8C0FE741 */
 w5  =  8.36339918996282139126e-04, /* 0x3F4B67BA, 0x4CDAD5D1 */
 w6  = -1.63092934096575273989e-03; /* 0xBF5AB89D, 0x0B9E43E4 */
 
 /*
  * Compute sin(pi*x) without actually doing the pi*x multiplication.
  * sin_pi(x) is only called for x < 0 and |x| < 2**(p-1) where p is
  * the precision of x.
  */
 static double
 sin_pi(double x)
 {
 	volatile double vz;
 	double y,z;
 	int n;
 
 	y = -x;
 
 	vz = y+0x1p52;			/* depend on 0 <= y < 0x1p52 */
 	z = vz-0x1p52;			/* rint(y) for the above range */
 	if (z == y)
 	    return zero;
 
 	vz = y+0x1p50;
 	GET_LOW_WORD(n,vz);		/* bits for rounded y (units 0.25) */
 	z = vz-0x1p50;			/* y rounded to a multiple of 0.25 */
 	if (z > y) {
 	    z -= 0.25;			/* adjust to round down */
 	    n--;
 	}
 	n &= 7;				/* octant of y mod 2 */
 	y = y - z + n * 0.25;		/* y mod 2 */
 
 	switch (n) {
 	    case 0:   y =  __kernel_sin(pi*y,zero,0); break;
 	    case 1:
 	    case 2:   y =  __kernel_cos(pi*(0.5-y),zero); break;
 	    case 3:
 	    case 4:   y =  __kernel_sin(pi*(one-y),zero,0); break;
 	    case 5:
 	    case 6:   y = -__kernel_cos(pi*(y-1.5),zero); break;
 	    default:  y =  __kernel_sin(pi*(y-2.0),zero,0); break;
 	    }
 	return -y;
 }
 
 
 double
-__ieee754_lgamma_r(double x, int *signgamp)
+lgamma_r(double x, int *signgamp)
 {
 	double nadj,p,p1,p2,p3,q,r,t,w,y,z;
 	int32_t hx;
 	int i,ix,lx;
 
 	EXTRACT_WORDS(hx,lx,x);
 
     /* purge +-Inf and NaNs */
 	*signgamp = 1;
 	ix = hx&0x7fffffff;
 	if(ix>=0x7ff00000) return x*x;
 
     /* purge +-0 and tiny arguments */
 	*signgamp = 1-2*((uint32_t)hx>>31);
 	if(ix<0x3c700000) {	/* |x|<2**-56, return -log(|x|) */
 	    if((ix|lx)==0)
 	        return one/vzero;
-	    return -__ieee754_log(fabs(x));
+	    return -log(fabs(x));
 	}
 
     /* purge negative integers and start evaluation for other x < 0 */
 	if(hx<0) {
 	    *signgamp = 1;
 	    if(ix>=0x43300000) 	/* |x|>=2**52, must be -integer */
 		return one/vzero;
 	    t = sin_pi(x);
 	    if(t==zero) return one/vzero; /* -integer */
-	    nadj = __ieee754_log(pi/fabs(t*x));
+	    nadj = log(pi/fabs(t*x));
 	    if(t<zero) *signgamp = -1;
 	    x = -x;
 	}
 
     /* purge 1 and 2 */
 	if((((ix-0x3ff00000)|lx)==0)||(((ix-0x40000000)|lx)==0)) r = 0;
     /* for x < 2.0 */
 	else if(ix<0x40000000) {
 	    if(ix<=0x3feccccc) { 	/* lgamma(x) = lgamma(x+1)-log(x) */
-		r = -__ieee754_log(x);
+		r = -log(x);
 		if(ix>=0x3FE76944) {y = one-x; i= 0;}
 		else if(ix>=0x3FCDA661) {y= x-(tc-one); i=1;}
 	  	else {y = x; i=2;}
 	    } else {
 	  	r = zero;
 	        if(ix>=0x3FFBB4C3) {y=2.0-x;i=0;} /* [1.7316,2] */
 	        else if(ix>=0x3FF3B4C4) {y=x-tc;i=1;} /* [1.23,1.73] */
 		else {y=x-one;i=2;}
 	    }
 	    switch(i) {
 	      case 0:
 		z = y*y;
 		p1 = a0+z*(a2+z*(a4+z*(a6+z*(a8+z*a10))));
 		p2 = z*(a1+z*(a3+z*(a5+z*(a7+z*(a9+z*a11)))));
 		p  = y*p1+p2;
 		r  += p-y/2; break;
 	      case 1:
 		z = y*y;
 		w = z*y;
 		p1 = t0+w*(t3+w*(t6+w*(t9 +w*t12)));	/* parallel comp */
 		p2 = t1+w*(t4+w*(t7+w*(t10+w*t13)));
 		p3 = t2+w*(t5+w*(t8+w*(t11+w*t14)));
 		p  = z*p1-(tt-w*(p2+y*p3));
 		r += tf + p; break;
 	      case 2:
 		p1 = y*(u0+y*(u1+y*(u2+y*(u3+y*(u4+y*u5)))));
 		p2 = one+y*(v1+y*(v2+y*(v3+y*(v4+y*v5))));
 		r += p1/p2-y/2;
 	    }
 	}
     /* x < 8.0 */
 	else if(ix<0x40200000) {
 	    i = x;
 	    y = x-i;
 	    p = y*(s0+y*(s1+y*(s2+y*(s3+y*(s4+y*(s5+y*s6))))));
 	    q = one+y*(r1+y*(r2+y*(r3+y*(r4+y*(r5+y*r6)))));
 	    r = y/2+p/q;
 	    z = one;	/* lgamma(1+s) = log(s) + lgamma(s) */
 	    switch(i) {
 	    case 7: z *= (y+6);		/* FALLTHRU */
 	    case 6: z *= (y+5);		/* FALLTHRU */
 	    case 5: z *= (y+4);		/* FALLTHRU */
 	    case 4: z *= (y+3);		/* FALLTHRU */
 	    case 3: z *= (y+2);		/* FALLTHRU */
-		    r += __ieee754_log(z); break;
+		    r += log(z); break;
 	    }
     /* 8.0 <= x < 2**56 */
 	} else if (ix < 0x43700000) {
-	    t = __ieee754_log(x);
+	    t = log(x);
 	    z = one/x;
 	    y = z*z;
 	    w = w0+z*(w1+y*(w2+y*(w3+y*(w4+y*(w5+y*w6)))));
 	    r = (x-half)*(t-one)+w;
 	} else
     /* 2**56 <= x <= inf */
-	    r =  x*(__ieee754_log(x)-one);
+	    r =  x*(log(x)-one);
 	if(hx<0) r = nadj - r;
 	return r;
 }
 
 #if (LDBL_MANT_DIG == 53)
 __weak_reference(lgamma_r, lgammal_r);
 #endif
diff --git a/lib/msun/src/e_lgammaf.c b/lib/msun/src/e_lgammaf.c
index 1e2c55273e10..00a816c35c37 100644
--- a/lib/msun/src/e_lgammaf.c
+++ b/lib/msun/src/e_lgammaf.c
@@ -1,34 +1,34 @@
 /* e_lgammaf.c -- float version of e_lgamma.c.
  * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
  */
 
 /*
  * ====================================================
  * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
  *
  * Developed at SunPro, a Sun Microsystems, Inc. business.
  * Permission to use, copy, modify, and distribute this
  * software is freely granted, provided that this notice
  * is preserved.
  * ====================================================
  */
 
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
-/* __ieee754_lgammaf(x)
+/* lgammaf(x)
  * Return the logarithm of the Gamma function of x.
  *
- * Method: call __ieee754_lgammaf_r
+ * Method: call lgammaf_r
  */
 
 #include "math.h"
 #include "math_private.h"
 
 extern int signgam;
 
 float
-__ieee754_lgammaf(float x)
+lgammaf(float x)
 {
-	return __ieee754_lgammaf_r(x,&signgam);
+	return lgammaf_r(x,&signgam);
 }
diff --git a/lib/msun/src/e_lgammaf_r.c b/lib/msun/src/e_lgammaf_r.c
index 48346c336000..fdd23218e58d 100644
--- a/lib/msun/src/e_lgammaf_r.c
+++ b/lib/msun/src/e_lgammaf_r.c
@@ -1,215 +1,215 @@
 /* e_lgammaf_r.c -- float version of e_lgamma_r.c.
  * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
  * Conversion to float fixed By Steven G. Kargl.
  */
 
 /*
  * ====================================================
  * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
  *
  * Developed at SunPro, a Sun Microsystems, Inc. business.
  * Permission to use, copy, modify, and distribute this
  * software is freely granted, provided that this notice
  * is preserved.
  * ====================================================
  */
 
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
 #include "math.h"
 #include "math_private.h"
 
 static const volatile float vzero = 0;
 
 static const float
 zero=  0,
 half=  0.5,
 one =  1,
 pi  =  3.1415927410e+00, /* 0x40490fdb */
 /*
  * Domain y in [0x1p-27, 0.27], range ~[-3.4599e-10, 3.4590e-10]:
  * |(lgamma(2 - y) + 0.5 * y) / y - a(y)| < 2**-31.4
  */
 a0  =  7.72156641e-02, /* 0x3d9e233f */
 a1  =  3.22467119e-01, /* 0x3ea51a69 */
 a2  =  6.73484802e-02, /* 0x3d89ee00 */
 a3  =  2.06395667e-02, /* 0x3ca9144f */
 a4  =  6.98275631e-03, /* 0x3be4cf9b */
 a5  =  4.11768444e-03, /* 0x3b86eda4 */
 /*
  * Domain x in [tc-0.24, tc+0.28], range ~[-5.6577e-10, 5.5677e-10]:
  * |(lgamma(x) - tf) - t(x - tc)| < 2**-30.8.
  */
 tc  =  1.46163213e+00, /* 0x3fbb16c3 */
 tf  = -1.21486291e-01, /* 0xbdf8cdce */
 t0  = -2.94064460e-11, /* 0xae0154b7 */
 t1  = -2.35939837e-08, /* 0xb2caabb8 */
 t2  =  4.83836412e-01, /* 0x3ef7b968 */
 t3  = -1.47586212e-01, /* 0xbe1720d7 */
 t4  =  6.46013096e-02, /* 0x3d844db1 */
 t5  = -3.28450352e-02, /* 0xbd068884 */
 t6  =  1.86483748e-02, /* 0x3c98c47a */
 t7  = -9.89206228e-03, /* 0xbc221251 */
 /*
  * Domain y in [-0.1, 0.232], range ~[-8.4931e-10, 8.7794e-10]:
  * |(lgamma(1 + y) + 0.5 * y) / y - u(y) / v(y)| < 2**-31.2
  */
 u0  = -7.72156641e-02, /* 0xbd9e233f */
 u1  =  7.36789703e-01, /* 0x3f3c9e40 */
 u2  =  4.95649040e-01, /* 0x3efdc5b6 */
 v1  =  1.10958421e+00, /* 0x3f8e06db */
 v2  =  2.10598111e-01, /* 0x3e57a708 */
 v3  = -1.02995494e-02, /* 0xbc28bf71 */
 /*
  * Domain x in (2, 3], range ~[-5.5189e-11, 5.2317e-11]:
  * |(lgamma(y+2) - 0.5 * y) / y - s(y)/r(y)| < 2**-35.0
  * with y = x - 2.
  */
 s0 = -7.72156641e-02, /* 0xbd9e233f */
 s1 =  2.69987404e-01, /* 0x3e8a3bca */
 s2 =  1.42851010e-01, /* 0x3e124789 */
 s3 =  1.19389519e-02, /* 0x3c439b98 */
 r1 =  6.79650068e-01, /* 0x3f2dfd8c */
 r2 =  1.16058730e-01, /* 0x3dedb033 */
 r3 =  3.75673687e-03, /* 0x3b763396 */
 /*
  * Domain z in [8, 0x1p24], range ~[-1.2640e-09, 1.2640e-09]:
  * |lgamma(x) - (x - 0.5) * (log(x) - 1) - w(1/x)| < 2**-29.6.
  */
 w0 =  4.18938547e-01, /* 0x3ed67f1d */
 w1 =  8.33332464e-02, /* 0x3daaaa9f */
 w2 = -2.76129087e-03; /* 0xbb34f6c6 */
 
 static float
 sin_pif(float x)
 {
 	volatile float vz;
 	float y,z;
 	int n;
 
 	y = -x;
 
 	vz = y+0x1p23F;			/* depend on 0 <= y < 0x1p23 */
 	z = vz-0x1p23F;			/* rintf(y) for the above range */
 	if (z == y)
 	    return zero;
 
 	vz = y+0x1p21F;
 	GET_FLOAT_WORD(n,vz);		/* bits for rounded y (units 0.25) */
 	z = vz-0x1p21F;			/* y rounded to a multiple of 0.25 */
 	if (z > y) {
 	    z -= 0.25F;			/* adjust to round down */
 	    n--;
 	}
 	n &= 7;				/* octant of y mod 2 */
 	y = y - z + n * 0.25F;		/* y mod 2 */
 
 	switch (n) {
 	    case 0:   y =  __kernel_sindf(pi*y); break;
 	    case 1:
 	    case 2:   y =  __kernel_cosdf(pi*((float)0.5-y)); break;
 	    case 3:
 	    case 4:   y =  __kernel_sindf(pi*(one-y)); break;
 	    case 5:
 	    case 6:   y = -__kernel_cosdf(pi*(y-(float)1.5)); break;
 	    default:  y =  __kernel_sindf(pi*(y-(float)2.0)); break;
 	    }
 	return -y;
 }
 
 
 float
-__ieee754_lgammaf_r(float x, int *signgamp)
+lgammaf_r(float x, int *signgamp)
 {
 	float nadj,p,p1,p2,q,r,t,w,y,z;
 	int32_t hx;
 	int i,ix;
 
 	GET_FLOAT_WORD(hx,x);
 
     /* purge +-Inf and NaNs */
 	*signgamp = 1;
 	ix = hx&0x7fffffff;
 	if(ix>=0x7f800000) return x*x;
 
     /* purge +-0 and tiny arguments */
 	*signgamp = 1-2*((uint32_t)hx>>31);
 	if(ix<0x32000000) {		/* |x|<2**-27, return -log(|x|) */
 	    if(ix==0)
 	        return one/vzero;
-	    return -__ieee754_logf(fabsf(x));
+	    return -logf(fabsf(x));
 	}
 
     /* purge negative integers and start evaluation for other x < 0 */
 	if(hx<0) {
 	    *signgamp = 1;
 	    if(ix>=0x4b000000) 		/* |x|>=2**23, must be -integer */
 		return one/vzero;
 	    t = sin_pif(x);
 	    if(t==zero) return one/vzero; /* -integer */
-	    nadj = __ieee754_logf(pi/fabsf(t*x));
+	    nadj = logf(pi/fabsf(t*x));
 	    if(t<zero) *signgamp = -1;
 	    x = -x;
 	}
 
     /* purge 1 and 2 */
 	if (ix==0x3f800000||ix==0x40000000) r = 0;
     /* for x < 2.0 */
 	else if(ix<0x40000000) {
 	    if(ix<=0x3f666666) { 	/* lgamma(x) = lgamma(x+1)-log(x) */
-		r = -__ieee754_logf(x);
+		r = -logf(x);
 		if(ix>=0x3f3b4a20) {y = one-x; i= 0;}
 		else if(ix>=0x3e6d3308) {y= x-(tc-one); i=1;}
 	  	else {y = x; i=2;}
 	    } else {
 	  	r = zero;
 	        if(ix>=0x3fdda618) {y=2-x;i=0;} /* [1.7316,2] */
 	        else if(ix>=0x3F9da620) {y=x-tc;i=1;} /* [1.23,1.73] */
 		else {y=x-one;i=2;}
 	    }
 	    switch(i) {
 	      case 0:
 		z = y*y;
 		p1 = a0+z*(a2+z*a4);
 		p2 = z*(a1+z*(a3+z*a5));
 		p  = y*p1+p2;
 		r  += p-y/2; break;
 	      case 1:
 		p = t0+y*t1+y*y*(t2+y*(t3+y*(t4+y*(t5+y*(t6+y*t7)))));
 		r += tf + p; break;
 	      case 2:
 		p1 = y*(u0+y*(u1+y*u2));
 		p2 = one+y*(v1+y*(v2+y*v3));
 		r += p1/p2-y/2;
 	    }
 	}
     /* x < 8.0 */
 	else if(ix<0x41000000) {
 	    i = x;
 	    y = x-i;
 	    p = y*(s0+y*(s1+y*(s2+y*s3)));
 	    q = one+y*(r1+y*(r2+y*r3));
 	    r = y/2+p/q;
 	    z = one;	/* lgamma(1+s) = log(s) + lgamma(s) */
 	    switch(i) {
 	    case 7: z *= (y+6);		/* FALLTHRU */
 	    case 6: z *= (y+5);		/* FALLTHRU */
 	    case 5: z *= (y+4);		/* FALLTHRU */
 	    case 4: z *= (y+3);		/* FALLTHRU */
 	    case 3: z *= (y+2);		/* FALLTHRU */
-		    r += __ieee754_logf(z); break;
+		    r += logf(z); break;
 	    }
     /* 8.0 <= x < 2**27 */
 	} else if (ix < 0x4d000000) {
-	    t = __ieee754_logf(x);
+	    t = logf(x);
 	    z = one/x;
 	    y = z*z;
 	    w = w0+z*(w1+y*w2);
 	    r = (x-half)*(t-one)+w;
 	} else
     /* 2**27 <= x <= inf */
-	    r =  x*(__ieee754_logf(x)-one);
+	    r =  x*(logf(x)-one);
 	if(hx<0) r = nadj - r;
 	return r;
 }
diff --git a/lib/msun/src/e_log.c b/lib/msun/src/e_log.c
index 68bc1070ba37..03ce82061375 100644
--- a/lib/msun/src/e_log.c
+++ b/lib/msun/src/e_log.c
@@ -1,147 +1,147 @@
 
 /* @(#)e_log.c 1.3 95/01/18 */
 /*
  * ====================================================
  * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
  *
  * Developed at SunSoft, a Sun Microsystems, Inc. business.
  * Permission to use, copy, modify, and distribute this
  * software is freely granted, provided that this notice 
  * is preserved.
  * ====================================================
  */
 
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
-/* __ieee754_log(x)
+/* log(x)
  * Return the logrithm of x
  *
  * Method :                  
  *   1. Argument Reduction: find k and f such that 
  *			x = 2^k * (1+f), 
  *	   where  sqrt(2)/2 < 1+f < sqrt(2) .
  *
  *   2. Approximation of log(1+f).
  *	Let s = f/(2+f) ; based on log(1+f) = log(1+s) - log(1-s)
  *		 = 2s + 2/3 s**3 + 2/5 s**5 + .....,
  *	     	 = 2s + s*R
  *      We use a special Reme algorithm on [0,0.1716] to generate 
  * 	a polynomial of degree 14 to approximate R The maximum error 
  *	of this polynomial approximation is bounded by 2**-58.45. In
  *	other words,
  *		        2      4      6      8      10      12      14
  *	    R(z) ~ Lg1*s +Lg2*s +Lg3*s +Lg4*s +Lg5*s  +Lg6*s  +Lg7*s
  *  	(the values of Lg1 to Lg7 are listed in the program)
  *	and
  *	    |      2          14          |     -58.45
  *	    | Lg1*s +...+Lg7*s    -  R(z) | <= 2 
  *	    |                             |
  *	Note that 2s = f - s*f = f - hfsq + s*hfsq, where hfsq = f*f/2.
  *	In order to guarantee error in log below 1ulp, we compute log
  *	by
  *		log(1+f) = f - s*(f - R)	(if f is not too large)
  *		log(1+f) = f - (hfsq - s*(hfsq+R)).	(better accuracy)
  *	
  *	3. Finally,  log(x) = k*ln2 + log(1+f).  
  *			    = k*ln2_hi+(f-(hfsq-(s*(hfsq+R)+k*ln2_lo)))
  *	   Here ln2 is split into two floating point number: 
  *			ln2_hi + ln2_lo,
  *	   where n*ln2_hi is always exact for |n| < 2000.
  *
  * Special cases:
  *	log(x) is NaN with signal if x < 0 (including -INF) ; 
  *	log(+INF) is +INF; log(0) is -INF with signal;
  *	log(NaN) is that NaN with no signal.
  *
  * Accuracy:
  *	according to an error analysis, the error is always less than
  *	1 ulp (unit in the last place).
  *
  * Constants:
  * The hexadecimal values are the intended ones for the following 
  * constants. The decimal values may be used, provided that the 
  * compiler will convert from decimal to binary accurately enough 
  * to produce the hexadecimal values shown.
  */
 
 #include <float.h>
 
 #include "math.h"
 #include "math_private.h"
 
 static const double
 ln2_hi  =  6.93147180369123816490e-01,	/* 3fe62e42 fee00000 */
 ln2_lo  =  1.90821492927058770002e-10,	/* 3dea39ef 35793c76 */
 two54   =  1.80143985094819840000e+16,  /* 43500000 00000000 */
 Lg1 = 6.666666666666735130e-01,  /* 3FE55555 55555593 */
 Lg2 = 3.999999999940941908e-01,  /* 3FD99999 9997FA04 */
 Lg3 = 2.857142874366239149e-01,  /* 3FD24924 94229359 */
 Lg4 = 2.222219843214978396e-01,  /* 3FCC71C5 1D8E78AF */
 Lg5 = 1.818357216161805012e-01,  /* 3FC74664 96CB03DE */
 Lg6 = 1.531383769920937332e-01,  /* 3FC39A09 D078C69F */
 Lg7 = 1.479819860511658591e-01;  /* 3FC2F112 DF3E5244 */
 
 static const double zero   =  0.0;
 static volatile double vzero = 0.0;
 
 double
-__ieee754_log(double x)
+log(double x)
 {
 	double hfsq,f,s,z,R,w,t1,t2,dk;
 	int32_t k,hx,i,j;
 	u_int32_t lx;
 
 	EXTRACT_WORDS(hx,lx,x);
 
 	k=0;
 	if (hx < 0x00100000) {			/* x < 2**-1022  */
 	    if (((hx&0x7fffffff)|lx)==0) 
 		return -two54/vzero;		/* log(+-0)=-inf */
 	    if (hx<0) return (x-x)/zero;	/* log(-#) = NaN */
 	    k -= 54; x *= two54; /* subnormal number, scale up x */
 	    GET_HIGH_WORD(hx,x);
 	} 
 	if (hx >= 0x7ff00000) return x+x;
 	k += (hx>>20)-1023;
 	hx &= 0x000fffff;
 	i = (hx+0x95f64)&0x100000;
 	SET_HIGH_WORD(x,hx|(i^0x3ff00000));	/* normalize x or x/2 */
 	k += (i>>20);
 	f = x-1.0;
 	if((0x000fffff&(2+hx))<3) {	/* -2**-20 <= f < 2**-20 */
 	    if(f==zero) {
 		if(k==0) {
 		    return zero;
 		} else {
 		    dk=(double)k;
 		    return dk*ln2_hi+dk*ln2_lo;
 		}
 	    }
 	    R = f*f*(0.5-0.33333333333333333*f);
 	    if(k==0) return f-R; else {dk=(double)k;
 	    	     return dk*ln2_hi-((R-dk*ln2_lo)-f);}
 	}
  	s = f/(2.0+f); 
 	dk = (double)k;
 	z = s*s;
 	i = hx-0x6147a;
 	w = z*z;
 	j = 0x6b851-hx;
 	t1= w*(Lg2+w*(Lg4+w*Lg6)); 
 	t2= z*(Lg1+w*(Lg3+w*(Lg5+w*Lg7))); 
 	i |= j;
 	R = t2+t1;
 	if(i>0) {
 	    hfsq=0.5*f*f;
 	    if(k==0) return f-(hfsq-s*(hfsq+R)); else
 		     return dk*ln2_hi-((hfsq-(s*(hfsq+R)+dk*ln2_lo))-f);
 	} else {
 	    if(k==0) return f-s*(f-R); else
 		     return dk*ln2_hi-((s*(f-R)-dk*ln2_lo)-f);
 	}
 }
 
 #if (LDBL_MANT_DIG == 53)
 __weak_reference(log, logl);
 #endif
diff --git a/lib/msun/src/e_log10.c b/lib/msun/src/e_log10.c
index 3c89ed2d86cb..595c23808941 100644
--- a/lib/msun/src/e_log10.c
+++ b/lib/msun/src/e_log10.c
@@ -1,94 +1,94 @@
 
 /* @(#)e_log10.c 1.3 95/01/18 */
 /*
  * ====================================================
  * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
  *
  * Developed at SunSoft, a Sun Microsystems, Inc. business.
  * Permission to use, copy, modify, and distribute this
  * software is freely granted, provided that this notice 
  * is preserved.
  * ====================================================
  */
 
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
 /*
  * Return the base 10 logarithm of x.  See e_log.c and k_log.h for most
  * comments.
  *
  *    log10(x) = (f - 0.5*f*f + k_log1p(f)) / ln10 + k * log10(2)
  * in not-quite-routine extra precision.
  */
 
 #include <float.h>
 
 #include "math.h"
 #include "math_private.h"
 #include "k_log.h"
 
 static const double
 two54      =  1.80143985094819840000e+16, /* 0x43500000, 0x00000000 */
 ivln10hi   =  4.34294481878168880939e-01, /* 0x3fdbcb7b, 0x15200000 */
 ivln10lo   =  2.50829467116452752298e-11, /* 0x3dbb9438, 0xca9aadd5 */
 log10_2hi  =  3.01029995663611771306e-01, /* 0x3FD34413, 0x509F6000 */
 log10_2lo  =  3.69423907715893078616e-13; /* 0x3D59FEF3, 0x11F12B36 */
 
 static const double zero   =  0.0;
 static volatile double vzero = 0.0;
 
 double
-__ieee754_log10(double x)
+log10(double x)
 {
 	double f,hfsq,hi,lo,r,val_hi,val_lo,w,y,y2;
 	int32_t i,k,hx;
 	u_int32_t lx;
 
 	EXTRACT_WORDS(hx,lx,x);
 
 	k=0;
 	if (hx < 0x00100000) {			/* x < 2**-1022  */
 	    if (((hx&0x7fffffff)|lx)==0)
 		return -two54/vzero;		/* log(+-0)=-inf */
 	    if (hx<0) return (x-x)/zero;	/* log(-#) = NaN */
 	    k -= 54; x *= two54; /* subnormal number, scale up x */
 	    GET_HIGH_WORD(hx,x);
 	}
 	if (hx >= 0x7ff00000) return x+x;
 	if (hx == 0x3ff00000 && lx == 0)
 	    return zero;			/* log(1) = +0 */
 	k += (hx>>20)-1023;
 	hx &= 0x000fffff;
 	i = (hx+0x95f64)&0x100000;
 	SET_HIGH_WORD(x,hx|(i^0x3ff00000));	/* normalize x or x/2 */
 	k += (i>>20);
 	y = (double)k;
 	f = x - 1.0;
 	hfsq = 0.5*f*f;
 	r = k_log1p(f);
 
 	/* See e_log2.c for most details. */
 	hi = f - hfsq;
 	SET_LOW_WORD(hi,0);
 	lo = (f - hi) - hfsq + r;
 	val_hi = hi*ivln10hi;
 	y2 = y*log10_2hi;
 	val_lo = y*log10_2lo + (lo+hi)*ivln10lo + lo*ivln10hi;
 
 	/*
 	 * Extra precision in for adding y*log10_2hi is not strictly needed
 	 * since there is no very large cancellation near x = sqrt(2) or
 	 * x = 1/sqrt(2), but we do it anyway since it costs little on CPUs
 	 * with some parallelism and it reduces the error for many args.
 	 */
 	w = y2 + val_hi;
 	val_lo += (y2 - w) + val_hi;
 	val_hi = w;
 
 	return val_lo + val_hi;
 }
 
 #if (LDBL_MANT_DIG == 53)
 __weak_reference(log10, log10l);
 #endif
diff --git a/lib/msun/src/e_log10f.c b/lib/msun/src/e_log10f.c
index 9856df2e7b6a..d0c3a53c88ea 100644
--- a/lib/msun/src/e_log10f.c
+++ b/lib/msun/src/e_log10f.c
@@ -1,72 +1,72 @@
 /*
  * ====================================================
  * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
  *
  * Developed at SunPro, a Sun Microsystems, Inc. business.
  * Permission to use, copy, modify, and distribute this
  * software is freely granted, provided that this notice
  * is preserved.
  * ====================================================
  */
 
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
 /*
  * Float version of e_log10.c.  See the latter for most comments.
  */
 
 #include "math.h"
 #include "math_private.h"
 #include "k_logf.h"
 
 static const float
 two25      =  3.3554432000e+07, /* 0x4c000000 */
 ivln10hi   =  4.3432617188e-01, /* 0x3ede6000 */
 ivln10lo   = -3.1689971365e-05, /* 0xb804ead9 */
 log10_2hi  =  3.0102920532e-01, /* 0x3e9a2080 */
 log10_2lo  =  7.9034151668e-07; /* 0x355427db */
 
 static const float zero   =  0.0;
 static volatile float vzero = 0.0;
 
 float
-__ieee754_log10f(float x)
+log10f(float x)
 {
 	float f,hfsq,hi,lo,r,y;
 	int32_t i,k,hx;
 
 	GET_FLOAT_WORD(hx,x);
 
 	k=0;
 	if (hx < 0x00800000) {			/* x < 2**-126  */
 	    if ((hx&0x7fffffff)==0)
 		return -two25/vzero;		/* log(+-0)=-inf */
 	    if (hx<0) return (x-x)/zero;	/* log(-#) = NaN */
 	    k -= 25; x *= two25; /* subnormal number, scale up x */
 	    GET_FLOAT_WORD(hx,x);
 	}
 	if (hx >= 0x7f800000) return x+x;
 	if (hx == 0x3f800000)
 	    return zero;			/* log(1) = +0 */
 	k += (hx>>23)-127;
 	hx &= 0x007fffff;
 	i = (hx+(0x4afb0d))&0x800000;
 	SET_FLOAT_WORD(x,hx|(i^0x3f800000));	/* normalize x or x/2 */
 	k += (i>>23);
 	y = (float)k;
 	f = x - (float)1.0;
 	hfsq = (float)0.5*f*f;
 	r = k_log1pf(f);
 
 	/* See e_log2f.c and e_log2.c for details. */
 	if (sizeof(float_t) > sizeof(float))
 		return (r - hfsq + f) * ((float_t)ivln10lo + ivln10hi) +
 		    y * ((float_t)log10_2lo + log10_2hi);
 	hi = f - hfsq;
 	GET_FLOAT_WORD(hx,hi);
 	SET_FLOAT_WORD(hi,hx&0xfffff000);
 	lo = (f - hi) - hfsq + r;
 	return y*log10_2lo + (lo+hi)*ivln10lo + lo*ivln10hi + hi*ivln10hi +
 	    y*log10_2hi;
 }
diff --git a/lib/msun/src/e_log2.c b/lib/msun/src/e_log2.c
index 4766cdb49583..10b1c00d50de 100644
--- a/lib/msun/src/e_log2.c
+++ b/lib/msun/src/e_log2.c
@@ -1,117 +1,117 @@
 
 /* @(#)e_log10.c 1.3 95/01/18 */
 /*
  * ====================================================
  * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
  *
  * Developed at SunSoft, a Sun Microsystems, Inc. business.
  * Permission to use, copy, modify, and distribute this
  * software is freely granted, provided that this notice 
  * is preserved.
  * ====================================================
  */
 
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
 /*
  * Return the base 2 logarithm of x.  See e_log.c and k_log.h for most
  * comments.
  *
  * This reduces x to {k, 1+f} exactly as in e_log.c, then calls the kernel,
  * then does the combining and scaling steps
  *    log2(x) = (f - 0.5*f*f + k_log1p(f)) / ln2 + k
  * in not-quite-routine extra precision.
  */
 
 #include <float.h>
 
 #include "math.h"
 #include "math_private.h"
 #include "k_log.h"
 
 static const double
 two54      =  1.80143985094819840000e+16, /* 0x43500000, 0x00000000 */
 ivln2hi    =  1.44269504072144627571e+00, /* 0x3ff71547, 0x65200000 */
 ivln2lo    =  1.67517131648865118353e-10; /* 0x3de705fc, 0x2eefa200 */
 
 static const double zero   =  0.0;
 static volatile double vzero = 0.0;
 
 double
-__ieee754_log2(double x)
+log2(double x)
 {
 	double f,hfsq,hi,lo,r,val_hi,val_lo,w,y;
 	int32_t i,k,hx;
 	u_int32_t lx;
 
 	EXTRACT_WORDS(hx,lx,x);
 
 	k=0;
 	if (hx < 0x00100000) {			/* x < 2**-1022  */
 	    if (((hx&0x7fffffff)|lx)==0)
 		return -two54/vzero;		/* log(+-0)=-inf */
 	    if (hx<0) return (x-x)/zero;	/* log(-#) = NaN */
 	    k -= 54; x *= two54; /* subnormal number, scale up x */
 	    GET_HIGH_WORD(hx,x);
 	}
 	if (hx >= 0x7ff00000) return x+x;
 	if (hx == 0x3ff00000 && lx == 0)
 	    return zero;			/* log(1) = +0 */
 	k += (hx>>20)-1023;
 	hx &= 0x000fffff;
 	i = (hx+0x95f64)&0x100000;
 	SET_HIGH_WORD(x,hx|(i^0x3ff00000));	/* normalize x or x/2 */
 	k += (i>>20);
 	y = (double)k;
 	f = x - 1.0;
 	hfsq = 0.5*f*f;
 	r = k_log1p(f);
 
 	/*
 	 * f-hfsq must (for args near 1) be evaluated in extra precision
 	 * to avoid a large cancellation when x is near sqrt(2) or 1/sqrt(2).
 	 * This is fairly efficient since f-hfsq only depends on f, so can
 	 * be evaluated in parallel with R.  Not combining hfsq with R also
 	 * keeps R small (though not as small as a true `lo' term would be),
 	 * so that extra precision is not needed for terms involving R.
 	 *
 	 * Compiler bugs involving extra precision used to break Dekker's
 	 * theorem for spitting f-hfsq as hi+lo, unless double_t was used
 	 * or the multi-precision calculations were avoided when double_t
 	 * has extra precision.  These problems are now automatically
 	 * avoided as a side effect of the optimization of combining the
 	 * Dekker splitting step with the clear-low-bits step.
 	 *
 	 * y must (for args near sqrt(2) and 1/sqrt(2)) be added in extra
 	 * precision to avoid a very large cancellation when x is very near
 	 * these values.  Unlike the above cancellations, this problem is
 	 * specific to base 2.  It is strange that adding +-1 is so much
 	 * harder than adding +-ln2 or +-log10_2.
 	 *
 	 * This uses Dekker's theorem to normalize y+val_hi, so the
 	 * compiler bugs are back in some configurations, sigh.  And I
 	 * don't want to used double_t to avoid them, since that gives a
 	 * pessimization and the support for avoiding the pessimization
 	 * is not yet available.
 	 *
 	 * The multi-precision calculations for the multiplications are
 	 * routine.
 	 */
 	hi = f - hfsq;
 	SET_LOW_WORD(hi,0);
 	lo = (f - hi) - hfsq + r;
 	val_hi = hi*ivln2hi;
 	val_lo = (lo+hi)*ivln2lo + lo*ivln2hi;
 
 	/* spadd(val_hi, val_lo, y), except for not using double_t: */
 	w = y + val_hi;
 	val_lo += (y - w) + val_hi;
 	val_hi = w;
 
 	return val_lo + val_hi;
 }
 
 #if (LDBL_MANT_DIG == 53)
 __weak_reference(log2, log2l);
 #endif
diff --git a/lib/msun/src/e_log2f.c b/lib/msun/src/e_log2f.c
index 1794484e64ec..956f33a344a0 100644
--- a/lib/msun/src/e_log2f.c
+++ b/lib/msun/src/e_log2f.c
@@ -1,82 +1,82 @@
 /*
  * ====================================================
  * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
  *
  * Developed at SunPro, a Sun Microsystems, Inc. business.
  * Permission to use, copy, modify, and distribute this
  * software is freely granted, provided that this notice
  * is preserved.
  * ====================================================
  */
 
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
 /*
  * Float version of e_log2.c.  See the latter for most comments.
  */
 
 #include "math.h"
 #include "math_private.h"
 #include "k_logf.h"
 
 static const float
 two25      =  3.3554432000e+07, /* 0x4c000000 */
 ivln2hi    =  1.4428710938e+00, /* 0x3fb8b000 */
 ivln2lo    = -1.7605285393e-04; /* 0xb9389ad4 */
 
 static const float zero   =  0.0;
 static volatile float vzero = 0.0;
 
 float
-__ieee754_log2f(float x)
+log2f(float x)
 {
 	float f,hfsq,hi,lo,r,y;
 	int32_t i,k,hx;
 
 	GET_FLOAT_WORD(hx,x);
 
 	k=0;
 	if (hx < 0x00800000) {			/* x < 2**-126  */
 	    if ((hx&0x7fffffff)==0)
 		return -two25/vzero;		/* log(+-0)=-inf */
 	    if (hx<0) return (x-x)/zero;	/* log(-#) = NaN */
 	    k -= 25; x *= two25; /* subnormal number, scale up x */
 	    GET_FLOAT_WORD(hx,x);
 	}
 	if (hx >= 0x7f800000) return x+x;
 	if (hx == 0x3f800000)
 	    return zero;			/* log(1) = +0 */
 	k += (hx>>23)-127;
 	hx &= 0x007fffff;
 	i = (hx+(0x4afb0d))&0x800000;
 	SET_FLOAT_WORD(x,hx|(i^0x3f800000));	/* normalize x or x/2 */
 	k += (i>>23);
 	y = (float)k;
 	f = x - (float)1.0;
 	hfsq = (float)0.5*f*f;
 	r = k_log1pf(f);
 
 	/*
 	 * We no longer need to avoid falling into the multi-precision
 	 * calculations due to compiler bugs breaking Dekker's theorem.
 	 * Keep avoiding this as an optimization.  See e_log2.c for more
 	 * details (some details are here only because the optimization
 	 * is not yet available in double precision).
 	 *
 	 * Another compiler bug turned up.  With gcc on i386,
 	 * (ivln2lo + ivln2hi) would be evaluated in float precision
 	 * despite runtime evaluations using double precision.  So we
 	 * must cast one of its terms to float_t.  This makes the whole
 	 * expression have type float_t, so return is forced to waste
 	 * time clobbering its extra precision.
 	 */
 	if (sizeof(float_t) > sizeof(float))
 		return (r - hfsq + f) * ((float_t)ivln2lo + ivln2hi) + y;
 
 	hi = f - hfsq;
 	GET_FLOAT_WORD(hx,hi);
 	SET_FLOAT_WORD(hi,hx&0xfffff000);
 	lo = (f - hi) - hfsq + r;
 	return (lo+hi)*ivln2lo + lo*ivln2hi + hi*ivln2hi + y;
 }
diff --git a/lib/msun/src/e_logf.c b/lib/msun/src/e_logf.c
index ec3985fcbeda..68a4d5d88342 100644
--- a/lib/msun/src/e_logf.c
+++ b/lib/msun/src/e_logf.c
@@ -1,89 +1,89 @@
 /* e_logf.c -- float version of e_log.c.
  * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
  */
 
 /*
  * ====================================================
  * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
  *
  * Developed at SunPro, a Sun Microsystems, Inc. business.
  * Permission to use, copy, modify, and distribute this
  * software is freely granted, provided that this notice
  * is preserved.
  * ====================================================
  */
 
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
 #include "math.h"
 #include "math_private.h"
 
 static const float
 ln2_hi =   6.9313812256e-01,	/* 0x3f317180 */
 ln2_lo =   9.0580006145e-06,	/* 0x3717f7d1 */
 two25 =    3.355443200e+07,	/* 0x4c000000 */
 /* |(log(1+s)-log(1-s))/s - Lg(s)| < 2**-34.24 (~[-4.95e-11, 4.97e-11]). */
 Lg1 =      0xaaaaaa.0p-24,	/* 0.66666662693 */
 Lg2 =      0xccce13.0p-25,	/* 0.40000972152 */
 Lg3 =      0x91e9ee.0p-25,	/* 0.28498786688 */
 Lg4 =      0xf89e26.0p-26;	/* 0.24279078841 */
 
 static const float zero   =  0.0;
 static volatile float vzero = 0.0;
 
 float
-__ieee754_logf(float x)
+logf(float x)
 {
 	float hfsq,f,s,z,R,w,t1,t2,dk;
 	int32_t k,ix,i,j;
 
 	GET_FLOAT_WORD(ix,x);
 
 	k=0;
 	if (ix < 0x00800000) {			/* x < 2**-126  */
 	    if ((ix&0x7fffffff)==0)
 		return -two25/vzero;		/* log(+-0)=-inf */
 	    if (ix<0) return (x-x)/zero;	/* log(-#) = NaN */
 	    k -= 25; x *= two25; /* subnormal number, scale up x */
 	    GET_FLOAT_WORD(ix,x);
 	}
 	if (ix >= 0x7f800000) return x+x;
 	k += (ix>>23)-127;
 	ix &= 0x007fffff;
 	i = (ix+(0x95f64<<3))&0x800000;
 	SET_FLOAT_WORD(x,ix|(i^0x3f800000));	/* normalize x or x/2 */
 	k += (i>>23);
 	f = x-(float)1.0;
 	if((0x007fffff&(0x8000+ix))<0xc000) {	/* -2**-9 <= f < 2**-9 */
 	    if(f==zero) {
 		if(k==0) {
 		    return zero;
 		} else {
 		    dk=(float)k;
 		    return dk*ln2_hi+dk*ln2_lo;
 		}
 	    }
 	    R = f*f*((float)0.5-(float)0.33333333333333333*f);
 	    if(k==0) return f-R; else {dk=(float)k;
 	    	     return dk*ln2_hi-((R-dk*ln2_lo)-f);}
 	}
  	s = f/((float)2.0+f);
 	dk = (float)k;
 	z = s*s;
 	i = ix-(0x6147a<<3);
 	w = z*z;
 	j = (0x6b851<<3)-ix;
 	t1= w*(Lg2+w*Lg4);
 	t2= z*(Lg1+w*Lg3);
 	i |= j;
 	R = t2+t1;
 	if(i>0) {
 	    hfsq=(float)0.5*f*f;
 	    if(k==0) return f-(hfsq-s*(hfsq+R)); else
 		     return dk*ln2_hi-((hfsq-(s*(hfsq+R)+dk*ln2_lo))-f);
 	} else {
 	    if(k==0) return f-s*(f-R); else
 		     return dk*ln2_hi-((s*(f-R)-dk*ln2_lo)-f);
 	}
 }
diff --git a/lib/msun/src/e_pow.c b/lib/msun/src/e_pow.c
index 69ddb7ffcb48..86cce8f15a21 100644
--- a/lib/msun/src/e_pow.c
+++ b/lib/msun/src/e_pow.c
@@ -1,314 +1,314 @@
 /* @(#)e_pow.c 1.5 04/04/22 SMI */
 /*
  * ====================================================
  * Copyright (C) 2004 by Sun Microsystems, Inc. All rights reserved.
  *
  * Permission to use, copy, modify, and distribute this
  * software is freely granted, provided that this notice
  * is preserved.
  * ====================================================
  */
 
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
-/* __ieee754_pow(x,y) return x**y
+/* pow(x,y) return x**y
  *
  *		      n
  * Method:  Let x =  2   * (1+f)
  *	1. Compute and return log2(x) in two pieces:
  *		log2(x) = w1 + w2,
  *	   where w1 has 53-24 = 29 bit trailing zeros.
  *	2. Perform y*log2(x) = n+y' by simulating multi-precision
  *	   arithmetic, where |y'|<=0.5.
  *	3. Return x**y = 2**n*exp(y'*log2)
  *
  * Special cases:
  *	1.  (anything) ** 0  is 1
  *	2.  (anything) ** 1  is itself
  *	3.  (anything) ** NAN is NAN except 1 ** NAN = 1
  *	4.  NAN ** (anything except 0) is NAN
  *	5.  +-(|x| > 1) **  +INF is +INF
  *	6.  +-(|x| > 1) **  -INF is +0
  *	7.  +-(|x| < 1) **  +INF is +0
  *	8.  +-(|x| < 1) **  -INF is +INF
  *	9.  +-1         ** +-INF is 1
  *	10. +0 ** (+anything except 0, NAN)               is +0
  *	11. -0 ** (+anything except 0, NAN, odd integer)  is +0
  *	12. +0 ** (-anything except 0, NAN)               is +INF
  *	13. -0 ** (-anything except 0, NAN, odd integer)  is +INF
  *	14. -0 ** (odd integer) = -( +0 ** (odd integer) )
  *	15. +INF ** (+anything except 0,NAN) is +INF
  *	16. +INF ** (-anything except 0,NAN) is +0
  *	17. -INF ** (anything)  = -0 ** (-anything)
  *	18. (-anything) ** (integer) is (-1)**(integer)*(+anything**integer)
  *	19. (-anything except 0 and inf) ** (non-integer) is NAN
  *
  * Accuracy:
  *	pow(x,y) returns x**y nearly rounded. In particular
  *			pow(integer,integer)
  *	always returns the correct integer provided it is
  *	representable.
  *
  * Constants :
  * The hexadecimal values are the intended ones for the following
  * constants. The decimal values may be used, provided that the
  * compiler will convert from decimal to binary accurately enough
  * to produce the hexadecimal values shown.
  */
 
 #include <float.h>
 #include "math.h"
 #include "math_private.h"
 
 static const double
 bp[] = {1.0, 1.5,},
 dp_h[] = { 0.0, 5.84962487220764160156e-01,}, /* 0x3FE2B803, 0x40000000 */
 dp_l[] = { 0.0, 1.35003920212974897128e-08,}, /* 0x3E4CFDEB, 0x43CFD006 */
 zero    =  0.0,
 half    =  0.5,
 qrtr    =  0.25,
 thrd    =  3.3333333333333331e-01, /* 0x3fd55555, 0x55555555 */
 one	=  1.0,
 two	=  2.0,
 two53	=  9007199254740992.0,	/* 0x43400000, 0x00000000 */
 huge	=  1.0e300,
 tiny    =  1.0e-300,
 	/* poly coefs for (3/2)*(log(x)-2s-2/3*s**3 */
 L1  =  5.99999999999994648725e-01, /* 0x3FE33333, 0x33333303 */
 L2  =  4.28571428578550184252e-01, /* 0x3FDB6DB6, 0xDB6FABFF */
 L3  =  3.33333329818377432918e-01, /* 0x3FD55555, 0x518F264D */
 L4  =  2.72728123808534006489e-01, /* 0x3FD17460, 0xA91D4101 */
 L5  =  2.30660745775561754067e-01, /* 0x3FCD864A, 0x93C9DB65 */
 L6  =  2.06975017800338417784e-01, /* 0x3FCA7E28, 0x4A454EEF */
 P1   =  1.66666666666666019037e-01, /* 0x3FC55555, 0x5555553E */
 P2   = -2.77777777770155933842e-03, /* 0xBF66C16C, 0x16BEBD93 */
 P3   =  6.61375632143793436117e-05, /* 0x3F11566A, 0xAF25DE2C */
 P4   = -1.65339022054652515390e-06, /* 0xBEBBBD41, 0xC5D26BF1 */
 P5   =  4.13813679705723846039e-08, /* 0x3E663769, 0x72BEA4D0 */
 lg2  =  6.93147180559945286227e-01, /* 0x3FE62E42, 0xFEFA39EF */
 lg2_h  =  6.93147182464599609375e-01, /* 0x3FE62E43, 0x00000000 */
 lg2_l  = -1.90465429995776804525e-09, /* 0xBE205C61, 0x0CA86C39 */
 ovt =  8.0085662595372944372e-0017, /* -(1024-log2(ovfl+.5ulp)) */
 cp    =  9.61796693925975554329e-01, /* 0x3FEEC709, 0xDC3A03FD =2/(3ln2) */
 cp_h  =  9.61796700954437255859e-01, /* 0x3FEEC709, 0xE0000000 =(float)cp */
 cp_l  = -7.02846165095275826516e-09, /* 0xBE3E2FE0, 0x145B01F5 =tail of cp_h*/
 ivln2    =  1.44269504088896338700e+00, /* 0x3FF71547, 0x652B82FE =1/ln2 */
 ivln2_h  =  1.44269502162933349609e+00, /* 0x3FF71547, 0x60000000 =24b 1/ln2*/
 ivln2_l  =  1.92596299112661746887e-08; /* 0x3E54AE0B, 0xF85DDF44 =1/ln2 tail*/
 
 double
-__ieee754_pow(double x, double y)
+pow(double x, double y)
 {
 	double z,ax,z_h,z_l,p_h,p_l;
 	double y1,t1,t2,r,s,t,u,v,w;
 	int32_t i,j,k,yisint,n;
 	int32_t hx,hy,ix,iy;
 	u_int32_t lx,ly;
 
 	EXTRACT_WORDS(hx,lx,x);
 	EXTRACT_WORDS(hy,ly,y);
 	ix = hx&0x7fffffff;  iy = hy&0x7fffffff;
 
     /* y==zero: x**0 = 1 */
 	if((iy|ly)==0) return one;
 
     /* x==1: 1**y = 1, even if y is NaN */
 	if (hx==0x3ff00000 && lx == 0) return one;
 
     /* y!=zero: result is NaN if either arg is NaN */
 	if(ix > 0x7ff00000 || ((ix==0x7ff00000)&&(lx!=0)) ||
 	   iy > 0x7ff00000 || ((iy==0x7ff00000)&&(ly!=0)))
 	    return nan_mix(x, y);
 
     /* determine if y is an odd int when x < 0
      * yisint = 0	... y is not an integer
      * yisint = 1	... y is an odd int
      * yisint = 2	... y is an even int
      */
 	yisint  = 0;
 	if(hx<0) {
 	    if(iy>=0x43400000) yisint = 2; /* even integer y */
 	    else if(iy>=0x3ff00000) {
 		k = (iy>>20)-0x3ff;	   /* exponent */
 		if(k>20) {
 		    j = ly>>(52-k);
 		    if((j<<(52-k))==ly) yisint = 2-(j&1);
 		} else if(ly==0) {
 		    j = iy>>(20-k);
 		    if((j<<(20-k))==iy) yisint = 2-(j&1);
 		}
 	    }
 	}
 
     /* special value of y */
 	if(ly==0) {
 	    if (iy==0x7ff00000) {	/* y is +-inf */
 	        if(((ix-0x3ff00000)|lx)==0)
 		    return  one;	/* (-1)**+-inf is 1 */
 	        else if (ix >= 0x3ff00000)/* (|x|>1)**+-inf = inf,0 */
 		    return (hy>=0)? y: zero;
 	        else			/* (|x|<1)**-,+inf = inf,0 */
 		    return (hy<0)?-y: zero;
 	    }
 	    if(iy==0x3ff00000) {	/* y is  +-1 */
 		if(hy<0) return one/x; else return x;
 	    }
 	    if(hy==0x40000000) return x*x; /* y is  2 */
 	    if(hy==0x3fe00000) {	/* y is  0.5 */
 		if(hx>=0)	/* x >= +0 */
 		return sqrt(x);
 	    }
 	}
 
 	ax   = fabs(x);
     /* special value of x */
 	if(lx==0) {
 	    if(ix==0x7ff00000||ix==0||ix==0x3ff00000){
 		z = ax;			/*x is +-0,+-inf,+-1*/
 		if(hy<0) z = one/z;	/* z = (1/|x|) */
 		if(hx<0) {
 		    if(((ix-0x3ff00000)|yisint)==0) {
 			z = (z-z)/(z-z); /* (-1)**non-int is NaN */
 		    } else if(yisint==1)
 			z = -z;		/* (x<0)**odd = -(|x|**odd) */
 		}
 		return z;
 	    }
 	}
 
     /* CYGNUS LOCAL + fdlibm-5.3 fix: This used to be
 	n = (hx>>31)+1;
        but ANSI C says a right shift of a signed negative quantity is
        implementation defined.  */
 	n = ((u_int32_t)hx>>31)-1;
 
     /* (x<0)**(non-int) is NaN */
 	if((n|yisint)==0) return (x-x)/(x-x);
 
 	s = one; /* s (sign of result -ve**odd) = -1 else = 1 */
 	if((n|(yisint-1))==0) s = -one;/* (-ve)**(odd int) */
 
     /* |y| is huge */
 	if(iy>0x41e00000) { /* if |y| > 2**31 */
 	    if(iy>0x43f00000){	/* if |y| > 2**64, must o/uflow */
 		if(ix<=0x3fefffff) return (hy<0)? huge*huge:tiny*tiny;
 		if(ix>=0x3ff00000) return (hy>0)? huge*huge:tiny*tiny;
 	    }
 	/* over/underflow if x is not close to one */
 	    if(ix<0x3fefffff) return (hy<0)? s*huge*huge:s*tiny*tiny;
 	    if(ix>0x3ff00000) return (hy>0)? s*huge*huge:s*tiny*tiny;
 	/* now |1-x| is tiny <= 2**-20, suffice to compute
 	   log(x) by x-x^2/2+x^3/3-x^4/4 */
 	    t = ax-one;		/* t has 20 trailing zeros */
 	    w = (t*t)*(half-t*(thrd-t*qrtr));
 	    u = ivln2_h*t;	/* ivln2_h has 21 sig. bits */
 	    v = t*ivln2_l-w*ivln2;
 	    t1 = u+v;
 	    SET_LOW_WORD(t1,0);
 	    t2 = v-(t1-u);
 	} else {
 	    double ss,s2,s_h,s_l,t_h,t_l;
 	    n = 0;
 	/* take care subnormal number */
 	    if(ix<0x00100000)
 		{ax *= two53; n -= 53; GET_HIGH_WORD(ix,ax); }
 	    n  += ((ix)>>20)-0x3ff;
 	    j  = ix&0x000fffff;
 	/* determine interval */
 	    ix = j|0x3ff00000;		/* normalize ix */
 	    if(j<=0x3988E) k=0;		/* |x|<sqrt(3/2) */
 	    else if(j<0xBB67A) k=1;	/* |x|<sqrt(3)   */
 	    else {k=0;n+=1;ix -= 0x00100000;}
 	    SET_HIGH_WORD(ax,ix);
 
 	/* compute ss = s_h+s_l = (x-1)/(x+1) or (x-1.5)/(x+1.5) */
 	    u = ax-bp[k];		/* bp[0]=1.0, bp[1]=1.5 */
 	    v = one/(ax+bp[k]);
 	    ss = u*v;
 	    s_h = ss;
 	    SET_LOW_WORD(s_h,0);
 	/* t_h=ax+bp[k] High */
 	    t_h = zero;
 	    SET_HIGH_WORD(t_h,((ix>>1)|0x20000000)+0x00080000+(k<<18));
 	    t_l = ax - (t_h-bp[k]);
 	    s_l = v*((u-s_h*t_h)-s_h*t_l);
 	/* compute log(ax) */
 	    s2 = ss*ss;
 	    r = s2*s2*(L1+s2*(L2+s2*(L3+s2*(L4+s2*(L5+s2*L6)))));
 	    r += s_l*(s_h+ss);
 	    s2  = s_h*s_h;
 	    t_h = 3+s2+r;
 	    SET_LOW_WORD(t_h,0);
 	    t_l = r-((t_h-3)-s2);
 	/* u+v = ss*(1+...) */
 	    u = s_h*t_h;
 	    v = s_l*t_h+t_l*ss;
 	/* 2/(3log2)*(ss+...) */
 	    p_h = u+v;
 	    SET_LOW_WORD(p_h,0);
 	    p_l = v-(p_h-u);
 	    z_h = cp_h*p_h;		/* cp_h+cp_l = 2/(3*log2) */
 	    z_l = cp_l*p_h+p_l*cp+dp_l[k];
 	/* log2(ax) = (ss+..)*2/(3*log2) = n + dp_h + z_h + z_l */
 	    t = n;
 	    t1 = (((z_h+z_l)+dp_h[k])+t);
 	    SET_LOW_WORD(t1,0);
 	    t2 = z_l-(((t1-t)-dp_h[k])-z_h);
 	}
 
     /* split up y into y1+y2 and compute (y1+y2)*(t1+t2) */
 	y1  = y;
 	SET_LOW_WORD(y1,0);
 	p_l = (y-y1)*t1+y*t2;
 	p_h = y1*t1;
 	z = p_l+p_h;
 	EXTRACT_WORDS(j,i,z);
 	if (j>=0x40900000) {				/* z >= 1024 */
 	    if(((j-0x40900000)|i)!=0)			/* if z > 1024 */
 		return s*huge*huge;			/* overflow */
 	    else {
 		if(p_l+ovt>z-p_h) return s*huge*huge;	/* overflow */
 	    }
 	} else if((j&0x7fffffff)>=0x4090cc00 ) {	/* z <= -1075 */
 	    if(((j-0xc090cc00)|i)!=0) 		/* z < -1075 */
 		return s*tiny*tiny;		/* underflow */
 	    else {
 		if(p_l<=z-p_h) return s*tiny*tiny;	/* underflow */
 	    }
 	}
     /*
      * compute 2**(p_h+p_l)
      */
 	i = j&0x7fffffff;
 	k = (i>>20)-0x3ff;
 	n = 0;
 	if(i>0x3fe00000) {		/* if |z| > 0.5, set n = [z+0.5] */
 	    n = j+(0x00100000>>(k+1));
 	    k = ((n&0x7fffffff)>>20)-0x3ff;	/* new k for n */
 	    t = zero;
 	    SET_HIGH_WORD(t,n&~(0x000fffff>>k));
 	    n = ((n&0x000fffff)|0x00100000)>>(20-k);
 	    if(j<0) n = -n;
 	    p_h -= t;
 	}
 	t = p_l+p_h;
 	SET_LOW_WORD(t,0);
 	u = t*lg2_h;
 	v = (p_l-(t-p_h))*lg2+t*lg2_l;
 	z = u+v;
 	w = v-(z-u);
 	t  = z*z;
 	t1  = z - t*(P1+t*(P2+t*(P3+t*(P4+t*P5))));
 	r  = (z*t1)/(t1-two)-(w+z*w);
 	z  = one-(r-z);
 	GET_HIGH_WORD(j,z);
 	j += (n<<20);
 	if((j>>20)<=0) z = scalbn(z,n);	/* subnormal output */
 	else SET_HIGH_WORD(z,j);
 	return s*z;
 }
 
 #if (LDBL_MANT_DIG == 53)
 __weak_reference(pow, powl);
 #endif
diff --git a/lib/msun/src/e_powf.c b/lib/msun/src/e_powf.c
index 33eedad50b16..bc9ff9cbba1c 100644
--- a/lib/msun/src/e_powf.c
+++ b/lib/msun/src/e_powf.c
@@ -1,252 +1,252 @@
 /* e_powf.c -- float version of e_pow.c.
  * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
  */
 
 /*
  * ====================================================
  * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
  *
  * Developed at SunPro, a Sun Microsystems, Inc. business.
  * Permission to use, copy, modify, and distribute this
  * software is freely granted, provided that this notice
  * is preserved.
  * ====================================================
  */
 
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
 #include "math.h"
 #include "math_private.h"
 
 static const float
 bp[] = {1.0, 1.5,},
 dp_h[] = { 0.0, 5.84960938e-01,}, /* 0x3f15c000 */
 dp_l[] = { 0.0, 1.56322085e-06,}, /* 0x35d1cfdc */
 zero    =  0.0,
 half    =  0.5,
 qrtr    =  0.25,
 thrd    =  3.33333343e-01, /* 0x3eaaaaab */
 one	=  1.0,
 two	=  2.0,
 two24	=  16777216.0,	/* 0x4b800000 */
 huge	=  1.0e30,
 tiny    =  1.0e-30,
 	/* poly coefs for (3/2)*(log(x)-2s-2/3*s**3 */
 L1  =  6.0000002384e-01, /* 0x3f19999a */
 L2  =  4.2857143283e-01, /* 0x3edb6db7 */
 L3  =  3.3333334327e-01, /* 0x3eaaaaab */
 L4  =  2.7272811532e-01, /* 0x3e8ba305 */
 L5  =  2.3066075146e-01, /* 0x3e6c3255 */
 L6  =  2.0697501302e-01, /* 0x3e53f142 */
 P1   =  1.6666667163e-01, /* 0x3e2aaaab */
 P2   = -2.7777778450e-03, /* 0xbb360b61 */
 P3   =  6.6137559770e-05, /* 0x388ab355 */
 P4   = -1.6533901999e-06, /* 0xb5ddea0e */
 P5   =  4.1381369442e-08, /* 0x3331bb4c */
 lg2  =  6.9314718246e-01, /* 0x3f317218 */
 lg2_h  =  6.93145752e-01, /* 0x3f317200 */
 lg2_l  =  1.42860654e-06, /* 0x35bfbe8c */
 ovt =  4.2995665694e-08, /* -(128-log2(ovfl+.5ulp)) */
 cp    =  9.6179670095e-01, /* 0x3f76384f =2/(3ln2) */
 cp_h  =  9.6191406250e-01, /* 0x3f764000 =12b cp */
 cp_l  = -1.1736857402e-04, /* 0xb8f623c6 =tail of cp_h */
 ivln2    =  1.4426950216e+00, /* 0x3fb8aa3b =1/ln2 */
 ivln2_h  =  1.4426879883e+00, /* 0x3fb8aa00 =16b 1/ln2*/
 ivln2_l  =  7.0526075433e-06; /* 0x36eca570 =1/ln2 tail*/
 
 float
-__ieee754_powf(float x, float y)
+powf(float x, float y)
 {
 	float z,ax,z_h,z_l,p_h,p_l;
 	float y1,t1,t2,r,s,sn,t,u,v,w;
 	int32_t i,j,k,yisint,n;
 	int32_t hx,hy,ix,iy,is;
 
 	GET_FLOAT_WORD(hx,x);
 	GET_FLOAT_WORD(hy,y);
 	ix = hx&0x7fffffff;  iy = hy&0x7fffffff;
 
     /* y==zero: x**0 = 1 */
 	if(iy==0) return one;
 
     /* x==1: 1**y = 1, even if y is NaN */
 	if (hx==0x3f800000) return one;
 
     /* y!=zero: result is NaN if either arg is NaN */
 	if(ix > 0x7f800000 ||
 	   iy > 0x7f800000)
 	    return nan_mix(x, y);
 
     /* determine if y is an odd int when x < 0
      * yisint = 0	... y is not an integer
      * yisint = 1	... y is an odd int
      * yisint = 2	... y is an even int
      */
 	yisint  = 0;
 	if(hx<0) {
 	    if(iy>=0x4b800000) yisint = 2; /* even integer y */
 	    else if(iy>=0x3f800000) {
 		k = (iy>>23)-0x7f;	   /* exponent */
 		j = iy>>(23-k);
 		if((j<<(23-k))==iy) yisint = 2-(j&1);
 	    }
 	}
 
     /* special value of y */
 	if (iy==0x7f800000) {	/* y is +-inf */
 	    if (ix==0x3f800000)
 	        return  one;	/* (-1)**+-inf is NaN */
 	    else if (ix > 0x3f800000)/* (|x|>1)**+-inf = inf,0 */
 	        return (hy>=0)? y: zero;
 	    else			/* (|x|<1)**-,+inf = inf,0 */
 	        return (hy<0)?-y: zero;
 	}
 	if(iy==0x3f800000) {	/* y is  +-1 */
 	    if(hy<0) return one/x; else return x;
 	}
 	if(hy==0x40000000) return x*x; /* y is  2 */
 	if(hy==0x3f000000) {	/* y is  0.5 */
 	    if(hx>=0)	/* x >= +0 */
-	    return __ieee754_sqrtf(x);
+	    return sqrtf(x);
 	}
 
 	ax   = fabsf(x);
     /* special value of x */
 	if(ix==0x7f800000||ix==0||ix==0x3f800000){
 	    z = ax;			/*x is +-0,+-inf,+-1*/
 	    if(hy<0) z = one/z;	/* z = (1/|x|) */
 	    if(hx<0) {
 		if(((ix-0x3f800000)|yisint)==0) {
 		    z = (z-z)/(z-z); /* (-1)**non-int is NaN */
 		} else if(yisint==1)
 		    z = -z;		/* (x<0)**odd = -(|x|**odd) */
 	    }
 	    return z;
 	}
 
 	n = ((u_int32_t)hx>>31)-1;
 
     /* (x<0)**(non-int) is NaN */
 	if((n|yisint)==0) return (x-x)/(x-x);
 
 	sn = one; /* s (sign of result -ve**odd) = -1 else = 1 */
 	if((n|(yisint-1))==0) sn = -one;/* (-ve)**(odd int) */
 
     /* |y| is huge */
 	if(iy>0x4d000000) { /* if |y| > 2**27 */
 	/* over/underflow if x is not close to one */
 	    if(ix<0x3f7ffff7) return (hy<0)? sn*huge*huge:sn*tiny*tiny;
 	    if(ix>0x3f800007) return (hy>0)? sn*huge*huge:sn*tiny*tiny;
 	/* now |1-x| is tiny <= 2**-20, suffice to compute
 	   log(x) by x-x^2/2+x^3/3-x^4/4 */
 	    t = ax-1;		/* t has 20 trailing zeros */
 	    w = (t*t)*(half-t*(thrd-t*qrtr));
 	    u = ivln2_h*t;	/* ivln2_h has 16 sig. bits */
 	    v = t*ivln2_l-w*ivln2;
 	    t1 = u+v;
 	    GET_FLOAT_WORD(is,t1);
 	    SET_FLOAT_WORD(t1,is&0xfffff000);
 	    t2 = v-(t1-u);
 	} else {
 	    float s2,s_h,s_l,t_h,t_l;
 	    n = 0;
 	/* take care subnormal number */
 	    if(ix<0x00800000)
 		{ax *= two24; n -= 24; GET_FLOAT_WORD(ix,ax); }
 	    n  += ((ix)>>23)-0x7f;
 	    j  = ix&0x007fffff;
 	/* determine interval */
 	    ix = j|0x3f800000;		/* normalize ix */
 	    if(j<=0x1cc471) k=0;	/* |x|<sqrt(3/2) */
 	    else if(j<0x5db3d7) k=1;	/* |x|<sqrt(3)   */
 	    else {k=0;n+=1;ix -= 0x00800000;}
 	    SET_FLOAT_WORD(ax,ix);
 
 	/* compute s = s_h+s_l = (x-1)/(x+1) or (x-1.5)/(x+1.5) */
 	    u = ax-bp[k];		/* bp[0]=1.0, bp[1]=1.5 */
 	    v = one/(ax+bp[k]);
 	    s = u*v;
 	    s_h = s;
 	    GET_FLOAT_WORD(is,s_h);
 	    SET_FLOAT_WORD(s_h,is&0xfffff000);
 	/* t_h=ax+bp[k] High */
 	    is = ((ix>>1)&0xfffff000)|0x20000000;
 	    SET_FLOAT_WORD(t_h,is+0x00400000+(k<<21));
 	    t_l = ax - (t_h-bp[k]);
 	    s_l = v*((u-s_h*t_h)-s_h*t_l);
 	/* compute log(ax) */
 	    s2 = s*s;
 	    r = s2*s2*(L1+s2*(L2+s2*(L3+s2*(L4+s2*(L5+s2*L6)))));
 	    r += s_l*(s_h+s);
 	    s2  = s_h*s_h;
 	    t_h = 3+s2+r;
 	    GET_FLOAT_WORD(is,t_h);
 	    SET_FLOAT_WORD(t_h,is&0xfffff000);
 	    t_l = r-((t_h-3)-s2);
 	/* u+v = s*(1+...) */
 	    u = s_h*t_h;
 	    v = s_l*t_h+t_l*s;
 	/* 2/(3log2)*(s+...) */
 	    p_h = u+v;
 	    GET_FLOAT_WORD(is,p_h);
 	    SET_FLOAT_WORD(p_h,is&0xfffff000);
 	    p_l = v-(p_h-u);
 	    z_h = cp_h*p_h;		/* cp_h+cp_l = 2/(3*log2) */
 	    z_l = cp_l*p_h+p_l*cp+dp_l[k];
 	/* log2(ax) = (s+..)*2/(3*log2) = n + dp_h + z_h + z_l */
 	    t = n;
 	    t1 = (((z_h+z_l)+dp_h[k])+t);
 	    GET_FLOAT_WORD(is,t1);
 	    SET_FLOAT_WORD(t1,is&0xfffff000);
 	    t2 = z_l-(((t1-t)-dp_h[k])-z_h);
 	}
 
     /* split up y into y1+y2 and compute (y1+y2)*(t1+t2) */
 	GET_FLOAT_WORD(is,y);
 	SET_FLOAT_WORD(y1,is&0xfffff000);
 	p_l = (y-y1)*t1+y*t2;
 	p_h = y1*t1;
 	z = p_l+p_h;
 	GET_FLOAT_WORD(j,z);
 	if (j>0x43000000)				/* if z > 128 */
 	    return sn*huge*huge;			/* overflow */
 	else if (j==0x43000000) {			/* if z == 128 */
 	    if(p_l+ovt>z-p_h) return sn*huge*huge;	/* overflow */
 	}
 	else if ((j&0x7fffffff)>0x43160000)		/* z <= -150 */
 	    return sn*tiny*tiny;			/* underflow */
 	else if (j==0xc3160000){			/* z == -150 */
 	    if(p_l<=z-p_h) return sn*tiny*tiny;		/* underflow */
 	}
     /*
      * compute 2**(p_h+p_l)
      */
 	i = j&0x7fffffff;
 	k = (i>>23)-0x7f;
 	n = 0;
 	if(i>0x3f000000) {		/* if |z| > 0.5, set n = [z+0.5] */
 	    n = j+(0x00800000>>(k+1));
 	    k = ((n&0x7fffffff)>>23)-0x7f;	/* new k for n */
 	    SET_FLOAT_WORD(t,n&~(0x007fffff>>k));
 	    n = ((n&0x007fffff)|0x00800000)>>(23-k);
 	    if(j<0) n = -n;
 	    p_h -= t;
 	}
 	t = p_l+p_h;
 	GET_FLOAT_WORD(is,t);
 	SET_FLOAT_WORD(t,is&0xffff8000);
 	u = t*lg2_h;
 	v = (p_l-(t-p_h))*lg2+t*lg2_l;
 	z = u+v;
 	w = v-(z-u);
 	t  = z*z;
 	t1  = z - t*(P1+t*(P2+t*(P3+t*(P4+t*P5))));
 	r  = (z*t1)/(t1-two)-(w+z*w);
 	z  = one-(r-z);
 	GET_FLOAT_WORD(j,z);
 	j += (n<<23);
 	if((j>>23)<=0) z = scalbnf(z,n);	/* subnormal output */
 	else SET_FLOAT_WORD(z,j);
 	return sn*z;
 }
diff --git a/lib/msun/src/e_remainder.c b/lib/msun/src/e_remainder.c
index a4ae0b780fae..13156d8cbc65 100644
--- a/lib/msun/src/e_remainder.c
+++ b/lib/msun/src/e_remainder.c
@@ -1,79 +1,79 @@
 
 /* @(#)e_remainder.c 1.3 95/01/18 */
 /*
  * ====================================================
  * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
  *
  * Developed at SunSoft, a Sun Microsystems, Inc. business.
  * Permission to use, copy, modify, and distribute this
  * software is freely granted, provided that this notice 
  * is preserved.
  * ====================================================
  */
 
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
-/* __ieee754_remainder(x,p)
+/* remainder(x,p)
  * Return :                  
  * 	returns  x REM p  =  x - [x/p]*p as if in infinite 
  * 	precise arithmetic, where [x/p] is the (infinite bit) 
  *	integer nearest x/p (in half way case choose the even one).
  * Method : 
  *	Based on fmod() return x-[x/p]chopped*p exactlp.
  */
 
 #include <float.h>
 
 #include "math.h"
 #include "math_private.h"
 
 static const double zero = 0.0;
 
 
 double
-__ieee754_remainder(double x, double p)
+remainder(double x, double p)
 {
 	int32_t hx,hp;
 	u_int32_t sx,lx,lp;
 	double p_half;
 
 	EXTRACT_WORDS(hx,lx,x);
 	EXTRACT_WORDS(hp,lp,p);
 	sx = hx&0x80000000;
 	hp &= 0x7fffffff;
 	hx &= 0x7fffffff;
 
     /* purge off exception values */
 	if(((hp|lp)==0)||		 	/* p = 0 */
 	  (hx>=0x7ff00000)||			/* x not finite */
 	  ((hp>=0x7ff00000)&&			/* p is NaN */
 	  (((hp-0x7ff00000)|lp)!=0)))
 	    return nan_mix_op(x, p, *)/nan_mix_op(x, p, *);
 
 
-	if (hp<=0x7fdfffff) x = __ieee754_fmod(x,p+p);	/* now x < 2p */
+	if (hp<=0x7fdfffff) x = fmod(x,p+p);	/* now x < 2p */
 	if (((hx-hp)|(lx-lp))==0) return zero*x;
 	x  = fabs(x);
 	p  = fabs(p);
 	if (hp<0x00200000) {
 	    if(x+x>p) {
 		x-=p;
 		if(x+x>=p) x -= p;
 	    }
 	} else {
 	    p_half = 0.5*p;
 	    if(x>p_half) {
 		x-=p;
 		if(x>=p_half) x -= p;
 	    }
 	}
 	GET_HIGH_WORD(hx,x);
 	if ((hx&0x7fffffff)==0) hx = 0;
 	SET_HIGH_WORD(x,hx^sx);
 	return x;
 }
 
 #if LDBL_MANT_DIG == 53
 __weak_reference(remainder, remainderl);
 #endif
diff --git a/lib/msun/src/e_remainderf.c b/lib/msun/src/e_remainderf.c
index 8004493de77b..e0dcfd181dfd 100644
--- a/lib/msun/src/e_remainderf.c
+++ b/lib/msun/src/e_remainderf.c
@@ -1,65 +1,65 @@
 /* e_remainderf.c -- float version of e_remainder.c.
  * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
  */
 
 /*
  * ====================================================
  * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
  *
  * Developed at SunPro, a Sun Microsystems, Inc. business.
  * Permission to use, copy, modify, and distribute this
  * software is freely granted, provided that this notice
  * is preserved.
  * ====================================================
  */
 
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
 #include "math.h"
 #include "math_private.h"
 
 static const float zero = 0.0;
 
 
 float
-__ieee754_remainderf(float x, float p)
+remainderf(float x, float p)
 {
 	int32_t hx,hp;
 	u_int32_t sx;
 	float p_half;
 
 	GET_FLOAT_WORD(hx,x);
 	GET_FLOAT_WORD(hp,p);
 	sx = hx&0x80000000;
 	hp &= 0x7fffffff;
 	hx &= 0x7fffffff;
 
     /* purge off exception values */
 	if((hp==0)||			 	/* p = 0 */
 	  (hx>=0x7f800000)||			/* x not finite */
 	  ((hp>0x7f800000)))			/* p is NaN */
 	    return nan_mix_op(x, p, *)/nan_mix_op(x, p, *);
 
 
-	if (hp<=0x7effffff) x = __ieee754_fmodf(x,p+p);	/* now x < 2p */
+	if (hp<=0x7effffff) x = fmodf(x,p+p);	/* now x < 2p */
 	if ((hx-hp)==0) return zero*x;
 	x  = fabsf(x);
 	p  = fabsf(p);
 	if (hp<0x01000000) {
 	    if(x+x>p) {
 		x-=p;
 		if(x+x>=p) x -= p;
 	    }
 	} else {
 	    p_half = (float)0.5*p;
 	    if(x>p_half) {
 		x-=p;
 		if(x>=p_half) x -= p;
 	    }
 	}
 	GET_FLOAT_WORD(hx,x);
 	if ((hx&0x7fffffff)==0) hx = 0;
 	SET_FLOAT_WORD(x,hx^sx);
 	return x;
 }
diff --git a/lib/msun/src/e_scalb.c b/lib/msun/src/e_scalb.c
index c0a7b5b75b12..84a68939b836 100644
--- a/lib/msun/src/e_scalb.c
+++ b/lib/msun/src/e_scalb.c
@@ -1,47 +1,47 @@
 
 /* @(#)e_scalb.c 1.3 95/01/18 */
 /*
  * ====================================================
  * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
  *
  * Developed at SunSoft, a Sun Microsystems, Inc. business.
  * Permission to use, copy, modify, and distribute this
  * software is freely granted, provided that this notice 
  * is preserved.
  * ====================================================
  */
 
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
 /*
- * __ieee754_scalb(x, fn) is provide for
+ * scalb(x, fn) is provide for
  * passing various standard test suite. One 
  * should use scalbn() instead.
  */
 
 #include "math.h"
 #include "math_private.h"
 
 #ifdef _SCALB_INT
 double
-__ieee754_scalb(double x, int fn)
+scalb(double x, int fn)
 #else
 double
-__ieee754_scalb(double x, double fn)
+scalb(double x, double fn)
 #endif
 {
 #ifdef _SCALB_INT
 	return scalbn(x,fn);
 #else
 	if (isnan(x)||isnan(fn)) return x*fn;
 	if (!finite(fn)) {
 	    if(fn>0.0) return x*fn;
 	    else       return x/(-fn);
 	}
 	if (rint(fn)!=fn) return (fn-fn)/(fn-fn);
 	if ( fn > 65000.0) return scalbn(x, 65000);
 	if (-fn > 65000.0) return scalbn(x,-65000);
 	return scalbn(x,(int)fn);
 #endif
 }
diff --git a/lib/msun/src/e_scalbf.c b/lib/msun/src/e_scalbf.c
index d49e9041f849..28483a5e2826 100644
--- a/lib/msun/src/e_scalbf.c
+++ b/lib/msun/src/e_scalbf.c
@@ -1,43 +1,43 @@
 /* e_scalbf.c -- float version of e_scalb.c.
  * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
  */
 
 /*
  * ====================================================
  * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
  *
  * Developed at SunPro, a Sun Microsystems, Inc. business.
  * Permission to use, copy, modify, and distribute this
  * software is freely granted, provided that this notice
  * is preserved.
  * ====================================================
  */
 
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
 #include "math.h"
 #include "math_private.h"
 
 #ifdef _SCALB_INT
 float
-__ieee754_scalbf(float x, int fn)
+scalbf(float x, int fn)
 #else
 float
-__ieee754_scalbf(float x, float fn)
+scalbf(float x, float fn)
 #endif
 {
 #ifdef _SCALB_INT
 	return scalbnf(x,fn);
 #else
 	if ((isnanf)(x)||(isnanf)(fn)) return x*fn;
 	if (!finitef(fn)) {
 	    if(fn>(float)0.0) return x*fn;
 	    else       return x/(-fn);
 	}
 	if (rintf(fn)!=fn) return (fn-fn)/(fn-fn);
 	if ( fn > (float)65000.0) return scalbnf(x, 65000);
 	if (-fn > (float)65000.0) return scalbnf(x,-65000);
 	return scalbnf(x,(int)fn);
 #endif
 }
diff --git a/lib/msun/src/e_sinh.c b/lib/msun/src/e_sinh.c
index 6c01f4a3c8e3..9fe89996a098 100644
--- a/lib/msun/src/e_sinh.c
+++ b/lib/msun/src/e_sinh.c
@@ -1,79 +1,79 @@
 
 /* @(#)e_sinh.c 1.3 95/01/18 */
 /*
  * ====================================================
  * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
  *
  * Developed at SunSoft, a Sun Microsystems, Inc. business.
  * Permission to use, copy, modify, and distribute this
  * software is freely granted, provided that this notice 
  * is preserved.
  * ====================================================
  */
 
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
-/* __ieee754_sinh(x)
+/* sinh(x)
  * Method : 
  * mathematically sinh(x) if defined to be (exp(x)-exp(-x))/2
  *	1. Replace x by |x| (sinh(-x) = -sinh(x)). 
  *	2. 
  *		                                    E + E/(E+1)
  *	    0        <= x <= 22     :  sinh(x) := --------------, E=expm1(x)
  *			       			        2
  *
  *	    22       <= x <= lnovft :  sinh(x) := exp(x)/2 
  *	    lnovft   <= x <= ln2ovft:  sinh(x) := exp(x/2)/2 * exp(x/2)
  *	    ln2ovft  <  x	    :  sinh(x) := x*shuge (overflow)
  *
  * Special cases:
  *	sinh(x) is |x| if x is +INF, -INF, or NaN.
  *	only sinh(0)=0 is exact for finite x.
  */
 
 #include <float.h>
 
 #include "math.h"
 #include "math_private.h"
 
 static const double one = 1.0, shuge = 1.0e307;
 
 double
-__ieee754_sinh(double x)
+sinh(double x)
 {
 	double t,h;
 	int32_t ix,jx;
 
     /* High word of |x|. */
 	GET_HIGH_WORD(jx,x);
 	ix = jx&0x7fffffff;
 
     /* x is INF or NaN */
 	if(ix>=0x7ff00000) return x+x;	
 
 	h = 0.5;
 	if (jx<0) h = -h;
     /* |x| in [0,22], return sign(x)*0.5*(E+E/(E+1))) */
 	if (ix < 0x40360000) {		/* |x|<22 */
 	    if (ix<0x3e300000) 		/* |x|<2**-28 */
 		if(shuge+x>one) return x;/* sinh(tiny) = tiny with inexact */
 	    t = expm1(fabs(x));
 	    if(ix<0x3ff00000) return h*(2.0*t-t*t/(t+one));
 	    return h*(t+t/(t+one));
 	}
 
     /* |x| in [22, log(maxdouble)] return 0.5*exp(|x|) */
-	if (ix < 0x40862E42)  return h*__ieee754_exp(fabs(x));
+	if (ix < 0x40862E42)  return h*exp(fabs(x));
 
     /* |x| in [log(maxdouble), overflowthresold] */
 	if (ix<=0x408633CE)
 	    return h*2.0*__ldexp_exp(fabs(x), -1);
 
     /* |x| > overflowthresold, sinh(x) overflow */
 	return x*shuge;
 }
 
 #if (LDBL_MANT_DIG == 53)
 __weak_reference(sinh, sinhl);
 #endif
diff --git a/lib/msun/src/e_sinhf.c b/lib/msun/src/e_sinhf.c
index 1be2dc397d11..082beb14fb14 100644
--- a/lib/msun/src/e_sinhf.c
+++ b/lib/msun/src/e_sinhf.c
@@ -1,56 +1,56 @@
 /* e_sinhf.c -- float version of e_sinh.c.
  * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
  */
 
 /*
  * ====================================================
  * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
  *
  * Developed at SunPro, a Sun Microsystems, Inc. business.
  * Permission to use, copy, modify, and distribute this
  * software is freely granted, provided that this notice
  * is preserved.
  * ====================================================
  */
 
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
 #include "math.h"
 #include "math_private.h"
 
 static const float one = 1.0, shuge = 1.0e37;
 
 float
-__ieee754_sinhf(float x)
+sinhf(float x)
 {
 	float t,h;
 	int32_t ix,jx;
 
 	GET_FLOAT_WORD(jx,x);
 	ix = jx&0x7fffffff;
 
     /* x is INF or NaN */
 	if(ix>=0x7f800000) return x+x;
 
 	h = 0.5;
 	if (jx<0) h = -h;
     /* |x| in [0,9], return sign(x)*0.5*(E+E/(E+1))) */
 	if (ix < 0x41100000) {		/* |x|<9 */
 	    if (ix<0x39800000) 		/* |x|<2**-12 */
 		if(shuge+x>one) return x;/* sinh(tiny) = tiny with inexact */
 	    t = expm1f(fabsf(x));
 	    if(ix<0x3f800000) return h*((float)2.0*t-t*t/(t+one));
 	    return h*(t+t/(t+one));
 	}
 
     /* |x| in [9, logf(maxfloat)] return 0.5*exp(|x|) */
-	if (ix < 0x42b17217)  return h*__ieee754_expf(fabsf(x));
+	if (ix < 0x42b17217)  return h*expf(fabsf(x));
 
     /* |x| in [logf(maxfloat), overflowthresold] */
 	if (ix<=0x42b2d4fc)
 	    return h*2.0F*__ldexp_expf(fabsf(x), -1);
 
     /* |x| > overflowthresold, sinh(x) overflow */
 	return x*shuge;
 }
diff --git a/lib/msun/src/e_sqrt.c b/lib/msun/src/e_sqrt.c
index 37351a425ce4..5460dd0dbddd 100644
--- a/lib/msun/src/e_sqrt.c
+++ b/lib/msun/src/e_sqrt.c
@@ -1,459 +1,459 @@
 
 /* @(#)e_sqrt.c 1.3 95/01/18 */
 /*
  * ====================================================
  * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
  *
  * Developed at SunSoft, a Sun Microsystems, Inc. business.
  * Permission to use, copy, modify, and distribute this
  * software is freely granted, provided that this notice 
  * is preserved.
  * ====================================================
  */
 
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
 #include <float.h>
 
 #include "math.h"
 #include "math_private.h"
 
 #ifdef USE_BUILTIN_SQRT
 double
-__ieee754_sqrt(double x)
+sqrt(double x)
 {
 	return (__builtin_sqrt(x));
 }
 #else
-/* __ieee754_sqrt(x)
+/* sqrt(x)
  * Return correctly rounded sqrt.
  *           ------------------------------------------
  *	     |  Use the hardware sqrt if you have one |
  *           ------------------------------------------
  * Method: 
  *   Bit by bit method using integer arithmetic. (Slow, but portable) 
  *   1. Normalization
  *	Scale x to y in [1,4) with even powers of 2: 
  *	find an integer k such that  1 <= (y=x*2^(2k)) < 4, then
  *		sqrt(x) = 2^k * sqrt(y)
  *   2. Bit by bit computation
  *	Let q  = sqrt(y) truncated to i bit after binary point (q = 1),
  *	     i							 0
  *                                     i+1         2
  *	    s  = 2*q , and	y  =  2   * ( y - q  ).		(1)
  *	     i      i            i                 i
  *                                                        
  *	To compute q    from q , one checks whether 
  *		    i+1       i                       
  *
  *			      -(i+1) 2
  *			(q + 2      ) <= y.			(2)
  *     			  i
  *							      -(i+1)
  *	If (2) is false, then q   = q ; otherwise q   = q  + 2      .
  *		 	       i+1   i             i+1   i
  *
  *	With some algebric manipulation, it is not difficult to see
  *	that (2) is equivalent to 
  *                             -(i+1)
  *			s  +  2       <= y			(3)
  *			 i                i
  *
  *	The advantage of (3) is that s  and y  can be computed by 
  *				      i      i
  *	the following recurrence formula:
  *	    if (3) is false
  *
  *	    s     =  s  ,	y    = y   ;			(4)
  *	     i+1      i		 i+1    i
  *
  *	    otherwise,
  *                         -i                     -(i+1)
  *	    s	  =  s  + 2  ,  y    = y  -  s  - 2  		(5)
  *           i+1      i          i+1    i     i
  *				
  *	One may easily use induction to prove (4) and (5). 
  *	Note. Since the left hand side of (3) contain only i+2 bits,
  *	      it does not necessary to do a full (53-bit) comparison 
  *	      in (3).
  *   3. Final rounding
  *	After generating the 53 bits result, we compute one more bit.
  *	Together with the remainder, we can decide whether the
  *	result is exact, bigger than 1/2ulp, or less than 1/2ulp
  *	(it will never equal to 1/2ulp).
  *	The rounding mode can be detected by checking whether
  *	huge + tiny is equal to huge, and whether huge - tiny is
  *	equal to huge for some floating point number "huge" and "tiny".
  *		
  * Special cases:
  *	sqrt(+-0) = +-0 	... exact
  *	sqrt(inf) = inf
  *	sqrt(-ve) = NaN		... with invalid signal
  *	sqrt(NaN) = NaN		... with invalid signal for signaling NaN
  *
  * Other methods : see the appended file at the end of the program below.
  *---------------
  */
 
 static	const double	one	= 1.0, tiny=1.0e-300;
 
 double
-__ieee754_sqrt(double x)
+sqrt(double x)
 {
 	double z;
 	int32_t sign = (int)0x80000000;
 	int32_t ix0,s0,q,m,t,i;
 	u_int32_t r,t1,s1,ix1,q1;
 
 	EXTRACT_WORDS(ix0,ix1,x);
 
     /* take care of Inf and NaN */
 	if((ix0&0x7ff00000)==0x7ff00000) {			
 	    return x*x+x;		/* sqrt(NaN)=NaN, sqrt(+inf)=+inf
 					   sqrt(-inf)=sNaN */
 	} 
     /* take care of zero */
 	if(ix0<=0) {
 	    if(((ix0&(~sign))|ix1)==0) return x;/* sqrt(+-0) = +-0 */
 	    else if(ix0<0)
 		return (x-x)/(x-x);		/* sqrt(-ve) = sNaN */
 	}
     /* normalize x */
 	m = (ix0>>20);
 	if(m==0) {				/* subnormal x */
 	    while(ix0==0) {
 		m -= 21;
 		ix0 |= (ix1>>11); ix1 <<= 21;
 	    }
 	    for(i=0;(ix0&0x00100000)==0;i++) ix0<<=1;
 	    m -= i-1;
 	    ix0 |= (ix1>>(32-i));
 	    ix1 <<= i;
 	}
 	m -= 1023;	/* unbias exponent */
 	ix0 = (ix0&0x000fffff)|0x00100000;
 	if(m&1){	/* odd m, double x to make it even */
 	    ix0 += ix0 + ((ix1&sign)>>31);
 	    ix1 += ix1;
 	}
 	m >>= 1;	/* m = [m/2] */
 
     /* generate sqrt(x) bit by bit */
 	ix0 += ix0 + ((ix1&sign)>>31);
 	ix1 += ix1;
 	q = q1 = s0 = s1 = 0;	/* [q,q1] = sqrt(x) */
 	r = 0x00200000;		/* r = moving bit from right to left */
 
 	while(r!=0) {
 	    t = s0+r; 
 	    if(t<=ix0) { 
 		s0   = t+r; 
 		ix0 -= t; 
 		q   += r; 
 	    } 
 	    ix0 += ix0 + ((ix1&sign)>>31);
 	    ix1 += ix1;
 	    r>>=1;
 	}
 
 	r = sign;
 	while(r!=0) {
 	    t1 = s1+r; 
 	    t  = s0;
 	    if((t<ix0)||((t==ix0)&&(t1<=ix1))) { 
 		s1  = t1+r;
 		if(((t1&sign)==sign)&&(s1&sign)==0) s0 += 1;
 		ix0 -= t;
 		if (ix1 < t1) ix0 -= 1;
 		ix1 -= t1;
 		q1  += r;
 	    }
 	    ix0 += ix0 + ((ix1&sign)>>31);
 	    ix1 += ix1;
 	    r>>=1;
 	}
 
     /* use floating add to find out rounding direction */
 	if((ix0|ix1)!=0) {
 	    z = one-tiny; /* trigger inexact flag */
 	    if (z>=one) {
 	        z = one+tiny;
 	        if (q1==(u_int32_t)0xffffffff) { q1=0; q += 1;}
 		else if (z>one) {
 		    if (q1==(u_int32_t)0xfffffffe) q+=1;
 		    q1+=2; 
 		} else
 	            q1 += (q1&1);
 	    }
 	}
 	ix0 = (q>>1)+0x3fe00000;
 	ix1 =  q1>>1;
 	if ((q&1)==1) ix1 |= sign;
 	ix0 += (m <<20);
 	INSERT_WORDS(z,ix0,ix1);
 	return z;
 }
 #endif
 
 #if (LDBL_MANT_DIG == 53)
 __weak_reference(sqrt, sqrtl);
 #endif
 
 /*
 Other methods  (use floating-point arithmetic)
 -------------
 (This is a copy of a drafted paper by Prof W. Kahan 
 and K.C. Ng, written in May, 1986)
 
 	Two algorithms are given here to implement sqrt(x) 
 	(IEEE double precision arithmetic) in software.
 	Both supply sqrt(x) correctly rounded. The first algorithm (in
 	Section A) uses newton iterations and involves four divisions.
 	The second one uses reciproot iterations to avoid division, but
 	requires more multiplications. Both algorithms need the ability
 	to chop results of arithmetic operations instead of round them, 
 	and the INEXACT flag to indicate when an arithmetic operation
 	is executed exactly with no roundoff error, all part of the 
 	standard (IEEE 754-1985). The ability to perform shift, add,
 	subtract and logical AND operations upon 32-bit words is needed
 	too, though not part of the standard.
 
 A.  sqrt(x) by Newton Iteration
 
    (1)	Initial approximation
 
 	Let x0 and x1 be the leading and the trailing 32-bit words of
 	a floating point number x (in IEEE double format) respectively 
 
 	    1    11		     52				  ...widths
 	   ------------------------------------------------------
 	x: |s|	  e     |	      f				|
 	   ------------------------------------------------------
 	      msb    lsb  msb				      lsb ...order
 
  
 	     ------------------------  	     ------------------------
 	x0:  |s|   e    |    f1     |	 x1: |          f2           |
 	     ------------------------  	     ------------------------
 
 	By performing shifts and subtracts on x0 and x1 (both regarded
 	as integers), we obtain an 8-bit approximation of sqrt(x) as
 	follows.
 
 		k  := (x0>>1) + 0x1ff80000;
 		y0 := k - T1[31&(k>>15)].	... y ~ sqrt(x) to 8 bits
 	Here k is a 32-bit integer and T1[] is an integer array containing
 	correction terms. Now magically the floating value of y (y's
 	leading 32-bit word is y0, the value of its trailing word is 0)
 	approximates sqrt(x) to almost 8-bit.
 
 	Value of T1:
 	static int T1[32]= {
 	0,	1024,	3062,	5746,	9193,	13348,	18162,	23592,
 	29598,	36145,	43202,	50740,	58733,	67158,	75992,	85215,
 	83599,	71378,	60428,	50647,	41945,	34246,	27478,	21581,
 	16499,	12183,	8588,	5674,	3403,	1742,	661,	130,};
 
     (2)	Iterative refinement
 
 	Apply Heron's rule three times to y, we have y approximates 
 	sqrt(x) to within 1 ulp (Unit in the Last Place):
 
 		y := (y+x/y)/2		... almost 17 sig. bits
 		y := (y+x/y)/2		... almost 35 sig. bits
 		y := y-(y-x/y)/2	... within 1 ulp
 
 
 	Remark 1.
 	    Another way to improve y to within 1 ulp is:
 
 		y := (y+x/y)		... almost 17 sig. bits to 2*sqrt(x)
 		y := y - 0x00100006	... almost 18 sig. bits to sqrt(x)
 
 				2
 			    (x-y )*y
 		y := y + 2* ----------	...within 1 ulp
 			       2
 			     3y  + x
 
 
 	This formula has one division fewer than the one above; however,
 	it requires more multiplications and additions. Also x must be
 	scaled in advance to avoid spurious overflow in evaluating the
 	expression 3y*y+x. Hence it is not recommended uless division
 	is slow. If division is very slow, then one should use the 
 	reciproot algorithm given in section B.
 
     (3) Final adjustment
 
 	By twiddling y's last bit it is possible to force y to be 
 	correctly rounded according to the prevailing rounding mode
 	as follows. Let r and i be copies of the rounding mode and
 	inexact flag before entering the square root program. Also we
 	use the expression y+-ulp for the next representable floating
 	numbers (up and down) of y. Note that y+-ulp = either fixed
 	point y+-1, or multiply y by nextafter(1,+-inf) in chopped
 	mode.
 
 		I := FALSE;	... reset INEXACT flag I
 		R := RZ;	... set rounding mode to round-toward-zero
 		z := x/y;	... chopped quotient, possibly inexact
 		If(not I) then {	... if the quotient is exact
 		    if(z=y) {
 		        I := i;	 ... restore inexact flag
 		        R := r;  ... restore rounded mode
 		        return sqrt(x):=y.
 		    } else {
 			z := z - ulp;	... special rounding
 		    }
 		}
 		i := TRUE;		... sqrt(x) is inexact
 		If (r=RN) then z=z+ulp	... rounded-to-nearest
 		If (r=RP) then {	... round-toward-+inf
 		    y = y+ulp; z=z+ulp;
 		}
 		y := y+z;		... chopped sum
 		y0:=y0-0x00100000;	... y := y/2 is correctly rounded.
 	        I := i;	 		... restore inexact flag
 	        R := r;  		... restore rounded mode
 	        return sqrt(x):=y.
 		    
     (4)	Special cases
 
 	Square root of +inf, +-0, or NaN is itself;
 	Square root of a negative number is NaN with invalid signal.
 
 
 B.  sqrt(x) by Reciproot Iteration
 
    (1)	Initial approximation
 
 	Let x0 and x1 be the leading and the trailing 32-bit words of
 	a floating point number x (in IEEE double format) respectively
 	(see section A). By performing shifs and subtracts on x0 and y0,
 	we obtain a 7.8-bit approximation of 1/sqrt(x) as follows.
 
 	    k := 0x5fe80000 - (x0>>1);
 	    y0:= k - T2[63&(k>>14)].	... y ~ 1/sqrt(x) to 7.8 bits
 
 	Here k is a 32-bit integer and T2[] is an integer array 
 	containing correction terms. Now magically the floating
 	value of y (y's leading 32-bit word is y0, the value of
 	its trailing word y1 is set to zero) approximates 1/sqrt(x)
 	to almost 7.8-bit.
 
 	Value of T2:
 	static int T2[64]= {
 	0x1500,	0x2ef8,	0x4d67,	0x6b02,	0x87be,	0xa395,	0xbe7a,	0xd866,
 	0xf14a,	0x1091b,0x11fcd,0x13552,0x14999,0x15c98,0x16e34,0x17e5f,
 	0x18d03,0x19a01,0x1a545,0x1ae8a,0x1b5c4,0x1bb01,0x1bfde,0x1c28d,
 	0x1c2de,0x1c0db,0x1ba73,0x1b11c,0x1a4b5,0x1953d,0x18266,0x16be0,
 	0x1683e,0x179d8,0x18a4d,0x19992,0x1a789,0x1b445,0x1bf61,0x1c989,
 	0x1d16d,0x1d77b,0x1dddf,0x1e2ad,0x1e5bf,0x1e6e8,0x1e654,0x1e3cd,
 	0x1df2a,0x1d635,0x1cb16,0x1be2c,0x1ae4e,0x19bde,0x1868e,0x16e2e,
 	0x1527f,0x1334a,0x11051,0xe951,	0xbe01,	0x8e0d,	0x5924,	0x1edd,};
 
     (2)	Iterative refinement
 
 	Apply Reciproot iteration three times to y and multiply the
 	result by x to get an approximation z that matches sqrt(x)
 	to about 1 ulp. To be exact, we will have 
 		-1ulp < sqrt(x)-z<1.0625ulp.
 	
 	... set rounding mode to Round-to-nearest
 	   y := y*(1.5-0.5*x*y*y)	... almost 15 sig. bits to 1/sqrt(x)
 	   y := y*((1.5-2^-30)+0.5*x*y*y)... about 29 sig. bits to 1/sqrt(x)
 	... special arrangement for better accuracy
 	   z := x*y			... 29 bits to sqrt(x), with z*y<1
 	   z := z + 0.5*z*(1-z*y)	... about 1 ulp to sqrt(x)
 
 	Remark 2. The constant 1.5-2^-30 is chosen to bias the error so that
 	(a) the term z*y in the final iteration is always less than 1; 
 	(b) the error in the final result is biased upward so that
 		-1 ulp < sqrt(x) - z < 1.0625 ulp
 	    instead of |sqrt(x)-z|<1.03125ulp.
 
     (3)	Final adjustment
 
 	By twiddling y's last bit it is possible to force y to be 
 	correctly rounded according to the prevailing rounding mode
 	as follows. Let r and i be copies of the rounding mode and
 	inexact flag before entering the square root program. Also we
 	use the expression y+-ulp for the next representable floating
 	numbers (up and down) of y. Note that y+-ulp = either fixed
 	point y+-1, or multiply y by nextafter(1,+-inf) in chopped
 	mode.
 
 	R := RZ;		... set rounding mode to round-toward-zero
 	switch(r) {
 	    case RN:		... round-to-nearest
 	       if(x<= z*(z-ulp)...chopped) z = z - ulp; else
 	       if(x<= z*(z+ulp)...chopped) z = z; else z = z+ulp;
 	       break;
 	    case RZ:case RM:	... round-to-zero or round-to--inf
 	       R:=RP;		... reset rounding mod to round-to-+inf
 	       if(x<z*z ... rounded up) z = z - ulp; else
 	       if(x>=(z+ulp)*(z+ulp) ...rounded up) z = z+ulp;
 	       break;
 	    case RP:		... round-to-+inf
 	       if(x>(z+ulp)*(z+ulp)...chopped) z = z+2*ulp; else
 	       if(x>z*z ...chopped) z = z+ulp;
 	       break;
 	}
 
 	Remark 3. The above comparisons can be done in fixed point. For
 	example, to compare x and w=z*z chopped, it suffices to compare
 	x1 and w1 (the trailing parts of x and w), regarding them as
 	two's complement integers.
 
 	...Is z an exact square root?
 	To determine whether z is an exact square root of x, let z1 be the
 	trailing part of z, and also let x0 and x1 be the leading and
 	trailing parts of x.
 
 	If ((z1&0x03ffffff)!=0)	... not exact if trailing 26 bits of z!=0
 	    I := 1;		... Raise Inexact flag: z is not exact
 	else {
 	    j := 1 - [(x0>>20)&1]	... j = logb(x) mod 2
 	    k := z1 >> 26;		... get z's 25-th and 26-th 
 					    fraction bits
 	    I := i or (k&j) or ((k&(j+j+1))!=(x1&3));
 	}
 	R:= r		... restore rounded mode
 	return sqrt(x):=z.
 
 	If multiplication is cheaper then the foregoing red tape, the 
 	Inexact flag can be evaluated by
 
 	    I := i;
 	    I := (z*z!=x) or I.
 
 	Note that z*z can overwrite I; this value must be sensed if it is 
 	True.
 
 	Remark 4. If z*z = x exactly, then bit 25 to bit 0 of z1 must be
 	zero.
 
 		    --------------------
 		z1: |        f2        | 
 		    --------------------
 		bit 31		   bit 0
 
 	Further more, bit 27 and 26 of z1, bit 0 and 1 of x1, and the odd
 	or even of logb(x) have the following relations:
 
 	-------------------------------------------------
 	bit 27,26 of z1		bit 1,0 of x1	logb(x)
 	-------------------------------------------------
 	00			00		odd and even
 	01			01		even
 	10			10		odd
 	10			00		even
 	11			01		even
 	-------------------------------------------------
 
     (4)	Special cases (see (4) of Section A).	
  
  */
  
diff --git a/lib/msun/src/e_sqrtf.c b/lib/msun/src/e_sqrtf.c
index 06e5d62fa5f9..1fd0cec447fb 100644
--- a/lib/msun/src/e_sqrtf.c
+++ b/lib/msun/src/e_sqrtf.c
@@ -1,97 +1,97 @@
 /* e_sqrtf.c -- float version of e_sqrt.c.
  * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
  */
 
 /*
  * ====================================================
  * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
  *
  * Developed at SunPro, a Sun Microsystems, Inc. business.
  * Permission to use, copy, modify, and distribute this
  * software is freely granted, provided that this notice
  * is preserved.
  * ====================================================
  */
 
 #ifndef lint
 static char rcsid[] = "$FreeBSD$";
 #endif
 
 #include "math.h"
 #include "math_private.h"
 
 #ifdef USE_BUILTIN_SQRTF
 float
-__ieee754_sqrtf(float x)
+sqrtf(float x)
 {
 	return (__builtin_sqrtf(x));
 }
 #else
 static	const float	one	= 1.0, tiny=1.0e-30;
 
 float
-__ieee754_sqrtf(float x)
+sqrtf(float x)
 {
 	float z;
 	int32_t sign = (int)0x80000000;
 	int32_t ix,s,q,m,t,i;
 	u_int32_t r;
 
 	GET_FLOAT_WORD(ix,x);
 
     /* take care of Inf and NaN */
 	if((ix&0x7f800000)==0x7f800000) {
 	    return x*x+x;		/* sqrt(NaN)=NaN, sqrt(+inf)=+inf
 					   sqrt(-inf)=sNaN */
 	}
     /* take care of zero */
 	if(ix<=0) {
 	    if((ix&(~sign))==0) return x;/* sqrt(+-0) = +-0 */
 	    else if(ix<0)
 		return (x-x)/(x-x);		/* sqrt(-ve) = sNaN */
 	}
     /* normalize x */
 	m = (ix>>23);
 	if(m==0) {				/* subnormal x */
 	    for(i=0;(ix&0x00800000)==0;i++) ix<<=1;
 	    m -= i-1;
 	}
 	m -= 127;	/* unbias exponent */
 	ix = (ix&0x007fffff)|0x00800000;
 	if(m&1)	/* odd m, double x to make it even */
 	    ix += ix;
 	m >>= 1;	/* m = [m/2] */
 
     /* generate sqrt(x) bit by bit */
 	ix += ix;
 	q = s = 0;		/* q = sqrt(x) */
 	r = 0x01000000;		/* r = moving bit from right to left */
 
 	while(r!=0) {
 	    t = s+r;
 	    if(t<=ix) {
 		s    = t+r;
 		ix  -= t;
 		q   += r;
 	    }
 	    ix += ix;
 	    r>>=1;
 	}
 
     /* use floating add to find out rounding direction */
 	if(ix!=0) {
 	    z = one-tiny; /* trigger inexact flag */
 	    if (z>=one) {
 	        z = one+tiny;
 		if (z>one)
 		    q += 2;
 		else
 		    q += (q&1);
 	    }
 	}
 	ix = (q>>1)+0x3f000000;
 	ix += (m <<23);
 	SET_FLOAT_WORD(z,ix);
 	return z;
 }
 #endif
diff --git a/lib/msun/src/math_private.h b/lib/msun/src/math_private.h
index 20ce7bd88464..a7467d75166c 100644
--- a/lib/msun/src/math_private.h
+++ b/lib/msun/src/math_private.h
@@ -1,924 +1,863 @@
 /*
  * ====================================================
  * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
  *
  * Developed at SunPro, a Sun Microsystems, Inc. business.
  * Permission to use, copy, modify, and distribute this
  * software is freely granted, provided that this notice
  * is preserved.
  * ====================================================
  */
 
 /*
  * from: @(#)fdlibm.h 5.1 93/09/24
  * $FreeBSD$
  */
 
 #ifndef _MATH_PRIVATE_H_
 #define	_MATH_PRIVATE_H_
 
 #include <sys/types.h>
 #include <machine/endian.h>
 
 /*
  * The original fdlibm code used statements like:
  *	n0 = ((*(int*)&one)>>29)^1;		* index of high word *
  *	ix0 = *(n0+(int*)&x);			* high word of x *
  *	ix1 = *((1-n0)+(int*)&x);		* low word of x *
  * to dig two 32 bit words out of the 64 bit IEEE floating point
  * value.  That is non-ANSI, and, moreover, the gcc instruction
  * scheduler gets it wrong.  We instead use the following macros.
  * Unlike the original code, we determine the endianness at compile
  * time, not at run time; I don't see much benefit to selecting
  * endianness at run time.
  */
 
 /*
  * A union which permits us to convert between a double and two 32 bit
  * ints.
  */
 
 #ifdef __arm__
 #if defined(__VFP_FP__) || defined(__ARM_EABI__)
 #define	IEEE_WORD_ORDER	BYTE_ORDER
 #else
 #define	IEEE_WORD_ORDER	BIG_ENDIAN
 #endif
 #else /* __arm__ */
 #define	IEEE_WORD_ORDER	BYTE_ORDER
 #endif
 
 /* A union which permits us to convert between a long double and
    four 32 bit ints.  */
 
 #if IEEE_WORD_ORDER == BIG_ENDIAN
 
 typedef union
 {
   long double value;
   struct {
     u_int32_t mswhi;
     u_int32_t mswlo;
     u_int32_t lswhi;
     u_int32_t lswlo;
   } parts32;
   struct {
     u_int64_t msw;
     u_int64_t lsw;
   } parts64;
 } ieee_quad_shape_type;
 
 #endif
 
 #if IEEE_WORD_ORDER == LITTLE_ENDIAN
 
 typedef union
 {
   long double value;
   struct {
     u_int32_t lswlo;
     u_int32_t lswhi;
     u_int32_t mswlo;
     u_int32_t mswhi;
   } parts32;
   struct {
     u_int64_t lsw;
     u_int64_t msw;
   } parts64;
 } ieee_quad_shape_type;
 
 #endif
 
 #if IEEE_WORD_ORDER == BIG_ENDIAN
 
 typedef union
 {
   double value;
   struct
   {
     u_int32_t msw;
     u_int32_t lsw;
   } parts;
   struct
   {
     u_int64_t w;
   } xparts;
 } ieee_double_shape_type;
 
 #endif
 
 #if IEEE_WORD_ORDER == LITTLE_ENDIAN
 
 typedef union
 {
   double value;
   struct
   {
     u_int32_t lsw;
     u_int32_t msw;
   } parts;
   struct
   {
     u_int64_t w;
   } xparts;
 } ieee_double_shape_type;
 
 #endif
 
 /* Get two 32 bit ints from a double.  */
 
 #define EXTRACT_WORDS(ix0,ix1,d)				\
 do {								\
   ieee_double_shape_type ew_u;					\
   ew_u.value = (d);						\
   (ix0) = ew_u.parts.msw;					\
   (ix1) = ew_u.parts.lsw;					\
 } while (0)
 
 /* Get a 64-bit int from a double. */
 #define EXTRACT_WORD64(ix,d)					\
 do {								\
   ieee_double_shape_type ew_u;					\
   ew_u.value = (d);						\
   (ix) = ew_u.xparts.w;						\
 } while (0)
 
 /* Get the more significant 32 bit int from a double.  */
 
 #define GET_HIGH_WORD(i,d)					\
 do {								\
   ieee_double_shape_type gh_u;					\
   gh_u.value = (d);						\
   (i) = gh_u.parts.msw;						\
 } while (0)
 
 /* Get the less significant 32 bit int from a double.  */
 
 #define GET_LOW_WORD(i,d)					\
 do {								\
   ieee_double_shape_type gl_u;					\
   gl_u.value = (d);						\
   (i) = gl_u.parts.lsw;						\
 } while (0)
 
 /* Set a double from two 32 bit ints.  */
 
 #define INSERT_WORDS(d,ix0,ix1)					\
 do {								\
   ieee_double_shape_type iw_u;					\
   iw_u.parts.msw = (ix0);					\
   iw_u.parts.lsw = (ix1);					\
   (d) = iw_u.value;						\
 } while (0)
 
 /* Set a double from a 64-bit int. */
 #define INSERT_WORD64(d,ix)					\
 do {								\
   ieee_double_shape_type iw_u;					\
   iw_u.xparts.w = (ix);						\
   (d) = iw_u.value;						\
 } while (0)
 
 /* Set the more significant 32 bits of a double from an int.  */
 
 #define SET_HIGH_WORD(d,v)					\
 do {								\
   ieee_double_shape_type sh_u;					\
   sh_u.value = (d);						\
   sh_u.parts.msw = (v);						\
   (d) = sh_u.value;						\
 } while (0)
 
 /* Set the less significant 32 bits of a double from an int.  */
 
 #define SET_LOW_WORD(d,v)					\
 do {								\
   ieee_double_shape_type sl_u;					\
   sl_u.value = (d);						\
   sl_u.parts.lsw = (v);						\
   (d) = sl_u.value;						\
 } while (0)
 
 /*
  * A union which permits us to convert between a float and a 32 bit
  * int.
  */
 
 typedef union
 {
   float value;
   /* FIXME: Assumes 32 bit int.  */
   unsigned int word;
 } ieee_float_shape_type;
 
 /* Get a 32 bit int from a float.  */
 
 #define GET_FLOAT_WORD(i,d)					\
 do {								\
   ieee_float_shape_type gf_u;					\
   gf_u.value = (d);						\
   (i) = gf_u.word;						\
 } while (0)
 
 /* Set a float from a 32 bit int.  */
 
 #define SET_FLOAT_WORD(d,i)					\
 do {								\
   ieee_float_shape_type sf_u;					\
   sf_u.word = (i);						\
   (d) = sf_u.value;						\
 } while (0)
 
 /*
  * Get expsign and mantissa as 16 bit and 64 bit ints from an 80 bit long
  * double.
  */
 
 #define	EXTRACT_LDBL80_WORDS(ix0,ix1,d)				\
 do {								\
   union IEEEl2bits ew_u;					\
   ew_u.e = (d);							\
   (ix0) = ew_u.xbits.expsign;					\
   (ix1) = ew_u.xbits.man;					\
 } while (0)
 
 /*
  * Get expsign and mantissa as one 16 bit and two 64 bit ints from a 128 bit
  * long double.
  */
 
 #define	EXTRACT_LDBL128_WORDS(ix0,ix1,ix2,d)			\
 do {								\
   union IEEEl2bits ew_u;					\
   ew_u.e = (d);							\
   (ix0) = ew_u.xbits.expsign;					\
   (ix1) = ew_u.xbits.manh;					\
   (ix2) = ew_u.xbits.manl;					\
 } while (0)
 
 /* Get expsign as a 16 bit int from a long double.  */
 
 #define	GET_LDBL_EXPSIGN(i,d)					\
 do {								\
   union IEEEl2bits ge_u;					\
   ge_u.e = (d);							\
   (i) = ge_u.xbits.expsign;					\
 } while (0)
 
 /*
  * Set an 80 bit long double from a 16 bit int expsign and a 64 bit int
  * mantissa.
  */
 
 #define	INSERT_LDBL80_WORDS(d,ix0,ix1)				\
 do {								\
   union IEEEl2bits iw_u;					\
   iw_u.xbits.expsign = (ix0);					\
   iw_u.xbits.man = (ix1);					\
   (d) = iw_u.e;							\
 } while (0)
 
 /*
  * Set a 128 bit long double from a 16 bit int expsign and two 64 bit ints
  * comprising the mantissa.
  */
 
 #define	INSERT_LDBL128_WORDS(d,ix0,ix1,ix2)			\
 do {								\
   union IEEEl2bits iw_u;					\
   iw_u.xbits.expsign = (ix0);					\
   iw_u.xbits.manh = (ix1);					\
   iw_u.xbits.manl = (ix2);					\
   (d) = iw_u.e;							\
 } while (0)
 
 /* Set expsign of a long double from a 16 bit int.  */
 
 #define	SET_LDBL_EXPSIGN(d,v)					\
 do {								\
   union IEEEl2bits se_u;					\
   se_u.e = (d);							\
   se_u.xbits.expsign = (v);					\
   (d) = se_u.e;							\
 } while (0)
 
 #ifdef __i386__
 /* Long double constants are broken on i386. */
 #define	LD80C(m, ex, v) {						\
 	.xbits.man = __CONCAT(m, ULL),					\
 	.xbits.expsign = (0x3fff + (ex)) | ((v) < 0 ? 0x8000 : 0),	\
 }
 #else
 /* The above works on non-i386 too, but we use this to check v. */
 #define	LD80C(m, ex, v)	{ .e = (v), }
 #endif
 
 #ifdef FLT_EVAL_METHOD
 /*
  * Attempt to get strict C99 semantics for assignment with non-C99 compilers.
  */
 #if FLT_EVAL_METHOD == 0 || __GNUC__ == 0
 #define	STRICT_ASSIGN(type, lval, rval)	((lval) = (rval))
 #else
 #define	STRICT_ASSIGN(type, lval, rval) do {	\
 	volatile type __lval;			\
 						\
 	if (sizeof(type) >= sizeof(long double))	\
 		(lval) = (rval);		\
 	else {					\
 		__lval = (rval);		\
 		(lval) = __lval;		\
 	}					\
 } while (0)
 #endif
 #endif /* FLT_EVAL_METHOD */
 
 /* Support switching the mode to FP_PE if necessary. */
 #if defined(__i386__) && !defined(NO_FPSETPREC)
 #define	ENTERI() ENTERIT(long double)
 #define	ENTERIT(returntype)			\
 	returntype __retval;			\
 	fp_prec_t __oprec;			\
 						\
 	if ((__oprec = fpgetprec()) != FP_PE)	\
 		fpsetprec(FP_PE)
 #define	RETURNI(x) do {				\
 	__retval = (x);				\
 	if (__oprec != FP_PE)			\
 		fpsetprec(__oprec);		\
 	RETURNF(__retval);			\
 } while (0)
 #define	ENTERV()				\
 	fp_prec_t __oprec;			\
 						\
 	if ((__oprec = fpgetprec()) != FP_PE)	\
 		fpsetprec(FP_PE)
 #define	RETURNV() do {				\
 	if (__oprec != FP_PE)			\
 		fpsetprec(__oprec);		\
 	return;			\
 } while (0)
 #else
 #define	ENTERI()
 #define	ENTERIT(x)
 #define	RETURNI(x)	RETURNF(x)
 #define	ENTERV()
 #define	RETURNV()	return
 #endif
 
 /* Default return statement if hack*_t() is not used. */
 #define      RETURNF(v)      return (v)
 
 /*
  * 2sum gives the same result as 2sumF without requiring |a| >= |b| or
  * a == 0, but is slower.
  */
 #define	_2sum(a, b) do {	\
 	__typeof(a) __s, __w;	\
 				\
 	__w = (a) + (b);	\
 	__s = __w - (a);	\
 	(b) = ((a) - (__w - __s)) + ((b) - __s); \
 	(a) = __w;		\
 } while (0)
 
 /*
  * 2sumF algorithm.
  *
  * "Normalize" the terms in the infinite-precision expression a + b for
  * the sum of 2 floating point values so that b is as small as possible
  * relative to 'a'.  (The resulting 'a' is the value of the expression in
  * the same precision as 'a' and the resulting b is the rounding error.)
  * |a| must be >= |b| or 0, b's type must be no larger than 'a's type, and
  * exponent overflow or underflow must not occur.  This uses a Theorem of
  * Dekker (1971).  See Knuth (1981) 4.2.2 Theorem C.  The name "TwoSum"
  * is apparently due to Skewchuk (1997).
  *
  * For this to always work, assignment of a + b to 'a' must not retain any
  * extra precision in a + b.  This is required by C standards but broken
  * in many compilers.  The brokenness cannot be worked around using
  * STRICT_ASSIGN() like we do elsewhere, since the efficiency of this
  * algorithm would be destroyed by non-null strict assignments.  (The
  * compilers are correct to be broken -- the efficiency of all floating
  * point code calculations would be destroyed similarly if they forced the
  * conversions.)
  *
  * Fortunately, a case that works well can usually be arranged by building
  * any extra precision into the type of 'a' -- 'a' should have type float_t,
  * double_t or long double.  b's type should be no larger than 'a's type.
  * Callers should use these types with scopes as large as possible, to
  * reduce their own extra-precision and efficiciency problems.  In
  * particular, they shouldn't convert back and forth just to call here.
  */
 #ifdef DEBUG
 #define	_2sumF(a, b) do {				\
 	__typeof(a) __w;				\
 	volatile __typeof(a) __ia, __ib, __r, __vw;	\
 							\
 	__ia = (a);					\
 	__ib = (b);					\
 	assert(__ia == 0 || fabsl(__ia) >= fabsl(__ib));	\
 							\
 	__w = (a) + (b);				\
 	(b) = ((a) - __w) + (b);			\
 	(a) = __w;					\
 							\
 	/* The next 2 assertions are weak if (a) is already long double. */ \
 	assert((long double)__ia + __ib == (long double)(a) + (b));	\
 	__vw = __ia + __ib;				\
 	__r = __ia - __vw;				\
 	__r += __ib;					\
 	assert(__vw == (a) && __r == (b));		\
 } while (0)
 #else /* !DEBUG */
 #define	_2sumF(a, b) do {	\
 	__typeof(a) __w;	\
 				\
 	__w = (a) + (b);	\
 	(b) = ((a) - __w) + (b); \
 	(a) = __w;		\
 } while (0)
 #endif /* DEBUG */
 
 /*
  * Set x += c, where x is represented in extra precision as a + b.
  * x must be sufficiently normalized and sufficiently larger than c,
  * and the result is then sufficiently normalized.
  *
  * The details of ordering are that |a| must be >= |c| (so that (a, c)
  * can be normalized without extra work to swap 'a' with c).  The details of
  * the normalization are that b must be small relative to the normalized 'a'.
  * Normalization of (a, c) makes the normalized c tiny relative to the
  * normalized a, so b remains small relative to 'a' in the result.  However,
  * b need not ever be tiny relative to 'a'.  For example, b might be about
  * 2**20 times smaller than 'a' to give about 20 extra bits of precision.
  * That is usually enough, and adding c (which by normalization is about
  * 2**53 times smaller than a) cannot change b significantly.  However,
  * cancellation of 'a' with c in normalization of (a, c) may reduce 'a'
  * significantly relative to b.  The caller must ensure that significant
  * cancellation doesn't occur, either by having c of the same sign as 'a',
  * or by having |c| a few percent smaller than |a|.  Pre-normalization of
  * (a, b) may help.
  *
  * This is a variant of an algorithm of Kahan (see Knuth (1981) 4.2.2
  * exercise 19).  We gain considerable efficiency by requiring the terms to
  * be sufficiently normalized and sufficiently increasing.
  */
 #define	_3sumF(a, b, c) do {	\
 	__typeof(a) __tmp;	\
 				\
 	__tmp = (c);		\
 	_2sumF(__tmp, (a));	\
 	(b) += (a);		\
 	(a) = __tmp;		\
 } while (0)
 
 /*
  * Common routine to process the arguments to nan(), nanf(), and nanl().
  */
 void _scan_nan(uint32_t *__words, int __num_words, const char *__s);
 
 /*
  * Mix 0, 1 or 2 NaNs.  First add 0 to each arg.  This normally just turns
  * signaling NaNs into quiet NaNs by setting a quiet bit.  We do this
  * because we want to never return a signaling NaN, and also because we
  * don't want the quiet bit to affect the result.  Then mix the converted
  * args using the specified operation.
  *
  * When one arg is NaN, the result is typically that arg quieted.  When both
  * args are NaNs, the result is typically the quietening of the arg whose
  * mantissa is largest after quietening.  When neither arg is NaN, the
  * result may be NaN because it is indeterminate, or finite for subsequent
  * construction of a NaN as the indeterminate 0.0L/0.0L.
  *
  * Technical complications: the result in bits after rounding to the final
  * precision might depend on the runtime precision and/or on compiler
  * optimizations, especially when different register sets are used for
  * different precisions.  Try to make the result not depend on at least the
  * runtime precision by always doing the main mixing step in long double
  * precision.  Try to reduce dependencies on optimizations by adding the
  * the 0's in different precisions (unless everything is in long double
  * precision).
  */
 #define	nan_mix(x, y)		(nan_mix_op((x), (y), +))
 #define	nan_mix_op(x, y, op)	(((x) + 0.0L) op ((y) + 0))
 
 #ifdef _COMPLEX_H
 
 /*
  * C99 specifies that complex numbers have the same representation as
  * an array of two elements, where the first element is the real part
  * and the second element is the imaginary part.
  */
 typedef union {
 	float complex f;
 	float a[2];
 } float_complex;
 typedef union {
 	double complex f;
 	double a[2];
 } double_complex;
 typedef union {
 	long double complex f;
 	long double a[2];
 } long_double_complex;
 #define	REALPART(z)	((z).a[0])
 #define	IMAGPART(z)	((z).a[1])
 
 /*
  * Inline functions that can be used to construct complex values.
  *
  * The C99 standard intends x+I*y to be used for this, but x+I*y is
  * currently unusable in general since gcc introduces many overflow,
  * underflow, sign and efficiency bugs by rewriting I*y as
  * (0.0+I)*(y+0.0*I) and laboriously computing the full complex product.
  * In particular, I*Inf is corrupted to NaN+I*Inf, and I*-0 is corrupted
  * to -0.0+I*0.0.
  *
  * The C11 standard introduced the macros CMPLX(), CMPLXF() and CMPLXL()
  * to construct complex values.  Compilers that conform to the C99
  * standard require the following functions to avoid the above issues.
  */
 
 #ifndef CMPLXF
 static __inline float complex
 CMPLXF(float x, float y)
 {
 	float_complex z;
 
 	REALPART(z) = x;
 	IMAGPART(z) = y;
 	return (z.f);
 }
 #endif
 
 #ifndef CMPLX
 static __inline double complex
 CMPLX(double x, double y)
 {
 	double_complex z;
 
 	REALPART(z) = x;
 	IMAGPART(z) = y;
 	return (z.f);
 }
 #endif
 
 #ifndef CMPLXL
 static __inline long double complex
 CMPLXL(long double x, long double y)
 {
 	long_double_complex z;
 
 	REALPART(z) = x;
 	IMAGPART(z) = y;
 	return (z.f);
 }
 #endif
 
 #endif /* _COMPLEX_H */
  
 /*
  * The rnint() family rounds to the nearest integer for a restricted range
  * range of args (up to about 2**MANT_DIG).  We assume that the current
  * rounding mode is FE_TONEAREST so that this can be done efficiently.
  * Extra precision causes more problems in practice, and we only centralize
  * this here to reduce those problems, and have not solved the efficiency
  * problems.  The exp2() family uses a more delicate version of this that
  * requires extracting bits from the intermediate value, so it is not
  * centralized here and should copy any solution of the efficiency problems.
  */
 
 static inline double
 rnint(__double_t x)
 {
 	/*
 	 * This casts to double to kill any extra precision.  This depends
 	 * on the cast being applied to a double_t to avoid compiler bugs
 	 * (this is a cleaner version of STRICT_ASSIGN()).  This is
 	 * inefficient if there actually is extra precision, but is hard
 	 * to improve on.  We use double_t in the API to minimise conversions
 	 * for just calling here.  Note that we cannot easily change the
 	 * magic number to the one that works directly with double_t, since
 	 * the rounding precision is variable at runtime on x86 so the
 	 * magic number would need to be variable.  Assuming that the
 	 * rounding precision is always the default is too fragile.  This
 	 * and many other complications will move when the default is
 	 * changed to FP_PE.
 	 */
 	return ((double)(x + 0x1.8p52) - 0x1.8p52);
 }
 
 static inline float
 rnintf(__float_t x)
 {
 	/*
 	 * As for rnint(), except we could just call that to handle the
 	 * extra precision case, usually without losing efficiency.
 	 */
 	return ((float)(x + 0x1.8p23F) - 0x1.8p23F);
 }
 
 #ifdef LDBL_MANT_DIG
 /*
  * The complications for extra precision are smaller for rnintl() since it
  * can safely assume that the rounding precision has been increased from
  * its default to FP_PE on x86.  We don't exploit that here to get small
  * optimizations from limiting the rangle to double.  We just need it for
  * the magic number to work with long doubles.  ld128 callers should use
  * rnint() instead of this if possible.  ld80 callers should prefer
  * rnintl() since for amd64 this avoids swapping the register set, while
  * for i386 it makes no difference (assuming FP_PE), and for other arches
  * it makes little difference.
  */
 static inline long double
 rnintl(long double x)
 {
 	return (x + __CONCAT(0x1.8p, LDBL_MANT_DIG) / 2 -
 	    __CONCAT(0x1.8p, LDBL_MANT_DIG) / 2);
 }
 #endif /* LDBL_MANT_DIG */
 
 /*
  * irint() and i64rint() give the same result as casting to their integer
  * return type provided their arg is a floating point integer.  They can
  * sometimes be more efficient because no rounding is required.
  */
 #if (defined(amd64) || defined(__i386__)) && defined(__GNUCLIKE_ASM)
 #define	irint(x)						\
     (sizeof(x) == sizeof(float) &&				\
     sizeof(__float_t) == sizeof(long double) ? irintf(x) :	\
     sizeof(x) == sizeof(double) &&				\
     sizeof(__double_t) == sizeof(long double) ? irintd(x) :	\
     sizeof(x) == sizeof(long double) ? irintl(x) : (int)(x))
 #else
 #define	irint(x)	((int)(x))
 #endif
 
 #define	i64rint(x)	((int64_t)(x))	/* only needed for ld128 so not opt. */
 
 #if defined(__i386__) && defined(__GNUCLIKE_ASM)
 static __inline int
 irintf(float x)
 {
 	int n;
 
 	__asm("fistl %0" : "=m" (n) : "t" (x));
 	return (n);
 }
 
 static __inline int
 irintd(double x)
 {
 	int n;
 
 	__asm("fistl %0" : "=m" (n) : "t" (x));
 	return (n);
 }
 #endif
 
 #if (defined(__amd64__) || defined(__i386__)) && defined(__GNUCLIKE_ASM)
 static __inline int
 irintl(long double x)
 {
 	int n;
 
 	__asm("fistl %0" : "=m" (n) : "t" (x));
 	return (n);
 }
 #endif
 
 #ifdef DEBUG
 #if defined(__amd64__) || defined(__i386__)
 #define	breakpoint()	asm("int $3")
 #else
 #include <signal.h>
 
 #define	breakpoint()	raise(SIGTRAP)
 #endif
 #endif
 
 /* Write a pari script to test things externally. */
 #ifdef DOPRINT
 #include <stdio.h>
 
 #ifndef DOPRINT_SWIZZLE
 #define	DOPRINT_SWIZZLE		0
 #endif
 
 #ifdef DOPRINT_LD80
 
 #define	DOPRINT_START(xp) do {						\
 	uint64_t __lx;							\
 	uint16_t __hx;							\
 									\
 	/* Hack to give more-problematic args. */			\
 	EXTRACT_LDBL80_WORDS(__hx, __lx, *xp);				\
 	__lx ^= DOPRINT_SWIZZLE;					\
 	INSERT_LDBL80_WORDS(*xp, __hx, __lx);				\
 	printf("x = %.21Lg; ", (long double)*xp);			\
 } while (0)
 #define	DOPRINT_END1(v)							\
 	printf("y = %.21Lg; z = 0; show(x, y, z);\n", (long double)(v))
 #define	DOPRINT_END2(hi, lo)						\
 	printf("y = %.21Lg; z = %.21Lg; show(x, y, z);\n",		\
 	    (long double)(hi), (long double)(lo))
 
 #elif defined(DOPRINT_D64)
 
 #define	DOPRINT_START(xp) do {						\
 	uint32_t __hx, __lx;						\
 									\
 	EXTRACT_WORDS(__hx, __lx, *xp);					\
 	__lx ^= DOPRINT_SWIZZLE;					\
 	INSERT_WORDS(*xp, __hx, __lx);					\
 	printf("x = %.21Lg; ", (long double)*xp);			\
 } while (0)
 #define	DOPRINT_END1(v)							\
 	printf("y = %.21Lg; z = 0; show(x, y, z);\n", (long double)(v))
 #define	DOPRINT_END2(hi, lo)						\
 	printf("y = %.21Lg; z = %.21Lg; show(x, y, z);\n",		\
 	    (long double)(hi), (long double)(lo))
 
 #elif defined(DOPRINT_F32)
 
 #define	DOPRINT_START(xp) do {						\
 	uint32_t __hx;							\
 									\
 	GET_FLOAT_WORD(__hx, *xp);					\
 	__hx ^= DOPRINT_SWIZZLE;					\
 	SET_FLOAT_WORD(*xp, __hx);					\
 	printf("x = %.21Lg; ", (long double)*xp);			\
 } while (0)
 #define	DOPRINT_END1(v)							\
 	printf("y = %.21Lg; z = 0; show(x, y, z);\n", (long double)(v))
 #define	DOPRINT_END2(hi, lo)						\
 	printf("y = %.21Lg; z = %.21Lg; show(x, y, z);\n",		\
 	    (long double)(hi), (long double)(lo))
 
 #else /* !DOPRINT_LD80 && !DOPRINT_D64 (LD128 only) */
 
 #ifndef DOPRINT_SWIZZLE_HIGH
 #define	DOPRINT_SWIZZLE_HIGH	0
 #endif
 
 #define	DOPRINT_START(xp) do {						\
 	uint64_t __lx, __llx;						\
 	uint16_t __hx;							\
 									\
 	EXTRACT_LDBL128_WORDS(__hx, __lx, __llx, *xp);			\
 	__llx ^= DOPRINT_SWIZZLE;					\
 	__lx ^= DOPRINT_SWIZZLE_HIGH;					\
 	INSERT_LDBL128_WORDS(*xp, __hx, __lx, __llx);			\
 	printf("x = %.36Lg; ", (long double)*xp);					\
 } while (0)
 #define	DOPRINT_END1(v)							\
 	printf("y = %.36Lg; z = 0; show(x, y, z);\n", (long double)(v))
 #define	DOPRINT_END2(hi, lo)						\
 	printf("y = %.36Lg; z = %.36Lg; show(x, y, z);\n",		\
 	    (long double)(hi), (long double)(lo))
 
 #endif /* DOPRINT_LD80 */
 
 #else /* !DOPRINT */
 #define	DOPRINT_START(xp)
 #define	DOPRINT_END1(v)
 #define	DOPRINT_END2(hi, lo)
 #endif /* DOPRINT */
 
 #define	RETURNP(x) do {			\
 	DOPRINT_END1(x);		\
 	RETURNF(x);			\
 } while (0)
 #define	RETURNPI(x) do {		\
 	DOPRINT_END1(x);		\
 	RETURNI(x);			\
 } while (0)
 #define	RETURN2P(x, y) do {		\
 	DOPRINT_END2((x), (y));		\
 	RETURNF((x) + (y));		\
 } while (0)
 #define	RETURN2PI(x, y) do {		\
 	DOPRINT_END2((x), (y));		\
 	RETURNI((x) + (y));		\
 } while (0)
 #ifdef STRUCT_RETURN
 #define	RETURNSP(rp) do {		\
 	if (!(rp)->lo_set)		\
 		RETURNP((rp)->hi);	\
 	RETURN2P((rp)->hi, (rp)->lo);	\
 } while (0)
 #define	RETURNSPI(rp) do {		\
 	if (!(rp)->lo_set)		\
 		RETURNPI((rp)->hi);	\
 	RETURN2PI((rp)->hi, (rp)->lo);	\
 } while (0)
 #endif
 #define	SUM2P(x, y) ({			\
 	const __typeof (x) __x = (x);	\
 	const __typeof (y) __y = (y);	\
 					\
 	DOPRINT_END2(__x, __y);		\
 	__x + __y;			\
 })
 
-/*
- * ieee style elementary functions
- *
- * We rename functions here to improve other sources' diffability
- * against fdlibm.
- */
-#define	__ieee754_sqrt	sqrt
-#define	__ieee754_acos	acos
-#define	__ieee754_acosh	acosh
-#define	__ieee754_log	log
-#define	__ieee754_log2	log2
-#define	__ieee754_atanh	atanh
-#define	__ieee754_asin	asin
-#define	__ieee754_atan2	atan2
-#define	__ieee754_exp	exp
-#define	__ieee754_cosh	cosh
-#define	__ieee754_fmod	fmod
-#define	__ieee754_pow	pow
-#define	__ieee754_lgamma lgamma
-#define	__ieee754_gamma	gamma
-#define	__ieee754_lgamma_r lgamma_r
-#define	__ieee754_gamma_r gamma_r
-#define	__ieee754_log10	log10
-#define	__ieee754_sinh	sinh
-#define	__ieee754_hypot	hypot
-#define	__ieee754_j0	j0
-#define	__ieee754_j1	j1
-#define	__ieee754_y0	y0
-#define	__ieee754_y1	y1
-#define	__ieee754_jn	jn
-#define	__ieee754_yn	yn
-#define	__ieee754_remainder remainder
-#define	__ieee754_scalb	scalb
-#define	__ieee754_sqrtf	sqrtf
-#define	__ieee754_acosf	acosf
-#define	__ieee754_acoshf acoshf
-#define	__ieee754_logf	logf
-#define	__ieee754_atanhf atanhf
-#define	__ieee754_asinf	asinf
-#define	__ieee754_atan2f atan2f
-#define	__ieee754_expf	expf
-#define	__ieee754_coshf	coshf
-#define	__ieee754_fmodf	fmodf
-#define	__ieee754_powf	powf
-#define	__ieee754_lgammaf lgammaf
-#define	__ieee754_gammaf gammaf
-#define	__ieee754_lgammaf_r lgammaf_r
-#define	__ieee754_gammaf_r gammaf_r
-#define	__ieee754_log10f log10f
-#define	__ieee754_log2f log2f
-#define	__ieee754_sinhf	sinhf
-#define	__ieee754_hypotf hypotf
-#define	__ieee754_j0f	j0f
-#define	__ieee754_j1f	j1f
-#define	__ieee754_y0f	y0f
-#define	__ieee754_y1f	y1f
-#define	__ieee754_jnf	jnf
-#define	__ieee754_ynf	ynf
-#define	__ieee754_remainderf remainderf
-#define	__ieee754_scalbf scalbf
-
 /* fdlibm kernel function */
 int	__kernel_rem_pio2(double*,double*,int,int,int);
 
 /* double precision kernel functions */
 #ifndef INLINE_REM_PIO2
 int	__ieee754_rem_pio2(double,double*);
 #endif
 double	__kernel_sin(double,double,int);
 double	__kernel_cos(double,double);
 double	__kernel_tan(double,double,int);
 double	__ldexp_exp(double,int);
 #ifdef _COMPLEX_H
 double complex __ldexp_cexp(double complex,int);
 #endif
 
 /* float precision kernel functions */
 #ifndef INLINE_REM_PIO2F
 int	__ieee754_rem_pio2f(float,double*);
 #endif
 #ifndef INLINE_KERNEL_SINDF
 float	__kernel_sindf(double);
 #endif
 #ifndef INLINE_KERNEL_COSDF
 float	__kernel_cosdf(double);
 #endif
 #ifndef INLINE_KERNEL_TANDF
 float	__kernel_tandf(double,int);
 #endif
 float	__ldexp_expf(float,int);
 #ifdef _COMPLEX_H
 float complex __ldexp_cexpf(float complex,int);
 #endif
 
 /* long double precision kernel functions */
 long double __kernel_sinl(long double, long double, int);
 long double __kernel_cosl(long double, long double);
 long double __kernel_tanl(long double, long double, int);
 
 #endif /* !_MATH_PRIVATE_H_ */
diff --git a/lib/msun/src/s_asinh.c b/lib/msun/src/s_asinh.c
index cbb3d463a30f..a1b9169bef99 100644
--- a/lib/msun/src/s_asinh.c
+++ b/lib/msun/src/s_asinh.c
@@ -1,62 +1,62 @@
 /* @(#)s_asinh.c 5.1 93/09/24 */
 /*
  * ====================================================
  * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
  *
  * Developed at SunPro, a Sun Microsystems, Inc. business.
  * Permission to use, copy, modify, and distribute this
  * software is freely granted, provided that this notice
  * is preserved.
  * ====================================================
  */
 
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
 /* asinh(x)
  * Method :
  *	Based on
  *		asinh(x) = sign(x) * log [ |x| + sqrt(x*x+1) ]
  *	we have
  *	asinh(x) := x  if  1+x*x=1,
  *		 := sign(x)*(log(x)+ln2)) for large |x|, else
  *		 := sign(x)*log(2|x|+1/(|x|+sqrt(x*x+1))) if|x|>2, else
  *		 := sign(x)*log1p(|x| + x^2/(1 + sqrt(1+x^2)))
  */
 
 #include <float.h>
 
 #include "math.h"
 #include "math_private.h"
 
 static const double
 one =  1.00000000000000000000e+00, /* 0x3FF00000, 0x00000000 */
 ln2 =  6.93147180559945286227e-01, /* 0x3FE62E42, 0xFEFA39EF */
 huge=  1.00000000000000000000e+300;
 
 double
 asinh(double x)
 {
 	double t,w;
 	int32_t hx,ix;
 	GET_HIGH_WORD(hx,x);
 	ix = hx&0x7fffffff;
 	if(ix>=0x7ff00000) return x+x;	/* x is inf or NaN */
 	if(ix< 0x3e300000) {	/* |x|<2**-28 */
 	    if(huge+x>one) return x;	/* return x inexact except 0 */
 	}
 	if(ix>0x41b00000) {	/* |x| > 2**28 */
-	    w = __ieee754_log(fabs(x))+ln2;
+	    w = log(fabs(x))+ln2;
 	} else if (ix>0x40000000) {	/* 2**28 > |x| > 2.0 */
 	    t = fabs(x);
-	    w = __ieee754_log(2.0*t+one/(__ieee754_sqrt(x*x+one)+t));
+	    w = log(2.0*t+one/(sqrt(x*x+one)+t));
 	} else {		/* 2.0 > |x| > 2**-28 */
 	    t = x*x;
-	    w =log1p(fabs(x)+t/(one+__ieee754_sqrt(one+t)));
+	    w =log1p(fabs(x)+t/(one+sqrt(one+t)));
 	}
 	if(hx>0) return w; else return -w;
 }
 
 #if LDBL_MANT_DIG == 53
 __weak_reference(asinh, asinhl);
 #endif
diff --git a/lib/msun/src/s_asinhf.c b/lib/msun/src/s_asinhf.c
index c1620dd58fa2..72bcefed9343 100644
--- a/lib/msun/src/s_asinhf.c
+++ b/lib/msun/src/s_asinhf.c
@@ -1,48 +1,48 @@
 /* s_asinhf.c -- float version of s_asinh.c.
  * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
  */
 
 /*
  * ====================================================
  * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
  *
  * Developed at SunPro, a Sun Microsystems, Inc. business.
  * Permission to use, copy, modify, and distribute this
  * software is freely granted, provided that this notice
  * is preserved.
  * ====================================================
  */
 
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
 #include "math.h"
 #include "math_private.h"
 
 static const float
 one =  1.0000000000e+00, /* 0x3F800000 */
 ln2 =  6.9314718246e-01, /* 0x3f317218 */
 huge=  1.0000000000e+30;
 
 float
 asinhf(float x)
 {
 	float t,w;
 	int32_t hx,ix;
 	GET_FLOAT_WORD(hx,x);
 	ix = hx&0x7fffffff;
 	if(ix>=0x7f800000) return x+x;	/* x is inf or NaN */
 	if(ix< 0x31800000) {	/* |x|<2**-28 */
 	    if(huge+x>one) return x;	/* return x inexact except 0 */
 	}
 	if(ix>0x4d800000) {	/* |x| > 2**28 */
-	    w = __ieee754_logf(fabsf(x))+ln2;
+	    w = logf(fabsf(x))+ln2;
 	} else if (ix>0x40000000) {	/* 2**28 > |x| > 2.0 */
 	    t = fabsf(x);
-	    w = __ieee754_logf((float)2.0*t+one/(__ieee754_sqrtf(x*x+one)+t));
+	    w = logf((float)2.0*t+one/(sqrtf(x*x+one)+t));
 	} else {		/* 2.0 > |x| > 2**-28 */
 	    t = x*x;
-	    w =log1pf(fabsf(x)+t/(one+__ieee754_sqrtf(one+t)));
+	    w =log1pf(fabsf(x)+t/(one+sqrtf(one+t)));
 	}
 	if(hx>0) return w; else return -w;
 }
diff --git a/lib/msun/src/s_erf.c b/lib/msun/src/s_erf.c
index 5f228474f422..ab2dc19058bd 100644
--- a/lib/msun/src/s_erf.c
+++ b/lib/msun/src/s_erf.c
@@ -1,309 +1,309 @@
 /* @(#)s_erf.c 5.1 93/09/24 */
 /*
  * ====================================================
  * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
  *
  * Developed at SunPro, a Sun Microsystems, Inc. business.
  * Permission to use, copy, modify, and distribute this
  * software is freely granted, provided that this notice
  * is preserved.
  * ====================================================
  */
 
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
 /* double erf(double x)
  * double erfc(double x)
  *			     x
  *		      2      |\
  *     erf(x)  =  ---------  | exp(-t*t)dt
  *	 	   sqrt(pi) \|
  *			     0
  *
  *     erfc(x) =  1-erf(x)
  *  Note that
  *		erf(-x) = -erf(x)
  *		erfc(-x) = 2 - erfc(x)
  *
  * Method:
  *	1. For |x| in [0, 0.84375]
  *	    erf(x)  = x + x*R(x^2)
  *          erfc(x) = 1 - erf(x)           if x in [-.84375,0.25]
  *                  = 0.5 + ((0.5-x)-x*R)  if x in [0.25,0.84375]
  *	   where R = P/Q where P is an odd poly of degree 8 and
  *	   Q is an odd poly of degree 10.
  *						 -57.90
  *			| R - (erf(x)-x)/x | <= 2
  *
  *
  *	   Remark. The formula is derived by noting
  *          erf(x) = (2/sqrt(pi))*(x - x^3/3 + x^5/10 - x^7/42 + ....)
  *	   and that
  *          2/sqrt(pi) = 1.128379167095512573896158903121545171688
  *	   is close to one. The interval is chosen because the fix
  *	   point of erf(x) is near 0.6174 (i.e., erf(x)=x when x is
  *	   near 0.6174), and by some experiment, 0.84375 is chosen to
  * 	   guarantee the error is less than one ulp for erf.
  *
  *      2. For |x| in [0.84375,1.25], let s = |x| - 1, and
  *         c = 0.84506291151 rounded to single (24 bits)
  *         	erf(x)  = sign(x) * (c  + P1(s)/Q1(s))
  *         	erfc(x) = (1-c)  - P1(s)/Q1(s) if x > 0
  *			  1+(c+P1(s)/Q1(s))    if x < 0
  *         	|P1/Q1 - (erf(|x|)-c)| <= 2**-59.06
  *	   Remark: here we use the taylor series expansion at x=1.
  *		erf(1+s) = erf(1) + s*Poly(s)
  *			 = 0.845.. + P1(s)/Q1(s)
  *	   That is, we use rational approximation to approximate
  *			erf(1+s) - (c = (single)0.84506291151)
  *	   Note that |P1/Q1|< 0.078 for x in [0.84375,1.25]
  *	   where
  *		P1(s) = degree 6 poly in s
  *		Q1(s) = degree 6 poly in s
  *
  *      3. For x in [1.25,1/0.35(~2.857143)],
  *         	erfc(x) = (1/x)*exp(-x*x-0.5625+R1/S1)
  *         	erf(x)  = 1 - erfc(x)
  *	   where
  *		R1(z) = degree 7 poly in z, (z=1/x^2)
  *		S1(z) = degree 8 poly in z
  *
  *      4. For x in [1/0.35,28]
  *         	erfc(x) = (1/x)*exp(-x*x-0.5625+R2/S2) if x > 0
  *			= 2.0 - (1/x)*exp(-x*x-0.5625+R2/S2) if -6<x<0
  *			= 2.0 - tiny		(if x <= -6)
  *         	erf(x)  = sign(x)*(1.0 - erfc(x)) if x < 6, else
  *         	erf(x)  = sign(x)*(1.0 - tiny)
  *	   where
  *		R2(z) = degree 6 poly in z, (z=1/x^2)
  *		S2(z) = degree 7 poly in z
  *
  *      Note1:
  *	   To compute exp(-x*x-0.5625+R/S), let s be a single
  *	   precision number and s := x; then
  *		-x*x = -s*s + (s-x)*(s+x)
  *	        exp(-x*x-0.5626+R/S) =
  *			exp(-s*s-0.5625)*exp((s-x)*(s+x)+R/S);
  *      Note2:
  *	   Here 4 and 5 make use of the asymptotic series
  *			  exp(-x*x)
  *		erfc(x) ~ ---------- * ( 1 + Poly(1/x^2) )
  *			  x*sqrt(pi)
  *	   We use rational approximation to approximate
  *      	g(s)=f(1/x^2) = log(erfc(x)*x) - x*x + 0.5625
  *	   Here is the error bound for R1/S1 and R2/S2
  *      	|R1/S1 - f(x)|  < 2**(-62.57)
  *      	|R2/S2 - f(x)|  < 2**(-61.52)
  *
  *      5. For inf > x >= 28
  *         	erf(x)  = sign(x) *(1 - tiny)  (raise inexact)
  *         	erfc(x) = tiny*tiny (raise underflow) if x > 0
  *			= 2 - tiny if x<0
  *
  *      7. Special case:
  *         	erf(0)  = 0, erf(inf)  = 1, erf(-inf) = -1,
  *         	erfc(0) = 1, erfc(inf) = 0, erfc(-inf) = 2,
  *	   	erfc/erf(NaN) is NaN
  */
 
 #include <float.h>
 #include "math.h"
 #include "math_private.h"
 
 /* XXX Prevent compilers from erroneously constant folding: */
 static const volatile double tiny= 1e-300;
 
 static const double
 half= 0.5,
 one = 1,
 two = 2,
 /* c = (float)0.84506291151 */
 erx =  8.45062911510467529297e-01, /* 0x3FEB0AC1, 0x60000000 */
 /*
  * In the domain [0, 2**-28], only the first term in the power series
  * expansion of erf(x) is used.  The magnitude of the first neglected
  * terms is less than 2**-84.
  */
 efx =  1.28379167095512586316e-01, /* 0x3FC06EBA, 0x8214DB69 */
 efx8=  1.02703333676410069053e+00, /* 0x3FF06EBA, 0x8214DB69 */
 /*
  * Coefficients for approximation to erf on [0,0.84375]
  */
 pp0  =  1.28379167095512558561e-01, /* 0x3FC06EBA, 0x8214DB68 */
 pp1  = -3.25042107247001499370e-01, /* 0xBFD4CD7D, 0x691CB913 */
 pp2  = -2.84817495755985104766e-02, /* 0xBF9D2A51, 0xDBD7194F */
 pp3  = -5.77027029648944159157e-03, /* 0xBF77A291, 0x236668E4 */
 pp4  = -2.37630166566501626084e-05, /* 0xBEF8EAD6, 0x120016AC */
 qq1  =  3.97917223959155352819e-01, /* 0x3FD97779, 0xCDDADC09 */
 qq2  =  6.50222499887672944485e-02, /* 0x3FB0A54C, 0x5536CEBA */
 qq3  =  5.08130628187576562776e-03, /* 0x3F74D022, 0xC4D36B0F */
 qq4  =  1.32494738004321644526e-04, /* 0x3F215DC9, 0x221C1A10 */
 qq5  = -3.96022827877536812320e-06, /* 0xBED09C43, 0x42A26120 */
 /*
  * Coefficients for approximation to erf in [0.84375,1.25]
  */
 pa0  = -2.36211856075265944077e-03, /* 0xBF6359B8, 0xBEF77538 */
 pa1  =  4.14856118683748331666e-01, /* 0x3FDA8D00, 0xAD92B34D */
 pa2  = -3.72207876035701323847e-01, /* 0xBFD7D240, 0xFBB8C3F1 */
 pa3  =  3.18346619901161753674e-01, /* 0x3FD45FCA, 0x805120E4 */
 pa4  = -1.10894694282396677476e-01, /* 0xBFBC6398, 0x3D3E28EC */
 pa5  =  3.54783043256182359371e-02, /* 0x3FA22A36, 0x599795EB */
 pa6  = -2.16637559486879084300e-03, /* 0xBF61BF38, 0x0A96073F */
 qa1  =  1.06420880400844228286e-01, /* 0x3FBB3E66, 0x18EEE323 */
 qa2  =  5.40397917702171048937e-01, /* 0x3FE14AF0, 0x92EB6F33 */
 qa3  =  7.18286544141962662868e-02, /* 0x3FB2635C, 0xD99FE9A7 */
 qa4  =  1.26171219808761642112e-01, /* 0x3FC02660, 0xE763351F */
 qa5  =  1.36370839120290507362e-02, /* 0x3F8BEDC2, 0x6B51DD1C */
 qa6  =  1.19844998467991074170e-02, /* 0x3F888B54, 0x5735151D */
 /*
  * Coefficients for approximation to erfc in [1.25,1/0.35]
  */
 ra0  = -9.86494403484714822705e-03, /* 0xBF843412, 0x600D6435 */
 ra1  = -6.93858572707181764372e-01, /* 0xBFE63416, 0xE4BA7360 */
 ra2  = -1.05586262253232909814e+01, /* 0xC0251E04, 0x41B0E726 */
 ra3  = -6.23753324503260060396e+01, /* 0xC04F300A, 0xE4CBA38D */
 ra4  = -1.62396669462573470355e+02, /* 0xC0644CB1, 0x84282266 */
 ra5  = -1.84605092906711035994e+02, /* 0xC067135C, 0xEBCCABB2 */
 ra6  = -8.12874355063065934246e+01, /* 0xC0545265, 0x57E4D2F2 */
 ra7  = -9.81432934416914548592e+00, /* 0xC023A0EF, 0xC69AC25C */
 sa1  =  1.96512716674392571292e+01, /* 0x4033A6B9, 0xBD707687 */
 sa2  =  1.37657754143519042600e+02, /* 0x4061350C, 0x526AE721 */
 sa3  =  4.34565877475229228821e+02, /* 0x407B290D, 0xD58A1A71 */
 sa4  =  6.45387271733267880336e+02, /* 0x40842B19, 0x21EC2868 */
 sa5  =  4.29008140027567833386e+02, /* 0x407AD021, 0x57700314 */
 sa6  =  1.08635005541779435134e+02, /* 0x405B28A3, 0xEE48AE2C */
 sa7  =  6.57024977031928170135e+00, /* 0x401A47EF, 0x8E484A93 */
 sa8  = -6.04244152148580987438e-02, /* 0xBFAEEFF2, 0xEE749A62 */
 /*
  * Coefficients for approximation to erfc in [1/.35,28]
  */
 rb0  = -9.86494292470009928597e-03, /* 0xBF843412, 0x39E86F4A */
 rb1  = -7.99283237680523006574e-01, /* 0xBFE993BA, 0x70C285DE */
 rb2  = -1.77579549177547519889e+01, /* 0xC031C209, 0x555F995A */
 rb3  = -1.60636384855821916062e+02, /* 0xC064145D, 0x43C5ED98 */
 rb4  = -6.37566443368389627722e+02, /* 0xC083EC88, 0x1375F228 */
 rb5  = -1.02509513161107724954e+03, /* 0xC0900461, 0x6A2E5992 */
 rb6  = -4.83519191608651397019e+02, /* 0xC07E384E, 0x9BDC383F */
 sb1  =  3.03380607434824582924e+01, /* 0x403E568B, 0x261D5190 */
 sb2  =  3.25792512996573918826e+02, /* 0x40745CAE, 0x221B9F0A */
 sb3  =  1.53672958608443695994e+03, /* 0x409802EB, 0x189D5118 */
 sb4  =  3.19985821950859553908e+03, /* 0x40A8FFB7, 0x688C246A */
 sb5  =  2.55305040643316442583e+03, /* 0x40A3F219, 0xCEDF3BE6 */
 sb6  =  4.74528541206955367215e+02, /* 0x407DA874, 0xE79FE763 */
 sb7  = -2.24409524465858183362e+01; /* 0xC03670E2, 0x42712D62 */
 
 double
 erf(double x)
 {
 	int32_t hx,ix,i;
 	double R,S,P,Q,s,y,z,r;
 	GET_HIGH_WORD(hx,x);
 	ix = hx&0x7fffffff;
 	if(ix>=0x7ff00000) {		/* erf(nan)=nan */
 	    i = ((u_int32_t)hx>>31)<<1;
 	    return (double)(1-i)+one/x;	/* erf(+-inf)=+-1 */
 	}
 
 	if(ix < 0x3feb0000) {		/* |x|<0.84375 */
 	    if(ix < 0x3e300000) { 	/* |x|<2**-28 */
 	        if (ix < 0x00800000)
 		    return (8*x+efx8*x)/8;	/* avoid spurious underflow */
 		return x + efx*x;
 	    }
 	    z = x*x;
 	    r = pp0+z*(pp1+z*(pp2+z*(pp3+z*pp4)));
 	    s = one+z*(qq1+z*(qq2+z*(qq3+z*(qq4+z*qq5))));
 	    y = r/s;
 	    return x + x*y;
 	}
 	if(ix < 0x3ff40000) {		/* 0.84375 <= |x| < 1.25 */
 	    s = fabs(x)-one;
 	    P = pa0+s*(pa1+s*(pa2+s*(pa3+s*(pa4+s*(pa5+s*pa6)))));
 	    Q = one+s*(qa1+s*(qa2+s*(qa3+s*(qa4+s*(qa5+s*qa6)))));
 	    if(hx>=0) return erx + P/Q; else return -erx - P/Q;
 	}
 	if (ix >= 0x40180000) {		/* inf>|x|>=6 */
 	    if(hx>=0) return one-tiny; else return tiny-one;
 	}
 	x = fabs(x);
  	s = one/(x*x);
 	if(ix< 0x4006DB6E) {	/* |x| < 1/0.35 */
 	    R=ra0+s*(ra1+s*(ra2+s*(ra3+s*(ra4+s*(ra5+s*(ra6+s*ra7))))));
 	    S=one+s*(sa1+s*(sa2+s*(sa3+s*(sa4+s*(sa5+s*(sa6+s*(sa7+
 		s*sa8)))))));
 	} else {	/* |x| >= 1/0.35 */
 	    R=rb0+s*(rb1+s*(rb2+s*(rb3+s*(rb4+s*(rb5+s*rb6)))));
 	    S=one+s*(sb1+s*(sb2+s*(sb3+s*(sb4+s*(sb5+s*(sb6+s*sb7))))));
 	}
 	z  = x;
 	SET_LOW_WORD(z,0);
-	r  =  __ieee754_exp(-z*z-0.5625)*__ieee754_exp((z-x)*(z+x)+R/S);
+	r  =  exp(-z*z-0.5625)*exp((z-x)*(z+x)+R/S);
 	if(hx>=0) return one-r/x; else return  r/x-one;
 }
 
 #if (LDBL_MANT_DIG == 53)
 __weak_reference(erf, erfl);
 #endif
 
 double
 erfc(double x)
 {
 	int32_t hx,ix;
 	double R,S,P,Q,s,y,z,r;
 	GET_HIGH_WORD(hx,x);
 	ix = hx&0x7fffffff;
 	if(ix>=0x7ff00000) {			/* erfc(nan)=nan */
 						/* erfc(+-inf)=0,2 */
 	    return (double)(((u_int32_t)hx>>31)<<1)+one/x;
 	}
 
 	if(ix < 0x3feb0000) {		/* |x|<0.84375 */
 	    if(ix < 0x3c700000)  	/* |x|<2**-56 */
 		return one-x;
 	    z = x*x;
 	    r = pp0+z*(pp1+z*(pp2+z*(pp3+z*pp4)));
 	    s = one+z*(qq1+z*(qq2+z*(qq3+z*(qq4+z*qq5))));
 	    y = r/s;
 	    if(hx < 0x3fd00000) {  	/* x<1/4 */
 		return one-(x+x*y);
 	    } else {
 		r = x*y;
 		r += (x-half);
 	        return half - r ;
 	    }
 	}
 	if(ix < 0x3ff40000) {		/* 0.84375 <= |x| < 1.25 */
 	    s = fabs(x)-one;
 	    P = pa0+s*(pa1+s*(pa2+s*(pa3+s*(pa4+s*(pa5+s*pa6)))));
 	    Q = one+s*(qa1+s*(qa2+s*(qa3+s*(qa4+s*(qa5+s*qa6)))));
 	    if(hx>=0) {
 	        z  = one-erx; return z - P/Q;
 	    } else {
 		z = erx+P/Q; return one+z;
 	    }
 	}
 	if (ix < 0x403c0000) {		/* |x|<28 */
 	    x = fabs(x);
  	    s = one/(x*x);
 	    if(ix< 0x4006DB6D) {	/* |x| < 1/.35 ~ 2.857143*/
 		R=ra0+s*(ra1+s*(ra2+s*(ra3+s*(ra4+s*(ra5+s*(ra6+s*ra7))))));
 		S=one+s*(sa1+s*(sa2+s*(sa3+s*(sa4+s*(sa5+s*(sa6+s*(sa7+
 		    s*sa8)))))));
 	    } else {			/* |x| >= 1/.35 ~ 2.857143 */
 		if(hx<0&&ix>=0x40180000) return two-tiny;/* x < -6 */
 		R=rb0+s*(rb1+s*(rb2+s*(rb3+s*(rb4+s*(rb5+s*rb6)))));
 		S=one+s*(sb1+s*(sb2+s*(sb3+s*(sb4+s*(sb5+s*(sb6+s*sb7))))));
 	    }
 	    z  = x;
 	    SET_LOW_WORD(z,0);
-	    r  =  __ieee754_exp(-z*z-0.5625)*__ieee754_exp((z-x)*(z+x)+R/S);
+	    r  =  exp(-z*z-0.5625)*exp((z-x)*(z+x)+R/S);
 	    if(hx>0) return r/x; else return two-r/x;
 	} else {
 	    if(hx>0) return tiny*tiny; else return two-tiny;
 	}
 }
 
 #if (LDBL_MANT_DIG == 53)
 __weak_reference(erfc, erfcl);
 #endif
diff --git a/lib/msun/src/s_significand.c b/lib/msun/src/s_significand.c
index 356e3001f7ca..eed80ece1cc4 100644
--- a/lib/msun/src/s_significand.c
+++ b/lib/msun/src/s_significand.c
@@ -1,29 +1,29 @@
 /* @(#)s_signif.c 5.1 93/09/24 */
 /*
  * ====================================================
  * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
  *
  * Developed at SunPro, a Sun Microsystems, Inc. business.
  * Permission to use, copy, modify, and distribute this
  * software is freely granted, provided that this notice
  * is preserved.
  * ====================================================
  */
 
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
 /*
  * significand(x) computes just
  * 	scalb(x, (double) -ilogb(x)),
  * for exercising the fraction-part(F) IEEE 754-1985 test vector.
  */
 
 #include "math.h"
 #include "math_private.h"
 
 double
 significand(double x)
 {
-	return __ieee754_scalb(x,(double) -ilogb(x));
+	return scalb(x,(double) -ilogb(x));
 }
diff --git a/lib/msun/src/s_significandf.c b/lib/msun/src/s_significandf.c
index ad030e239133..b33ab7b6f6b2 100644
--- a/lib/msun/src/s_significandf.c
+++ b/lib/msun/src/s_significandf.c
@@ -1,26 +1,26 @@
 /* s_significandf.c -- float version of s_significand.c.
  * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
  */
 
 /*
  * ====================================================
  * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
  *
  * Developed at SunPro, a Sun Microsystems, Inc. business.
  * Permission to use, copy, modify, and distribute this
  * software is freely granted, provided that this notice
  * is preserved.
  * ====================================================
  */
 
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
 #include "math.h"
 #include "math_private.h"
 
 float
 significandf(float x)
 {
-	return __ieee754_scalbf(x,(float) -ilogbf(x));
+	return scalbf(x,(float) -ilogbf(x));
 }