2005-09-08 Jeff Johnston <jjohnstn@redhat.com>
* Makefile.am: Add include files under bits sub-directory.
* Makefile.in: Regenerated.
* libc/sys/linux/argp/argp-fs-xinl.c: Set __OPTIMIZE__ to
actual value of 1 to be compatible with newer glibc headers.
* libc/sys/linux/sys/cdefs.h: Fix to be compatible with newer
glibc headers.
* libc/sys/linux/sys/dirent.h: Ditto.
* libc/sys/linux/argp/argp-xinl.c: Ditto.
* libc/sys/linux/dl/dl-runtime.c: Make sure fixup and
profile_fixup routines are marked used so they won't be
optimized away.
* libc/sys/linux/dl/dl-cache.c: Don't use weak_extern macro
to mark functions as weak.
* libc/sys/linux/dl/dl-open.c: Ditto.
* libc/sys/linux/iconv/gconv_open.c: Fix to obey new gcc4
rules about lvalues.
* libc/sys/linux/iconv/gconv_simple.c: Ditto.
* libc/sys/linux/linuxthreads/bits/libc-lock.h: Don't use
weak_extern macro to mark functions as weak. Instead always
use #pragma weak.
* iconvdata/jis0208.h: Fix to work with gcc4.
* libc/sys/linux/dl/dl-load.c: Ditto.
* libc/sys/linux/dl/dl-reloc.c: Ditto.
* libc/sys/linux/dl/do-rel.h: Ditto.
* libc/sys/linux/dl/dynamic-link.h: Ditto.
* libc/sys/linux/include/ltdl.h: Ditto.
* libc/sys/linux/machine/i386/dl-machine.h: Ditto.
* libc/sys/linux/machine/i386/weakalias.h: Ditto.
* libc/sys/linux/net/ns_ntoa.c: Ditto.
* libc/sys/linux/bits/initspin.h: New file.
* libc/sys/linux/bits/libc-lock.h: Ditto.
* libc/sys/linux/bits/pthreadtypes.h: Ditto.
* libc/sys/linux/bits/typesizes.h: Ditto.
This commit is contained in:
Jeff Johnston
parent
7b786e4861
commit
b10ab72581
|
|
@ -1,3 +1,39 @@
|
|||
2005-09-08 Jeff Johnston <jjohnstn@redhat.com>
|
||||
|
||||
* Makefile.am: Add include files under bits sub-directory.
|
||||
* Makefile.in: Regenerated.
|
||||
* libc/sys/linux/argp/argp-fs-xinl.c: Set __OPTIMIZE__ to
|
||||
actual value of 1 to be compatible with newer glibc headers.
|
||||
* libc/sys/linux/sys/cdefs.h: Fix to be compatible with newer
|
||||
glibc headers.
|
||||
* libc/sys/linux/sys/dirent.h: Ditto.
|
||||
* libc/sys/linux/argp/argp-xinl.c: Ditto.
|
||||
* libc/sys/linux/dl/dl-runtime.c: Make sure fixup and
|
||||
profile_fixup routines are marked used so they won't be
|
||||
optimized away.
|
||||
* libc/sys/linux/dl/dl-cache.c: Don't use weak_extern macro
|
||||
to mark functions as weak.
|
||||
* libc/sys/linux/dl/dl-open.c: Ditto.
|
||||
* libc/sys/linux/iconv/gconv_open.c: Fix to obey new gcc4
|
||||
rules about lvalues.
|
||||
* libc/sys/linux/iconv/gconv_simple.c: Ditto.
|
||||
* libc/sys/linux/linuxthreads/bits/libc-lock.h: Don't use
|
||||
weak_extern macro to mark functions as weak. Instead always
|
||||
use #pragma weak.
|
||||
* iconvdata/jis0208.h: Fix to work with gcc4.
|
||||
* libc/sys/linux/dl/dl-load.c: Ditto.
|
||||
* libc/sys/linux/dl/dl-reloc.c: Ditto.
|
||||
* libc/sys/linux/dl/do-rel.h: Ditto.
|
||||
* libc/sys/linux/dl/dynamic-link.h: Ditto.
|
||||
* libc/sys/linux/include/ltdl.h: Ditto.
|
||||
* libc/sys/linux/machine/i386/dl-machine.h: Ditto.
|
||||
* libc/sys/linux/machine/i386/weakalias.h: Ditto.
|
||||
* libc/sys/linux/net/ns_ntoa.c: Ditto.
|
||||
* libc/sys/linux/bits/initspin.h: New file.
|
||||
* libc/sys/linux/bits/libc-lock.h: Ditto.
|
||||
* libc/sys/linux/bits/pthreadtypes.h: Ditto.
|
||||
* libc/sys/linux/bits/typesizes.h: Ditto.
|
||||
|
||||
2005-09-08 Eric Blake <ebb9@byu.net>
|
||||
|
||||
* libc/argz/argz_insert.c (argz_insert): Don't die with EINVAL when
|
||||
|
|
|
|||
|
|
@ -281,6 +281,7 @@ endif
|
|||
$(INSTALL_DATA) $$i $(DESTDIR)$(tooldir)/include/sys/`basename $$i`; \
|
||||
else true; fi ; \
|
||||
done ; \
|
||||
$(mkinstalldirs) $(DESTDIR)$(tooldir)/include/bits; \
|
||||
for i in $(srcdir)/libc/sys/$(sys_dir)/bits/*.h; do \
|
||||
if [ -f $$i ]; then \
|
||||
$(INSTALL_DATA) $$i $(DESTDIR)$(tooldir)/include/bits/`basename $$i`; \
|
||||
|
|
|
|||
|
|
@ -787,6 +787,7 @@ install-data-local: install-toollibLIBRARIES
|
|||
$(INSTALL_DATA) $$i $(DESTDIR)$(tooldir)/include/sys/`basename $$i`; \
|
||||
else true; fi ; \
|
||||
done ; \
|
||||
$(mkinstalldirs) $(DESTDIR)$(tooldir)/include/bits; \
|
||||
for i in $(srcdir)/libc/sys/$(sys_dir)/bits/*.h; do \
|
||||
if [ -f $$i ]; then \
|
||||
$(INSTALL_DATA) $$i $(DESTDIR)$(tooldir)/include/bits/`basename $$i`; \
|
||||
|
|
|
|||
|
|
@ -24,15 +24,6 @@
|
|||
#include <gconv.h>
|
||||
#include <stdint.h>
|
||||
|
||||
/* Conversion table. */
|
||||
extern const uint16_t __jis0208_to_ucs[];
|
||||
|
||||
extern const char __jisx0208_from_ucs4_lat1[256][2];
|
||||
extern const char __jisx0208_from_ucs4_greek[0xc1][2];
|
||||
extern const struct jisx0208_ucs_idx __jisx0208_from_ucs_idx[];
|
||||
extern const char __jisx0208_from_ucs_tab[][2];
|
||||
|
||||
|
||||
/* Struct for table with indeces in UCS mapping table. */
|
||||
struct jisx0208_ucs_idx
|
||||
{
|
||||
|
|
@ -41,6 +32,13 @@ struct jisx0208_ucs_idx
|
|||
uint16_t idx;
|
||||
};
|
||||
|
||||
/* Conversion table. */
|
||||
extern const uint16_t __jis0208_to_ucs[];
|
||||
|
||||
extern const char __jisx0208_from_ucs4_lat1[256][2];
|
||||
extern const char __jisx0208_from_ucs4_greek[0xc1][2];
|
||||
extern const struct jisx0208_ucs_idx __jisx0208_from_ucs_idx[];
|
||||
extern const char __jisx0208_from_ucs_tab[][2];
|
||||
|
||||
static inline uint32_t
|
||||
jisx0208_to_ucs4 (const unsigned char **s, size_t avail, unsigned char offset)
|
||||
|
|
|
|||
|
|
@ -24,7 +24,7 @@
|
|||
|
||||
#define ARGP_FS_EI
|
||||
#undef __OPTIMIZE__
|
||||
#define __OPTIMIZE__
|
||||
#define __OPTIMIZE__ 1
|
||||
#include "argp-fmtstream.h"
|
||||
|
||||
/* Add weak aliases. */
|
||||
|
|
|
|||
|
|
@ -29,7 +29,7 @@
|
|||
#endif
|
||||
#define ARGP_EI
|
||||
#undef __OPTIMIZE__
|
||||
#define __OPTIMIZE__
|
||||
#define __OPTIMIZE__ 1
|
||||
#include <argp.h>
|
||||
|
||||
/* Add weak aliases. */
|
||||
|
|
|
|||
|
|
@ -0,0 +1,28 @@
|
|||
/* Generic definitions for spinlock initializers.
|
||||
Copyright (C) 2000, 2001 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 Lesser General Public License as
|
||||
published by the Free Software Foundation; either version 2.1 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
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser 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. */
|
||||
|
||||
/* Initial value of a spinlock. Most platforms should use zero,
|
||||
unless they only implement a "test and clear" operation instead of
|
||||
the usual "test and set". */
|
||||
#define __LT_SPINLOCK_INIT 0
|
||||
|
||||
/* Macros for lock initializers, using the above definition. */
|
||||
#define __LOCK_INITIALIZER { 0, __LT_SPINLOCK_INIT }
|
||||
#define __ALT_LOCK_INITIALIZER { 0, __LT_SPINLOCK_INIT }
|
||||
#define __ATOMIC_INITIALIZER { 0, __LT_SPINLOCK_INIT }
|
||||
|
|
@ -0,0 +1,380 @@
|
|||
/* libc-internal interface for mutex locks. LinuxThreads version.
|
||||
Copyright (C) 1996,1997,1998,1999,2000,2001,2002,2003
|
||||
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 Lesser General Public License as
|
||||
published by the Free Software Foundation; either version 2.1 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
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser 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_LIBC_LOCK_H
|
||||
#define _BITS_LIBC_LOCK_H 1
|
||||
|
||||
#include <pthread.h>
|
||||
|
||||
#if defined _LIBC && !defined NOT_IN_libc
|
||||
#include <linuxthreads/internals.h>
|
||||
#endif
|
||||
|
||||
/* Mutex type. */
|
||||
#if defined(_LIBC) || defined(_IO_MTSAFE_IO)
|
||||
typedef pthread_mutex_t __libc_lock_t;
|
||||
typedef struct { pthread_mutex_t mutex; } __libc_lock_recursive_t;
|
||||
# ifdef __USE_UNIX98
|
||||
typedef pthread_rwlock_t __libc_rwlock_t;
|
||||
# else
|
||||
typedef struct __libc_rwlock_opaque__ __libc_rwlock_t;
|
||||
# endif
|
||||
typedef __libc_lock_recursive_t __rtld_lock_recursive_t;
|
||||
#else
|
||||
typedef struct __libc_lock_opaque__ __libc_lock_t;
|
||||
typedef struct __libc_lock_recursive_opaque__ __libc_lock_recursive_t;
|
||||
typedef struct __libc_rwlock_opaque__ __libc_rwlock_t;
|
||||
#endif
|
||||
|
||||
/* Type for key to thread-specific data. */
|
||||
typedef pthread_key_t __libc_key_t;
|
||||
|
||||
/* Define a lock variable NAME with storage class CLASS. The lock must be
|
||||
initialized with __libc_lock_init before it can be used (or define it
|
||||
with __libc_lock_define_initialized, below). Use `extern' for CLASS to
|
||||
declare a lock defined in another module. In public structure
|
||||
definitions you must use a pointer to the lock structure (i.e., NAME
|
||||
begins with a `*'), because its storage size will not be known outside
|
||||
of libc. */
|
||||
#define __libc_lock_define(CLASS,NAME) \
|
||||
CLASS __libc_lock_t NAME;
|
||||
#define __libc_rwlock_define(CLASS,NAME) \
|
||||
CLASS __libc_rwlock_t NAME;
|
||||
#define __libc_lock_define_recursive(CLASS,NAME) \
|
||||
CLASS __libc_lock_recursive_t NAME;
|
||||
#define __rtld_lock_define_recursive(CLASS,NAME) \
|
||||
CLASS __rtld_lock_recursive_t NAME;
|
||||
|
||||
/* Define an initialized lock variable NAME with storage class CLASS.
|
||||
|
||||
For the C library we take a deeper look at the initializer. For
|
||||
this implementation all fields are initialized to zero. Therefore
|
||||
we don't initialize the variable which allows putting it into the
|
||||
BSS section. (Except on PA-RISC and other odd architectures, where
|
||||
initialized locks must be set to one due to the lack of normal
|
||||
atomic operations.) */
|
||||
|
||||
#if __LT_SPINLOCK_INIT == 0
|
||||
# define __libc_lock_define_initialized(CLASS,NAME) \
|
||||
CLASS __libc_lock_t NAME;
|
||||
#else
|
||||
# define __libc_lock_define_initialized(CLASS,NAME) \
|
||||
CLASS __libc_lock_t NAME = PTHREAD_MUTEX_INITIALIZER;
|
||||
#endif
|
||||
|
||||
#define __libc_rwlock_define_initialized(CLASS,NAME) \
|
||||
CLASS __libc_rwlock_t NAME = PTHREAD_RWLOCK_INITIALIZER;
|
||||
|
||||
/* Define an initialized recursive lock variable NAME with storage
|
||||
class CLASS. */
|
||||
#define __libc_lock_define_initialized_recursive(CLASS,NAME) \
|
||||
CLASS __libc_lock_recursive_t NAME = _LIBC_LOCK_RECURSIVE_INITIALIZER;
|
||||
#define _LIBC_LOCK_RECURSIVE_INITIALIZER \
|
||||
{PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP}
|
||||
|
||||
#define __rtld_lock_define_initialized_recursive(CLASS,NAME) \
|
||||
CLASS __rtld_lock_recursive_t NAME = _RTLD_LOCK_RECURSIVE_INITIALIZER;
|
||||
#define _RTLD_LOCK_RECURSIVE_INITIALIZER \
|
||||
{PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP}
|
||||
|
||||
#if defined _LIBC && defined IS_IN_libpthread
|
||||
# define __libc_maybe_call(FUNC, ARGS, ELSE) FUNC ARGS
|
||||
#else
|
||||
# if defined __PIC__ || (defined _LIBC && defined SHARED)
|
||||
# define __libc_maybe_call(FUNC, ARGS, ELSE) \
|
||||
(__extension__ ({ __typeof (FUNC) *_fn = (FUNC); \
|
||||
_fn != NULL ? (*_fn) ARGS : ELSE; }))
|
||||
# else
|
||||
# define __libc_maybe_call(FUNC, ARGS, ELSE) \
|
||||
(FUNC != NULL ? FUNC ARGS : ELSE)
|
||||
# endif
|
||||
#endif
|
||||
#if defined _LIBC && !defined NOT_IN_libc && defined SHARED
|
||||
# define __libc_maybe_call2(FUNC, ARGS, ELSE) \
|
||||
({__builtin_expect (__libc_pthread_functions.ptr_##FUNC != NULL, 0) \
|
||||
? __libc_pthread_functions.ptr_##FUNC ARGS : ELSE; })
|
||||
#else
|
||||
# define __libc_maybe_call2(FUNC, ARGS, ELSE) __libc_maybe_call (__##FUNC, ARGS, ELSE)
|
||||
#endif
|
||||
|
||||
/* Initialize the named lock variable, leaving it in a consistent, unlocked
|
||||
state. */
|
||||
#if defined _LIBC && !defined NOT_IN_libc && defined SHARED
|
||||
#define __libc_lock_init(NAME) \
|
||||
({ \
|
||||
(NAME).__m_count = 0; \
|
||||
(NAME).__m_owner = NULL; \
|
||||
(NAME).__m_kind = PTHREAD_MUTEX_TIMED_NP; \
|
||||
(NAME).__m_lock.__status = 0; \
|
||||
(NAME).__m_lock.__spinlock = __LT_SPINLOCK_INIT; \
|
||||
0; })
|
||||
#else
|
||||
#define __libc_lock_init(NAME) \
|
||||
(__libc_maybe_call2 (pthread_mutex_init, (&(NAME), NULL), 0))
|
||||
#endif
|
||||
#define __libc_rwlock_init(NAME) \
|
||||
(__libc_maybe_call (__pthread_rwlock_init, (&(NAME), NULL), 0));
|
||||
|
||||
/* Same as last but this time we initialize a recursive mutex. */
|
||||
#if defined _LIBC && !defined NOT_IN_libc && defined SHARED
|
||||
#define __libc_lock_init_recursive(NAME) \
|
||||
({ \
|
||||
(NAME).mutex.__m_count = 0; \
|
||||
(NAME).mutex.__m_owner = NULL; \
|
||||
(NAME).mutex.__m_kind = PTHREAD_MUTEX_RECURSIVE_NP; \
|
||||
(NAME).mutex.__m_lock.__status = 0; \
|
||||
(NAME).mutex.__m_lock.__spinlock = __LT_SPINLOCK_INIT; \
|
||||
0; })
|
||||
#else
|
||||
#define __libc_lock_init_recursive(NAME) \
|
||||
do { \
|
||||
if (__pthread_mutex_init != NULL) \
|
||||
{ \
|
||||
pthread_mutexattr_t __attr; \
|
||||
__pthread_mutexattr_init (&__attr); \
|
||||
__pthread_mutexattr_settype (&__attr, PTHREAD_MUTEX_RECURSIVE_NP); \
|
||||
__pthread_mutex_init (&(NAME).mutex, &__attr); \
|
||||
__pthread_mutexattr_destroy (&__attr); \
|
||||
} \
|
||||
} while (0);
|
||||
#endif
|
||||
#define __rtld_lock_init_recursive(NAME) \
|
||||
__libc_lock_init_recursive (NAME)
|
||||
|
||||
/* Finalize the named lock variable, which must be locked. It cannot be
|
||||
used again until __libc_lock_init is called again on it. This must be
|
||||
called on a lock variable before the containing storage is reused. */
|
||||
#define __libc_lock_fini(NAME) \
|
||||
(__libc_maybe_call2 (pthread_mutex_destroy, (&(NAME)), 0));
|
||||
#define __libc_rwlock_fini(NAME) \
|
||||
(__libc_maybe_call (__pthread_rwlock_destroy, (&(NAME)), 0));
|
||||
|
||||
/* Finalize recursive named lock. */
|
||||
#define __libc_lock_fini_recursive(NAME) __libc_lock_fini ((NAME).mutex)
|
||||
#define __rtld_lock_fini_recursive(NAME) __libc_lock_fini_recursive (NAME)
|
||||
|
||||
/* Lock the named lock variable. */
|
||||
#define __libc_lock_lock(NAME) \
|
||||
(__libc_maybe_call2 (pthread_mutex_lock, (&(NAME)), 0));
|
||||
#define __libc_rwlock_rdlock(NAME) \
|
||||
(__libc_maybe_call (__pthread_rwlock_rdlock, (&(NAME)), 0));
|
||||
#define __libc_rwlock_wrlock(NAME) \
|
||||
(__libc_maybe_call (__pthread_rwlock_wrlock, (&(NAME)), 0));
|
||||
|
||||
/* Lock the recursive named lock variable. */
|
||||
#define __libc_lock_lock_recursive(NAME) __libc_lock_lock ((NAME).mutex)
|
||||
|
||||
/* Try to lock the named lock variable. */
|
||||
#define __libc_lock_trylock(NAME) \
|
||||
(__libc_maybe_call2 (pthread_mutex_trylock, (&(NAME)), 0))
|
||||
#define __libc_rwlock_tryrdlock(NAME) \
|
||||
(__libc_maybe_call (__pthread_rwlock_tryrdlock, (&(NAME)), 0))
|
||||
#define __libc_rwlock_trywrlock(NAME) \
|
||||
(__libc_maybe_call (__pthread_rwlock_trywrlock, (&(NAME)), 0))
|
||||
|
||||
/* Try to lock the recursive named lock variable. */
|
||||
#define __libc_lock_trylock_recursive(NAME) __libc_lock_trylock ((NAME).mutex)
|
||||
#define __rtld_lock_trylock_recursive(NAME) \
|
||||
__libc_lock_trylock_recursive (NAME)
|
||||
|
||||
/* Unlock the named lock variable. */
|
||||
#define __libc_lock_unlock(NAME) \
|
||||
(__libc_maybe_call2 (pthread_mutex_unlock, (&(NAME)), 0));
|
||||
#define __libc_rwlock_unlock(NAME) \
|
||||
(__libc_maybe_call (__pthread_rwlock_unlock, (&(NAME)), 0));
|
||||
|
||||
/* Unlock the recursive named lock variable. */
|
||||
#define __libc_lock_unlock_recursive(NAME) __libc_lock_unlock ((NAME).mutex)
|
||||
|
||||
#if defined _LIBC && defined SHARED
|
||||
# define __rtld_lock_default_lock_recursive(lock) \
|
||||
++((pthread_mutex_t *)(lock))->__m_count;
|
||||
|
||||
# define __rtld_lock_default_unlock_recursive(lock) \
|
||||
--((pthread_mutex_t *)(lock))->__m_count;
|
||||
|
||||
# define __rtld_lock_lock_recursive(NAME) \
|
||||
GL(dl_rtld_lock_recursive) (&(NAME).mutex)
|
||||
|
||||
# define __rtld_lock_unlock_recursive(NAME) \
|
||||
GL(dl_rtld_unlock_recursive) (&(NAME).mutex)
|
||||
#else
|
||||
#define __rtld_lock_lock_recursive(NAME) __libc_lock_lock_recursive (NAME)
|
||||
#define __rtld_lock_unlock_recursive(NAME) __libc_lock_unlock_recursive (NAME)
|
||||
#endif
|
||||
|
||||
/* Define once control variable. */
|
||||
#if PTHREAD_ONCE_INIT == 0
|
||||
/* Special case for static variables where we can avoid the initialization
|
||||
if it is zero. */
|
||||
# define __libc_once_define(CLASS, NAME) \
|
||||
CLASS pthread_once_t NAME
|
||||
#else
|
||||
# define __libc_once_define(CLASS, NAME) \
|
||||
CLASS pthread_once_t NAME = PTHREAD_ONCE_INIT
|
||||
#endif
|
||||
|
||||
/* Call handler iff the first call. */
|
||||
#define __libc_once(ONCE_CONTROL, INIT_FUNCTION) \
|
||||
do { \
|
||||
if (__pthread_once != NULL) \
|
||||
__pthread_once (&(ONCE_CONTROL), (INIT_FUNCTION)); \
|
||||
else if ((ONCE_CONTROL) == PTHREAD_ONCE_INIT) { \
|
||||
INIT_FUNCTION (); \
|
||||
(ONCE_CONTROL) = 2; \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
|
||||
/* Start critical region with cleanup. */
|
||||
#define __libc_cleanup_region_start(DOIT, FCT, ARG) \
|
||||
{ struct _pthread_cleanup_buffer _buffer; \
|
||||
int _avail = (DOIT) && _pthread_cleanup_push_defer != NULL; \
|
||||
if (_avail) { \
|
||||
_pthread_cleanup_push_defer (&_buffer, (FCT), (ARG)); \
|
||||
}
|
||||
|
||||
/* End critical region with cleanup. */
|
||||
#define __libc_cleanup_region_end(DOIT) \
|
||||
if (_avail) { \
|
||||
_pthread_cleanup_pop_restore (&_buffer, (DOIT)); \
|
||||
} \
|
||||
}
|
||||
|
||||
/* Sometimes we have to exit the block in the middle. */
|
||||
#define __libc_cleanup_end(DOIT) \
|
||||
if (_avail) { \
|
||||
_pthread_cleanup_pop_restore (&_buffer, (DOIT)); \
|
||||
}
|
||||
|
||||
#define __libc_cleanup_push(fct, arg) \
|
||||
{ struct _pthread_cleanup_buffer _buffer; \
|
||||
__libc_maybe_call (_pthread_cleanup_push, (&_buffer, (fct), (arg)), 0)
|
||||
|
||||
#define __libc_cleanup_pop(execute) \
|
||||
__libc_maybe_call (_pthread_cleanup_pop, (&_buffer, execute), 0); \
|
||||
}
|
||||
|
||||
/* Create thread-specific key. */
|
||||
#define __libc_key_create(KEY, DESTRUCTOR) \
|
||||
(__libc_maybe_call (__pthread_key_create, (KEY, DESTRUCTOR), 1))
|
||||
|
||||
/* Get thread-specific data. */
|
||||
#define __libc_getspecific(KEY) \
|
||||
(__libc_maybe_call (__pthread_getspecific, (KEY), NULL))
|
||||
|
||||
/* Set thread-specific data. */
|
||||
#define __libc_setspecific(KEY, VALUE) \
|
||||
(__libc_maybe_call (__pthread_setspecific, (KEY, VALUE), 0))
|
||||
|
||||
|
||||
/* Register handlers to execute before and after `fork'. */
|
||||
#define __libc_atfork(PREPARE, PARENT, CHILD) \
|
||||
(__libc_maybe_call (__pthread_atfork, (PREPARE, PARENT, CHILD), 0))
|
||||
|
||||
/* Functions that are used by this file and are internal to the GNU C
|
||||
library. */
|
||||
|
||||
extern int __pthread_mutex_init (pthread_mutex_t *__mutex,
|
||||
__const pthread_mutexattr_t *__mutex_attr);
|
||||
|
||||
extern int __pthread_mutex_destroy (pthread_mutex_t *__mutex);
|
||||
|
||||
extern int __pthread_mutex_trylock (pthread_mutex_t *__mutex);
|
||||
|
||||
extern int __pthread_mutex_lock (pthread_mutex_t *__mutex);
|
||||
|
||||
extern int __pthread_mutex_unlock (pthread_mutex_t *__mutex);
|
||||
|
||||
extern int __pthread_mutexattr_init (pthread_mutexattr_t *__attr);
|
||||
|
||||
extern int __pthread_mutexattr_destroy (pthread_mutexattr_t *__attr);
|
||||
|
||||
extern int __pthread_mutexattr_settype (pthread_mutexattr_t *__attr,
|
||||
int __kind);
|
||||
|
||||
#ifdef __USE_UNIX98
|
||||
extern int __pthread_rwlock_init (pthread_rwlock_t *__rwlock,
|
||||
__const pthread_rwlockattr_t *__attr);
|
||||
|
||||
extern int __pthread_rwlock_destroy (pthread_rwlock_t *__rwlock);
|
||||
|
||||
extern int __pthread_rwlock_rdlock (pthread_rwlock_t *__rwlock);
|
||||
|
||||
extern int __pthread_rwlock_tryrdlock (pthread_rwlock_t *__rwlock);
|
||||
|
||||
extern int __pthread_rwlock_wrlock (pthread_rwlock_t *__rwlock);
|
||||
|
||||
extern int __pthread_rwlock_trywrlock (pthread_rwlock_t *__rwlock);
|
||||
|
||||
extern int __pthread_rwlock_unlock (pthread_rwlock_t *__rwlock);
|
||||
#endif
|
||||
|
||||
extern int __pthread_key_create (pthread_key_t *__key,
|
||||
void (*__destr_function) (void *));
|
||||
|
||||
extern int __pthread_setspecific (pthread_key_t __key,
|
||||
__const void *__pointer);
|
||||
|
||||
extern void *__pthread_getspecific (pthread_key_t __key);
|
||||
|
||||
extern int __pthread_once (pthread_once_t *__once_control,
|
||||
void (*__init_routine) (void));
|
||||
|
||||
extern int __pthread_atfork (void (*__prepare) (void),
|
||||
void (*__parent) (void),
|
||||
void (*__child) (void));
|
||||
|
||||
|
||||
|
||||
/* Make the pthread functions weak so that we can elide them from
|
||||
single-threaded processes. */
|
||||
#ifndef __NO_WEAK_PTHREAD_ALIASES
|
||||
# pragma weak __pthread_mutex_init
|
||||
# pragma weak __pthread_mutex_destroy
|
||||
# pragma weak __pthread_mutex_lock
|
||||
# pragma weak __pthread_mutex_trylock
|
||||
# pragma weak __pthread_mutex_unlock
|
||||
# pragma weak __pthread_mutexattr_init
|
||||
# pragma weak __pthread_mutexattr_destroy
|
||||
# pragma weak __pthread_mutexattr_settype
|
||||
# pragma weak __pthread_rwlock_destroy
|
||||
# pragma weak __pthread_rwlock_rdlock
|
||||
# pragma weak __pthread_rwlock_tryrdlock
|
||||
# pragma weak __pthread_rwlock_wrlock
|
||||
# pragma weak __pthread_rwlock_trywrlock
|
||||
# pragma weak __pthread_rwlock_unlock
|
||||
# pragma weak __pthread_key_create
|
||||
# pragma weak __pthread_setspecific
|
||||
# pragma weak __pthread_getspecific
|
||||
# pragma weak __pthread_once
|
||||
# pragma weak __pthread_initialize
|
||||
# pragma weak __pthread_atfork
|
||||
# pragma weak _pthread_cleanup_push_defer
|
||||
# pragma weak _pthread_cleanup_pop_restore
|
||||
# pragma weak _pthread_cleanup_push
|
||||
# pragma weak _pthread_cleanup_pop
|
||||
#endif
|
||||
|
||||
/* We need portable names for some functions. E.g., when they are
|
||||
used as argument to __libc_cleanup_region_start. */
|
||||
#define __libc_mutex_unlock __pthread_mutex_unlock
|
||||
|
||||
#endif /* bits/libc-lock.h */
|
||||
|
|
@ -0,0 +1,152 @@
|
|||
/* Linuxthreads - a simple clone()-based implementation of Posix */
|
||||
/* threads for Linux. */
|
||||
/* Copyright (C) 1996 Xavier Leroy (Xavier.Leroy@inria.fr) */
|
||||
/* */
|
||||
/* This program 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. */
|
||||
/* */
|
||||
/* This program 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. */
|
||||
|
||||
#if !defined _BITS_TYPES_H && !defined _PTHREAD_H
|
||||
# error "Never include <bits/pthreadtypes.h> directly; use <sys/types.h> instead."
|
||||
#endif
|
||||
|
||||
#ifndef _BITS_PTHREADTYPES_H
|
||||
#define _BITS_PTHREADTYPES_H 1
|
||||
|
||||
#define __need_schedparam
|
||||
#include <bits/sched.h>
|
||||
|
||||
/* Fast locks (not abstract because mutexes and conditions aren't abstract). */
|
||||
struct _pthread_fastlock
|
||||
{
|
||||
long int __status; /* "Free" or "taken" or head of waiting list */
|
||||
int __spinlock; /* Used by compare_and_swap emulation. Also,
|
||||
adaptive SMP lock stores spin count here. */
|
||||
};
|
||||
|
||||
#ifndef _PTHREAD_DESCR_DEFINED
|
||||
/* Thread descriptors */
|
||||
typedef struct _pthread_descr_struct *_pthread_descr;
|
||||
# define _PTHREAD_DESCR_DEFINED
|
||||
#endif
|
||||
|
||||
|
||||
/* Attributes for threads. */
|
||||
typedef struct __pthread_attr_s
|
||||
{
|
||||
int __detachstate;
|
||||
int __schedpolicy;
|
||||
struct __sched_param __schedparam;
|
||||
int __inheritsched;
|
||||
int __scope;
|
||||
size_t __guardsize;
|
||||
int __stackaddr_set;
|
||||
void *__stackaddr;
|
||||
size_t __stacksize;
|
||||
} pthread_attr_t;
|
||||
|
||||
|
||||
/* Conditions (not abstract because of PTHREAD_COND_INITIALIZER */
|
||||
|
||||
#ifdef __GLIBC_HAVE_LONG_LONG
|
||||
__extension__ typedef long long __pthread_cond_align_t;
|
||||
#else
|
||||
typedef long __pthread_cond_align_t;
|
||||
#endif
|
||||
|
||||
typedef struct
|
||||
{
|
||||
struct _pthread_fastlock __c_lock; /* Protect against concurrent access */
|
||||
_pthread_descr __c_waiting; /* Threads waiting on this condition */
|
||||
char __padding[48 - sizeof (struct _pthread_fastlock)
|
||||
- sizeof (_pthread_descr) - sizeof (__pthread_cond_align_t)];
|
||||
__pthread_cond_align_t __align;
|
||||
} pthread_cond_t;
|
||||
|
||||
|
||||
/* Attribute for conditionally variables. */
|
||||
typedef struct
|
||||
{
|
||||
int __dummy;
|
||||
} pthread_condattr_t;
|
||||
|
||||
/* Keys for thread-specific data */
|
||||
typedef unsigned int pthread_key_t;
|
||||
|
||||
|
||||
/* Mutexes (not abstract because of PTHREAD_MUTEX_INITIALIZER). */
|
||||
/* (The layout is unnatural to maintain binary compatibility
|
||||
with earlier releases of LinuxThreads.) */
|
||||
typedef struct
|
||||
{
|
||||
int __m_reserved; /* Reserved for future use */
|
||||
int __m_count; /* Depth of recursive locking */
|
||||
_pthread_descr __m_owner; /* Owner thread (if recursive or errcheck) */
|
||||
int __m_kind; /* Mutex kind: fast, recursive or errcheck */
|
||||
struct _pthread_fastlock __m_lock; /* Underlying fast lock */
|
||||
} pthread_mutex_t;
|
||||
|
||||
|
||||
/* Attribute for mutex. */
|
||||
typedef struct
|
||||
{
|
||||
int __mutexkind;
|
||||
} pthread_mutexattr_t;
|
||||
|
||||
|
||||
/* Once-only execution */
|
||||
typedef int pthread_once_t;
|
||||
|
||||
|
||||
#if defined __USE_UNIX98 || defined __USE_XOPEN2K
|
||||
/* Read-write locks. */
|
||||
typedef struct _pthread_rwlock_t
|
||||
{
|
||||
struct _pthread_fastlock __rw_lock; /* Lock to guarantee mutual exclusion */
|
||||
int __rw_readers; /* Number of readers */
|
||||
_pthread_descr __rw_writer; /* Identity of writer, or NULL if none */
|
||||
_pthread_descr __rw_read_waiting; /* Threads waiting for reading */
|
||||
_pthread_descr __rw_write_waiting; /* Threads waiting for writing */
|
||||
int __rw_kind; /* Reader/Writer preference selection */
|
||||
int __rw_pshared; /* Shared between processes or not */
|
||||
} pthread_rwlock_t;
|
||||
|
||||
|
||||
/* Attribute for read-write locks. */
|
||||
typedef struct
|
||||
{
|
||||
int __lockkind;
|
||||
int __pshared;
|
||||
} pthread_rwlockattr_t;
|
||||
#endif
|
||||
|
||||
#ifdef __USE_XOPEN2K
|
||||
/* POSIX spinlock data type. */
|
||||
typedef volatile int pthread_spinlock_t;
|
||||
|
||||
/* POSIX barrier. */
|
||||
typedef struct {
|
||||
struct _pthread_fastlock __ba_lock; /* Lock to guarantee mutual exclusion */
|
||||
int __ba_required; /* Threads needed for completion */
|
||||
int __ba_present; /* Threads waiting */
|
||||
_pthread_descr __ba_waiting; /* Queue of waiting threads */
|
||||
} pthread_barrier_t;
|
||||
|
||||
/* barrier attribute */
|
||||
typedef struct {
|
||||
int __pshared;
|
||||
} pthread_barrierattr_t;
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
/* Thread identifiers */
|
||||
typedef unsigned long int pthread_t;
|
||||
|
||||
#endif /* bits/pthreadtypes.h */
|
||||
|
|
@ -0,0 +1,66 @@
|
|||
/* bits/typesizes.h -- underlying types for *_t. Generic version.
|
||||
Copyright (C) 2002, 2003 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 Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 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
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with the GNU C Library; if not, write to the Free
|
||||
Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
|
||||
02111-1307 USA. */
|
||||
|
||||
#ifndef _BITS_TYPES_H
|
||||
# error "Never include <bits/typesizes.h> directly; use <sys/types.h> instead."
|
||||
#endif
|
||||
|
||||
#ifndef _BITS_TYPESIZES_H
|
||||
#define _BITS_TYPESIZES_H 1
|
||||
|
||||
/* See <bits/types.h> for the meaning of these macros. This file exists so
|
||||
that <bits/types.h> need not vary across different GNU platforms. */
|
||||
|
||||
#define __DEV_T_TYPE __UQUAD_TYPE
|
||||
#define __UID_T_TYPE __U32_TYPE
|
||||
#define __GID_T_TYPE __U32_TYPE
|
||||
#define __INO_T_TYPE __ULONGWORD_TYPE
|
||||
#define __INO64_T_TYPE __UQUAD_TYPE
|
||||
#define __MODE_T_TYPE __U32_TYPE
|
||||
#define __NLINK_T_TYPE __UWORD_TYPE
|
||||
#define __OFF_T_TYPE __SLONGWORD_TYPE
|
||||
#define __OFF64_T_TYPE __SQUAD_TYPE
|
||||
#define __PID_T_TYPE __S32_TYPE
|
||||
#define __RLIM_T_TYPE __ULONGWORD_TYPE
|
||||
#define __RLIM64_T_TYPE __UQUAD_TYPE
|
||||
#define __BLKCNT_T_TYPE __SLONGWORD_TYPE
|
||||
#define __BLKCNT64_T_TYPE __SQUAD_TYPE
|
||||
#define __FSBLKCNT_T_TYPE __ULONGWORD_TYPE
|
||||
#define __FSBLKCNT64_T_TYPE __UQUAD_TYPE
|
||||
#define __FSFILCNT_T_TYPE __ULONGWORD_TYPE
|
||||
#define __FSFILCNT64_T_TYPE __UQUAD_TYPE
|
||||
#define __ID_T_TYPE __U32_TYPE
|
||||
#define __CLOCK_T_TYPE __SLONGWORD_TYPE
|
||||
#define __TIME_T_TYPE __SLONGWORD_TYPE
|
||||
#define __USECONDS_T_TYPE __U32_TYPE
|
||||
#define __SUSECONDS_T_TYPE __SLONGWORD_TYPE
|
||||
#define __DADDR_T_TYPE __S32_TYPE
|
||||
#define __SWBLK_T_TYPE __SLONGWORD_TYPE
|
||||
#define __KEY_T_TYPE __S32_TYPE
|
||||
#define __CLOCKID_T_TYPE __S32_TYPE
|
||||
#define __TIMER_T_TYPE __S32_TYPE
|
||||
#define __BLKSIZE_T_TYPE __SLONGWORD_TYPE
|
||||
#define __FSID_T_TYPE struct { int __val[2]; }
|
||||
#define __SSIZE_T_TYPE __SWORD_TYPE
|
||||
|
||||
/* Number of descriptors that can fit in an `fd_set'. */
|
||||
#define __FD_SETSIZE 1024
|
||||
|
||||
|
||||
#endif /* bits/typesizes.h */
|
||||
|
|
@ -208,7 +208,7 @@ _dl_load_cache_lookup (const char *name)
|
|||
/* This file ends in static libraries where we don't have a hwcap. */
|
||||
unsigned long int *hwcap;
|
||||
uint64_t platform;
|
||||
weak_extern (_dl_hwcap);
|
||||
#pragma weak _dl_hwcap
|
||||
|
||||
/* This is where the strings start. */
|
||||
cache_data = (const char *) cache_new;
|
||||
|
|
|
|||
|
|
@ -1095,7 +1095,7 @@ _dl_map_object_from_fd (const char *name, int fd, struct filebuf *fbp,
|
|||
}
|
||||
else
|
||||
/* Adjust the PT_PHDR value by the runtime load address. */
|
||||
(ElfW(Addr)) l->l_phdr += l->l_addr;
|
||||
l->l_phdr = (ElfW(Addr)) l->l_phdr + l->l_addr;
|
||||
}
|
||||
|
||||
/* We are done mapping in the file. We no longer need the descriptor. */
|
||||
|
|
@ -1115,7 +1115,7 @@ _dl_map_object_from_fd (const char *name, int fd, struct filebuf *fbp,
|
|||
}
|
||||
}
|
||||
else
|
||||
(ElfW(Addr)) l->l_ld += l->l_addr;
|
||||
l->l_ld = (ElfW(Addr)) l->l_ld + l->l_addr;
|
||||
|
||||
l->l_entry += l->l_addr;
|
||||
|
||||
|
|
|
|||
|
|
@ -36,8 +36,8 @@
|
|||
extern ElfW(Addr) _dl_sysdep_start (void **start_argptr,
|
||||
void (*dl_main) (const ElfW(Phdr) *phdr,
|
||||
ElfW(Word) phnum,
|
||||
ElfW(Addr) *user_entry));
|
||||
weak_extern (BP_SYM (_dl_sysdep_start))
|
||||
ElfW(Addr) *user_entry))
|
||||
weak_function;
|
||||
|
||||
/* This function is used to unload the cache file if necessary. */
|
||||
extern void _dl_unload_cache (void);
|
||||
|
|
|
|||
|
|
@ -105,50 +105,47 @@ _dl_relocate_object (struct link_map *l, struct r_scope_elem *scope[],
|
|||
{
|
||||
/* Do the actual relocation of the object's GOT and other data. */
|
||||
|
||||
/* String table object symbols. */
|
||||
const char *strtab = (const void *) D_PTR (l, l_info[DT_STRTAB]);
|
||||
|
||||
/* This macro is used as a callback from the ELF_DYNAMIC_RELOCATE code. */
|
||||
#define RESOLVE_MAP(ref, version, r_type) \
|
||||
#define RESOLVE_MAP(ref, version, r_type, scope) \
|
||||
(ELFW(ST_BIND) ((*ref)->st_info) != STB_LOCAL \
|
||||
? ((__builtin_expect ((*ref) == l->l_lookup_cache.sym, 0) \
|
||||
&& elf_machine_type_class (r_type) == l->l_lookup_cache.type_class) \
|
||||
? ((__builtin_expect ((*ref) == map->l_lookup_cache.sym, 0) \
|
||||
&& elf_machine_type_class (r_type) == map->l_lookup_cache.type_class)\
|
||||
? (++_dl_num_cache_relocations, \
|
||||
(*ref) = l->l_lookup_cache.ret, \
|
||||
l->l_lookup_cache.value) \
|
||||
(*ref) = map->l_lookup_cache.ret, \
|
||||
map->l_lookup_cache.value) \
|
||||
: ({ lookup_t _lr; \
|
||||
int _tc = elf_machine_type_class (r_type); \
|
||||
l->l_lookup_cache.type_class = _tc; \
|
||||
l->l_lookup_cache.sym = (*ref); \
|
||||
map->l_lookup_cache.type_class = _tc; \
|
||||
map->l_lookup_cache.sym = (*ref); \
|
||||
_lr = ((version) != NULL && (version)->hash != 0 \
|
||||
? _dl_lookup_versioned_symbol (strtab + (*ref)->st_name, \
|
||||
l, (ref), scope, \
|
||||
map, (ref), scope, \
|
||||
(version), _tc, 0) \
|
||||
: _dl_lookup_symbol (strtab + (*ref)->st_name, l, (ref), \
|
||||
: _dl_lookup_symbol (strtab + (*ref)->st_name, map, (ref),\
|
||||
scope, _tc, 0)); \
|
||||
l->l_lookup_cache.ret = (*ref); \
|
||||
l->l_lookup_cache.value = _lr; })) \
|
||||
: l)
|
||||
#define RESOLVE(ref, version, r_type) \
|
||||
map->l_lookup_cache.ret = (*ref); \
|
||||
map->l_lookup_cache.value = _lr; })) \
|
||||
: map)
|
||||
#define RESOLVE(ref, version, r_type, scope) \
|
||||
(ELFW(ST_BIND) ((*ref)->st_info) != STB_LOCAL \
|
||||
? ((__builtin_expect ((*ref) == l->l_lookup_cache.sym, 0) \
|
||||
&& elf_machine_type_class (r_type) == l->l_lookup_cache.type_class) \
|
||||
? ((__builtin_expect ((*ref) == map->l_lookup_cache.sym, 0) \
|
||||
&& elf_machine_type_class (r_type) == map->l_lookup_cache.type_class)\
|
||||
? (++_dl_num_cache_relocations, \
|
||||
(*ref) = l->l_lookup_cache.ret, \
|
||||
l->l_lookup_cache.value) \
|
||||
(*ref) = map->l_lookup_cache.ret, \
|
||||
map->l_lookup_cache.value) \
|
||||
: ({ lookup_t _lr; \
|
||||
int _tc = elf_machine_type_class (r_type); \
|
||||
l->l_lookup_cache.type_class = _tc; \
|
||||
l->l_lookup_cache.sym = (*ref); \
|
||||
map->l_lookup_cache.type_class = _tc; \
|
||||
map->l_lookup_cache.sym = (*ref); \
|
||||
_lr = ((version) != NULL && (version)->hash != 0 \
|
||||
? _dl_lookup_versioned_symbol (strtab + (*ref)->st_name, \
|
||||
l, (ref), scope, \
|
||||
map, (ref), scope, \
|
||||
(version), _tc, 0) \
|
||||
: _dl_lookup_symbol (strtab + (*ref)->st_name, l, (ref), \
|
||||
: _dl_lookup_symbol (strtab + (*ref)->st_name, map, (ref),\
|
||||
scope, _tc, 0)); \
|
||||
l->l_lookup_cache.ret = (*ref); \
|
||||
l->l_lookup_cache.value = _lr; })) \
|
||||
: l->l_addr)
|
||||
map->l_lookup_cache.ret = (*ref); \
|
||||
map->l_lookup_cache.value = _lr; })) \
|
||||
: map->l_addr)
|
||||
|
||||
#include "dynamic-link.h"
|
||||
|
||||
|
|
@ -197,6 +194,7 @@ _dl_relocate_object (struct link_map *l, struct r_scope_elem *scope[],
|
|||
}
|
||||
}
|
||||
|
||||
#include <machine/dl-machine.h>
|
||||
|
||||
void
|
||||
internal_function
|
||||
|
|
|
|||
|
|
@ -46,7 +46,7 @@
|
|||
function. */
|
||||
|
||||
#ifndef ELF_MACHINE_NO_PLT
|
||||
static ElfW(Addr) __attribute__ ((regparm (2), unused))
|
||||
static ElfW(Addr) __attribute__ ((regparm (2), used))
|
||||
fixup (
|
||||
# ifdef ELF_MACHINE_RUNTIME_FIXUP_ARGS
|
||||
ELF_MACHINE_RUNTIME_FIXUP_ARGS,
|
||||
|
|
@ -130,7 +130,7 @@ fixup (
|
|||
|
||||
#if !defined PROF && !defined ELF_MACHINE_NO_PLT && !__BOUNDED_POINTERS__
|
||||
|
||||
static ElfW(Addr) __attribute__ ((regparm (3), unused))
|
||||
static ElfW(Addr) __attribute__ ((regparm (3), used))
|
||||
profile_fixup (
|
||||
#ifdef ELF_MACHINE_RUNTIME_FIXUP_ARGS
|
||||
ELF_MACHINE_RUNTIME_FIXUP_ARGS,
|
||||
|
|
|
|||
|
|
@ -44,7 +44,8 @@
|
|||
static inline void
|
||||
elf_dynamic_do_rel (struct link_map *map,
|
||||
ElfW(Addr) reladdr, ElfW(Addr) relsize,
|
||||
int lazy)
|
||||
int lazy,
|
||||
struct r_scope_elem *scope[])
|
||||
{
|
||||
const ElfW(Rel) *r = (const void *) reladdr;
|
||||
const ElfW(Rel) *end = (const void *) (reladdr + relsize);
|
||||
|
|
@ -77,7 +78,7 @@ elf_dynamic_do_rel (struct link_map *map,
|
|||
RTLD_BOOTSTRAP) because rtld.c contains the common defn for
|
||||
_dl_rtld_map, which is incompatible with a weak decl in the same
|
||||
file. */
|
||||
weak_extern (_dl_rtld_map);
|
||||
#pragma weak _dl_rtld_map
|
||||
if (map != &_dl_rtld_map) /* Already done in rtld itself. */
|
||||
# ifndef DO_RELA
|
||||
/* Rela platforms get the offset from r_addend and this must
|
||||
|
|
@ -101,13 +102,14 @@ elf_dynamic_do_rel (struct link_map *map,
|
|||
ElfW(Half) ndx = version[ELFW(R_SYM) (r->r_info)];
|
||||
elf_machine_rel (map, r, &symtab[ELFW(R_SYM) (r->r_info)],
|
||||
&map->l_versions[ndx],
|
||||
(void *) (l_addr + r->r_offset));
|
||||
(void *) (l_addr + r->r_offset),
|
||||
scope);
|
||||
}
|
||||
}
|
||||
else
|
||||
for (; r < end; ++r)
|
||||
elf_machine_rel (map, r, &symtab[ELFW(R_SYM) (r->r_info)], NULL,
|
||||
(void *) (l_addr + r->r_offset));
|
||||
(void *) (l_addr + r->r_offset), scope);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -17,6 +17,9 @@
|
|||
Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
|
||||
02111-1307 USA. */
|
||||
|
||||
#ifndef __DYNAMIC_LINK_H__
|
||||
#define __DYNAMIC_LINK_H__
|
||||
|
||||
#include <elf.h>
|
||||
#include <machine/dl-machine.h>
|
||||
#include <assert.h>
|
||||
|
|
@ -33,7 +36,7 @@ extern int _dl_verbose __attribute__ ((unused));
|
|||
|
||||
/* Read the dynamic section at DYN and fill in INFO with indices DT_*. */
|
||||
|
||||
static inline void __attribute__ ((unused))
|
||||
static void __attribute__ ((unused))
|
||||
elf_get_dynamic_info (struct link_map *l)
|
||||
{
|
||||
ElfW(Dyn) *dyn = l->l_ld;
|
||||
|
|
@ -121,6 +124,17 @@ elf_get_dynamic_info (struct link_map *l)
|
|||
info[DT_RPATH] = NULL;
|
||||
}
|
||||
|
||||
# if ! ELF_MACHINE_NO_REL
|
||||
# include "do-rel.h"
|
||||
# endif
|
||||
|
||||
# if ! ELF_MACHINE_NO_RELA
|
||||
# define DO_RELA
|
||||
# include "do-rel.h"
|
||||
# endif
|
||||
|
||||
#endif /* __DYNAMIC_LINK_H__ */
|
||||
|
||||
#ifdef RESOLVE
|
||||
|
||||
/* Get the definitions of `elf_dynamic_do_rel' and `elf_dynamic_do_rela'.
|
||||
|
|
@ -164,7 +178,8 @@ elf_get_dynamic_info (struct link_map *l)
|
|||
elf_dynamic_do_##reloc ((map), \
|
||||
ranges[ranges_index].start, \
|
||||
ranges[ranges_index].size, \
|
||||
ranges[ranges_index].lazy); \
|
||||
ranges[ranges_index].lazy, \
|
||||
scope); \
|
||||
} while (0)
|
||||
# else
|
||||
# define _ELF_DYNAMIC_DO_RELOC(RELOC, reloc, map, do_lazy, test_rel) \
|
||||
|
|
@ -204,7 +219,8 @@ elf_get_dynamic_info (struct link_map *l)
|
|||
elf_dynamic_do_##reloc ((map), \
|
||||
ranges[ranges_index].start, \
|
||||
ranges[ranges_index].size, \
|
||||
ranges[ranges_index].lazy); \
|
||||
ranges[ranges_index].lazy, \
|
||||
scope); \
|
||||
} while (0)
|
||||
# endif
|
||||
|
||||
|
|
@ -215,7 +231,6 @@ elf_get_dynamic_info (struct link_map *l)
|
|||
# endif
|
||||
|
||||
# if ! ELF_MACHINE_NO_REL
|
||||
# include "do-rel.h"
|
||||
# define ELF_DYNAMIC_DO_REL(map, lazy) \
|
||||
_ELF_DYNAMIC_DO_RELOC (REL, rel, map, lazy, _ELF_CHECK_REL)
|
||||
# else
|
||||
|
|
@ -223,8 +238,6 @@ elf_get_dynamic_info (struct link_map *l)
|
|||
# endif
|
||||
|
||||
# if ! ELF_MACHINE_NO_RELA
|
||||
# define DO_RELA
|
||||
# include "do-rel.h"
|
||||
# define ELF_DYNAMIC_DO_RELA(map, lazy) \
|
||||
_ELF_DYNAMIC_DO_RELOC (RELA, rela, map, lazy, _ELF_CHECK_REL)
|
||||
# else
|
||||
|
|
|
|||
|
|
@ -172,7 +172,10 @@ __gconv_open (const char *toset, const char *fromset, __gconv_t *handle,
|
|||
lastp = runp;
|
||||
else
|
||||
/* This means we haven't found the module. Remove it. */
|
||||
(lastp == NULL ? trans : lastp->next) = runp->next;
|
||||
if (lastp == NULL)
|
||||
trans = runp->next;
|
||||
else
|
||||
lastp->next = runp->next;
|
||||
}
|
||||
|
||||
/* Allocate room for handle. */
|
||||
|
|
|
|||
|
|
@ -75,7 +75,10 @@ internal_ucs4_loop (struct __gconv_step *step,
|
|||
size_t cnt;
|
||||
|
||||
for (cnt = 0; cnt < n_convert; ++cnt, inptr += 4)
|
||||
*((uint32_t *) outptr)++ = bswap_32 (*(const uint32_t *) inptr);
|
||||
{
|
||||
*((uint32_t *) outptr) = bswap_32 (*(const uint32_t *) inptr);
|
||||
outptr = (unsigned char *)((uint32_t *) outptr + 1);
|
||||
}
|
||||
|
||||
*inptrp = inptr;
|
||||
*outptrp = outptr;
|
||||
|
|
@ -180,8 +183,13 @@ internal_ucs4_loop_single (struct __gconv_step *step,
|
|||
|
||||
*outptrp += 4;
|
||||
#elif __BYTE_ORDER == __BIG_ENDIAN
|
||||
/* XXX unaligned */
|
||||
*(*((uint32_t **) outptrp)++) = state->__value.__wch;
|
||||
{
|
||||
uint32_t **p = (uint32_t **)outptrp;
|
||||
uint32_t *q = *p;
|
||||
/* XXX unaligned */
|
||||
*q = state->__value.__wch;
|
||||
outptrp = (unsigned char *)(p + 1);
|
||||
}
|
||||
#else
|
||||
# error "This endianess is not supported."
|
||||
#endif
|
||||
|
|
@ -244,7 +252,7 @@ ucs4_internal_loop (struct __gconv_step *step,
|
|||
if (flags & __GCONV_IGNORE_ERRORS)
|
||||
{
|
||||
/* Just ignore this character. */
|
||||
++*irreversible;
|
||||
*irreversible = *irreversible + 1;
|
||||
continue;
|
||||
}
|
||||
|
||||
|
|
@ -253,7 +261,8 @@ ucs4_internal_loop (struct __gconv_step *step,
|
|||
return __GCONV_ILLEGAL_INPUT;
|
||||
}
|
||||
|
||||
*((uint32_t *) outptr)++ = inval;
|
||||
*((uint32_t *) outptr) = inval;
|
||||
outptr = (unsigned char *) ((uint32_t *) outptr + 1);
|
||||
}
|
||||
|
||||
*inptrp = inptr;
|
||||
|
|
@ -301,7 +310,7 @@ ucs4_internal_loop_unaligned (struct __gconv_step *step,
|
|||
if (flags & __GCONV_IGNORE_ERRORS)
|
||||
{
|
||||
/* Just ignore this character. */
|
||||
++*irreversible;
|
||||
*irreversible = *irreversible + 1;
|
||||
continue;
|
||||
}
|
||||
|
||||
|
|
@ -536,8 +545,13 @@ internal_ucs4le_loop_single (struct __gconv_step *step,
|
|||
|
||||
*outptrp += 4;
|
||||
#else
|
||||
{
|
||||
/* XXX unaligned */
|
||||
*(*((uint32_t **) outptrp)++) = state->__value.__wch;
|
||||
uint32_t **p = (uint32_t **)outptrp;
|
||||
uint32_t *q = *p;
|
||||
*q = state->__value.__wch;
|
||||
outptrp = (unsigned char **)(p + 1);
|
||||
}
|
||||
#endif
|
||||
|
||||
/* Clear the state buffer. */
|
||||
|
|
@ -604,7 +618,8 @@ ucs4le_internal_loop (struct __gconv_step *step,
|
|||
return __GCONV_ILLEGAL_INPUT;
|
||||
}
|
||||
|
||||
*((uint32_t *) outptr)++ = inval;
|
||||
*((uint32_t *) outptr) = inval;
|
||||
outptr = (unsigned char *)((uint32_t *) outptr + 1);
|
||||
}
|
||||
|
||||
*inptrp = inptr;
|
||||
|
|
@ -781,12 +796,16 @@ ucs4le_internal_loop_single (struct __gconv_step *step,
|
|||
break; \
|
||||
} \
|
||||
\
|
||||
++*irreversible; \
|
||||
*irreversible = *irreversible + 1; \
|
||||
++inptr; \
|
||||
} \
|
||||
else \
|
||||
/* It's an one byte sequence. */ \
|
||||
*((uint32_t *) outptr)++ = *inptr++; \
|
||||
{ \
|
||||
/* It's an one byte sequence. */ \
|
||||
*((uint32_t *) outptr) = *inptr; \
|
||||
++inptr; \
|
||||
outptr = (unsigned char *)((uint32_t *) outptr + 1); \
|
||||
} \
|
||||
}
|
||||
#define LOOP_NEED_FLAGS
|
||||
#include <iconv/loop.c>
|
||||
|
|
@ -815,8 +834,11 @@ ucs4le_internal_loop_single (struct __gconv_step *step,
|
|||
STANDARD_ERR_HANDLER (4); \
|
||||
} \
|
||||
else \
|
||||
/* It's an one byte sequence. */ \
|
||||
*outptr++ = *((const uint32_t *) inptr)++; \
|
||||
{ \
|
||||
/* It's an one byte sequence. */ \
|
||||
*outptr++ = *((const uint32_t *) inptr); \
|
||||
inptr = ((const uint32_t *) inptr + 1); \
|
||||
} \
|
||||
}
|
||||
#define LOOP_NEED_FLAGS
|
||||
#include <iconv/loop.c>
|
||||
|
|
@ -993,7 +1015,7 @@ ucs4le_internal_loop_single (struct __gconv_step *step,
|
|||
{ \
|
||||
/* Ignore it. */ \
|
||||
inptr += i; \
|
||||
++*irreversible; \
|
||||
*irreversible = *irreversible + 1; \
|
||||
continue; \
|
||||
} \
|
||||
\
|
||||
|
|
@ -1023,7 +1045,7 @@ ucs4le_internal_loop_single (struct __gconv_step *step,
|
|||
if (ignore_errors_p ()) \
|
||||
{ \
|
||||
inptr += i; \
|
||||
++*irreversible; \
|
||||
*irreversible = *irreversible + 1; \
|
||||
continue; \
|
||||
} \
|
||||
\
|
||||
|
|
@ -1035,7 +1057,8 @@ ucs4le_internal_loop_single (struct __gconv_step *step,
|
|||
} \
|
||||
\
|
||||
/* Now adjust the pointers and store the result. */ \
|
||||
*((uint32_t *) outptr)++ = ch; \
|
||||
*((uint32_t *) outptr) = ch; \
|
||||
outptr = (unsigned char *)((uint32_t *) outptr + 1); \
|
||||
}
|
||||
#define LOOP_NEED_FLAGS
|
||||
|
||||
|
|
@ -1174,11 +1197,12 @@ ucs4le_internal_loop_single (struct __gconv_step *step,
|
|||
break; \
|
||||
} \
|
||||
inptr += 2; \
|
||||
++*irreversible; \
|
||||
*irreversible = *irreversible + 1; \
|
||||
continue; \
|
||||
} \
|
||||
\
|
||||
*((uint32_t *) outptr)++ = u1; \
|
||||
*((uint32_t *) outptr) = u1; \
|
||||
outptr = (unsigned char *)((uint32_t *) outptr + 1); \
|
||||
inptr += 2; \
|
||||
}
|
||||
#define LOOP_NEED_FLAGS
|
||||
|
|
@ -1223,12 +1247,13 @@ ucs4le_internal_loop_single (struct __gconv_step *step,
|
|||
break; \
|
||||
} \
|
||||
inptr += 4; \
|
||||
++*irreversible; \
|
||||
*irreversible = *irreversible + 1; \
|
||||
continue; \
|
||||
} \
|
||||
else \
|
||||
{ \
|
||||
*((uint16_t *) outptr)++ = val; \
|
||||
*((uint16_t *) outptr) = val; \
|
||||
outptr = (unsigned char *)((uint16_t *) outptr + 1); \
|
||||
inptr += 4; \
|
||||
} \
|
||||
}
|
||||
|
|
@ -1265,11 +1290,12 @@ ucs4le_internal_loop_single (struct __gconv_step *step,
|
|||
break; \
|
||||
} \
|
||||
inptr += 2; \
|
||||
++*irreversible; \
|
||||
*irreversible = *irreversible + 1; \
|
||||
continue; \
|
||||
} \
|
||||
\
|
||||
*((uint32_t *) outptr)++ = u1; \
|
||||
*((uint32_t *) outptr) = u1; \
|
||||
outptr = (unsigned char *)((uint32_t *) outptr + 1); \
|
||||
inptr += 2; \
|
||||
}
|
||||
#define LOOP_NEED_FLAGS
|
||||
|
|
@ -1313,12 +1339,13 @@ ucs4le_internal_loop_single (struct __gconv_step *step,
|
|||
break; \
|
||||
} \
|
||||
inptr += 4; \
|
||||
++*irreversible; \
|
||||
*irreversible = *irreversible + 1; \
|
||||
continue; \
|
||||
} \
|
||||
else \
|
||||
{ \
|
||||
*((uint16_t *) outptr)++ = bswap_16 (val); \
|
||||
*((uint16_t *) outptr) = bswap_16 (val); \
|
||||
outptr = (unsigned char *)((uint16_t *) outptr + 1); \
|
||||
inptr += 4; \
|
||||
} \
|
||||
}
|
||||
|
|
|
|||
|
|
@ -0,0 +1,361 @@
|
|||
/* ltdl.h -- generic dlopen functions
|
||||
Copyright (C) 1998-2000 Free Software Foundation, Inc.
|
||||
Originally by Thomas Tanner <tanner@ffii.org>
|
||||
This file is part of GNU Libtool.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2 of the License, or (at your option) any later version.
|
||||
|
||||
As a special exception to the GNU Lesser General Public License,
|
||||
if you distribute this file as part of a program or library that
|
||||
is built using GNU libtool, you may include it under the same
|
||||
distribution terms that you use for the rest of that program.
|
||||
|
||||
This 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
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free
|
||||
Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
|
||||
02111-1307 USA
|
||||
*/
|
||||
|
||||
/* Only include this header file once. */
|
||||
#ifndef LTDL_H
|
||||
#define LTDL_H 1
|
||||
|
||||
#include <sys/types.h> /* for size_t declaration */
|
||||
|
||||
|
||||
/* --- MACROS FOR PORTABILITY --- */
|
||||
|
||||
|
||||
/* Saves on those hard to debug '\0' typos.... */
|
||||
#define LT_EOS_CHAR '\0'
|
||||
|
||||
/* LTDL_BEGIN_C_DECLS should be used at the beginning of your declarations,
|
||||
so that C++ compilers don't mangle their names. Use LTDL_END_C_DECLS at
|
||||
the end of C declarations. */
|
||||
#ifdef __cplusplus
|
||||
# define LT_BEGIN_C_DECLS extern "C" {
|
||||
# define LT_END_C_DECLS }
|
||||
#else
|
||||
# define LT_BEGIN_C_DECLS /* empty */
|
||||
# define LT_END_C_DECLS /* empty */
|
||||
#endif
|
||||
|
||||
LT_BEGIN_C_DECLS
|
||||
|
||||
|
||||
/* LT_PARAMS is a macro used to wrap function prototypes, so that compilers
|
||||
that don't understand ANSI C prototypes still work, and ANSI C
|
||||
compilers can issue warnings about type mismatches. */
|
||||
#if defined (__STDC__) || defined (_AIX) || (defined (__mips) && defined (_SYSTYPE_SVR4)) || defined(WIN32) || defined(__cplusplus)
|
||||
# define LT_PARAMS(protos) protos
|
||||
# define lt_ptr void*
|
||||
#else
|
||||
# define LT_PARAMS(protos) ()
|
||||
# define lt_ptr char*
|
||||
#endif
|
||||
|
||||
/* LT_STMT_START/END are used to create macros which expand to a
|
||||
a single compound statement in a portable way. */
|
||||
#if defined (__GNUC__) && !defined (__STRICT_ANSI__) && !defined (__cplusplus)
|
||||
# define LT_STMT_START (void)(
|
||||
# define LT_STMT_END )
|
||||
#else
|
||||
# if (defined (sun) || defined (__sun__))
|
||||
# define LT_STMT_START if (1)
|
||||
# define LT_STMT_END else (void)0
|
||||
# else
|
||||
# define LT_STMT_START do
|
||||
# define LT_STMT_END while (0)
|
||||
# endif
|
||||
#endif
|
||||
|
||||
/* LT_CONC creates a new concatenated symbol for the compiler
|
||||
in a portable way. */
|
||||
#if defined(__STDC__) || defined(__cplusplus)
|
||||
# define LT_CONC(s,t) s##t
|
||||
#else
|
||||
# define LT_CONC(s,t) s/**/t
|
||||
#endif
|
||||
|
||||
/* LT_STRLEN can be used safely on NULL pointers. */
|
||||
#define LT_STRLEN(s) (((s) && (s)[0]) ? strlen (s) : 0)
|
||||
|
||||
|
||||
|
||||
/* --- WINDOWS SUPPORT --- */
|
||||
|
||||
|
||||
/* Canonicalise Windows and Cygwin recognition macros. */
|
||||
#ifdef __CYGWIN32__
|
||||
# ifndef __CYGWIN__
|
||||
# define __CYGWIN__ __CYGWIN32__
|
||||
# endif
|
||||
#endif
|
||||
#if defined(_WIN32) || defined(WIN32)
|
||||
# ifndef __WINDOWS__
|
||||
# ifdef _WIN32
|
||||
# define __WINDOWS__ _WIN32
|
||||
# else
|
||||
# ifdef WIN32
|
||||
# define __WINDOWS__ WIN32
|
||||
# endif
|
||||
# endif
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#ifdef __WINDOWS__
|
||||
# ifndef __CYGWIN__
|
||||
/* LT_DIRSEP_CHAR is accepted *in addition* to '/' as a directory
|
||||
separator when it is set. */
|
||||
# define LT_DIRSEP_CHAR '\\'
|
||||
# define LT_PATHSEP_CHAR ';'
|
||||
# endif
|
||||
#endif
|
||||
#ifndef LT_PATHSEP_CHAR
|
||||
# define LT_PATHSEP_CHAR ':'
|
||||
#endif
|
||||
|
||||
/* DLL building support on win32 hosts; mostly to workaround their
|
||||
ridiculous implementation of data symbol exporting. */
|
||||
#ifndef LT_SCOPE
|
||||
# ifdef __WINDOWS__
|
||||
# ifdef DLL_EXPORT /* defined by libtool (if required) */
|
||||
# define LT_SCOPE __declspec(dllexport)
|
||||
# endif
|
||||
# ifdef LIBLTDL_DLL_IMPORT /* define if linking with this dll */
|
||||
# define LT_SCOPE extern __declspec(dllimport)
|
||||
# endif
|
||||
# endif
|
||||
# ifndef LT_SCOPE /* static linking or !__WINDOWS__ */
|
||||
# define LT_SCOPE extern
|
||||
# endif
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
|
||||
/* --- DYNAMIC MODULE LOADING API --- */
|
||||
|
||||
|
||||
typedef struct lt_dlhandle_struct *lt_dlhandle; /* A loaded module. */
|
||||
|
||||
/* Initialisation and finalisation functions for libltdl. */
|
||||
extern int lt_dlinit LT_PARAMS((void));
|
||||
extern int lt_dlexit LT_PARAMS((void));
|
||||
|
||||
/* Module search path manipulation. */
|
||||
extern int lt_dladdsearchdir LT_PARAMS((const char *search_dir));
|
||||
extern int lt_dlinsertsearchdir LT_PARAMS((const char *before,
|
||||
const char *search_dir));
|
||||
extern int lt_dlsetsearchpath LT_PARAMS((const char *search_path));
|
||||
extern const char *lt_dlgetsearchpath LT_PARAMS((void));
|
||||
extern int lt_dlforeachfile LT_PARAMS((
|
||||
const char *search_path,
|
||||
int (*func) (const char *filename, lt_ptr data),
|
||||
lt_ptr data));
|
||||
|
||||
/* Portable libltdl versions of the system dlopen() API. */
|
||||
extern lt_dlhandle lt_dlopen LT_PARAMS((const char *filename));
|
||||
extern lt_dlhandle lt_dlopenext LT_PARAMS((const char *filename));
|
||||
extern lt_ptr lt_dlsym LT_PARAMS((lt_dlhandle handle,
|
||||
const char *name));
|
||||
extern const char *lt_dlerror LT_PARAMS((void));
|
||||
extern int lt_dlclose LT_PARAMS((lt_dlhandle handle));
|
||||
|
||||
/* Module residency management. */
|
||||
extern int lt_dlmakeresident LT_PARAMS((lt_dlhandle handle));
|
||||
extern int lt_dlisresident LT_PARAMS((lt_dlhandle handle));
|
||||
|
||||
|
||||
|
||||
|
||||
/* --- MUTEX LOCKING --- */
|
||||
|
||||
|
||||
typedef void lt_dlmutex_lock LT_PARAMS((void));
|
||||
typedef void lt_dlmutex_unlock LT_PARAMS((void));
|
||||
typedef void lt_dlmutex_seterror LT_PARAMS((const char *errmsg));
|
||||
typedef const char *lt_dlmutex_geterror LT_PARAMS((void));
|
||||
|
||||
extern int lt_dlmutex_register LT_PARAMS((lt_dlmutex_lock *lock,
|
||||
lt_dlmutex_unlock *unlock,
|
||||
lt_dlmutex_seterror *seterror,
|
||||
lt_dlmutex_geterror *geterror));
|
||||
|
||||
|
||||
|
||||
|
||||
/* --- MEMORY HANDLING --- */
|
||||
|
||||
|
||||
/* By default, the realloc function pointer is set to our internal
|
||||
realloc implementation which iself uses lt_dlmalloc and lt_dlfree.
|
||||
libltdl relies on a featureful realloc, but if you are sure yours
|
||||
has the right semantics then you can assign it directly. Generally,
|
||||
it is safe to assign just a malloc() and a free() function. */
|
||||
LT_SCOPE lt_ptr (*lt_dlmalloc) LT_PARAMS((size_t size));
|
||||
LT_SCOPE lt_ptr (*lt_dlrealloc) LT_PARAMS((lt_ptr ptr, size_t size));
|
||||
LT_SCOPE void (*lt_dlfree) LT_PARAMS((lt_ptr ptr));
|
||||
|
||||
|
||||
|
||||
|
||||
/* --- PRELOADED MODULE SUPPORT --- */
|
||||
|
||||
|
||||
/* A preopened symbol. Arrays of this type comprise the exported
|
||||
symbols for a dlpreopened module. */
|
||||
typedef struct {
|
||||
const char *name;
|
||||
lt_ptr address;
|
||||
} lt_dlsymlist;
|
||||
|
||||
extern int lt_dlpreload LT_PARAMS((const lt_dlsymlist *preloaded));
|
||||
extern int lt_dlpreload_default
|
||||
LT_PARAMS((const lt_dlsymlist *preloaded));
|
||||
|
||||
#define LTDL_SET_PRELOADED_SYMBOLS() LT_STMT_START{ \
|
||||
extern const lt_dlsymlist lt_preloaded_symbols[]; \
|
||||
lt_dlpreload_default(lt_preloaded_symbols); \
|
||||
}LT_STMT_END
|
||||
|
||||
|
||||
|
||||
|
||||
/* --- MODULE INFORMATION --- */
|
||||
|
||||
|
||||
/* Read only information pertaining to a loaded module. */
|
||||
typedef struct {
|
||||
char *filename; /* file name */
|
||||
char *name; /* module name */
|
||||
int ref_count; /* number of times lt_dlopened minus
|
||||
number of times lt_dlclosed. */
|
||||
} lt_dlinfo;
|
||||
|
||||
extern const lt_dlinfo *lt_dlgetinfo LT_PARAMS((lt_dlhandle handle));
|
||||
extern lt_dlhandle lt_dlhandle_next LT_PARAMS((lt_dlhandle place));
|
||||
extern int lt_dlforeach LT_PARAMS((
|
||||
int (*func) (lt_dlhandle handle, lt_ptr data),
|
||||
lt_ptr data));
|
||||
|
||||
/* Associating user data with loaded modules. */
|
||||
typedef unsigned lt_dlcaller_id;
|
||||
|
||||
extern lt_dlcaller_id lt_dlcaller_register LT_PARAMS((void));
|
||||
extern lt_ptr lt_dlcaller_set_data LT_PARAMS((lt_dlcaller_id key,
|
||||
lt_dlhandle handle,
|
||||
lt_ptr data));
|
||||
extern lt_ptr lt_dlcaller_get_data LT_PARAMS((lt_dlcaller_id key,
|
||||
lt_dlhandle handle));
|
||||
|
||||
|
||||
|
||||
/* --- USER MODULE LOADER API --- */
|
||||
|
||||
|
||||
typedef struct lt_dlloader lt_dlloader;
|
||||
typedef lt_ptr lt_user_data;
|
||||
typedef lt_ptr lt_module;
|
||||
|
||||
/* Function pointer types for creating user defined module loaders. */
|
||||
typedef lt_module lt_module_open LT_PARAMS((lt_user_data loader_data,
|
||||
const char *filename));
|
||||
typedef int lt_module_close LT_PARAMS((lt_user_data loader_data,
|
||||
lt_module handle));
|
||||
typedef lt_ptr lt_find_sym LT_PARAMS((lt_user_data loader_data,
|
||||
lt_module handle,
|
||||
const char *symbol));
|
||||
typedef int lt_dlloader_exit LT_PARAMS((lt_user_data loader_data));
|
||||
|
||||
struct lt_user_dlloader {
|
||||
const char *sym_prefix;
|
||||
lt_module_open *module_open;
|
||||
lt_module_close *module_close;
|
||||
lt_find_sym *find_sym;
|
||||
lt_dlloader_exit *dlloader_exit;
|
||||
lt_user_data dlloader_data;
|
||||
};
|
||||
|
||||
extern lt_dlloader *lt_dlloader_next LT_PARAMS((lt_dlloader *place));
|
||||
extern lt_dlloader *lt_dlloader_find LT_PARAMS((
|
||||
const char *loader_name));
|
||||
extern const char *lt_dlloader_name LT_PARAMS((lt_dlloader *place));
|
||||
extern lt_user_data *lt_dlloader_data LT_PARAMS((lt_dlloader *place));
|
||||
extern int lt_dlloader_add LT_PARAMS((lt_dlloader *place,
|
||||
const struct lt_user_dlloader *dlloader,
|
||||
const char *loader_name));
|
||||
extern int lt_dlloader_remove LT_PARAMS((
|
||||
const char *loader_name));
|
||||
|
||||
|
||||
|
||||
/* --- ERROR MESSAGE HANDLING --- */
|
||||
|
||||
|
||||
/* Defining error strings alongside their symbolic names in a macro in
|
||||
this way allows us to expand the macro in different contexts with
|
||||
confidence that the enumeration of symbolic names will map correctly
|
||||
onto the table of error strings. */
|
||||
#define lt_dlerror_table \
|
||||
LT_ERROR(UNKNOWN, "unknown error") \
|
||||
LT_ERROR(DLOPEN_NOT_SUPPORTED, "dlopen support not available") \
|
||||
LT_ERROR(INVALID_LOADER, "invalid loader") \
|
||||
LT_ERROR(INIT_LOADER, "loader initialization failed") \
|
||||
LT_ERROR(REMOVE_LOADER, "loader removal failed") \
|
||||
LT_ERROR(FILE_NOT_FOUND, "file not found") \
|
||||
LT_ERROR(DEPLIB_NOT_FOUND, "dependency library not found") \
|
||||
LT_ERROR(NO_SYMBOLS, "no symbols defined") \
|
||||
LT_ERROR(CANNOT_OPEN, "can't open the module") \
|
||||
LT_ERROR(CANNOT_CLOSE, "can't close the module") \
|
||||
LT_ERROR(SYMBOL_NOT_FOUND, "symbol not found") \
|
||||
LT_ERROR(NO_MEMORY, "not enough memory") \
|
||||
LT_ERROR(INVALID_HANDLE, "invalid module handle") \
|
||||
LT_ERROR(BUFFER_OVERFLOW, "internal buffer overflow") \
|
||||
LT_ERROR(INVALID_ERRORCODE, "invalid errorcode") \
|
||||
LT_ERROR(SHUTDOWN, "library already shutdown") \
|
||||
LT_ERROR(CLOSE_RESIDENT_MODULE, "can't close resident module") \
|
||||
LT_ERROR(INVALID_MUTEX_ARGS, "invalid mutex handler registration") \
|
||||
LT_ERROR(INVALID_POSITION, "invalid search path insert position")
|
||||
|
||||
/* Enumerate the symbolic error names. */
|
||||
enum {
|
||||
#define LT_ERROR(name, diagnostic) LT_CONC(LT_ERROR_, name),
|
||||
lt_dlerror_table
|
||||
#undef LT_ERROR
|
||||
|
||||
LT_ERROR_MAX
|
||||
};
|
||||
|
||||
/* These functions are only useful from inside custom module loaders. */
|
||||
extern int lt_dladderror LT_PARAMS((const char *diagnostic));
|
||||
extern int lt_dlseterror LT_PARAMS((int errorcode));
|
||||
|
||||
|
||||
|
||||
|
||||
/* --- SOURCE COMPATIBILITY WITH OLD LIBLTDL --- */
|
||||
|
||||
|
||||
#ifdef LT_NON_POSIX_NAMESPACE
|
||||
# define lt_ptr_t lt_ptr
|
||||
# define lt_module_t lt_module
|
||||
# define lt_module_open_t lt_module_open
|
||||
# define lt_module_close_t lt_module_close
|
||||
# define lt_find_sym_t lt_find_sym
|
||||
# define lt_dlloader_exit_t lt_dlloader_exit
|
||||
# define lt_dlloader_t lt_dlloader
|
||||
# define lt_dlloader_data_t lt_user_data
|
||||
#endif
|
||||
|
||||
LT_END_C_DECLS
|
||||
|
||||
#endif /* !LTDL_H */
|
||||
|
|
@ -265,36 +265,6 @@ extern int __pthread_atfork (void (*__prepare) (void),
|
|||
/* Make the pthread functions weak so that we can elide them from
|
||||
single-threaded processes. */
|
||||
#ifndef __NO_WEAK_PTHREAD_ALIASES
|
||||
# ifdef weak_extern
|
||||
# if _LIBC
|
||||
# include <bp-sym.h>
|
||||
# else
|
||||
# define BP_SYM (sym) sym
|
||||
# endif
|
||||
weak_extern (BP_SYM (__pthread_mutex_init))
|
||||
weak_extern (BP_SYM (__pthread_mutex_destroy))
|
||||
weak_extern (BP_SYM (__pthread_mutex_lock))
|
||||
weak_extern (BP_SYM (__pthread_mutex_trylock))
|
||||
weak_extern (BP_SYM (__pthread_mutex_unlock))
|
||||
weak_extern (BP_SYM (__pthread_mutexattr_init))
|
||||
weak_extern (BP_SYM (__pthread_mutexattr_destroy))
|
||||
weak_extern (BP_SYM (__pthread_mutexattr_settype))
|
||||
weak_extern (BP_SYM (__pthread_rwlock_init))
|
||||
weak_extern (BP_SYM (__pthread_rwlock_destroy))
|
||||
weak_extern (BP_SYM (__pthread_rwlock_rdlock))
|
||||
weak_extern (BP_SYM (__pthread_rwlock_tryrdlock))
|
||||
weak_extern (BP_SYM (__pthread_rwlock_wrlock))
|
||||
weak_extern (BP_SYM (__pthread_rwlock_trywrlock))
|
||||
weak_extern (BP_SYM (__pthread_rwlock_unlock))
|
||||
weak_extern (BP_SYM (__pthread_key_create))
|
||||
weak_extern (BP_SYM (__pthread_setspecific))
|
||||
weak_extern (BP_SYM (__pthread_getspecific))
|
||||
weak_extern (BP_SYM (__pthread_once))
|
||||
weak_extern (__pthread_initialize)
|
||||
weak_extern (__pthread_atfork)
|
||||
weak_extern (BP_SYM (_pthread_cleanup_push_defer))
|
||||
weak_extern (BP_SYM (_pthread_cleanup_pop_restore))
|
||||
# else
|
||||
# pragma weak __pthread_mutex_init
|
||||
# pragma weak __pthread_mutex_destroy
|
||||
# pragma weak __pthread_mutex_lock
|
||||
|
|
|
|||
|
|
@ -292,6 +292,20 @@ elf_machine_plt_value (struct link_map *map, const Elf32_Rel *reloc,
|
|||
return value;
|
||||
}
|
||||
|
||||
static inline void __attribute__ ((unused))
|
||||
elf_machine_rel (struct link_map *map, const Elf32_Rel *reloc,
|
||||
const Elf32_Sym *sym, const struct r_found_version *version,
|
||||
Elf32_Addr *const reloc_addr,
|
||||
struct r_scope_elem *scope[]);
|
||||
|
||||
static inline void __attribute__ ((unused))
|
||||
elf_machine_rel_relative (Elf32_Addr l_addr, const Elf32_Rel *reloc,
|
||||
Elf32_Addr *const reloc_addr);
|
||||
|
||||
static inline void
|
||||
elf_machine_lazy_rel (struct link_map *map,
|
||||
Elf32_Addr l_addr, const Elf32_Rel *reloc);
|
||||
|
||||
#endif /* !dl_machine_h */
|
||||
|
||||
#ifdef RESOLVE
|
||||
|
|
@ -299,10 +313,11 @@ elf_machine_plt_value (struct link_map *map, const Elf32_Rel *reloc,
|
|||
/* Perform the relocation specified by RELOC and SYM (which is fully resolved).
|
||||
MAP is the object containing the reloc. */
|
||||
|
||||
static inline void
|
||||
static inline void __attribute__ ((unused))
|
||||
elf_machine_rel (struct link_map *map, const Elf32_Rel *reloc,
|
||||
const Elf32_Sym *sym, const struct r_found_version *version,
|
||||
Elf32_Addr *const reloc_addr)
|
||||
Elf32_Addr *const reloc_addr,
|
||||
struct r_scope_elem *scope[])
|
||||
{
|
||||
const unsigned int r_type = ELF32_R_TYPE (reloc->r_info);
|
||||
|
||||
|
|
@ -316,7 +331,7 @@ elf_machine_rel (struct link_map *map, const Elf32_Rel *reloc,
|
|||
(i.e. #ifdef RTLD_BOOTSTRAP) because rtld.c contains the
|
||||
common defn for _dl_rtld_map, which is incompatible with a
|
||||
weak decl in the same file. */
|
||||
weak_extern (_dl_rtld_map);
|
||||
#pragma weak _dl_rtld_map
|
||||
if (map != &_dl_rtld_map) /* Already done in rtld itself. */
|
||||
# endif
|
||||
*reloc_addr += map->l_addr;
|
||||
|
|
@ -331,7 +346,9 @@ elf_machine_rel (struct link_map *map, const Elf32_Rel *reloc,
|
|||
#ifndef RTLD_BOOTSTRAP
|
||||
const Elf32_Sym *const refsym = sym;
|
||||
#endif
|
||||
Elf32_Addr value = RESOLVE (&sym, version, r_type);
|
||||
/* String table object symbols. */
|
||||
const char *strtab = (const void *) D_PTR (map, l_info[DT_STRTAB]);
|
||||
Elf32_Addr value = RESOLVE (&sym, version, r_type, scope);
|
||||
if (sym)
|
||||
value += sym->st_value;
|
||||
|
||||
|
|
@ -379,7 +396,7 @@ elf_machine_rel (struct link_map *map, const Elf32_Rel *reloc,
|
|||
}
|
||||
}
|
||||
|
||||
static inline void
|
||||
static inline void __attribute__ ((unused))
|
||||
elf_machine_rel_relative (Elf32_Addr l_addr, const Elf32_Rel *reloc,
|
||||
Elf32_Addr *const reloc_addr)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -1,8 +1,10 @@
|
|||
#define weak_alias(name, aliasname) \
|
||||
extern __typeof (name) aliasname __attribute__ ((weak, alias (#name)));
|
||||
|
||||
#if 0
|
||||
#define weak_extern(symbol) _weak_extern (symbol)
|
||||
#define _weak_extern(symbol) asm (".weak " #symbol);
|
||||
#endif
|
||||
|
||||
#define weak_function __attribute__ ((weak))
|
||||
|
||||
|
|
|
|||
|
|
@ -43,6 +43,8 @@ static char sccsid[] = "@(#)ns_ntoa.c 8.1 (Berkeley) 6/4/93";
|
|||
#include <netns/ns.h>
|
||||
#include <stdio.h>
|
||||
|
||||
static char *spectHex(char *p0);
|
||||
|
||||
char *
|
||||
ns_ntoa(addr)
|
||||
struct ns_addr addr;
|
||||
|
|
@ -54,7 +56,6 @@ ns_ntoa(addr)
|
|||
char *cp2;
|
||||
u_char *up = addr.x_host.c_host;
|
||||
u_char *uplim = up + 6;
|
||||
static char *spectHex();
|
||||
|
||||
net.net_e = addr.x_net;
|
||||
sprintf(obuf, "%lx", (u_long)ntohl(net.long_e));
|
||||
|
|
|
|||
|
|
@ -227,4 +227,12 @@
|
|||
# endif
|
||||
#endif
|
||||
|
||||
/* The nonull function attribute allows to mark pointer parameters which
|
||||
must not be NULL. */
|
||||
#if __GNUC_PREREQ (3,3)
|
||||
# define __nonnull(params) __attribute__ ((__nonnull__ params))
|
||||
#else
|
||||
# define __nonnull(params)
|
||||
#endif
|
||||
|
||||
#endif /* sys/cdefs.h */
|
||||
|
|
|
|||
|
|
@ -41,6 +41,7 @@ int closedir(DIR *);
|
|||
|
||||
/* internal prototype */
|
||||
void _seekdir(DIR *dir,off_t offset);
|
||||
DIR *_opendir(const char *);
|
||||
|
||||
#ifndef _POSIX_SOURCE
|
||||
long telldir (DIR *);
|
||||
|
|
|
|||
Loading…
Reference in New Issue