diff options
26 files changed, 1181 insertions, 116 deletions
diff --git a/newlib/ChangeLog b/newlib/ChangeLog index 989355c..fcd764c 100644 --- a/newlib/ChangeLog +++ b/newlib/ChangeLog @@ -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 diff --git a/newlib/Makefile.am b/newlib/Makefile.am index cd8fa61..db574a2 100644 --- a/newlib/Makefile.am +++ b/newlib/Makefile.am @@ -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`; \ diff --git a/newlib/Makefile.in b/newlib/Makefile.in index 7ce0e60..0e4e5a7 100644 --- a/newlib/Makefile.in +++ b/newlib/Makefile.in @@ -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`; \ diff --git a/newlib/iconvdata/jis0208.h b/newlib/iconvdata/jis0208.h index ef6b891..131a5c5 100644 --- a/newlib/iconvdata/jis0208.h +++ b/newlib/iconvdata/jis0208.h @@ -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) diff --git a/newlib/libc/sys/linux/argp/argp-fs-xinl.c b/newlib/libc/sys/linux/argp/argp-fs-xinl.c index b61a303..9b836d1 100644 --- a/newlib/libc/sys/linux/argp/argp-fs-xinl.c +++ b/newlib/libc/sys/linux/argp/argp-fs-xinl.c @@ -24,7 +24,7 @@ #define ARGP_FS_EI #undef __OPTIMIZE__ -#define __OPTIMIZE__ +#define __OPTIMIZE__ 1 #include "argp-fmtstream.h" /* Add weak aliases. */ diff --git a/newlib/libc/sys/linux/argp/argp-xinl.c b/newlib/libc/sys/linux/argp/argp-xinl.c index 0d64b1e..644836d 100644 --- a/newlib/libc/sys/linux/argp/argp-xinl.c +++ b/newlib/libc/sys/linux/argp/argp-xinl.c @@ -29,7 +29,7 @@ #endif #define ARGP_EI #undef __OPTIMIZE__ -#define __OPTIMIZE__ +#define __OPTIMIZE__ 1 #include <argp.h> /* Add weak aliases. */ diff --git a/newlib/libc/sys/linux/bits/initspin.h b/newlib/libc/sys/linux/bits/initspin.h new file mode 100644 index 0000000..a19ec07 --- /dev/null +++ b/newlib/libc/sys/linux/bits/initspin.h @@ -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 } diff --git a/newlib/libc/sys/linux/bits/libc-lock.h b/newlib/libc/sys/linux/bits/libc-lock.h new file mode 100644 index 0000000..2b17044 --- /dev/null +++ b/newlib/libc/sys/linux/bits/libc-lock.h @@ -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 */ diff --git a/newlib/libc/sys/linux/bits/pthreadtypes.h b/newlib/libc/sys/linux/bits/pthreadtypes.h new file mode 100644 index 0000000..d1daef0 --- /dev/null +++ b/newlib/libc/sys/linux/bits/pthreadtypes.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 */ diff --git a/newlib/libc/sys/linux/bits/typesizes.h b/newlib/libc/sys/linux/bits/typesizes.h new file mode 100644 index 0000000..45264ac --- /dev/null +++ b/newlib/libc/sys/linux/bits/typesizes.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 */ diff --git a/newlib/libc/sys/linux/dl/dl-cache.c b/newlib/libc/sys/linux/dl/dl-cache.c index a71e5e8..9511da1 100644 --- a/newlib/libc/sys/linux/dl/dl-cache.c +++ b/newlib/libc/sys/linux/dl/dl-cache.c @@ -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; diff --git a/newlib/libc/sys/linux/dl/dl-load.c b/newlib/libc/sys/linux/dl/dl-load.c index 65b72c7..4e32d60 100644 --- a/newlib/libc/sys/linux/dl/dl-load.c +++ b/newlib/libc/sys/linux/dl/dl-load.c @@ -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; diff --git a/newlib/libc/sys/linux/dl/dl-open.c b/newlib/libc/sys/linux/dl/dl-open.c index 1953614..4e068d4 100644 --- a/newlib/libc/sys/linux/dl/dl-open.c +++ b/newlib/libc/sys/linux/dl/dl-open.c @@ -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); diff --git a/newlib/libc/sys/linux/dl/dl-reloc.c b/newlib/libc/sys/linux/dl/dl-reloc.c index 9416314..0bffa4e 100644 --- a/newlib/libc/sys/linux/dl/dl-reloc.c +++ b/newlib/libc/sys/linux/dl/dl-reloc.c @@ -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 diff --git a/newlib/libc/sys/linux/dl/dl-runtime.c b/newlib/libc/sys/linux/dl/dl-runtime.c index 403091d..4fb81cf 100644 --- a/newlib/libc/sys/linux/dl/dl-runtime.c +++ b/newlib/libc/sys/linux/dl/dl-runtime.c @@ -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, diff --git a/newlib/libc/sys/linux/dl/do-rel.h b/newlib/libc/sys/linux/dl/do-rel.h index 46202d7..03b9e80 100644 --- a/newlib/libc/sys/linux/dl/do-rel.h +++ b/newlib/libc/sys/linux/dl/do-rel.h @@ -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); } } diff --git a/newlib/libc/sys/linux/dl/dynamic-link.h b/newlib/libc/sys/linux/dl/dynamic-link.h index a63fded..c1709f7 100644 --- a/newlib/libc/sys/linux/dl/dynamic-link.h +++ b/newlib/libc/sys/linux/dl/dynamic-link.h @@ -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 diff --git a/newlib/libc/sys/linux/iconv/gconv_open.c b/newlib/libc/sys/linux/iconv/gconv_open.c index 5c10d60..1b2fbb5 100644 --- a/newlib/libc/sys/linux/iconv/gconv_open.c +++ b/newlib/libc/sys/linux/iconv/gconv_open.c @@ -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. */ diff --git a/newlib/libc/sys/linux/iconv/gconv_simple.c b/newlib/libc/sys/linux/iconv/gconv_simple.c index a4a99ea..edc091f 100644 --- a/newlib/libc/sys/linux/iconv/gconv_simple.c +++ b/newlib/libc/sys/linux/iconv/gconv_simple.c @@ -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; \ } \ } diff --git a/newlib/libc/sys/linux/include/ltdl.h b/newlib/libc/sys/linux/include/ltdl.h new file mode 100644 index 0000000..2bbfa30 --- /dev/null +++ b/newlib/libc/sys/linux/include/ltdl.h @@ -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 */ diff --git a/newlib/libc/sys/linux/linuxthreads/bits/libc-lock.h b/newlib/libc/sys/linux/linuxthreads/bits/libc-lock.h index 2c1d162..1250022 100644 --- a/newlib/libc/sys/linux/linuxthreads/bits/libc-lock.h +++ b/newlib/libc/sys/linux/linuxthreads/bits/libc-lock.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 diff --git a/newlib/libc/sys/linux/machine/i386/dl-machine.h b/newlib/libc/sys/linux/machine/i386/dl-machine.h index 032713e..80757e8 100644 --- a/newlib/libc/sys/linux/machine/i386/dl-machine.h +++ b/newlib/libc/sys/linux/machine/i386/dl-machine.h @@ -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) { diff --git a/newlib/libc/sys/linux/machine/i386/weakalias.h b/newlib/libc/sys/linux/machine/i386/weakalias.h index 7b0b18a..2813bfe 100644 --- a/newlib/libc/sys/linux/machine/i386/weakalias.h +++ b/newlib/libc/sys/linux/machine/i386/weakalias.h @@ -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)) diff --git a/newlib/libc/sys/linux/net/ns_ntoa.c b/newlib/libc/sys/linux/net/ns_ntoa.c index 0180760..b6a6c4c 100644 --- a/newlib/libc/sys/linux/net/ns_ntoa.c +++ b/newlib/libc/sys/linux/net/ns_ntoa.c @@ -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)); diff --git a/newlib/libc/sys/linux/sys/cdefs.h b/newlib/libc/sys/linux/sys/cdefs.h index 459785b..f6ea0c7 100644 --- a/newlib/libc/sys/linux/sys/cdefs.h +++ b/newlib/libc/sys/linux/sys/cdefs.h @@ -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 */ diff --git a/newlib/libc/sys/linux/sys/dirent.h b/newlib/libc/sys/linux/sys/dirent.h index 083158e..4bbae42 100644 --- a/newlib/libc/sys/linux/sys/dirent.h +++ b/newlib/libc/sys/linux/sys/dirent.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 *); |