From 3996f34b46043ed8ea8fdc6f44377d969d64396b Mon Sep 17 00:00:00 2001 From: Ulrich Drepper Date: Mon, 28 Jul 1997 22:35:20 +0000 Subject: Update. 1997-07-28 23:35 Ulrich Drepper * csu/gmon-start.c (__gmon_start__): Call __monstartup not monstartup. * gmon/gmon.c: Rename moncontrol to __moncontrol and monstartup to __monstartup. * gmon/sys/gmon.h: Fix prototypes. * gmon/sys/gmon_out.h: Pretty print. * gmon/bb_exit_func.c (__bb_exit_func): Use memcpy instead of bcopy. * gmon/gmon.c (__monstartup): Likewise. (write_hist): Remove dependency on 32 int. (_mcleanup): Don't call perror, use fprintf. * elf/dl-load.c: Fix handling of current directory in search path. * elf/Makefile (dl-routines): Add dl-profile. * elf/dl-profile.c: New file. * elf/dl-runtime.c (fixup): Add new parameter with address to store relocation result in to elf_machine_relplt. (profile_fixup): New function. * elf/do-rel.h (elf_dynamic_do_rel): Add new parameter with address to store relocation result in to elf_machine_relplt. * elf/dl-support.c: Define _dl_profile and _dl_profile_map. * elf/dynamic-link.h (ELF_DYNAMIC_RELOCATE): Add new parameter and call elf_machine_runtime_setup with extra argument. * elf/dl-reloc.c (_dl_relocate_object): Add new argument to ELF_DYNAMIC_RELOCATE. * elf/link.h: Add prototypes for new functions and variables. * elf/rtld.c: Parse LD_PROFILE and LD_PROFILE_OUTPUT environment variables and call _dl_start_profile if necessary. * include/sys/gmon_out.h: New file. * sysdeps/alpha/dl-machine.h (elf_machine_runtime_setup): Add new parameter to enable profiling. (elf_machine_rela): Add new parameter to specify place to store result in. * sysdeps/m68k/dl-machine.h: Likewise. * sysdeps/mips/dl-machine.h: Likewise. * sysdeps/mips/mips64/dl-machine.h: Likewise. * sysdeps/powerpc/dl-machine.h: Likewise. * sysdeps/sparc/dl-machine.h: Likewise. * sysdeps/sparc64/dl-machine.h: Likewise. * sysdeps/i386/dl-machine.h: Likewise. (elf_machine_runtime_setup): Setup got[2] to _dl_runtime_resolve if we do profiling. (ELF_MACHINE_RUNTIME_TRAMPOLINE): Add code for _dl_runtime_profile. * nis/nss_compat/compat-grp.c (internal_setgrent): Set FD_CLOEXEC for stream on input file. * nis/nss_compat/compat-pwd.c (internal_setpwent): Likewise. * nis/nss_compat/compat-spwd.c (internal_setspent): Likewise. * nss/nss_db/db-XXX.c (internal_setent): Likewise. * nss/nss_db/db-alias.c (internal_setent): Likewise. * nss/nss_db/db-netgrp.c (internal_setent): Likewise. * nss/nss_files/files-XXX.c (internal_setent): Likewise. * nss/nss_files/files-alias.c (internal_setent): Likewise. * nss/nss_files/files-netgrp.c (internal_setent): Likewise. * string/string.h: Pretty print. * sysdeps/i386/fpu/bits/mathinline.h: Major update by John Bowman. Add float and long double versions. 1997-07-27 Andreas Schwab * elf/rtld.c (print_unresolved): Replace empty object name by main program name. 1997-07-27 Andreas Schwab * sysdeps/generic/htons.c (htons): Renamed from __htons. 1997-07-27 Andreas Schwab * sysdeps/m68k/bits/byteswap.h: New file. 1997-07-27 23:50 Philip Blundell * inet/netinet/icmp6.h: Update for new drafts of POSIX.1g and IPv6 advanced API. * inet/netinet/in.h: Likewise. * inet/netinet/ip6.h: Likewise. * sysdeps/unix/sysv/linux/bits/socket.h: Likewise. * posix/sys/types.h: Add socklen_t. * manual/socket.texi: Document some more IPv6 things. * manual/libc.texinfo: Likewise. 1997-07-26 Andreas Jaeger * libc.map: Define missing symbol. 1997-07-27 14:31 Thorsten Kukuk * nis/Makefile: Add nis_findserv. * nis/lckcache.c: Fix typo. * nis/nis_call.c: Fix problems with multihomed servers. * nis/nis_findserv.c: New file. * nis/nis_intern.h: Add more prototypes. * nis/nis_lookup.c (nis_lookup): Don't try the next server if network is unreachable. * nis/nis_table.c (nis_list): Likewise. * nis/nis_ping.c (nis_ping): Use MASTER_ONLY, don't call abort() in error case. * nis/nis_util.c (__nis_finddirectory): Give the right error code back. * nis/ypclnt.c: Make sure, that all sockets are closed. --- sysdeps/i386/dl-machine.h | 51 ++- sysdeps/i386/fpu/bits/mathinline.h | 868 +++++++++++++++++-------------------- 2 files changed, 433 insertions(+), 486 deletions(-) (limited to 'sysdeps/i386') diff --git a/sysdeps/i386/dl-machine.h b/sysdeps/i386/dl-machine.h index d6fc038411..e517cff0ff 100644 --- a/sysdeps/i386/dl-machine.h +++ b/sysdeps/i386/dl-machine.h @@ -81,16 +81,20 @@ elf_machine_load_address (void) destroys the passed register information. */ static ElfW(Addr) fixup (struct link_map *l, ElfW(Word) reloc_offset) __attribute__ ((regparm (2), unused)); +static ElfW(Addr) profile_fixup (struct link_map *l, ElfW(Word) reloc_offset, + ElfW(Addr) retaddr) + __attribute__ ((regparm (3), unused)); #endif /* Set up the loaded object described by L so its unrelocated PLT entries will jump to the on-demand fixup code in dl-runtime.c. */ static inline int __attribute__ ((unused)) -elf_machine_runtime_setup (struct link_map *l, int lazy) +elf_machine_runtime_setup (struct link_map *l, int lazy, int profile) { Elf32_Addr *got; extern void _dl_runtime_resolve (Elf32_Word); + extern void _dl_runtime_profile (Elf32_Word); if (l->l_info[DT_JMPREL] && lazy) { @@ -100,9 +104,23 @@ elf_machine_runtime_setup (struct link_map *l, int lazy) and then jump to _GLOBAL_OFFSET_TABLE[2]. */ got = (Elf32_Addr *) (l->l_addr + l->l_info[DT_PLTGOT]->d_un.d_ptr); got[1] = (Elf32_Addr) l; /* Identify this shared object. */ - /* This function will get called to fix up the GOT entry indicated by - the offset on the stack, and then jump to the resolved address. */ - got[2] = (Elf32_Addr) &_dl_runtime_resolve; + + /* The got[2] entry contains the address of a function which gets + called to get the address of a so far unresolved function and + jump to it. The profiling extension of the dynamic linker allows + to intercept the calls to collect information. In this case we + don't store the address in the GOT so that all future calls also + end in this function. */ + if (profile) + { + got[2] = (Elf32_Addr) &_dl_runtime_profile; + /* Say that we really want profiling and the timers are started. */ + _dl_profile_map = l; + } + else + /* This function will get called to fix up the GOT entry indicated by + the offset on the stack, and then jump to the resolved address. */ + got[2] = (Elf32_Addr) &_dl_runtime_resolve; } return lazy; @@ -126,12 +144,31 @@ _dl_runtime_resolve: xchgl %eax, (%esp) # Get %eax contents end store function address. ret $8 # Jump to function address. .size _dl_runtime_resolve, .-_dl_runtime_resolve + + .globl _dl_runtime_profile + .type _dl_runtime_profile, @function +_dl_runtime_profile: + pushl %eax # Preserve registers otherwise clobbered. + pushl %ecx + pushl %edx + movl 20(%esp), %ecx # Load return address + movl 16(%esp), %edx # Copy args pushed by PLT in register. Note + movl 12(%esp), %eax # that `fixup' takes its parameters in regs. + call profile_fixup # Call resolver. + popl %edx # Get register content back. + popl %ecx + xchgl %eax, (%esp) # Get %eax contents end store function address. + ret $8 # Jump to function address. + .size _dl_runtime_profile, .-_dl_runtime_profile "); #else # define ELF_MACHINE_RUNTIME_TRAMPOLINE asm ("\ .globl _dl_runtime_resolve + .globl _dl_runtime_profile .type _dl_runtime_resolve, @function + .type _dl_runtime_profile, @function _dl_runtime_resolve: +_dl_runtime_profile: pushl %eax # Preserve registers otherwise clobbered. pushl %ecx pushl %edx @@ -147,6 +184,7 @@ _dl_runtime_resolve: xchgl %eax, (%esp) # Get %eax contents end store function address. ret $8 # Jump to function address. .size _dl_runtime_resolve, .-_dl_runtime_resolve + .size _dl_runtime_profile, .-_dl_runtime_profile "); #endif /* The PLT uses Elf32_Rel relocs. */ @@ -261,10 +299,9 @@ extern char **_dl_argv; static inline void elf_machine_rel (struct link_map *map, const Elf32_Rel *reloc, - const Elf32_Sym *sym, const struct r_found_version *version) + const Elf32_Sym *sym, const struct r_found_version *version, + Elf32_Addr *const reloc_addr) { - Elf32_Addr *const reloc_addr = (void *) (map->l_addr + reloc->r_offset); - if (ELF32_R_TYPE (reloc->r_info) == R_386_RELATIVE) { #ifndef RTLD_BOOTSTRAP diff --git a/sysdeps/i386/fpu/bits/mathinline.h b/sysdeps/i386/fpu/bits/mathinline.h index 4228959d23..2fc5baf81e 100644 --- a/sysdeps/i386/fpu/bits/mathinline.h +++ b/sysdeps/i386/fpu/bits/mathinline.h @@ -1,7 +1,7 @@ /* 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 , 1995. + Contributed by John C. Bowman , 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 @@ -28,45 +28,45 @@ These must not be inline functions since we have to be able to handle all floating-point types. */ # define isgreater(x, y) \ - ({ int result; \ + ({ int __result; \ __asm__ ("fucompp; fnstsw; andb $0x45, %%ah; setz %%al;" \ "andl $0x01, %0" \ - : "=a" (result) : "u" (y), "t" (x) : "cc", "st", "st(1)"); \ - result; }) + : "=a" (__result) : "u" (y), "t" (x) : "cc", "st", "st(1)"); \ + __result; }) # define isgreaterequal(x, y) \ - ({ int result; \ + ({ int __result; \ __asm__ ("fucompp; fnstsw; testb $0x05, %%ah; setz %%al;" \ "andl $0x01, %0" \ - : "=a" (result) : "u" (y), "t" (x) : "cc", "st", "st(1)"); \ - result; }) + : "=a" (__result) : "u" (y), "t" (x) : "cc", "st", "st(1)"); \ + __result; }) # define isless(x, y) \ - ({ int result; \ + ({ int __result; \ __asm__ ("fucompp; fnstsw; xorb $0x01, %%ah; testb $0x45, %%ah;" \ "setz %%al; andl $0x01, %0" \ - : "=a" (result) : "u" (y), "t" (x) : "cc", "st", "st(1)"); \ - result; }) + : "=a" (__result) : "u" (y), "t" (x) : "cc", "st", "st(1)"); \ + __result; }) # define islessequal(x, y) \ - ({ int result; \ + ({ int __result; \ __asm__ ("fucompp; fnstsw; xorb $0x01, %%ah; testb $0x05, %%ah;" \ "setz %%al; andl $0x01, %0" \ - : "=a" (result) : "u" (y), "t" (x) : "cc", "st", "st(1)"); \ - result; }) + : "=a" (__result) : "u" (y), "t" (x) : "cc", "st", "st(1)"); \ + __result; }) # define islessgreater(x, y) \ - ({ int result; \ + ({ int __result; \ __asm__ ("fucompp; fnstsw; testb $0x44, %%ah; setz %%al;" \ "andl $0x01, %0" \ - : "=a" (result) : "u" (y), "t" (x) : "cc", "st", "st(1)"); \ - result; }) + : "=a" (__result) : "u" (y), "t" (x) : "cc", "st", "st(1)"); \ + __result; }) # define isunordered(x, y) \ - ({ int result; \ + ({ int __result; \ __asm__ ("fucompp; fnstsw; sahf; setp %%al; andl $0x01, %0" \ - : "=a" (result) : "u" (y), "t" (x) : "cc", "st", "st(1)"); \ - result; }) + : "=a" (__result) : "u" (y), "t" (x) : "cc", "st", "st(1)"); \ + __result; }) #endif @@ -88,425 +88,328 @@ # define __MATH_INLINE extern __inline #endif -__MATH_INLINE double cos (double); -__MATH_INLINE double sin (double); +/* A macro to define float, double, and long double versions of various + math functions for the ix87 FPU. FUNC is the function name (which will + be suffixed with f and l for the float and long double version, + respectively). OP is the name of the FPU operation. */ +#if defined __USE_MISC || defined __USE_ISOC9X +# define __inline_mathop(func, op) \ + __inline_mathop_ (double, func, op) \ + __inline_mathop_ (float, __CONCAT(func,f), op) \ + __inline_mathop_ (long double, __CONCAT(func,l), op) +#else +# define __inline_mathop(func, op) \ + __inline_mathop_ (double, func, op) +#endif -__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; -} +#define __inline_mathop_(float_type, func, op) \ + __inline_mathop_decl_ (float_type, func, op, "0" (__x)) -__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; +#if defined __USE_MISC || defined __USE_ISOC9X +# define __inline_mathop_decl(func, op, params...) \ + __inline_mathop_decl_ (double, func, op, params) \ + __inline_mathop_decl_ (float, __CONCAT(func,f), op, params) \ + __inline_mathop_decl_ (long double, __CONCAT(func,l), op, params) +#else +# define __inline_mathop_decl(func, op, params...) \ + __inline_mathop_decl_ (double, func, op, params) +#endif - __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)); +#define __inline_mathop_decl_(float_type, func, op, params...) \ + __MATHINLINE float_type func (float_type); \ + __MATHINLINE float_type func (float_type __x) \ + { \ + register float_type __result; \ + __asm __volatile__ (op : "=t" (__results) : params); \ + return __result; \ + } + + +#if defined __USE_MISC || defined __USE_ISOC9X +# define __inline_mathcode(func, arg, code) \ + __inline_mathcode_ (double, func, arg, code) \ + __inline_mathcode_ (float, __CONCAT(func,f), arg, code) \ + __inline_mathcode_ (long double, __CONCAT(func,l), arg, code) +#else +# define __inline_mathcode(func, arg, code) \ + __inline_mathcode_ (double, func, arg, code) +#endif - return __value; -} +#define __inline_mathcode_(float_type, func, arg, code) \ + __MATH_INLINE float_type func (float_type); \ + __MATH_INLINE float_type func (float_type arg) \ + { \ + code; \ + } -__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)); +#if defined __USE_MISC || defined __USE_ISOC9X +# define __inline_mathcode2(func, arg1, arg2, code) \ + __inline_mathcode2_ (double, func, arg1, arg2, code) \ + __inline_mathcode2_ (float, __CONCAT(func,f), arg1, arg2, code) \ + __inline_mathcode2_ (long double, __CONCAT(func,l), arg1, arg2, code) +#else +# define __inline_mathcode2(func, arg1, arg2, code) \ + __inline_mathcode2_ (double, func, arg1, arg2, code) +#endif - return __value; -} +#define __inline_mathcode2_(float_type, func, arg1, arg2, code) \ + __MATH_INLINE float_type func (float_type, float_type); \ + __MATH_INLINE float_type func (float_type arg1, float_type arg2) \ + { \ + code; \ + } + + +/* Optimized inline implementation, sometimes woth reduced precision + and/or argument range. */ +#define __expm1_code \ + register long double __value; \ + register long double __exponent; \ + register long double __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 +__inline_mathcode_ (long double, __expm1l, __x, __expm1_code) + + +#define __exp_code \ + register long double __value; \ + register long double __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 +__inline_mathcode (exp, __x, __exp_code) +__inline_mathcode_ (long double, __expl, __x, __exp_code) + + +__inline_mathcode (tan, __x, \ + register long double __value; \ + register long double __value2 __attribute__ ((unused)); \ + __asm __volatile__ \ + ("fptan" \ + : "=t" (__value2), "=u" (__value) : "0" (__x)); \ + return __value) + + +#define __atan2_code \ + register long double __value; \ + __asm __volatile__ \ + ("fpatan\n\t" \ + : "=t" (__value) : "0" (__x), "u" (__y) : "st(1)"); \ + return __value +__inline_mathcode2 (atan2, __y, __x, __atan2_code) +__inline_mathcode2_ (long double, __atan2l, __y, __x, __atan2_code) + + +__inline_mathcode2 (fmod, __x, __y, \ + register long double __value; \ + __asm __volatile__ \ + ("1: fprem\n\t" \ + "fnstsw %%ax\n\t" \ + "sahf\n\t" \ + "jp 1b" \ + : "=t" (__value) : "0" (__x), "u" (__y) : "ax", "cc"); \ + return __value) + + +__inline_mathcode2 (pow, __x, __y, \ + register long double __value; \ + register long double __exponent; \ + long int __p = (long int) __y; \ + if (__x == 0.0 && __y > 0.0) \ + return 0.0; \ + if (__y == (double) __p) \ + { \ + long 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__ \ + ("fyl2x" : "=t" (__value) : "0" (__x), "u" (1.0) : "st1"); \ + __asm __volatile__ \ + ("fmul %%st(1) # y * log2(x)\n\t" \ + "fst %%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" (__y), "1" (__value)); \ + __value += 1.0; \ + __asm __volatile__ \ + ("fscale" \ + : "=t" (__value) : "0" (__value), "u" (__exponent)); \ + return __value) + + +__inline_mathop (sqrt, "fsqrt") +__inline_mathop_ (long double, __sqrtl, "fsqrt") + +__inline_mathop (fabs, "fabs") + +/* The argument range of this inline version is reduced. */ +__inline_mathop (sin, "fsin") +/* The argument range of this inline version is reduced. */ +__inline_mathop (cos, "fcos") + +__inline_mathop (atan, "fld1; fpatan") +__inline_mathop (log, "fldln2; fxch; fyl2x") +__inline_mathop (log10, "fldlg2; fxch; fyl2x") + +__inline_mathcode (asin, __x, return __atan2l (__x, __sqrtl (1.0 - __x * __x))) +__inline_mathcode (acos, __x, return __atan2l (__sqrtl (1.0 - __x * __x), __x)) + +__inline_mathcode (__sgn1, __x, return __x >= 0.0 ? 1.0 : -1.0) + + +/* The argument range of the inline version of sinhl is slightly reduced. */ +__inline_mathcode (sinh, __x, \ + register long double __exm1 = __expm1l (__builtin_fabsl (__x)); \ + return 0.5 * (__exm1 / (__exm1 + 1.0) + __exm1) * __sgn1l (__x)) + +__inline_mathcode (cosh, __x, \ + register long double __ex = __expl (__x); \ + return 0.5 * (__ex + 1.0 / __ex)) + +__inline_mathcode (tanh, __x, \ + register long double __exm1 = __expm1l (-__builtin_fabsl (__x + __x)); \ + return __exm1 / (__exm1 + 2.0) * __sgn1l (-__x)) + + +__inline_mathcode (floor, __x, \ + register long double __value; \ + __volatile unsigned short int __cw; \ + __volatile unsigned short int __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) + +__inline_mathcode (ceil, __x, \ + register long double __value; \ + __volatile unsigned short int __cw; \ + __volatile unsigned short int __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); -} +__inline_mathop_decl (log2, "fyl2x", "u" (1.0), "0" (__x) : "st(1)") + +__inline_mathcode (expm1, __x, __expm1_code) /* 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; -} +__inline_mathcode (log1p, __x, \ + register long double __value; \ + if (__builtin_fabsl (__x) >= 1.0 - 0.5 * __M_SQRT2) \ + __value = logl (1.0 + __x); \ + else \ + __asm __volatile__ \ + ("fldln2\n\t" \ + "fxch\n\t" \ + "fyl2xp1" \ + : "=t" (__value) : "0" (__x)); \ + return __value) + + +/* The argument range of the inline version of asinhl is slightly reduced. */ +__inline_mathcode (asinh, __x, \ + register long double __y = __builtin_fabsl (__x); \ + return (log1pl (__y * __y / (__sqrtl (__y * __y + 1.0) + 1.0) + __y) \ + * __sgn1l (__x)) + +__inline_mathcode (acosh, __x, \ + return logl (__x + __sqrtl (__x - 1.0) * __sqrtl (__x + 1.0))) + +__inline_mathcode (atanh, __x, \ + register long double __y = __builtin_fabsl (__x); \ + return (-0.5 * log1pl (-(__y + __y) / (1.0 + __y)) * \ + __sgn1l (__x))) + + +/* The argument range of the inline version of hypotl is slightly reduced. */ +__inline_mathcode2 (hypot, __x, __y, return __sqrtl (__x * __x + __y * __y)) + +__inline_mathcode(logb, __x, \ + register long double __value; \ + register long double __junk; \ + __asm __volatile__ \ + ("fxtract\n\t" \ + : "=t" (__junk), "=u" (__value) : "0" (__x)); \ + return __value) + + +__inline_mathcode2 (ldexp, __x, __y, \ + register long double __value; \ + __asm __volatile__ \ + ("fscale" \ + : "=t" (__value) : "0" (__x), "u" ((long double) __y)); \ + 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; -} +__inline_mathcode2 (drem, __x, __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); @@ -522,82 +425,89 @@ __finite (double __x) 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); +/* Miscellaneous functions */ + +__inline_mathcode (__sgn, __x, \ + return __x == 0.0 ? 0.0 : (__x > 0.0 ? 1.0 : -1.0)) + +__inline_mathcode (__coshm1, __x, \ + register long double __exm1 = __expm1l (__builtin_fabsl (__x)); \ + return 0.5 * (__exm1 / (__exm1 + 1.0)) * __exm1) + +__inline_mathcode (__acosh1p, __x, \ + return log1pl (__x + __sqrtl (__x) * __sqrtl (__x + 2.0))) + +__inline_mathcode (__pow2, __x, \ + register long double __value; \ + register long double __exponent; \ + long int __p = (long int) __x; \ + if (__x == (long double) __p) \ + return ldexpl (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) + +#define __sincos_code \ + register long double __cosr; \ + register long double __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 void __sincos (double __x, double *__sinx, double *__cosx); __MATH_INLINE void -sincos (double __x, double *__sinx, double *__cosx) +__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; + __sincos_code; } -__MATH_INLINE double sgn (double __x); -__MATH_INLINE double -sgn (double __x) +__MATH_INLINE void __sincosf (float __x, float *__sinx, float *__cosx); +__MATH_INLINE void +__sincosf (float __x, float *__sinx, float *__cosx) { - return __x == 0.0 ? 0.0 : (__x > 0.0 ? 1.0 : -1.0); + __sincos_code; } -__MATH_INLINE double pow2 (double __x); -__MATH_INLINE double -pow2 (double __x) +__MATH_INLINE void __sincosl (long double __x, long double *__sinx, + long double *__cosx); +__MATH_INLINE void +__sincosl (long double __x, long double *__sinx, long double *__cosx) { - 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; + __sincos_code; } #endif /* __USE_MISC */ +/* Undefine some of the large macros which are not used anymore. */ +#undef __expm1_code +#undef __exp_code +#undef __atan2_code +#undef __sincos_code + #endif /* __NO_MATH_INLINES */ #endif /* __GNUC__ */ -- cgit 1.4.1