for c11 mtx and cnd functions, use externally consistent type names

despite looking like undefined behavior, the affected code is correct
both before and after this patch. the pairs mtx_t and pthread_mutex_t,
and cnd_t and pthread_cond_t, are not mutually compatible within a
single translation unit (because they are distinct untagged aggregate
instances), but they are compatible with an object of either type from
another translation unit (6.2.7 ¶1), and therefore a given translation
unit can choose which one it wants to use.

in the interest of being able to move declarations out of source files
to headers that facilitate checking, use the pthread type names in
declaring the namespace-safe versions of the pthread functions and
cast the argument pointer types when calling them.

diff --git a/src/thread/cnd_broadcast.c b/src/thread/cnd_broadcast.c
index 85d4d3ead318a0436c0dfb7aae076f3a17345a79..0ad061a3f9ec03ad1a8350cdf6e20b2dcbf21328 100644 (file)
--- a/src/thread/cnd_broadcast.c
+++ b/src/thread/cnd_broadcast.c
@@ -1,10 +1,11 @@
 #include <threads.h>
+#include <pthread.h>
 
-int __private_cond_signal(cnd_t *, int);
+int __private_cond_signal(pthread_cond_t *, int);
 
 int cnd_broadcast(cnd_t *c)
 {
        /* This internal function never fails, and always returns zero,
         * which matches the value thrd_success is defined with. */
-       return __private_cond_signal(c, -1);
+       return __private_cond_signal((pthread_cond_t *)c, -1);
 }

diff --git a/src/thread/cnd_signal.c b/src/thread/cnd_signal.c
index 1211260b4b89548476314245bd282330332f96c6..8165dae162e03697688e7b2f8a41c2fa169bc11b 100644 (file)
--- a/src/thread/cnd_signal.c
+++ b/src/thread/cnd_signal.c
@@ -1,10 +1,11 @@
 #include <threads.h>
+#include <pthread.h>
 
-int __private_cond_signal(cnd_t *, int);
+int __private_cond_signal(pthread_cond_t *, int);
 
 int cnd_signal(cnd_t *c)
 {
        /* This internal function never fails, and always returns zero,
         * which matches the value thrd_success is defined with. */
-       return __private_cond_signal(c, 1);
+       return __private_cond_signal((pthread_cond_t *)c, 1);
 }

diff --git a/src/thread/cnd_timedwait.c b/src/thread/cnd_timedwait.c
index 599767937d0526d23c8bc899ae895fd1eb2703e0..7bfe1045c0a9e20bcf8ecd45b51b7e6c960e6caa 100644 (file)
--- a/src/thread/cnd_timedwait.c
+++ b/src/thread/cnd_timedwait.c
@@ -1,11 +1,12 @@
 #include <threads.h>
+#include <pthread.h>
 #include <errno.h>
 
-int __pthread_cond_timedwait(cnd_t *restrict, mtx_t *restrict, const struct timespec *restrict);
+int __pthread_cond_timedwait(pthread_cond_t *restrict, pthread_mutex_t *restrict, const struct timespec *restrict);
 
 int cnd_timedwait(cnd_t *restrict c, mtx_t *restrict m, const struct timespec *restrict ts)
 {
-       int ret = __pthread_cond_timedwait(c, m, ts);
+       int ret = __pthread_cond_timedwait((pthread_cond_t *)c, (pthread_mutex_t *)m, ts);
        switch (ret) {
        /* May also return EINVAL or EPERM. */
        default:        return thrd_error;

diff --git a/src/thread/mtx_timedlock.c b/src/thread/mtx_timedlock.c
index bcc152c564348898c1ed9218aebb3dc3776a7c23..d098053bad32ebc5158e0f6089f698a184f09438 100644 (file)
--- a/src/thread/mtx_timedlock.c
+++ b/src/thread/mtx_timedlock.c
@@ -1,11 +1,12 @@
 #include <threads.h>
+#include <pthread.h>
 #include <errno.h>
 
-int __pthread_mutex_timedlock(mtx_t *restrict, const struct timespec *restrict);
+int __pthread_mutex_timedlock(pthread_mutex_t *restrict, const struct timespec *restrict);
 
 int mtx_timedlock(mtx_t *restrict m, const struct timespec *restrict ts)
 {
-       int ret = __pthread_mutex_timedlock(m, ts);
+       int ret = __pthread_mutex_timedlock((pthread_mutex_t *)m, ts);
        switch (ret) {
        default:        return thrd_error;
        case 0:         return thrd_success;

diff --git a/src/thread/mtx_trylock.c b/src/thread/mtx_trylock.c
index 61e7694edcda2528f8c184a4e91feb7060b23051..8d1fb07c0c9ccd81aa579ba65bed64fbaaed308f 100644 (file)
--- a/src/thread/mtx_trylock.c
+++ b/src/thread/mtx_trylock.c
@@ -1,14 +1,14 @@
 #include "pthread_impl.h"
 #include <threads.h>
 
-int __pthread_mutex_trylock(mtx_t *);
+int __pthread_mutex_trylock(pthread_mutex_t *);
 
 int mtx_trylock(mtx_t *m)
 {
        if (m->_m_type == PTHREAD_MUTEX_NORMAL)
                return (a_cas(&m->_m_lock, 0, EBUSY) & EBUSY) ? thrd_busy : thrd_success;
 
-       int ret = __pthread_mutex_trylock(m);
+       int ret = __pthread_mutex_trylock((pthread_mutex_t *)m);
        switch (ret) {
        default:    return thrd_error;
        case 0:     return thrd_success;

diff --git a/src/thread/mtx_unlock.c b/src/thread/mtx_unlock.c
index 5033ace7f3292c9604e4f9627c3f912fba6aae87..ac91f993c69431630ceb597b7a50c821d089f41e 100644 (file)
--- a/src/thread/mtx_unlock.c
+++ b/src/thread/mtx_unlock.c
@@ -1,11 +1,12 @@
 #include <threads.h>
+#include <pthread.h>
 
-int __pthread_mutex_unlock(mtx_t *);
+int __pthread_mutex_unlock(pthread_mutex_t *);
 
 int mtx_unlock(mtx_t *mtx)
 {
        /* The only cases where pthread_mutex_unlock can return an
         * error are undefined behavior for C11 mtx_unlock, so we can
         * assume it does not return an error and simply tail call. */
-       return __pthread_mutex_unlock(mtx);
+       return __pthread_mutex_unlock((pthread_mutex_t *)mtx);
 }