Update from version 2.1.3 to 2.2.3 of LinuxThreads.

6 files changed, 2390 insertions, 429 deletions

diff --git a/devel/linuxthreads/files/freebsd-compat.h b/devel/linuxthreads/files/freebsd-compat.h
index 6e1c7b89c747..83041c3dfcff 100644
--- a/devel/linuxthreads/files/freebsd-compat.h
+++ b/devel/linuxthreads/files/freebsd-compat.h
@@ -6,14 +6,57 @@
 #include <sys/time.h>
 
 
+#if __FreeBSD__ >= 5
+#define __libc_accept __sys_accept
+#define __libc_close __sys_close
+#define __libc_connect __sys_connect
+#define __libc_fcntl __sys_fcntl
+#define __libc_fork __sys_fork
+#define __libc_fsync __sys_fsync
+#define __libc_nanosleep __sys_nanosleep
+#define __libc_open __sys_open
+#define __libc_read __sys_read
+#define __libc_waitpid __waitpid
+#define __libc_write __sys_write
+#define __libc_longjmp __longjmp
+#define __libc_siglongjmp __siglongjmp
+#define __libc_msync __sys_msync
+#define __libc_recvfrom __sys_recvfrom
+#define __libc_recvmsg __sys_recvmsg
+#define __libc_sendmsg __sys_sendmsg
+#define __libc_sendto __sys_sendto
+#define __libc_sigaction __sys_sigaction
+#define __libc_poll __sys_poll
+#define __libc_getpid __sys_getpid
+#else
+#define __libc_accept _accept
 #define __libc_close _close
+#define __libc_connect _connect
+#define __libc_fcntl _fcntl
+#define __libc_fork _fork
+#define __libc_fsync _fsync
 #define __libc_nanosleep _nanosleep
+#define __libc_open _open
 #define __libc_read _read
-#define __libc_waitpid waitpid
+#define __libc_waitpid __waitpid
 #define __libc_write _write
 #define __libc_longjmp __longjmp
 #define __libc_siglongjmp __siglongjmp
-#define __libc_fork _fork
+#define __libc_msync _msync
+#define __libc_recvfrom _recvfrom
+#define __libc_recvmsg _recvmsg
+#define __libc_sendmsg _sendmsg
+#define __libc_sendto _sendto
+#define __libc_sigaction _sigaction
+#define __libc_poll _poll
+#define __libc_getpid _getpid
+#endif
+#define __libc_wait __wait
+#define __libc_system __system
+#define __getpid __libc_getpid
+#define __poll __libc_poll
+#define __libc_tcdrain __tcdrain
+#define __libc_pause __pause
 #define __libc_current_sigrtmin current_sigrtmin
 #define __libc_current_sigrtmax current_sigrtmax
 #define __libc_allocate_rtsig allocate_rtsig
@@ -25,18 +68,55 @@
 #define __sched_getscheduler sched_getscheduler
 #define __sched_getparam sched_getparam
 #define __gettimeofday _gettimeofday
-#define __poll _poll
-#define __getpid _getpid
 #define __jmp_buf jmp_buf
-#define __sigaction _sigaction
 #define _h_errno h_errno
 #define __ptr_t void *
 #define __pid_t pid_t
 
+ssize_t __libc_write(int, const void *, size_t);
+ssize_t __libc_read(int, void *, size_t);
+pid_t   __libc_waitpid(pid_t wpid, int *status, int options);
+int	__libc_poll(struct pollfd *_pfd, unsigned int _nfsd, int _timeout);
+pid_t	__libc_getpid(void);
+pid_t	__libc_waitpid(pid_t, int *, int);
+int	__libc_sigaction(int, const struct sigaction *, struct sigaction *);
+int	__libc_fcntl(int, int, ...);
+int	__libc_fsync(int);
+int     __libc_msync(void *, size_t, int);
+int     __libc_open(const char *, int, ...);
+int     __libc_pause(void);
+ssize_t __libc_pwrite(int, const void *, size_t, off_t);
+ssize_t __libc_pread(int, void *, size_t, off_t);
+int     __libc_tcdrain(int);
+pid_t   __libc_wait(int *);
+int     __libc_system(const char *);
+int     __libc_accept(int s, struct sockaddr *addr, socklen_t *addrlen);
+int	__libc_connect(int, const struct sockaddr *, socklen_t);
+ssize_t __libc_recvfrom(int, void *, size_t, int, struct sockaddr *,
+			socklen_t *);
+ssize_t __libc_recvmsg(int, struct msghdr *, int);
+ssize_t __libc_sendmsg(int, const struct msghdr *, int);
+ssize_t __libc_sendto(int, const void *,
+		      size_t, int, const struct sockaddr *, socklen_t);
+
 #ifndef __P
 #   define __P(args)	args
 #endif
 
+#ifndef __THROW
+#define __THROW
+#endif
+
+#ifndef __restrict
+#define __restrict
+#endif
+
+#define SHLIB_COMPAT(lib, old, new) 0
+
+#define versioned_symbol(libname, realname, aliasname, libver) __strong_reference(realname,aliasname)
+
+#define link_warning(symbol, warning) __warn_references(symbol, warning);
+
 #ifndef __PMT
 #  define __PMT(args)	args
 #endif
@@ -49,7 +129,7 @@
 
 #define ENOTSUP EOPNOTSUPP
 
-#define __builtin_expect(x,y) (x) == (y)
+#define __builtin_expect(x,y) (x)
 #define internal_function
 
 
diff --git a/devel/linuxthreads/files/gethostby_r.c b/devel/linuxthreads/files/gethostby_r.c
index 11ee9cd7ff18..c5c88355ffc1 100644
--- a/devel/linuxthreads/files/gethostby_r.c
+++ b/devel/linuxthreads/files/gethostby_r.c
@@ -105,6 +105,7 @@ convert (struct hostent *host, struct hostent *result,
   return 0;
 }
 
+#if __FreeBSD__ < 5
 struct hostent *
 gethostbyaddr_r (const char *addr, int length, int type,
        struct hostent *result, char *buffer, int buflen,
@@ -124,6 +125,7 @@ gethostbyaddr_r (const char *addr, int length, int type,
   pthread_mutex_unlock (&gethostby_mutex);
   return result;
 }
+#endif
 
 struct hostent *
 gethostbyname_r (const char *name,
diff --git a/devel/linuxthreads/files/libc_thread.c b/devel/linuxthreads/files/libc_thread.c
index 0978796d952c..b58de1990a91 100644
--- a/devel/linuxthreads/files/libc_thread.c
+++ b/devel/linuxthreads/files/libc_thread.c
@@ -68,38 +68,6 @@ extern int __isthreaded;
 int _posix_priority_scheduling;
 #endif
 
-#if defined(NEWLIBC)
-/* The following are needed if we're going to get thread safe behavior
- * in the time functions in lib/libc/stdtime/localtime.c
- */
-#if defined(COMPILING_UTHREADS)
-static struct pthread_mutex	_lcl_mutexd = PTHREAD_MUTEX_STATIC_INITIALIZER;
-static struct pthread_mutex	_gmt_mutexd = PTHREAD_MUTEX_STATIC_INITIALIZER;
-static struct pthread_mutex	_localtime_mutexd = PTHREAD_MUTEX_STATIC_INITIALIZER;
-static struct pthread_mutex	_gmtime_mutexd = PTHREAD_MUTEX_STATIC_INITIALIZER;
-static pthread_mutex_t		_lcl_mutex   = &_lcl_mutexd;
-static pthread_mutex_t		_gmt_mutex   = &_gmt_mutexd;
-static pthread_mutex_t		_localtime_mutex = &_localtime_mutexd;
-static pthread_mutex_t		_gmtime_mutex = &_gmtime_mutexd;
-#endif
-#if defined(LINUXTHREADS)
-static pthread_mutex_t	_lcl_mutex	= PTHREAD_MUTEX_INITIALIZER;
-static pthread_mutex_t	_gmt_mutex	= PTHREAD_MUTEX_INITIALIZER;
-static pthread_mutex_t	_localtime_mutex = PTHREAD_MUTEX_INITIALIZER;
-static pthread_mutex_t	_gmtime_mutex	= PTHREAD_MUTEX_INITIALIZER;
-#else
-/* Customize this based on your mutex declarations */
-static pthread_mutex_t	_lcl_mutex	= PTHREAD_MUTEX_INITIALIZER;
-static pthread_mutex_t	_gmt_mutex	= PTHREAD_MUTEX_INITIALIZER;
-static pthread_mutex_t	_localtime_mutex = PTHREAD_MUTEX_INITIALIZER;
-static pthread_mutex_t	_gmtime_mutex	= PTHREAD_MUTEX_INITIALIZER;
-#endif
-extern pthread_mutex_t	*lcl_mutex;
-extern pthread_mutex_t	*gmt_mutex;
-extern pthread_mutex_t	*localtime_mutex;
-extern pthread_mutex_t	*gmtime_mutex;
-#endif
-
 void *lock_create (void *context);
 void rlock_acquire (void *lock);
 void wlock_acquire (void *lock);
@@ -127,13 +95,6 @@ static void _pthread_initialize(void)
 	/* This turns on thread safe behaviour in libc when we link with it */
 	__isthreaded = 1;
 
-#if defined(NEWLIBC)
-	/* Set up pointers for lib/libc/stdtime/localtime.c */
-	lcl_mutex       = &_lcl_mutex;
-	gmt_mutex       = &_gmt_mutex;
-	localtime_mutex = &_localtime_mutex;
-	gmtime_mutex    = &_gmtime_mutex;
-#endif
 }
 
 void _spinlock (int * spinlock)
diff --git a/devel/linuxthreads/files/localtime.c b/devel/linuxthreads/files/localtime.c
new file mode 100644
index 000000000000..81fb3740dfbb
--- /dev/null
+++ b/devel/linuxthreads/files/localtime.c
@@ -0,0 +1,1739 @@
+/*
+** This file is in the public domain, so clarified as of
+** June 5, 1996 by Arthur David Olson (arthur_david_olson@nih.gov).
+**
+** $FreeBSD: /tmp/pcvs/ports/devel/linuxthreads/files/localtime.c,v 1.1 2001-06-14 01:34:18 tegge Exp $
+*/
+
+#ifndef lint
+#ifndef NOID
+static char	elsieid[] __attribute__ ((unused)) = "@(#)localtime.c	7.57";
+#endif /* !defined NOID */
+#endif /* !defined lint */
+
+/*
+** Leap second handling from Bradley White (bww@k.gp.cs.cmu.edu).
+** POSIX-style TZ environment variable handling from Guy Harris
+** (guy@auspex.com).
+*/
+
+/*LINTLIBRARY*/
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <pthread.h>
+#include "private.h"
+
+#include "tzfile.h"
+
+#define __isthreaded 1
+#define	_MUTEX_LOCK(x)		if (__isthreaded) pthread_mutex_lock(x)
+#define	_MUTEX_UNLOCK(x)	if (__isthreaded) pthread_mutex_unlock(x)
+
+/*
+** SunOS 4.1.1 headers lack O_BINARY.
+*/
+
+#ifdef O_BINARY
+#define OPEN_MODE	(O_RDONLY | O_BINARY)
+#endif /* defined O_BINARY */
+#ifndef O_BINARY
+#define OPEN_MODE	O_RDONLY
+#endif /* !defined O_BINARY */
+
+#ifndef WILDABBR
+/*
+** Someone might make incorrect use of a time zone abbreviation:
+**	1.	They might reference tzname[0] before calling tzset (explicitly
+**		or implicitly).
+**	2.	They might reference tzname[1] before calling tzset (explicitly
+**		or implicitly).
+**	3.	They might reference tzname[1] after setting to a time zone
+**		in which Daylight Saving Time is never observed.
+**	4.	They might reference tzname[0] after setting to a time zone
+**		in which Standard Time is never observed.
+**	5.	They might reference tm.TM_ZONE after calling offtime.
+** What's best to do in the above cases is open to debate;
+** for now, we just set things up so that in any of the five cases
+** WILDABBR is used.  Another possibility:  initialize tzname[0] to the
+** string "tzname[0] used before set", and similarly for the other cases.
+** And another:  initialize tzname[0] to "ERA", with an explanation in the
+** manual page of what this "time zone abbreviation" means (doing this so
+** that tzname[0] has the "normal" length of three characters).
+*/
+#define WILDABBR	"   "
+#endif /* !defined WILDABBR */
+
+static char		wildabbr[] = "WILDABBR";
+
+static const char	gmt[] = "GMT";
+
+struct ttinfo {				/* time type information */
+	long		tt_gmtoff;	/* GMT offset in seconds */
+	int		tt_isdst;	/* used to set tm_isdst */
+	int		tt_abbrind;	/* abbreviation list index */
+	int		tt_ttisstd;	/* TRUE if transition is std time */
+	int		tt_ttisgmt;	/* TRUE if transition is GMT */
+};
+
+struct lsinfo {				/* leap second information */
+	time_t		ls_trans;	/* transition time */
+	long		ls_corr;	/* correction to apply */
+};
+
+#define BIGGEST(a, b)	(((a) > (b)) ? (a) : (b))
+
+#ifdef TZNAME_MAX
+#define MY_TZNAME_MAX	TZNAME_MAX
+#endif /* defined TZNAME_MAX */
+#ifndef TZNAME_MAX
+#define MY_TZNAME_MAX	255
+#endif /* !defined TZNAME_MAX */
+
+struct state {
+	int		leapcnt;
+	int		timecnt;
+	int		typecnt;
+	int		charcnt;
+	time_t		ats[TZ_MAX_TIMES];
+	unsigned char	types[TZ_MAX_TIMES];
+	struct ttinfo	ttis[TZ_MAX_TYPES];
+	char		chars[BIGGEST(BIGGEST(TZ_MAX_CHARS + 1, sizeof gmt),
+				(2 * (MY_TZNAME_MAX + 1)))];
+	struct lsinfo	lsis[TZ_MAX_LEAPS];
+};
+
+struct rule {
+	int		r_type;		/* type of rule--see below */
+	int		r_day;		/* day number of rule */
+	int		r_week;		/* week number of rule */
+	int		r_mon;		/* month number of rule */
+	long		r_time;		/* transition time of rule */
+};
+
+#define JULIAN_DAY		0	/* Jn - Julian day */
+#define DAY_OF_YEAR		1	/* n - day of year */
+#define MONTH_NTH_DAY_OF_WEEK	2	/* Mm.n.d - month, week, day of week */
+
+/*
+** Prototypes for static functions.
+*/
+
+static long		detzcode P((const char * codep));
+static const char *	getzname P((const char * strp));
+static const char *	getnum P((const char * strp, int * nump, int min,
+				int max));
+static const char *	getsecs P((const char * strp, long * secsp));
+static const char *	getoffset P((const char * strp, long * offsetp));
+static const char *	getrule P((const char * strp, struct rule * rulep));
+static void		gmtload P((struct state * sp));
+static void		gmtsub P((const time_t * timep, long offset,
+				struct tm * tmp));
+static void		localsub P((const time_t * timep, long offset,
+				struct tm * tmp));
+static int		increment_overflow P((int * number, int delta));
+static int		normalize_overflow P((int * tensptr, int * unitsptr,
+				int base));
+static void		settzname P((void));
+static time_t		time1 P((struct tm * tmp,
+				void(*funcp) P((const time_t *,
+				long, struct tm *)),
+				long offset));
+static time_t		time2 P((struct tm *tmp,
+				void(*funcp) P((const time_t *,
+				long, struct tm*)),
+				long offset, int * okayp));
+static void		timesub P((const time_t * timep, long offset,
+				const struct state * sp, struct tm * tmp));
+static int		tmcomp P((const struct tm * atmp,
+				const struct tm * btmp));
+static time_t		transtime P((time_t janfirst, int year,
+				const struct rule * rulep, long offset));
+static int		tzload P((const char * name, struct state * sp));
+static int		tzparse P((const char * name, struct state * sp,
+				int lastditch));
+
+#ifdef ALL_STATE
+static struct state *	lclptr;
+static struct state *	gmtptr;
+#endif /* defined ALL_STATE */
+
+#ifndef ALL_STATE
+static struct state	lclmem;
+static struct state	gmtmem;
+#define lclptr		(&lclmem)
+#define gmtptr		(&gmtmem)
+#endif /* State Farm */
+
+#ifndef TZ_STRLEN_MAX
+#define TZ_STRLEN_MAX 255
+#endif /* !defined TZ_STRLEN_MAX */
+
+static char		lcl_TZname[TZ_STRLEN_MAX + 1];
+static int		lcl_is_set;
+static int		gmt_is_set;
+static pthread_mutex_t	lcl_mutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_mutex_t	gmt_mutex = PTHREAD_MUTEX_INITIALIZER;
+
+char *			tzname[2] = {
+	wildabbr,
+	wildabbr
+};
+
+/*
+** Section 4.12.3 of X3.159-1989 requires that
+**	Except for the strftime function, these functions [asctime,
+**	ctime, gmtime, localtime] return values in one of two static
+**	objects: a broken-down time structure and an array of char.
+** Thanks to Paul Eggert (eggert@twinsun.com) for noting this.
+*/
+
+static struct tm	tm;
+
+#ifdef USG_COMPAT
+time_t			timezone = 0;
+int			daylight = 0;
+#endif /* defined USG_COMPAT */
+
+#ifdef ALTZONE
+time_t			altzone = 0;
+#endif /* defined ALTZONE */
+
+static long
+detzcode(codep)
+const char * const	codep;
+{
+	register long	result;
+	register int	i;
+
+	result = (codep[0] & 0x80) ? ~0L : 0L;
+	for (i = 0; i < 4; ++i)
+		result = (result << 8) | (codep[i] & 0xff);
+	return result;
+}
+
+static void
+settzname P((void))
+{
+	register struct state * 	sp = lclptr;
+	register int			i;
+
+	tzname[0] = wildabbr;
+	tzname[1] = wildabbr;
+#ifdef USG_COMPAT
+	daylight = 0;
+	timezone = 0;
+#endif /* defined USG_COMPAT */
+#ifdef ALTZONE
+	altzone = 0;
+#endif /* defined ALTZONE */
+#ifdef ALL_STATE
+	if (sp == NULL) {
+		tzname[0] = tzname[1] = gmt;
+		return;
+	}
+#endif /* defined ALL_STATE */
+	for (i = 0; i < sp->typecnt; ++i) {
+		register const struct ttinfo * const	ttisp = &sp->ttis[i];
+
+		tzname[ttisp->tt_isdst] =
+			&sp->chars[ttisp->tt_abbrind];
+#ifdef USG_COMPAT
+		if (ttisp->tt_isdst)
+			daylight = 1;
+		if (i == 0 || !ttisp->tt_isdst)
+			timezone = -(ttisp->tt_gmtoff);
+#endif /* defined USG_COMPAT */
+#ifdef ALTZONE
+		if (i == 0 || ttisp->tt_isdst)
+			altzone = -(ttisp->tt_gmtoff);
+#endif /* defined ALTZONE */
+	}
+	/*
+	** And to get the latest zone names into tzname. . .
+	*/
+	for (i = 0; i < sp->timecnt; ++i) {
+		register const struct ttinfo * const	ttisp =
+							&sp->ttis[
+								sp->types[i]];
+
+		tzname[ttisp->tt_isdst] =
+			&sp->chars[ttisp->tt_abbrind];
+	}
+}
+
+static int
+tzload(name, sp)
+register const char *		name;
+register struct state * const	sp;
+{
+	register const char *	p;
+	register int		i;
+	register int		fid;
+
+	/* XXX The following is from OpenBSD, and I'm not sure it is correct */
+	if (name != NULL && issetugid() != 0)
+		if ((name[0] == ':' && name[1] == '/') || 
+		    name[0] == '/' || strchr(name, '.'))
+			name = NULL;
+	if (name == NULL && (name = TZDEFAULT) == NULL)
+		return -1;
+	{
+		register int	doaccess;
+		struct stat	stab;
+		/*
+		** Section 4.9.1 of the C standard says that
+		** "FILENAME_MAX expands to an integral constant expression
+		** that is the size needed for an array of char large enough
+		** to hold the longest file name string that the implementation
+		** guarantees can be opened."
+		*/
+		char		fullname[FILENAME_MAX + 1];
+
+		if (name[0] == ':')
+			++name;
+		doaccess = name[0] == '/';
+		if (!doaccess) {
+			if ((p = TZDIR) == NULL)
+				return -1;
+			if ((strlen(p) + 1 + strlen(name) + 1) >= sizeof fullname)
+				return -1;
+			(void) strcpy(fullname, p);
+			(void) strcat(fullname, "/");
+			(void) strcat(fullname, name);
+			/*
+			** Set doaccess if '.' (as in "../") shows up in name.
+			*/
+			if (strchr(name, '.') != NULL)
+				doaccess = TRUE;
+			name = fullname;
+		}
+		if (doaccess && access(name, R_OK) != 0)
+		     	return -1;
+		if ((fid = open(name, OPEN_MODE)) == -1)
+			return -1;
+		if ((fstat(fid, &stab) < 0) || !S_ISREG(stab.st_mode))
+			return -1;
+	}
+	{
+		struct tzhead *	tzhp;
+		char		buf[sizeof *sp + sizeof *tzhp];
+		int		ttisstdcnt;
+		int		ttisgmtcnt;
+
+		i = read(fid, buf, sizeof buf);
+		if (close(fid) != 0)
+			return -1;
+		p = buf;
+		p += (sizeof tzhp->tzh_magic) + (sizeof tzhp->tzh_reserved);
+		ttisstdcnt = (int) detzcode(p);
+		p += 4;
+		ttisgmtcnt = (int) detzcode(p);
+		p += 4;
+		sp->leapcnt = (int) detzcode(p);
+		p += 4;
+		sp->timecnt = (int) detzcode(p);
+		p += 4;
+		sp->typecnt = (int) detzcode(p);
+		p += 4;
+		sp->charcnt = (int) detzcode(p);
+		p += 4;
+		if (sp->leapcnt < 0 || sp->leapcnt > TZ_MAX_LEAPS ||
+			sp->typecnt <= 0 || sp->typecnt > TZ_MAX_TYPES ||
+			sp->timecnt < 0 || sp->timecnt > TZ_MAX_TIMES ||
+			sp->charcnt < 0 || sp->charcnt > TZ_MAX_CHARS ||
+			(ttisstdcnt != sp->typecnt && ttisstdcnt != 0) ||
+			(ttisgmtcnt != sp->typecnt && ttisgmtcnt != 0))
+				return -1;
+		if (i - (p - buf) < sp->timecnt * 4 +	/* ats */
+			sp->timecnt +			/* types */
+			sp->typecnt * (4 + 2) +		/* ttinfos */
+			sp->charcnt +			/* chars */
+			sp->leapcnt * (4 + 4) +		/* lsinfos */
+			ttisstdcnt +			/* ttisstds */
+			ttisgmtcnt)			/* ttisgmts */
+				return -1;
+		for (i = 0; i < sp->timecnt; ++i) {
+			sp->ats[i] = detzcode(p);
+			p += 4;
+		}
+		for (i = 0; i < sp->timecnt; ++i) {
+			sp->types[i] = (unsigned char) *p++;
+			if (sp->types[i] >= sp->typecnt)
+				return -1;
+		}
+		for (i = 0; i < sp->typecnt; ++i) {
+			register struct ttinfo *	ttisp;
+
+			ttisp = &sp->ttis[i];
+			ttisp->tt_gmtoff = detzcode(p);
+			p += 4;
+			ttisp->tt_isdst = (unsigned char) *p++;
+			if (ttisp->tt_isdst != 0 && ttisp->tt_isdst != 1)
+				return -1;
+			ttisp->tt_abbrind = (unsigned char) *p++;
+			if (ttisp->tt_abbrind < 0 ||
+				ttisp->tt_abbrind > sp->charcnt)
+					return -1;
+		}
+		for (i = 0; i < sp->charcnt; ++i)
+			sp->chars[i] = *p++;
+		sp->chars[i] = '\0';	/* ensure '\0' at end */
+		for (i = 0; i < sp->leapcnt; ++i) {
+			register struct lsinfo *	lsisp;
+
+			lsisp = &sp->lsis[i];
+			lsisp->ls_trans = detzcode(p);
+			p += 4;
+			lsisp->ls_corr = detzcode(p);
+			p += 4;
+		}
+		for (i = 0; i < sp->typecnt; ++i) {
+			register struct ttinfo *	ttisp;
+
+			ttisp = &sp->ttis[i];
+			if (ttisstdcnt == 0)
+				ttisp->tt_ttisstd = FALSE;
+			else {
+				ttisp->tt_ttisstd = *p++;
+				if (ttisp->tt_ttisstd != TRUE &&
+					ttisp->tt_ttisstd != FALSE)
+						return -1;
+			}
+		}
+		for (i = 0; i < sp->typecnt; ++i) {
+			register struct ttinfo *	ttisp;
+
+			ttisp = &sp->ttis[i];
+			if (ttisgmtcnt == 0)
+				ttisp->tt_ttisgmt = FALSE;
+			else {
+				ttisp->tt_ttisgmt = *p++;
+				if (ttisp->tt_ttisgmt != TRUE &&
+					ttisp->tt_ttisgmt != FALSE)
+						return -1;
+			}
+		}
+	}
+	return 0;
+}
+
+static const int	mon_lengths[2][MONSPERYEAR] = {
+	{ 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },
+	{ 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }
+};
+
+static const int	year_lengths[2] = {
+	DAYSPERNYEAR, DAYSPERLYEAR
+};
+
+/*
+** Given a pointer into a time zone string, scan until a character that is not
+** a valid character in a zone name is found.  Return a pointer to that
+** character.
+*/
+
+static const char *
+getzname(strp)
+register const char *	strp;
+{
+	register char	c;
+
+	while ((c = *strp) != '\0' && !is_digit(c) && c != ',' && c != '-' &&
+		c != '+')
+			++strp;
+	return strp;
+}
+
+/*
+** Given a pointer into a time zone string, extract a number from that string.
+** Check that the number is within a specified range; if it is not, return
+** NULL.
+** Otherwise, return a pointer to the first character not part of the number.
+*/
+
+static const char *
+getnum(strp, nump, min, max)
+register const char *	strp;
+int * const		nump;
+const int		min;
+const int		max;
+{
+	register char	c;
+	register int	num;
+
+	if (strp == NULL || !is_digit(c = *strp))
+		return NULL;
+	num = 0;
+	do {
+		num = num * 10 + (c - '0');
+		if (num > max)
+			return NULL;	/* illegal value */
+		c = *++strp;
+	} while (is_digit(c));
+	if (num < min)
+		return NULL;		/* illegal value */
+	*nump = num;
+	return strp;
+}
+
+/*
+** Given a pointer into a time zone string, extract a number of seconds,
+** in hh[:mm[:ss]] form, from the string.
+** If any error occurs, return NULL.
+** Otherwise, return a pointer to the first character not part of the number
+** of seconds.
+*/
+
+static const char *
+getsecs(strp, secsp)
+register const char *	strp;
+long * const		secsp;
+{
+	int	num;
+
+	/*
+	** `HOURSPERDAY * DAYSPERWEEK - 1' allows quasi-Posix rules like
+	** "M10.4.6/26", which does not conform to Posix,
+	** but which specifies the equivalent of
+	** ``02:00 on the first Sunday on or after 23 Oct''.
+	*/
+	strp = getnum(strp, &num, 0, HOURSPERDAY * DAYSPERWEEK - 1);
+	if (strp == NULL)
+		return NULL;
+	*secsp = num * (long) SECSPERHOUR;
+	if (*strp == ':') {
+		++strp;
+		strp = getnum(strp, &num, 0, MINSPERHOUR - 1);
+		if (strp == NULL)
+			return NULL;
+		*secsp += num * SECSPERMIN;
+		if (*strp == ':') {
+			++strp;
+			/* `SECSPERMIN' allows for leap seconds.  */
+			strp = getnum(strp, &num, 0, SECSPERMIN);
+			if (strp == NULL)
+				return NULL;
+			*secsp += num;
+		}
+	}
+	return strp;
+}
+
+/*
+** Given a pointer into a time zone string, extract an offset, in
+** [+-]hh[:mm[:ss]] form, from the string.
+** If any error occurs, return NULL.
+** Otherwise, return a pointer to the first character not part of the time.
+*/
+
+static const char *
+getoffset(strp, offsetp)
+register const char *	strp;
+long * const		offsetp;
+{
+	register int	neg = 0;
+
+	if (*strp == '-') {
+		neg = 1;
+		++strp;
+	} else if (*strp == '+')
+		++strp;
+	strp = getsecs(strp, offsetp);
+	if (strp == NULL)
+		return NULL;		/* illegal time */
+	if (neg)
+		*offsetp = -*offsetp;
+	return strp;
+}
+
+/*
+** Given a pointer into a time zone string, extract a rule in the form
+** date[/time].  See POSIX section 8 for the format of "date" and "time".
+** If a valid rule is not found, return NULL.
+** Otherwise, return a pointer to the first character not part of the rule.
+*/
+
+static const char *
+getrule(strp, rulep)
+const char *			strp;
+register struct rule * const	rulep;
+{
+	if (*strp == 'J') {
+		/*
+		** Julian day.
+		*/
+		rulep->r_type = JULIAN_DAY;
+		++strp;
+		strp = getnum(strp, &rulep->r_day, 1, DAYSPERNYEAR);
+	} else if (*strp == 'M') {
+		/*
+		** Month, week, day.
+		*/
+		rulep->r_type = MONTH_NTH_DAY_OF_WEEK;
+		++strp;
+		strp = getnum(strp, &rulep->r_mon, 1, MONSPERYEAR);
+		if (strp == NULL)
+			return NULL;
+		if (*strp++ != '.')
+			return NULL;
+		strp = getnum(strp, &rulep->r_week, 1, 5);
+		if (strp == NULL)
+			return NULL;
+		if (*strp++ != '.')
+			return NULL;
+		strp = getnum(strp, &rulep->r_day, 0, DAYSPERWEEK - 1);
+	} else if (is_digit(*strp)) {
+		/*
+		** Day of year.
+		*/
+		rulep->r_type = DAY_OF_YEAR;
+		strp = getnum(strp, &rulep->r_day, 0, DAYSPERLYEAR - 1);
+	} else	return NULL;		/* invalid format */
+	if (strp == NULL)
+		return NULL;
+	if (*strp == '/') {
+		/*
+		** Time specified.
+		*/
+		++strp;
+		strp = getsecs(strp, &rulep->r_time);
+	} else	rulep->r_time = 2 * SECSPERHOUR;	/* default = 2:00:00 */
+	return strp;
+}
+
+/*
+** Given the Epoch-relative time of January 1, 00:00:00 GMT, in a year, the
+** year, a rule, and the offset from GMT at the time that rule takes effect,
+** calculate the Epoch-relative time that rule takes effect.
+*/
+
+static time_t
+transtime(janfirst, year, rulep, offset)
+const time_t				janfirst;
+const int				year;
+register const struct rule * const	rulep;
+const long				offset;
+{
+	register int	leapyear;
+	register time_t	value;
+	register int	i;
+	int		d, m1, yy0, yy1, yy2, dow;
+
+	INITIALIZE(value);
+	leapyear = isleap(year);
+	switch (rulep->r_type) {
+
+	case JULIAN_DAY:
+		/*
+		** Jn - Julian day, 1 == January 1, 60 == March 1 even in leap
+		** years.
+		** In non-leap years, or if the day number is 59 or less, just
+		** add SECSPERDAY times the day number-1 to the time of
+		** January 1, midnight, to get the day.
+		*/
+		value = janfirst + (rulep->r_day - 1) * SECSPERDAY;
+		if (leapyear && rulep->r_day >= 60)
+			value += SECSPERDAY;
+		break;
+
+	case DAY_OF_YEAR:
+		/*
+		** n - day of year.
+		** Just add SECSPERDAY times the day number to the time of
+		** January 1, midnight, to get the day.
+		*/
+		value = janfirst + rulep->r_day * SECSPERDAY;
+		break;
+
+	case MONTH_NTH_DAY_OF_WEEK:
+		/*
+		** Mm.n.d - nth "dth day" of month m.
+		*/
+		value = janfirst;
+		for (i = 0; i < rulep->r_mon - 1; ++i)
+			value += mon_lengths[leapyear][i] * SECSPERDAY;
+
+		/*
+		** Use Zeller's Congruence to get day-of-week of first day of
+		** month.
+		*/
+		m1 = (rulep->r_mon + 9) % 12 + 1;
+		yy0 = (rulep->r_mon <= 2) ? (year - 1) : year;
+		yy1 = yy0 / 100;
+		yy2 = yy0 % 100;
+		dow = ((26 * m1 - 2) / 10 +
+			1 + yy2 + yy2 / 4 + yy1 / 4 - 2 * yy1) % 7;
+		if (dow < 0)
+			dow += DAYSPERWEEK;
+
+		/*
+		** "dow" is the day-of-week of the first day of the month.  Get
+		** the day-of-month (zero-origin) of the first "dow" day of the
+		** month.
+		*/
+		d = rulep->r_day - dow;
+		if (d < 0)
+			d += DAYSPERWEEK;
+		for (i = 1; i < rulep->r_week; ++i) {
+			if (d + DAYSPERWEEK >=
+				mon_lengths[leapyear][rulep->r_mon - 1])
+					break;
+			d += DAYSPERWEEK;
+		}
+
+		/*
+		** "d" is the day-of-month (zero-origin) of the day we want.
+		*/
+		value += d * SECSPERDAY;
+		break;
+	}
+
+	/*
+	** "value" is the Epoch-relative time of 00:00:00 GMT on the day in
+	** question.  To get the Epoch-relative time of the specified local
+	** time on that day, add the transition time and the current offset
+	** from GMT.
+	*/
+	return value + rulep->r_time + offset;
+}
+
+/*
+** Given a POSIX section 8-style TZ string, fill in the rule tables as
+** appropriate.
+*/
+
+static int
+tzparse(name, sp, lastditch)
+const char *			name;
+register struct state * const	sp;
+const int			lastditch;
+{
+	const char *			stdname;
+	const char *			dstname;
+	size_t				stdlen;
+	size_t				dstlen;
+	long				stdoffset;
+	long				dstoffset;
+	register time_t *		atp;
+	register unsigned char *	typep;
+	register char *			cp;
+	register int			load_result;
+
+	INITIALIZE(dstname);
+	stdname = name;
+	if (lastditch) {
+		stdlen = strlen(name);	/* length of standard zone name */
+		name += stdlen;
+		if (stdlen >= sizeof sp->chars)
+			stdlen = (sizeof sp->chars) - 1;
+		stdoffset = 0;
+	} else {
+		name = getzname(name);
+		stdlen = name - stdname;
+		if (stdlen < 3)
+			return -1;
+		if (*name == '\0')
+			return -1;	/* was "stdoffset = 0;" */
+		else {
+			name = getoffset(name, &stdoffset);
+			if (name == NULL)
+				return -1;
+		}
+	}
+	load_result = tzload(TZDEFRULES, sp);
+	if (load_result != 0)
+		sp->leapcnt = 0;		/* so, we're off a little */
+	if (*name != '\0') {
+		dstname = name;
+		name = getzname(name);
+		dstlen = name - dstname;	/* length of DST zone name */
+		if (dstlen < 3)
+			return -1;
+		if (*name != '\0' && *name != ',' && *name != ';') {
+			name = getoffset(name, &dstoffset);
+			if (name == NULL)
+				return -1;
+		} else	dstoffset = stdoffset - SECSPERHOUR;
+		if (*name == ',' || *name == ';') {
+			struct rule	start;
+			struct rule	end;
+			register int	year;
+			register time_t	janfirst;
+			time_t		starttime;
+			time_t		endtime;
+
+			++name;
+			if ((name = getrule(name, &start)) == NULL)
+				return -1;
+			if (*name++ != ',')
+				return -1;
+			if ((name = getrule(name, &end)) == NULL)
+				return -1;
+			if (*name != '\0')
+				return -1;
+			sp->typecnt = 2;	/* standard time and DST */
+			/*
+			** Two transitions per year, from EPOCH_YEAR to 2037.
+			*/
+			sp->timecnt = 2 * (2037 - EPOCH_YEAR + 1);
+			if (sp->timecnt > TZ_MAX_TIMES)
+				return -1;
+			sp->ttis[0].tt_gmtoff = -dstoffset;
+			sp->ttis[0].tt_isdst = 1;
+			sp->ttis[0].tt_abbrind = stdlen + 1;
+			sp->ttis[1].tt_gmtoff = -stdoffset;
+			sp->ttis[1].tt_isdst = 0;
+			sp->ttis[1].tt_abbrind = 0;
+			atp = sp->ats;
+			typep = sp->types;
+			janfirst = 0;
+			for (year = EPOCH_YEAR; year <= 2037; ++year) {
+				starttime = transtime(janfirst, year, &start,
+					stdoffset);
+				endtime = transtime(janfirst, year, &end,
+					dstoffset);
+				if (starttime > endtime) {
+					*atp++ = endtime;
+					*typep++ = 1;	/* DST ends */
+					*atp++ = starttime;
+					*typep++ = 0;	/* DST begins */
+				} else {
+					*atp++ = starttime;
+					*typep++ = 0;	/* DST begins */
+					*atp++ = endtime;
+					*typep++ = 1;	/* DST ends */
+				}
+				janfirst += year_lengths[isleap(year)] *
+					SECSPERDAY;
+			}
+		} else {
+			register long	theirstdoffset;
+			register long	theirdstoffset;
+			register long	theiroffset;
+			register int	isdst;
+			register int	i;
+			register int	j;
+
+			if (*name != '\0')
+				return -1;
+			if (load_result != 0)
+				return -1;
+			/*
+			** Initial values of theirstdoffset and theirdstoffset.
+			*/
+			theirstdoffset = 0;
+			for (i = 0; i < sp->timecnt; ++i) {
+				j = sp->types[i];
+				if (!sp->ttis[j].tt_isdst) {
+					theirstdoffset =
+						-sp->ttis[j].tt_gmtoff;
+					break;
+				}
+			}
+			theirdstoffset = 0;
+			for (i = 0; i < sp->timecnt; ++i) {
+				j = sp->types[i];
+				if (sp->ttis[j].tt_isdst) {
+					theirdstoffset =
+						-sp->ttis[j].tt_gmtoff;
+					break;
+				}
+			}
+			/*
+			** Initially we're assumed to be in standard time.
+			*/
+			isdst = FALSE;
+			theiroffset = theirstdoffset;
+			/*
+			** Now juggle transition times and types
+			** tracking offsets as you do.
+			*/
+			for (i = 0; i < sp->timecnt; ++i) {
+				j = sp->types[i];
+				sp->types[i] = sp->ttis[j].tt_isdst;
+				if (sp->ttis[j].tt_ttisgmt) {
+					/* No adjustment to transition time */
+				} else {
+					/*
+					** If summer time is in effect, and the
+					** transition time was not specified as
+					** standard time, add the summer time
+					** offset to the transition time;
+					** otherwise, add the standard time
+					** offset to the transition time.
+					*/
+					/*
+					** Transitions from DST to DDST
+					** will effectively disappear since
+					** POSIX provides for only one DST
+					** offset.
+					*/
+					if (isdst && !sp->ttis[j].tt_ttisstd) {
+						sp->ats[i] += dstoffset -
+							theirdstoffset;
+					} else {
+						sp->ats[i] += stdoffset -
+							theirstdoffset;
+					}
+				}
+				theiroffset = -sp->ttis[j].tt_gmtoff;
+				if (sp->ttis[j].tt_isdst)
+					theirdstoffset = theiroffset;
+				else	theirstdoffset = theiroffset;
+			}
+			/*
+			** Finally, fill in ttis.
+			** ttisstd and ttisgmt need not be handled.
+			*/
+			sp->ttis[0].tt_gmtoff = -stdoffset;
+			sp->ttis[0].tt_isdst = FALSE;
+			sp->ttis[0].tt_abbrind = 0;
+			sp->ttis[1].tt_gmtoff = -dstoffset;
+			sp->ttis[1].tt_isdst = TRUE;
+			sp->ttis[1].tt_abbrind = stdlen + 1;
+		}
+	} else {
+		dstlen = 0;
+		sp->typecnt = 1;		/* only standard time */
+		sp->timecnt = 0;
+		sp->ttis[0].tt_gmtoff = -stdoffset;
+		sp->ttis[0].tt_isdst = 0;
+		sp->ttis[0].tt_abbrind = 0;
+	}
+	sp->charcnt = stdlen + 1;
+	if (dstlen != 0)
+		sp->charcnt += dstlen + 1;
+	if (sp->charcnt > sizeof sp->chars)
+		return -1;
+	cp = sp->chars;
+	(void) strncpy(cp, stdname, stdlen);
+	cp += stdlen;
+	*cp++ = '\0';
+	if (dstlen != 0) {
+		(void) strncpy(cp, dstname, dstlen);
+		*(cp + dstlen) = '\0';
+	}
+	return 0;
+}
+
+static void
+gmtload(sp)
+struct state * const	sp;
+{
+	if (tzload(gmt, sp) != 0)
+		(void) tzparse(gmt, sp, TRUE);
+}
+
+static void
+tzsetwall_basic(void)
+{
+	if (lcl_is_set < 0)
+		return;
+	lcl_is_set = -1;
+
+#ifdef ALL_STATE
+	if (lclptr == NULL) {
+		lclptr = (struct state *) malloc(sizeof *lclptr);
+		if (lclptr == NULL) {
+			settzname();	/* all we can do */
+			return;
+		}
+	}
+#endif /* defined ALL_STATE */
+	if (tzload((char *) NULL, lclptr) != 0)
+		gmtload(lclptr);
+	settzname();
+}
+
+void
+tzsetwall P((void))
+{
+	_MUTEX_LOCK(&lcl_mutex);
+	tzsetwall_basic();
+	_MUTEX_UNLOCK(&lcl_mutex);
+}
+
+static void
+tzset_basic(void)
+{
+	register const char *	name;
+
+	name = getenv("TZ");
+	if (name == NULL) {
+		tzsetwall_basic();
+		return;
+	}
+
+	if (lcl_is_set > 0  &&  strcmp(lcl_TZname, name) == 0)
+		return;
+	lcl_is_set = (strlen(name) < sizeof(lcl_TZname));
+	if (lcl_is_set)
+		(void) strcpy(lcl_TZname, name);
+
+#ifdef ALL_STATE
+	if (lclptr == NULL) {
+		lclptr = (struct state *) malloc(sizeof *lclptr);
+		if (lclptr == NULL) {
+			settzname();	/* all we can do */
+			return;
+		}
+	}
+#endif /* defined ALL_STATE */
+	if (*name == '\0') {
+		/*
+		** User wants it fast rather than right.
+		*/
+		lclptr->leapcnt = 0;		/* so, we're off a little */
+		lclptr->timecnt = 0;
+		lclptr->ttis[0].tt_gmtoff = 0;
+		lclptr->ttis[0].tt_abbrind = 0;
+		(void) strcpy(lclptr->chars, gmt);
+	} else if (tzload(name, lclptr) != 0)
+		if (name[0] == ':' || tzparse(name, lclptr, FALSE) != 0)
+			(void) gmtload(lclptr);
+	settzname();
+}
+
+void
+tzset P((void))
+{
+	_MUTEX_LOCK(&lcl_mutex);
+	tzset_basic();
+	_MUTEX_UNLOCK(&lcl_mutex);
+}
+
+/*
+** The easy way to behave "as if no library function calls" localtime
+** is to not call it--so we drop its guts into "localsub", which can be
+** freely called.  (And no, the PANS doesn't require the above behavior--
+** but it *is* desirable.)
+**
+** The unused offset argument is for the benefit of mktime variants.
+*/
+
+/*ARGSUSED*/
+static void
+localsub(timep, offset, tmp)
+const time_t * const	timep;
+const long		offset;
+struct tm * const	tmp;
+{
+	register struct state *		sp;
+	register const struct ttinfo *	ttisp;
+	register int			i;
+	const time_t			t = *timep;
+
+	sp = lclptr;
+#ifdef ALL_STATE
+	if (sp == NULL) {
+		gmtsub(timep, offset, tmp);
+		return;
+	}
+#endif /* defined ALL_STATE */
+	if (sp->timecnt == 0 || t < sp->ats[0]) {
+		i = 0;
+		while (sp->ttis[i].tt_isdst)
+			if (++i >= sp->typecnt) {
+				i = 0;
+				break;
+			}
+	} else {
+		for (i = 1; i < sp->timecnt; ++i)
+			if (t < sp->ats[i])
+				break;
+		i = sp->types[i - 1];
+	}
+	ttisp = &sp->ttis[i];
+	/*
+	** To get (wrong) behavior that's compatible with System V Release 2.0
+	** you'd replace the statement below with
+	**	t += ttisp->tt_gmtoff;
+	**	timesub(&t, 0L, sp, tmp);
+	*/
+	timesub(&t, ttisp->tt_gmtoff, sp, tmp);
+	tmp->tm_isdst = ttisp->tt_isdst;
+	tzname[tmp->tm_isdst] = &sp->chars[ttisp->tt_abbrind];
+#ifdef TM_ZONE
+	tmp->TM_ZONE = &sp->chars[ttisp->tt_abbrind];
+#endif /* defined TM_ZONE */
+}
+
+struct tm *
+localtime_r(timep, p_tm)
+const time_t * const	timep;
+struct tm *p_tm;
+{
+	_MUTEX_LOCK(&lcl_mutex);
+	tzset_basic();
+	localsub(timep, 0L, p_tm);
+	_MUTEX_UNLOCK(&lcl_mutex);
+	return(p_tm);
+}
+
+struct tm *
+localtime(timep)
+const time_t * const	timep;
+{
+	static pthread_mutex_t localtime_mutex = PTHREAD_MUTEX_INITIALIZER;
+	static pthread_key_t localtime_key = -1;
+	struct tm *p_tm;
+
+	if (__isthreaded != 0) {
+		pthread_mutex_lock(&localtime_mutex);
+		if (localtime_key < 0) {
+			if (pthread_key_create(&localtime_key, free) < 0) {
+				pthread_mutex_unlock(&localtime_mutex);
+				return(NULL);
+			}
+		}
+		pthread_mutex_unlock(&localtime_mutex);
+		p_tm = pthread_getspecific(localtime_key);
+		if (p_tm == NULL) {
+			if ((p_tm = (struct tm *)malloc(sizeof(struct tm)))
+			    == NULL)
+				return(NULL);
+			pthread_setspecific(localtime_key, p_tm);
+		}
+		pthread_mutex_lock(&lcl_mutex);
+		tzset_basic();
+		localsub(timep, 0L, p_tm);
+		pthread_mutex_unlock(&lcl_mutex);
+		return(p_tm);
+	} else {
+		tzset_basic();
+		localsub(timep, 0L, &tm);
+		return(&tm);
+	}
+}
+
+/*
+** gmtsub is to gmtime as localsub is to localtime.
+*/
+
+static void
+gmtsub(timep, offset, tmp)
+const time_t * const	timep;
+const long		offset;
+struct tm * const	tmp;
+{
+	_MUTEX_LOCK(&gmt_mutex);
+	if (!gmt_is_set) {
+		gmt_is_set = TRUE;
+#ifdef ALL_STATE
+		gmtptr = (struct state *) malloc(sizeof *gmtptr);
+		if (gmtptr != NULL)
+#endif /* defined ALL_STATE */
+			gmtload(gmtptr);
+	}
+	_MUTEX_UNLOCK(&gmt_mutex);
+	timesub(timep, offset, gmtptr, tmp);
+#ifdef TM_ZONE
+	/*
+	** Could get fancy here and deliver something such as
+	** "GMT+xxxx" or "GMT-xxxx" if offset is non-zero,
+	** but this is no time for a treasure hunt.
+	*/
+	if (offset != 0)
+		tmp->TM_ZONE = wildabbr;
+	else {
+#ifdef ALL_STATE
+		if (gmtptr == NULL)
+			tmp->TM_ZONE = gmt;
+		else	tmp->TM_ZONE = gmtptr->chars;
+#endif /* defined ALL_STATE */
+#ifndef ALL_STATE
+		tmp->TM_ZONE = gmtptr->chars;
+#endif /* State Farm */
+	}
+#endif /* defined TM_ZONE */
+}
+
+struct tm *
+gmtime(timep)
+const time_t * const	timep;
+{
+	static pthread_mutex_t gmtime_mutex = PTHREAD_MUTEX_INITIALIZER;
+	static pthread_key_t gmtime_key = -1;
+	struct tm *p_tm;
+
+	if (__isthreaded != 0) {
+		pthread_mutex_lock(&gmtime_mutex);
+		if (gmtime_key < 0) {
+			if (pthread_key_create(&gmtime_key, free) < 0) {
+				pthread_mutex_unlock(&gmtime_mutex);
+				return(NULL);
+			}
+		}
+		pthread_mutex_unlock(&gmtime_mutex);
+		/*
+		 * Changed to follow POSIX.1 threads standard, which
+		 * is what BSD currently has.
+		 */
+		if ((p_tm = pthread_getspecific(gmtime_key)) == NULL) {
+			if ((p_tm = (struct tm *)malloc(sizeof(struct tm)))
+			    == NULL) {
+				return(NULL);
+			}
+			pthread_setspecific(gmtime_key, p_tm);
+		}
+		gmtsub(timep, 0L, p_tm);
+		return(p_tm);
+	}
+	else {
+		gmtsub(timep, 0L, &tm);
+		return(&tm);
+	}
+}
+
+struct tm *
+gmtime_r(const time_t * timep, struct tm * tm)
+{
+	gmtsub(timep, 0L, tm);
+	return(tm);
+}
+
+#ifdef STD_INSPIRED
+
+struct tm *
+offtime(timep, offset)
+const time_t * const	timep;
+const long		offset;
+{
+	gmtsub(timep, offset, &tm);
+	return &tm;
+}
+
+#endif /* defined STD_INSPIRED */
+
+static void
+timesub(timep, offset, sp, tmp)
+const time_t * const			timep;
+const long				offset;
+register const struct state * const	sp;
+register struct tm * const		tmp;
+{
+	register const struct lsinfo *	lp;
+	register long			days;
+	register long			rem;
+	register int			y;
+	register int			yleap;
+	register const int *		ip;
+	register long			corr;
+	register int			hit;
+	register int			i;
+
+	corr = 0;
+	hit = 0;
+#ifdef ALL_STATE
+	i = (sp == NULL) ? 0 : sp->leapcnt;
+#endif /* defined ALL_STATE */
+#ifndef ALL_STATE
+	i = sp->leapcnt;
+#endif /* State Farm */
+	while (--i >= 0) {
+		lp = &sp->lsis[i];
+		if (*timep >= lp->ls_trans) {
+			if (*timep == lp->ls_trans) {
+				hit = ((i == 0 && lp->ls_corr > 0) ||
+					lp->ls_corr > sp->lsis[i - 1].ls_corr);
+				if (hit)
+					while (i > 0 &&
+						sp->lsis[i].ls_trans ==
+						sp->lsis[i - 1].ls_trans + 1 &&
+						sp->lsis[i].ls_corr ==
+						sp->lsis[i - 1].ls_corr + 1) {
+							++hit;
+							--i;
+					}
+			}
+			corr = lp->ls_corr;
+			break;
+		}
+	}
+	days = *timep / SECSPERDAY;
+	rem = *timep % SECSPERDAY;
+#ifdef mc68k
+	if (*timep == 0x80000000) {
+		/*
+		** A 3B1 muffs the division on the most negative number.
+		*/
+		days = -24855;
+		rem = -11648;
+	}
+#endif /* defined mc68k */
+	rem += (offset - corr);
+	while (rem < 0) {
+		rem += SECSPERDAY;
+		--days;
+	}
+	while (rem >= SECSPERDAY) {
+		rem -= SECSPERDAY;
+		++days;
+	}
+	tmp->tm_hour = (int) (rem / SECSPERHOUR);
+	rem = rem % SECSPERHOUR;
+	tmp->tm_min = (int) (rem / SECSPERMIN);
+	/*
+	** A positive leap second requires a special
+	** representation.  This uses "... ??:59:60" et seq.
+	*/
+	tmp->tm_sec = (int) (rem % SECSPERMIN) + hit;
+	tmp->tm_wday = (int) ((EPOCH_WDAY + days) % DAYSPERWEEK);
+	if (tmp->tm_wday < 0)
+		tmp->tm_wday += DAYSPERWEEK;
+	y = EPOCH_YEAR;
+#define LEAPS_THRU_END_OF(y)	((y) / 4 - (y) / 100 + (y) / 400)
+	while (days < 0 || days >= (long) year_lengths[yleap = isleap(y)]) {
+		register int	newy;
+
+		newy = y + days / DAYSPERNYEAR;
+		if (days < 0)
+			--newy;
+		days -= (newy - y) * DAYSPERNYEAR +
+			LEAPS_THRU_END_OF(newy - 1) -
+			LEAPS_THRU_END_OF(y - 1);
+		y = newy;
+	}
+	tmp->tm_year = y - TM_YEAR_BASE;
+	tmp->tm_yday = (int) days;
+	ip = mon_lengths[yleap];
+	for (tmp->tm_mon = 0; days >= (long) ip[tmp->tm_mon]; ++(tmp->tm_mon))
+		days = days - (long) ip[tmp->tm_mon];
+	tmp->tm_mday = (int) (days + 1);
+	tmp->tm_isdst = 0;
+#ifdef TM_GMTOFF
+	tmp->TM_GMTOFF = offset;
+#endif /* defined TM_GMTOFF */
+}
+
+char *
+ctime(timep)
+const time_t * const	timep;
+{
+/*
+** Section 4.12.3.2 of X3.159-1989 requires that
+**	The ctime funciton converts the calendar time pointed to by timer
+**	to local time in the form of a string.  It is equivalent to
+**		asctime(localtime(timer))
+*/
+	return asctime(localtime(timep));
+}
+
+char *
+ctime_r(timep, buf)
+const time_t * const	timep;
+char *buf;
+{
+        struct tm tm;
+	return asctime_r(localtime_r(timep, &tm), buf);
+}
+
+/*
+** Adapted from code provided by Robert Elz, who writes:
+**	The "best" way to do mktime I think is based on an idea of Bob
+**	Kridle's (so its said...) from a long time ago.
+**	[kridle@xinet.com as of 1996-01-16.]
+**	It does a binary search of the time_t space.  Since time_t's are
+**	just 32 bits, its a max of 32 iterations (even at 64 bits it
+**	would still be very reasonable).
+*/
+
+#ifndef WRONG
+#define WRONG	(-1)
+#endif /* !defined WRONG */
+
+/*
+** Simplified normalize logic courtesy Paul Eggert (eggert@twinsun.com).
+*/
+
+static int
+increment_overflow(number, delta)
+int *	number;
+int	delta;
+{
+	int	number0;
+
+	number0 = *number;
+	*number += delta;
+	return (*number < number0) != (delta < 0);
+}
+
+static int
+normalize_overflow(tensptr, unitsptr, base)
+int * const	tensptr;
+int * const	unitsptr;
+const int	base;
+{
+	register int	tensdelta;
+
+	tensdelta = (*unitsptr >= 0) ?
+		(*unitsptr / base) :
+		(-1 - (-1 - *unitsptr) / base);
+	*unitsptr -= tensdelta * base;
+	return increment_overflow(tensptr, tensdelta);
+}
+
+static int
+tmcomp(atmp, btmp)
+register const struct tm * const atmp;
+register const struct tm * const btmp;
+{
+	register int	result;
+
+	if ((result = (atmp->tm_year - btmp->tm_year)) == 0 &&
+		(result = (atmp->tm_mon - btmp->tm_mon)) == 0 &&
+		(result = (atmp->tm_mday - btmp->tm_mday)) == 0 &&
+		(result = (atmp->tm_hour - btmp->tm_hour)) == 0 &&
+		(result = (atmp->tm_min - btmp->tm_min)) == 0)
+			result = atmp->tm_sec - btmp->tm_sec;
+	return result;
+}
+
+static time_t
+time2(tmp, funcp, offset, okayp)
+struct tm * const	tmp;
+void (* const		funcp) P((const time_t*, long, struct tm*));
+const long		offset;
+int * const		okayp;
+{
+	register const struct state *	sp;
+	register int			dir;
+	register int			bits;
+	register int			i, j ;
+	register int			saved_seconds;
+	time_t				newt;
+	time_t				t;
+	struct tm			yourtm, mytm;
+
+	*okayp = FALSE;
+	yourtm = *tmp;
+	if (normalize_overflow(&yourtm.tm_hour, &yourtm.tm_min, MINSPERHOUR))
+		return WRONG;
+	if (normalize_overflow(&yourtm.tm_mday, &yourtm.tm_hour, HOURSPERDAY))
+		return WRONG;
+	if (normalize_overflow(&yourtm.tm_year, &yourtm.tm_mon, MONSPERYEAR))
+		return WRONG;
+	/*
+	** Turn yourtm.tm_year into an actual year number for now.
+	** It is converted back to an offset from TM_YEAR_BASE later.
+	*/
+	if (increment_overflow(&yourtm.tm_year, TM_YEAR_BASE))
+		return WRONG;
+	while (yourtm.tm_mday <= 0) {
+		if (increment_overflow(&yourtm.tm_year, -1))
+			return WRONG;
+		i = yourtm.tm_year + (1 < yourtm.tm_mon);
+		yourtm.tm_mday += year_lengths[isleap(i)];
+	}
+	while (yourtm.tm_mday > DAYSPERLYEAR) {
+		i = yourtm.tm_year + (1 < yourtm.tm_mon);
+		yourtm.tm_mday -= year_lengths[isleap(i)];
+		if (increment_overflow(&yourtm.tm_year, 1))
+			return WRONG;
+	}
+	for ( ; ; ) {
+		i = mon_lengths[isleap(yourtm.tm_year)][yourtm.tm_mon];
+		if (yourtm.tm_mday <= i)
+			break;
+		yourtm.tm_mday -= i;
+		if (++yourtm.tm_mon >= MONSPERYEAR) {
+			yourtm.tm_mon = 0;
+			if (increment_overflow(&yourtm.tm_year, 1))
+				return WRONG;
+		}
+	}
+	if (increment_overflow(&yourtm.tm_year, -TM_YEAR_BASE))
+		return WRONG;
+	if (yourtm.tm_sec >= 0 && yourtm.tm_sec < SECSPERMIN)
+		saved_seconds = 0;
+	else if (yourtm.tm_year + TM_YEAR_BASE < EPOCH_YEAR) {
+		/*
+		** We can't set tm_sec to 0, because that might push the
+		** time below the minimum representable time.
+		** Set tm_sec to 59 instead.
+		** This assumes that the minimum representable time is
+		** not in the same minute that a leap second was deleted from,
+		** which is a safer assumption than using 58 would be.
+		*/
+		if (increment_overflow(&yourtm.tm_sec, 1 - SECSPERMIN))
+			return WRONG;
+		saved_seconds = yourtm.tm_sec;
+		yourtm.tm_sec = SECSPERMIN - 1;
+	} else {
+		saved_seconds = yourtm.tm_sec;
+		yourtm.tm_sec = 0;
+	}
+	/*
+	** Divide the search space in half
+	** (this works whether time_t is signed or unsigned).
+	*/
+	bits = TYPE_BIT(time_t) - 1;
+	/*
+	** If time_t is signed, then 0 is just above the median,
+	** assuming two's complement arithmetic.
+	** If time_t is unsigned, then (1 << bits) is just above the median.
+	*/
+	t = TYPE_SIGNED(time_t) ? 0 : (((time_t) 1) << bits);
+	for ( ; ; ) {
+		(*funcp)(&t, offset, &mytm);
+		dir = tmcomp(&mytm, &yourtm);
+		if (dir != 0) {
+			if (bits-- < 0)
+				return WRONG;
+			if (bits < 0)
+				--t; /* may be needed if new t is minimal */
+			else if (dir > 0)
+				t -= ((time_t) 1) << bits;
+			else	t += ((time_t) 1) << bits;
+			continue;
+		}
+		if (yourtm.tm_isdst < 0 || mytm.tm_isdst == yourtm.tm_isdst)
+			break;
+		/*
+		** Right time, wrong type.
+		** Hunt for right time, right type.
+		** It's okay to guess wrong since the guess
+		** gets checked.
+		*/
+		/*
+		** The (void *) casts are the benefit of SunOS 3.3 on Sun 2's.
+		*/
+		sp = (const struct state *)
+			(((void *) funcp == (void *) localsub) ?
+			lclptr : gmtptr);
+#ifdef ALL_STATE
+		if (sp == NULL)
+			return WRONG;
+#endif /* defined ALL_STATE */
+		for (i = sp->typecnt - 1; i >= 0; --i) {
+			if (sp->ttis[i].tt_isdst != yourtm.tm_isdst)
+				continue;
+			for (j = sp->typecnt - 1; j >= 0; --j) {
+				if (sp->ttis[j].tt_isdst == yourtm.tm_isdst)
+					continue;
+				newt = t + sp->ttis[j].tt_gmtoff -
+					sp->ttis[i].tt_gmtoff;
+				(*funcp)(&newt, offset, &mytm);
+				if (tmcomp(&mytm, &yourtm) != 0)
+					continue;
+				if (mytm.tm_isdst != yourtm.tm_isdst)
+					continue;
+				/*
+				** We have a match.
+				*/
+				t = newt;
+				goto label;
+			}
+		}
+		return WRONG;
+	}
+label:
+	newt = t + saved_seconds;
+	if ((newt < t) != (saved_seconds < 0))
+		return WRONG;
+	t = newt;
+	(*funcp)(&t, offset, tmp);
+	*okayp = TRUE;
+	return t;
+}
+
+static time_t
+time1(tmp, funcp, offset)
+struct tm * const	tmp;
+void (* const		funcp) P((const time_t *, long, struct tm *));
+const long		offset;
+{
+	register time_t			t;
+	register const struct state *	sp;
+	register int			samei, otheri;
+	int				okay;
+
+	if (tmp->tm_isdst > 1)
+		tmp->tm_isdst = 1;
+	t = time2(tmp, funcp, offset, &okay);
+#ifdef PCTS
+	/*
+	** PCTS code courtesy Grant Sullivan (grant@osf.org).
+	*/
+	if (okay)
+		return t;
+	if (tmp->tm_isdst < 0)
+		tmp->tm_isdst = 0;	/* reset to std and try again */
+#endif /* defined PCTS */
+#ifndef PCTS
+	if (okay || tmp->tm_isdst < 0)
+		return t;
+#endif /* !defined PCTS */
+	/*
+	** We're supposed to assume that somebody took a time of one type
+	** and did some math on it that yielded a "struct tm" that's bad.
+	** We try to divine the type they started from and adjust to the
+	** type they need.
+	*/
+	/*
+	** The (void *) casts are the benefit of SunOS 3.3 on Sun 2's.
+	*/
+	sp = (const struct state *) (((void *) funcp == (void *) localsub) ?
+		lclptr : gmtptr);
+#ifdef ALL_STATE
+	if (sp == NULL)
+		return WRONG;
+#endif /* defined ALL_STATE */
+	for (samei = sp->typecnt - 1; samei >= 0; --samei) {
+		if (sp->ttis[samei].tt_isdst != tmp->tm_isdst)
+			continue;
+		for (otheri = sp->typecnt - 1; otheri >= 0; --otheri) {
+			if (sp->ttis[otheri].tt_isdst == tmp->tm_isdst)
+				continue;
+			tmp->tm_sec += sp->ttis[otheri].tt_gmtoff -
+					sp->ttis[samei].tt_gmtoff;
+			tmp->tm_isdst = !tmp->tm_isdst;
+			t = time2(tmp, funcp, offset, &okay);
+			if (okay)
+				return t;
+			tmp->tm_sec -= sp->ttis[otheri].tt_gmtoff -
+					sp->ttis[samei].tt_gmtoff;
+			tmp->tm_isdst = !tmp->tm_isdst;
+		}
+	}
+	return WRONG;
+}
+
+time_t
+mktime(tmp)
+struct tm * const	tmp;
+{
+	time_t mktime_return_value;
+	_MUTEX_LOCK(&lcl_mutex);
+	tzset_basic();
+	mktime_return_value = time1(tmp, localsub, 0L);
+	_MUTEX_UNLOCK(&lcl_mutex);
+	return(mktime_return_value);
+}
+
+#ifdef STD_INSPIRED
+
+time_t
+timelocal(tmp)
+struct tm * const	tmp;
+{
+	tmp->tm_isdst = -1;	/* in case it wasn't initialized */
+	return mktime(tmp);
+}
+
+time_t
+timegm(tmp)
+struct tm * const	tmp;
+{
+	tmp->tm_isdst = 0;
+	return time1(tmp, gmtsub, 0L);
+}
+
+time_t
+timeoff(tmp, offset)
+struct tm * const	tmp;
+const long		offset;
+{
+	tmp->tm_isdst = 0;
+	return time1(tmp, gmtsub, offset);
+}
+
+#endif /* defined STD_INSPIRED */
+
+#ifdef CMUCS
+
+/*
+** The following is supplied for compatibility with
+** previous versions of the CMUCS runtime library.
+*/
+
+long
+gtime(tmp)
+struct tm * const	tmp;
+{
+	const time_t	t = mktime(tmp);
+
+	if (t == WRONG)
+		return -1;
+	return t;
+}
+
+#endif /* defined CMUCS */
+
+/*
+** XXX--is the below the right way to conditionalize??
+*/
+
+#ifdef STD_INSPIRED
+
+/*
+** IEEE Std 1003.1-1988 (POSIX) legislates that 536457599
+** shall correspond to "Wed Dec 31 23:59:59 GMT 1986", which
+** is not the case if we are accounting for leap seconds.
+** So, we provide the following conversion routines for use
+** when exchanging timestamps with POSIX conforming systems.
+*/
+
+static long
+leapcorr(timep)
+time_t *	timep;
+{
+	register struct state *		sp;
+	register struct lsinfo *	lp;
+	register int			i;
+
+	sp = lclptr;
+	i = sp->leapcnt;
+	while (--i >= 0) {
+		lp = &sp->lsis[i];
+		if (*timep >= lp->ls_trans)
+			return lp->ls_corr;
+	}
+	return 0;
+}
+
+time_t
+time2posix(t)
+time_t	t;
+{
+	tzset();
+	return t - leapcorr(&t);
+}
+
+time_t
+posix2time(t)
+time_t	t;
+{
+	time_t	x;
+	time_t	y;
+
+	tzset();
+	/*
+	** For a positive leap second hit, the result
+	** is not unique.  For a negative leap second
+	** hit, the corresponding time doesn't exist,
+	** so we return an adjacent second.
+	*/
+	x = t + leapcorr(&t);
+	y = x - leapcorr(&x);
+	if (y < t) {
+		do {
+			x++;
+			y = x - leapcorr(&x);
+		} while (y < t);
+		if (t != y)
+			return x - 1;
+	} else if (y > t) {
+		do {
+			--x;
+			y = x - leapcorr(&x);
+		} while (y > t);
+		if (t != y)
+			return x + 1;
+	}
+	return x;
+}
+
+#endif /* defined STD_INSPIRED */
diff --git a/devel/linuxthreads/files/patch-aa b/devel/linuxthreads/files/patch-aa
index 4096f66324f9..9dd4ac1ad0af 100644
--- a/devel/linuxthreads/files/patch-aa
+++ b/devel/linuxthreads/files/patch-aa
@@ -1,27 +1,24 @@
-diff -ru ../linuxthreads/Examples/Makefile ./Examples/Makefile
---- ../linuxthreads/Examples/Makefile	Wed Mar 11 13:42:23 1998
-+++ ./Examples/Makefile	Mon Feb 26 12:36:31 2001
-@@ -1,8 +1,8 @@
+diff -ru ../../work/linuxthreads-2.2.3/Examples/Makefile ./Examples/Makefile
+--- ../../work/linuxthreads-2.2.3/Examples/Makefile	Wed Mar 11 12:42:23 1998
++++ ./Examples/Makefile	Thu Jun  7 22:59:29 2001
+@@ -1,6 +1,6 @@
  CC=gcc
 -CFLAGS=-g -O -Wall -I.. -D_REENTRANT
 -LIBPTHREAD=../libpthread.a
 +CFLAGS=-g -O -Wall -I/usr/local/include/pthread/linuxthreads -D_REENTRANT
 +LIBPTHREAD=-L/usr/local/lib -llthread -llgcc_r
  
--PROGS=ex1 ex2 ex3 ex4 ex5 proxy
-+PROGS=ex1 ex2 ex3 ex4 ex5
+ PROGS=ex1 ex2 ex3 ex4 ex5 proxy
  
- all: $(PROGS)
- 
-diff -ru ../linuxthreads/Makefile ./Makefile
---- ../linuxthreads/Makefile	Wed Nov  3 01:09:36 1999
-+++ ./Makefile	Mon Feb 26 12:36:31 2001
-@@ -1,68 +1,74 @@
--# Copyright (C) 1996, 1997, 1998, 1999 Free Software Foundation, Inc.
+diff -ru ../../work/linuxthreads-2.2.3/Makefile ./Makefile
+--- ../../work/linuxthreads-2.2.3/Makefile	Wed Apr 25 21:50:59 2001
++++ ./Makefile	Thu Jun  7 23:13:52 2001
+@@ -1,128 +1,76 @@
+-# Copyright (C) 1996,1997,1998,1999,2000,2001 Free Software Foundation, Inc.
 -# This file is part of the GNU C Library.
 +LIB=lthread
-+SHLIB_MAJOR= 2
-+SHLIB_MINOR= 1
++SHLIB_MAJOR= 2.2
++SHLIB_MINOR= 3
 +
 +.if !defined(MACHINE_ARCH)
 +MACHINE_ARCH != /usr/bin/uname -m
@@ -51,6 +48,7 @@ diff -ru ../linuxthreads/Makefile ./Makefile
 +CFLAGS += -DLIBC_RCS
 +CFLAGS += -DLINUXTHREADS 
 +CFLAGS += -D__USE_UNIX98
++CFLAGS += -D__USE_XOPEN2K -D_STACK_GROWS_DOWN -DNEWLIBC -D_THREAD_SAFE
 +
 +AINC = -I${LIBSRC_BASE}/libc/${MACHINE_ARCH} -I${.CURDIR}/sysdeps/${MACHINE_ARCH}
 +
@@ -59,7 +57,8 @@ diff -ru ../linuxthreads/Makefile ./Makefile
 +	getnetby_r.c getprotoby_r.c getpw_r.c getservby_r.c join.c lclone.c \
 +	libc_calls.c libc_thread.c manager.c mutex.c pt-machine.c ptfork.c \
 +	pthread.c ptlongjmp.c rwlock.c sched.c semaphore.c signals.c \
-+	specific.c spinlock.c uthread_file.c wraputhread.c wrapsyscall.c
++	specific.c spinlock.c uthread_file.c wraputhread.c wrapsyscall.c \
++	barrier.c localtime.c
 +
 +SOBJS += libgcc_r/frame.o libgcc_r/_eh.o
 +
@@ -74,7 +73,7 @@ diff -ru ../linuxthreads/Makefile ./Makefile
 +		${PREFIX}/include/pthread/linuxthreads/semaphore.h
 +	${INSTALL} -d -o ${BINOWN} -g ${BINGRP} -m 0755 \
 +		${PREFIX}/include/pthread/linuxthreads/bits
-+.for hdr in libc-lock.h libc-tsd.h pthreadtypes.h stdio-lock.h
++.for hdr in libc-lock.h libc-tsd.h pthreadtypes.h stdio-lock.h initspin.h
 +	${INSTALL} -C -o ${BINOWN} -g ${BINGRP} -m 444 \
 +		${.CURDIR}/sysdeps/pthread/bits/$(hdr) \
 +		${PREFIX}/include/pthread/linuxthreads/bits/$(hdr)
@@ -125,43 +124,118 @@ diff -ru ../linuxthreads/Makefile ./Makefile
 -libpthread-routines := attr cancel condvar join manager mutex ptfork \
 -		       ptlongjmp pthread signals specific errno lockfile \
 -		       semaphore spinlock wrapsyscall rwlock pt-machine \
--		       oldsemaphore events
+-		       oldsemaphore events getcpuclockid pspinlock barrier \
+-		       ptclock_gettime ptclock_settime
+-
+-nodelete-yes = -Wl,--enable-new-dtags,-z,nodelete
+-initfirst-yes = -Wl,--enable-new-dtags,-z,initfirst
+-LDFLAGS-pthread.so = $(nodelete-$(have-z-nodelete)) \
+-		     $(initfirst-$(have-z-initfirst))
 -
 -vpath %.c Examples
--tests = ex1 ex2 ex3 ex4 ex5 ex6
+-
+-tst-cancel-ARGS = "$(objpfx)"
+-CFLAGS-tst-cancel.c = -fno-inline
+-
+-include ../Makeconfig
+-
+-ifeq ($(build-shared),yes)
+-before-compile := $(objpfx)crti.o
+-extra-objs = crti.o
+-
+-CFLAGS-pt-initfini.s = -g0 -fPIC -fno-inline-functions
+-endif
+-
+-librt-tests = ex10 ex11
+-tests = ex1 ex2 ex3 ex4 ex5 ex6 ex7 ex8 ex9 $(librt-tests) ex12 ex13 joinrace \
+-	tststack $(tests-nodelete-$(have-z-nodelete)) ecmutex ex14 ex15 ex16 \
+-	ex17 tst-cancel
+-
+-ifeq (yes,$(build-shared))
+-tests-nodelete-yes = unload
+-endif
 -
 -include ../Rules
 -
+-extra-B-pthread.so = -B$(common-objpfx)linuxthreads/
+-
+-znodelete-yes = -DHAVE_Z_NODELETE
 -CFLAGS-mutex.c += -D__NO_WEAK_PTHREAD_ALIASES
 -CFLAGS-specific.c += -D__NO_WEAK_PTHREAD_ALIASES
--CFLAGS-pthread.c += -D__NO_WEAK_PTHREAD_ALIASES
+-CFLAGS-pthread.c += -D__NO_WEAK_PTHREAD_ALIASES $(znodelete-$(have-z-nodelete))
 -CFLAGS-ptfork.c += -D__NO_WEAK_PTHREAD_ALIASES
--CFLAGS-cancel.c += -D__NO_WEAK_PTHREAD_ALIASES
+-CFLAGS-cancel.c += -D__NO_WEAK_PTHREAD_ALIASES -D_RPC_THREAD_SAFE_
+-CFLAGS-unload.c += -DPREFIX=\"$(objpfx)\"
 -
 -# Depend on libc.so so a DT_NEEDED is generated in the shared objects.
 -# This ensures they will load libc.so for needed symbols if loaded by
 -# a statically-linked program that hasn't already loaded it.
--$(objpfx)libpthread.so: $(common-objpfx)libc.so
+-$(objpfx)libpthread.so: $(common-objpfx)libc.so \
+-			$(common-objpfx)libc_nonshared.a
 -
 -# Make sure we link with the thread library.
 -ifeq ($(build-shared),yes)
--libpthread = $(objpfx)libpthread.so
+-$(addprefix $(objpfx),$(tests)): $(objpfx)libpthread.so
+-$(addprefix $(objpfx),$(librt-tests)): $(common-objpfx)rt/librt.so
+-$(objpfx)unload: $(common-objpfx)dlfcn/libdl.so
 -else
--libpthread = $(objpfx)libpthread.a
+-$(addprefix $(objpfx),$(tests)): $(objpfx)libpthread.a
+-$(addprefix $(objpfx),$(librt-tests)): $(common-objpfx)rt/librt.a
+-endif
+-ifeq ($(build-bounded),yes)
+-$(tests:%=$(objpfx)%-bp): $(objpfx)libpthread_b.a
+-$(librt-tests:%=$(objpfx)%-bp): $(common-objpfx)rt/librt_b.a
 -endif
 -
--$(objpfx)ex1: $(libpthread)
--$(objpfx)ex2: $(libpthread)
--$(objpfx)ex3: $(libpthread)
--$(objpfx)ex4: $(libpthread)
--$(objpfx)ex5: $(libpthread)
--$(objpfx)ex6: $(libpthread)
+-ifeq ($(build-shared),yes)
+-vpath pt-initfini.c $(full_config_sysdirs)
+-
+-$(objpfx)pt-initfini.s: pt-initfini.c
+-	$(compile.c) -S $(CFLAGS-pt-initfini.s) -finhibit-size-directive \
+-		$(patsubst -f%,-fno-%,$(exceptions)) -o $@
+-
+-# We only have one kind of startup code files.  Static binaries and
+-# shared libraries are build using the PIC version.
+-$(objpfx)crti.S: $(objpfx)pt-initfini.s
+-	sed -n -e '1,/@HEADER_ENDS/p' \
+-	       -e '/@_.*_PROLOG_BEGINS/,/@_.*_PROLOG_ENDS/p' \
+-	       -e '/@TRAILER_BEGINS/,$$p' $< > $@
+-
+-$(objpfx)defs.h: $(objpfx)pt-initfini.s
+-	sed -n -e '/@TESTS_BEGIN/,/@TESTS_END/p' $< | \
+-		$(AWK) -f ../csu/defs.awk > $@
+-
+-$(objpfx)crti.o: $(objpfx)crti.S $(objpfx)defs.h
+-	$(compile.S) -g0 $(ASFLAGS-.os) -o $@
+-
+-generated += crti.S defs.h pt-initfini.s
+-endif
+-
+-ifeq (yes,$(build-static-nss))
+-otherlibs += $(nssobjdir)/libnss_files.a $(resolvobjdir)/libnss_dns.a \
+-             $(resolvobjdir)/libresolv.a
+-endif
 +
 +.include <bsd.lib.mk>
-diff -ru ../linuxthreads/attr.c ./attr.c
---- ../linuxthreads/attr.c	Tue Oct 27 14:51:54 1998
-+++ ./attr.c	Mon Feb 26 12:36:31 2001
-@@ -27,7 +27,7 @@
+diff -ru ../../work/linuxthreads-2.2.3/attr.c ./attr.c
+--- ../../work/linuxthreads-2.2.3/attr.c	Tue Mar 27 04:52:55 2001
++++ ./attr.c	Thu Jun  7 22:59:29 2001
+@@ -18,11 +18,14 @@
+ #include <string.h>
+ #include <unistd.h>
+ #include <sys/param.h>
++#include <sys/time.h>
+ #include <sys/resource.h>
+ #include "pthread.h"
+ #include "internals.h"
++#if 0
+ #include <shlib-compat.h>
+ #include <stackinfo.h>
++#endif
+ 
+ int __pthread_attr_init_2_1(pthread_attr_t *attr)
+ {
+@@ -30,7 +33,7 @@
  
    attr->__detachstate = PTHREAD_CREATE_JOINABLE;
    attr->__schedpolicy = SCHED_OTHER;
@@ -170,9 +244,32 @@ diff -ru ../linuxthreads/attr.c ./attr.c
    attr->__inheritsched = PTHREAD_EXPLICIT_SCHED;
    attr->__scope = PTHREAD_SCOPE_SYSTEM;
    attr->__guardsize = ps;
-diff -ru ../linuxthreads/errno.c ./errno.c
---- ../linuxthreads/errno.c	Wed Aug 26 17:57:28 1998
-+++ ./errno.c	Mon Feb 26 12:53:17 2001
+diff -ru ../../work/linuxthreads-2.2.3/cancel.c ./cancel.c
+--- ../../work/linuxthreads-2.2.3/cancel.c	Thu Apr 12 23:10:53 2001
++++ ./cancel.c	Thu Jun  7 22:59:29 2001
+@@ -20,7 +20,6 @@
+ #include "internals.h"
+ #include "spinlock.h"
+ #include "restart.h"
+-#include <stackinfo.h>
+ 
+ #ifdef _STACK_GROWS_DOWN
+ # define FRAME_LEFT(frame, other) ((char *) frame >= (char *) other)
+@@ -202,9 +201,11 @@
+ 	break;
+     }
+ 
++#if 0
+   /* And the TSD which needs special help.  */
+   if (THREAD_GETMEM(self, p_libc_specific[_LIBC_TSD_KEY_RPC_VARS]) != NULL)
+     __rpc_thread_destroy ();
++#endif
+ }
+ 
+ #ifndef SHARED
+diff -ru ../../work/linuxthreads-2.2.3/errno.c ./errno.c
+--- ../../work/linuxthreads-2.2.3/errno.c	Sat Dec  4 20:31:49 1999
++++ ./errno.c	Thu Jun  7 22:59:29 2001
 @@ -19,13 +19,13 @@
  #include "pthread.h"
  #include "internals.h"
@@ -189,20 +286,29 @@ diff -ru ../linuxthreads/errno.c ./errno.c
  {
    pthread_descr self = thread_self();
    return THREAD_GETMEM (self, p_h_errnop);
-diff -ru ../linuxthreads/internals.h ./internals.h
---- ../linuxthreads/internals.h	Fri Jan 21 02:40:19 2000
-+++ ./internals.h	Mon Feb 26 12:36:31 2001
-@@ -26,8 +26,8 @@
- #include <unistd.h>
- #include <sys/types.h>
+diff -ru ../../work/linuxthreads-2.2.3/internals.h ./internals.h
+--- ../../work/linuxthreads-2.2.3/internals.h	Wed Apr 25 21:50:59 2001
++++ ./internals.h	Thu Jun  7 22:59:29 2001
+@@ -20,6 +20,7 @@
+ /* Includes */
+ 
+ #include <limits.h>
++#include <netinet/in.h>
+ #include <resolv.h>
+ #include <setjmp.h>
+ #include <signal.h>
+@@ -31,9 +32,8 @@
+ extern int __compare_and_swap (long int *p, long int oldval, long int newval);
+ 
  #include "pt-machine.h"
 +#include "freebsd-compat.h"
  #include "semaphore.h"
 -#include "../linuxthreads_db/thread_dbP.h"
+-#include <hp-timing.h>
  
  #ifndef THREAD_GETMEM
  # define THREAD_GETMEM(descr, member) descr->member
-@@ -148,14 +148,19 @@
+@@ -161,13 +161,18 @@
    char p_sigwaiting;            /* true if a sigwait() is in progress */
    struct pthread_start_args p_start_args; /* arguments for thread creation */
    void ** p_specific[PTHREAD_KEY_1STLEVEL_SIZE]; /* thread-specific data */
@@ -213,20 +319,19 @@ diff -ru ../linuxthreads/internals.h ./internals.h
    int p_userstack;		/* nonzero if the user provided the stack */
    void *p_guardaddr;		/* address of guard area or NULL */
    size_t p_guardsize;		/* size of guard area */
-   pthread_descr p_self;		/* Pointer to this structure */
    int p_nr;                     /* Index of descriptor in __pthread_handles */
-+#if (0)
-   int p_report_events;         /* Nonzero if events must be reported.  */
++#if 0
+   int p_report_events;		/* Nonzero if events must be reported.  */
    td_eventbuf_t p_eventbuf;     /* Data for event.  */
 +#endif
    struct pthread_atomic p_resume_count; /* number of times restart() was
  					   called on thread */
    char p_woken_by_cancel;       /* cancellation performed wakeup */
-@@ -267,11 +272,13 @@
+@@ -293,11 +298,13 @@
  
  extern volatile int __pthread_threads_debug;
  
-+#if (0)
++#if 0
  /* Globally enabled events.  */
  extern volatile td_thr_events_t __pthread_threads_events;
  
@@ -234,56 +339,65 @@ diff -ru ../linuxthreads/internals.h ./internals.h
  extern volatile pthread_descr __pthread_last_event;
 +#endif
  
- /* Return the handle corresponding to a thread id */
+ /* Flag which tells whether we are executing on SMP kernel. */
+ extern int __pthread_smp_kernel;
+@@ -510,8 +517,10 @@
+ extern int __pthread_spin_init (pthread_spinlock_t *__lock, int __pshared);
+ extern int __pthread_spin_destroy (pthread_spinlock_t *__lock);
+ 
++#if 0
+ extern int __pthread_clock_gettime (hp_timing_t freq, struct timespec *tp);
+ extern void __pthread_clock_settime (hp_timing_t offset);
++#endif
+ 
  
-diff -ru ../linuxthreads/join.c ./join.c
---- ../linuxthreads/join.c	Thu Jan  6 02:45:15 2000
-+++ ./join.c	Mon Feb 26 12:36:31 2001
-@@ -39,6 +39,7 @@
+ /* Global pointers to old or new suspend functions */
+diff -ru ../../work/linuxthreads-2.2.3/join.c ./join.c
+--- ../../work/linuxthreads-2.2.3/join.c	Thu Apr 12 21:02:02 2001
++++ ./join.c	Thu Jun  7 22:59:29 2001
+@@ -43,6 +43,7 @@
+   /* Store return value */
+   __pthread_lock(THREAD_GETMEM(self, p_lock), self);
    THREAD_SETMEM(self, p_retval, retval);
-   /* Say that we've terminated */
-   THREAD_SETMEM(self, p_terminated, 1);
-+#if (0)
++#if 0
    /* See whether we have to signal the death.  */
    if (THREAD_GETMEM(self, p_report_events))
      {
-@@ -60,6 +61,7 @@
+@@ -64,6 +65,7 @@
  	  __linuxthreads_death_event();
  	}
      }
 +#endif
+   /* Say that we've terminated */
+   THREAD_SETMEM(self, p_terminated, 1);
    /* See if someone is joining on us */
-   joining = THREAD_GETMEM(self, p_joining);
-   __pthread_unlock(THREAD_GETMEM(self, p_lock));
-diff -ru ../linuxthreads/manager.c ./manager.c
---- ../linuxthreads/manager.c	Fri Jan 21 02:40:19 2000
-+++ ./manager.c	Mon Feb 26 12:36:31 2001
-@@ -52,8 +52,10 @@
+diff -ru ../../work/linuxthreads-2.2.3/manager.c ./manager.c
+--- ../../work/linuxthreads-2.2.3/manager.c	Wed Apr 25 21:50:59 2001
++++ ./manager.c	Thu Jun  7 22:59:29 2001
+@@ -54,8 +54,10 @@
     (set to 1 by gdb) */
  volatile int __pthread_threads_debug;
  
-+#if (0)
++#if 0
  /* Globally enabled events.  */
  volatile td_thr_events_t __pthread_threads_events;
 +#endif
  
  /* Pointer to thread descriptor with last event.  */
  volatile pthread_descr __pthread_last_event;
-@@ -85,10 +87,10 @@
- /* Forward declarations */
+@@ -92,9 +94,9 @@
  
  static int pthread_handle_create(pthread_t *thread, const pthread_attr_t *attr,
--                                 void * (*start_routine)(void *), void *arg,
+                                  void * (*start_routine)(void *), void *arg,
 -                                 sigset_t *mask, int father_pid,
-+				 void * (*start_routine)(void *), void *arg,
-+				 sigset_t * mask, int father_pid/*,
++                                 sigset_t *mask, int father_pid/*,
  				 int report_events,
 -				 td_thr_events_t *event_maskp);
 +				 td_thr_events_t *event_maskp*/);
  static void pthread_handle_free(pthread_t th_id);
- static void pthread_handle_exit(pthread_descr issuing_thread, int exitcode);
- static void pthread_reap_children(void);
-@@ -149,9 +151,10 @@
+ static void pthread_handle_exit(pthread_descr issuing_thread, int exitcode)
+      __attribute__ ((noreturn));
+@@ -160,9 +162,9 @@
                                  request.req_args.create.fn,
                                  request.req_args.create.arg,
                                  &request.req_args.create.mask,
@@ -291,39 +405,27 @@ diff -ru ../linuxthreads/manager.c ./manager.c
 +                                request.req_thread->p_pid/*,
  				request.req_thread->p_report_events,
 -				&request.req_thread->p_eventbuf.eventmask);
-+                                &request.req_thread->p_eventbuf.eventmask*/);
-+
++				&request.req_thread->p_eventbuf.eventmask*/);
          restart(request.req_thread);
          break;
        case REQ_FREE:
-@@ -245,6 +248,7 @@
-   return 0;
+@@ -277,6 +279,7 @@
+   __pthread_do_exit(outcome, CURRENT_STACK_FRAME);
  }
  
-+#if (0)
- static int pthread_start_thread_event(void *arg)
- {
-   pthread_descr self = (pthread_descr) arg;
-@@ -263,6 +267,7 @@
++#if 0
+ static int
+ __attribute__ ((noreturn))
+ pthread_start_thread_event(void *arg)
+@@ -297,6 +300,7 @@
    /* Continue with the real function.  */
-   return pthread_start_thread (arg);
+   pthread_start_thread (arg);
  }
 +#endif
  
  static int pthread_allocate_stack(const pthread_attr_t *attr,
                                    pthread_descr default_new_thread,
-@@ -295,8 +300,8 @@
-       /* Allocate space for stack and thread descriptor at default address */
-       new_thread = default_new_thread;
-       new_thread_bottom = (char *) (new_thread + 1) - stacksize;
--      if (mmap((caddr_t)((char *)(new_thread + 1) - INITIAL_STACK_SIZE),
--               INITIAL_STACK_SIZE, PROT_READ | PROT_WRITE | PROT_EXEC,
-+      if (mmap((caddr_t)((char *)(new_thread + 1) - stacksize),
-+               stacksize, PROT_READ | PROT_WRITE | PROT_EXEC,
-                MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED | MAP_GROWSDOWN,
-                -1, 0) == MAP_FAILED)
-         /* Bad luck, this segment is already mapped. */
-@@ -337,9 +342,9 @@
+@@ -476,9 +480,9 @@
  
  static int pthread_handle_create(pthread_t *thread, const pthread_attr_t *attr,
  				 void * (*start_routine)(void *), void *arg,
@@ -335,7 +437,7 @@ diff -ru ../linuxthreads/manager.c ./manager.c
  {
    size_t sseg;
    int pid;
-@@ -407,6 +412,12 @@
+@@ -549,6 +553,12 @@
      }
      new_thread->p_priority =
        new_thread->p_start_args.schedparam.sched_priority;
@@ -348,42 +450,31 @@ diff -ru ../linuxthreads/manager.c ./manager.c
    }
    /* Finish setting up arguments to pthread_start_thread */
    new_thread->p_start_args.start_routine = start_routine;
-@@ -417,6 +428,7 @@
+@@ -563,6 +573,7 @@
    /* Do the cloning.  We have to use two different functions depending
       on whether we are debugging or not.  */
-   pid = 0;     /* Note that the thread never can have PID zero.  */
-+#if (0)
+   pid = 0;	/* Note that the thread never can have PID zero.  */
++#if 0
    if (report_events)
      {
        /* See whether the TD_CREATE event bit is set in any of the
-@@ -457,6 +469,7 @@
+@@ -619,6 +630,7 @@
  	    }
  	}
      }
 +#endif
    if (pid == 0)
-     pid = __clone(pthread_start_thread, (void **) new_thread,
- 		  CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND |
-@@ -468,8 +481,8 @@
-       {
- 	if (new_thread->p_guardsize != 0)
- 	  munmap(new_thread->p_guardaddr, new_thread->p_guardsize);
--	munmap((caddr_t)((char *)(new_thread+1) - INITIAL_STACK_SIZE),
--	       INITIAL_STACK_SIZE);
-+	munmap((caddr_t)((char *)(new_thread+1) - STACK_SIZE),
-+	       STACK_SIZE);
-       }
-     __pthread_handles[sseg].h_descr = NULL;
-     __pthread_handles[sseg].h_bottom = NULL;
-@@ -555,6 +568,7 @@
+     {
+ #ifdef NEED_SEPARATE_REGISTER_STACK
+@@ -738,6 +750,7 @@
        /* Mark thread as exited, and if detached, free its resources */
        __pthread_lock(th->p_lock, NULL);
        th->p_exited = 1;
-+#if (0)
++#if 0
        /* If we have to signal this event do it now.  */
        if (th->p_report_events)
  	{
-@@ -574,6 +588,7 @@
+@@ -757,6 +770,7 @@
  	      __linuxthreads_reap_event();
  	    }
  	}
@@ -391,7 +482,7 @@ diff -ru ../linuxthreads/manager.c ./manager.c
        detached = th->p_detached;
        __pthread_unlock(th->p_lock);
        if (detached)
-@@ -651,10 +666,14 @@
+@@ -834,10 +848,14 @@
  
  /* Process-wide exit() */
  
@@ -406,10 +497,29 @@ diff -ru ../linuxthreads/manager.c ./manager.c
    __pthread_exit_code = exitcode;
    /* Send the CANCEL signal to all running threads, including the main
       thread, but excluding the thread from which the exit request originated
-diff -ru ../linuxthreads/pthread.c ./pthread.c
---- ../linuxthreads/pthread.c	Fri Jan 21 02:40:19 2000
-+++ ./pthread.c	Mon Feb 26 13:11:57 2001
-@@ -20,6 +20,7 @@
+diff -ru ../../work/linuxthreads-2.2.3/ptfork.c ./ptfork.c
+--- ../../work/linuxthreads-2.2.3/ptfork.c	Sun Jan  7 04:35:20 2001
++++ ./ptfork.c	Thu Jun  7 22:59:29 2001
+@@ -84,7 +84,6 @@
+ 
+   pthread_call_handlers(pthread_atfork_prepare);
+   __pthread_once_fork_prepare();
+-  __flockfilelist();
+ 
+   pid = __libc_fork();
+ 
+@@ -97,7 +96,6 @@
+ 
+     pthread_mutex_init(&pthread_atfork_lock, NULL);
+   } else {
+-    __funlockfilelist();
+     __pthread_once_fork_parent();
+     pthread_call_handlers(pthread_atfork_parent);
+ 
+diff -ru ../../work/linuxthreads-2.2.3/pthread.c ./pthread.c
+--- ../../work/linuxthreads-2.2.3/pthread.c	Wed Apr 25 21:50:59 2001
++++ ./pthread.c	Thu Jun  7 22:59:29 2001
+@@ -21,11 +21,11 @@
  #include <stdlib.h>
  #include <string.h>
  #include <unistd.h>
@@ -417,7 +527,21 @@ diff -ru ../linuxthreads/pthread.c ./pthread.c
  #include <fcntl.h>
  #include <sys/wait.h>
  #include <sys/resource.h>
-@@ -37,7 +38,7 @@
+ #include <sys/sysctl.h>
+-#include <shlib-compat.h>
+ #include "pthread.h"
+ #include "internals.h"
+ #include "spinlock.h"
+@@ -43,7 +43,7 @@
+ #endif
+ 
+ /* These variables are used by the setup code.  */
+-extern int _errno;
++extern int _errno __asm__("errno");
+ extern int _h_errno;
+ 
+ /* Descriptor of the initial thread */
+@@ -60,7 +60,7 @@
    NULL,			      /* pthread_descr p_nextlock */
    PTHREAD_THREADS_MAX,        /* pthread_t p_tid */
    0,                          /* int p_pid */
@@ -426,27 +550,26 @@ diff -ru ../linuxthreads/pthread.c ./pthread.c
    &__pthread_handles[0].h_lock, /* struct _pthread_fastlock * p_lock */
    0,                          /* int p_signal */
    NULL,                       /* sigjmp_buf * p_signal_buf */
-@@ -60,14 +61,19 @@
-   0,                          /* char p_sigwaiting */
-   PTHREAD_START_ARGS_INITIALIZER, /* struct pthread_start_args p_start_args */
+@@ -84,13 +84,18 @@
+   PTHREAD_START_ARGS_INITIALIZER(NULL),
+                               /* struct pthread_start_args p_start_args */
    {NULL},                     /* void ** p_specific[PTHREAD_KEY_1STLEVEL_SIZE] */
 +  {NULL, NULL},               /* TAILQ_ENTRY(_pthread_descr_struct) qe */
 +  {NULL},                     /* char timebuf[26] */
 +  {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL}, /* struct tm local_tm */
    {NULL},                     /* void * p_libc_specific[_LIBC_TSD_KEY_N] */
-   0,                          /* int p_userstack */
+   1,                          /* int p_userstack */
    NULL,                       /* void * p_guardaddr */
    0,                          /* size_t p_guardsize */
-   &__pthread_initial_thread,  /* pthread_descr p_self */
    0,                          /* Always index 0 */
-+#if (0)
++#if 0
    0,                          /* int p_report_events */
    {{{0, }}, 0, NULL},         /* td_eventbuf_t p_eventbuf */
 +#endif
-   ATOMIC_INITIALIZER,         /* struct pthread_atomic p_resume_count */
+   __ATOMIC_INITIALIZER,       /* struct pthread_atomic p_resume_count */
    0,                          /* char p_woken_by_cancel */
-   NULL,                       /* struct pthread_extricate_if *p_extricate */
-@@ -87,7 +93,7 @@
+   0,                          /* char p_condvar_avail */
+@@ -117,7 +122,7 @@
    NULL,			      /* pthread_descr p_nextlock */
    0,                          /* int p_tid */
    0,                          /* int p_pid */
@@ -455,9 +578,9 @@ diff -ru ../linuxthreads/pthread.c ./pthread.c
    &__pthread_handles[1].h_lock, /* struct _pthread_fastlock * p_lock */
    0,                          /* int p_signal */
    NULL,                       /* sigjmp_buf * p_signal_buf */
-@@ -110,14 +116,19 @@
-   0,                          /* char p_sigwaiting */
-   PTHREAD_START_ARGS_INITIALIZER, /* struct pthread_start_args p_start_args */
+@@ -141,13 +146,18 @@
+   PTHREAD_START_ARGS_INITIALIZER(__pthread_manager),
+                               /* struct pthread_start_args p_start_args */
    {NULL},                     /* void ** p_specific[PTHREAD_KEY_1STLEVEL_SIZE] */
 +  {NULL, NULL},               /* TAILQ_ENTRY(_pthread_descr_struct) qe */
 +  {NULL},                     /* char timebuf[26] */
@@ -466,49 +589,36 @@ diff -ru ../linuxthreads/pthread.c ./pthread.c
    0,                          /* int p_userstack */
    NULL,                       /* void * p_guardaddr */
    0,                          /* size_t p_guardsize */
-   &__pthread_manager_thread,  /* pthread_descr p_self */
    1,                          /* Always index 1 */
-+#if (0)
++#if 0
    0,                          /* int p_report_events */
    {{{0, }}, 0, NULL},         /* td_eventbuf_t p_eventbuf */
 +#endif
-   ATOMIC_INITIALIZER,         /* struct pthread_atomic p_resume_count */
+   __ATOMIC_INITIALIZER,       /* struct pthread_atomic p_resume_count */
    0,                          /* char p_woken_by_cancel */
-   NULL,                       /* struct pthread_extricate_if *p_extricate */
-@@ -153,6 +164,7 @@
+   0,                          /* char p_condvar_avail */
+@@ -185,6 +195,7 @@
  /* For process-wide exit() */
  
- int __pthread_exit_requested = 0;
+ int __pthread_exit_requested;
 +int __pthread_exit_requested_bymainthread = 0;
- int __pthread_exit_code = 0;
+ int __pthread_exit_code;
  
- /* Pointers that select new or old suspend/resume functions
-@@ -171,18 +183,20 @@
-                                             p_pid);
- 
- /* These variables are used by the setup code.  */
--extern int _errno;
-+extern int _errno __asm__("errno");
- extern int _h_errno;
+ /* Maximum stack size.  */
+@@ -216,11 +227,7 @@
  
  /* Forward declarations */
  
--static void pthread_exit_process(int retcode, void *arg);
-+static void pthread_exit_process(void);
- #ifndef __i386__
+-static void pthread_onexit_process(int retcode, void *arg);
+-#ifndef HAVE_Z_NODELETE
+-static void pthread_atexit_process(void *arg, int retcode);
+-static void pthread_atexit_retcode(void *arg, int retcode);
+-#endif
++static void pthread_onexit_process(void);
  static void pthread_handle_sigcancel(int sig);
  static void pthread_handle_sigrestart(int sig);
- #else
--static void pthread_handle_sigcancel(int sig, struct sigcontext ctx);
--static void pthread_handle_sigrestart(int sig, struct sigcontext ctx);
-+static void pthread_handle_sigcancel(int sig, int code,
-+				     struct sigcontext * ctx);
-+static void pthread_handle_sigrestart(int sig, int code,
-+				      struct sigcontext * ctx);
- #endif
  static void pthread_handle_sigdebug(int sig);
- 
-@@ -194,8 +208,8 @@
+@@ -238,8 +245,8 @@
  #ifndef __SIGRTMIN
  static int current_rtmin = -1;
  static int current_rtmax = -1;
@@ -516,10 +626,10 @@ diff -ru ../linuxthreads/pthread.c ./pthread.c
 -int __pthread_sig_cancel = SIGUSR2;
 +int __pthread_sig_restart = SIGUSR2;
 +int __pthread_sig_cancel = SIGUSR1;
- int __pthread_sig_debug = 0;
+ int __pthread_sig_debug;
  #else
  static int current_rtmin;
-@@ -206,8 +220,8 @@
+@@ -250,8 +257,8 @@
  int __pthread_sig_cancel = __SIGRTMIN + 1;
  int __pthread_sig_debug = __SIGRTMIN + 2;
  #else
@@ -527,59 +637,105 @@ diff -ru ../linuxthreads/pthread.c ./pthread.c
 -int __pthread_sig_cancel = SIGUSR2;
 +int __pthread_sig_restart = SIGUSR2;
 +int __pthread_sig_cancel = SIGUSR1;
- int __pthread_sig_debug = 0;
+ int __pthread_sig_debug;
  #endif
  
-@@ -345,7 +359,7 @@
- #ifndef __i386__
-   sa.sa_handler = pthread_handle_sigrestart;
- #else
--  sa.sa_handler = (__sighandler_t) pthread_handle_sigrestart;
-+  sa.sa_handler = (__sighandler_t *) pthread_handle_sigrestart;
- #endif
-   sigemptyset(&sa.sa_mask);
-   sa.sa_flags = 0;
-@@ -353,7 +367,7 @@
- #ifndef __i386__
-   sa.sa_handler = pthread_handle_sigcancel;
- #else
--  sa.sa_handler = (__sighandler_t) pthread_handle_sigcancel;
-+  sa.sa_handler = (__sighandler_t *) pthread_handle_sigcancel;
- #endif
-   sa.sa_flags = 0;
-   __sigaction(__pthread_sig_cancel, &sa, NULL);
-@@ -370,7 +384,7 @@
+@@ -348,26 +355,17 @@
+ static int
+ is_smp_system (void)
+ {
+-  static const int sysctl_args[] = { CTL_KERN, KERN_VERSION };
+-  char buf[512];
++  static const int sysctl_args[] = { CTL_HW, HW_NCPU };
++  int buf;
+   size_t reslen = sizeof (buf);
+ 
+-  /* Try reading the number using `sysctl' first.  */
+-  if (__sysctl ((int *) sysctl_args,
+-		sizeof (sysctl_args) / sizeof (sysctl_args[0]),
+-		buf, &reslen, NULL, 0) < 0)
+-    {
+-      /* This was not successful.  Now try reading the /proc filesystem.  */
+-      int fd = __open ("/proc/sys/kernel/version", O_RDONLY);
+-      if (__builtin_expect (fd, 0) == -1
+-	  || (reslen = __read (fd, buf, sizeof (buf))) <= 0)
+-	/* This also didn't work.  We give up and say it's a UP machine.  */
+-	buf[0] = '\0';
+-
+-      __close (fd);
+-    }
+-
+-  return strstr (buf, "SMP") != NULL;
++  buf = 1;
++  if (sysctl ((int *) sysctl_args,
++	      sizeof (sysctl_args) / sizeof (sysctl_args[0]),
++	      &buf, &reslen, NULL, 0) < 0)
++	  return 0;
++  
++  return buf > 1;
+ }
+ 
+ 
+@@ -448,13 +446,7 @@
    /* Register an exit function to kill all other threads. */
    /* Do it early so that user-registered atexit functions are called
-      before pthread_exit_process. */
--  __on_exit(pthread_exit_process, NULL);
-+  atexit(pthread_exit_process);
+      before pthread_*exit_process. */
+-#ifndef HAVE_Z_NODELETE
+-  if (__builtin_expect (&__dso_handle != NULL, 1))
+-    __cxa_atexit ((void (*) (void *)) pthread_atexit_process, NULL,
+-		  __dso_handle);
+-  else
+-#endif
+-    __on_exit (pthread_onexit_process, NULL);
++  atexit(pthread_onexit_process);
+   /* How many processors.  */
+   __pthread_smp_kernel = is_smp_system ();
  }
+@@ -502,12 +494,6 @@
+   int pid;
+   struct pthread_request request;
  
- void __pthread_initialize(void)
-@@ -399,6 +413,7 @@
+-#ifndef HAVE_Z_NODELETE
+-  if (__builtin_expect (&__dso_handle != NULL, 1))
+-    __cxa_atexit ((void (*) (void *)) pthread_atexit_retcode, NULL,
+-		  __dso_handle);
+-#endif
+-
+   if (__pthread_max_stacksize == 0)
+     __pthread_init_max_stacksize ();
+   /* If basic initialization not done yet (e.g. we're called from a
+@@ -525,6 +511,7 @@
    }
    /* Start the thread manager */
    pid = 0;
-+#if (0)
-   if (__pthread_initial_thread.p_report_events)
++#if 0
+   if (__builtin_expect (__pthread_initial_thread.p_report_events, 0))
      {
        /* It's a bit more complicated.  We have to report the creation of
-@@ -436,10 +451,12 @@
- 	    }
+@@ -572,17 +559,20 @@
+ 	  __pthread_unlock(__pthread_manager_thread.p_lock);
  	}
      }
 +#endif
  
-   if (pid == 0)
-     pid = __clone(__pthread_manager, (void **) __pthread_manager_thread_tos,
--		  CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND,
-+		  CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND |
-+		  __pthread_sig_cancel,
- 		  (void *)(long)manager_pipe[0]);
-   if (pid == -1) {
-     free(__pthread_manager_thread_bos);
-@@ -568,7 +585,7 @@
+   if (__builtin_expect (pid, 0) == 0)
+     {
+ #ifdef NEED_SEPARATE_REGISTER_STACK
+       pid = __clone2(__pthread_manager, (void **) __pthread_manager_thread_bos,
+ 		     THREAD_MANAGER_STACK_SIZE,
+-		     CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND,
++		     CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND |
++		     __pthread_sig_cancel,
+ 		     (void *)(long)manager_pipe[0]);
+ #else
+       pid = __clone(__pthread_manager, (void **) __pthread_manager_thread_tos,
+-		    CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND,
++		    CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND |
++		    __pthread_sig_cancel,
+ 		    (void *)(long)manager_pipe[0]);
+ #endif
+     }
+@@ -715,7 +705,7 @@
      __pthread_unlock(&handle->h_lock);
      return errno;
    }
@@ -588,17 +744,17 @@ diff -ru ../linuxthreads/pthread.c ./pthread.c
    __pthread_unlock(&handle->h_lock);
    if (__pthread_manager_request >= 0)
      __pthread_manager_adjust_prio(th->p_priority);
-@@ -597,7 +614,7 @@
+@@ -751,7 +741,7 @@
  
  /* Process-wide exit() request */
  
--static void pthread_exit_process(int retcode, void *arg)
-+static void pthread_exit_process(void)
+-static void pthread_onexit_process(int retcode, void *arg)
++static void pthread_onexit_process(void)
  {
-   struct pthread_request request;
-   pthread_descr self = thread_self();
-@@ -605,7 +622,7 @@
-   if (__pthread_manager_request >= 0) {
+   if (__builtin_expect (__pthread_manager_request, 0) >= 0) {
+     struct pthread_request request;
+@@ -759,7 +749,7 @@
+ 
      request.req_thread = self;
      request.req_kind = REQ_PROCESS_EXIT;
 -    request.req_args.exit.code = retcode;
@@ -606,36 +762,28 @@ diff -ru ../linuxthreads/pthread.c ./pthread.c
      __libc_write(__pthread_manager_request,
  		 (char *) &request, sizeof(request));
      suspend(self);
-@@ -625,10 +642,11 @@
- {
-   pthread_descr self = thread_self();
- #else
--static void pthread_handle_sigrestart(int sig, struct sigcontext ctx)
-+static void pthread_handle_sigrestart(int sig, int code,
-+				      struct sigcontext * ctx)
- {
-   pthread_descr self;
--  asm volatile ("movw %w0,%%gs" : : "r" (ctx.gs));
-+  asm volatile ("movw %w0,%%gs" : : "r" (ctx->sc_gs));
-   self = thread_self();
- #endif
-   THREAD_SETMEM(self, p_signal, sig);
-@@ -647,11 +665,11 @@
-   pthread_descr self = thread_self();
-   sigjmp_buf * jmpbuf;
- #else
--static void pthread_handle_sigcancel(int sig, struct sigcontext ctx)
-+static void pthread_handle_sigcancel(int sig, int code, struct sigcontext * ctx)
- {
-   pthread_descr self;
-   sigjmp_buf * jmpbuf;
--  asm volatile ("movw %w0,%%gs" : : "r" (ctx.gs));
-+  asm volatile ("movw %w0,%%gs" : : "r" (ctx->sc_gs));
-   self = thread_self();
- #endif
+@@ -774,19 +764,6 @@
+   }
+ }
  
-@@ -663,6 +681,9 @@
-   if (__pthread_exit_requested) {
+-#ifndef HAVE_Z_NODELETE
+-static int __pthread_atexit_retcode;
+-
+-static void pthread_atexit_process(void *arg, int retcode)
+-{
+-  pthread_onexit_process (retcode ?: __pthread_atexit_retcode, arg);
+-}
+-
+-static void pthread_atexit_retcode(void *arg, int retcode)
+-{
+-  __pthread_atexit_retcode = retcode;
+-}
+-#endif
+ 
+ /* The handler for the RESTART signal just records the signal received
+    in the thread descriptor, and optionally performs a siglongjmp
+@@ -818,6 +795,9 @@
+   if (__builtin_expect (__pthread_exit_requested, 0)) {
      /* Main thread should accumulate times for thread manager and its
         children, so that timings for main thread account for all threads. */
 +    if (self == __pthread_main_thread &&
@@ -644,16 +792,16 @@ diff -ru ../linuxthreads/pthread.c ./pthread.c
      if (self == __pthread_main_thread)
        waitpid(__pthread_manager_thread.p_pid, NULL, __WCLONE);
      _exit(__pthread_exit_code);
-@@ -731,7 +752,7 @@
+@@ -894,7 +874,7 @@
  {
    struct sigaction sa;
    /* Terminate all other threads and thread manager */
--  pthread_exit_process(0, NULL);
-+  pthread_exit_process();
+-  pthread_onexit_process(0, NULL);
++  pthread_onexit_process();
    /* Make current thread the main thread in case the calling thread
       changes its mind, does not exec(), and creates new threads instead. */
    __pthread_reset_main_thread();
-@@ -838,3 +859,13 @@
+@@ -1131,3 +1111,17 @@
  static const int *const __pthread_require_wrappers =
    &__pthread_provide_wrappers;
  #endif
@@ -667,26 +815,31 @@ diff -ru ../linuxthreads/pthread.c ./pthread.c
 +
 +extern int *__error(void);
 +static int *(*unusedref3)(void) __attribute__ ((unused)) = __error;
-diff -ru ../linuxthreads/ptlongjmp.c ./ptlongjmp.c
---- ../linuxthreads/ptlongjmp.c	Tue Oct 27 14:52:00 1998
-+++ ./ptlongjmp.c	Mon Feb 26 12:36:31 2001
-@@ -19,13 +19,14 @@
++
++static
++struct tm *(*unusedref4)(const time_t *) __attribute__ ((unused)) = localtime;
++
+diff -ru ../../work/linuxthreads-2.2.3/ptlongjmp.c ./ptlongjmp.c
+--- ../../work/linuxthreads-2.2.3/ptlongjmp.c	Thu Apr 12 21:02:02 2001
++++ ./ptlongjmp.c	Thu Jun  7 22:59:29 2001
+@@ -18,14 +18,15 @@
+ #include <setjmp.h>
  #include "pthread.h"
  #include "internals.h"
+-#include <stackinfo.h>
  
-+#if (0)
++#if 0
  /* These functions are not declared anywhere since they shouldn't be
     used at another place but here.  */
  extern void __libc_siglongjmp (sigjmp_buf env, int val)
       __attribute__ ((noreturn));
  extern void __libc_longjmp (sigjmp_buf env, int val)
       __attribute__ ((noreturn));
--
 +#endif
  
+ 
  static void pthread_cleanup_upto(__jmp_buf target)
- {
-@@ -44,12 +45,12 @@
+@@ -63,12 +64,12 @@
  
  void siglongjmp(sigjmp_buf env, int val)
  {
@@ -701,20 +854,42 @@ diff -ru ../linuxthreads/ptlongjmp.c ./ptlongjmp.c
 +  pthread_cleanup_upto((void *) env);
    __libc_longjmp(env, val);
  }
-diff -ru ../linuxthreads/semaphore.h ./semaphore.h
---- ../linuxthreads/semaphore.h	Wed Feb 23 08:02:52 2000
-+++ ./semaphore.h	Mon Feb 26 12:36:31 2001
+diff -ru ../../work/linuxthreads-2.2.3/restart.h ./restart.h
+--- ../../work/linuxthreads-2.2.3/restart.h	Mon Apr 17 17:18:55 2000
++++ ./restart.h	Thu Jun  7 22:59:29 2001
+@@ -13,7 +13,6 @@
+ /* GNU Library General Public License for more details.                 */
+ 
+ #include <signal.h>
+-#include <kernel-features.h>
+ 
+ /* Primitives for controlling thread execution */
+ 
+diff -ru ../../work/linuxthreads-2.2.3/semaphore.c ./semaphore.c
+--- ../../work/linuxthreads-2.2.3/semaphore.c	Thu Apr 12 21:02:02 2001
++++ ./semaphore.c	Thu Jun  7 22:59:29 2001
+@@ -21,7 +21,6 @@
+ #include "spinlock.h"
+ #include "restart.h"
+ #include "queue.h"
+-#include <shlib-compat.h>
+ 
+ int __new_sem_init(sem_t *sem, int pshared, unsigned int value)
+ {
+diff -ru ../../work/linuxthreads-2.2.3/semaphore.h ./semaphore.h
+--- ../../work/linuxthreads-2.2.3/semaphore.h	Fri Feb  9 18:04:08 2001
++++ ./semaphore.h	Thu Jun  7 22:59:29 2001
 @@ -15,7 +15,6 @@
  #ifndef _SEMAPHORE_H
  #define _SEMAPHORE_H    1
  
 -#include <features.h>
  #include <sys/types.h>
- 
- #ifndef _PTHREAD_DESCR_DEFINED
-diff -ru ../linuxthreads/signals.c ./signals.c
---- ../linuxthreads/signals.c	Mon Oct  4 21:50:04 1999
-+++ ./signals.c	Mon Feb 26 12:36:31 2001
+ #ifdef __USE_XOPEN2K
+ # define __need_timespec
+diff -ru ../../work/linuxthreads-2.2.3/signals.c ./signals.c
+--- ../../work/linuxthreads-2.2.3/signals.c	Tue Apr 17 15:17:16 2001
++++ ./signals.c	Thu Jun  7 22:59:29 2001
 @@ -20,7 +20,6 @@
  #include "internals.h"
  #include "spinlock.h"
@@ -727,8 +902,8 @@ diff -ru ../linuxthreads/signals.c ./signals.c
  }
  
  /* User-provided signal handlers */
--typedef void (*arch_sighandler_t) __PMT ((int, SIGCONTEXT));
-+typedef void (*arch_sighandler_t) __PMT ((int, int, SIGCONTEXT));
+-typedef void (*arch_sighandler_t) (int, SIGCONTEXT);
++typedef void (*arch_sighandler_t) (int, int, SIGCONTEXT);
  static union
  {
    arch_sighandler_t old;
@@ -740,13 +915,13 @@ diff -ru ../linuxthreads/signals.c ./signals.c
 -static void pthread_sighandler(int signo, SIGCONTEXT ctx)
 +static void pthread_sighandler(int signo, int code, SIGCONTEXT ctx)
  {
-   pthread_descr self = thread_self();
+   pthread_descr self;
    char * in_sighandler;
-@@ -93,14 +92,14 @@
+@@ -94,14 +93,14 @@
    in_sighandler = THREAD_GETMEM(self, p_in_sighandler);
    if (in_sighandler == NULL)
      THREAD_SETMEM(self, p_in_sighandler, CURRENT_STACK_FRAME);
--  sighandler[signo].old(signo, SIGCONTEXT_EXTRA_ARGS ctx);
+-  CALL_SIGHANDLER(sighandler[signo].old, signo, ctx);
 +  sighandler[signo].old(signo, code, ctx);
    if (in_sighandler == NULL)
      THREAD_SETMEM(self, p_in_sighandler, NULL);
@@ -758,9 +933,9 @@ diff -ru ../linuxthreads/signals.c ./signals.c
 +static void pthread_sighandler_rt(int signo, siginfo_t *si,
 +				  ucontext_t *uc)
  {
-   pthread_descr self = thread_self();
+   pthread_descr self;
    char * in_sighandler;
-@@ -140,9 +139,9 @@
+@@ -145,9 +144,9 @@
  	  && sig > 0 && sig < NSIG)
  	{
  	  if (act->sa_flags & SA_SIGINFO)
@@ -772,7 +947,7 @@ diff -ru ../linuxthreads/signals.c ./signals.c
  	}
        newactp = &newact;
      }
-@@ -153,7 +152,7 @@
+@@ -158,7 +157,7 @@
    if (sig > 0 && sig < NSIG)
      {
        if (oact != NULL)
@@ -781,18 +956,21 @@ diff -ru ../linuxthreads/signals.c ./signals.c
        if (act)
  	/* For the assignment is does not matter whether it's a normal
  	   or real-time signal.  */
-diff -ru ../linuxthreads/spinlock.c ./spinlock.c
---- ../linuxthreads/spinlock.c	Thu Jan  6 02:47:19 2000
-+++ ./spinlock.c	Mon Feb 26 12:36:31 2001
-@@ -137,7 +137,6 @@
- 
- #if !defined HAS_COMPARE_AND_SWAP || defined TEST_FOR_COMPARE_AND_SWAP
+diff -ru ../../work/linuxthreads-2.2.3/spinlock.c ./spinlock.c
+--- ../../work/linuxthreads-2.2.3/spinlock.c	Tue Mar 27 04:52:56 2001
++++ ./spinlock.c	Thu Jun  7 22:59:29 2001
+@@ -24,10 +24,6 @@
+ #include "spinlock.h"
+ #include "restart.h"
  
+-#if !defined HAS_COMPARE_AND_SWAP || defined TEST_FOR_COMPARE_AND_SWAP
 -static void __pthread_acquire(int * spinlock);
+-#endif
+-
  
- int __pthread_compare_and_swap(long * ptr, long oldval, long newval,
-                                int * spinlock)
-@@ -174,7 +173,7 @@
+ /* The status field of a spinlock is a pointer whose least significant
+    bit is a locked flag.
+@@ -701,7 +697,7 @@
     - When nanosleep() returns, we try again, doing MAX_SPIN_COUNT
       sched_yield(), then sleeping again if needed. */
  
@@ -801,21 +979,21 @@ diff -ru ../linuxthreads/spinlock.c ./spinlock.c
  {
    int cnt = 0;
    struct timespec tm;
-diff -ru ../linuxthreads/spinlock.h ./spinlock.h
---- ../linuxthreads/spinlock.h	Thu Jan  6 02:45:15 2000
-+++ ./spinlock.h	Mon Feb 26 12:36:31 2001
-@@ -71,6 +71,8 @@
-   return 0;
+diff -ru ../../work/linuxthreads-2.2.3/spinlock.h ./spinlock.h
+--- ../../work/linuxthreads-2.2.3/spinlock.h	Fri Feb  9 18:04:08 2001
++++ ./spinlock.h	Thu Jun  7 22:59:29 2001
+@@ -180,6 +180,8 @@
+ #endif
  }
  
 +void __pthread_acquire(int * spinlock);
 +
- #define LOCK_INITIALIZER {0, 0}
- 
  /* Operations on pthread_atomic, which is defined in internals.h */
-diff -ru ../linuxthreads/sysdeps/pthread/bits/pthreadtypes.h ./sysdeps/pthread/bits/pthreadtypes.h
---- ../linuxthreads/sysdeps/pthread/bits/pthreadtypes.h	Fri Jan 21 02:40:19 2000
-+++ ./sysdeps/pthread/bits/pthreadtypes.h	Mon Feb 26 12:36:31 2001
+ 
+ static inline long atomic_increment(struct pthread_atomic *pa)
+diff -ru ../../work/linuxthreads-2.2.3/sysdeps/pthread/bits/pthreadtypes.h ./sysdeps/pthread/bits/pthreadtypes.h
+--- ../../work/linuxthreads-2.2.3/sysdeps/pthread/bits/pthreadtypes.h	Fri Feb  9 18:04:09 2001
++++ ./sysdeps/pthread/bits/pthreadtypes.h	Thu Jun  7 22:59:29 2001
 @@ -20,7 +20,6 @@
  #define _BITS_PTHREADTYPES_H	1
  
@@ -824,7 +1002,7 @@ diff -ru ../linuxthreads/sysdeps/pthread/bits/pthreadtypes.h ./sysdeps/pthread/b
  
  /* Fast locks (not abstract because mutexes and conditions aren't abstract). */
  struct _pthread_fastlock
-@@ -41,7 +40,7 @@
+@@ -42,7 +41,7 @@
  {
    int __detachstate;
    int __schedpolicy;
@@ -833,30 +1011,24 @@ diff -ru ../linuxthreads/sysdeps/pthread/bits/pthreadtypes.h ./sysdeps/pthread/b
    int __inheritsched;
    int __scope;
    size_t __guardsize;
-diff -ru ../linuxthreads/sysdeps/pthread/pthread.h ./sysdeps/pthread/pthread.h
---- ../linuxthreads/sysdeps/pthread/pthread.h	Fri Jan 21 02:40:19 2000
-+++ ./sysdeps/pthread/pthread.h	Mon Feb 26 12:36:31 2001
-@@ -15,7 +15,6 @@
+diff -ru ../../work/linuxthreads-2.2.3/sysdeps/pthread/pthread.h ./sysdeps/pthread/pthread.h
+--- ../../work/linuxthreads-2.2.3/sysdeps/pthread/pthread.h	Tue Mar 27 04:52:56 2001
++++ ./sysdeps/pthread/pthread.h	Thu Jun  7 22:59:29 2001
+@@ -15,7 +15,9 @@
  #ifndef _PTHREAD_H
  #define _PTHREAD_H	1
  
 -#include <features.h>
++#ifndef __THROW
++#define __THROW
++#endif
  
  #include <sched.h>
  #include <time.h>
-@@ -108,7 +107,7 @@
- 
- struct _pthread_cleanup_buffer
- {
--  void (*__routine) __PMT ((void *));	  /* Function to call.  */
-+  void (*__routine) __P ((void *));	  /* Function to call.  */
-   void *__arg;				  /* Its argument.  */
-   int __canceltype;			  /* Saved cancellation type. */
-   struct _pthread_cleanup_buffer *__prev; /* Chaining of cleanup functions.  */
-diff -ru ../linuxthreads/sysdeps/unix/sysv/linux/bits/local_lim.h ./sysdeps/unix/sysv/linux/bits/local_lim.h
---- ../linuxthreads/sysdeps/unix/sysv/linux/bits/local_lim.h	Thu Nov 12 19:03:14 1998
-+++ ./sysdeps/unix/sysv/linux/bits/local_lim.h	Mon Feb 26 12:36:31 2001
-@@ -24,7 +24,7 @@
+diff -ru ../../work/linuxthreads-2.2.3/sysdeps/unix/sysv/linux/bits/local_lim.h ./sysdeps/unix/sysv/linux/bits/local_lim.h
+--- ../../work/linuxthreads-2.2.3/sysdeps/unix/sysv/linux/bits/local_lim.h	Fri Jun  9 19:17:35 2000
++++ ./sysdeps/unix/sysv/linux/bits/local_lim.h	Thu Jun  7 22:59:29 2001
+@@ -33,7 +33,7 @@
  #endif
  
  /* The kernel sources contain a file with all the needed information.  */
@@ -865,23 +1037,23 @@ diff -ru ../linuxthreads/sysdeps/unix/sysv/linux/bits/local_lim.h ./sysdeps/unix
  
  /* Have to remove NR_OPEN?  */
  #ifdef __undef_NR_OPEN
-diff -ru ../linuxthreads/sysdeps/unix/sysv/linux/bits/sigthread.h ./sysdeps/unix/sysv/linux/bits/sigthread.h
---- ../linuxthreads/sysdeps/unix/sysv/linux/bits/sigthread.h	Sat Sep 12 23:33:14 1998
-+++ ./sysdeps/unix/sysv/linux/bits/sigthread.h	Mon Feb 26 12:36:31 2001
-@@ -28,8 +28,8 @@
- 
+diff -ru ../../work/linuxthreads-2.2.3/sysdeps/unix/sysv/linux/bits/sigthread.h ./sysdeps/unix/sysv/linux/bits/sigthread.h
+--- ../../work/linuxthreads-2.2.3/sysdeps/unix/sysv/linux/bits/sigthread.h	Thu Aug 31 21:45:04 2000
++++ ./sysdeps/unix/sysv/linux/bits/sigthread.h	Thu Jun  7 22:59:29 2001
+@@ -29,8 +29,8 @@
  /* Modify the signal mask for the calling thread.  The arguments have
     the same meaning as for sigprocmask(2). */
--extern int pthread_sigmask __P ((int __how, __const __sigset_t *__newmask,
--				 __sigset_t *__oldmask));
-+extern int pthread_sigmask __P ((int __how, __const sigset_t *__newmask,
-+				 sigset_t *__oldmask));
+ extern int pthread_sigmask (int __how,
+-			    __const __sigset_t *__restrict __newmask,
+-			    __sigset_t *__restrict __oldmask)__THROW;
++			    __const sigset_t *__restrict __newmask,
++			    sigset_t *__restrict __oldmask)__THROW;
  
  /* Send signal SIGNO to the given thread. */
- extern int pthread_kill __P ((pthread_t __thread, int __signo));
-diff -ru ../linuxthreads/wrapsyscall.c ./wrapsyscall.c
---- ../linuxthreads/wrapsyscall.c	Tue Dec  1 20:34:20 1998
-+++ ./wrapsyscall.c	Mon Feb 26 12:36:31 2001
+ extern int pthread_kill (pthread_t __thread, int __signo) __THROW;
+diff -ru ../../work/linuxthreads-2.2.3/wrapsyscall.c ./wrapsyscall.c
+--- ../../work/linuxthreads-2.2.3/wrapsyscall.c	Wed Apr 25 21:50:59 2001
++++ ./wrapsyscall.c	Thu Jun  7 22:59:29 2001
 @@ -29,6 +29,7 @@
  #include <sys/resource.h>
  #include <sys/wait.h>
@@ -889,45 +1061,12 @@ diff -ru ../linuxthreads/wrapsyscall.c ./wrapsyscall.c
 +#include "internals.h"
  
  
- #ifndef PIC
-@@ -39,20 +40,20 @@
- 
- 
- #define CANCELABLE_SYSCALL(res_type, name, param_list, params) \
--res_type __libc_##name param_list;					      \
-+res_type _##name param_list;						      \
- res_type								      \
- name param_list								      \
- {									      \
-   res_type result;							      \
-   int oldtype;								      \
-   pthread_setcanceltype (PTHREAD_CANCEL_ASYNCHRONOUS, &oldtype);	      \
--  result = __libc_##name params;					      \
-+  result = _##name params;						      \
-   pthread_setcanceltype (oldtype, NULL);				      \
-   return result;							      \
- }
- 
- #define CANCELABLE_SYSCALL_VA(res_type, name, param_list, params, last_arg) \
--res_type __libc_##name param_list;					      \
-+res_type _##name param_list;						      \
- res_type								      \
- name param_list								      \
- {									      \
-@@ -61,7 +62,7 @@
-   va_list ap;								      \
-   pthread_setcanceltype (PTHREAD_CANCEL_ASYNCHRONOUS, &oldtype);	      \
-   va_start (ap, last_arg);						      \
--  result = __libc_##name params;					      \
-+  result = _##name params;						      \
-   va_end (ap);								      \
-   pthread_setcanceltype (oldtype, NULL);				      \
-   return result;							      \
-@@ -83,10 +84,12 @@
+ #ifndef SHARED
+@@ -85,15 +86,19 @@
  CANCELABLE_SYSCALL (int, fsync, (int fd), (fd))
  
  
-+#if (0)
++#if 0
  /* lseek(2).  */
  CANCELABLE_SYSCALL (off_t, lseek, (int fd, off_t offset, int whence),
  		    (fd, offset, whence))
@@ -935,66 +1074,98 @@ diff -ru ../linuxthreads/wrapsyscall.c ./wrapsyscall.c
 +#endif
  
  
++#if 0
+ /* lseek64(2).  */
+ CANCELABLE_SYSCALL (off64_t, lseek64, (int fd, off64_t offset, int whence),
+ 		    (fd, offset, whence))
++#endif
+ 
+ 
  /* msync(2).  */
-@@ -107,7 +110,7 @@
+@@ -113,40 +118,50 @@
+ strong_alias (open, __open)
+ 
+ 
++#if 0
+ /* open64(3).  */
+ CANCELABLE_SYSCALL_VA (int, open64, (const char *pathname, int flags, ...),
+ 		       (pathname, flags, va_arg (ap, mode_t)), flags)
+ strong_alias (open64, __open64)
++#endif
  
  
  /* pause(2).  */
--CANCELABLE_SYSCALL (int, pause, (void), ())
-+CANCELABLE_SYSCALL (int, _pause, (void), ())
+ CANCELABLE_SYSCALL (int, pause, (void), ())
  
  
- /* read(2).  */
-@@ -117,20 +120,21 @@
++#if 0
+ /* pread(3).  */
+ CANCELABLE_SYSCALL (ssize_t, pread, (int fd, void *buf, size_t count,
+ 				     off_t offset),
+ 		    (fd, buf, count, offset))
++#endif
  
  
- /* system(3).  */
--CANCELABLE_SYSCALL (int, system, (const char *line), (line))
--
-+CANCELABLE_SYSCALL (int, _system, (const char *line), (line))
++#if 0
+ /* pread64(3).  */
+ CANCELABLE_SYSCALL (ssize_t, pread64, (int fd, void *buf, size_t count,
+ 				       off64_t offset),
+ 		    (fd, buf, count, offset))
+ strong_alias (pread64, __pread64)
++#endif
  
- /* tcdrain(2).  */
--CANCELABLE_SYSCALL (int, tcdrain, (int fd), (fd))
-+CANCELABLE_SYSCALL (int, _tcdrain, (int fd), (fd))
  
++#if 0
+ /* pwrite(3).  */
+ CANCELABLE_SYSCALL (ssize_t, pwrite, (int fd, const void *buf, size_t n,
+ 				      off_t offset),
+ 		    (fd, buf, n, offset))
++#endif
  
- /* wait(2).  */
--CANCELABLE_SYSCALL (__pid_t, wait, (__WAIT_STATUS_DEFN stat_loc), (stat_loc))
-+#if (1)
-+CANCELABLE_SYSCALL (__pid_t, _wait, (__WAIT_STATUS_DEFN stat_loc), (stat_loc))
+ 
++#if 0
+ /* pwrite64(3).  */
+ CANCELABLE_SYSCALL (ssize_t, pwrite64, (int fd, const void *buf, size_t n,
+ 					off64_t offset),
+ 		    (fd, buf, n, offset))
+ strong_alias (pwrite64, __pwrite64)
 +#endif
+ 
+ 
+ /* read(2).  */
+@@ -165,7 +180,9 @@
+ 
+ /* wait(2).  */
+ CANCELABLE_SYSCALL (__pid_t, wait, (__WAIT_STATUS_DEFN stat_loc), (stat_loc))
++#if 0
  strong_alias (wait, __wait)
++#endif
  
  
  /* waitpid(2).  */
--CANCELABLE_SYSCALL (__pid_t, waitpid, (__pid_t pid, int *stat_loc,
-+CANCELABLE_SYSCALL (__pid_t, _waitpid, (__pid_t pid, int *stat_loc,
- 				       int options),
- 		    (pid, stat_loc, options))
- 
-@@ -155,9 +159,11 @@
+@@ -194,9 +211,11 @@
  		    (fd, addr, len))
  strong_alias (connect, __connect)
  
-+#if (0)
++#if 0
  /* recv(2).  */
- CANCELABLE_SYSCALL (int, recv, (int fd, __ptr_t buf, size_t n, int flags),
+ CANCELABLE_SYSCALL (ssize_t, recv, (int fd, __ptr_t buf, size_t n, int flags),
  		    (fd, buf, n, flags))
 +#endif
  
  /* recvfrom(2).  */
- CANCELABLE_SYSCALL (int, recvfrom, (int fd, __ptr_t buf, size_t n, int flags,
-@@ -168,11 +174,13 @@
- CANCELABLE_SYSCALL (int, recvmsg, (int fd, struct msghdr *message, int flags),
+ CANCELABLE_SYSCALL (ssize_t, recvfrom, (int fd, __ptr_t buf, size_t n, int flags,
+@@ -207,11 +226,13 @@
+ CANCELABLE_SYSCALL (ssize_t, recvmsg, (int fd, struct msghdr *message, int flags),
  		    (fd, message, flags))
  
-+#if (0)
++#if 0
  /* send(2).  */
- CANCELABLE_SYSCALL (int, send, (int fd, const __ptr_t buf, size_t n,
- 				int flags),
+ CANCELABLE_SYSCALL (ssize_t, send, (int fd, const __ptr_t buf, size_t n,
+ 				    int flags),
  		    (fd, buf, n, flags))
  strong_alias (send, __send)
 +#endif
  
  /* sendmsg(2).  */
- CANCELABLE_SYSCALL (int, sendmsg, (int fd, const struct msghdr *message,
+ CANCELABLE_SYSCALL (ssize_t, sendmsg, (int fd, const struct msghdr *message,
diff --git a/devel/linuxthreads/files/wraputhread.c b/devel/linuxthreads/files/wraputhread.c
index 7898d49ceb6f..8f1dafd987ae 100644
--- a/devel/linuxthreads/files/wraputhread.c
+++ b/devel/linuxthreads/files/wraputhread.c
@@ -23,13 +23,21 @@
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  *
- * $FreeBSD: /tmp/pcvs/ports/devel/linuxthreads/files/wraputhread.c,v 1.1 2001-02-20 00:34:57 tegge Exp $
+ * $FreeBSD: /tmp/pcvs/ports/devel/linuxthreads/files/wraputhread.c,v 1.2 2001-06-14 01:34:18 tegge Exp $
  */
 
 #include <pthread.h>
 #include <stdlib.h>
 #include <sys/errno.h>
 
+void *__pthread_getspecific(pthread_key_t);
+int   __pthread_setspecific(pthread_key_t, const void *);
+int   __pthread_key_create(pthread_key_t *, void (*) (void *));
+int   __pthread_mutex_destroy(pthread_mutex_t *);
+int   __pthread_mutex_init(pthread_mutex_t *, const pthread_mutexattr_t *);
+int   __pthread_mutex_lock(pthread_mutex_t *);
+int   __pthread_mutex_trylock(pthread_mutex_t *);
+int   __pthread_mutex_unlock(pthread_mutex_t *);
 
 void *
 _pthread_getspecific(pthread_key_t key)