Add compatibility symbol maps. libpthread (.so.1 and .so.2)

used LIBTHREAD_1_0 as its version definition, but now needs
to define its symbols in the same namespace used by libc.
The compatibility hooks allows you to use libraries and
binaries built and linked to libpthread before libc was
built with symbol versioning.  The shims can be removed if
libpthread is given a version bump.

Reviewed by:	davidxu

lib/libkse/Makefile

@@ -31,10 +31,13 @@ CFLAGS+=-D_LOCK_DEBUG
 # however it is no longer strictly conformed to POSIX
 # CFLAGS+=-DSYSTEM_SCOPE_ONLY
 
-LDFLAGS= -Wl,--version-script=${.CURDIR}/pthread.map
+LDFLAGS= -Wl,--version-script=${.CURDIR}/pthread.map -Wl,-zmuldefs
 
 # enable extra internal consistancy checks
 CFLAGS+=-D_PTHREADS_INVARIANTS -Wall
+.if defined(SYMVER_ENABLED)
+CFLAGS+=-DSYMBOL_VERSIONING
+.endif
 
 PRECIOUSLIB=
 

lib/libkse/sys/thr_error.c

@@ -40,6 +40,8 @@
 #undef errno
 extern	int	errno;
 
+LT10_COMPAT_DEFAULT(__error);
+
 int *
 __error(void)
 {

lib/libkse/thread/thr_accept.c

@@ -32,6 +32,9 @@ __FBSDID("$FreeBSD$");
 #include <pthread.h>
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(__accept);
+LT10_COMPAT_DEFAULT(accept);
+
 __weak_reference(__accept, accept);
 
 int

lib/libkse/thread/thr_aio_suspend.c

@@ -33,6 +33,9 @@
 #include <pthread.h>
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(_aio_suspend);
+LT10_COMPAT_DEFAULT(aio_suspend);
+
 __weak_reference(_aio_suspend, aio_suspend);
 
 int

lib/libkse/thread/thr_atfork.c

@@ -31,6 +31,9 @@
 #include <sys/queue.h>
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(_pthread_atfork);
+LT10_COMPAT_DEFAULT(pthread_atfork);
+
 __weak_reference(_pthread_atfork, pthread_atfork);
 
 int

lib/libkse/thread/thr_attr_destroy.c

@@ -36,6 +36,9 @@
 #include <pthread.h>
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(_pthread_attr_destroy);
+LT10_COMPAT_DEFAULT(pthread_attr_destroy);
+
 __weak_reference(_pthread_attr_destroy, pthread_attr_destroy);
 
 int

lib/libkse/thread/thr_attr_get_np.c

@@ -31,6 +31,9 @@
 #include <pthread_np.h>
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(_pthread_attr_get_np);
+LT10_COMPAT_DEFAULT(pthread_attr_get_np);
+
 __weak_reference(_pthread_attr_get_np, pthread_attr_get_np);
 
 int

lib/libkse/thread/thr_attr_getdetachstate.c

@@ -35,6 +35,9 @@
 #include <pthread.h>
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(_pthread_attr_getdetachstate);
+LT10_COMPAT_DEFAULT(pthread_attr_getdetachstate);
+
 __weak_reference(_pthread_attr_getdetachstate, pthread_attr_getdetachstate);
 
 int

lib/libkse/thread/thr_attr_getguardsize.c

@@ -33,6 +33,9 @@
 #include <pthread.h>
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(_pthread_attr_getguardsize);
+LT10_COMPAT_DEFAULT(pthread_attr_getguardsize);
+
 __weak_reference(_pthread_attr_getguardsize, pthread_attr_getguardsize);
 
 int

lib/libkse/thread/thr_attr_getinheritsched.c

@@ -35,6 +35,9 @@
 #include <pthread.h>
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(_pthread_attr_getinheritsched);
+LT10_COMPAT_DEFAULT(pthread_attr_getinheritsched);
+
 __weak_reference(_pthread_attr_getinheritsched, pthread_attr_getinheritsched);
 
 int

lib/libkse/thread/thr_attr_getschedparam.c

@@ -35,6 +35,9 @@
 #include <pthread.h>
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(_pthread_attr_getschedparam);
+LT10_COMPAT_DEFAULT(pthread_attr_getschedparam);
+
 __weak_reference(_pthread_attr_getschedparam, pthread_attr_getschedparam);
 
 int

lib/libkse/thread/thr_attr_getschedpolicy.c

@@ -35,6 +35,9 @@
 #include <pthread.h>
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(_pthread_attr_getschedpolicy);
+LT10_COMPAT_DEFAULT(pthread_attr_getschedpolicy);
+
 __weak_reference(_pthread_attr_getschedpolicy, pthread_attr_getschedpolicy);
 
 int

lib/libkse/thread/thr_attr_getscope.c

@@ -35,6 +35,9 @@
 #include <pthread.h>
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(_pthread_attr_getscope);
+LT10_COMPAT_DEFAULT(pthread_attr_getscope);
+
 __weak_reference(_pthread_attr_getscope, pthread_attr_getscope);
 
 int

lib/libkse/thread/thr_attr_getstack.c

@@ -35,6 +35,9 @@
 #include <pthread.h>
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(_pthread_attr_getstack);
+LT10_COMPAT_DEFAULT(pthread_attr_getstack);
+
 __weak_reference(_pthread_attr_getstack, pthread_attr_getstack);
 
 int

lib/libkse/thread/thr_attr_getstackaddr.c

@@ -35,6 +35,9 @@
 #include <pthread.h>
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(_pthread_attr_getstackaddr);
+LT10_COMPAT_DEFAULT(pthread_attr_getstackaddr);
+
 __weak_reference(_pthread_attr_getstackaddr, pthread_attr_getstackaddr);
 
 int

lib/libkse/thread/thr_attr_getstacksize.c

@@ -35,6 +35,9 @@
 #include <pthread.h>
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(_pthread_attr_getstacksize);
+LT10_COMPAT_DEFAULT(pthread_attr_getstacksize);
+
 __weak_reference(_pthread_attr_getstacksize, pthread_attr_getstacksize);
 
 int

lib/libkse/thread/thr_attr_init.c

@@ -37,6 +37,9 @@
 #include <pthread.h>
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(_pthread_attr_init);
+LT10_COMPAT_DEFAULT(pthread_attr_init);
+
 __weak_reference(_pthread_attr_init, pthread_attr_init);
 
 int

lib/libkse/thread/thr_attr_setcreatesuspend_np.c

@@ -35,6 +35,9 @@
 #include <pthread.h>
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(_pthread_attr_setcreatesuspend_np);
+LT10_COMPAT_DEFAULT(pthread_attr_setcreatesuspend_np);
+
 __weak_reference(_pthread_attr_setcreatesuspend_np, pthread_attr_setcreatesuspend_np);
 
 int

lib/libkse/thread/thr_attr_setdetachstate.c

@@ -35,6 +35,9 @@
 #include <pthread.h>
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(_pthread_attr_setdetachstate);
+LT10_COMPAT_DEFAULT(pthread_attr_setdetachstate);
+
 __weak_reference(_pthread_attr_setdetachstate, pthread_attr_setdetachstate);
 
 int

lib/libkse/thread/thr_attr_setguardsize.c

@@ -34,6 +34,9 @@
 #include <pthread.h>
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(_pthread_attr_setguardsize);
+LT10_COMPAT_DEFAULT(pthread_attr_setguardsize);
+
 __weak_reference(_pthread_attr_setguardsize, pthread_attr_setguardsize);
 
 int

lib/libkse/thread/thr_attr_setinheritsched.c

@@ -35,6 +35,9 @@
 #include <pthread.h>
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(_pthread_attr_setinheritsched);
+LT10_COMPAT_DEFAULT(pthread_attr_setinheritsched);
+
 __weak_reference(_pthread_attr_setinheritsched, pthread_attr_setinheritsched);
 
 int

lib/libkse/thread/thr_attr_setschedparam.c

@@ -35,6 +35,9 @@
 #include <pthread.h>
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(_pthread_attr_setschedparam);
+LT10_COMPAT_DEFAULT(pthread_attr_setschedparam);
+
 __weak_reference(_pthread_attr_setschedparam, pthread_attr_setschedparam);
 
 int

lib/libkse/thread/thr_attr_setschedpolicy.c

@@ -35,6 +35,9 @@
 #include <pthread.h>
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(_pthread_attr_setschedpolicy);
+LT10_COMPAT_DEFAULT(pthread_attr_setschedpolicy);
+
 __weak_reference(_pthread_attr_setschedpolicy, pthread_attr_setschedpolicy);
 
 int

lib/libkse/thread/thr_attr_setscope.c

@@ -35,6 +35,9 @@
 #include <pthread.h>
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(_pthread_attr_setscope);
+LT10_COMPAT_DEFAULT(pthread_attr_setscope);
+
 __weak_reference(_pthread_attr_setscope, pthread_attr_setscope);
 
 int

lib/libkse/thread/thr_attr_setstack.c

@@ -35,6 +35,9 @@
 #include <pthread.h>
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(_pthread_attr_setstack);
+LT10_COMPAT_DEFAULT(pthread_attr_setstack);
+
 __weak_reference(_pthread_attr_setstack, pthread_attr_setstack);
 
 int

lib/libkse/thread/thr_attr_setstackaddr.c

@@ -35,6 +35,9 @@
 #include <pthread.h>
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(_pthread_attr_setstackaddr);
+LT10_COMPAT_DEFAULT(pthread_attr_setstackaddr);
+
 __weak_reference(_pthread_attr_setstackaddr, pthread_attr_setstackaddr);
 
 int

lib/libkse/thread/thr_attr_setstacksize.c

@@ -35,6 +35,9 @@
 #include <pthread.h>
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(_pthread_attr_setstacksize);
+LT10_COMPAT_DEFAULT(pthread_attr_setstacksize);
+
 __weak_reference(_pthread_attr_setstacksize, pthread_attr_setstacksize);
 
 int

lib/libkse/thread/thr_barrier.c

@@ -33,6 +33,13 @@
 #include "un-namespace.h"
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(_pthread_barrier_init);
+LT10_COMPAT_DEFAULT(pthread_barrier_init);
+LT10_COMPAT_PRIVATE(_pthread_barrier_wait);
+LT10_COMPAT_DEFAULT(pthread_barrier_wait);
+LT10_COMPAT_PRIVATE(_pthread_barrier_destroy);
+LT10_COMPAT_DEFAULT(pthread_barrier_destroy);
+
 __weak_reference(_pthread_barrier_init,		pthread_barrier_init);
 __weak_reference(_pthread_barrier_wait,		pthread_barrier_wait);
 __weak_reference(_pthread_barrier_destroy,	pthread_barrier_destroy);

lib/libkse/thread/thr_barrierattr.c

@@ -33,6 +33,15 @@
 #include <pthread.h>
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(_pthread_barrierattr_destroy);
+LT10_COMPAT_DEFAULT(pthread_barrierattr_destroy);
+LT10_COMPAT_PRIVATE(_pthread_barrierattr_init);
+LT10_COMPAT_DEFAULT(pthread_barrierattr_init);
+LT10_COMPAT_PRIVATE(_pthread_barrierattr_setpshared);
+LT10_COMPAT_DEFAULT(pthread_barrierattr_setpshared);
+LT10_COMPAT_PRIVATE(_pthread_barrierattr_getpshared);
+LT10_COMPAT_DEFAULT(pthread_barrierattr_getpshared);
+
 __weak_reference(_pthread_barrierattr_destroy, pthread_barrierattr_destroy);
 __weak_reference(_pthread_barrierattr_init, pthread_barrierattr_init);
 __weak_reference(_pthread_barrierattr_setpshared,

lib/libkse/thread/thr_cancel.c

@@ -6,6 +6,15 @@
 #include <pthread.h>
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(_pthread_cancel);
+LT10_COMPAT_DEFAULT(pthread_cancel);
+LT10_COMPAT_PRIVATE(_pthread_setcancelstate);
+LT10_COMPAT_DEFAULT(pthread_setcancelstate);
+LT10_COMPAT_PRIVATE(_pthread_setcanceltype);
+LT10_COMPAT_DEFAULT(pthread_setcanceltype);
+LT10_COMPAT_PRIVATE(_pthread_testcancel);
+LT10_COMPAT_DEFAULT(pthread_testcancel);
+
 __weak_reference(_pthread_cancel, pthread_cancel);
 __weak_reference(_pthread_setcancelstate, pthread_setcancelstate);
 __weak_reference(_pthread_setcanceltype, pthread_setcanceltype);

lib/libkse/thread/thr_clean.c

@@ -37,6 +37,11 @@
 #include <pthread.h>
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(_pthread_cleanup_push);
+LT10_COMPAT_DEFAULT(pthread_cleanup_push);
+LT10_COMPAT_PRIVATE(_pthread_cleanup_pop);
+LT10_COMPAT_DEFAULT(pthread_cleanup_pop);
+
 __weak_reference(_pthread_cleanup_push, pthread_cleanup_push);
 __weak_reference(_pthread_cleanup_pop, pthread_cleanup_pop);
 

lib/libkse/thread/thr_close.c

@@ -39,6 +39,9 @@
 #include <pthread.h>
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(__close);
+LT10_COMPAT_DEFAULT(close);
+
 __weak_reference(__close, close);
 
 int

lib/libkse/thread/thr_concurrency.c

@@ -33,6 +33,11 @@
 
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(_pthread_getconcurrency);
+LT10_COMPAT_DEFAULT(pthread_getconcurrency);
+LT10_COMPAT_PRIVATE(_pthread_setconcurrency);
+LT10_COMPAT_DEFAULT(pthread_setconcurrency);
+
 /*#define DEBUG_CONCURRENCY */
 #ifdef DEBUG_CONCURRENCY
 #define DBG_MSG		stdout_debug

lib/libkse/thread/thr_cond.c

@@ -37,6 +37,21 @@
 #include <pthread.h>
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(__pthread_cond_wait);
+LT10_COMPAT_PRIVATE(_pthread_cond_wait);
+LT10_COMPAT_DEFAULT(pthread_cond_wait);
+LT10_COMPAT_PRIVATE(__pthread_cond_timedwait);
+LT10_COMPAT_PRIVATE(_pthread_cond_timedwait);
+LT10_COMPAT_DEFAULT(pthread_cond_timedwait);
+LT10_COMPAT_PRIVATE(_pthread_cond_init);
+LT10_COMPAT_DEFAULT(pthread_cond_init);
+LT10_COMPAT_PRIVATE(_pthread_cond_destroy);
+LT10_COMPAT_DEFAULT(pthread_cond_destroy);
+LT10_COMPAT_PRIVATE(_pthread_cond_signal);
+LT10_COMPAT_DEFAULT(pthread_cond_signal);
+LT10_COMPAT_PRIVATE(_pthread_cond_broadcast);
+LT10_COMPAT_DEFAULT(pthread_cond_broadcast);
+
 #define	THR_IN_CONDQ(thr)	(((thr)->sflags & THR_FLAGS_IN_SYNCQ) != 0)
 #define	THR_CONDQ_SET(thr)	(thr)->sflags |= THR_FLAGS_IN_SYNCQ
 #define	THR_CONDQ_CLEAR(thr)	(thr)->sflags &= ~THR_FLAGS_IN_SYNCQ

lib/libkse/thread/thr_condattr_destroy.c

@@ -36,6 +36,9 @@
 #include <pthread.h>
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(_pthread_condattr_destroy);
+LT10_COMPAT_DEFAULT(pthread_condattr_destroy);
+
 __weak_reference(_pthread_condattr_destroy, pthread_condattr_destroy);
 
 int

lib/libkse/thread/thr_condattr_init.c

@@ -37,6 +37,9 @@
 #include <pthread.h>
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(_pthread_condattr_init);
+LT10_COMPAT_DEFAULT(pthread_condattr_init);
+
 __weak_reference(_pthread_condattr_init, pthread_condattr_init);
 
 int

lib/libkse/thread/thr_connect.c

@@ -32,6 +32,9 @@ __FBSDID("$FreeBSD$");
 #include <pthread.h>
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(__connect);
+LT10_COMPAT_DEFAULT(connect);
+
 __weak_reference(__connect, connect);
 
 int

lib/libkse/thread/thr_creat.c

@@ -33,6 +33,9 @@
 #include <pthread.h>
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(___creat);
+LT10_COMPAT_DEFAULT(creat);
+
 extern int __creat(const char *, mode_t);
 
 __weak_reference(___creat, creat);

lib/libkse/thread/thr_create.c

@@ -44,6 +44,9 @@
 #include "thr_private.h"
 #include "libc_private.h"
 
+LT10_COMPAT_PRIVATE(_pthread_create);
+LT10_COMPAT_DEFAULT(pthread_create);
+
 static void free_thread(struct pthread *curthread, struct pthread *thread);
 static int  create_stack(struct pthread_attr *pattr);
 static void free_stack(struct pthread_attr *pattr);

lib/libkse/thread/thr_detach.c

@@ -37,6 +37,9 @@
 #include <pthread.h>
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(_pthread_detach);
+LT10_COMPAT_DEFAULT(pthread_detach);
+
 __weak_reference(_pthread_detach, pthread_detach);
 
 int

lib/libkse/thread/thr_equal.c

@@ -34,6 +34,9 @@
 #include <pthread.h>
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(_pthread_equal);
+LT10_COMPAT_DEFAULT(pthread_equal);
+
 __weak_reference(_pthread_equal, pthread_equal);
 
 int

lib/libkse/thread/thr_execve.c

@@ -34,6 +34,9 @@
 #include <unistd.h>
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(_execve);
+LT10_COMPAT_DEFAULT(execve);
+
 __weak_reference(_execve, execve);
 
 int 

lib/libkse/thread/thr_exit.c

@@ -40,6 +40,9 @@
 #include <pthread.h>
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(_pthread_exit);
+LT10_COMPAT_DEFAULT(pthread_exit);
+
 void	_pthread_exit(void *status);
 
 __weak_reference(_pthread_exit, pthread_exit);

lib/libkse/thread/thr_fcntl.c

@@ -38,6 +38,9 @@
 #include <pthread.h>
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(__fcntl);
+LT10_COMPAT_DEFAULT(fcntl);
+
 __weak_reference(__fcntl, fcntl);
 
 int

lib/libkse/thread/thr_fork.c

@@ -43,6 +43,9 @@
 #include "libc_private.h"
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(_fork);
+LT10_COMPAT_DEFAULT(fork);
+
 __weak_reference(_fork, fork);
 
 pid_t

lib/libkse/thread/thr_fsync.c

@@ -35,6 +35,9 @@
 #include <pthread.h>
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(__fsync);
+LT10_COMPAT_DEFAULT(fsync);
+
 __weak_reference(__fsync, fsync);
 
 int

lib/libkse/thread/thr_getprio.c

@@ -35,6 +35,9 @@
 #include <pthread.h>
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(_pthread_getprio);
+LT10_COMPAT_DEFAULT(pthread_getprio);
+
 __weak_reference(_pthread_getprio, pthread_getprio);
 
 int

lib/libkse/thread/thr_getschedparam.c

@@ -35,6 +35,9 @@
 #include <pthread.h>
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(_pthread_getschedparam);
+LT10_COMPAT_DEFAULT(pthread_getschedparam);
+
 __weak_reference(_pthread_getschedparam, pthread_getschedparam);
 
 int

lib/libkse/thread/thr_info.c

@@ -44,6 +44,9 @@
 #define NELEMENTS(arr)	(sizeof(arr) / sizeof(arr[0]))
 #endif
 
+LT10_COMPAT_PRIVATE(_pthread_set_name_np);
+LT10_COMPAT_DEFAULT(pthread_set_name_np);
+
 static void	dump_thread(int fd, pthread_t pthread, int long_version);
 
 __weak_reference(_pthread_set_name_np, pthread_set_name_np);

lib/libkse/thread/thr_init.c

@@ -69,6 +69,11 @@
 #include "libc_private.h"
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(_libkse_debug);
+LT10_COMPAT_PRIVATE(_thread_activated);
+LT10_COMPAT_PRIVATE(_thread_active_threads);
+LT10_COMPAT_PRIVATE(_thread_list);
+
 int	__pthread_cond_wait(pthread_cond_t *, pthread_mutex_t *);
 int	__pthread_mutex_lock(pthread_mutex_t *);
 int	__pthread_mutex_trylock(pthread_mutex_t *);

lib/libkse/thread/thr_join.c

@@ -35,6 +35,9 @@
 #include <pthread.h>
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(_pthread_join);
+LT10_COMPAT_DEFAULT(pthread_join);
+
 __weak_reference(_pthread_join, pthread_join);
 
 int

lib/libkse/thread/thr_kill.c

@@ -36,6 +36,9 @@
 #include <pthread.h>
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(_pthread_kill);
+LT10_COMPAT_DEFAULT(pthread_kill);
+
 __weak_reference(_pthread_kill, pthread_kill);
 
 int

lib/libkse/thread/thr_main_np.c

@@ -31,6 +31,9 @@
 #include <pthread_np.h>
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(_pthread_main_np);
+LT10_COMPAT_DEFAULT(pthread_main_np);
+
 __weak_reference(_pthread_main_np, pthread_main_np);
 
 /*

lib/libkse/thread/thr_mattr_init.c

@@ -37,6 +37,9 @@
 #include <pthread.h>
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(_pthread_mutexattr_init);
+LT10_COMPAT_DEFAULT(pthread_mutexattr_init);
+
 __weak_reference(_pthread_mutexattr_init, pthread_mutexattr_init);
 
 int

lib/libkse/thread/thr_mattr_kind_np.c

@@ -35,6 +35,15 @@
 #include <pthread.h>
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(_pthread_mutexattr_setkind_np);
+LT10_COMPAT_DEFAULT(pthread_mutexattr_setkind_np);
+LT10_COMPAT_PRIVATE(_pthread_mutexattr_getkind_np);
+LT10_COMPAT_DEFAULT(pthread_mutexattr_getkind_np);
+LT10_COMPAT_PRIVATE(_pthread_mutexattr_gettype);
+LT10_COMPAT_DEFAULT(pthread_mutexattr_gettype);
+LT10_COMPAT_PRIVATE(_pthread_mutexattr_settype);
+LT10_COMPAT_DEFAULT(pthread_mutexattr_settype);
+
 __weak_reference(_pthread_mutexattr_setkind_np, pthread_mutexattr_setkind_np);
 __weak_reference(_pthread_mutexattr_getkind_np, pthread_mutexattr_getkind_np);
 __weak_reference(_pthread_mutexattr_gettype, pthread_mutexattr_gettype);

lib/libkse/thread/thr_msync.c

@@ -11,6 +11,9 @@
 #include <pthread.h>
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(__msync);
+LT10_COMPAT_DEFAULT(msync);
+
 __weak_reference(__msync, msync);
 
 int

lib/libkse/thread/thr_multi_np.c

@@ -34,6 +34,11 @@
 #include <pthread.h>
 #include <pthread_np.h>
 
+#include "thr_private.h"
+
+LT10_COMPAT_PRIVATE(_pthread_multi_np);
+LT10_COMPAT_DEFAULT(pthread_multi_np);
+
 __weak_reference(_pthread_multi_np, pthread_multi_np);
 
 int

lib/libkse/thread/thr_mutex.c

@@ -91,6 +91,23 @@ static struct pthread_mutex_attr	static_mutex_attr =
     PTHREAD_MUTEXATTR_STATIC_INITIALIZER;
 static pthread_mutexattr_t		static_mattr = &static_mutex_attr;
 
+LT10_COMPAT_PRIVATE(__pthread_mutex_init);
+LT10_COMPAT_PRIVATE(_pthread_mutex_init);
+LT10_COMPAT_DEFAULT(pthread_mutex_init);
+LT10_COMPAT_PRIVATE(__pthread_mutex_lock);
+LT10_COMPAT_PRIVATE(_pthread_mutex_lock);
+LT10_COMPAT_DEFAULT(pthread_mutex_lock);
+LT10_COMPAT_PRIVATE(__pthread_mutex_timedlock);
+LT10_COMPAT_PRIVATE(_pthread_mutex_timedlock);
+LT10_COMPAT_DEFAULT(pthread_mutex_timedlock);
+LT10_COMPAT_PRIVATE(__pthread_mutex_trylock);
+LT10_COMPAT_PRIVATE(_pthread_mutex_trylock);
+LT10_COMPAT_DEFAULT(pthread_mutex_trylock);
+LT10_COMPAT_PRIVATE(_pthread_mutex_destroy);
+LT10_COMPAT_DEFAULT(pthread_mutex_destroy);
+LT10_COMPAT_PRIVATE(_pthread_mutex_unlock);
+LT10_COMPAT_DEFAULT(pthread_mutex_unlock);
+
 /* Single underscore versions provided for libc internal usage: */
 __weak_reference(__pthread_mutex_init, pthread_mutex_init);
 __weak_reference(__pthread_mutex_lock, pthread_mutex_lock);

lib/libkse/thread/thr_mutex_prioceiling.c

@@ -37,6 +37,15 @@
 #include <pthread.h>
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(_pthread_mutexattr_getprioceiling);
+LT10_COMPAT_DEFAULT(pthread_mutexattr_getprioceiling);
+LT10_COMPAT_PRIVATE(_pthread_mutexattr_setprioceiling);
+LT10_COMPAT_DEFAULT(pthread_mutexattr_setprioceiling);
+LT10_COMPAT_PRIVATE(_pthread_mutex_getprioceiling);
+LT10_COMPAT_DEFAULT(pthread_mutex_getprioceiling);
+LT10_COMPAT_PRIVATE(_pthread_mutex_setprioceiling);
+LT10_COMPAT_DEFAULT(pthread_mutex_setprioceiling);
+
 __weak_reference(_pthread_mutexattr_getprioceiling, pthread_mutexattr_getprioceiling);
 __weak_reference(_pthread_mutexattr_setprioceiling, pthread_mutexattr_setprioceiling);
 __weak_reference(_pthread_mutex_getprioceiling, pthread_mutex_getprioceiling);

lib/libkse/thread/thr_mutex_protocol.c

@@ -37,6 +37,11 @@
 #include <pthread.h>
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(_pthread_mutexattr_getprotocol);
+LT10_COMPAT_DEFAULT(pthread_mutexattr_getprotocol);
+LT10_COMPAT_PRIVATE(_pthread_mutexattr_setprotocol);
+LT10_COMPAT_DEFAULT(pthread_mutexattr_setprotocol);
+
 __weak_reference(_pthread_mutexattr_getprotocol, pthread_mutexattr_getprotocol);
 __weak_reference(_pthread_mutexattr_setprotocol, pthread_mutexattr_setprotocol);
 

lib/libkse/thread/thr_mutexattr_destroy.c

@@ -36,6 +36,9 @@
 #include <pthread.h>
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(_pthread_mutexattr_destroy);
+LT10_COMPAT_DEFAULT(pthread_mutexattr_destroy);
+
 __weak_reference(_pthread_mutexattr_destroy, pthread_mutexattr_destroy);
 
 int

lib/libkse/thread/thr_nanosleep.c

@@ -36,6 +36,10 @@
 #include <pthread.h>
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(__nanosleep);
+LT10_COMPAT_PRIVATE(_nanosleep);
+LT10_COMPAT_DEFAULT(nanosleep);
+
 __weak_reference(__nanosleep, nanosleep);
 
 int

lib/libkse/thread/thr_once.c

@@ -36,6 +36,9 @@
 #include "un-namespace.h"
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(_pthread_once);
+LT10_COMPAT_DEFAULT(pthread_once);
+
 __weak_reference(_pthread_once, pthread_once);
 
 #define ONCE_NEVER_DONE		PTHREAD_NEEDS_INIT

lib/libkse/thread/thr_open.c

@@ -40,6 +40,9 @@
 #include <pthread.h>
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(__open);
+LT10_COMPAT_DEFAULT(open);
+
 __weak_reference(__open, open);
 
 int

lib/libkse/thread/thr_pause.c

@@ -35,6 +35,9 @@
 
 extern int __pause(void);
 
+LT10_COMPAT_PRIVATE(_pause);
+LT10_COMPAT_DEFAULT(pause);
+
 __weak_reference(_pause, pause);
 
 int

lib/libkse/thread/thr_poll.c

@@ -41,6 +41,9 @@
 #include <pthread.h>
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(__poll);
+LT10_COMPAT_DEFAULT(poll);
+
 __weak_reference(__poll, poll);
 
 int

lib/libkse/thread/thr_private.h

@@ -59,6 +59,40 @@
 #include "pthread_md.h"
 #endif
 
+/*
+ * Unfortunately, libpthread had symbol versioning before libc.
+ * But now libc has symbol versioning, we need to occupy the
+ * same version namespace in order to override some libc functions.
+ * So in order to avoid breaking binaries requiring symbols from
+ * LIBTHREAD_1_0, we need to provide a compatible interface for
+ * those symbols.
+ */
+#if defined(SYMBOL_VERSIONING) && defined(PIC)
+#define	SYM_LT10(sym)			__CONCAT(sym, _lt10)
+#define	SYM_FB10(sym)			__CONCAT(sym, _fb10)
+#define	SYM_FBP10(sym)			__CONCAT(sym, _fbp10)
+#define	WEAK_REF(sym, alias)		__weak_reference(sym, alias)
+#define	SYM_COMPAT(sym, impl, ver)	__sym_compat(sym, impl, ver)
+#define	SYM_DEFAULT(sym, impl, ver)	__sym_default(sym, impl, ver)
+
+#define	LT10_COMPAT(sym)				\
+	WEAK_REF(sym, SYM_LT10(sym));			\
+	SYM_COMPAT(sym, SYM_LT10(sym), LIBTHREAD_1_0)
+
+#define	LT10_COMPAT_DEFAULT(sym)			\
+	LT10_COMPAT(sym);				\
+	WEAK_REF(sym, SYM_FB10(sym));			\
+	SYM_DEFAULT(sym, SYM_FB10(sym), FBSD_1.0)
+
+#define	LT10_COMPAT_PRIVATE(sym)			\
+	LT10_COMPAT(sym);				\
+	WEAK_REF(sym, SYM_FBP10(sym));			\
+	SYM_DEFAULT(sym, SYM_FBP10(sym), FBSDprivate)
+#else
+#define	LT10_COMPAT_DEFAULT(sym)
+#define	LT10_COMPAT_PRIVATE(sym)
+#endif
+
 /*
  * Evaluate the storage class specifier.
  */

lib/libkse/thread/thr_pselect.c

@@ -40,6 +40,9 @@ __FBSDID("$FreeBSD$");
 extern int __pselect(int count, fd_set *rfds, fd_set *wfds, fd_set *efds, 
 		const struct timespec *timo, const sigset_t *mask);
 
+LT10_COMPAT_PRIVATE(_pselect);
+LT10_COMPAT_DEFAULT(pselect);
+
 __weak_reference(_pselect, pselect);
 
 int 

lib/libkse/thread/thr_pspinlock.c

@@ -37,6 +37,17 @@
 
 #define SPIN_COUNT 10000
 
+LT10_COMPAT_PRIVATE(_pthread_spin_init);
+LT10_COMPAT_DEFAULT(pthread_spin_init);
+LT10_COMPAT_PRIVATE(_pthread_spin_destroy);
+LT10_COMPAT_DEFAULT(pthread_spin_destroy);
+LT10_COMPAT_PRIVATE(_pthread_spin_trylock);
+LT10_COMPAT_DEFAULT(pthread_spin_trylock);
+LT10_COMPAT_PRIVATE(_pthread_spin_lock);
+LT10_COMPAT_DEFAULT(pthread_spin_lock);
+LT10_COMPAT_PRIVATE(_pthread_spin_unlock);
+LT10_COMPAT_DEFAULT(pthread_spin_unlock);
+
 __weak_reference(_pthread_spin_init, pthread_spin_init);
 __weak_reference(_pthread_spin_destroy, pthread_spin_destroy);
 __weak_reference(_pthread_spin_trylock, pthread_spin_trylock);

lib/libkse/thread/thr_raise.c

@@ -33,6 +33,9 @@
 #include <errno.h>
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(_raise);
+LT10_COMPAT_DEFAULT(raise);
+
 __weak_reference(_raise, raise);
 
 int

lib/libkse/thread/thr_read.c

@@ -40,6 +40,9 @@
 #include <pthread.h>
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(__read);
+LT10_COMPAT_DEFAULT(read);
+
 __weak_reference(__read, read);
 
 ssize_t

lib/libkse/thread/thr_readv.c

@@ -40,6 +40,9 @@
 #include <pthread.h>
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(__readv);
+LT10_COMPAT_DEFAULT(readv);
+
 __weak_reference(__readv, readv);
 
 ssize_t

lib/libkse/thread/thr_resume_np.c

@@ -37,6 +37,11 @@
 
 static struct kse_mailbox *resume_common(struct pthread *);
 
+LT10_COMPAT_PRIVATE(_pthread_resume_np);
+LT10_COMPAT_DEFAULT(pthread_resume_np);
+LT10_COMPAT_PRIVATE(_pthread_resume_all_np);
+LT10_COMPAT_DEFAULT(pthread_resume_all_np);
+
 __weak_reference(_pthread_resume_np, pthread_resume_np);
 __weak_reference(_pthread_resume_all_np, pthread_resume_all_np);
 

lib/libkse/thread/thr_rwlock.c

@@ -38,6 +38,25 @@
 /* maximum number of times a read lock may be obtained */
 #define	MAX_READ_LOCKS		(INT_MAX - 1)
 
+LT10_COMPAT_PRIVATE(_pthread_rwlock_destroy);
+LT10_COMPAT_DEFAULT(pthread_rwlock_destroy);
+LT10_COMPAT_PRIVATE(_pthread_rwlock_init);
+LT10_COMPAT_DEFAULT(pthread_rwlock_init);
+LT10_COMPAT_PRIVATE(_pthread_rwlock_rdlock);
+LT10_COMPAT_DEFAULT(pthread_rwlock_rdlock);
+LT10_COMPAT_PRIVATE(_pthread_rwlock_timedrdlock);
+LT10_COMPAT_DEFAULT(pthread_rwlock_timedrdlock);
+LT10_COMPAT_PRIVATE(_pthread_rwlock_tryrdlock);
+LT10_COMPAT_DEFAULT(pthread_rwlock_tryrdlock);
+LT10_COMPAT_PRIVATE(_pthread_rwlock_trywrlock);
+LT10_COMPAT_DEFAULT(pthread_rwlock_trywrlock);
+LT10_COMPAT_PRIVATE(_pthread_rwlock_unlock);
+LT10_COMPAT_DEFAULT(pthread_rwlock_unlock);
+LT10_COMPAT_PRIVATE(_pthread_rwlock_wrlock);
+LT10_COMPAT_DEFAULT(pthread_rwlock_wrlock);
+LT10_COMPAT_PRIVATE(_pthread_rwlock_timedwrlock);
+LT10_COMPAT_DEFAULT(pthread_rwlock_timedwrlock);
+
 __weak_reference(_pthread_rwlock_destroy, pthread_rwlock_destroy);
 __weak_reference(_pthread_rwlock_init, pthread_rwlock_init);
 __weak_reference(_pthread_rwlock_rdlock, pthread_rwlock_rdlock);

lib/libkse/thread/thr_rwlockattr.c

@@ -32,6 +32,15 @@
 #include <pthread.h>
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(_pthread_rwlockattr_destroy);
+LT10_COMPAT_DEFAULT(pthread_rwlockattr_destroy);
+LT10_COMPAT_PRIVATE(_pthread_rwlockattr_getpshared);
+LT10_COMPAT_DEFAULT(pthread_rwlockattr_getpshared);
+LT10_COMPAT_PRIVATE(_pthread_rwlockattr_init);
+LT10_COMPAT_DEFAULT(pthread_rwlockattr_init);
+LT10_COMPAT_PRIVATE(_pthread_rwlockattr_setpshared);
+LT10_COMPAT_DEFAULT(pthread_rwlockattr_setpshared);
+
 __weak_reference(_pthread_rwlockattr_destroy, pthread_rwlockattr_destroy);
 __weak_reference(_pthread_rwlockattr_getpshared, pthread_rwlockattr_getpshared);
 __weak_reference(_pthread_rwlockattr_init, pthread_rwlockattr_init);

lib/libkse/thread/thr_select.c

@@ -43,6 +43,9 @@
 #include <pthread.h>
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(__select);
+LT10_COMPAT_DEFAULT(select);
+
 __weak_reference(__select, select);
 
 int 

lib/libkse/thread/thr_self.c

@@ -34,6 +34,9 @@
 #include <pthread.h>
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(_pthread_self);
+LT10_COMPAT_DEFAULT(pthread_self);
+
 __weak_reference(_pthread_self, pthread_self);
 
 pthread_t

lib/libkse/thread/thr_sem.c

@@ -43,6 +43,14 @@
 #include "libc_private.h"
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(_sem_init);
+LT10_COMPAT_DEFAULT(sem_init);
+LT10_COMPAT_PRIVATE(_sem_wait);
+LT10_COMPAT_DEFAULT(sem_wait);
+LT10_COMPAT_PRIVATE(_sem_timedwait);
+LT10_COMPAT_DEFAULT(sem_timedwait);
+LT10_COMPAT_PRIVATE(_sem_post);
+LT10_COMPAT_DEFAULT(sem_post);
 
 extern int pthread_cond_wait(pthread_cond_t *, pthread_mutex_t *);
 extern int pthread_cond_timedwait(pthread_cond_t *, pthread_mutex_t *,

lib/libkse/thread/thr_setprio.c

@@ -34,6 +34,9 @@
 #include <pthread.h>
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(_pthread_setprio);
+LT10_COMPAT_DEFAULT(pthread_setprio);
+
 __weak_reference(_pthread_setprio, pthread_setprio);
 
 int

lib/libkse/thread/thr_setschedparam.c

@@ -36,6 +36,9 @@
 #include <pthread.h>
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(_pthread_setschedparam);
+LT10_COMPAT_DEFAULT(pthread_setschedparam);
+
 __weak_reference(_pthread_setschedparam, pthread_setschedparam);
 
 int

lib/libkse/thread/thr_sigaction.c

@@ -36,6 +36,9 @@
 #include <pthread.h>
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(_sigaction);
+LT10_COMPAT_DEFAULT(sigaction);
+
 __weak_reference(_sigaction, sigaction);
 
 int

lib/libkse/thread/thr_sigaltstack.c

@@ -31,6 +31,9 @@ __FBSDID("$FreeBSD$");
 #include <signal.h>
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(_sigaltstack);
+LT10_COMPAT_DEFAULT(sigaltstack);
+
 __weak_reference(_sigaltstack, sigaltstack);
 
 int

lib/libkse/thread/thr_sigmask.c

@@ -40,6 +40,9 @@
 #include <pthread.h>
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(_pthread_sigmask);
+LT10_COMPAT_DEFAULT(pthread_sigmask);
+
 __weak_reference(_pthread_sigmask, pthread_sigmask);
 
 int

lib/libkse/thread/thr_sigpending.c

@@ -39,6 +39,9 @@
 #include <pthread.h>
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(_sigpending);
+LT10_COMPAT_DEFAULT(sigpending);
+
 __weak_reference(_sigpending, sigpending);
 
 int

lib/libkse/thread/thr_sigprocmask.c

@@ -39,6 +39,9 @@
 #include <pthread.h>
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(_sigprocmask);
+LT10_COMPAT_DEFAULT(sigprocmask);
+
 __weak_reference(_sigprocmask, sigprocmask);
 
 int

lib/libkse/thread/thr_sigsuspend.c

@@ -41,6 +41,10 @@
 
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(__sigsuspend);
+LT10_COMPAT_PRIVATE(_sigsuspend);
+LT10_COMPAT_DEFAULT(sigsuspend);
+
 __weak_reference(__sigsuspend, sigsuspend);
 
 int

lib/libkse/thread/thr_sigwait.c

@@ -39,6 +39,16 @@
 #include <pthread.h>
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(__sigwait);
+LT10_COMPAT_PRIVATE(_sigwait);
+LT10_COMPAT_DEFAULT(sigwait);
+LT10_COMPAT_PRIVATE(__sigtimedwait);
+LT10_COMPAT_PRIVATE(_sigtimedwait);
+LT10_COMPAT_DEFAULT(sigtimedwait);
+LT10_COMPAT_PRIVATE(__sigwaitinfo);
+LT10_COMPAT_PRIVATE(_sigwaitinfo);
+LT10_COMPAT_DEFAULT(sigwaitinfo);
+
 __weak_reference(__sigwait, sigwait);
 __weak_reference(__sigtimedwait, sigtimedwait);
 __weak_reference(__sigwaitinfo, sigwaitinfo);

lib/libkse/thread/thr_single_np.c

@@ -34,6 +34,11 @@
 #include <pthread.h>
 #include <pthread_np.h>
 
+#include "thr_private.h"
+
+LT10_COMPAT_PRIVATE(_pthread_single_np);
+LT10_COMPAT_DEFAULT(pthread_single_np);
+
 __weak_reference(_pthread_single_np, pthread_single_np);
 
 int _pthread_single_np()

lib/libkse/thread/thr_sleep.c

@@ -36,6 +36,11 @@
 extern unsigned int	__sleep(unsigned int);
 extern int		__usleep(useconds_t);
 
+LT10_COMPAT_PRIVATE(_sleep);
+LT10_COMPAT_DEFAULT(sleep);
+LT10_COMPAT_PRIVATE(_usleep);
+LT10_COMPAT_DEFAULT(usleep);
+
 __weak_reference(_sleep, sleep);
 __weak_reference(_usleep, usleep);
 

lib/libkse/thread/thr_spec.c

@@ -36,11 +36,27 @@
 #include <string.h>
 #include <errno.h>
 #include <pthread.h>
+
 #include "thr_private.h"
 
-/* Static variables: */
+
 struct pthread_key _thread_keytable[PTHREAD_KEYS_MAX];
 
+/*
+ * XXX - This breaks the linker if LT10_COMPAT_DEFAULT doesn't
+ * also include a weak reference to the default symbol.
+ */
+LT10_COMPAT_PRIVATE(_thread_keytable);
+
+LT10_COMPAT_PRIVATE(_pthread_key_create);
+LT10_COMPAT_DEFAULT(pthread_key_create);
+LT10_COMPAT_PRIVATE(_pthread_key_delete);
+LT10_COMPAT_DEFAULT(pthread_key_delete);
+LT10_COMPAT_PRIVATE(_pthread_getspecific);
+LT10_COMPAT_DEFAULT(pthread_getspecific);
+LT10_COMPAT_PRIVATE(_pthread_setspecific);
+LT10_COMPAT_DEFAULT(pthread_setspecific);
+
 __weak_reference(_pthread_key_create, pthread_key_create);
 __weak_reference(_pthread_key_delete, pthread_key_delete);
 __weak_reference(_pthread_getspecific, pthread_getspecific);

lib/libkse/thread/thr_spinlock.c

@@ -58,6 +58,10 @@ static struct spinlock_extra	extra[MAX_SPINLOCKS];
 static int			spinlock_count = 0;
 static int			initialized = 0;
 
+LT10_COMPAT_PRIVATE(_spinlock);
+LT10_COMPAT_PRIVATE(_spinlock_debug);
+LT10_COMPAT_PRIVATE(_spinunlock);
+
 /*
  * These are for compatability only.  Spinlocks of this type
  * are deprecated.

lib/libkse/thread/thr_suspend_np.c

@@ -37,6 +37,11 @@
 
 static void suspend_common(struct pthread *thread);
 
+LT10_COMPAT_PRIVATE(_pthread_suspend_np);
+LT10_COMPAT_DEFAULT(pthread_suspend_np);
+LT10_COMPAT_PRIVATE(_pthread_suspend_all_np);
+LT10_COMPAT_DEFAULT(pthread_suspend_all_np);
+
 __weak_reference(_pthread_suspend_np, pthread_suspend_np);
 __weak_reference(_pthread_suspend_all_np, pthread_suspend_all_np);
 

lib/libkse/thread/thr_switch_np.c

@@ -36,6 +36,10 @@
 #include <pthread_np.h>
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(_pthread_switch_add_np);
+LT10_COMPAT_DEFAULT(pthread_switch_add_np);
+LT10_COMPAT_PRIVATE(_pthread_switch_delete_np);
+LT10_COMPAT_DEFAULT(pthread_switch_delete_np);
 
 __weak_reference(_pthread_switch_add_np, pthread_switch_add_np);
 __weak_reference(_pthread_switch_delete_np, pthread_switch_delete_np);

lib/libkse/thread/thr_symbols.c

@@ -39,6 +39,24 @@
 
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(_thread_off_tcb);
+LT10_COMPAT_PRIVATE(_thread_off_tmbx);
+LT10_COMPAT_PRIVATE(_thread_off_next);
+LT10_COMPAT_PRIVATE(_thread_off_attr_flags);
+LT10_COMPAT_PRIVATE(_thread_off_kse);
+LT10_COMPAT_PRIVATE(_thread_off_kse_locklevel);
+LT10_COMPAT_PRIVATE(_thread_off_thr_locklevel);
+LT10_COMPAT_PRIVATE(_thread_off_linkmap);
+LT10_COMPAT_PRIVATE(_thread_off_tlsindex);
+LT10_COMPAT_PRIVATE(_thread_size_key);
+LT10_COMPAT_PRIVATE(_thread_off_key_allocated);
+LT10_COMPAT_PRIVATE(_thread_off_key_destructor);
+LT10_COMPAT_PRIVATE(_thread_max_keys);
+LT10_COMPAT_PRIVATE(_thread_off_dtv);
+LT10_COMPAT_PRIVATE(_thread_off_state);
+LT10_COMPAT_PRIVATE(_thread_state_running);
+LT10_COMPAT_PRIVATE(_thread_state_zoombie);
+
 /* A collection of symbols needed by debugger */
 
 /* int _libkse_debug */

lib/libkse/thread/thr_system.c

@@ -35,6 +35,9 @@
 
 extern int __system(const char *);
 
+LT10_COMPAT_PRIVATE(_system);
+LT10_COMPAT_DEFAULT(system);
+
 __weak_reference(_system, system);
 
 int

lib/libkse/thread/thr_tcdrain.c

@@ -35,6 +35,9 @@
 
 extern int __tcdrain(int);
 
+LT10_COMPAT_PRIVATE(_tcdrain);
+LT10_COMPAT_DEFAULT(tcdrain);
+
 __weak_reference(_tcdrain, tcdrain);
 
 int

lib/libkse/thread/thr_vfork.c

@@ -3,6 +3,11 @@
  */
 #include <unistd.h>
 
+#include "thr_private.h"
+
+LT10_COMPAT_PRIVATE(_vfork);
+LT10_COMPAT_DEFAULT(vfork);
+
 __weak_reference(_vfork, vfork);
 
 int

lib/libkse/thread/thr_wait.c

@@ -34,6 +34,9 @@
 
 extern int __wait(int *);
 
+LT10_COMPAT_PRIVATE(_wait);
+LT10_COMPAT_DEFAULT(wait);
+
 __weak_reference(_wait, wait);
 
 pid_t

lib/libkse/thread/thr_wait4.c

@@ -41,6 +41,9 @@
 
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(__wait4);
+LT10_COMPAT_DEFAULT(wait4);
+
 __weak_reference(__wait4, wait4);
 
 pid_t

lib/libkse/thread/thr_waitpid.c

@@ -34,6 +34,9 @@
 #include <pthread.h>
 #include "thr_private.h"
 
+LT10_COMPAT_PRIVATE(_waitpid);
+LT10_COMPAT_DEFAULT(waitpid);
+
 extern int __waitpid(pid_t, int *, int);
 
 __weak_reference(_waitpid, waitpid);