remove linuxthreads.new, rename linuxthreads.old

Linuxthreads.new isn't really useful with the existence
of NPTL/TLS for well supported architectures. There is no
reason to use LT.new for ARM/MIPS or other architectures
supporting NPTL/TLS. It is not available for noMMU architectures
like Blackfin or FR-V. To simplify the live of the few uClibc-ng
developers, LT.new is removed and LT.old is renamed to LT.
LINUXTHREADS_OLD -> UCLIBC_HAS_LINUXTHREADS

7 files changed, 0 insertions, 1660 deletions

diff --git a/libpthread/linuxthreads.old/sysdeps/pthread/bits/libc-lock.h b/libpthread/linuxthreads.old/sysdeps/pthread/bits/libc-lock.h
deleted file mode 100644
index 8833e343d..000000000
--- a/libpthread/linuxthreads.old/sysdeps/pthread/bits/libc-lock.h
+++ /dev/null
@@ -1,415 +0,0 @@
-/* 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, see <http://www.gnu.org/licenses/>.  */
-
-#ifndef _BITS_LIBC_LOCK_H
-#define _BITS_LIBC_LOCK_H 1
-
-#include <pthread.h>
-
-#if defined _LIBC && !defined NOT_IN_libc
-#include <linuxthreads.old/internals.h>
-#endif
-
-/* Mutex type.  */
-#if defined(_LIBC) || defined(_IO_MTSAFE_IO)
-typedef pthread_mutex_t __libc_lock_t;
-typedef pthread_mutex_t __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 an adaptive mutex.  */
-#if defined _LIBC && !defined NOT_IN_libc && defined SHARED
-#define __libc_lock_init_adaptive(NAME) \
-  ({									      \
-    (NAME).__m_count = 0;						      \
-    (NAME).__m_owner = NULL;						      \
-    (NAME).__m_kind = PTHREAD_MUTEX_ADAPTIVE_NP;			      \
-    (NAME).__m_lock.__status = 0;					      \
-    (NAME).__m_lock.__spinlock = __LT_SPINLOCK_INIT;			      \
-    0; })
-#else
-#define __libc_lock_init_adaptive(NAME) \
-  do {									      \
-    if (__pthread_mutex_init != NULL)					      \
-      {									      \
-	pthread_mutexattr_t __attr;					      \
-	__pthread_mutexattr_init (&__attr);				      \
-	__pthread_mutexattr_settype (&__attr, PTHREAD_MUTEX_ADAPTIVE_NP);     \
-	__pthread_mutex_init (&(NAME), &__attr);			      \
-	__pthread_mutexattr_destroy (&__attr);				      \
-      }									      \
-  } while (0);
-#endif
-
-/* 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).__m_count = 0;						      \
-    (NAME).__m_owner = NULL;					      \
-    (NAME).__m_kind = PTHREAD_MUTEX_RECURSIVE_NP;			      \
-    (NAME).__m_lock.__status = 0;					      \
-    (NAME).__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), &__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)
-
-/* 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) = !PTHREAD_ONCE_INIT;				      \
-    }									      \
-  } 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));			      \
-    }
-
-#if 0
-#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);	      \
-    }
-#endif
-
-/* 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
-# ifdef weak_extern
-#   define BP_SYM(sym) sym
-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_atfork)
-weak_extern (BP_SYM (_pthread_cleanup_push))
-weak_extern (BP_SYM (_pthread_cleanup_pop))
-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
-#  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_atfork
-#  pragma weak _pthread_cleanup_push_defer
-#  pragma weak _pthread_cleanup_pop_restore
-#  pragma weak _pthread_cleanup_push
-#  pragma weak _pthread_cleanup_pop
-# endif
-#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/libpthread/linuxthreads.old/sysdeps/pthread/bits/libc-tsd.h b/libpthread/linuxthreads.old/sysdeps/pthread/bits/libc-tsd.h
deleted file mode 100644
index 97af75ebf..000000000
--- a/libpthread/linuxthreads.old/sysdeps/pthread/bits/libc-tsd.h
+++ /dev/null
@@ -1,69 +0,0 @@
-/* libc-internal interface for thread-specific data.  LinuxThreads version.
-   Copyright (C) 1997-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, see <http://www.gnu.org/licenses/>.  */
-
-#ifndef _BITS_LIBC_TSD_H
-#define _BITS_LIBC_TSD_H 1
-
-/* Fast thread-specific data internal to libc.  */
-enum __libc_tsd_key_t { _LIBC_TSD_KEY_MALLOC = 0,
-			_LIBC_TSD_KEY_DL_ERROR,
-			_LIBC_TSD_KEY_RPC_VARS,
-			_LIBC_TSD_KEY_LOCALE,
-			_LIBC_TSD_KEY_CTYPE_B,
-			_LIBC_TSD_KEY_CTYPE_TOLOWER,
-			_LIBC_TSD_KEY_CTYPE_TOUPPER,
-			_LIBC_TSD_KEY_N };
-
-#include <features.h>
-#include <linuxthreads.old/internals.h>
-
-#ifdef __UCLIBC_HAS_TLS__
-#include <tls.h>
-
-/* When __thread works, the generic definition is what we want.  */
-# include <sysdeps/generic/bits/libc-tsd.h>
-
-#else
-
-# include <bits/libc-lock.h>
-
-# ifndef SHARED
-extern void ** __pthread_internal_tsd_address (int);
-extern void *__pthread_internal_tsd_get (int);
-extern int __pthread_internal_tsd_set (int, const void *);
-
-weak_extern (__pthread_internal_tsd_address)
-weak_extern (__pthread_internal_tsd_get)
-weak_extern (__pthread_internal_tsd_set)
-# endif
-
-#define __libc_tsd_define(CLASS, KEY)	CLASS void *__libc_tsd_##KEY##_data;
-#define __libc_tsd_address(KEY) \
-  __libc_maybe_call2 (pthread_internal_tsd_address,			\
-		      (_LIBC_TSD_KEY_##KEY), &__libc_tsd_##KEY##_data)
-#define __libc_tsd_get(KEY) \
-  __libc_maybe_call2 (pthread_internal_tsd_get,				\
-		      (_LIBC_TSD_KEY_##KEY), __libc_tsd_##KEY##_data)
-#define __libc_tsd_set(KEY, VALUE) \
-  __libc_maybe_call2 (pthread_internal_tsd_set,				\
-		      (_LIBC_TSD_KEY_##KEY, (VALUE)),			\
-		       (__libc_tsd_##KEY##_data = (VALUE), 0))
-
-#endif
-
-#endif	/* bits/libc-tsd.h */
diff --git a/libpthread/linuxthreads.old/sysdeps/pthread/bits/pthreadtypes.h b/libpthread/linuxthreads.old/sysdeps/pthread/bits/pthreadtypes.h
deleted file mode 100644
index 3eb592919..000000000
--- a/libpthread/linuxthreads.old/sysdeps/pthread/bits/pthreadtypes.h
+++ /dev/null
@@ -1,145 +0,0 @@
-/* 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_size_t
-#include <stddef.h>
-
-#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 */
-typedef struct
-{
-  struct _pthread_fastlock __c_lock; /* Protect against concurrent access */
-  _pthread_descr __c_waiting;        /* Threads waiting on this condition */
-} 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/libpthread/linuxthreads.old/sysdeps/pthread/not-cancel.h b/libpthread/linuxthreads.old/sysdeps/pthread/not-cancel.h
deleted file mode 100644
index bbdb0739c..000000000
--- a/libpthread/linuxthreads.old/sysdeps/pthread/not-cancel.h
+++ /dev/null
@@ -1,113 +0,0 @@
-/* Uncancelable versions of cancelable interfaces.  Linux version.
-   Copyright (C) 2003, 2006 Free Software Foundation, Inc.
-   This file is part of the GNU C Library.
-   Contributed by Ulrich Drepper <drepper@redhat.com>, 2003.
-
-   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, see
-   <http://www.gnu.org/licenses/>.  */
-
-#include <sys/types.h>
-#include <sysdep.h>
-
-/* Uncancelable open.  */
-#if defined __NR_openat && !defined __NR_open
-#define open_not_cancel(name, flags, mode) \
-	INLINE_SYSCALL (openat, 4, AT_FDCWD, (const char *) (name), \
-		(flags), (mode))
-#define open_not_cancel_2(name, flags) \
-	INLINE_SYSCALL (openat, 3, AT_FDCWD, (const char *) (name), \
-		(flags))
-#else
-#define open_not_cancel(name, flags, mode) \
-   INLINE_SYSCALL (open, 3, (const char *) (name), (flags), (mode))
-#define open_not_cancel_2(name, flags) \
-   INLINE_SYSCALL (open, 2, (const char *) (name), (flags))
-#endif
-
-/* Uncancelable openat.  */
-#if !defined NOT_IN_libc || defined IS_IN_libpthread || defined IS_IN_librt
-extern int __openat_nocancel (int fd, const char *fname, int oflag,
-			      mode_t mode) attribute_hidden;
-extern int __openat64_nocancel (int fd, const char *fname, int oflag,
-				mode_t mode) attribute_hidden;
-#else
-# define __openat_nocancel(fd, fname, oflag, mode) \
-  openat (fd, fname, oflag, mode)
-# define __openat64_nocancel(fd, fname, oflag, mode) \
-  openat64 (fd, fname, oflag, mode)
-#endif
-
-#define openat_not_cancel(fd, fname, oflag, mode) \
-  __openat_nocancel (fd, fname, oflag, mode)
-#define openat_not_cancel_3(fd, fname, oflag) \
-  __openat_nocancel (fd, fname, oflag, 0)
-#define openat64_not_cancel(fd, fname, oflag, mode) \
-  __openat64_nocancel (fd, fname, oflag, mode)
-#define openat64_not_cancel_3(fd, fname, oflag) \
-  __openat64_nocancel (fd, fname, oflag, 0)
-
-/* Uncancelable close.  */
-#define close_not_cancel(fd) \
-  INLINE_SYSCALL (close, 1, fd)
-#define close_not_cancel_no_status(fd) \
-  (void) ({ INTERNAL_SYSCALL_DECL (err);				      \
-	    INTERNAL_SYSCALL (close, err, 1, (fd)); })
-
-/* Uncancelable read.  */
-#define read_not_cancel(fd, buf, n) \
-  INLINE_SYSCALL (read, 3, (fd), (buf), (n))
-
-/* Uncancelable write.  */
-#define write_not_cancel(fd, buf, n) \
-  INLINE_SYSCALL (write, 3, (fd), (buf), (n))
-
-/* Uncancelable writev.  */
-#define writev_not_cancel_no_status(fd, iov, n) \
-  (void) ({ INTERNAL_SYSCALL_DECL (err);				      \
-	    INTERNAL_SYSCALL (writev, err, 3, (fd), (iov), (n)); })
-
-/* Uncancelable fcntl.  */
-#define fcntl_not_cancel(fd, cmd, val) \
-  __fcntl_nocancel (fd, cmd, val)
-
-/* Uncancelable waitpid.  */
-#ifdef __NR_waitpid
-# define waitpid_not_cancel(pid, stat_loc, options) \
-  INLINE_SYSCALL (waitpid, 3, pid, stat_loc, options)
-#else
-# define waitpid_not_cancel(pid, stat_loc, options) \
-  INLINE_SYSCALL (wait4, 4, pid, stat_loc, options, NULL)
-#endif
-
-/* Uncancelable pause.  */
-#ifdef __NR_pause
-# define pause_not_cancel() \
-  INLINE_SYSCALL (pause, 0)
-#else
-# define pause_not_cancel() \
-  __pause_nocancel ()
-#endif
-
-/* Uncancelable nanosleep.  */
-#ifdef __NR_nanosleep
-# define nanosleep_not_cancel(requested_time, remaining) \
-  INLINE_SYSCALL (nanosleep, 2, requested_time, remaining)
-#else
-# define nanosleep_not_cancel(requested_time, remaining) \
-  __nanosleep_nocancel (requested_time, remaining)
-#endif
-
-/* Uncancelable sigsuspend.  */
-#define sigsuspend_not_cancel(set) \
-  __sigsuspend_nocancel (set)
diff --git a/libpthread/linuxthreads.old/sysdeps/pthread/pthread-functions.h b/libpthread/linuxthreads.old/sysdeps/pthread/pthread-functions.h
deleted file mode 100644
index 2afaa52e8..000000000
--- a/libpthread/linuxthreads.old/sysdeps/pthread/pthread-functions.h
+++ /dev/null
@@ -1,113 +0,0 @@
-/* Copyright (C) 2003 Free Software Foundation, Inc.
-   This file is part of the GNU C Library.
-   Contributed by Ulrich Drepper <drepper@redhat.com>, 2003.
-
-   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, see
-   <http://www.gnu.org/licenses/>.  */
-
-#ifndef _PTHREAD_FUNCTIONS_H
-#define _PTHREAD_FUNCTIONS_H	1
-
-#include <pthread.h>
-#if 0
-#include <setjmp.h>
-#include <linuxthreads.old/internals.h>
-
-struct fork_block;
-#endif
-
-/* Data type shared with libc.  The libc uses it to pass on calls to
-   the thread functions.  Wine pokes directly into this structure,
-   so if possible avoid breaking it and append new hooks to the end.  */
-struct pthread_functions
-{
-#if 0
-  pid_t (*ptr_pthread_fork) (struct fork_block *);
-#endif
-  int (*ptr_pthread_attr_destroy) (pthread_attr_t *);
-  int (*ptr_pthread_attr_init) (pthread_attr_t *);
-  int (*ptr_pthread_attr_getdetachstate) (const pthread_attr_t *, int *);
-  int (*ptr_pthread_attr_setdetachstate) (pthread_attr_t *, int);
-  int (*ptr_pthread_attr_getinheritsched) (const pthread_attr_t *, int *);
-  int (*ptr_pthread_attr_setinheritsched) (pthread_attr_t *, int);
-  int (*ptr_pthread_attr_getschedparam) (const pthread_attr_t *,
-					 struct sched_param *);
-  int (*ptr_pthread_attr_setschedparam) (pthread_attr_t *,
-					 const struct sched_param *);
-  int (*ptr_pthread_attr_getschedpolicy) (const pthread_attr_t *, int *);
-  int (*ptr_pthread_attr_setschedpolicy) (pthread_attr_t *, int);
-  int (*ptr_pthread_attr_getscope) (const pthread_attr_t *, int *);
-  int (*ptr_pthread_attr_setscope) (pthread_attr_t *, int);
-  int (*ptr_pthread_condattr_destroy) (pthread_condattr_t *);
-  int (*ptr_pthread_condattr_init) (pthread_condattr_t *);
-  int (*ptr_pthread_cond_broadcast) (pthread_cond_t *);
-  int (*ptr_pthread_cond_destroy) (pthread_cond_t *);
-  int (*ptr_pthread_cond_init) (pthread_cond_t *,
-				  const pthread_condattr_t *);
-  int (*ptr_pthread_cond_signal) (pthread_cond_t *);
-  int (*ptr_pthread_cond_wait) (pthread_cond_t *, pthread_mutex_t *);
-  int (*ptr_pthread_equal) (pthread_t, pthread_t);
-  void (*ptr___pthread_exit) (void *);
-  int (*ptr_pthread_getschedparam) (pthread_t, int *, struct sched_param *);
-  int (*ptr_pthread_setschedparam) (pthread_t, int,
-				    const struct sched_param *);
-  int (*ptr_pthread_mutex_destroy) (pthread_mutex_t *);
-  int (*ptr_pthread_mutex_init) (pthread_mutex_t *,
-				 const pthread_mutexattr_t *);
-  int (*ptr_pthread_mutex_lock) (pthread_mutex_t *);
-  int (*ptr_pthread_mutex_trylock) (pthread_mutex_t *);
-  int (*ptr_pthread_mutex_unlock) (pthread_mutex_t *);
-  pthread_t (*ptr_pthread_self) (void);
-  int (*ptr_pthread_setcancelstate) (int, int *);
-  int (*ptr_pthread_setcanceltype) (int, int *);
-#if 0
-  void (*ptr_pthread_do_exit) (void *retval, char *currentframe);
-  void (*ptr_pthread_cleanup_upto) (__jmp_buf target,
-				    char *targetframe);
-  pthread_descr (*ptr_pthread_thread_self) (void);
-#endif
-#if !defined __UCLIBC_HAS_TLS__ && defined __UCLIBC_HAS_RPC__
-  int (*ptr_pthread_internal_tsd_set) (int key, const void *pointer);
-  void * (*ptr_pthread_internal_tsd_get) (int key);
-  void ** __attribute__ ((__const__))
-    (*ptr_pthread_internal_tsd_address) (int key);
-#endif
-#if 0
-  int (*ptr_pthread_sigaction) (int sig, const struct sigaction * act,
-				struct sigaction *oact);
-  int (*ptr_pthread_sigwait) (const sigset_t *set, int *sig);
-  int (*ptr_pthread_raise) (int sig);
-#endif
-  int (*ptr_pthread_cond_timedwait) (pthread_cond_t *, pthread_mutex_t *,
-				       const struct timespec *);
-#if 0
-  void (*ptr__pthread_cleanup_push) (struct _pthread_cleanup_buffer * buffer,
-				     void (*routine)(void *), void * arg);
-#endif
-  void (*ptr__pthread_cleanup_push_defer) (struct _pthread_cleanup_buffer * buffer,
-					   void (*routine)(void *), void * arg);
-#if 0
-  void (*ptr__pthread_cleanup_pop) (struct _pthread_cleanup_buffer * buffer,
-				    int execute);
-#endif
-  void (*ptr__pthread_cleanup_pop_restore) (struct _pthread_cleanup_buffer * buffer,
-					    int execute);
-};
-
-/* Variable in libc.so.  */
-extern struct pthread_functions __libc_pthread_functions attribute_hidden;
-
-extern int * __libc_pthread_init (const struct pthread_functions *functions);
-
-#endif	/* pthread-functions.h */
diff --git a/libpthread/linuxthreads.old/sysdeps/pthread/pthread.h b/libpthread/linuxthreads.old/sysdeps/pthread/pthread.h
deleted file mode 100644
index 3c7044d8b..000000000
--- a/libpthread/linuxthreads.old/sysdeps/pthread/pthread.h
+++ /dev/null
@@ -1,725 +0,0 @@
-/* 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.                 */
-
-#ifndef _PTHREAD_H
-#define _PTHREAD_H	1
-
-#include <features.h>
-
-#include <sched.h>
-#include <time.h>
-
-#define __need_sigset_t
-#include <signal.h>
-#include <bits/pthreadtypes.h>
-#include <bits/initspin.h>
-
-
-__BEGIN_DECLS
-
-/* Initializers.  */
-
-#define PTHREAD_MUTEX_INITIALIZER \
-  {0, 0, 0, PTHREAD_MUTEX_ADAPTIVE_NP, __LOCK_INITIALIZER}
-#ifdef __USE_GNU
-# define PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP \
-  {0, 0, 0, PTHREAD_MUTEX_RECURSIVE_NP, __LOCK_INITIALIZER}
-# define PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP \
-  {0, 0, 0, PTHREAD_MUTEX_ERRORCHECK_NP, __LOCK_INITIALIZER}
-# define PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP \
-  {0, 0, 0, PTHREAD_MUTEX_ADAPTIVE_NP, __LOCK_INITIALIZER}
-#endif
-
-#define PTHREAD_COND_INITIALIZER {__LOCK_INITIALIZER, 0}
-
-#if defined __USE_UNIX98 || defined __USE_XOPEN2K
-# define PTHREAD_RWLOCK_INITIALIZER \
-  { __LOCK_INITIALIZER, 0, NULL, NULL, NULL,				      \
-    PTHREAD_RWLOCK_DEFAULT_NP, PTHREAD_PROCESS_PRIVATE }
-#endif
-#ifdef __USE_GNU
-# define PTHREAD_RWLOCK_WRITER_NONRECURSIVE_INITIALIZER_NP \
-  { __LOCK_INITIALIZER, 0, NULL, NULL, NULL,				      \
-    PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP, PTHREAD_PROCESS_PRIVATE }
-#endif
-
-/* Values for attributes.  */
-
-enum
-{
-  PTHREAD_CREATE_JOINABLE,
-#define PTHREAD_CREATE_JOINABLE	PTHREAD_CREATE_JOINABLE
-  PTHREAD_CREATE_DETACHED
-#define PTHREAD_CREATE_DETACHED	PTHREAD_CREATE_DETACHED
-};
-
-enum
-{
-  PTHREAD_INHERIT_SCHED,
-#define PTHREAD_INHERIT_SCHED	PTHREAD_INHERIT_SCHED
-  PTHREAD_EXPLICIT_SCHED
-#define PTHREAD_EXPLICIT_SCHED	PTHREAD_EXPLICIT_SCHED
-};
-
-enum
-{
-  PTHREAD_SCOPE_SYSTEM,
-#define PTHREAD_SCOPE_SYSTEM	PTHREAD_SCOPE_SYSTEM
-  PTHREAD_SCOPE_PROCESS
-#define PTHREAD_SCOPE_PROCESS	PTHREAD_SCOPE_PROCESS
-};
-
-enum
-{
-  PTHREAD_MUTEX_ADAPTIVE_NP,
-  PTHREAD_MUTEX_RECURSIVE_NP,
-  PTHREAD_MUTEX_ERRORCHECK_NP,
-  PTHREAD_MUTEX_TIMED_NP
-#ifdef __USE_UNIX98
-  ,
-  PTHREAD_MUTEX_NORMAL = PTHREAD_MUTEX_ADAPTIVE_NP,
-  PTHREAD_MUTEX_RECURSIVE = PTHREAD_MUTEX_RECURSIVE_NP,
-  PTHREAD_MUTEX_ERRORCHECK = PTHREAD_MUTEX_ERRORCHECK_NP,
-  PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_NORMAL
-#endif
-#ifdef __USE_GNU
-  /* For compatibility.  */
-  , PTHREAD_MUTEX_FAST_NP = PTHREAD_MUTEX_ADAPTIVE_NP
-#endif
-};
-
-enum
-{
-  PTHREAD_PROCESS_PRIVATE,
-#define PTHREAD_PROCESS_PRIVATE	PTHREAD_PROCESS_PRIVATE
-  PTHREAD_PROCESS_SHARED
-#define PTHREAD_PROCESS_SHARED	PTHREAD_PROCESS_SHARED
-};
-
-#if defined __USE_UNIX98 || defined __USE_XOPEN2K
-enum
-{
-  PTHREAD_RWLOCK_PREFER_READER_NP,
-  PTHREAD_RWLOCK_PREFER_WRITER_NP,
-  PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP,
-  PTHREAD_RWLOCK_DEFAULT_NP = PTHREAD_RWLOCK_PREFER_WRITER_NP
-};
-#endif	/* Unix98 */
-
-#define PTHREAD_ONCE_INIT 0
-
-/* Special constants */
-
-#ifdef __USE_XOPEN2K
-/* -1 is distinct from 0 and all errno constants */
-# define PTHREAD_BARRIER_SERIAL_THREAD -1
-#endif
-
-/* Cleanup buffers */
-
-struct _pthread_cleanup_buffer
-{
-  void (*__routine) (void *);		  /* Function to call.  */
-  void *__arg;				  /* Its argument.  */
-  int __canceltype;			  /* Saved cancellation type. */
-  struct _pthread_cleanup_buffer *__prev; /* Chaining of cleanup functions.  */
-};
-
-/* Cancellation */
-
-enum
-{
-  PTHREAD_CANCEL_ENABLE,
-#define PTHREAD_CANCEL_ENABLE	PTHREAD_CANCEL_ENABLE
-  PTHREAD_CANCEL_DISABLE
-#define PTHREAD_CANCEL_DISABLE	PTHREAD_CANCEL_DISABLE
-};
-enum
-{
-  PTHREAD_CANCEL_DEFERRED,
-#define PTHREAD_CANCEL_DEFERRED	PTHREAD_CANCEL_DEFERRED
-  PTHREAD_CANCEL_ASYNCHRONOUS
-#define PTHREAD_CANCEL_ASYNCHRONOUS	PTHREAD_CANCEL_ASYNCHRONOUS
-};
-#define PTHREAD_CANCELED ((void *) -1)
-
-
-/* Function for handling threads.  */
-
-/* Create a thread with given attributes ATTR (or default attributes
-   if ATTR is NULL), and call function START_ROUTINE with given
-   arguments ARG.  */
-extern int pthread_create (pthread_t *__restrict __threadp,
-			   const pthread_attr_t *__restrict __attr,
-			   void *(*__start_routine) (void *),
-			   void *__restrict __arg) __THROWNL;
-
-/* Obtain the identifier of the current thread.  */
-extern pthread_t pthread_self (void) __THROW;
-
-/* Compare two thread identifiers.  */
-extern int pthread_equal (pthread_t __thread1, pthread_t __thread2) __THROW;
-
-/* Terminate calling thread.  */
-extern void pthread_exit (void *__retval) __attribute__ ((__noreturn__));
-
-/* Make calling thread wait for termination of the thread TH.  The
-   exit status of the thread is stored in *THREAD_RETURN, if THREAD_RETURN
-   is not NULL.  */
-extern int pthread_join (pthread_t __th, void **__thread_return);
-
-#ifdef __USE_GNU
-/* Check whether thread TH has terminated.  If yes return the status of
-   the thread in *THREAD_RETURN, if THREAD_RETURN is not NULL.  */
-extern int pthread_tryjoin_np (pthread_t __th, void **__thread_return) __THROW;
-
-/* Make calling thread wait for termination of the thread TH, but only
-   until TIMEOUT.  The exit status of the thread is stored in
-   *THREAD_RETURN, if THREAD_RETURN is not NULL.
-
-   This function is a cancellation point and therefore not marked with
-   __THROW.  */
-extern int pthread_timedjoin_np (pthread_t __th, void **__thread_return,
-				 __const struct timespec *__abstime);
-#endif
-
-/* Indicate that the thread TH is never to be joined with PTHREAD_JOIN.
-   The resources of TH will therefore be freed immediately when it
-   terminates, instead of waiting for another thread to perform PTHREAD_JOIN
-   on it.  */
-extern int pthread_detach (pthread_t __th) __THROW;
-
-
-/* Functions for handling attributes.  */
-
-/* Initialize thread attribute *ATTR with default attributes
-   (detachstate is PTHREAD_JOINABLE, scheduling policy is SCHED_OTHER,
-    no user-provided stack).  */
-extern int pthread_attr_init (pthread_attr_t *__attr) __THROW;
-
-/* Destroy thread attribute *ATTR.  */
-extern int pthread_attr_destroy (pthread_attr_t *__attr) __THROW;
-
-/* Set the `detachstate' attribute in *ATTR according to DETACHSTATE.  */
-extern int pthread_attr_setdetachstate (pthread_attr_t *__attr,
-					int __detachstate) __THROW;
-
-/* Return in *DETACHSTATE the `detachstate' attribute in *ATTR.  */
-extern int pthread_attr_getdetachstate (const pthread_attr_t *__attr,
-					int *__detachstate) __THROW;
-
-/* Set scheduling parameters (priority, etc) in *ATTR according to PARAM.  */
-extern int pthread_attr_setschedparam (pthread_attr_t *__restrict __attr,
-				       const struct sched_param *__restrict
-				       __param) __THROW;
-
-/* Return in *PARAM the scheduling parameters of *ATTR.  */
-extern int pthread_attr_getschedparam (const pthread_attr_t *__restrict
-				       __attr,
-				       struct sched_param *__restrict __param)
-     __THROW;
-
-/* Set scheduling policy in *ATTR according to POLICY.  */
-extern int pthread_attr_setschedpolicy (pthread_attr_t *__attr, int __policy)
-     __THROW;
-
-/* Return in *POLICY the scheduling policy of *ATTR.  */
-extern int pthread_attr_getschedpolicy (const pthread_attr_t *__restrict
-					__attr, int *__restrict __policy)
-     __THROW;
-
-/* Set scheduling inheritance mode in *ATTR according to INHERIT.  */
-extern int pthread_attr_setinheritsched (pthread_attr_t *__attr,
-					 int __inherit) __THROW;
-
-/* Return in *INHERIT the scheduling inheritance mode of *ATTR.  */
-extern int pthread_attr_getinheritsched (const pthread_attr_t *__restrict
-					 __attr, int *__restrict __inherit)
-     __THROW;
-
-/* Set scheduling contention scope in *ATTR according to SCOPE.  */
-extern int pthread_attr_setscope (pthread_attr_t *__attr, int __scope)
-     __THROW;
-
-/* Return in *SCOPE the scheduling contention scope of *ATTR.  */
-extern int pthread_attr_getscope (const pthread_attr_t *__restrict __attr,
-				  int *__restrict __scope) __THROW;
-
-#ifdef __USE_UNIX98
-/* Set the size of the guard area at the bottom of the thread.  */
-extern int pthread_attr_setguardsize (pthread_attr_t *__attr,
-				      size_t __guardsize) __THROW;
-
-/* Get the size of the guard area at the bottom of the thread.  */
-extern int pthread_attr_getguardsize (const pthread_attr_t *__restrict
-				      __attr, size_t *__restrict __guardsize)
-     __THROW;
-#endif
-
-#if 0 /* uClibc: deprecated stuff disabled. def __UCLIBC_SUSV3_LEGACY__ */
-/* Set the starting address of the stack of the thread to be created.
-   Depending on whether the stack grows up or down the value must either
-   be higher or lower than all the address in the memory block.  The
-   minimal size of the block must be PTHREAD_STACK_SIZE.  */
-extern int pthread_attr_setstackaddr (pthread_attr_t *__attr,
-				      void *__stackaddr) __THROW;
-
-/* Return the previously set address for the stack.  */
-extern int pthread_attr_getstackaddr (const pthread_attr_t *__restrict
-				      __attr, void **__restrict __stackaddr)
-     __THROW;
-#endif
-
-#ifdef __USE_XOPEN2K
-/* The following two interfaces are intended to replace the last two.  They
-   require setting the address as well as the size since only setting the
-   address will make the implementation on some architectures impossible.  */
-extern int pthread_attr_setstack (pthread_attr_t *__attr, void *__stackaddr,
-				  size_t __stacksize) __THROW;
-
-/* Return the previously set address for the stack.  */
-extern int pthread_attr_getstack (const pthread_attr_t *__restrict __attr,
-				  void **__restrict __stackaddr,
-				  size_t *__restrict __stacksize) __THROW;
-#endif
-
-/* Add information about the minimum stack size needed for the thread
-   to be started.  This size must never be less than PTHREAD_STACK_SIZE
-   and must also not exceed the system limits.  */
-extern int pthread_attr_setstacksize (pthread_attr_t *__attr,
-				      size_t __stacksize) __THROW;
-
-/* Return the currently used minimal stack size.  */
-extern int pthread_attr_getstacksize (const pthread_attr_t *__restrict
-				      __attr, size_t *__restrict __stacksize)
-     __THROW;
-
-#if 0
-/* Not yet implemented in uClibc! */
-
-#ifdef __USE_GNU
-/* Initialize thread attribute *ATTR with attributes corresponding to the
-   already running thread TH.  It shall be called on uninitialized ATTR
-   and destroyed with pthread_attr_destroy when no longer needed.  */
-extern int pthread_getattr_np (pthread_t __th, pthread_attr_t *__attr) __THROW;
-#endif
-#endif
-
-/* Functions for scheduling control.  */
-
-/* Set the scheduling parameters for TARGET_THREAD according to POLICY
-   and *PARAM.  */
-extern int pthread_setschedparam (pthread_t __target_thread, int __policy,
-				  const struct sched_param *__param)
-     __THROW;
-
-/* Return in *POLICY and *PARAM the scheduling parameters for TARGET_THREAD.  */
-extern int pthread_getschedparam (pthread_t __target_thread,
-				  int *__restrict __policy,
-				  struct sched_param *__restrict __param)
-     __THROW;
-
-#ifdef __USE_UNIX98
-/* Determine level of concurrency.  */
-extern int pthread_getconcurrency (void) __THROW;
-
-/* Set new concurrency level to LEVEL.  */
-extern int pthread_setconcurrency (int __level) __THROW;
-#endif
-
-#ifdef __USE_GNU
-/* Same thing, different name */
-#define pthread_yield() sched_yield()
-#endif
-
-/* Functions for mutex handling.  */
-
-/* Initialize MUTEX using attributes in *MUTEX_ATTR, or use the
-   default values if later is NULL.  */
-extern int pthread_mutex_init (pthread_mutex_t *__restrict __mutex,
-			       const pthread_mutexattr_t *__restrict
-			       __mutex_attr) __THROW;
-
-/* Destroy MUTEX.  */
-extern int pthread_mutex_destroy (pthread_mutex_t *__mutex) __THROW;
-
-/* Try to lock MUTEX.  */
-extern int pthread_mutex_trylock (pthread_mutex_t *__mutex) __THROWNL;
-
-/* Wait until lock for MUTEX becomes available and lock it.  */
-extern int pthread_mutex_lock (pthread_mutex_t *__mutex) __THROWNL;
-
-#ifdef __USE_XOPEN2K
-/* Wait until lock becomes available, or specified time passes. */
-extern int pthread_mutex_timedlock (pthread_mutex_t *__restrict __mutex,
-				    const struct timespec *__restrict
-				    __abstime) __THROWNL;
-#endif
-
-/* Unlock MUTEX.  */
-extern int pthread_mutex_unlock (pthread_mutex_t *__mutex) __THROWNL;
-
-
-/* Functions for handling mutex attributes.  */
-
-/* Initialize mutex attribute object ATTR with default attributes
-   (kind is PTHREAD_MUTEX_TIMED_NP).  */
-extern int pthread_mutexattr_init (pthread_mutexattr_t *__attr) __THROW;
-
-/* Destroy mutex attribute object ATTR.  */
-extern int pthread_mutexattr_destroy (pthread_mutexattr_t *__attr) __THROW;
-
-/* Get the process-shared flag of the mutex attribute ATTR.  */
-extern int pthread_mutexattr_getpshared (const pthread_mutexattr_t *
-					 __restrict __attr,
-					 int *__restrict __pshared) __THROW;
-
-/* Set the process-shared flag of the mutex attribute ATTR.  */
-extern int pthread_mutexattr_setpshared (pthread_mutexattr_t *__attr,
-					 int __pshared) __THROW;
-
-#ifdef __USE_UNIX98
-/* Set the mutex kind attribute in *ATTR to KIND (either PTHREAD_MUTEX_NORMAL,
-   PTHREAD_MUTEX_RECURSIVE, PTHREAD_MUTEX_ERRORCHECK, or
-   PTHREAD_MUTEX_DEFAULT).  */
-extern int pthread_mutexattr_settype (pthread_mutexattr_t *__attr, int __kind)
-     __THROW;
-
-/* Return in *KIND the mutex kind attribute in *ATTR.  */
-extern int pthread_mutexattr_gettype (const pthread_mutexattr_t *__restrict
-				      __attr, int *__restrict __kind) __THROW;
-#endif
-
-
-/* Functions for handling conditional variables.  */
-
-/* Initialize condition variable COND using attributes ATTR, or use
-   the default values if later is NULL.  */
-extern int pthread_cond_init (pthread_cond_t *__restrict __cond,
-			      const pthread_condattr_t *__restrict
-			      __cond_attr) __THROW;
-libpthread_hidden_proto(pthread_cond_init)
-
-/* Destroy condition variable COND.  */
-extern int pthread_cond_destroy (pthread_cond_t *__cond) __THROW;
-libpthread_hidden_proto(pthread_cond_destroy)
-
-/* Wake up one thread waiting for condition variable COND.  */
-extern int pthread_cond_signal (pthread_cond_t *__cond) __THROWNL;
-libpthread_hidden_proto(pthread_cond_signal)
-
-/* Wake up all threads waiting for condition variables COND.  */
-extern int pthread_cond_broadcast (pthread_cond_t *__cond) __THROWNL;
-libpthread_hidden_proto(pthread_cond_broadcast)
-
-/* Wait for condition variable COND to be signaled or broadcast.
-   MUTEX is assumed to be locked before.  */
-extern int pthread_cond_wait (pthread_cond_t *__restrict __cond,
-			      pthread_mutex_t *__restrict __mutex);
-libpthread_hidden_proto(pthread_cond_wait)
-
-/* Wait for condition variable COND to be signaled or broadcast until
-   ABSTIME.  MUTEX is assumed to be locked before.  ABSTIME is an
-   absolute time specification; zero is the beginning of the epoch
-   (00:00:00 GMT, January 1, 1970).  */
-extern int pthread_cond_timedwait (pthread_cond_t *__restrict __cond,
-				   pthread_mutex_t *__restrict __mutex,
-				   const struct timespec *__restrict
-				   __abstime);
-libpthread_hidden_proto(pthread_cond_timedwait)
-
-/* Functions for handling condition variable attributes.  */
-
-/* Initialize condition variable attribute ATTR.  */
-extern int pthread_condattr_init (pthread_condattr_t *__attr) __THROW;
-libpthread_hidden_proto(pthread_condattr_init)
-
-/* Destroy condition variable attribute ATTR.  */
-extern int pthread_condattr_destroy (pthread_condattr_t *__attr) __THROW;
-libpthread_hidden_proto(pthread_condattr_destroy)
-
-/* Get the process-shared flag of the condition variable attribute ATTR.  */
-extern int pthread_condattr_getpshared (const pthread_condattr_t *
-					__restrict __attr,
-					int *__restrict __pshared) __THROW;
-
-/* Set the process-shared flag of the condition variable attribute ATTR.  */
-extern int pthread_condattr_setpshared (pthread_condattr_t *__attr,
-					int __pshared) __THROW;
-
-
-#if defined __USE_UNIX98 || defined __USE_XOPEN2K
-/* Functions for handling read-write locks.  */
-
-/* Initialize read-write lock RWLOCK using attributes ATTR, or use
-   the default values if later is NULL.  */
-extern int pthread_rwlock_init (pthread_rwlock_t *__restrict __rwlock,
-				const pthread_rwlockattr_t *__restrict
-				__attr) __THROW;
-
-/* Destroy read-write lock RWLOCK.  */
-extern int pthread_rwlock_destroy (pthread_rwlock_t *__rwlock) __THROW;
-
-/* Acquire read lock for RWLOCK.  */
-extern int pthread_rwlock_rdlock (pthread_rwlock_t *__rwlock) __THROWNL;
-
-/* Try to acquire read lock for RWLOCK.  */
-extern int pthread_rwlock_tryrdlock (pthread_rwlock_t *__rwlock) __THROWNL;
-
-# ifdef __USE_XOPEN2K
-/* Try to acquire read lock for RWLOCK or return after specfied time.  */
-extern int pthread_rwlock_timedrdlock (pthread_rwlock_t *__restrict __rwlock,
-				       const struct timespec *__restrict
-				       __abstime) __THROWNL;
-# endif
-
-/* Acquire write lock for RWLOCK.  */
-extern int pthread_rwlock_wrlock (pthread_rwlock_t *__rwlock) __THROWNL;
-
-/* Try to acquire write lock for RWLOCK.  */
-extern int pthread_rwlock_trywrlock (pthread_rwlock_t *__rwlock) __THROWNL;
-
-# ifdef __USE_XOPEN2K
-/* Try to acquire write lock for RWLOCK or return after specfied time.  */
-extern int pthread_rwlock_timedwrlock (pthread_rwlock_t *__restrict __rwlock,
-				       const struct timespec *__restrict
-				       __abstime) __THROWNL;
-# endif
-
-/* Unlock RWLOCK.  */
-extern int pthread_rwlock_unlock (pthread_rwlock_t *__rwlock) __THROWNL;
-
-
-/* Functions for handling read-write lock attributes.  */
-
-/* Initialize attribute object ATTR with default values.  */
-extern int pthread_rwlockattr_init (pthread_rwlockattr_t *__attr) __THROW;
-
-/* Destroy attribute object ATTR.  */
-extern int pthread_rwlockattr_destroy (pthread_rwlockattr_t *__attr) __THROW;
-
-/* Return current setting of process-shared attribute of ATTR in PSHARED.  */
-extern int pthread_rwlockattr_getpshared (const pthread_rwlockattr_t *
-					  __restrict __attr,
-					  int *__restrict __pshared) __THROW;
-
-/* Set process-shared attribute of ATTR to PSHARED.  */
-extern int pthread_rwlockattr_setpshared (pthread_rwlockattr_t *__attr,
-					  int __pshared) __THROW;
-
-/* Return current setting of reader/writer preference.  */
-extern int pthread_rwlockattr_getkind_np (const pthread_rwlockattr_t *__attr,
-					  int *__pref) __THROW;
-
-/* Set reader/write preference.  */
-extern int pthread_rwlockattr_setkind_np (pthread_rwlockattr_t *__attr,
-					  int __pref) __THROW;
-#endif
-
-#if 0
-/* Not yet implemented in uClibc! */
-
-#ifdef __USE_XOPEN2K
-/* The IEEE Std. 1003.1j-2000 introduces functions to implement
-   spinlocks.  */
-
-/* Initialize the spinlock LOCK.  If PSHARED is nonzero the spinlock can
-   be shared between different processes.  */
-extern int pthread_spin_init (pthread_spinlock_t *__lock, int __pshared)
-     __THROW;
-
-/* Destroy the spinlock LOCK.  */
-extern int pthread_spin_destroy (pthread_spinlock_t *__lock) __THROW;
-
-/* Wait until spinlock LOCK is retrieved.  */
-extern int pthread_spin_lock (pthread_spinlock_t *__lock) __THROWNL;
-
-/* Try to lock spinlock LOCK.  */
-extern int pthread_spin_trylock (pthread_spinlock_t *__lock) __THROWNL;
-
-/* Release spinlock LOCK.  */
-extern int pthread_spin_unlock (pthread_spinlock_t *__lock) __THROWNL;
-
-
-/* Barriers are a also a new feature in 1003.1j-2000. */
-
-extern int pthread_barrier_init (pthread_barrier_t *__restrict __barrier,
-				 const pthread_barrierattr_t *__restrict
-				 __attr, unsigned int __count) __THROW;
-
-extern int pthread_barrier_destroy (pthread_barrier_t *__barrier) __THROW;
-
-extern int pthread_barrierattr_init (pthread_barrierattr_t *__attr) __THROW;
-
-extern int pthread_barrierattr_destroy (pthread_barrierattr_t *__attr) __THROW;
-
-extern int pthread_barrierattr_getpshared (const pthread_barrierattr_t *
-					   __restrict __attr,
-					   int *__restrict __pshared) __THROW;
-
-extern int pthread_barrierattr_setpshared (pthread_barrierattr_t *__attr,
-					   int __pshared) __THROW;
-
-extern int pthread_barrier_wait (pthread_barrier_t *__barrier) __THROWNL;
-#endif
-#endif
-
-
-/* Functions for handling thread-specific data.  */
-
-/* Create a key value identifying a location in the thread-specific
-   data area.  Each thread maintains a distinct thread-specific data
-   area.  DESTR_FUNCTION, if non-NULL, is called with the value
-   associated to that key when the key is destroyed.
-   DESTR_FUNCTION is not called if the value associated is NULL when
-   the key is destroyed.  */
-extern int pthread_key_create (pthread_key_t *__key,
-			       void (*__destr_function) (void *)) __THROW;
-
-/* Destroy KEY.  */
-extern int pthread_key_delete (pthread_key_t __key) __THROW;
-
-/* Store POINTER in the thread-specific data slot identified by KEY. */
-extern int pthread_setspecific (pthread_key_t __key,
-				const void *__pointer) __THROW;
-
-/* Return current value of the thread-specific data slot identified by KEY.  */
-extern void *pthread_getspecific (pthread_key_t __key) __THROW;
-
-
-/* Functions for handling initialization.  */
-
-/* Guarantee that the initialization function INIT_ROUTINE will be called
-   only once, even if pthread_once is executed several times with the
-   same ONCE_CONTROL argument. ONCE_CONTROL must point to a static or
-   extern variable initialized to PTHREAD_ONCE_INIT.
-
-   The initialization functions might throw exception which is why
-   this function is not marked with __THROW.  */
-extern int pthread_once (pthread_once_t *__once_control,
-			 void (*__init_routine) (void));
-
-
-/* Functions for handling cancellation.  */
-
-/* Set cancelability state of current thread to STATE, returning old
-   state in *OLDSTATE if OLDSTATE is not NULL.  */
-extern int pthread_setcancelstate (int __state, int *__oldstate);
-
-/* Set cancellation state of current thread to TYPE, returning the old
-   type in *OLDTYPE if OLDTYPE is not NULL.  */
-extern int pthread_setcanceltype (int __type, int *__oldtype);
-
-/* Cancel THREAD immediately or at the next possibility.  */
-extern int pthread_cancel (pthread_t __cancelthread);
-
-/* Test for pending cancellation for the current thread and terminate
-   the thread as per pthread_exit(PTHREAD_CANCELED) if it has been
-   cancelled.  */
-extern void pthread_testcancel (void);
-
-
-/* Install a cleanup handler: ROUTINE will be called with arguments ARG
-   when the thread is cancelled or calls pthread_exit.  ROUTINE will also
-   be called with arguments ARG when the matching pthread_cleanup_pop
-   is executed with non-zero EXECUTE argument.
-   pthread_cleanup_push and pthread_cleanup_pop are macros and must always
-   be used in matching pairs at the same nesting level of braces. */
-
-#define pthread_cleanup_push(routine,arg) \
-  { struct _pthread_cleanup_buffer _buffer;				      \
-    _pthread_cleanup_push (&_buffer, (routine), (arg));
-
-extern void _pthread_cleanup_push (struct _pthread_cleanup_buffer *__buffer,
-				   void (*__routine) (void *),
-				   void *__arg) __THROW;
-
-/* Remove a cleanup handler installed by the matching pthread_cleanup_push.
-   If EXECUTE is non-zero, the handler function is called. */
-
-#define pthread_cleanup_pop(execute) \
-    _pthread_cleanup_pop (&_buffer, (execute)); }
-
-extern void _pthread_cleanup_pop (struct _pthread_cleanup_buffer *__buffer,
-				  int __execute) __THROW;
-
-/* Install a cleanup handler as pthread_cleanup_push does, but also
-   saves the current cancellation type and set it to deferred cancellation.  */
-
-#ifdef __USE_GNU
-# define pthread_cleanup_push_defer_np(routine,arg) \
-  { struct _pthread_cleanup_buffer _buffer;				      \
-    _pthread_cleanup_push_defer (&_buffer, (routine), (arg));
-
-extern void _pthread_cleanup_push_defer (struct _pthread_cleanup_buffer *__buffer,
-					 void (*__routine) (void *),
-					 void *__arg) __THROW;
-extern void __pthread_cleanup_push_defer (struct _pthread_cleanup_buffer *__buffer,
-					  void (*__routine) (void *),
-					  void *__arg) __THROW;
-
-/* Remove a cleanup handler as pthread_cleanup_pop does, but also
-   restores the cancellation type that was in effect when the matching
-   pthread_cleanup_push_defer was called.  */
-
-# define pthread_cleanup_pop_restore_np(execute) \
-  _pthread_cleanup_pop_restore (&_buffer, (execute)); }
-
-extern void _pthread_cleanup_pop_restore (struct _pthread_cleanup_buffer *__buffer,
-					  int __execute) __THROW;
-extern void __pthread_cleanup_pop_restore (struct _pthread_cleanup_buffer *__buffer,
-					   int __execute) __THROW;
-#endif
-
-
-#if 0
-/* Not yet implemented in uClibc! */
-
-#ifdef __USE_XOPEN2K
-/* Get ID of CPU-time clock for thread THREAD_ID.  */
-extern int pthread_getcpuclockid (pthread_t __thread_id,
-				  clockid_t *__clock_id) __THROW;
-#endif
-#endif
-
-
-/* Functions for handling signals.  */
-#include <bits/sigthread.h>
-
-
-/* Functions for handling process creation and process execution.  */
-
-/* Install handlers to be called when a new process is created with FORK.
-   The PREPARE handler is called in the parent process just before performing
-   FORK. The PARENT handler is called in the parent process just after FORK.
-   The CHILD handler is called in the child process.  Each of the three
-   handlers can be NULL, meaning that no handler needs to be called at that
-   point.
-   PTHREAD_ATFORK can be called several times, in which case the PREPARE
-   handlers are called in LIFO order (last added with PTHREAD_ATFORK,
-   first called before FORK), and the PARENT and CHILD handlers are called
-   in FIFO (first added, first called).  */
-
-extern int pthread_atfork (void (*__prepare) (void),
-			   void (*__parent) (void),
-			   void (*__child) (void)) __THROW;
-
-/* Terminate all threads in the program except the calling process.
-   Should be called just before invoking one of the exec*() functions.  */
-
-extern void pthread_kill_other_threads_np (void) __THROW;
-
-__END_DECLS
-
-#endif	/* pthread.h */
diff --git a/libpthread/linuxthreads.old/sysdeps/pthread/tls.h b/libpthread/linuxthreads.old/sysdeps/pthread/tls.h
deleted file mode 100644
index 2068f1e77..000000000
--- a/libpthread/linuxthreads.old/sysdeps/pthread/tls.h
+++ /dev/null
@@ -1,80 +0,0 @@
-/* Definition for thread-local data handling.  Generic version.
-   Copyright (C) 2002 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, see
-   <http://www.gnu.org/licenses/>.  */
-
-/* By default no TLS support is available.  This is signaled by the
-   absence of the symbol USE_TLS.  */
-#undef USE_TLS
-
-
-/* An architecture-specific version of this file has to defined a
-   number of symbols:
-
-     TLS_TCB_AT_TP  or  TLS_DTV_AT_TP
-
-     The presence of one of these symbols signals which variant of
-     the TLS ABI is used.  There are in the moment two variants
-     available:
-
-     * the thread pointer points to a thread control block
-
-     * the thread pointer points to the dynamic thread vector
-
-
-     TLS_TCB_SIZE
-
-     This is the size of the thread control block structure.  How
-     this is actually defined depends on the ABI.  The thread control
-     block could be internal descriptor of the thread library or
-     just a data structure which allows finding the DTV.
-
-     TLS_INIT_TCB_SIZE
-
-     Similarly, but this value is only used at startup and in the
-     dynamic linker itself.  There are no threads in use at that time.
-
-
-     TLS_TCB_ALIGN
-
-     Alignment requirements for the TCB structure.
-
-     TLS_INIT_TCB_ALIGN
-
-     Similarly, but for the structure used at startup time.
-
-
-     INSTALL_DTV(tcb, init_dtv)
-
-     This macro must install the given initial DTV into the thread control
-     block TCB.  The normal runtime functionality must then be able to
-     use the value.
-
-
-     TLS_INIT_TP(tcb, firstcall)
-
-     This macro must initialize the thread pointer to enable normal TLS
-     operation.  The first parameter is a pointer to the thread control
-     block.  The second parameter specifies whether this is the first
-     call for the TCB.  ld.so calls this macro more than once.
-
-
-     THREAD_DTV()
-
-     This macro returns the address of the DTV of the current thread.
-     This normally is done using the the thread register which points
-     to the dtv or the TCB (from which the DTV can found).
-  */