Index: lib/libthr/thread/thr_attr.c =================================================================== --- lib/libthr/thread/thr_attr.c +++ lib/libthr/thread/thr_attr.c @@ -109,10 +109,11 @@ static size_t _get_kern_cpuset_size(void); -__weak_reference(_pthread_attr_destroy, pthread_attr_destroy); +__weak_reference(_thr_attr_destroy, _pthread_attr_destroy); +__weak_reference(_thr_attr_destroy, pthread_attr_destroy); int -_pthread_attr_destroy(pthread_attr_t *attr) +_thr_attr_destroy(pthread_attr_t *attr) { int ret; @@ -136,10 +137,11 @@ return(ret); } -__weak_reference(_pthread_attr_get_np, pthread_attr_get_np); +__weak_reference(_thr_attr_get_np, pthread_attr_get_np); +__weak_reference(_thr_attr_get_np, _pthread_attr_get_np); int -_pthread_attr_get_np(pthread_t pthread, pthread_attr_t *dstattr) +_thr_attr_get_np(pthread_t pthread, pthread_attr_t *dstattr) { struct pthread *curthread; struct pthread_attr attr, *dst; @@ -173,10 +175,11 @@ return (ret); } -__weak_reference(_pthread_attr_getdetachstate, pthread_attr_getdetachstate); +__weak_reference(_thr_attr_getdetachstate, pthread_attr_getdetachstate); +__weak_reference(_thr_attr_getdetachstate, _pthread_attr_getdetachstate); int -_pthread_attr_getdetachstate(const pthread_attr_t *attr, int *detachstate) +_thr_attr_getdetachstate(const pthread_attr_t *attr, int *detachstate) { int ret; @@ -196,10 +199,11 @@ return(ret); } -__weak_reference(_pthread_attr_getguardsize, pthread_attr_getguardsize); +__weak_reference(_thr_attr_getguardsize, pthread_attr_getguardsize); +__weak_reference(_thr_attr_getguardsize, _pthread_attr_getguardsize); int -_pthread_attr_getguardsize(const pthread_attr_t * __restrict attr, +_thr_attr_getguardsize(const pthread_attr_t * __restrict attr, size_t * __restrict guardsize) { int ret; @@ -215,10 +219,11 @@ return(ret); } -__weak_reference(_pthread_attr_getinheritsched, pthread_attr_getinheritsched); +__weak_reference(_thr_attr_getinheritsched, pthread_attr_getinheritsched); +__weak_reference(_thr_attr_getinheritsched, _pthread_attr_getinheritsched); int -_pthread_attr_getinheritsched(const pthread_attr_t * __restrict attr, +_thr_attr_getinheritsched(const pthread_attr_t * __restrict attr, int * __restrict sched_inherit) { int ret = 0; @@ -231,10 +236,11 @@ return(ret); } -__weak_reference(_pthread_attr_getschedparam, pthread_attr_getschedparam); +__weak_reference(_thr_attr_getschedparam, pthread_attr_getschedparam); +__weak_reference(_thr_attr_getschedparam, _pthread_attr_getschedparam); int -_pthread_attr_getschedparam(const pthread_attr_t * __restrict attr, +_thr_attr_getschedparam(const pthread_attr_t * __restrict attr, struct sched_param * __restrict param) { int ret = 0; @@ -247,10 +253,11 @@ return(ret); } -__weak_reference(_pthread_attr_getschedpolicy, pthread_attr_getschedpolicy); +__weak_reference(_thr_attr_getschedpolicy, pthread_attr_getschedpolicy); +__weak_reference(_thr_attr_getschedpolicy, _pthread_attr_getschedpolicy); int -_pthread_attr_getschedpolicy(const pthread_attr_t * __restrict attr, +_thr_attr_getschedpolicy(const pthread_attr_t * __restrict attr, int * __restrict policy) { int ret = 0; @@ -263,10 +270,11 @@ return(ret); } -__weak_reference(_pthread_attr_getscope, pthread_attr_getscope); +__weak_reference(_thr_attr_getscope, pthread_attr_getscope); +__weak_reference(_thr_attr_getscope, _pthread_attr_getscope); int -_pthread_attr_getscope(const pthread_attr_t * __restrict attr, +_thr_attr_getscope(const pthread_attr_t * __restrict attr, int * __restrict contentionscope) { int ret = 0; @@ -286,8 +294,7 @@ int _pthread_attr_getstack(const pthread_attr_t * __restrict attr, - void ** __restrict stackaddr, - size_t * __restrict stacksize) + void ** __restrict stackaddr, size_t * __restrict stacksize) { int ret; @@ -304,10 +311,11 @@ return(ret); } -__weak_reference(_pthread_attr_getstackaddr, pthread_attr_getstackaddr); +__weak_reference(_thr_attr_getstackaddr, pthread_attr_getstackaddr); +__weak_reference(_thr_attr_getstackaddr, _pthread_attr_getstackaddr); int -_pthread_attr_getstackaddr(const pthread_attr_t *attr, void **stackaddr) +_thr_attr_getstackaddr(const pthread_attr_t *attr, void **stackaddr) { int ret; @@ -322,10 +330,11 @@ return(ret); } -__weak_reference(_pthread_attr_getstacksize, pthread_attr_getstacksize); +__weak_reference(_thr_attr_getstacksize, pthread_attr_getstacksize); +__weak_reference(_thr_attr_getstacksize, _pthread_attr_getstacksize); int -_pthread_attr_getstacksize(const pthread_attr_t * __restrict attr, +_thr_attr_getstacksize(const pthread_attr_t * __restrict attr, size_t * __restrict stacksize) { int ret; @@ -341,10 +350,11 @@ return(ret); } -__weak_reference(_pthread_attr_init, pthread_attr_init); +__weak_reference(_thr_attr_init, pthread_attr_init); +__weak_reference(_thr_attr_init, _pthread_attr_init); int -_pthread_attr_init(pthread_attr_t *attr) +_thr_attr_init(pthread_attr_t *attr) { int ret; pthread_attr_t pattr; @@ -382,10 +392,11 @@ return(ret); } -__weak_reference(_pthread_attr_setdetachstate, pthread_attr_setdetachstate); +__weak_reference(_thr_attr_setdetachstate, pthread_attr_setdetachstate); +__weak_reference(_thr_attr_setdetachstate, _pthread_attr_setdetachstate); int -_pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate) +_thr_attr_setdetachstate(pthread_attr_t *attr, int detachstate) { int ret; @@ -407,10 +418,11 @@ return(ret); } -__weak_reference(_pthread_attr_setguardsize, pthread_attr_setguardsize); +__weak_reference(_thr_attr_setguardsize, pthread_attr_setguardsize); +__weak_reference(_thr_attr_setguardsize, _pthread_attr_setguardsize); int -_pthread_attr_setguardsize(pthread_attr_t *attr, size_t guardsize) +_thr_attr_setguardsize(pthread_attr_t *attr, size_t guardsize) { int ret; @@ -425,10 +437,11 @@ return(ret); } -__weak_reference(_pthread_attr_setinheritsched, pthread_attr_setinheritsched); +__weak_reference(_thr_attr_setinheritsched, pthread_attr_setinheritsched); +__weak_reference(_thr_attr_setinheritsched, _pthread_attr_setinheritsched); int -_pthread_attr_setinheritsched(pthread_attr_t *attr, int sched_inherit) +_thr_attr_setinheritsched(pthread_attr_t *attr, int sched_inherit) { int ret = 0; @@ -443,10 +456,11 @@ return(ret); } -__weak_reference(_pthread_attr_setschedparam, pthread_attr_setschedparam); +__weak_reference(_thr_attr_setschedparam, pthread_attr_setschedparam); +__weak_reference(_thr_attr_setschedparam, _pthread_attr_setschedparam); int -_pthread_attr_setschedparam(pthread_attr_t * __restrict attr, +_thr_attr_setschedparam(pthread_attr_t * __restrict attr, const struct sched_param * __restrict param) { int policy; @@ -476,10 +490,11 @@ return (0); } -__weak_reference(_pthread_attr_setschedpolicy, pthread_attr_setschedpolicy); +__weak_reference(_thr_attr_setschedpolicy, pthread_attr_setschedpolicy); +__weak_reference(_thr_attr_setschedpolicy, _pthread_attr_setschedpolicy); int -_pthread_attr_setschedpolicy(pthread_attr_t *attr, int policy) +_thr_attr_setschedpolicy(pthread_attr_t *attr, int policy) { int ret = 0; @@ -494,10 +509,11 @@ return(ret); } -__weak_reference(_pthread_attr_setscope, pthread_attr_setscope); +__weak_reference(_thr_attr_setscope, pthread_attr_setscope); +__weak_reference(_thr_attr_setscope, _pthread_attr_setscope); int -_pthread_attr_setscope(pthread_attr_t *attr, int contentionscope) +_thr_attr_setscope(pthread_attr_t *attr, int contentionscope) { int ret = 0; @@ -536,10 +552,11 @@ return(ret); } -__weak_reference(_pthread_attr_setstackaddr, pthread_attr_setstackaddr); +__weak_reference(_thr_attr_setstackaddr, pthread_attr_setstackaddr); +__weak_reference(_thr_attr_setstackaddr, _pthread_attr_setstackaddr); int -_pthread_attr_setstackaddr(pthread_attr_t *attr, void *stackaddr) +_thr_attr_setstackaddr(pthread_attr_t *attr, void *stackaddr) { int ret; @@ -554,10 +571,11 @@ return(ret); } -__weak_reference(_pthread_attr_setstacksize, pthread_attr_setstacksize); +__weak_reference(_thr_attr_setstacksize, pthread_attr_setstacksize); +__weak_reference(_thr_attr_setstacksize, _pthread_attr_setstacksize); int -_pthread_attr_setstacksize(pthread_attr_t *attr, size_t stacksize) +_thr_attr_setstacksize(pthread_attr_t *attr, size_t stacksize) { int ret; Index: lib/libthr/thread/thr_cancel.c =================================================================== --- lib/libthr/thread/thr_cancel.c +++ lib/libthr/thread/thr_cancel.c @@ -35,10 +35,14 @@ #include "thr_private.h" -__weak_reference(_pthread_cancel, pthread_cancel); -__weak_reference(_pthread_setcancelstate, pthread_setcancelstate); -__weak_reference(_pthread_setcanceltype, pthread_setcanceltype); -__weak_reference(_pthread_testcancel, pthread_testcancel); +__weak_reference(_thr_cancel, pthread_cancel); +__weak_reference(_thr_cancel, _pthread_cancel); +__weak_reference(_thr_setcancelstate, pthread_setcancelstate); +__weak_reference(_thr_setcancelstate, _pthread_setcancelstate); +__weak_reference(_thr_setcanceltype, pthread_setcanceltype); +__weak_reference(_thr_setcanceltype, _pthread_setcanceltype); +__weak_reference(_Tthr_testcancel, pthread_testcancel); +__weak_reference(_Tthr_testcancel, _pthread_testcancel); static inline void testcancel(struct pthread *curthread) @@ -55,7 +59,7 @@ } int -_pthread_cancel(pthread_t pthread) +_thr_cancel(pthread_t pthread) { struct pthread *curthread = _get_curthread(); int ret; @@ -77,7 +81,7 @@ } int -_pthread_setcancelstate(int state, int *oldstate) +_thr_setcancelstate(int state, int *oldstate) { struct pthread *curthread = _get_curthread(); int oldval; @@ -104,7 +108,7 @@ } int -_pthread_setcanceltype(int type, int *oldtype) +_thr_setcanceltype(int type, int *oldtype) { struct pthread *curthread = _get_curthread(); int oldval; @@ -130,7 +134,7 @@ } void -_pthread_testcancel(void) +_Tthr_testcancel(void) { struct pthread *curthread; Index: lib/libthr/thread/thr_clean.c =================================================================== --- lib/libthr/thread/thr_clean.c +++ lib/libthr/thread/thr_clean.c @@ -46,12 +46,18 @@ #undef pthread_cleanup_pop /* old binary compatible interfaces */ -__weak_reference(_pthread_cleanup_push, pthread_cleanup_push); -__weak_reference(_pthread_cleanup_pop, pthread_cleanup_pop); +__weak_reference(_thr_cleanup_pop, pthread_cleanup_pop); +__weak_reference(_thr_cleanup_pop, _pthread_cleanup_pop); +__weak_reference(_thr_cleanup_push, pthread_cleanup_push); +__weak_reference(_thr_cleanup_push, _pthread_cleanup_push); + +/* help static linking when libc symbols have preference */ +__weak_reference(__thr_cleanup_push_imp, __pthread_cleanup_push_imp); +__weak_reference(__thr_cleanup_pop_imp, __pthread_cleanup_pop_imp); void -__pthread_cleanup_push_imp(void (*routine)(void *), void *arg, - struct _pthread_cleanup_info *info) +__thr_cleanup_push_imp(void (*routine)(void *), void *arg, + struct _pthread_cleanup_info *info) { struct pthread *curthread = _get_curthread(); struct pthread_cleanup *newbuf; @@ -65,7 +71,7 @@ } void -__pthread_cleanup_pop_imp(int execute) +__thr_cleanup_pop_imp(int execute) { struct pthread *curthread = _get_curthread(); struct pthread_cleanup *old; @@ -80,7 +86,7 @@ } void -_pthread_cleanup_push(void (*routine) (void *), void *arg) +_thr_cleanup_push(void (*routine)(void *), void *arg) { struct pthread *curthread = _get_curthread(); struct pthread_cleanup *newbuf; @@ -98,7 +104,7 @@ } void -_pthread_cleanup_pop(int execute) +_thr_cleanup_pop(int execute) { __pthread_cleanup_pop_imp(execute); } Index: lib/libthr/thread/thr_cond.c =================================================================== --- lib/libthr/thread/thr_cond.c +++ lib/libthr/thread/thr_cond.c @@ -49,7 +49,6 @@ /* * Prototypes */ -int __pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex); int __pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec * abstime); static int cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr); @@ -63,13 +62,18 @@ * versions are not and are provided for libc internal usage (which * shouldn't introduce cancellation points). */ -__weak_reference(__pthread_cond_wait, pthread_cond_wait); +__weak_reference(__thr_cond_wait, pthread_cond_wait); +__weak_reference(__thr_cond_wait, __pthread_cond_wait); +__weak_reference(_thr_cond_wait, _pthread_cond_wait); __weak_reference(__pthread_cond_timedwait, pthread_cond_timedwait); - -__weak_reference(_pthread_cond_init, pthread_cond_init); -__weak_reference(_pthread_cond_destroy, pthread_cond_destroy); -__weak_reference(_pthread_cond_signal, pthread_cond_signal); -__weak_reference(_pthread_cond_broadcast, pthread_cond_broadcast); +__weak_reference(_thr_cond_init, pthread_cond_init); +__weak_reference(_thr_cond_init, _pthread_cond_init); +__weak_reference(_thr_cond_destroy, pthread_cond_destroy); +__weak_reference(_thr_cond_destroy, _pthread_cond_destroy); +__weak_reference(_thr_cond_signal, pthread_cond_signal); +__weak_reference(_thr_cond_signal, _pthread_cond_signal); +__weak_reference(_thr_cond_broadcast, pthread_cond_broadcast); +__weak_reference(_thr_cond_broadcast, _pthread_cond_broadcast); #define CV_PSHARED(cvp) (((cvp)->kcond.c_flags & USYNC_PROCESS_SHARED) != 0) @@ -149,7 +153,7 @@ } int -_pthread_cond_init(pthread_cond_t * __restrict cond, +_thr_cond_init(pthread_cond_t * __restrict cond, const pthread_condattr_t * __restrict cond_attr) { @@ -158,7 +162,7 @@ } int -_pthread_cond_destroy(pthread_cond_t *cond) +_thr_cond_destroy(pthread_cond_t *cond) { struct pthread_cond *cvp; int error; @@ -377,14 +381,14 @@ } int -_pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex) +_thr_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex) { return (cond_wait_common(cond, mutex, NULL, 0)); } int -__pthread_cond_wait(pthread_cond_t * __restrict cond, +__thr_cond_wait(pthread_cond_t * __restrict cond, pthread_mutex_t * __restrict mutex) { @@ -392,7 +396,7 @@ } int -_pthread_cond_timedwait(pthread_cond_t * __restrict cond, +_thr_cond_timedwait(pthread_cond_t * __restrict cond, pthread_mutex_t * __restrict mutex, const struct timespec * __restrict abstime) { @@ -541,14 +545,14 @@ } int -_pthread_cond_signal(pthread_cond_t * cond) +_thr_cond_signal(pthread_cond_t * cond) { return (cond_signal_common(cond)); } int -_pthread_cond_broadcast(pthread_cond_t * cond) +_thr_cond_broadcast(pthread_cond_t * cond) { return (cond_broadcast_common(cond)); Index: lib/libthr/thread/thr_detach.c =================================================================== --- lib/libthr/thread/thr_detach.c +++ lib/libthr/thread/thr_detach.c @@ -38,10 +38,11 @@ #include "thr_private.h" -__weak_reference(_pthread_detach, pthread_detach); +__weak_reference(_thr_detach, pthread_detach); +__weak_reference(_thr_detach, _pthread_detach); int -_pthread_detach(pthread_t pthread) +_thr_detach(pthread_t pthread) { struct pthread *curthread = _get_curthread(); int rval; Index: lib/libthr/thread/thr_equal.c =================================================================== --- lib/libthr/thread/thr_equal.c +++ lib/libthr/thread/thr_equal.c @@ -37,10 +37,11 @@ #include "un-namespace.h" #include "thr_private.h" -__weak_reference(_pthread_equal, pthread_equal); +__weak_reference(_thr_equal, pthread_equal); +__weak_reference(_thr_equal, _pthread_equal); int -_pthread_equal(pthread_t t1, pthread_t t2) +_thr_equal(pthread_t t1, pthread_t t2) { /* Compare the two thread pointers: */ return (t1 == t2); Index: lib/libthr/thread/thr_exit.c =================================================================== --- lib/libthr/thread/thr_exit.c +++ lib/libthr/thread/thr_exit.c @@ -50,7 +50,8 @@ static void exit_thread(void) __dead2; -__weak_reference(_pthread_exit, pthread_exit); +__weak_reference(_thr_exit, pthread_exit); +__weak_reference(_thr_exit, _pthread_exit); #ifdef _PTHREAD_FORCED_UNWIND static int message_printed; @@ -203,7 +204,7 @@ } void -_pthread_exit(void *status) +_thr_exit(void *status) { _pthread_exit_mask(status, NULL); } Index: lib/libthr/thread/thr_fork.c =================================================================== --- lib/libthr/thread/thr_fork.c +++ lib/libthr/thread/thr_fork.c @@ -75,10 +75,11 @@ #include "rtld_lock.h" #include "thr_private.h" -__weak_reference(_pthread_atfork, pthread_atfork); +__weak_reference(_thr_atfork, _pthread_atfork); +__weak_reference(_thr_atfork, pthread_atfork); int -_pthread_atfork(void (*prepare)(void), void (*parent)(void), +_thr_atfork(void (*prepare)(void), void (*parent)(void), void (*child)(void)) { struct pthread *curthread; Index: lib/libthr/thread/thr_getthreadid_np.c =================================================================== --- lib/libthr/thread/thr_getthreadid_np.c +++ lib/libthr/thread/thr_getthreadid_np.c @@ -35,13 +35,14 @@ #include "thr_private.h" -__weak_reference(_pthread_getthreadid_np, pthread_getthreadid_np); +__weak_reference(_thr_getthreadid_np, _pthread_getthreadid_np); +__weak_reference(_thr_getthreadid_np, pthread_getthreadid_np); /* * Provide the equivelant to AIX pthread_getthreadid_np() function. */ int -_pthread_getthreadid_np(void) +_thr_getthreadid_np(void) { struct pthread *curthread; Index: lib/libthr/thread/thr_init.c =================================================================== --- lib/libthr/thread/thr_init.c +++ lib/libthr/thread/thr_init.c @@ -203,76 +203,74 @@ (pthread_func_t)entry, (pthread_func_t)entry static pthread_func_t jmp_table[][2] = { - {DUAL_ENTRY(_pthread_atfork)}, /* PJT_ATFORK */ - {DUAL_ENTRY(_pthread_attr_destroy)}, /* PJT_ATTR_DESTROY */ - {DUAL_ENTRY(_pthread_attr_getdetachstate)}, /* PJT_ATTR_GETDETACHSTATE */ - {DUAL_ENTRY(_pthread_attr_getguardsize)}, /* PJT_ATTR_GETGUARDSIZE */ - {DUAL_ENTRY(_pthread_attr_getinheritsched)}, /* PJT_ATTR_GETINHERITSCHED */ - {DUAL_ENTRY(_pthread_attr_getschedparam)}, /* PJT_ATTR_GETSCHEDPARAM */ - {DUAL_ENTRY(_pthread_attr_getschedpolicy)}, /* PJT_ATTR_GETSCHEDPOLICY */ - {DUAL_ENTRY(_pthread_attr_getscope)}, /* PJT_ATTR_GETSCOPE */ - {DUAL_ENTRY(_pthread_attr_getstackaddr)}, /* PJT_ATTR_GETSTACKADDR */ - {DUAL_ENTRY(_pthread_attr_getstacksize)}, /* PJT_ATTR_GETSTACKSIZE */ - {DUAL_ENTRY(_pthread_attr_init)}, /* PJT_ATTR_INIT */ - {DUAL_ENTRY(_pthread_attr_setdetachstate)}, /* PJT_ATTR_SETDETACHSTATE */ - {DUAL_ENTRY(_pthread_attr_setguardsize)}, /* PJT_ATTR_SETGUARDSIZE */ - {DUAL_ENTRY(_pthread_attr_setinheritsched)}, /* PJT_ATTR_SETINHERITSCHED */ - {DUAL_ENTRY(_pthread_attr_setschedparam)}, /* PJT_ATTR_SETSCHEDPARAM */ - {DUAL_ENTRY(_pthread_attr_setschedpolicy)}, /* PJT_ATTR_SETSCHEDPOLICY */ - {DUAL_ENTRY(_pthread_attr_setscope)}, /* PJT_ATTR_SETSCOPE */ - {DUAL_ENTRY(_pthread_attr_setstackaddr)}, /* PJT_ATTR_SETSTACKADDR */ - {DUAL_ENTRY(_pthread_attr_setstacksize)}, /* PJT_ATTR_SETSTACKSIZE */ - {DUAL_ENTRY(_pthread_cancel)}, /* PJT_CANCEL */ - {DUAL_ENTRY(_pthread_cleanup_pop)}, /* PJT_CLEANUP_POP */ - {DUAL_ENTRY(_pthread_cleanup_push)}, /* PJT_CLEANUP_PUSH */ - {DUAL_ENTRY(_pthread_cond_broadcast)}, /* PJT_COND_BROADCAST */ - {DUAL_ENTRY(_pthread_cond_destroy)}, /* PJT_COND_DESTROY */ - {DUAL_ENTRY(_pthread_cond_init)}, /* PJT_COND_INIT */ - {DUAL_ENTRY(_pthread_cond_signal)}, /* PJT_COND_SIGNAL */ - {DUAL_ENTRY(_pthread_cond_timedwait)}, /* PJT_COND_TIMEDWAIT */ - {(pthread_func_t)__pthread_cond_wait, - (pthread_func_t)_pthread_cond_wait}, /* PJT_COND_WAIT */ - {DUAL_ENTRY(_pthread_detach)}, /* PJT_DETACH */ - {DUAL_ENTRY(_pthread_equal)}, /* PJT_EQUAL */ - {DUAL_ENTRY(_pthread_exit)}, /* PJT_EXIT */ - {DUAL_ENTRY(_pthread_getspecific)}, /* PJT_GETSPECIFIC */ - {DUAL_ENTRY(_pthread_join)}, /* PJT_JOIN */ - {DUAL_ENTRY(_pthread_key_create)}, /* PJT_KEY_CREATE */ - {DUAL_ENTRY(_pthread_key_delete)}, /* PJT_KEY_DELETE*/ - {DUAL_ENTRY(_pthread_kill)}, /* PJT_KILL */ - {DUAL_ENTRY(_pthread_main_np)}, /* PJT_MAIN_NP */ - {DUAL_ENTRY(_pthread_mutexattr_destroy)}, /* PJT_MUTEXATTR_DESTROY */ - {DUAL_ENTRY(_pthread_mutexattr_init)}, /* PJT_MUTEXATTR_INIT */ - {DUAL_ENTRY(_pthread_mutexattr_settype)}, /* PJT_MUTEXATTR_SETTYPE */ - {DUAL_ENTRY(_pthread_mutex_destroy)}, /* PJT_MUTEX_DESTROY */ - {DUAL_ENTRY(_pthread_mutex_init)}, /* PJT_MUTEX_INIT */ - {(pthread_func_t)__pthread_mutex_lock, - (pthread_func_t)_pthread_mutex_lock}, /* PJT_MUTEX_LOCK */ - {(pthread_func_t)__pthread_mutex_trylock, - (pthread_func_t)_pthread_mutex_trylock},/* PJT_MUTEX_TRYLOCK */ - {DUAL_ENTRY(_pthread_mutex_unlock)}, /* PJT_MUTEX_UNLOCK */ - {DUAL_ENTRY(_pthread_once)}, /* PJT_ONCE */ - {DUAL_ENTRY(_pthread_rwlock_destroy)}, /* PJT_RWLOCK_DESTROY */ - {DUAL_ENTRY(_pthread_rwlock_init)}, /* PJT_RWLOCK_INIT */ - {DUAL_ENTRY(_pthread_rwlock_rdlock)}, /* PJT_RWLOCK_RDLOCK */ - {DUAL_ENTRY(_pthread_rwlock_tryrdlock)},/* PJT_RWLOCK_TRYRDLOCK */ - {DUAL_ENTRY(_pthread_rwlock_trywrlock)},/* PJT_RWLOCK_TRYWRLOCK */ - {DUAL_ENTRY(_pthread_rwlock_unlock)}, /* PJT_RWLOCK_UNLOCK */ - {DUAL_ENTRY(_pthread_rwlock_wrlock)}, /* PJT_RWLOCK_WRLOCK */ - {DUAL_ENTRY(_pthread_self)}, /* PJT_SELF */ - {DUAL_ENTRY(_pthread_setcancelstate)}, /* PJT_SETCANCELSTATE */ - {DUAL_ENTRY(_pthread_setcanceltype)}, /* PJT_SETCANCELTYPE */ - {DUAL_ENTRY(_pthread_setspecific)}, /* PJT_SETSPECIFIC */ - {DUAL_ENTRY(_pthread_sigmask)}, /* PJT_SIGMASK */ - {DUAL_ENTRY(_pthread_testcancel)}, /* PJT_TESTCANCEL */ - {DUAL_ENTRY(__pthread_cleanup_pop_imp)},/* PJT_CLEANUP_POP_IMP */ - {DUAL_ENTRY(__pthread_cleanup_push_imp)},/* PJT_CLEANUP_PUSH_IMP */ - {DUAL_ENTRY(_pthread_cancel_enter)}, /* PJT_CANCEL_ENTER */ - {DUAL_ENTRY(_pthread_cancel_leave)}, /* PJT_CANCEL_LEAVE */ - {DUAL_ENTRY(_pthread_mutex_consistent)},/* PJT_MUTEX_CONSISTENT */ - {DUAL_ENTRY(_pthread_mutexattr_getrobust)},/* PJT_MUTEXATTR_GETROBUST */ - {DUAL_ENTRY(_pthread_mutexattr_setrobust)},/* PJT_MUTEXATTR_SETROBUST */ - {DUAL_ENTRY(_pthread_getthreadid_np)}, /* PJT_GETTHREADID_NP */ + [PJT_ATFORK] = {DUAL_ENTRY(_thr_atfork)}, + [PJT_ATTR_DESTROY] = {DUAL_ENTRY(_thr_attr_destroy)}, + [PJT_ATTR_GETDETACHSTATE] = {DUAL_ENTRY(_thr_attr_getdetachstate)}, + [PJT_ATTR_GETGUARDSIZE] = {DUAL_ENTRY(_thr_attr_getguardsize)}, + [PJT_ATTR_GETINHERITSCHED] = {DUAL_ENTRY(_thr_attr_getinheritsched)}, + [PJT_ATTR_GETSCHEDPARAM] = {DUAL_ENTRY(_thr_attr_getschedparam)}, + [PJT_ATTR_GETSCHEDPOLICY] = {DUAL_ENTRY(_thr_attr_getschedpolicy)}, + [PJT_ATTR_GETSCOPE] = {DUAL_ENTRY(_thr_attr_getscope)}, + [PJT_ATTR_GETSTACKADDR] = {DUAL_ENTRY(_thr_attr_getstackaddr)}, + [PJT_ATTR_GETSTACKSIZE] = {DUAL_ENTRY(_thr_attr_getstacksize)}, + [PJT_ATTR_INIT] = {DUAL_ENTRY(_thr_attr_init)}, + [PJT_ATTR_SETDETACHSTATE] = {DUAL_ENTRY(_thr_attr_setdetachstate)}, + [PJT_ATTR_SETGUARDSIZE] = {DUAL_ENTRY(_thr_attr_setguardsize)}, + [PJT_ATTR_SETINHERITSCHED] = {DUAL_ENTRY(_thr_attr_setinheritsched)}, + [PJT_ATTR_SETSCHEDPARAM] = {DUAL_ENTRY(_thr_attr_setschedparam)}, + [PJT_ATTR_SETSCHEDPOLICY] = {DUAL_ENTRY(_thr_attr_setschedpolicy)}, + [PJT_ATTR_SETSCOPE] = {DUAL_ENTRY(_thr_attr_setscope)}, + [PJT_ATTR_SETSTACKADDR] = {DUAL_ENTRY(_thr_attr_setstackaddr)}, + [PJT_ATTR_SETSTACKSIZE] = {DUAL_ENTRY(_thr_attr_setstacksize)}, + [PJT_CANCEL] = {DUAL_ENTRY(_thr_cancel)}, + [PJT_CLEANUP_POP] = {DUAL_ENTRY(_thr_cleanup_pop)}, + [PJT_CLEANUP_PUSH] = {DUAL_ENTRY(_thr_cleanup_push)}, + [PJT_COND_BROADCAST] = {DUAL_ENTRY(_thr_cond_broadcast)}, + [PJT_COND_DESTROY] = {DUAL_ENTRY(_thr_cond_destroy)}, + [PJT_COND_INIT] = {DUAL_ENTRY(_thr_cond_init)}, + [PJT_COND_SIGNAL] = {DUAL_ENTRY(_thr_cond_signal)}, + [PJT_COND_TIMEDWAIT] = {DUAL_ENTRY(_thr_cond_timedwait)}, + [PJT_COND_WAIT] = {(pthread_func_t)__thr_cond_wait, + (pthread_func_t)_thr_cond_wait}, + [PJT_DETACH] = {DUAL_ENTRY(_thr_detach)}, + [PJT_EQUAL] = {DUAL_ENTRY(_thr_equal)}, + [PJT_EXIT] = {DUAL_ENTRY(_thr_exit)}, + [PJT_GETSPECIFIC] = {DUAL_ENTRY(_thr_getspecific)}, + [PJT_JOIN] = {DUAL_ENTRY(_thr_join)}, + [PJT_KEY_CREATE] = {DUAL_ENTRY(_thr_key_create)}, + [PJT_KEY_DELETE] = {DUAL_ENTRY(_thr_key_delete)}, + [PJT_KILL] = {DUAL_ENTRY(_thr_kill)}, + [PJT_MAIN_NP] = {DUAL_ENTRY(_thr_main_np)}, + [PJT_MUTEXATTR_DESTROY] = {DUAL_ENTRY(_thr_mutexattr_destroy)}, + [PJT_MUTEXATTR_INIT] = {DUAL_ENTRY(_thr_mutexattr_init)}, + [PJT_MUTEXATTR_SETTYPE] = {DUAL_ENTRY(_thr_mutexattr_settype)}, + [PJT_MUTEX_DESTROY] = {DUAL_ENTRY(_thr_mutex_destroy)}, + [PJT_MUTEX_INIT] = {DUAL_ENTRY(__Tthr_mutex_init)}, + [PJT_MUTEX_LOCK] = {DUAL_ENTRY(__Tthr_mutex_lock)}, + [PJT_MUTEX_TRYLOCK] = {DUAL_ENTRY(__Tthr_mutex_trylock)}, + [PJT_MUTEX_UNLOCK] = {DUAL_ENTRY(_thr_mutex_unlock)}, + [PJT_ONCE] = {DUAL_ENTRY(_thr_once)}, + [PJT_RWLOCK_DESTROY] = {DUAL_ENTRY(_thr_rwlock_destroy)}, + [PJT_RWLOCK_INIT] = {DUAL_ENTRY(_thr_rwlock_init)}, + [PJT_RWLOCK_RDLOCK] = {DUAL_ENTRY(_Tthr_rwlock_rdlock)}, + [PJT_RWLOCK_TRYRDLOCK] = {DUAL_ENTRY(_Tthr_rwlock_tryrdlock)}, + [PJT_RWLOCK_TRYWRLOCK] = {DUAL_ENTRY(_Tthr_rwlock_trywrlock)}, + [PJT_RWLOCK_UNLOCK] = {DUAL_ENTRY(_Tthr_rwlock_unlock)}, + [PJT_RWLOCK_WRLOCK] = {DUAL_ENTRY(_Tthr_rwlock_wrlock)}, + [PJT_SELF] = {DUAL_ENTRY(_Tthr_self)}, + [PJT_SETCANCELSTATE] = {DUAL_ENTRY(_thr_setcancelstate)}, + [PJT_SETCANCELTYPE] = {DUAL_ENTRY(_thr_setcanceltype)}, + [PJT_SETSPECIFIC] = {DUAL_ENTRY(_thr_setspecific)}, + [PJT_SIGMASK] = {DUAL_ENTRY(_thr_sigmask)}, + [PJT_TESTCANCEL] = {DUAL_ENTRY(_Tthr_testcancel)}, + [PJT_CLEANUP_POP_IMP] = {DUAL_ENTRY(__thr_cleanup_pop_imp)}, + [PJT_CLEANUP_PUSH_IMP] = {DUAL_ENTRY(__thr_cleanup_push_imp)}, + [PJT_CANCEL_ENTER] = {DUAL_ENTRY(_thr_cancel_enter)}, + [PJT_CANCEL_LEAVE] = {DUAL_ENTRY(_thr_cancel_leave)}, + [PJT_MUTEX_CONSISTENT] = {DUAL_ENTRY(_Tthr_mutex_consistent)}, + [PJT_MUTEXATTR_GETROBUST] = {DUAL_ENTRY(_thr_mutexattr_getrobust)}, + [PJT_MUTEXATTR_SETROBUST] = {DUAL_ENTRY(_thr_mutexattr_setrobust)}, + [PJT_GETTHREADID_NP] = {DUAL_ENTRY(_thr_getthreadid_np)}, }; static int init_once = 0; Index: lib/libthr/thread/thr_join.c =================================================================== --- lib/libthr/thread/thr_join.c +++ lib/libthr/thread/thr_join.c @@ -40,7 +40,8 @@ const struct timespec *abstime); static int join_common(pthread_t, void **, const struct timespec *); -__weak_reference(_pthread_join, pthread_join); +__weak_reference(_thr_join, pthread_join); +__weak_reference(_thr_join, _pthread_join); __weak_reference(_pthread_timedjoin_np, pthread_timedjoin_np); static void backout_join(void *arg) @@ -54,7 +55,7 @@ } int -_pthread_join(pthread_t pthread, void **thread_return) +_thr_join(pthread_t pthread, void **thread_return) { return (join_common(pthread, thread_return, NULL)); } Index: lib/libthr/thread/thr_kill.c =================================================================== --- lib/libthr/thread/thr_kill.c +++ lib/libthr/thread/thr_kill.c @@ -40,10 +40,11 @@ #include "thr_private.h" -__weak_reference(_pthread_kill, pthread_kill); +__weak_reference(_thr_kill, _pthread_kill); +__weak_reference(_thr_kill, pthread_kill); int -_pthread_kill(pthread_t pthread, int sig) +_thr_kill(pthread_t pthread, int sig) { struct pthread *curthread; int ret; Index: lib/libthr/thread/thr_main_np.c =================================================================== --- lib/libthr/thread/thr_main_np.c +++ lib/libthr/thread/thr_main_np.c @@ -37,13 +37,14 @@ #include "thr_private.h" -__weak_reference(_pthread_main_np, pthread_main_np); +__weak_reference(_thr_main_np, pthread_main_np); +__weak_reference(_thr_main_np, _pthread_main_np); /* * Provide the equivalent to Solaris thr_main() function. */ int -_pthread_main_np(void) +_thr_main_np(void) { if (!_thr_initial) Index: lib/libthr/thread/thr_mutex.c =================================================================== --- lib/libthr/thread/thr_mutex.c +++ lib/libthr/thread/thr_mutex.c @@ -65,11 +65,6 @@ /* * Prototypes */ -int __pthread_mutex_consistent(pthread_mutex_t *mutex); -int __pthread_mutex_init(pthread_mutex_t * __restrict mutex, - const pthread_mutexattr_t * __restrict mutex_attr); -int __pthread_mutex_trylock(pthread_mutex_t *mutex); -int __pthread_mutex_lock(pthread_mutex_t *mutex); int __pthread_mutex_timedlock(pthread_mutex_t * __restrict mutex, const struct timespec * __restrict abstime); int _pthread_mutex_getspinloops_np(pthread_mutex_t *mutex, int *count); @@ -90,21 +85,27 @@ static bool is_robust_mutex(struct pthread_mutex *m); static bool is_pshared_mutex(struct pthread_mutex *m); -__weak_reference(__pthread_mutex_init, pthread_mutex_init); -__strong_reference(__pthread_mutex_init, _pthread_mutex_init); -__weak_reference(__pthread_mutex_lock, pthread_mutex_lock); -__strong_reference(__pthread_mutex_lock, _pthread_mutex_lock); +__weak_reference(__Tthr_mutex_init, pthread_mutex_init); +__weak_reference(__Tthr_mutex_init, __pthread_mutex_init); +__strong_reference(__Tthr_mutex_init, _pthread_mutex_init); +__weak_reference(__Tthr_mutex_lock, pthread_mutex_lock); +__weak_reference(__Tthr_mutex_lock, __pthread_mutex_lock); +__strong_reference(__Tthr_mutex_lock, _pthread_mutex_lock); __weak_reference(__pthread_mutex_timedlock, pthread_mutex_timedlock); __strong_reference(__pthread_mutex_timedlock, _pthread_mutex_timedlock); -__weak_reference(__pthread_mutex_trylock, pthread_mutex_trylock); -__strong_reference(__pthread_mutex_trylock, _pthread_mutex_trylock); -__weak_reference(_pthread_mutex_consistent, pthread_mutex_consistent); -__strong_reference(_pthread_mutex_consistent, __pthread_mutex_consistent); +__weak_reference(__Tthr_mutex_trylock, pthread_mutex_trylock); +__weak_reference(__Tthr_mutex_trylock, __pthread_mutex_trylock); +__strong_reference(__Tthr_mutex_trylock, _pthread_mutex_trylock); +__weak_reference(_Tthr_mutex_consistent, pthread_mutex_consistent); +__weak_reference(_Tthr_mutex_consistent, _pthread_mutex_consistent); +__strong_reference(_Tthr_mutex_consistent, __pthread_mutex_consistent); /* Single underscore versions provided for libc internal usage: */ /* No difference between libc and application usage of these: */ -__weak_reference(_pthread_mutex_destroy, pthread_mutex_destroy); -__weak_reference(_pthread_mutex_unlock, pthread_mutex_unlock); +__weak_reference(_thr_mutex_destroy, pthread_mutex_destroy); +__weak_reference(_thr_mutex_destroy, _pthread_mutex_destroy); +__weak_reference(_thr_mutex_unlock, pthread_mutex_unlock); +__weak_reference(_thr_mutex_unlock, _pthread_mutex_unlock); __weak_reference(_pthread_mutex_getprioceiling, pthread_mutex_getprioceiling); __weak_reference(_pthread_mutex_setprioceiling, pthread_mutex_setprioceiling); @@ -377,7 +378,7 @@ } int -__pthread_mutex_init(pthread_mutex_t * __restrict mutex, +__Tthr_mutex_init(pthread_mutex_t * __restrict mutex, const pthread_mutexattr_t * __restrict mutex_attr) { struct pthread_mutex *pmtx; @@ -459,7 +460,7 @@ } int -_pthread_mutex_destroy(pthread_mutex_t *mutex) +_thr_mutex_destroy(pthread_mutex_t *mutex) { pthread_mutex_t m, m1; int ret; @@ -608,7 +609,7 @@ } int -__pthread_mutex_trylock(pthread_mutex_t *mutex) +__Tthr_mutex_trylock(pthread_mutex_t *mutex) { struct pthread *curthread; struct pthread_mutex *m; @@ -737,7 +738,7 @@ } int -__pthread_mutex_lock(pthread_mutex_t *mutex) +__Tthr_mutex_lock(pthread_mutex_t *mutex) { struct pthread_mutex *m; int ret; @@ -764,7 +765,7 @@ } int -_pthread_mutex_unlock(pthread_mutex_t *mutex) +_thr_mutex_unlock(pthread_mutex_t *mutex) { struct pthread_mutex *mp; @@ -1167,7 +1168,7 @@ } int -_pthread_mutex_consistent(pthread_mutex_t *mutex) +_Tthr_mutex_consistent(pthread_mutex_t *mutex) { struct pthread_mutex *m; struct pthread *curthread; Index: lib/libthr/thread/thr_mutexattr.c =================================================================== --- lib/libthr/thread/thr_mutexattr.c +++ lib/libthr/thread/thr_mutexattr.c @@ -72,12 +72,15 @@ #include "thr_private.h" -__weak_reference(_pthread_mutexattr_init, pthread_mutexattr_init); +__weak_reference(_thr_mutexattr_init, pthread_mutexattr_init); +__weak_reference(_thr_mutexattr_init, _pthread_mutexattr_init); __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); -__weak_reference(_pthread_mutexattr_settype, pthread_mutexattr_settype); -__weak_reference(_pthread_mutexattr_destroy, pthread_mutexattr_destroy); +__weak_reference(_thr_mutexattr_settype, pthread_mutexattr_settype); +__weak_reference(_thr_mutexattr_settype, _pthread_mutexattr_settype); +__weak_reference(_thr_mutexattr_destroy, pthread_mutexattr_destroy); +__weak_reference(_thr_mutexattr_destroy, _pthread_mutexattr_destroy); __weak_reference(_pthread_mutexattr_getpshared, pthread_mutexattr_getpshared); __weak_reference(_pthread_mutexattr_setpshared, pthread_mutexattr_setpshared); __weak_reference(_pthread_mutexattr_getprotocol, pthread_mutexattr_getprotocol); @@ -86,11 +89,13 @@ pthread_mutexattr_getprioceiling); __weak_reference(_pthread_mutexattr_setprioceiling, pthread_mutexattr_setprioceiling); -__weak_reference(_pthread_mutexattr_getrobust, pthread_mutexattr_getrobust); -__weak_reference(_pthread_mutexattr_setrobust, pthread_mutexattr_setrobust); +__weak_reference(_thr_mutexattr_getrobust, pthread_mutexattr_getrobust); +__weak_reference(_thr_mutexattr_getrobust, _pthread_mutexattr_getrobust); +__weak_reference(_thr_mutexattr_setrobust, pthread_mutexattr_setrobust); +__weak_reference(_thr_mutexattr_setrobust, _pthread_mutexattr_setrobust); int -_pthread_mutexattr_init(pthread_mutexattr_t *attr) +_thr_mutexattr_init(pthread_mutexattr_t *attr) { int ret; pthread_mutexattr_t pattr; @@ -136,7 +141,7 @@ } int -_pthread_mutexattr_settype(pthread_mutexattr_t *attr, int type) +_thr_mutexattr_settype(pthread_mutexattr_t *attr, int type) { int ret; @@ -166,7 +171,7 @@ } int -_pthread_mutexattr_destroy(pthread_mutexattr_t *attr) +_thr_mutexattr_destroy(pthread_mutexattr_t *attr) { int ret; if (attr == NULL || *attr == NULL) { @@ -263,7 +268,7 @@ } int -_pthread_mutexattr_getrobust(pthread_mutexattr_t *mattr, int *robust) +_thr_mutexattr_getrobust(pthread_mutexattr_t *mattr, int *robust) { int ret; @@ -277,7 +282,7 @@ } int -_pthread_mutexattr_setrobust(pthread_mutexattr_t *mattr, int robust) +_thr_mutexattr_setrobust(pthread_mutexattr_t *mattr, int robust) { int ret; Index: lib/libthr/thread/thr_once.c =================================================================== --- lib/libthr/thread/thr_once.c +++ lib/libthr/thread/thr_once.c @@ -35,7 +35,8 @@ #include "thr_private.h" -__weak_reference(_pthread_once, pthread_once); +__weak_reference(_thr_once, pthread_once); +__weak_reference(_thr_once, _pthread_once); #define ONCE_NEVER_DONE PTHREAD_NEEDS_INIT #define ONCE_DONE PTHREAD_DONE_INIT @@ -63,7 +64,7 @@ } int -_pthread_once(pthread_once_t *once_control, void (*init_routine) (void)) +_thr_once(pthread_once_t *once_control, void (*init_routine)(void)) { struct pthread *curthread; int state; Index: lib/libthr/thread/thr_private.h =================================================================== --- lib/libthr/thread/thr_private.h +++ lib/libthr/thread/thr_private.h @@ -1013,6 +1013,86 @@ void __thr_malloc_prefork(struct pthread *curthread); void __thr_malloc_postfork(struct pthread *curthread); +int _thr_join(pthread_t, void **); +int _thr_kill(pthread_t, int); +int _thr_getthreadid_np(void); +void __thr_cleanup_push_imp(void (*)(void *), void *, + struct _pthread_cleanup_info *); +void __thr_cleanup_pop_imp(int); +void _thr_cleanup_push(void (*)(void *), void *); +void _thr_cleanup_pop(int); +void _thr_cancel_enter(struct pthread *); +void _thr_cancel_leave(struct pthread *, int); +void _Tthr_testcancel(void); +int _thr_cancel(pthread_t); +int _thr_atfork(void (*)(void), void (*)(void), void (*)(void)); +int _thr_attr_destroy(pthread_attr_t *); +int _thr_attr_get_np(pthread_t, pthread_attr_t *); +int _thr_attr_getdetachstate(const pthread_attr_t *, int *); +int _thr_attr_getguardsize(const pthread_attr_t * __restrict, + size_t * __restrict); +int _thr_attr_getinheritsched(const pthread_attr_t * __restrict, + int * __restrict); +int _thr_attr_getschedparam(const pthread_attr_t * __restrict, + struct sched_param * __restrict); +int _thr_attr_getschedpolicy(const pthread_attr_t * __restrict, + int * __restrict); +int _thr_attr_getscope(const pthread_attr_t * __restrict, int * __restrict); +int _thr_attr_getstackaddr(const pthread_attr_t *, void **); +int _thr_attr_getstacksize(const pthread_attr_t * __restrict, + size_t * __restrict); +int _thr_attr_init(pthread_attr_t *); +int _thr_attr_setdetachstate(pthread_attr_t *, int); +int _thr_attr_setguardsize(pthread_attr_t *, size_t); +int _thr_attr_setinheritsched(pthread_attr_t *, int); +int _thr_attr_setschedparam(pthread_attr_t * __restrict, + const struct sched_param * __restrict); +int _thr_attr_setschedpolicy(pthread_attr_t *, int); +int _thr_attr_setscope(pthread_attr_t *, int); +int _thr_attr_setstackaddr(pthread_attr_t *, void *); +int _thr_attr_setstacksize(pthread_attr_t *, size_t); +int _thr_cond_init(pthread_cond_t * __restrict, + const pthread_condattr_t * __restrict); +int _thr_cond_destroy(pthread_cond_t *); +int _thr_cond_timedwait(pthread_cond_t * __restrict, + pthread_mutex_t * __restrict, const struct timespec * __restrict); +int _thr_cond_signal(pthread_cond_t * cond); +int _thr_cond_broadcast(pthread_cond_t * cond); +int __thr_cond_wait(pthread_cond_t *, pthread_mutex_t *); +int _thr_cond_wait(pthread_cond_t *, pthread_mutex_t *); +int _thr_detach(pthread_t); +int _thr_equal(pthread_t, pthread_t); +void _thr_exit(void *); +int _thr_key_create(pthread_key_t *, void (*)(void *)); +int _thr_key_delete(pthread_key_t); +int _thr_setspecific(pthread_key_t, const void *); +void *_thr_getspecific(pthread_key_t); +int _thr_setcancelstate(int, int *); +int _thr_setcanceltype(int, int *); +pthread_t _Tthr_self(void); +int _thr_rwlock_init(pthread_rwlock_t *, const pthread_rwlockattr_t *); +int _thr_rwlock_destroy(pthread_rwlock_t *); +int _Tthr_rwlock_rdlock(pthread_rwlock_t *); +int _Tthr_rwlock_tryrdlock(pthread_rwlock_t *); +int _Tthr_rwlock_trywrlock(pthread_rwlock_t *); +int _Tthr_rwlock_wrlock(pthread_rwlock_t *); +int _Tthr_rwlock_unlock(pthread_rwlock_t *); +int _thr_once(pthread_once_t *, void (*)(void)); +int _thr_sigmask(int, const sigset_t *, sigset_t *); +int _thr_main_np(void); +int _thr_mutexattr_init(pthread_mutexattr_t *); +int _thr_mutexattr_destroy(pthread_mutexattr_t *); +int _thr_mutexattr_settype(pthread_mutexattr_t *, int); +int _thr_mutexattr_getrobust(pthread_mutexattr_t *, int *); +int _thr_mutexattr_setrobust(pthread_mutexattr_t *, int); +int __Tthr_mutex_init(pthread_mutex_t * __restrict, + const pthread_mutexattr_t * __restrict); +int _Tthr_mutex_consistent(pthread_mutex_t *); +int _thr_mutex_destroy(pthread_mutex_t *); +int _thr_mutex_unlock(pthread_mutex_t *); +int __Tthr_mutex_lock(pthread_mutex_t *); +int __Tthr_mutex_trylock(pthread_mutex_t *); + __END_DECLS __NULLABILITY_PRAGMA_POP Index: lib/libthr/thread/thr_rwlock.c =================================================================== --- lib/libthr/thread/thr_rwlock.c +++ lib/libthr/thread/thr_rwlock.c @@ -41,14 +41,21 @@ _Static_assert(sizeof(struct pthread_rwlock) <= PAGE_SIZE, "pthread_rwlock is too large for off-page"); -__weak_reference(_pthread_rwlock_destroy, pthread_rwlock_destroy); -__weak_reference(_pthread_rwlock_init, pthread_rwlock_init); -__weak_reference(_pthread_rwlock_rdlock, pthread_rwlock_rdlock); +__weak_reference(_thr_rwlock_destroy, pthread_rwlock_destroy); +__weak_reference(_thr_rwlock_destroy, _pthread_rwlock_destroy); +__weak_reference(_thr_rwlock_init, pthread_rwlock_init); +__weak_reference(_thr_rwlock_init, _pthread_rwlock_init); +__weak_reference(_Tthr_rwlock_rdlock, pthread_rwlock_rdlock); +__weak_reference(_Tthr_rwlock_rdlock, _pthread_rwlock_rdlock); __weak_reference(_pthread_rwlock_timedrdlock, pthread_rwlock_timedrdlock); -__weak_reference(_pthread_rwlock_tryrdlock, pthread_rwlock_tryrdlock); -__weak_reference(_pthread_rwlock_trywrlock, pthread_rwlock_trywrlock); -__weak_reference(_pthread_rwlock_unlock, pthread_rwlock_unlock); -__weak_reference(_pthread_rwlock_wrlock, pthread_rwlock_wrlock); +__weak_reference(_Tthr_rwlock_tryrdlock, pthread_rwlock_tryrdlock); +__weak_reference(_Tthr_rwlock_tryrdlock, _pthread_rwlock_tryrdlock); +__weak_reference(_Tthr_rwlock_trywrlock, pthread_rwlock_trywrlock); +__weak_reference(_Tthr_rwlock_trywrlock, _pthread_rwlock_trywrlock); +__weak_reference(_Tthr_rwlock_unlock, pthread_rwlock_unlock); +__weak_reference(_Tthr_rwlock_unlock, _pthread_rwlock_unlock); +__weak_reference(_Tthr_rwlock_wrlock, pthread_rwlock_wrlock); +__weak_reference(_Tthr_rwlock_wrlock, _pthread_rwlock_wrlock); __weak_reference(_pthread_rwlock_timedwrlock, pthread_rwlock_timedwrlock); static int init_static(struct pthread *thread, pthread_rwlock_t *rwlock); @@ -110,7 +117,7 @@ } int -_pthread_rwlock_destroy (pthread_rwlock_t *rwlock) +_thr_rwlock_destroy(pthread_rwlock_t *rwlock) { pthread_rwlock_t prwlock; int ret; @@ -150,7 +157,7 @@ } int -_pthread_rwlock_init(pthread_rwlock_t *rwlock, const pthread_rwlockattr_t *attr) +_thr_rwlock_init(pthread_rwlock_t *rwlock, const pthread_rwlockattr_t *attr) { *rwlock = NULL; @@ -219,7 +226,7 @@ } int -_pthread_rwlock_rdlock (pthread_rwlock_t *rwlock) +_Tthr_rwlock_rdlock(pthread_rwlock_t *rwlock) { return (rwlock_rdlock_common(rwlock, NULL)); } @@ -232,7 +239,7 @@ } int -_pthread_rwlock_tryrdlock (pthread_rwlock_t *rwlock) +_Tthr_rwlock_tryrdlock(pthread_rwlock_t *rwlock) { struct pthread *curthread = _get_curthread(); pthread_rwlock_t prwlock; @@ -268,7 +275,7 @@ } int -_pthread_rwlock_trywrlock (pthread_rwlock_t *rwlock) +_Tthr_rwlock_trywrlock(pthread_rwlock_t *rwlock) { struct pthread *curthread = _get_curthread(); pthread_rwlock_t prwlock; @@ -285,7 +292,7 @@ } static int -rwlock_wrlock_common (pthread_rwlock_t *rwlock, const struct timespec *abstime) +rwlock_wrlock_common(pthread_rwlock_t *rwlock, const struct timespec *abstime) { struct pthread *curthread = _get_curthread(); pthread_rwlock_t prwlock; @@ -331,7 +338,7 @@ } int -_pthread_rwlock_wrlock (pthread_rwlock_t *rwlock) +_Tthr_rwlock_wrlock(pthread_rwlock_t *rwlock) { return (rwlock_wrlock_common (rwlock, NULL)); } @@ -344,7 +351,7 @@ } int -_pthread_rwlock_unlock(pthread_rwlock_t *rwlock) +_Tthr_rwlock_unlock(pthread_rwlock_t *rwlock) { struct pthread *curthread = _get_curthread(); pthread_rwlock_t prwlock; Index: lib/libthr/thread/thr_self.c =================================================================== --- lib/libthr/thread/thr_self.c +++ lib/libthr/thread/thr_self.c @@ -38,10 +38,11 @@ #include "thr_private.h" -__weak_reference(_pthread_self, pthread_self); +__weak_reference(_Tthr_self, pthread_self); +__weak_reference(_Tthr_self, _pthread_self); pthread_t -_pthread_self(void) +_Tthr_self(void) { _thr_check_init(); Index: lib/libthr/thread/thr_sig.c =================================================================== --- lib/libthr/thread/thr_sig.c +++ lib/libthr/thread/thr_sig.c @@ -601,10 +601,11 @@ return (__sys_sigprocmask(how, p, oset)); } -__weak_reference(_pthread_sigmask, pthread_sigmask); +__weak_reference(_thr_sigmask, pthread_sigmask); +__weak_reference(_thr_sigmask, _pthread_sigmask); int -_pthread_sigmask(int how, const sigset_t *set, sigset_t *oset) +_thr_sigmask(int how, const sigset_t *set, sigset_t *oset) { if (__thr_sigprocmask(how, set, oset)) Index: lib/libthr/thread/thr_spec.c =================================================================== --- lib/libthr/thread/thr_spec.c +++ lib/libthr/thread/thr_spec.c @@ -47,14 +47,17 @@ /* Used in symbol lookup of libthread_db */ struct pthread_key _thread_keytable[PTHREAD_KEYS_MAX]; -__weak_reference(_pthread_key_create, pthread_key_create); -__weak_reference(_pthread_key_delete, pthread_key_delete); -__weak_reference(_pthread_getspecific, pthread_getspecific); -__weak_reference(_pthread_setspecific, pthread_setspecific); - +__weak_reference(_thr_key_create, pthread_key_create); +__weak_reference(_thr_key_create, _pthread_key_create); +__weak_reference(_thr_key_delete, pthread_key_delete); +__weak_reference(_thr_key_delete, _pthread_key_delete); +__weak_reference(_thr_getspecific, pthread_getspecific); +__weak_reference(_thr_getspecific, _pthread_getspecific); +__weak_reference(_thr_setspecific, pthread_setspecific); +__weak_reference(_thr_setspecific, _pthread_setspecific); int -_pthread_key_create(pthread_key_t *key, void (*destructor)(void *)) +_thr_key_create(pthread_key_t *key, void (*destructor)(void *)) { struct pthread *curthread; int i; @@ -82,7 +85,7 @@ } int -_pthread_key_delete(pthread_key_t userkey) +_thr_key_delete(pthread_key_t userkey) { struct pthread *curthread; int key, ret; @@ -165,7 +168,7 @@ } int -_pthread_setspecific(pthread_key_t userkey, const void *value) +_thr_setspecific(pthread_key_t userkey, const void *value) { struct pthread *pthread; void *tmp; @@ -195,7 +198,7 @@ } void * -_pthread_getspecific(pthread_key_t userkey) +_thr_getspecific(pthread_key_t userkey) { struct pthread *pthread; const void *data;