diff --git a/mingw-w64-libraries/winpthreads/include/pthread.h b/mingw-w64-libraries/winpthreads/include/pthread.h
index d06c0c8..3ab5db7 100644
--- a/mingw-w64-libraries/winpthreads/include/pthread.h
+++ b/mingw-w64-libraries/winpthreads/include/pthread.h
@@ -139,7 +139,16 @@
 #define PTHREAD_MUTEX_RECURSIVE_NP	PTHREAD_MUTEX_RECURSIVE
 
 WINPTHREAD_API void * pthread_timechange_handler_np(void * dummy);
-WINPTHREAD_API int    pthread_delay_np (const struct timespec *interval);
+WINPTHREAD_API int    pthread_delay32_np (const struct _timespec32 *interval);
+WINPTHREAD_API int    pthread_delay64_np (const struct _timespec64 *interval);
+WINPTHREAD_THREAD_DECL int    pthread_delay_np (const struct timespec *interval)
+{
+#if WINPTHREADS_TIME_BITS == 32
+  return pthread_delay32_np ((const struct _timespec32 *) interval);
+#else
+  return pthread_delay64_np ((const struct _timespec64 *) interval);
+#endif
+}
 WINPTHREAD_API int    pthread_num_processors_np(void);
 WINPTHREAD_API int    pthread_set_num_processors_np(int n);
 
@@ -269,12 +278,29 @@
 WINPTHREAD_API int       pthread_setname_np(pthread_t thread, const char *name);
 WINPTHREAD_API int       pthread_getname_np(pthread_t thread, char *name, size_t len);
 
-
 WINPTHREAD_API int pthread_rwlock_init(pthread_rwlock_t *rwlock_, const pthread_rwlockattr_t *attr);
 WINPTHREAD_API int pthread_rwlock_wrlock(pthread_rwlock_t *l);
-WINPTHREAD_API int pthread_rwlock_timedwrlock(pthread_rwlock_t *rwlock, const struct timespec *ts);
+WINPTHREAD_API int pthread_rwlock_timedwrlock32(pthread_rwlock_t *rwlock, const struct _timespec32 *ts);
+WINPTHREAD_API int pthread_rwlock_timedwrlock64(pthread_rwlock_t *rwlock, const struct _timespec64 *ts);
+WINPTHREAD_RWLOCK_DECL int pthread_rwlock_timedwrlock(pthread_rwlock_t *rwlock, const struct timespec *ts)
+{
+#if WINPTHREADS_TIME_BITS == 32
+  return pthread_rwlock_timedwrlock32 (rwlock, (const struct _timespec32 *) ts);
+#else
+  return pthread_rwlock_timedwrlock64 (rwlock, (const struct _timespec64 *) ts);
+#endif
+}
 WINPTHREAD_API int pthread_rwlock_rdlock(pthread_rwlock_t *l);
-WINPTHREAD_API int pthread_rwlock_timedrdlock(pthread_rwlock_t *l, const struct timespec *ts);
+WINPTHREAD_API int pthread_rwlock_timedrdlock32(pthread_rwlock_t *l, const struct _timespec32 *ts);
+WINPTHREAD_API int pthread_rwlock_timedrdlock64(pthread_rwlock_t *l, const struct _timespec64 *ts);
+WINPTHREAD_RWLOCK_DECL int pthread_rwlock_timedrdlock(pthread_rwlock_t *l, const struct timespec *ts)
+{
+#if WINPTHREADS_TIME_BITS == 32
+  return pthread_rwlock_timedrdlock32 (l, (const struct _timespec32 *) ts);
+#else
+  return pthread_rwlock_timedrdlock64 (l, (const struct _timespec64 *) ts);
+#endif
+}
 WINPTHREAD_API int pthread_rwlock_unlock(pthread_rwlock_t *l);
 WINPTHREAD_API int pthread_rwlock_tryrdlock(pthread_rwlock_t *l);
 WINPTHREAD_API int pthread_rwlock_trywrlock(pthread_rwlock_t *l);
@@ -285,11 +311,38 @@
 WINPTHREAD_API int pthread_cond_signal (pthread_cond_t *cv);
 WINPTHREAD_API int pthread_cond_broadcast (pthread_cond_t *cv);
 WINPTHREAD_API int pthread_cond_wait (pthread_cond_t *cv, pthread_mutex_t *external_mutex);
-WINPTHREAD_API int pthread_cond_timedwait(pthread_cond_t *cv, pthread_mutex_t *external_mutex, const struct timespec *t);
-WINPTHREAD_API int pthread_cond_timedwait_relative_np(pthread_cond_t *cv, pthread_mutex_t *external_mutex, const struct timespec *t);
+WINPTHREAD_API int pthread_cond_timedwait32(pthread_cond_t *cv, pthread_mutex_t *external_mutex, const struct _timespec32 *t);
+WINPTHREAD_API int pthread_cond_timedwait64(pthread_cond_t *cv, pthread_mutex_t *external_mutex, const struct _timespec64 *t);
+WINPTHREAD_COND_DECL int pthread_cond_timedwait(pthread_cond_t *cv, pthread_mutex_t *external_mutex, const struct timespec *t)
+{
+#if WINPTHREADS_TIME_BITS == 32
+  return pthread_cond_timedwait32 (cv, external_mutex, (const struct _timespec32 *) t);
+#else
+  return pthread_cond_timedwait64 (cv, external_mutex, (const struct _timespec64 *) t);
+#endif
+}
+WINPTHREAD_API int pthread_cond_timedwait32_relative_np(pthread_cond_t *cv, pthread_mutex_t *external_mutex, const struct _timespec32 *t);
+WINPTHREAD_API int pthread_cond_timedwait64_relative_np(pthread_cond_t *cv, pthread_mutex_t *external_mutex, const struct _timespec64 *t);
+WINPTHREAD_COND_DECL int pthread_cond_timedwait_relative_np(pthread_cond_t *cv, pthread_mutex_t *external_mutex, const struct timespec *t)
+{
+#if WINPTHREADS_TIME_BITS == 32
+  return pthread_cond_timedwait32_relative_np (cv, external_mutex, (const struct _timespec32 *) t);
+#else
+  return pthread_cond_timedwait64_relative_np (cv, external_mutex, (const struct _timespec64 *) t);
+#endif
+}
 
 WINPTHREAD_API int pthread_mutex_lock(pthread_mutex_t *m);
-WINPTHREAD_API int pthread_mutex_timedlock(pthread_mutex_t *m, const struct timespec *ts);
+WINPTHREAD_API int pthread_mutex_timedlock32(pthread_mutex_t *m, const struct _timespec32 *ts);
+WINPTHREAD_API int pthread_mutex_timedlock64(pthread_mutex_t *m, const struct _timespec64 *ts);
+WINPTHREAD_MUTEX_DECL int pthread_mutex_timedlock(pthread_mutex_t *m, const struct timespec *ts)
+{
+#if WINPTHREADS_TIME_BITS == 32
+  return pthread_mutex_timedlock32 (m, (const struct _timespec32 *) ts);
+#else
+  return pthread_mutex_timedlock64 (m, (const struct _timespec64 *) ts);
+#endif
+}
 WINPTHREAD_API int pthread_mutex_unlock(pthread_mutex_t *m);
 WINPTHREAD_API int pthread_mutex_trylock(pthread_mutex_t *m);
 WINPTHREAD_API int pthread_mutex_init(pthread_mutex_t *m, const pthread_mutexattr_t *a);
@@ -343,7 +396,6 @@
        clockid_t *clock_id);
 WINPTHREAD_API int pthread_condattr_setclock(pthread_condattr_t *attr,
        clockid_t clock_id);
-WINPTHREAD_API int __pthread_clock_nanosleep(clockid_t clock_id, int flags, const struct timespec *rqtp, struct timespec *rmtp);
 
 WINPTHREAD_API int pthread_barrierattr_init(void **attr);
 WINPTHREAD_API int pthread_barrierattr_destroy(void **attr);
diff --git a/mingw-w64-libraries/winpthreads/include/pthread_compat.h b/mingw-w64-libraries/winpthreads/include/pthread_compat.h
index 9611872..3a85528 100644
--- a/mingw-w64-libraries/winpthreads/include/pthread_compat.h
+++ b/mingw-w64-libraries/winpthreads/include/pthread_compat.h
@@ -60,6 +60,12 @@
 #ifndef WIN_PTHREADS_PTHREAD_COMPAT_H
 #define WIN_PTHREADS_PTHREAD_COMPAT_H
 
+#if defined(_USE_32BIT_TIME_T) || (defined(_TIME_BITS) && _TIME_BITS == 32)
+#define WINPTHREADS_TIME_BITS 32
+#else
+#define WINPTHREADS_TIME_BITS 64
+#endif
+
 #if defined(IN_WINPTHREAD)
 #  if defined(DLL_EXPORT)
 #    define WINPTHREAD_API  __declspec(dllexport)  /* building the DLL  */
@@ -97,7 +103,8 @@
 
 #ifdef __GNUC__
 
-#define WINPTHREADS_INLINE inline
+#define WINPTHREADS_INLINE __inline__
+#define WINPTHREADS_ALWAYS_INLINE __inline__ __attribute__((__always_inline__))
 #define WINPTHREADS_ATTRIBUTE(X) __attribute__(X)
 #define WINPTHREADS_SECTION(X) __section__(X)
 
@@ -110,9 +117,32 @@
 #endif
 
 #define WINPTHREADS_INLINE __inline
+#define WINPTHREADS_ALWAYS_INLINE __inline __forceinline
 #define WINPTHREADS_ATTRIBUTE(X) __declspec X
 #define WINPTHREADS_SECTION(X) allocate(X)
 
 #endif
 
+#ifndef WINPTHREAD_CLOCK_DECL
+#define WINPTHREAD_CLOCK_DECL static WINPTHREADS_ALWAYS_INLINE
+#endif
+#ifndef WINPTHREAD_COND_DECL
+#define WINPTHREAD_COND_DECL static WINPTHREADS_ALWAYS_INLINE
+#endif
+#ifndef WINPTHREAD_MUTEX_DECL
+#define WINPTHREAD_MUTEX_DECL static WINPTHREADS_ALWAYS_INLINE
+#endif
+#ifndef WINPTHREAD_NANOSLEEP_DECL
+#define WINPTHREAD_NANOSLEEP_DECL static WINPTHREADS_ALWAYS_INLINE
+#endif
+#ifndef WINPTHREAD_RWLOCK_DECL
+#define WINPTHREAD_RWLOCK_DECL static WINPTHREADS_ALWAYS_INLINE
+#endif
+#ifndef WINPTHREAD_SEM_DECL
+#define WINPTHREAD_SEM_DECL static WINPTHREADS_ALWAYS_INLINE
+#endif
+#ifndef WINPTHREAD_THREAD_DECL
+#define WINPTHREAD_THREAD_DECL static WINPTHREADS_ALWAYS_INLINE
+#endif
+
 #endif
diff --git a/mingw-w64-libraries/winpthreads/include/pthread_time.h b/mingw-w64-libraries/winpthreads/include/pthread_time.h
index 363154d..ac014ae 100644
--- a/mingw-w64-libraries/winpthreads/include/pthread_time.h
+++ b/mingw-w64-libraries/winpthreads/include/pthread_time.h
@@ -73,12 +73,60 @@
 extern "C" {
 #endif
 
-WINPTHREAD_API int __cdecl nanosleep(const struct timespec *request, struct timespec *remain);
+WINPTHREAD_API int __cdecl nanosleep32(const struct _timespec32 *request, struct _timespec32 *remain);
+WINPTHREAD_API int __cdecl nanosleep64(const struct _timespec64 *request, struct _timespec64 *remain);
+WINPTHREAD_NANOSLEEP_DECL int __cdecl nanosleep(const struct timespec *request, struct timespec *remain)
+{
+#if WINPTHREADS_TIME_BITS == 32
+  return nanosleep32 ((struct _timespec32 *)request, (struct _timespec32 *)remain);
+#else
+  return nanosleep64 ((struct _timespec64 *)request, (struct _timespec64 *)remain);
+#endif
+}
 
-WINPTHREAD_API int __cdecl clock_nanosleep(clockid_t clock_id, int flags, const struct timespec *request, struct timespec *remain);
-WINPTHREAD_API int __cdecl clock_getres(clockid_t clock_id, struct timespec *res);
-WINPTHREAD_API int __cdecl clock_gettime(clockid_t clock_id, struct timespec *tp);
-WINPTHREAD_API int __cdecl clock_settime(clockid_t clock_id, const struct timespec *tp);
+WINPTHREAD_API int __cdecl clock_nanosleep32(clockid_t clock_id, int flags, const struct _timespec32 *request, struct _timespec32 *remain);
+WINPTHREAD_API int __cdecl clock_nanosleep64(clockid_t clock_id, int flags, const struct _timespec64 *request, struct _timespec64 *remain);
+WINPTHREAD_CLOCK_DECL int __cdecl clock_nanosleep(clockid_t clock_id, int flags, const struct timespec *request, struct timespec *remain)
+{
+#if WINPTHREADS_TIME_BITS == 32
+  return clock_nanosleep32 (clock_id, flags, (struct _timespec32 *)request, (struct _timespec32 *)remain);
+#else
+  return clock_nanosleep64 (clock_id, flags, (struct _timespec64 *)request, (struct _timespec64 *)remain);
+#endif
+}
+
+WINPTHREAD_API int __cdecl clock_getres32(clockid_t clock_id, struct _timespec32 *res);
+WINPTHREAD_API int __cdecl clock_getres64(clockid_t clock_id, struct _timespec64 *res);
+WINPTHREAD_CLOCK_DECL int __cdecl clock_getres(clockid_t clock_id, struct timespec *res)
+{
+#if WINPTHREADS_TIME_BITS == 32
+  return clock_getres32 (clock_id, (struct _timespec32 *)res);
+#else
+  return clock_getres64 (clock_id, (struct _timespec64 *)res);
+#endif
+}
+
+WINPTHREAD_API int __cdecl clock_gettime32(clockid_t clock_id, struct _timespec32 *tp);
+WINPTHREAD_API int __cdecl clock_gettime64(clockid_t clock_id, struct _timespec64 *tp);
+WINPTHREAD_CLOCK_DECL int __cdecl clock_gettime(clockid_t clock_id, struct timespec *tp)
+{
+#if WINPTHREADS_TIME_BITS == 32
+  return clock_gettime32 (clock_id, (struct _timespec32 *)tp);
+#else
+  return clock_gettime64 (clock_id, (struct _timespec64 *)tp);
+#endif
+}
+
+WINPTHREAD_API int __cdecl clock_settime32(clockid_t clock_id, const struct _timespec32 *tp);
+WINPTHREAD_API int __cdecl clock_settime64(clockid_t clock_id, const struct _timespec64 *tp);
+WINPTHREAD_CLOCK_DECL int __cdecl clock_settime(clockid_t clock_id, const struct timespec *tp)
+{
+#if WINPTHREADS_TIME_BITS == 32
+  return clock_settime32 (clock_id, (struct _timespec32 *)tp);
+#else
+  return clock_settime64 (clock_id, (struct _timespec64 *)tp);
+#endif
+}
 
 #ifdef __cplusplus
 }
diff --git a/mingw-w64-libraries/winpthreads/include/semaphore.h b/mingw-w64-libraries/winpthreads/include/semaphore.h
index b6cd13f..649583f 100644
--- a/mingw-w64-libraries/winpthreads/include/semaphore.h
+++ b/mingw-w64-libraries/winpthreads/include/semaphore.h
@@ -43,7 +43,16 @@
 
 WINPTHREAD_API int sem_wait(sem_t *sem);
 
-WINPTHREAD_API int sem_timedwait(sem_t * sem, const struct timespec *t);
+WINPTHREAD_API int sem_timedwait32(sem_t * sem, const struct _timespec32 *t);
+WINPTHREAD_API int sem_timedwait64(sem_t * sem, const struct _timespec64 *t);
+WINPTHREAD_SEM_DECL int sem_timedwait(sem_t * sem, const struct timespec *t)
+{
+#if WINPTHREADS_TIME_BITS == 32
+  return sem_timedwait32 (sem, (const struct _timespec32 *) t);
+#else
+  return sem_timedwait64 (sem, (const struct _timespec64 *) t);
+#endif
+}
 
 WINPTHREAD_API int sem_post(sem_t *sem);
 
diff --git a/mingw-w64-libraries/winpthreads/src/clock.c b/mingw-w64-libraries/winpthreads/src/clock.c
index 17aa3da..922c5de 100644
--- a/mingw-w64-libraries/winpthreads/src/clock.c
+++ b/mingw-w64-libraries/winpthreads/src/clock.c
@@ -8,6 +8,7 @@
 #include "config.h"
 #endif
 
+#include <assert.h>
 #include <errno.h>
 #include <stdint.h>
 #include <time.h>
@@ -15,6 +16,8 @@
 #define WIN32_LEAN_AND_MEAN
 #include <windows.h>
 
+#define WINPTHREAD_CLOCK_DECL WINPTHREAD_API
+
 /* public header files */
 #include "pthread_time.h"
 /* internal header files */
@@ -56,7 +59,7 @@
  *         If the function fails, the return value is -1,
  *         with errno set to indicate the error.
  */
-int clock_getres(clockid_t clock_id, struct timespec *res)
+static int __clock_getres(clockid_t clock_id, struct _timespec64 *res)
 {
     clockid_t id = clock_id;
 
@@ -118,7 +121,7 @@
  *         If the function fails, the return value is -1,
  *         with errno set to indicate the error.
  */
-int clock_gettime(clockid_t clock_id, struct timespec *tp)
+static int __clock_gettime(clockid_t clock_id, struct _timespec64 *tp)
 {
     unsigned __int64 t;
     LARGE_INTEGER pf, pc;
@@ -206,20 +209,20 @@
  *         If the function fails, the return value is -1,
  *         with errno set to indicate the error.
  */
-int clock_nanosleep(clockid_t clock_id, int flags,
-                           const struct timespec *request,
-                           struct timespec *remain)
+static int __clock_nanosleep(clockid_t clock_id, int flags,
+                           const struct _timespec64 *request,
+                           struct _timespec64 *remain)
 {
-    struct timespec tp;
+    struct _timespec64 tp;
 
     if (clock_id != CLOCK_REALTIME)
         return lc_set_errno(EINVAL);
 
     if (flags == 0)
-        return nanosleep(request, remain);
+        return nanosleep64(request, remain);
 
     /* TIMER_ABSTIME = 1 */
-    clock_gettime(CLOCK_REALTIME, &tp);
+    __clock_gettime(CLOCK_REALTIME, &tp);
 
     tp.tv_sec = request->tv_sec - tp.tv_sec;
     tp.tv_nsec = request->tv_nsec - tp.tv_nsec;
@@ -228,7 +231,7 @@
         tp.tv_sec --;
     }
 
-    return nanosleep(&tp, remain);
+    return nanosleep64(&tp, remain);
 }
 
 /**
@@ -239,7 +242,7 @@
  *         If the function fails, the return value is -1,
  *         with errno set to indicate the error.
  */
-int clock_settime(clockid_t clock_id, const struct timespec *tp)
+static int __clock_settime(clockid_t clock_id, const struct _timespec64 *tp)
 {
     SYSTEMTIME st;
 
@@ -260,3 +263,92 @@
 
     return 0;
 }
+
+/**
+ * Versions to use with 64-bit time_t (struct _timespec64)
+ */
+
+int clock_getres64 (clockid_t clock_id, struct _timespec64 *tp)
+{
+    return __clock_getres (clock_id, tp);
+}
+
+int clock_gettime64 (clockid_t clock_id, struct _timespec64 *tp)
+{
+    return __clock_gettime (clock_id, tp);
+}
+
+int clock_settime64 (clockid_t clock_id, const struct _timespec64 *tp)
+{
+    return __clock_settime (clock_id, tp);
+}
+
+int clock_nanosleep64 (clockid_t clock_id, int flags,
+                const struct _timespec64 *request, struct _timespec64 *remain)
+{
+    return __clock_nanosleep (clock_id, flags, request, remain);
+}
+
+/**
+ * Versions to use with 32-bit time_t (struct _timespec32)
+ */
+
+int clock_getres32 (clockid_t clock_id, struct _timespec32 *tp)
+{
+    struct _timespec64 tp64 = {0};
+
+    if (__clock_getres (clock_id, &tp64) == -1)
+        return -1;
+
+    tp->tv_sec = (__time32_t) tp64.tv_sec;
+    tp->tv_nsec = tp64.tv_nsec;
+
+    return 0;
+}
+
+int clock_gettime32 (clockid_t clock_id, struct _timespec32 *tp)
+{
+    struct _timespec64 tp64 = {0};
+
+    if (__clock_gettime (clock_id, &tp64) == -1)
+        return -1;
+
+    if (tp64.tv_sec > INT_MAX)
+    {
+        _set_errno (EOVERFLOW);
+        return -1;
+    }
+
+    tp->tv_sec = (__time32_t) tp64.tv_sec;
+    tp->tv_nsec = tp64.tv_nsec;
+
+    return 0;
+}
+
+int clock_settime32 (clockid_t clock_id, const struct _timespec32 *tp)
+{
+    struct _timespec64 tp64 = {.tv_sec = tp->tv_sec, .tv_nsec = tp->tv_nsec};
+    return __clock_settime (clock_id, &tp64);
+}
+
+int clock_nanosleep32 (clockid_t clock_id, int flags,
+                const struct _timespec32 *request, struct _timespec32 *remain)
+{
+    struct _timespec64 request64 = {
+        .tv_sec = request->tv_sec,
+        .tv_nsec = request->tv_nsec
+    };
+    struct _timespec64 remain64 = {0};
+
+    if (__clock_nanosleep (clock_id, flags, &request64, &remain64) == -1)
+        return -1;
+
+    assert (remain64.tv_sec <= INT_MAX);
+
+    if (remain != NULL) {
+        remain->tv_sec = (__time32_t)remain64.tv_sec;
+        remain->tv_nsec = remain64.tv_nsec;
+    }
+
+    return 0;
+}
diff --git a/mingw-w64-libraries/winpthreads/src/cond.c b/mingw-w64-libraries/winpthreads/src/cond.c
index afede30..a77cd3e 100644
--- a/mingw-w64-libraries/winpthreads/src/cond.c
+++ b/mingw-w64-libraries/winpthreads/src/cond.c
@@ -36,6 +36,8 @@
 #define WIN32_LEAN_AND_MEAN
 #include <windows.h>
 
+#define WINPTHREAD_COND_DECL WINPTHREAD_API
+
 /* public header files */
 #include "pthread.h"
 #include "pthread_time.h"
@@ -124,40 +126,6 @@
 }
 
 int
-__pthread_clock_nanosleep (clockid_t clock_id, int flags, const struct timespec *rqtp,
-			   struct timespec *rmtp)
-{
-  unsigned long long tick, tick2;
-  unsigned long long delay;
-  DWORD dw;
-
-  if (clock_id != CLOCK_REALTIME
-      && clock_id != CLOCK_MONOTONIC
-      && clock_id != CLOCK_PROCESS_CPUTIME_ID)
-   return EINVAL;
-  if ((flags & TIMER_ABSTIME) != 0)
-    delay = _pthread_rel_time_in_ms (rqtp);
-  else
-    delay = _pthread_time_in_ms_from_timespec (rqtp);
-  do
-    {
-      dw = (DWORD) (delay >= 99999ULL ? 99999ULL : delay);
-      tick = _pthread_time_in_ms ();
-      _pthread_delay_np_ms (dw);
-      tick2 = _pthread_time_in_ms ();
-      tick2 -= tick;
-      if (tick2 >= delay)
-        delay = 0;
-      else
-        delay -= tick2;
-    }
-  while (delay != 0ULL);
-  if (rmtp)
-    memset (rmtp, 0, sizeof (*rmtp));
-  return 0;
-}
-
-int
 pthread_condattr_setpshared (pthread_condattr_t *a, int s)
 {
   if (!a || (s != PTHREAD_PROCESS_SHARED && s != PTHREAD_PROCESS_PRIVATE))
@@ -445,7 +413,7 @@
 }
 
 static int
-pthread_cond_timedwait_impl (pthread_cond_t *c, pthread_mutex_t *external_mutex, const struct timespec *t, int rel)
+pthread_cond_timedwait_impl (pthread_cond_t *c, pthread_mutex_t *external_mutex, const struct _timespec64 *t, int rel)
 {
   sCondWaitHelper ch;
   DWORD dwr;
@@ -511,17 +479,31 @@
 }
 
 int
-pthread_cond_timedwait(pthread_cond_t *c, pthread_mutex_t *m, const struct timespec *t)
+pthread_cond_timedwait64(pthread_cond_t *c, pthread_mutex_t *m, const struct _timespec64 *t)
 {
   return pthread_cond_timedwait_impl(c, m, t, 0);
 }
 
 int
-pthread_cond_timedwait_relative_np(pthread_cond_t *c, pthread_mutex_t *m, const struct timespec *t)
+pthread_cond_timedwait32(pthread_cond_t *c, pthread_mutex_t *m, const struct _timespec32 *t)
+{
+  struct _timespec64 t64 = {.tv_sec = t->tv_sec, .tv_nsec = t->tv_nsec};
+  return pthread_cond_timedwait_impl(c, m, &t64, 0);
+}
+
+int
+pthread_cond_timedwait64_relative_np(pthread_cond_t *c, pthread_mutex_t *m, const struct _timespec64 *t)
 {
   return pthread_cond_timedwait_impl(c, m, t, 1);
 }
 
+int
+pthread_cond_timedwait32_relative_np(pthread_cond_t *c, pthread_mutex_t *m, const struct _timespec32 *t)
+{
+  struct _timespec64 t64 = {.tv_sec = t->tv_sec, .tv_nsec = t->tv_nsec};
+  return pthread_cond_timedwait_impl(c, m, &t64, 1);
+}
+
 static void
 cleanup_wait (void *arg)
 {
diff --git a/mingw-w64-libraries/winpthreads/src/misc.c b/mingw-w64-libraries/winpthreads/src/misc.c
index 1e0d612..d9c5504 100644
--- a/mingw-w64-libraries/winpthreads/src/misc.c
+++ b/mingw-w64-libraries/winpthreads/src/misc.c
@@ -95,7 +95,7 @@
             - 0x19DB1DED53E8000ULL) / 10000ULL;
 }
 
-unsigned long long _pthread_time_in_ms_from_timespec(const struct timespec *ts)
+unsigned long long _pthread_time_in_ms_from_timespec(const struct _timespec64 *ts)
 {
     unsigned long long t = (unsigned long long) ts->tv_sec * 1000LL;
     /* The +999999 is here to ensure that the division always rounds up */
@@ -104,7 +104,7 @@
     return t;
 }
 
-unsigned long long _pthread_rel_time_in_ms(const struct timespec *ts)
+unsigned long long _pthread_rel_time_in_ms(const struct _timespec64 *ts)
 {
     unsigned long long t1 = _pthread_time_in_ms_from_timespec(ts);
     unsigned long long t2 = _pthread_time_in_ms();
diff --git a/mingw-w64-libraries/winpthreads/src/misc.h b/mingw-w64-libraries/winpthreads/src/misc.h
index 75818b4..f954ad4 100644
--- a/mingw-w64-libraries/winpthreads/src/misc.h
+++ b/mingw-w64-libraries/winpthreads/src/misc.h
@@ -75,8 +75,8 @@
 }
 
 unsigned long long _pthread_time_in_ms(void);
-unsigned long long _pthread_time_in_ms_from_timespec(const struct timespec *ts);
-unsigned long long _pthread_rel_time_in_ms(const struct timespec *ts);
+unsigned long long _pthread_time_in_ms_from_timespec(const struct _timespec64 *ts);
+unsigned long long _pthread_rel_time_in_ms(const struct _timespec64 *ts);
 unsigned long _pthread_wait_for_single_object (void *handle, unsigned long timeout);
 unsigned long _pthread_wait_for_multiple_objects (unsigned long count, void **handles, unsigned int all, unsigned long timeout);
 
diff --git a/mingw-w64-libraries/winpthreads/src/mutex.c b/mingw-w64-libraries/winpthreads/src/mutex.c
index 20d8815..b901209 100644
--- a/mingw-w64-libraries/winpthreads/src/mutex.c
+++ b/mingw-w64-libraries/winpthreads/src/mutex.c
@@ -32,6 +32,8 @@
 #define WIN32_LEAN_AND_MEAN
 #include <windows.h>
 
+#define WINPTHREAD_MUTEX_DECL WINPTHREAD_API
+
 /* public header files */
 #include "pthread.h"
 /* internal header files */
@@ -193,7 +195,8 @@
   return pthread_mutex_lock_intern (m, INFINITE);
 }
 
-int pthread_mutex_timedlock(pthread_mutex_t *m, const struct timespec *ts)
+/* Internal version which always uses `struct _timespec64`. */
+static int __pthread_mutex_timedlock(pthread_mutex_t *m, const struct _timespec64 *ts)
 {
   unsigned long long patience;
   if (ts != NULL) {
@@ -208,6 +211,17 @@
   return pthread_mutex_lock_intern(m, patience);
 }
 
+int pthread_mutex_timedlock64(pthread_mutex_t *m, const struct _timespec64 *ts)
+{
+  return __pthread_mutex_timedlock (m, ts);
+}
+
+int pthread_mutex_timedlock32(pthread_mutex_t *m, const struct _timespec32 *ts)
+{
+  struct _timespec64 ts64 = {.tv_sec = ts->tv_sec, .tv_nsec = ts->tv_nsec};
+  return __pthread_mutex_timedlock (m, &ts64);
+}
+
 int pthread_mutex_unlock(pthread_mutex_t *m)
 {
   /* Here m might an initialiser of an error-checking or recursive mutex, in
diff --git a/mingw-w64-libraries/winpthreads/src/nanosleep.c b/mingw-w64-libraries/winpthreads/src/nanosleep.c
index d1c1390..a81bf2c 100644
--- a/mingw-w64-libraries/winpthreads/src/nanosleep.c
+++ b/mingw-w64-libraries/winpthreads/src/nanosleep.c
@@ -8,12 +8,15 @@
 #include "config.h"
 #endif
 
+#include <assert.h>
 #include <errno.h>
 #include <time.h>
 
 #define WIN32_LEAN_AND_MEAN
 #include <windows.h>
 
+#define WINPTHREAD_NANOSLEEP_DECL WINPTHREAD_API
+
 /* public header files */
 #include "pthread.h"
 #include "pthread_time.h"
@@ -34,7 +37,7 @@
  *         If the function fails, the return value is -1,
  *         with errno set to indicate the error.
  */
-int nanosleep(const struct timespec *request, struct timespec *remain)
+static int __nanosleep(const struct _timespec64 *request, struct _timespec64 *remain)
 {
     unsigned long ms, rc = 0;
     unsigned __int64 u64, want, real;
@@ -78,3 +81,29 @@
 
     return 0;
 }
+
+int nanosleep64(const struct _timespec64 *request, struct _timespec64 *remain)
+{
+    return __nanosleep (request, remain);
+}
+
+int nanosleep32(const struct _timespec32 *request, struct _timespec32 *remain)
+{
+    struct _timespec64 request64 = {
+        .tv_sec = request->tv_sec,
+        .tv_nsec = request->tv_nsec
+    };
+    struct _timespec64 remain64 = {0};
+
+    if (__nanosleep (&request64, &remain64) == -1)
+        return -1;
+
+    assert (remain64.tv_sec <= INT_MAX);
+
+    if (remain != NULL) {
+        remain->tv_sec = (__time32_t)remain64.tv_sec;
+        remain->tv_nsec = remain64.tv_nsec;
+    }
+
+    return 0;
+}
diff --git a/mingw-w64-libraries/winpthreads/src/rwlock.c b/mingw-w64-libraries/winpthreads/src/rwlock.c
index 8aa62ec..68ef2a7 100644
--- a/mingw-w64-libraries/winpthreads/src/rwlock.c
+++ b/mingw-w64-libraries/winpthreads/src/rwlock.c
@@ -31,6 +31,8 @@
 #define WIN32_LEAN_AND_MEAN
 #include <windows.h>
 
+#define WINPTHREAD_RWLOCK_DECL WINPTHREAD_API
+
 /* public header files */
 #include "pthread.h"
 /* internal header files */
@@ -262,7 +264,8 @@
   return rwl_unref(rwlock_, ret);
 }
 
-int pthread_rwlock_timedrdlock (pthread_rwlock_t *rwlock_, const struct timespec *ts)
+/* Internal version which always uses `struct _timespec64`. */
+static int __pthread_rwlock_timedrdlock (pthread_rwlock_t *rwlock_, const struct _timespec64 *ts)
 {
   rwlock_t *rwlock;
   int ret;
@@ -273,12 +276,12 @@
   if(ret != 0) return ret;
 
   rwlock = (rwlock_t *)*rwlock_;
-  if ((ret = pthread_mutex_timedlock (&rwlock->mex, ts)) != 0)
+  if ((ret = pthread_mutex_timedlock64 (&rwlock->mex, ts)) != 0)
       return rwl_unref(rwlock_, ret);
   InterlockedIncrement(&rwlock->nsh_count);
   if (rwlock->nsh_count == INT_MAX)
   {
-    ret = pthread_mutex_timedlock(&rwlock->mcomplete, ts);
+    ret = pthread_mutex_timedlock64(&rwlock->mcomplete, ts);
     if (ret != 0)
     {
       if (ret == ETIMEDOUT)
@@ -295,6 +298,17 @@
   return rwl_unref(rwlock_, ret);
 }
 
+int pthread_rwlock_timedrdlock64(pthread_rwlock_t *l, const struct _timespec64 *ts)
+{
+  return __pthread_rwlock_timedrdlock (l, ts);
+}
+
+int pthread_rwlock_timedrdlock32(pthread_rwlock_t *l, const struct _timespec32 *ts)
+{
+  struct _timespec64 ts64 = {.tv_sec = ts->tv_sec, .tv_nsec = ts->tv_nsec};
+  return __pthread_rwlock_timedrdlock (l, &ts64);
+}
+
 int pthread_rwlock_tryrdlock (pthread_rwlock_t *rwlock_)
 {
   rwlock_t *rwlock;
@@ -442,7 +456,8 @@
   return rwl_unref(rwlock_,ret);
 }
 
-int pthread_rwlock_timedwrlock (pthread_rwlock_t *rwlock_, const struct timespec *ts)
+/* Internal version which always uses `struct _timespec64`. */
+static int __pthread_rwlock_timedwrlock (pthread_rwlock_t *rwlock_, const struct _timespec64 *ts)
 {
   int ret;
   rwlock_t *rwlock;
@@ -454,10 +469,10 @@
     return ret;
   rwlock = (rwlock_t *)*rwlock_;
 
-  ret = pthread_mutex_timedlock(&rwlock->mex, ts);
+  ret = pthread_mutex_timedlock64(&rwlock->mex, ts);
   if (ret != 0)
     return rwl_unref(rwlock_,ret);
-  ret = pthread_mutex_timedlock (&rwlock->mcomplete, ts);
+  ret = pthread_mutex_timedlock64(&rwlock->mcomplete, ts);
   if (ret != 0)
   {
     pthread_mutex_unlock(&rwlock->mex);
@@ -475,7 +490,7 @@
       rwlock->ncomplete = -rwlock->nsh_count;
       pthread_cleanup_push(st_cancelwrite, (void *) rwlock);
       do {
-	ret = pthread_cond_timedwait(&rwlock->ccomplete, &rwlock->mcomplete, ts);
+	ret = pthread_cond_timedwait64(&rwlock->ccomplete, &rwlock->mcomplete, ts);
       } while (rwlock->ncomplete < 0 && !ret);
       pthread_cleanup_pop(!ret ? 0 : 1);
 
@@ -488,6 +503,17 @@
   return rwl_unref(rwlock_,ret);
 }
 
+int pthread_rwlock_timedwrlock64(pthread_rwlock_t *rwlock, const struct _timespec64 *ts)
+{
+  return __pthread_rwlock_timedwrlock (rwlock, ts);
+}
+
+int pthread_rwlock_timedwrlock32(pthread_rwlock_t *rwlock, const struct _timespec32 *ts)
+{
+  struct _timespec64 ts64 = {.tv_sec = ts->tv_sec, .tv_nsec = ts->tv_nsec};
+  return __pthread_rwlock_timedwrlock (rwlock, &ts64);
+}
+
 int pthread_rwlockattr_destroy(pthread_rwlockattr_t *a)
 {
   if (!a)
diff --git a/mingw-w64-libraries/winpthreads/src/sem.c b/mingw-w64-libraries/winpthreads/src/sem.c
index 1226bb8..37abf2e 100644
--- a/mingw-w64-libraries/winpthreads/src/sem.c
+++ b/mingw-w64-libraries/winpthreads/src/sem.c
@@ -220,8 +220,9 @@
   return sem_result (ret);
 }
 
-int
-sem_timedwait (sem_t *sem, const struct timespec *t)
+/* Internal version which always uses `struct _timespec64`. */
+static int
+__sem_timedwait (sem_t *sem, const struct _timespec64 *t)
 {
   int cur_v, ret = 0;
   DWORD dwr;
@@ -259,6 +260,17 @@
   return sem_result (ret);
 }
 
+int sem_timedwait64(sem_t *sem, const struct _timespec64 *t)
+{
+  return __sem_timedwait (sem, t);
+}
+
+int sem_timedwait32(sem_t *sem, const struct _timespec32 *t)
+{
+  struct _timespec64 t64 = {.tv_sec = t->tv_sec, .tv_nsec = t->tv_nsec};
+  return __sem_timedwait (sem, &t64);
+}
+
 int
 sem_post (sem_t *sem)
 {
diff --git a/mingw-w64-libraries/winpthreads/src/thread.c b/mingw-w64-libraries/winpthreads/src/thread.c
index 6a86472..c0b36bb 100644
--- a/mingw-w64-libraries/winpthreads/src/thread.c
+++ b/mingw-w64-libraries/winpthreads/src/thread.c
@@ -34,6 +34,8 @@
 #include <windows.h>
 #include <strsafe.h>
 
+#define WINPTHREAD_THREAD_DECL WINPTHREAD_API
+
 /* public header files */
 #include "pthread.h"
 /* internal header files */
@@ -658,8 +660,8 @@
 
 /* Compatibility routine for pthread-win32.  It waits for ellapse of
    interval and additionally checks for possible thread-cancelation.  */
-int
-pthread_delay_np (const struct timespec *interval)
+static int
+__pthread_delay_np (const struct _timespec64 *interval)
 {
   DWORD to = (!interval ? 0 : dwMilliSecs (_pthread_time_in_ms_from_timespec (interval)));
   struct _pthread_v *s = __pthread_self_lite ();
@@ -681,6 +683,19 @@
 }
 
 int
+pthread_delay64_np (const struct _timespec64 *interval)
+{
+  return __pthread_delay_np(interval);
+}
+
+int
+pthread_delay32_np (const struct _timespec32 *interval)
+{
+  struct _timespec64 interval64 = {.tv_sec = interval->tv_sec, .tv_nsec = interval->tv_nsec};
+  return __pthread_delay_np(&interval64);
+}
+
+int
 _pthread_delay_np_ms (DWORD to)
 {
   struct _pthread_v *s = __pthread_self_lite ();