On Thu, 31 Oct 2002, Daniel Eischen wrote:

> This is better, although it has two stubs for each routine.  Adding
> a weak definition from pthread_foo() to _pthread_foo() (note the
> lack of _stub) doesn't do the same thing?

Ok, this version works and seems to be a reasonably tidy solution, at
least until/if the jump-table version a-la solaris is available. I
tweaked it slightly to move all the __weak_reference() calls together. Can
I commit this?

Index: gen/_pthread_stubs.c
===================================================================
RCS file: /home/ncvs/src/lib/libc/gen/_pthread_stubs.c,v
retrieving revision 1.7
diff -u -r1.7 _pthread_stubs.c
--- gen/_pthread_stubs.c        19 Sep 2002 01:09:49 -0000      1.7
+++ gen/_pthread_stubs.c        31 Oct 2002 19:30:24 -0000
@@ -31,6 +31,9 @@
 #include <pthread.h>
 #include <pthread_np.h>

+void *_pthread_getspecific(pthread_key_t key);
+pthread_t _pthread_self(void);
+
 /*
  * Weak symbols: All libc internal usage of these functions should
  * use the weak symbol versions (_pthread_XXX).  If libpthread is
@@ -42,6 +45,7 @@
  */
 __weak_reference(_pthread_cond_init_stub,      _pthread_cond_init);
 __weak_reference(_pthread_cond_signal_stub,    _pthread_cond_signal);
+__weak_reference(_pthread_cond_broadcast_stub, _pthread_cond_broadcast);
 __weak_reference(_pthread_cond_wait_stub,      _pthread_cond_wait);
 __weak_reference(_pthread_cond_destroy_stub,   _pthread_cond_destroy);
 __weak_reference(_pthread_getspecific_stub,    _pthread_getspecific);
@@ -59,180 +63,386 @@
 __weak_reference(_pthread_once_stub,           _pthread_once);
 __weak_reference(_pthread_self_stub,           _pthread_self);
 __weak_reference(_pthread_rwlock_init_stub,    _pthread_rwlock_init);
+__weak_reference(_pthread_rwlock_destroy_stub, _pthread_rwlock_destroy);
 __weak_reference(_pthread_rwlock_rdlock_stub,  _pthread_rwlock_rdlock);
 __weak_reference(_pthread_rwlock_tryrdlock_stub, _pthread_rwlock_tryrdlock);
-__weak_reference(_pthread_rwlock_trywrlock_stub, _pthread_rwlock_trywrloc);
+__weak_reference(_pthread_rwlock_trywrlock_stub, _pthread_rwlock_trywrlock);
 __weak_reference(_pthread_rwlock_unlock_stub,  _pthread_rwlock_unlock);
 __weak_reference(_pthread_rwlock_wrlock_stub,  _pthread_rwlock_wrlock);
 __weak_reference(_pthread_setspecific_stub,    _pthread_setspecific);
 __weak_reference(_pthread_sigmask_stub,                _pthread_sigmask);

+__weak_reference(pthread_cond_init_stub,       pthread_cond_init);
+__weak_reference(pthread_cond_signal_stub,     pthread_cond_signal);
+__weak_reference(pthread_cond_broadcast_stub,  pthread_cond_broadcast);
+__weak_reference(pthread_cond_wait_stub,       pthread_cond_wait);
+__weak_reference(pthread_cond_destroy_stub,    pthread_cond_destroy);
+__weak_reference(pthread_getspecific_stub,     pthread_getspecific);
+__weak_reference(pthread_key_create_stub,      pthread_key_create);
+__weak_reference(pthread_key_delete_stub,      pthread_key_delete);
+__weak_reference(pthread_main_np_stub,         pthread_main_np);
+__weak_reference(pthread_mutex_destroy_stub,   pthread_mutex_destroy);
+__weak_reference(pthread_mutex_init_stub,      pthread_mutex_init);
+__weak_reference(pthread_mutex_lock_stub,      pthread_mutex_lock);
+__weak_reference(pthread_mutex_trylock_stub,   pthread_mutex_trylock);
+__weak_reference(pthread_mutex_unlock_stub,    pthread_mutex_unlock);
+__weak_reference(pthread_mutexattr_init_stub,  pthread_mutexattr_init);
+__weak_reference(pthread_mutexattr_destroy_stub, pthread_mutexattr_destroy);
+__weak_reference(pthread_mutexattr_settype_stub, pthread_mutexattr_settype);
+__weak_reference(pthread_once_stub,            pthread_once);
+__weak_reference(pthread_self_stub,            pthread_self);
+__weak_reference(pthread_rwlock_init_stub,     pthread_rwlock_init);
+__weak_reference(pthread_rwlock_destroy_stub,  pthread_rwlock_destroy);
+__weak_reference(pthread_rwlock_rdlock_stub,   pthread_rwlock_rdlock);
+__weak_reference(pthread_rwlock_tryrdlock_stub, pthread_rwlock_tryrdlock);
+__weak_reference(pthread_rwlock_trywrlock_stub, pthread_rwlock_trywrlock);
+__weak_reference(pthread_rwlock_unlock_stub,   pthread_rwlock_unlock);
+__weak_reference(pthread_rwlock_wrlock_stub,   pthread_rwlock_wrlock);
+__weak_reference(pthread_setspecific_stub,     pthread_setspecific);
+__weak_reference(pthread_sigmask_stub,         pthread_sigmask);
+
 /* Define a null pthread structure just to satisfy _pthread_self. */
 struct pthread {
 };

 static struct pthread  main_thread;

-int
+static int
 _pthread_cond_init_stub(pthread_cond_t *cond,
     const pthread_condattr_t *cond_attr)
 {
        return (0);
 }

-int
+static int
 _pthread_cond_signal_stub(pthread_cond_t *cond)
 {
        return (0);
 }

-int
+static int
+_pthread_cond_broadcast_stub(pthread_cond_t *cond)
+{
+       return (0);
+}
+
+static int
 _pthread_cond_wait_stub(pthread_cond_t *cond, pthread_mutex_t *mutex)
 {
        return (0);
 }

-int
+static int
 _pthread_cond_destroy_stub(pthread_cond_t *cond)
 {
        return (0);
 }

-void *
+static void *
 _pthread_getspecific_stub(pthread_key_t key)
 {
        return (NULL);
 }

-int
+static int
 _pthread_key_create_stub(pthread_key_t *key, void (*destructor) (void *))
 {
        return (0);
 }

-int
+static int
 _pthread_key_delete_stub(pthread_key_t key)
 {
        return (0);
 }

-int
+static int
 _pthread_main_np_stub()
 {
        return (-1);
 }

-int
+static int
 _pthread_mutex_destroy_stub(pthread_mutex_t *mattr)
 {
        return (0);
 }

-int
+static int
 _pthread_mutex_init_stub(pthread_mutex_t *mutex, const pthread_mutexattr_t *mattr)
 {
        return (0);
 }

-int
+static int
 _pthread_mutex_lock_stub(pthread_mutex_t *mutex)
 {
        return (0);
 }

-int
+static int
 _pthread_mutex_trylock_stub(pthread_mutex_t *mutex)
 {
        return (0);
 }

-int
+static int
 _pthread_mutex_unlock_stub(pthread_mutex_t *mutex)
 {
        return (0);
 }

-int
+static int
 _pthread_mutexattr_init_stub(pthread_mutexattr_t *mattr)
 {
        return (0);
 }

-int
+static int
 _pthread_mutexattr_destroy_stub(pthread_mutexattr_t *mattr)
 {
        return (0);
 }

-int
+static int
 _pthread_mutexattr_settype_stub(pthread_mutexattr_t *mattr, int type)
 {
        return (0);
 }

-int
+static int
 _pthread_once_stub(pthread_once_t *once_control, void (*init_routine) (void))
 {
        return (0);
 }

-int
+static int
 _pthread_rwlock_init_stub(pthread_rwlock_t *rwlock,
     const pthread_rwlockattr_t *attr)
 {
        return (0);
 }

-int
+static int
 _pthread_rwlock_destroy_stub(pthread_rwlock_t *rwlock)
 {
        return (0);
 }

-int
+static int
 _pthread_rwlock_rdlock_stub(pthread_rwlock_t *rwlock)
 {
        return (0);
 }

-int
+static int
 _pthread_rwlock_tryrdlock_stub(pthread_rwlock_t *rwlock)
 {
        return (0);
 }

-int
+static int
 _pthread_rwlock_trywrlock_stub(pthread_rwlock_t *rwlock)
 {
        return (0);
 }

-int
+static int
 _pthread_rwlock_unlock_stub(pthread_rwlock_t *rwlock)
 {
        return (0);
 }

-int
+static int
 _pthread_rwlock_wrlock_stub(pthread_rwlock_t *rwlock)
 {
        return (0);
 }

-pthread_t
+static pthread_t
 _pthread_self_stub(void)
 {
        return (&main_thread);
 }

-int
+static int
 _pthread_setspecific_stub(pthread_key_t key, const void *value)
 {
        return (0);
 }

-int
+static int
 _pthread_sigmask_stub(int how, const sigset_t *set, sigset_t *oset)
 {
        return (0);
+}
+
+static int
+pthread_cond_init_stub(pthread_cond_t *cond,
+    const pthread_condattr_t *cond_attr)
+{
+       return (_pthread_cond_init(cond, cond_attr));
+}
+
+static int
+pthread_cond_signal_stub(pthread_cond_t *cond)
+{
+       return (_pthread_cond_signal(cond));
+}
+
+static int
+pthread_cond_broadcast_stub(pthread_cond_t *cond)
+{
+       return (_pthread_cond_broadcast(cond));
+}
+
+static int
+pthread_cond_wait_stub(pthread_cond_t *cond, pthread_mutex_t *mutex)
+{
+       return (_pthread_cond_wait(cond, mutex));
+}
+
+static int
+pthread_cond_destroy_stub(pthread_cond_t *cond)
+{
+       return (_pthread_cond_destroy(cond));
+}
+
+static void *
+pthread_getspecific_stub(pthread_key_t key)
+{
+       return (_pthread_getspecific(key));
+}
+
+static int
+pthread_key_create_stub(pthread_key_t *key, void (*destructor) (void *))
+{
+       return (_pthread_key_create(key, destructor));
+}
+
+static int
+pthread_key_delete_stub(pthread_key_t key)
+{
+       return (_pthread_key_delete(key));
+}
+
+static int
+pthread_main_np_stub()
+{
+       return (_pthread_main_np());
+}
+
+static int
+pthread_mutex_destroy_stub(pthread_mutex_t *mattr)
+{
+       return (_pthread_mutex_destroy(mattr));
+}
+
+static int
+pthread_mutex_init_stub(pthread_mutex_t *mutex, const pthread_mutexattr_t *mattr)
+{
+       return (_pthread_mutex_init(mutex, mattr));
+}
+
+static int
+pthread_mutex_lock_stub(pthread_mutex_t *mutex)
+{
+       return (_pthread_mutex_lock(mutex));
+}
+
+static int
+pthread_mutex_trylock_stub(pthread_mutex_t *mutex)
+{
+       return (_pthread_mutex_trylock(mutex));
+}
+
+static int
+pthread_mutex_unlock_stub(pthread_mutex_t *mutex)
+{
+       return (_pthread_mutex_unlock(mutex));
+}
+
+static int
+pthread_mutexattr_init_stub(pthread_mutexattr_t *mattr)
+{
+       return (_pthread_mutexattr_init(mattr));
+}
+
+static int
+pthread_mutexattr_destroy_stub(pthread_mutexattr_t *mattr)
+{
+       return (_pthread_mutexattr_destroy(mattr));
+}
+
+static int
+pthread_mutexattr_settype_stub(pthread_mutexattr_t *mattr, int type)
+{
+       return (_pthread_mutexattr_settype(mattr, type));
+}
+
+static int
+pthread_once_stub(pthread_once_t *once_control, void (*init_routine) (void))
+{
+       return (_pthread_once(once_control, init_routine));
+}
+
+static int
+pthread_rwlock_init_stub(pthread_rwlock_t *rwlock,
+    const pthread_rwlockattr_t *attr)
+{
+       return (_pthread_rwlock_init(rwlock, attr));
+}
+
+static int
+pthread_rwlock_destroy_stub(pthread_rwlock_t *rwlock)
+{
+       return (_pthread_rwlock_destroy(rwlock));
+}
+
+static int
+pthread_rwlock_rdlock_stub(pthread_rwlock_t *rwlock)
+{
+       return (_pthread_rwlock_rdlock(rwlock));
+}
+
+static int
+pthread_rwlock_tryrdlock_stub(pthread_rwlock_t *rwlock)
+{
+       return (_pthread_rwlock_tryrdlock(rwlock));
+}
+
+static int
+pthread_rwlock_trywrlock_stub(pthread_rwlock_t *rwlock)
+{
+       return (_pthread_rwlock_trywrlock(rwlock));
+}
+
+static int
+pthread_rwlock_unlock_stub(pthread_rwlock_t *rwlock)
+{
+       return (_pthread_rwlock_unlock(rwlock));
+}
+
+static int
+pthread_rwlock_wrlock_stub(pthread_rwlock_t *rwlock)
+{
+       return (_pthread_rwlock_wrlock(rwlock));
+}
+
+static pthread_t
+pthread_self_stub(void)
+{
+       return (_pthread_self());
+}
+
+static int
+pthread_setspecific_stub(pthread_key_t key, const void *value)
+{
+       return (_pthread_setspecific(key, value));
+}
+
+static int
+pthread_sigmask_stub(int how, const sigset_t *set, sigset_t *oset)
+{
+       return (_pthread_sigmask(how, set, oset));
 }
Index: include/namespace.h
===================================================================
RCS file: /home/ncvs/src/lib/libc/include/namespace.h,v
retrieving revision 1.9
diff -u -r1.9 namespace.h
--- include/namespace.h 29 Mar 2002 22:43:42 -0000      1.9
+++ include/namespace.h 30 Oct 2002 20:04:44 -0000
@@ -77,6 +77,7 @@
 #define                open                            _open
 #define                poll                            _poll
 #define                pthread_cond_signal             _pthread_cond_signal
+#define                pthread_cond_broadcast          _pthread_cond_broadcast
 #define                pthread_cond_wait               _pthread_cond_wait
 #define                pthread_cond_init               _pthread_cond_init
 #define                pthread_exit                    _pthread_exit
Index: include/reentrant.h
===================================================================
RCS file: /home/ncvs/src/lib/libc/include/reentrant.h,v
retrieving revision 1.1
diff -u -r1.1 reentrant.h
--- include/reentrant.h 19 Mar 2001 12:49:49 -0000      1.1
+++ include/reentrant.h 30 Oct 2002 20:04:44 -0000
@@ -109,6 +109,8 @@
 #define cond_init(c, a, p)     _pthread_cond_init(c, a)
 #define cond_signal(m)         if (__isthreaded) \
                                _pthread_cond_signal(m)
+#define cond_broadcast(m)      if (__isthreaded) \
+                               _pthread_cond_broadcast(m)
 #define cond_wait(c, m)                if (__isthreaded) \
                                _pthread_cond_wait(c, m)


-- 
Doug Rabson                             Mail:  [EMAIL PROTECTED]
                                        Phone: +44 20 8348 6160



To Unsubscribe: send mail to [EMAIL PROTECTED]
with "unsubscribe freebsd-current" in the body of the message

Reply via email to