src/native_client_sdk/src/libraries/third_party/pthreads-win32/implement.h

   1 /*
   2  * implement.h
   3  *
   4  * Definitions that don't need to be public.
   5  *
   6  * Keeps all the internals out of pthread.h
   7  *
   8  * --------------------------------------------------------------------------
   9  *
  10  *      Pthreads-win32 - POSIX Threads Library for Win32
  11  *      Copyright(C) 1998 John E. Bossom
  12  *      Copyright(C) 1999,2005 Pthreads-win32 contributors
  13  *
  14  *      Contact Email: Ross.Johnson@homemail.com.au
  15  *
  16  *      The current list of contributors is contained
  17  *      in the file CONTRIBUTORS included with the source
  18  *      code distribution. The list can also be seen at the
  19  *      following World Wide Web location:
  20  *      http://sources.redhat.com/pthreads-win32/contributors.html
  21  *
  22  *      This library is free software; you can redistribute it and/or
  23  *      modify it under the terms of the GNU Lesser General Public
  24  *      License as published by the Free Software Foundation; either
  25  *      version 2 of the License, or (at your option) any later version.
  26  *
  27  *      This library is distributed in the hope that it will be useful,
  28  *      but WITHOUT ANY WARRANTY; without even the implied warranty of
  29  *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  30  *      Lesser General Public License for more details.
  31  *
  32  *      You should have received a copy of the GNU Lesser General Public
  33  *      License along with this library in the file COPYING.LIB;
  34  *      if not, write to the Free Software Foundation, Inc.,
  35  *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
  36  */
  37
  38 #if !defined(_IMPLEMENT_H)
  39 #define _IMPLEMENT_H
  40
  41 #if !defined(_WIN32_WINNT)
  42 #define _WIN32_WINNT 0x0400
  43 #endif
  44
  45 #include <windows.h>
  46
  47 /*
  48  * In case windows.h doesn't define it (e.g. WinCE perhaps)
  49  */
  50 #if defined(WINCE)
  51 typedef VOID (APIENTRY *PAPCFUNC)(DWORD dwParam);
  52 #endif
  53
  54 /*
  55  * note: ETIMEDOUT is correctly defined in winsock.h
  56  */
  57 #include <winsock.h>
  58
  59 /*
  60  * In case ETIMEDOUT hasn't been defined above somehow.
  61  */
  62 #if !defined(ETIMEDOUT)
  63 #  define ETIMEDOUT 10060       /* This is the value in winsock.h. */
  64 #endif
  65
  66 #if !defined(malloc)
  67 #include <malloc.h>
  68 #endif
  69
  70 #if defined(__CLEANUP_C)
  71 # include <setjmp.h>
  72 #endif
  73
  74 #if !defined(INT_MAX)
  75 #include <limits.h>
  76 #endif
  77
  78 /* use local include files during development */
  79 #include "semaphore.h"
  80 #include "sched.h"
  81
  82 #if defined(HAVE_C_INLINE) || defined(__cplusplus)
  83 #define INLINE inline
  84 #else
  85 #define INLINE
  86 #endif
  87
  88 #if defined(_MSC_VER) && _MSC_VER < 1300
  89 /*
  90  * MSVC 6 does not use the "volatile" qualifier
  91  */
  92 #define PTW32_INTERLOCKED_VOLATILE
  93 #else
  94 #define PTW32_INTERLOCKED_VOLATILE volatile
  95 #endif
  96
  97 #define PTW32_INTERLOCKED_LONG long
  98 #define PTW32_INTERLOCKED_SIZE size_t
  99 #define PTW32_INTERLOCKED_PVOID PVOID
 100 #define PTW32_INTERLOCKED_LONGPTR PTW32_INTERLOCKED_VOLATILE long*
 101 #define PTW32_INTERLOCKED_SIZEPTR PTW32_INTERLOCKED_VOLATILE size_t*
 102 #define PTW32_INTERLOCKED_PVOID_PTR PTW32_INTERLOCKED_VOLATILE PVOID*
 103
 104 #if defined(__MINGW64__) || defined(__MINGW32__)
 105 #  include <stdint.h>
 106 #elif defined(__BORLANDC__)
 107 #  define int64_t ULONGLONG
 108 #else
 109 #  define int64_t _int64
 110 #  if defined(_MSC_VER) && _MSC_VER < 1300
 111      typedef long intptr_t;
 112 #  endif
 113 #endif
 114
 115 /*
 116  * Don't allow the linker to optimize away autostatic.obj in static builds.
 117  */
 118 #if defined(PTW32_STATIC_LIB)
 119   void ptw32_autostatic_anchor(void);
 120 #   if defined(__MINGW64__) || defined(__MINGW32__)
 121     __attribute__((unused, used))
 122 #   endif
 123   static void (*local_autostatic_anchor)(void) = ptw32_autostatic_anchor;
 124 #endif
 125
 126 typedef enum
 127 {
 128   /*
 129    * This enumeration represents the state of the thread;
 130    * The thread is still "alive" if the numeric value of the
 131    * state is greater or equal "PThreadStateRunning".
 132    */
 133   PThreadStateInitial = 0,      /* Thread not running                   */
 134   PThreadStateRunning,          /* Thread alive & kicking               */
 135   PThreadStateSuspended,        /* Thread alive but suspended           */
 136   PThreadStateCancelPending,    /* Thread alive but                     */
 137                                 /* has cancelation pending.             */
 138   PThreadStateCanceling,        /* Thread alive but is                  */
 139                                 /* in the process of terminating        */
 140                                 /* due to a cancellation request        */
 141   PThreadStateExiting,          /* Thread alive but exiting             */
 142                                 /* due to an exception                  */
 143   PThreadStateLast,             /* All handlers have been run and now   */
 144                                 /* final cleanup can be done.           */
 145   PThreadStateReuse             /* In reuse pool.                       */
 146 }
 147 PThreadState;
 148
 149 typedef struct ptw32_mcs_node_t_     ptw32_mcs_local_node_t;
 150 typedef struct ptw32_mcs_node_t_*    ptw32_mcs_lock_t;
 151 typedef struct ptw32_robust_node_t_  ptw32_robust_node_t;
 152 typedef struct ptw32_thread_t_       ptw32_thread_t;
 153
 154
 155 struct ptw32_thread_t_
 156 {
 157   unsigned __int64 seqNumber;   /* Process-unique thread sequence number */
 158   HANDLE threadH;               /* Win32 thread handle - POSIX thread is invalid if threadH == 0 */
 159   pthread_t ptHandle;           /* This thread's permanent pthread_t handle */
 160   ptw32_thread_t * prevReuse;   /* Links threads on reuse stack */
 161   volatile PThreadState state;
 162   ptw32_mcs_lock_t threadLock;  /* Used for serialised access to public thread state */
 163   ptw32_mcs_lock_t stateLock;   /* Used for async-cancel safety */
 164   HANDLE cancelEvent;
 165   void *exitStatus;
 166   void *parms;
 167   void *keys;
 168   void *nextAssoc;
 169 #if defined(__CLEANUP_C)
 170   jmp_buf start_mark;           /* Jump buffer follows void* so should be aligned */
 171 #endif                          /* __CLEANUP_C */
 172 #if defined(HAVE_SIGSET_T)
 173   sigset_t sigmask;
 174 #endif                          /* HAVE_SIGSET_T */
 175   ptw32_mcs_lock_t
 176               robustMxListLock; /* robustMxList lock */
 177   ptw32_robust_node_t*
 178                   robustMxList; /* List of currenty held robust mutexes */
 179   int ptErrno;
 180   int detachState;
 181   int sched_priority;           /* As set, not as currently is */
 182   int cancelState;
 183   int cancelType;
 184   int implicit:1;
 185   DWORD thread;                 /* Win32 thread ID */
 186 #if defined(_UWIN)
 187   DWORD dummy[5];
 188 #endif
 189   size_t align;                 /* Force alignment if this struct is packed */
 190 };
 191
 192
 193 /*
 194  * Special value to mark attribute objects as valid.
 195  */
 196 #define PTW32_ATTR_VALID ((unsigned long) 0xC4C0FFEE)
 197
 198 struct pthread_attr_t_
 199 {
 200   unsigned long valid;
 201   void *stackaddr;
 202   size_t stacksize;
 203   int detachstate;
 204   struct sched_param param;
 205   int inheritsched;
 206   int contentionscope;
 207 #if defined(HAVE_SIGSET_T)
 208   sigset_t sigmask;
 209 #endif                          /* HAVE_SIGSET_T */
 210 };
 211
 212
 213 /*
 214  * ====================
 215  * ====================
 216  * Semaphores, Mutexes and Condition Variables
 217  * ====================
 218  * ====================
 219  */
 220
 221 struct sem_t_
 222 {
 223   int value;
 224   pthread_mutex_t lock;
 225   HANDLE sem;
 226 #if defined(NEED_SEM)
 227   int leftToUnblock;
 228 #endif
 229 };
 230
 231 #define PTW32_OBJECT_AUTO_INIT ((void *)(size_t) -1)
 232 #define PTW32_OBJECT_INVALID   NULL
 233
 234 struct pthread_mutex_t_
 235 {
 236   LONG lock_idx;                /* Provides exclusive access to mutex state
 237                                    via the Interlocked* mechanism.
 238                                     0: unlocked/free.
 239                                     1: locked - no other waiters.
 240                                    -1: locked - with possible other waiters.
 241                                 */
 242   int recursive_count;          /* Number of unlocks a thread needs to perform
 243                                    before the lock is released (recursive
 244                                    mutexes only). */
 245   int kind;                     /* Mutex type. */
 246   pthread_t ownerThread;
 247   HANDLE event;                 /* Mutex release notification to waiting
 248                                    threads. */
 249   ptw32_robust_node_t*
 250                     robustNode; /* Extra state for robust mutexes  */
 251 };
 252
 253 enum ptw32_robust_state_t_
 254 {
 255   PTW32_ROBUST_CONSISTENT,
 256   PTW32_ROBUST_INCONSISTENT,
 257   PTW32_ROBUST_NOTRECOVERABLE
 258 };
 259
 260 typedef enum ptw32_robust_state_t_   ptw32_robust_state_t;
 261
 262 /*
 263  * Node used to manage per-thread lists of currently-held robust mutexes.
 264  */
 265 struct ptw32_robust_node_t_
 266 {
 267   pthread_mutex_t mx;
 268   ptw32_robust_state_t stateInconsistent;
 269   ptw32_robust_node_t* prev;
 270   ptw32_robust_node_t* next;
 271 };
 272
 273 struct pthread_mutexattr_t_
 274 {
 275   int pshared;
 276   int kind;
 277   int robustness;
 278 };
 279
 280 /*
 281  * Possible values, other than PTW32_OBJECT_INVALID,
 282  * for the "interlock" element in a spinlock.
 283  *
 284  * In this implementation, when a spinlock is initialised,
 285  * the number of cpus available to the process is checked.
 286  * If there is only one cpu then "interlock" is set equal to
 287  * PTW32_SPIN_USE_MUTEX and u.mutex is an initialised mutex.
 288  * If the number of cpus is greater than 1 then "interlock"
 289  * is set equal to PTW32_SPIN_UNLOCKED and the number is
 290  * stored in u.cpus. This arrangement allows the spinlock
 291  * routines to attempt an InterlockedCompareExchange on "interlock"
 292  * immediately and, if that fails, to try the inferior mutex.
 293  *
 294  * "u.cpus" isn't used for anything yet, but could be used at
 295  * some point to optimise spinlock behaviour.
 296  */
 297 #define PTW32_SPIN_INVALID     (0)
 298 #define PTW32_SPIN_UNLOCKED    (1)
 299 #define PTW32_SPIN_LOCKED      (2)
 300 #define PTW32_SPIN_USE_MUTEX   (3)
 301
 302 struct pthread_spinlock_t_
 303 {
 304   long interlock;               /* Locking element for multi-cpus. */
 305   union
 306   {
 307     int cpus;                   /* No. of cpus if multi cpus, or   */
 308     pthread_mutex_t mutex;      /* mutex if single cpu.            */
 309   } u;
 310 };
 311
 312 /*
 313  * MCS lock queue node - see ptw32_MCS_lock.c
 314  */
 315 struct ptw32_mcs_node_t_
 316 {
 317   struct ptw32_mcs_node_t_ **lock;        /* ptr to tail of queue */
 318   struct ptw32_mcs_node_t_  *next;        /* ptr to successor in queue */
 319   HANDLE                     readyFlag;   /* set after lock is released by
 320                                              predecessor */
 321   HANDLE                     nextFlag;    /* set after 'next' ptr is set by
 322                                              successor */
 323 };
 324
 325
 326 struct pthread_barrier_t_
 327 {
 328   unsigned int nCurrentBarrierHeight;
 329   unsigned int nInitialBarrierHeight;
 330   int pshared;
 331   sem_t semBarrierBreeched;
 332   ptw32_mcs_lock_t lock;
 333   ptw32_mcs_local_node_t proxynode;
 334 };
 335
 336 struct pthread_barrierattr_t_
 337 {
 338   int pshared;
 339 };
 340
 341 struct pthread_key_t_
 342 {
 343   DWORD key;
 344   void (PTW32_CDECL *destructor) (void *);
 345   ptw32_mcs_lock_t keyLock;
 346   void *threads;
 347 };
 348
 349
 350 typedef struct ThreadParms ThreadParms;
 351
 352 struct ThreadParms
 353 {
 354   pthread_t tid;
 355   void *(PTW32_CDECL *start) (void *);
 356   void *arg;
 357 };
 358
 359
 360 struct pthread_cond_t_
 361 {
 362   long nWaitersBlocked;         /* Number of threads blocked            */
 363   long nWaitersGone;            /* Number of threads timed out          */
 364   long nWaitersToUnblock;       /* Number of threads to unblock         */
 365   sem_t semBlockQueue;          /* Queue up threads waiting for the     */
 366   /*   condition to become signalled      */
 367   sem_t semBlockLock;           /* Semaphore that guards access to      */
 368   /* | waiters blocked count/block queue  */
 369   /* +-> Mandatory Sync.LEVEL-1           */
 370   pthread_mutex_t mtxUnblockLock;       /* Mutex that guards access to          */
 371   /* | waiters (to)unblock(ed) counts     */
 372   /* +-> Optional* Sync.LEVEL-2           */
 373   pthread_cond_t next;          /* Doubly linked list                   */
 374   pthread_cond_t prev;
 375 };
 376
 377
 378 struct pthread_condattr_t_
 379 {
 380   int pshared;
 381 };
 382
 383 #define PTW32_RWLOCK_MAGIC 0xfacade2
 384
 385 struct pthread_rwlock_t_
 386 {
 387   pthread_mutex_t mtxExclusiveAccess;
 388   pthread_mutex_t mtxSharedAccessCompleted;
 389   pthread_cond_t cndSharedAccessCompleted;
 390   int nSharedAccessCount;
 391   int nExclusiveAccessCount;
 392   int nCompletedSharedAccessCount;
 393   int nMagic;
 394 };
 395
 396 struct pthread_rwlockattr_t_
 397 {
 398   int pshared;
 399 };
 400
 401 typedef struct ThreadKeyAssoc ThreadKeyAssoc;
 402
 403 struct ThreadKeyAssoc
 404 {
 405   /*
 406    * Purpose:
 407    *      This structure creates an association between a thread and a key.
 408    *      It is used to implement the implicit invocation of a user defined
 409    *      destroy routine for thread specific data registered by a user upon
 410    *      exiting a thread.
 411    *
 412    *      Graphically, the arrangement is as follows, where:
 413    *
 414    *         K - Key with destructor
 415    *            (head of chain is key->threads)
 416    *         T - Thread that has called pthread_setspecific(Kn)
 417    *            (head of chain is thread->keys)
 418    *         A - Association. Each association is a node at the
 419    *             intersection of two doubly-linked lists.
 420    *
 421    *                 T1    T2    T3
 422    *                 |     |     |
 423    *                 |     |     |
 424    *         K1 -----+-----A-----A----->
 425    *                 |     |     |
 426    *                 |     |     |
 427    *         K2 -----A-----A-----+----->
 428    *                 |     |     |
 429    *                 |     |     |
 430    *         K3 -----A-----+-----A----->
 431    *                 |     |     |
 432    *                 |     |     |
 433    *                 V     V     V
 434    *
 435    *      Access to the association is guarded by two locks: the key's
 436    *      general lock (guarding the row) and the thread's general
 437    *      lock (guarding the column). This avoids the need for a
 438    *      dedicated lock for each association, which not only consumes
 439    *      more handles but requires that the lock resources persist
 440    *      until both the key is deleted and the thread has called the
 441    *      destructor. The two-lock arrangement allows those resources
 442    *      to be freed as soon as either thread or key is concluded.
 443    *
 444    *      To avoid deadlock, whenever both locks are required both the
 445    *      key and thread locks are acquired consistently in the order
 446    *      "key lock then thread lock". An exception to this exists
 447    *      when a thread calls the destructors, however, this is done
 448    *      carefully (but inelegantly) to avoid deadlock.
 449    *
 450    *      An association is created when a thread first calls
 451    *      pthread_setspecific() on a key that has a specified
 452    *      destructor.
 453    *
 454    *      An association is destroyed either immediately after the
 455    *      thread calls the key destructor function on thread exit, or
 456    *      when the key is deleted.
 457    *
 458    * Attributes:
 459    *      thread
 460    *              reference to the thread that owns the
 461    *              association. This is actually the pointer to the
 462    *              thread struct itself. Since the association is
 463    *              destroyed before the thread exits, this can never
 464    *              point to a different logical thread to the one that
 465    *              created the assoc, i.e. after thread struct reuse.
 466    *
 467    *      key
 468    *              reference to the key that owns the association.
 469    *
 470    *      nextKey
 471    *              The pthread_t->keys attribute is the head of a
 472    *              chain of associations that runs through the nextKey
 473    *              link. This chain provides the 1 to many relationship
 474    *              between a pthread_t and all pthread_key_t on which
 475    *              it called pthread_setspecific.
 476    *
 477    *      prevKey
 478    *              Similarly.
 479    *
 480    *      nextThread
 481    *              The pthread_key_t->threads attribute is the head of
 482    *              a chain of associations that runs through the
 483    *              nextThreads link. This chain provides the 1 to many
 484    *              relationship between a pthread_key_t and all the
 485    *              PThreads that have called pthread_setspecific for
 486    *              this pthread_key_t.
 487    *
 488    *      prevThread
 489    *              Similarly.
 490    *
 491    * Notes:
 492    *      1)      As soon as either the key or the thread is no longer
 493    *              referencing the association, it can be destroyed. The
 494    *              association will be removed from both chains.
 495    *
 496    *      2)      Under WIN32, an association is only created by
 497    *              pthread_setspecific if the user provided a
 498    *              destroyRoutine when they created the key.
 499    *
 500    *
 501    */
 502   ptw32_thread_t * thread;
 503   pthread_key_t key;
 504   ThreadKeyAssoc *nextKey;
 505   ThreadKeyAssoc *nextThread;
 506   ThreadKeyAssoc *prevKey;
 507   ThreadKeyAssoc *prevThread;
 508 };
 509
 510
 511 #if defined(__CLEANUP_SEH)
 512 /*
 513  * --------------------------------------------------------------
 514  * MAKE_SOFTWARE_EXCEPTION
 515  *      This macro constructs a software exception code following
 516  *      the same format as the standard Win32 error codes as defined
 517  *      in WINERROR.H
 518  *  Values are 32 bit values laid out as follows:
 519  *
 520  *   1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
 521  *  +---+-+-+-----------------------+-------------------------------+
 522  *  |Sev|C|R|     Facility          |               Code            |
 523  *  +---+-+-+-----------------------+-------------------------------+
 524  *
 525  * Severity Values:
 526  */
 527 #define SE_SUCCESS              0x00
 528 #define SE_INFORMATION          0x01
 529 #define SE_WARNING              0x02
 530 #define SE_ERROR                0x03
 531
 532 #define MAKE_SOFTWARE_EXCEPTION( _severity, _facility, _exception ) \
 533 ( (DWORD) ( ( (_severity) << 30 ) |     /* Severity code        */ \
 534             ( 1 << 29 ) |               /* MS=0, User=1         */ \
 535             ( 0 << 28 ) |               /* Reserved             */ \
 536             ( (_facility) << 16 ) |     /* Facility Code        */ \
 537             ( (_exception) <<  0 )      /* Exception Code       */ \
 538             ) )
 539
 540 /*
 541  * We choose one specific Facility/Error code combination to
 542  * identify our software exceptions vs. WIN32 exceptions.
 543  * We store our actual component and error code within
 544  * the optional information array.
 545  */
 546 #define EXCEPTION_PTW32_SERVICES        \
 547      MAKE_SOFTWARE_EXCEPTION( SE_ERROR, \
 548                               PTW32_SERVICES_FACILITY, \
 549                               PTW32_SERVICES_ERROR )
 550
 551 #define PTW32_SERVICES_FACILITY         0xBAD
 552 #define PTW32_SERVICES_ERROR            0xDEED
 553
 554 #endif /* __CLEANUP_SEH */
 555
 556 /*
 557  * Services available through EXCEPTION_PTW32_SERVICES
 558  * and also used [as parameters to ptw32_throw()] as
 559  * generic exception selectors.
 560  */
 561
 562 #define PTW32_EPS_EXIT                  (1)
 563 #define PTW32_EPS_CANCEL                (2)
 564
 565
 566 /* Useful macros */
 567 #define PTW32_MAX(a,b)  ((a)<(b)?(b):(a))
 568 #define PTW32_MIN(a,b)  ((a)>(b)?(b):(a))
 569
 570
 571 /* Declared in pthread_cancel.c */
 572 extern DWORD (*ptw32_register_cancelation) (PAPCFUNC, HANDLE, DWORD);
 573
 574 /* Thread Reuse stack bottom marker. Must not be NULL or any valid pointer to memory. */
 575 #define PTW32_THREAD_REUSE_EMPTY ((ptw32_thread_t *)(size_t) 1)
 576
 577 extern int ptw32_processInitialized;
 578 extern ptw32_thread_t * ptw32_threadReuseTop;
 579 extern ptw32_thread_t * ptw32_threadReuseBottom;
 580 extern pthread_key_t ptw32_selfThreadKey;
 581 extern pthread_key_t ptw32_cleanupKey;
 582 extern pthread_cond_t ptw32_cond_list_head;
 583 extern pthread_cond_t ptw32_cond_list_tail;
 584
 585 extern int ptw32_mutex_default_kind;
 586
 587 extern unsigned __int64 ptw32_threadSeqNumber;
 588
 589 extern int ptw32_concurrency;
 590
 591 extern int ptw32_features;
 592
 593 extern ptw32_mcs_lock_t ptw32_thread_reuse_lock;
 594 extern ptw32_mcs_lock_t ptw32_mutex_test_init_lock;
 595 extern ptw32_mcs_lock_t ptw32_cond_list_lock;
 596 extern ptw32_mcs_lock_t ptw32_cond_test_init_lock;
 597 extern ptw32_mcs_lock_t ptw32_rwlock_test_init_lock;
 598 extern ptw32_mcs_lock_t ptw32_spinlock_test_init_lock;
 599
 600 #if defined(_UWIN)
 601 extern int pthread_count;
 602 #endif
 603
 604 #if defined(__cplusplus)
 605 extern "C"
 606 {
 607 #endif                          /* __cplusplus */
 608
 609 /*
 610  * =====================
 611  * =====================
 612  * Forward Declarations
 613  * =====================
 614  * =====================
 615  */
 616
 617   int ptw32_is_attr (const pthread_attr_t * attr);
 618
 619   int ptw32_cond_check_need_init (pthread_cond_t * cond);
 620   int ptw32_mutex_check_need_init (pthread_mutex_t * mutex);
 621   int ptw32_rwlock_check_need_init (pthread_rwlock_t * rwlock);
 622   int ptw32_spinlock_check_need_init (pthread_spinlock_t * lock);
 623
 624   int ptw32_robust_mutex_inherit(pthread_mutex_t * mutex);
 625   void ptw32_robust_mutex_add(pthread_mutex_t* mutex, pthread_t self);
 626   void ptw32_robust_mutex_remove(pthread_mutex_t* mutex, ptw32_thread_t* otp);
 627
 628   DWORD
 629     ptw32_RegisterCancelation (PAPCFUNC callback,
 630                                HANDLE threadH, DWORD callback_arg);
 631
 632   int ptw32_processInitialize (void);
 633
 634   void ptw32_processTerminate (void);
 635
 636   void ptw32_threadDestroy (pthread_t tid);
 637
 638   void ptw32_pop_cleanup_all (int execute);
 639
 640   pthread_t ptw32_new (void);
 641
 642   pthread_t ptw32_threadReusePop (void);
 643
 644   void ptw32_threadReusePush (pthread_t thread);
 645
 646   int ptw32_getprocessors (int *count);
 647
 648   int ptw32_setthreadpriority (pthread_t thread, int policy, int priority);
 649
 650   void ptw32_rwlock_cancelwrwait (void *arg);
 651
 652 #if ! (defined (__MINGW64__) || defined(__MINGW32__)) || (defined(__MSVCRT__) && ! defined(__DMC__))
 653   unsigned __stdcall
 654 #else
 655   void
 656 #endif
 657     ptw32_threadStart (void *vthreadParms);
 658
 659   void ptw32_callUserDestroyRoutines (pthread_t thread);
 660
 661   int ptw32_tkAssocCreate (ptw32_thread_t * thread, pthread_key_t key);
 662
 663   void ptw32_tkAssocDestroy (ThreadKeyAssoc * assoc);
 664
 665   int ptw32_semwait (sem_t * sem);
 666
 667   DWORD ptw32_relmillisecs (const struct timespec * abstime);
 668
 669   void ptw32_mcs_lock_acquire (ptw32_mcs_lock_t * lock, ptw32_mcs_local_node_t * node);
 670
 671   int ptw32_mcs_lock_try_acquire (ptw32_mcs_lock_t * lock, ptw32_mcs_local_node_t * node);
 672
 673   void ptw32_mcs_lock_release (ptw32_mcs_local_node_t * node);
 674
 675   void ptw32_mcs_node_transfer (ptw32_mcs_local_node_t * new_node, ptw32_mcs_local_node_t * old_node);
 676
 677 #if defined(NEED_FTIME)
 678   void ptw32_timespec_to_filetime (const struct timespec *ts, FILETIME * ft);
 679   void ptw32_filetime_to_timespec (const FILETIME * ft, struct timespec *ts);
 680 #endif
 681
 682 /* Declared in misc.c */
 683 #if defined(NEED_CALLOC)
 684 #define calloc(n, s) ptw32_calloc(n, s)
 685   void *ptw32_calloc (size_t n, size_t s);
 686 #endif
 687
 688 /* Declared in private.c */
 689 #if defined(_MSC_VER)
 690 /*
 691  * Ignore the warning:
 692  * "C++ exception specification ignored except to indicate that
 693  * the function is not __declspec(nothrow)."
 694  */
 695 #pragma warning(disable:4290)
 696 #endif
 697   void ptw32_throw (DWORD exception)
 698 #if defined(__CLEANUP_CXX)
 699     throw(ptw32_exception_cancel,ptw32_exception_exit)
 700 #endif
 701 ;
 702
 703 #if defined(__cplusplus)
 704 }
 705 #endif                          /* __cplusplus */
 706
 707
 708 #if defined(_UWIN_)
 709 #   if defined(_MT)
 710 #       if defined(__cplusplus)
 711 extern "C"
 712 {
 713 #       endif
 714   _CRTIMP unsigned long __cdecl _beginthread (void (__cdecl *) (void *),
 715                                               unsigned, void *);
 716   _CRTIMP void __cdecl _endthread (void);
 717   _CRTIMP unsigned long __cdecl _beginthreadex (void *, unsigned,
 718                                                 unsigned (__stdcall *) (void *),
 719                                                 void *, unsigned, unsigned *);
 720   _CRTIMP void __cdecl _endthreadex (unsigned);
 721 #       if defined(__cplusplus)
 722 }
 723 #       endif
 724 #   endif
 725 #else
 726 #       include <process.h>
 727 #   endif
 728
 729
 730 /*
 731  * Use intrinsic versions wherever possible. VC will do this
 732  * automatically where possible and GCC define these if available:
 733  * __GCC_HAVE_SYNC_COMPARE_AND_SWAP_1
 734  * __GCC_HAVE_SYNC_COMPARE_AND_SWAP_2
 735  * __GCC_HAVE_SYNC_COMPARE_AND_SWAP_4
 736  * __GCC_HAVE_SYNC_COMPARE_AND_SWAP_8
 737  * __GCC_HAVE_SYNC_COMPARE_AND_SWAP_16
 738  *
 739  * The full set of Interlocked intrinsics in GCC are (check versions):
 740  * type __sync_fetch_and_add (type *ptr, type value, ...)
 741  * type __sync_fetch_and_sub (type *ptr, type value, ...)
 742  * type __sync_fetch_and_or (type *ptr, type value, ...)
 743  * type __sync_fetch_and_and (type *ptr, type value, ...)
 744  * type __sync_fetch_and_xor (type *ptr, type value, ...)
 745  * type __sync_fetch_and_nand (type *ptr, type value, ...)
 746  * type __sync_add_and_fetch (type *ptr, type value, ...)
 747  * type __sync_sub_and_fetch (type *ptr, type value, ...)
 748  * type __sync_or_and_fetch (type *ptr, type value, ...)
 749  * type __sync_and_and_fetch (type *ptr, type value, ...)
 750  * type __sync_xor_and_fetch (type *ptr, type value, ...)
 751  * type __sync_nand_and_fetch (type *ptr, type value, ...)
 752  * bool __sync_bool_compare_and_swap (type *ptr, type oldval type newval, ...)
 753  * type __sync_val_compare_and_swap (type *ptr, type oldval type newval, ...)
 754  * __sync_synchronize (...) // Full memory barrier
 755  * type __sync_lock_test_and_set (type *ptr, type value, ...) // Acquire barrier
 756  * void __sync_lock_release (type *ptr, ...) // Release barrier
 757  *
 758  * These are all overloaded and take 1,2,4,8 byte scalar or pointer types.
 759  *
 760  * The above aren't available in Mingw32 as of gcc 4.5.2 so define our own.
 761  */
 762 #if defined(__cplusplus)
 763 # define PTW32_TO_VLONG64PTR(ptr) reinterpret_cast<volatile LONG64 *>(ptr)
 764 #else
 765 # define PTW32_TO_VLONG64PTR(ptr) (ptr)
 766 #endif
 767
 768 #if defined(__GNUC__)
 769 # if defined(_WIN64)
 770 # define PTW32_INTERLOCKED_COMPARE_EXCHANGE_64(location, value, comparand)    \
 771     ({                                                                     \
 772       __typeof (value) _result;                                            \
 773       __asm__ __volatile__                                                 \
 774       (                                                                    \
 775         "lock\n\t"                                                         \
 776         "cmpxchgq      %2,(%1)"                                            \
 777         :"=a" (_result)                                                    \
 778         :"r"  (location), "r" (value), "a" (comparand)                     \
 779         :"memory", "cc");                                                  \
 780       _result;                                                             \
 781     })
 782 # define PTW32_INTERLOCKED_EXCHANGE_64(location, value)                    \
 783     ({                                                                     \
 784       __typeof (value) _result;                                            \
 785       __asm__ __volatile__                                                 \
 786       (                                                                    \
 787         "xchgq   %0,(%1)"                                                  \
 788         :"=r" (_result)                                                    \
 789         :"r" (location), "0" (value)                                       \
 790         :"memory", "cc");                                                  \
 791       _result;                                                             \
 792     })
 793 # define PTW32_INTERLOCKED_EXCHANGE_ADD_64(location, value)                \
 794     ({                                                                     \
 795       __typeof (value) _result;                                            \
 796       __asm__ __volatile__                                                 \
 797       (                                                                    \
 798         "lock\n\t"                                                         \
 799         "xaddq   %0,(%1)"                                                  \
 800         :"=r" (_result)                                                    \
 801         :"r" (location), "0" (value)                                       \
 802         :"memory", "cc");                                                  \
 803       _result;                                                             \
 804     })
 805 # define PTW32_INTERLOCKED_INCREMENT_64(location)                          \
 806     ({                                                                     \
 807       PTW32_INTERLOCKED_LONG _temp = 1;                                   \
 808       __asm__ __volatile__                                                 \
 809       (                                                                    \
 810         "lock\n\t"                                                         \
 811         "xaddq   %0,(%1)"                                                  \
 812         :"+r" (_temp)                                                      \
 813         :"r" (location)                                                    \
 814         :"memory", "cc");                                                  \
 815       ++_temp;                                                             \
 816     })
 817 # define PTW32_INTERLOCKED_DECREMENT_64(location)                          \
 818     ({                                                                     \
 819       PTW32_INTERLOCKED_LONG _temp = -1;                                  \
 820       __asm__ __volatile__                                                 \
 821       (                                                                    \
 822         "lock\n\t"                                                         \
 823         "xaddq   %2,(%1)"                                                  \
 824         :"+r" (_temp)                                                      \
 825         :"r" (location)                                                    \
 826         :"memory", "cc");                                                  \
 827       --_temp;                                                             \
 828     })
 829 #endif
 830 # define PTW32_INTERLOCKED_COMPARE_EXCHANGE_LONG(location, value, comparand)    \
 831     ({                                                                     \
 832       __typeof (value) _result;                                            \
 833       __asm__ __volatile__                                                 \
 834       (                                                                    \
 835         "lock\n\t"                                                         \
 836         "cmpxchgl       %2,(%1)"                                           \
 837         :"=a" (_result)                                                    \
 838         :"r"  (location), "r" (value), "a" (comparand)                     \
 839         :"memory", "cc");                                                  \
 840       _result;                                                             \
 841     })
 842 # define PTW32_INTERLOCKED_EXCHANGE_LONG(location, value)                  \
 843     ({                                                                     \
 844       __typeof (value) _result;                                            \
 845       __asm__ __volatile__                                                 \
 846       (                                                                    \
 847         "xchgl   %0,(%1)"                                                  \
 848         :"=r" (_result)                                                    \
 849         :"r" (location), "0" (value)                                       \
 850         :"memory", "cc");                                                  \
 851       _result;                                                             \
 852     })
 853 # define PTW32_INTERLOCKED_EXCHANGE_ADD_LONG(location, value)              \
 854     ({                                                                     \
 855       __typeof (value) _result;                                            \
 856       __asm__ __volatile__                                                 \
 857       (                                                                    \
 858         "lock\n\t"                                                         \
 859         "xaddl   %0,(%1)"                                                  \
 860         :"=r" (_result)                                                    \
 861         :"r" (location), "0" (value)                                       \
 862         :"memory", "cc");                                                  \
 863       _result;                                                             \
 864     })
 865 # define PTW32_INTERLOCKED_INCREMENT_LONG(location)                        \
 866     ({                                                                     \
 867       PTW32_INTERLOCKED_LONG _temp = 1;                                   \
 868       __asm__ __volatile__                                                 \
 869       (                                                                    \
 870         "lock\n\t"                                                         \
 871         "xaddl   %0,(%1)"                                                  \
 872         :"+r" (_temp)                                                      \
 873         :"r" (location)                                                    \
 874         :"memory", "cc");                                                  \
 875       ++_temp;                                                             \
 876     })
 877 # define PTW32_INTERLOCKED_DECREMENT_LONG(location)                        \
 878     ({                                                                     \
 879       PTW32_INTERLOCKED_LONG _temp = -1;                                  \
 880       __asm__ __volatile__                                                 \
 881       (                                                                    \
 882         "lock\n\t"                                                         \
 883         "xaddl   %0,(%1)"                                                  \
 884         :"+r" (_temp)                                                      \
 885         :"r" (location)                                                    \
 886         :"memory", "cc");                                                  \
 887       --_temp;                                                             \
 888     })
 889 # define PTW32_INTERLOCKED_COMPARE_EXCHANGE_PTR(location, value, comparand) \
 890     PTW32_INTERLOCKED_COMPARE_EXCHANGE_SIZE((PTW32_INTERLOCKED_SIZEPTR)location, \
 891                                             (PTW32_INTERLOCKED_SIZE)value, \
 892                                             (PTW32_INTERLOCKED_SIZE)comparand)
 893 # define PTW32_INTERLOCKED_EXCHANGE_PTR(location, value) \
 894     PTW32_INTERLOCKED_EXCHANGE_SIZE((PTW32_INTERLOCKED_SIZEPTR)location, \
 895                                     (PTW32_INTERLOCKED_SIZE)value)
 896 #else
 897 # if defined(_WIN64)
 898 #   define PTW32_INTERLOCKED_COMPARE_EXCHANGE_64(p,v,c) InterlockedCompareExchange64(PTW32_TO_VLONG64PTR(p),(v),(c))
 899 #   define PTW32_INTERLOCKED_EXCHANGE_64(p,v) InterlockedExchange64(PTW32_TO_VLONG64PTR(p),(v))
 900 #   define PTW32_INTERLOCKED_EXCHANGE_ADD_64(p,v) InterlockedExchangeAdd64(PTW32_TO_VLONG64PTR(p),(v))
 901 #   define PTW32_INTERLOCKED_INCREMENT_64(p) InterlockedIncrement64(PTW32_TO_VLONG64PTR(p))
 902 #   define PTW32_INTERLOCKED_DECREMENT_64(p) InterlockedDecrement64(PTW32_TO_VLONG64PTR(p))
 903 # endif
 904 # if defined(_MSC_VER) && _MSC_VER < 1300 && !defined(_WIN64) /* MSVC 6 */
 905 #  define PTW32_INTERLOCKED_COMPARE_EXCHANGE_LONG(location, value, comparand) \
 906       ((LONG)InterlockedCompareExchange((PVOID *)(location), (PVOID)(value), (PVOID)(comparand)))
 907 # else
 908 #  define PTW32_INTERLOCKED_COMPARE_EXCHANGE_LONG InterlockedCompareExchange
 909 # endif
 910 # define PTW32_INTERLOCKED_EXCHANGE_LONG(p,v) InterlockedExchange((p),(v))
 911 # define PTW32_INTERLOCKED_EXCHANGE_ADD_LONG(p,v) InterlockedExchangeAdd((p),(v))
 912 # define PTW32_INTERLOCKED_INCREMENT_LONG(p) InterlockedIncrement((p))
 913 # define PTW32_INTERLOCKED_DECREMENT_LONG(p) InterlockedDecrement((p))
 914 # if defined(_MSC_VER) && _MSC_VER < 1300 && !defined(_WIN64) /* MSVC 6 */
 915 #  define PTW32_INTERLOCKED_COMPARE_EXCHANGE_PTR InterlockedCompareExchange
 916 #  define PTW32_INTERLOCKED_EXCHANGE_PTR(location, value) \
 917     ((PVOID)InterlockedExchange((LPLONG)(location), (LONG)(value)))
 918 # else
 919 #  define PTW32_INTERLOCKED_COMPARE_EXCHANGE_PTR(p,v,c) InterlockedCompareExchangePointer((p),(v),(c))
 920 #  define PTW32_INTERLOCKED_EXCHANGE_PTR(p,v) InterlockedExchangePointer((p),(v))
 921 # endif
 922 #endif
 923 #if defined(_WIN64)
 924 #   define PTW32_INTERLOCKED_COMPARE_EXCHANGE_SIZE(p,v,c) PTW32_INTERLOCKED_COMPARE_EXCHANGE_64(PTW32_TO_VLONG64PTR(p),(v),(c))
 925 #   define PTW32_INTERLOCKED_EXCHANGE_SIZE(p,v) PTW32_INTERLOCKED_EXCHANGE_64(PTW32_TO_VLONG64PTR(p),(v))
 926 #   define PTW32_INTERLOCKED_EXCHANGE_ADD_SIZE(p,v) PTW32_INTERLOCKED_EXCHANGE_ADD_64(PTW32_TO_VLONG64PTR(p),(v))
 927 #   define PTW32_INTERLOCKED_INCREMENT_SIZE(p) PTW32_INTERLOCKED_INCREMENT_64(PTW32_TO_VLONG64PTR(p))
 928 #   define PTW32_INTERLOCKED_DECREMENT_SIZE(p) PTW32_INTERLOCKED_DECREMENT_64(PTW32_TO_VLONG64PTR(p))
 929 #else
 930 #   define PTW32_INTERLOCKED_COMPARE_EXCHANGE_SIZE(p,v,c) PTW32_INTERLOCKED_COMPARE_EXCHANGE_LONG((p),(v),(c))
 931 #   define PTW32_INTERLOCKED_EXCHANGE_SIZE(p,v) PTW32_INTERLOCKED_EXCHANGE_LONG((p),(v))
 932 #   define PTW32_INTERLOCKED_EXCHANGE_ADD_SIZE(p,v) PTW32_INTERLOCKED_EXCHANGE_ADD_LONG((p),(v))
 933 #   define PTW32_INTERLOCKED_INCREMENT_SIZE(p) PTW32_INTERLOCKED_INCREMENT_LONG((p))
 934 #   define PTW32_INTERLOCKED_DECREMENT_SIZE(p) PTW32_INTERLOCKED_DECREMENT_LONG((p))
 935 #endif
 936
 937 #if defined(NEED_CREATETHREAD)
 938
 939 /*
 940  * Macro uses args so we can cast start_proc to LPTHREAD_START_ROUTINE
 941  * in order to avoid warnings because of return type
 942  */
 943
 944 #define _beginthreadex(security, \
 945                        stack_size, \
 946                        start_proc, \
 947                        arg, \
 948                        flags, \
 949                        pid) \
 950         CreateThread(security, \
 951                      stack_size, \
 952                      (LPTHREAD_START_ROUTINE) start_proc, \
 953                      arg, \
 954                      flags, \
 955                      pid)
 956
 957 #define _endthreadex ExitThread
 958
 959 #endif                          /* NEED_CREATETHREAD */
 960
 961
 962 #endif                          /* _IMPLEMENT_H */