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/alpha/dl-machine.h | 6 +- sysdeps/generic/htons.c | 2 +- sysdeps/i386/dl-machine.h | 51 +- sysdeps/i386/fpu/bits/mathinline.h | 868 +++++++++++++++------------------- sysdeps/m68k/bits/byteswap.h | 63 +++ sysdeps/m68k/dl-machine.h | 7 +- sysdeps/mips/dl-machine.h | 6 +- sysdeps/mips/mips64/dl-machine.h | 6 +- sysdeps/powerpc/dl-machine.h | 6 +- sysdeps/sparc/dl-machine.h | 2 +- sysdeps/sparc64/dl-machine.h | 6 +- sysdeps/unix/sysv/linux/bits/socket.h | 8 +- 12 files changed, 521 insertions(+), 510 deletions(-) create mode 100644 sysdeps/m68k/bits/byteswap.h (limited to 'sysdeps') diff --git a/sysdeps/alpha/dl-machine.h b/sysdeps/alpha/dl-machine.h index 49d6830a65..746cdd236b 100644 --- a/sysdeps/alpha/dl-machine.h +++ b/sysdeps/alpha/dl-machine.h @@ -87,7 +87,7 @@ elf_machine_load_address (void) entries will jump to the on-demand fixup code in dl-runtime.c. */ static inline int -elf_machine_runtime_setup (struct link_map *l, int lazy) +elf_machine_runtime_setup (struct link_map *l, int lazy, int profile) { Elf64_Addr plt; extern void _dl_runtime_resolve (void); @@ -348,9 +348,9 @@ static inline void elf_machine_rela (struct link_map *map, const Elf64_Rela *reloc, const Elf64_Sym *sym, - const struct r_found_version *version) + const struct r_found_version *version, + Elf64_Addr *const reloc_addr) { - Elf64_Addr * const reloc_addr = (void *)(map->l_addr + reloc->r_offset); unsigned long const r_type = ELF64_R_TYPE (reloc->r_info); #ifndef RTLD_BOOTSTRAP diff --git a/sysdeps/generic/htons.c b/sysdeps/generic/htons.c index 8914f74f2e..1bbda3fd6a 100644 --- a/sysdeps/generic/htons.c +++ b/sysdeps/generic/htons.c @@ -22,7 +22,7 @@ #undef ntohs u_int16_t -__htons (x) +htons (x) u_int16_t x; { #if BYTE_ORDER == BIG_ENDIAN 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__ */ diff --git a/sysdeps/m68k/bits/byteswap.h b/sysdeps/m68k/bits/byteswap.h new file mode 100644 index 0000000000..54ec0d1920 --- /dev/null +++ b/sysdeps/m68k/bits/byteswap.h @@ -0,0 +1,63 @@ +/* Macros to swap the order of bytes in integer values. m68k version. + Copyright (C) 1997 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + 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_BYTESWAP_H +#define _BITS_BYTESWAP_H 1 + +/* Swap bytes in 16 bit value. We don't provide an assembler version + because GCC is smart enough to generate optimal assembler output, and + this allows for better cse. */ +#define __bswap_16(x) \ + ((((x) >> 8) & 0xff) | (((x) & 0xff) << 8)) + +/* Swap bytes in 32 bit value. */ +#define __bswap_constant_32(x) \ + ((((x) & 0xff000000) >> 24) | (((x) & 0x00ff0000) >> 8) | \ + (((x) & 0x0000ff00) << 8) | (((x) & 0x000000ff) << 24)) + +#if defined __GNUC__ && __GNUC__ >= 2 +#define __bswap_32(x) \ + __extension__ \ + ({ unsigned int __v; \ + if (__builtin_constant_p (x)) \ + __v = __bswap_constant_32 (x); \ + else \ + __asm__ __volatile__ ("ror%.w %#8, %0;" \ + "swap %0;" \ + "ror%.w %#8, %0" \ + : "=d" (__v) \ + : "0" (x)); \ + __v; }) +#else +#define __bswap_32(x) __bswap_constant_32 (x) +#endif + +#if defined __GNUC__ && __GNUC__ >= 2 +/* Swap bytes in 64 bit value. */ +#define __bswap_64(x) \ + __extension__ \ + ({ union { unsigned long long int __ll; \ + unsigned long int __l[2]; } __v, __r; \ + __v.__ll = (x); \ + __r.__l[0] = __bswap_32 (__v.__l[1]); \ + __r.__l[1] = __bswap_32 (__v.__l[0]); \ + __r.__ll; }) +#endif + +#endif /* bits/byteswap.h */ diff --git a/sysdeps/m68k/dl-machine.h b/sysdeps/m68k/dl-machine.h index c0a17c73c2..7c62aa2aad 100644 --- a/sysdeps/m68k/dl-machine.h +++ b/sysdeps/m68k/dl-machine.h @@ -76,7 +76,7 @@ elf_machine_load_address (void) entries will jump to the on-demand fixup code in dl-runtime.c. */ static inline int -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); @@ -211,10 +211,9 @@ _dl_start_user: static inline void elf_machine_rela (struct link_map *map, const Elf32_Rela *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_68K_RELATIVE) *reloc_addr = map->l_addr + reloc->r_addend; else diff --git a/sysdeps/mips/dl-machine.h b/sysdeps/mips/dl-machine.h index fce7cffb4a..6973f7612a 100644 --- a/sysdeps/mips/dl-machine.h +++ b/sysdeps/mips/dl-machine.h @@ -219,7 +219,7 @@ elf_machine_got_rel (struct link_map *map, int lazy) will jump to the on-demand fixup code in dl-runtime.c. */ static inline int -elf_machine_runtime_setup (struct link_map *l, int lazy) +elf_machine_runtime_setup (struct link_map *l, int lazy, int profile) { ElfW(Addr) *got; extern void _dl_runtime_resolve (ElfW(Word)); @@ -533,9 +533,9 @@ _RTLD_EPILOGUE(ENTRY_POINT)\ static inline void elf_machine_rel (struct link_map *map, const ElfW(Rel) *reloc, - const ElfW(Sym) *sym, const struct r_found_version *version) + const ElfW(Sym) *sym, const struct r_found_version *version, + ElfW(Addr) *const reloc_addr) { - ElfW(Addr) *const reloc_addr = (void *) (map->l_addr + reloc->r_offset); ElfW(Addr) loadbase; ElfW(Addr) undo __attribute__ ((unused)); diff --git a/sysdeps/mips/mips64/dl-machine.h b/sysdeps/mips/mips64/dl-machine.h index a20835af35..e501a2520e 100644 --- a/sysdeps/mips/mips64/dl-machine.h +++ b/sysdeps/mips/mips64/dl-machine.h @@ -219,7 +219,7 @@ elf_machine_got_rel (struct link_map *map, int lazy) will jump to the on-demand fixup code in dl-runtime.c. */ static inline int -elf_machine_runtime_setup (struct link_map *l, int lazy) +elf_machine_runtime_setup (struct link_map *l, int lazy, int profile) { ElfW(Addr) *got; extern void _dl_runtime_resolve (ElfW(Word)); @@ -529,9 +529,9 @@ _RTLD_EPILOGUE(ENTRY_POINT) \ static inline void elf_machine_rel (struct link_map *map, const ElfW(Rel) *reloc, - const ElfW(Sym) *sym, const struct r_found_version *version) + const ElfW(Sym) *sym, const struct r_found_version *version, + ElfW(Addr) *const reloc_addr) { - ElfW(Addr) *const reloc_addr = (void *) (map->l_addr + reloc->r_offset); ElfW(Addr) loadbase; ElfW(Addr) undo __attribute__ ((unused)); diff --git a/sysdeps/powerpc/dl-machine.h b/sysdeps/powerpc/dl-machine.h index 12bcf43e4d..c9d1d7332a 100644 --- a/sysdeps/powerpc/dl-machine.h +++ b/sysdeps/powerpc/dl-machine.h @@ -391,7 +391,7 @@ static ElfW(Addr) _dl_preferred_address = 1 ELF_MACHINE_RUNTIME_TRAMPOLINE, which resets the PLT entry to be one of the above two types. These entries are set up here. */ static inline int -elf_machine_runtime_setup (struct link_map *map, int lazy) +elf_machine_runtime_setup (struct link_map *map, int lazy, int profile) { if (map->l_info[DT_JMPREL]) { @@ -510,10 +510,10 @@ elf_machine_lazy_rel (struct link_map *map, const Elf32_Rela *reloc) static inline void elf_machine_rela (struct link_map *map, const Elf32_Rela *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) { const Elf32_Sym *const refsym = sym; - Elf32_Addr *const reloc_addr = (Elf32_Addr *)(map->l_addr + reloc->r_offset); Elf32_Word loadbase, finaladdr; const int rinfo = ELF32_R_TYPE (reloc->r_info); diff --git a/sysdeps/sparc/dl-machine.h b/sysdeps/sparc/dl-machine.h index 1d193ae91c..b50549c0ec 100644 --- a/sysdeps/sparc/dl-machine.h +++ b/sysdeps/sparc/dl-machine.h @@ -224,7 +224,7 @@ elf_machine_lazy_rel (struct link_map *map, const Elf32_Rela *reloc) entries will jump to the on-demand fixup code in dl-runtime.c. */ static inline int -elf_machine_runtime_setup (struct link_map *l, int lazy) +elf_machine_runtime_setup (struct link_map *l, int lazy, int profile) { Elf32_Addr *plt; extern void _dl_runtime_resolve (Elf32_Word); diff --git a/sysdeps/sparc64/dl-machine.h b/sysdeps/sparc64/dl-machine.h index ad216b79dc..df09c8fc85 100644 --- a/sysdeps/sparc64/dl-machine.h +++ b/sysdeps/sparc64/dl-machine.h @@ -68,9 +68,9 @@ elf_machine_load_address (void) static inline void elf_machine_rela (struct link_map *map, const Elf64_Rela *reloc, - const Elf64_Sym *sym, const struct r_found_version *version) + const Elf64_Sym *sym, const struct r_found_version *version, + Elf64_Addr *const reloc_addr) { - Elf64_Addr *const reloc_addr = (void *) (map->l_addr + reloc->r_offset); Elf64_Addr loadbase; #ifndef RTLD_BOOTSTRAP @@ -200,7 +200,7 @@ elf_machine_lazy_rel (struct link_map *map, const Elf64_Rela *reloc) entries will jump to the on-demand fixup code in dl-runtime.c. */ static inline int -elf_machine_runtime_setup (struct link_map *l, int lazy) +elf_machine_runtime_setup (struct link_map *l, int lazy, int profile) { Elf64_Addr *got; extern void _dl_runtime_resolve (Elf64_Word); diff --git a/sysdeps/unix/sysv/linux/bits/socket.h b/sysdeps/unix/sysv/linux/bits/socket.h index e3f53a97be..a17c37fd8e 100644 --- a/sysdeps/unix/sysv/linux/bits/socket.h +++ b/sysdeps/unix/sysv/linux/bits/socket.h @@ -28,6 +28,7 @@ #define __need_NULL #include +#include __BEGIN_DECLS @@ -130,25 +131,26 @@ struct msghdr { __ptr_t msg_name; /* Address to send to/receive from. */ int msg_namelen; /* Length of address data. */ - /* XXX Should be type `size_t' according to POSIX.1g. */ + /* XXX Should be type `socklen_t' according to POSIX.1g. */ struct iovec *msg_iov; /* Vector of data to send/receive into. */ size_t msg_iovlen; /* Number of elements in the vector. */ __ptr_t msg_control; /* Ancillary data (eg BSD filedesc passing). */ - size_t msg_controllen; /* Ancillary data buffer length. */ + socklen_t msg_controllen; /* Ancillary data buffer length. */ int msg_flags; /* Flags on received message. */ }; /* Structure used for storage of ancillary data object information. */ struct cmsghdr { - size_t cmsg_len; /* Length of data in cmsg_data plus length + socklen_t cmsg_len; /* Length of data in cmsg_data plus length of cmsghdr structure. */ int cmsg_level; /* Originating protocol. */ int cmsg_type; /* Protocol specific type. */ #if !defined __STRICT_ANSI__ && defined __GNUC__ && __GNUC__ >= 2 unsigned char __cmsg_data[0]; /* Ancillary data. */ + /* XXX Perhaps this should be removed. */ #endif }; -- cgit v1.2.3