cd6ede759f
1997-07-14 23:37 Ulrich Drepper <drepper@cygnus.com> * inet/getnameinfo.c: Pretty print. Correctly enlarge buffers. * login/programs/utmpd.c: Use _() instead of gettext(). * nis/nss_nisplus/nisplus-hosts.c: Optimize some uses of stpcpy away. * nis/nss_nisplus/nisplus-network.c: Likewise. * nis/nss_nisplus/nisplus-proto.c: Likewise. * nis/nss_nisplus/nisplus-rpc.c: Likewise. * nis/nss_nisplus/nisplus-service.c: Likewise. * sysdeps/alpha/fpu/bits/mathinline.h: Only define functions if __OPTIMIZE__. * sysdeps/powerpc/bits/mathinline.h: Likewise. * sysdeps/i386/fpu/bits/mathinline.h: Define ISO C9x comparison function always. * sysdeps/m68k/fpu/bits/mathinline.h: Likewise. * sysdeps/stub/bits/mathinline.h: Add conditionals to show how it should look like in real files. * sysdeps/generic/bits/select.h (__FD_ZERO): Don't use memset to prevent prototype trouble, use simple loop. * sysdeps/i386/bits/select.h [!__GNUC__] (__FD_ZERO): Likewise. * sysdeps/mips/mips64/Implies: Imply ieee754. * sysdeps/unix/sysv/linux/Makefile: Make sure bits/syscall.h is installed. * sysdeps/unix/sysv/linux/sys/syscal.h: Pretty print. 1997-07-14 00:25 Ulrich Drepper <drepper@cygnus.com> * sysdeps/stub/bits/stdio_lim.h: Unify with standalone version. * sysdeps/standalone/bits/stdio_lim.h: Removed. Patch by Zack Weinberg <zack@rabi.phys.columbia.edu>. 1997-06-22 Paul Eggert <eggert@twinsun.com> * time/strftime.c (strftime): Use tm_zone if available, even if _LIBC. * time/tzfile.c (__tzstring): New decl. (__tzfile_read, __tzfile_default): Set __tzname to permanent strings. (__tzfile_default): First two args are now const char *. * time/tzset.c (__tzstring): New function. (tz_rule): Name is now const char *. (struct tzstring_head): New type. (tzstring_list, tzstring_last_buffer_size): New static vars. (__tzset_internal): Time zone names are now permanent, not temporary.
605 lines
14 KiB
C
605 lines
14 KiB
C
/* Inline math functions for i387.
|
|
Copyright (C) 1995, 1996, 1997 Free Software Foundation, Inc.
|
|
This file is part of the GNU C Library.
|
|
Contributed by John C. Bowman <bowman@ipp-garching.mpg.de>, 1995.
|
|
|
|
The GNU C Library is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU Library General Public License as
|
|
published by the Free Software Foundation; either version 2 of the
|
|
License, or (at your option) any later version.
|
|
|
|
The GNU C Library is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
Library General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Library General Public
|
|
License along with the GNU C Library; see the file COPYING.LIB. If not,
|
|
write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
Boston, MA 02111-1307, USA. */
|
|
|
|
#ifndef _BITS_MATHINLINE_H
|
|
#define _BITS_MATHINLINE_H 1
|
|
|
|
|
|
#if defined __USE_ISOC9X && defined __GNUC__ && __GNUC__ >= 2
|
|
/* ISO C 9X defines some macros to perform unordered comparisons. The
|
|
ix87 FPU supports this with special opcodes and we should use them.
|
|
These must not be inline functions since we have to be able to handle
|
|
all floating-point types. */
|
|
# define isgreater(x, y) \
|
|
({ int result; \
|
|
__asm__ ("fucompp; fnstsw; andb $0x45, %%ah; setz %%al;" \
|
|
"andl $0xff, %0" \
|
|
: "=a" (result) : "t" (x), "u" (y) : "cc"); \
|
|
result; })
|
|
|
|
# define isgreaterequal(x, y) \
|
|
({ int result; \
|
|
__asm__ ("fucompp; fnstsw; testb $0x05, %%ah; setz %%al;" \
|
|
"andl $0xff, %0" \
|
|
: "=a" (result) : "t" (x), "u" (y) : "cc"); \
|
|
result; })
|
|
|
|
# define isless(x, y) \
|
|
({ int result; \
|
|
__asm__ ("fucompp; fnstsw; xorb $0x01, %%ah; testb $0x45, %%ah;" \
|
|
"setz %%al; andl $0xff, %0" \
|
|
: "=a" (result) : "t" (x), "u" (y) : "cc"); \
|
|
result; })
|
|
|
|
# define islessequal(x, y) \
|
|
({ int result; \
|
|
__asm__ ("fucompp; fnstsw; xorb $0x01, %%ah; testb $0x05, %%ah;" \
|
|
"setz %%al; andl $0xff, %0" \
|
|
: "=a" (result) : "t" (x), "u" (y) : "cc"); \
|
|
result; })
|
|
|
|
# define islessgreater(x, y) \
|
|
({ int result; \
|
|
__asm__ ("fucompp; fnstsw; testb $0x44, %%ah; setz %%al;" \
|
|
"andl $0xff, %0" \
|
|
: "=a" (result) : "t" (x), "u" (y) : "cc"); \
|
|
result; })
|
|
|
|
# define isunordered(x, y) \
|
|
({ int result; \
|
|
__asm__ ("fucompp; fnstsw; sahf; setp %%al; andl $0xff, %0" \
|
|
: "=a" (result) : "t" (x), "u" (y) : "cc"); \
|
|
result; })
|
|
#endif
|
|
|
|
|
|
#if defined __GNUC__ && \
|
|
(__GNUC__ < 2 || (__GNUC__ == 2 && __GNUC_MINOR__ <= 7))
|
|
/* gcc 2.7.2 and 2.7.2.1 have problems with inlining `long double'
|
|
functions so we disable this now. */
|
|
# undef __NO_MATH_INLINES
|
|
# define __NO_MATH_INLINES
|
|
#endif
|
|
|
|
|
|
#ifdef __GNUC__
|
|
#if !defined __NO_MATH_INLINES && defined __OPTIMIZE__
|
|
|
|
#ifdef __cplusplus
|
|
# define __MATH_INLINE __inline
|
|
#else
|
|
# define __MATH_INLINE extern __inline
|
|
#endif
|
|
|
|
__MATH_INLINE double cos (double);
|
|
__MATH_INLINE double sin (double);
|
|
|
|
|
|
__MATH_INLINE double __expm1 (double __x);
|
|
__MATH_INLINE double
|
|
__expm1 (double __x)
|
|
{
|
|
register double __value, __exponent, __temp;
|
|
__asm __volatile__
|
|
("fldl2e # e^x - 1 = 2^(x * log2(e)) - 1\n\t"
|
|
"fmul %%st(1) # x * log2(e)\n\t"
|
|
"fstl %%st(1)\n\t"
|
|
"frndint # int(x * log2(e))\n\t"
|
|
"fxch\n\t"
|
|
"fsub %%st(1) # fract(x * log2(e))\n\t"
|
|
"f2xm1 # 2^(fract(x * log2(e))) - 1\n\t"
|
|
"fscale # 2^(x * log2(e)) - 2^(int(x * log2(e)))\n\t"
|
|
: "=t" (__value), "=u" (__exponent) : "0" (__x));
|
|
__asm __volatile__
|
|
("fscale # 2^int(x * log2(e))\n\t"
|
|
: "=t" (__temp) : "0" (1.0), "u" (__exponent));
|
|
__temp -= 1.0;
|
|
|
|
return __temp + __value;
|
|
}
|
|
|
|
__MATH_INLINE double __sgn1 (double __x);
|
|
__MATH_INLINE double
|
|
__sgn1 (double __x)
|
|
{
|
|
return __x >= 0.0 ? 1.0 : -1.0;
|
|
}
|
|
|
|
__MATH_INLINE double sqrt (double __x);
|
|
__MATH_INLINE double
|
|
sqrt (double __x)
|
|
{
|
|
register double __value;
|
|
__asm __volatile__
|
|
("fsqrt"
|
|
: "=t" (__value) : "0" (__x));
|
|
|
|
return __value;
|
|
}
|
|
|
|
__MATH_INLINE double fabs (double __x);
|
|
__MATH_INLINE double
|
|
fabs (double __x)
|
|
{
|
|
register double __value;
|
|
__asm __volatile__
|
|
("fabs"
|
|
: "=t" (__value) : "0" (__x));
|
|
|
|
return __value;
|
|
}
|
|
|
|
/* The argument range of this inline version is limited. */
|
|
__MATH_INLINE double sin (double __x);
|
|
__MATH_INLINE double
|
|
sin (double __x)
|
|
{
|
|
register double __value;
|
|
__asm __volatile__
|
|
("fsin"
|
|
: "=t" (__value) : "0" (__x));
|
|
|
|
return __value;
|
|
}
|
|
|
|
/* The argument range of this inline version is limited. */
|
|
__MATH_INLINE double cos (double __x);
|
|
__MATH_INLINE double
|
|
cos (double __x)
|
|
{
|
|
register double __value;
|
|
__asm __volatile__
|
|
("fcos"
|
|
: "=t" (__value): "0" (__x));
|
|
|
|
return __value;
|
|
}
|
|
|
|
__MATH_INLINE double tan (double __x);
|
|
__MATH_INLINE double
|
|
tan (double __x)
|
|
{
|
|
register double __value;
|
|
register double __value2 __attribute__ ((unused));
|
|
__asm __volatile__
|
|
("fptan"
|
|
: "=t" (__value2), "=u" (__value) : "0" (__x));
|
|
|
|
return __value;
|
|
}
|
|
|
|
__MATH_INLINE double atan2 (double __y, double __x);
|
|
__MATH_INLINE double
|
|
atan2 (double __y, double __x)
|
|
{
|
|
register double __value;
|
|
__asm __volatile__
|
|
("fpatan\n\t"
|
|
"fldl %%st(0)"
|
|
: "=t" (__value) : "0" (__x), "u" (__y));
|
|
|
|
return __value;
|
|
}
|
|
|
|
__MATH_INLINE double asin (double __x);
|
|
__MATH_INLINE double
|
|
asin (double __x)
|
|
{
|
|
return atan2 (__x, sqrt (1.0 - __x * __x));
|
|
}
|
|
|
|
__MATH_INLINE double acos (double __x);
|
|
__MATH_INLINE double
|
|
acos (double __x)
|
|
{
|
|
return atan2 (sqrt (1.0 - __x * __x), __x);
|
|
}
|
|
|
|
__MATH_INLINE double atan (double __x);
|
|
__MATH_INLINE double
|
|
atan (double __x)
|
|
{
|
|
register double __value;
|
|
__asm __volatile__
|
|
("fld1\n\t"
|
|
"fpatan"
|
|
: "=t" (__value) : "0" (__x));
|
|
|
|
return __value;
|
|
}
|
|
|
|
__MATH_INLINE double exp (double __x);
|
|
__MATH_INLINE double
|
|
exp (double __x)
|
|
{
|
|
register double __value, __exponent;
|
|
__asm __volatile__
|
|
("fldl2e # e^x = 2^(x * log2(e))\n\t"
|
|
"fmul %%st(1) # x * log2(e)\n\t"
|
|
"fstl %%st(1)\n\t"
|
|
"frndint # int(x * log2(e))\n\t"
|
|
"fxch\n\t"
|
|
"fsub %%st(1) # fract(x * log2(e))\n\t"
|
|
"f2xm1 # 2^(fract(x * log2(e))) - 1\n\t"
|
|
: "=t" (__value), "=u" (__exponent) : "0" (__x));
|
|
__value += 1.0;
|
|
__asm __volatile__
|
|
("fscale"
|
|
: "=t" (__value) : "0" (__value), "u" (__exponent));
|
|
|
|
return __value;
|
|
}
|
|
|
|
__MATH_INLINE double sinh (double __x);
|
|
__MATH_INLINE double
|
|
sinh (double __x)
|
|
{
|
|
register double __exm1 = __expm1 (fabs (__x));
|
|
|
|
return 0.5 * (__exm1 / (__exm1 + 1.0) + __exm1) * __sgn1 (__x);
|
|
}
|
|
|
|
__MATH_INLINE double cosh (double __x);
|
|
__MATH_INLINE double
|
|
cosh (double __x)
|
|
{
|
|
register double __ex = exp (__x);
|
|
|
|
return 0.5 * (__ex + 1.0 / __ex);
|
|
}
|
|
|
|
__MATH_INLINE double tanh (double __x);
|
|
__MATH_INLINE double
|
|
tanh (double __x)
|
|
{
|
|
register double __exm1 = __expm1 (-fabs (__x + __x));
|
|
|
|
return __exm1 / (__exm1 + 2.0) * __sgn1 (-__x);
|
|
}
|
|
|
|
__MATH_INLINE double log (double __x);
|
|
__MATH_INLINE double
|
|
log (double __x)
|
|
{
|
|
register double __value;
|
|
__asm __volatile__
|
|
("fldln2\n\t"
|
|
"fxch\n\t"
|
|
"fyl2x"
|
|
: "=t" (__value) : "0" (__x));
|
|
|
|
return __value;
|
|
}
|
|
|
|
__MATH_INLINE double log10 (double __x);
|
|
__MATH_INLINE double
|
|
log10 (double __x)
|
|
{
|
|
register double __value;
|
|
__asm __volatile__
|
|
("fldlg2\n\t"
|
|
"fxch\n\t"
|
|
"fyl2x"
|
|
: "=t" (__value) : "0" (__x));
|
|
|
|
return __value;
|
|
}
|
|
|
|
__MATH_INLINE double __log2 (double __x);
|
|
__MATH_INLINE double
|
|
__log2 (double __x)
|
|
{
|
|
register double __value;
|
|
__asm __volatile__
|
|
("fyl2x"
|
|
: "=t" (__value) : "0" (__x), "u" (1.0));
|
|
|
|
return __value;
|
|
}
|
|
|
|
__MATH_INLINE double fmod (double __x, double __y);
|
|
__MATH_INLINE double
|
|
fmod (double __x, double __y)
|
|
{
|
|
register double __value;
|
|
__asm __volatile__
|
|
("1: fprem\n\t"
|
|
"fstsw %%ax\n\t"
|
|
"sahf\n\t"
|
|
"jp 1b"
|
|
: "=t" (__value) : "0" (__x), "u" (__y) : "ax", "cc");
|
|
|
|
return __value;
|
|
}
|
|
|
|
__MATH_INLINE double ldexp (double __x, int __y);
|
|
__MATH_INLINE double
|
|
ldexp (double __x, int __y)
|
|
{
|
|
register double __value;
|
|
__asm __volatile__
|
|
("fscale"
|
|
: "=t" (__value) : "0" (__x), "u" ((double) __y));
|
|
|
|
return __value;
|
|
}
|
|
|
|
__MATH_INLINE double pow (double __x, double __y);
|
|
__MATH_INLINE double
|
|
pow (double __x, double __y)
|
|
{
|
|
register double __value, __exponent;
|
|
long __p = (long) __y;
|
|
|
|
if (__x == 0.0 && __y > 0.0)
|
|
return 0.0;
|
|
if (__y == (double) __p)
|
|
{
|
|
double __r = 1.0;
|
|
if (__p == 0)
|
|
return 1.0;
|
|
if (__p < 0)
|
|
{
|
|
__p = -__p;
|
|
__x = 1.0 / __x;
|
|
}
|
|
while (1)
|
|
{
|
|
if (__p & 1)
|
|
__r *= __x;
|
|
__p >>= 1;
|
|
if (__p == 0)
|
|
return __r;
|
|
__x *= __x;
|
|
}
|
|
/* NOTREACHED */
|
|
}
|
|
__asm __volatile__
|
|
("fmul %%st(1) # y * log2(x)\n\t"
|
|
"fstl %%st(1)\n\t"
|
|
"frndint # int(y * log2(x))\n\t"
|
|
"fxch\n\t"
|
|
"fsub %%st(1) # fract(y * log2(x))\n\t"
|
|
"f2xm1 # 2^(fract(y * log2(x))) - 1\n\t"
|
|
: "=t" (__value), "=u" (__exponent) : "0" (__log2 (__x)), "1" (__y));
|
|
__value += 1.0;
|
|
__asm __volatile__
|
|
("fscale"
|
|
: "=t" (__value) : "0" (__value), "u" (__exponent));
|
|
|
|
return __value;
|
|
}
|
|
|
|
__MATH_INLINE double floor (double __x);
|
|
__MATH_INLINE double
|
|
floor (double __x)
|
|
{
|
|
register double __value;
|
|
__volatile unsigned short int __cw, __cwtmp;
|
|
|
|
__asm __volatile ("fnstcw %0" : "=m" (__cw));
|
|
__cwtmp = (__cw & 0xf3ff) | 0x0400; /* rounding down */
|
|
__asm __volatile ("fldcw %0" : : "m" (__cwtmp));
|
|
__asm __volatile ("frndint" : "=t" (__value) : "0" (__x));
|
|
__asm __volatile ("fldcw %0" : : "m" (__cw));
|
|
|
|
return __value;
|
|
}
|
|
|
|
__MATH_INLINE double ceil (double __x);
|
|
__MATH_INLINE double
|
|
ceil (double __x)
|
|
{
|
|
register double __value;
|
|
__volatile unsigned short int __cw, __cwtmp;
|
|
|
|
__asm __volatile ("fnstcw %0" : "=m" (__cw));
|
|
__cwtmp = (__cw & 0xf3ff) | 0x0800; /* rounding up */
|
|
__asm __volatile ("fldcw %0" : : "m" (__cwtmp));
|
|
__asm __volatile ("frndint" : "=t" (__value) : "0" (__x));
|
|
__asm __volatile ("fldcw %0" : : "m" (__cw));
|
|
|
|
return __value;
|
|
}
|
|
|
|
|
|
/* Optimized versions for some non-standardized functions. */
|
|
#if defined __USE_ISOC9X || defined __USE_MISC
|
|
|
|
__MATH_INLINE double hypot (double __x, double __y);
|
|
__MATH_INLINE double
|
|
hypot (double __x, double __y)
|
|
{
|
|
return sqrt (__x * __x + __y * __y);
|
|
}
|
|
|
|
/* We cannot rely on M_SQRT being defined. So we do it for ourself
|
|
here. */
|
|
# define __M_SQRT2 _Mldbl(1.41421356237309504880) /* sqrt(2) */
|
|
|
|
__MATH_INLINE double log1p (double __x);
|
|
__MATH_INLINE double
|
|
log1p (double __x)
|
|
{
|
|
register double __value;
|
|
|
|
if (fabs (__x) >= 1.0 - 0.5 * __M_SQRT2)
|
|
__value = log (1.0 + __x);
|
|
else
|
|
__asm __volatile__
|
|
("fldln2\n\t"
|
|
"fxch\n\t"
|
|
"fyl2xp1"
|
|
: "=t" (__value) : "0" (__x));
|
|
|
|
return __value;
|
|
}
|
|
|
|
__MATH_INLINE double asinh (double __x);
|
|
__MATH_INLINE double
|
|
asinh (double __x)
|
|
{
|
|
register double __y = fabs (__x);
|
|
|
|
return log1p ((__y * __y / (sqrt (__y * __y + 1.0) + 1.0) + __y)
|
|
* __sgn1 (__x));
|
|
}
|
|
|
|
__MATH_INLINE double acosh (double __x);
|
|
__MATH_INLINE double
|
|
acosh (double __x)
|
|
{
|
|
return log (__x + sqrt (__x - 1.0) * sqrt (__x + 1.0));
|
|
}
|
|
|
|
__MATH_INLINE double atanh (double __x);
|
|
__MATH_INLINE double
|
|
atanh (double __x)
|
|
{
|
|
register double __y = fabs (__x);
|
|
|
|
return -0.5 * __log1p (-(__y + __y) / (1.0 + __y)) * __sgn1 (__x);
|
|
}
|
|
|
|
__MATH_INLINE double logb (double __x);
|
|
__MATH_INLINE double
|
|
logb (double __x)
|
|
{
|
|
register double __value, __junk;
|
|
__asm __volatile__
|
|
("fxtract\n\t"
|
|
: "=t" (__junk), "=u" (__value) : "0" (__x));
|
|
|
|
return __value;
|
|
}
|
|
#endif
|
|
|
|
|
|
#ifdef __USE_MISC
|
|
__MATH_INLINE double drem (double __x, double __y);
|
|
__MATH_INLINE double
|
|
drem (double __x, double __y)
|
|
{
|
|
register double __value;
|
|
__asm __volatile__
|
|
("1: fprem1\n\t"
|
|
"fstsw %%ax\n\t"
|
|
"sahf\n\t"
|
|
"jp 1b"
|
|
: "=t" (__value) : "0" (__x), "u" (__y) : "ax", "cc");
|
|
|
|
return __value;
|
|
}
|
|
|
|
/* This function is used in the `isfinite' macro. */
|
|
__MATH_INLINE int __finite (double __x);
|
|
__MATH_INLINE int
|
|
__finite (double __x)
|
|
{
|
|
register int __result;
|
|
__asm__ __volatile__
|
|
("orl $0x800fffff, %0\n\t"
|
|
"incl %0\n\t"
|
|
"shrl $31, %0"
|
|
: "=q" (__result) : "0" (((int *) &__x)[1]));
|
|
return __result;
|
|
}
|
|
|
|
__MATH_INLINE double coshm1 (double __x);
|
|
__MATH_INLINE double
|
|
coshm1 (double __x)
|
|
{
|
|
register double __exm1 = __expm1 (fabs (__x));
|
|
|
|
return 0.5 * (__exm1 / (__exm1 + 1.0)) * __exm1;
|
|
}
|
|
|
|
__MATH_INLINE double acosh1p (double __x);
|
|
__MATH_INLINE double
|
|
acosh1p (double __x)
|
|
{
|
|
return __log1p (__x + sqrt (__x) * sqrt (__x + 2.0));
|
|
}
|
|
|
|
__MATH_INLINE void sincos (double __x, double *__sinx, double *__cosx);
|
|
__MATH_INLINE void
|
|
sincos (double __x, double *__sinx, double *__cosx)
|
|
{
|
|
register double __cosr, __sinr;
|
|
__asm __volatile__
|
|
("fsincos\n\t"
|
|
"fnstsw %%ax\n\t"
|
|
"testl $0x400, %%eax\n\t"
|
|
"jz 1f\n\t"
|
|
"fldpi\n\t"
|
|
"fadd %%st(0)\n\t"
|
|
"fxch %%st(1)\n\t"
|
|
"2: fprem1\n\t"
|
|
"fnstsw %%ax\n\t"
|
|
"testl $0x400, %%eax\n\t"
|
|
"jnz 2b\n\t"
|
|
"fstp %%st(1)\n\t"
|
|
"fsincos\n\t"
|
|
"1:"
|
|
: "=t" (__cosr), "=u" (__sinr) : "0" (__x));
|
|
|
|
*__sinx = __sinr;
|
|
*__cosx = __cosr;
|
|
}
|
|
|
|
__MATH_INLINE double sgn (double __x);
|
|
__MATH_INLINE double
|
|
sgn (double __x)
|
|
{
|
|
return __x == 0.0 ? 0.0 : (__x > 0.0 ? 1.0 : -1.0);
|
|
}
|
|
|
|
__MATH_INLINE double pow2 (double __x);
|
|
__MATH_INLINE double
|
|
pow2 (double __x)
|
|
{
|
|
register double __value, __exponent;
|
|
long __p = (long) __x;
|
|
|
|
if (__x == (double) __p)
|
|
return ldexp (1.0, __p);
|
|
|
|
__asm __volatile__
|
|
("fldl %%st(0)\n\t"
|
|
"frndint # int(x)\n\t"
|
|
"fxch\n\t"
|
|
"fsub %%st(1) # fract(x)\n\t"
|
|
"f2xm1 # 2^(fract(x)) - 1\n\t"
|
|
: "=t" (__value), "=u" (__exponent) : "0" (__x));
|
|
__value += 1.0;
|
|
__asm __volatile__
|
|
("fscale"
|
|
: "=t" (__value) : "0" (__value), "u" (__exponent));
|
|
|
|
return __value;
|
|
}
|
|
|
|
#endif /* __USE_MISC */
|
|
|
|
#endif /* __NO_MATH_INLINES */
|
|
#endif /* __GNUC__ */
|
|
|
|
#endif /* _BITS_MATHINLINE_H */
|