libphobos/libdruntime/core/sys/posix/pthread.d

   1 /**
   2  * D header file for POSIX.
   3  *
   4  * Copyright: Copyright Sean Kelly 2005 - 2009.
   5  * License:   $(HTTP www.boost.org/LICENSE_1_0.txt, Boost License 1.0).
   6  * Authors:   Sean Kelly, Alex Rønne Petersen
   7  * Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
   8  */
   9
  10 /*          Copyright Sean Kelly 2005 - 2009.
  11  * Distributed under the Boost Software License, Version 1.0.
  12  *    (See accompanying file LICENSE or copy at
  13  *          http://www.boost.org/LICENSE_1_0.txt)
  14  */
  15 module core.sys.posix.pthread;
  16
  17 import core.sys.posix.config;
  18 public import core.sys.posix.sys.types;
  19 public import core.sys.posix.sched;
  20 public import core.sys.posix.time;
  21
  22 import core.stdc.stdint;
  23
  24 version (OSX)
  25     version = Darwin;
  26 else version (iOS)
  27     version = Darwin;
  28 else version (TVOS)
  29     version = Darwin;
  30 else version (WatchOS)
  31     version = Darwin;
  32
  33 version (Posix):
  34 extern (C)
  35 nothrow:
  36
  37 //
  38 // Required
  39 //
  40 /*
  41 PTHREAD_CANCEL_ASYNCHRONOUS
  42 PTHREAD_CANCEL_ENABLE
  43 PTHREAD_CANCEL_DEFERRED
  44 PTHREAD_CANCEL_DISABLE
  45 PTHREAD_CANCELED
  46 PTHREAD_COND_INITIALIZER
  47 PTHREAD_CREATE_DETACHED
  48 PTHREAD_CREATE_JOINABLE
  49 PTHREAD_EXPLICIT_SCHED
  50 PTHREAD_INHERIT_SCHED
  51 PTHREAD_MUTEX_INITIALIZER
  52 PTHREAD_ONCE_INIT
  53 PTHREAD_PROCESS_SHARED
  54 PTHREAD_PROCESS_PRIVATE
  55
  56 int pthread_atfork(void function(), void function(), void function());
  57 int pthread_attr_destroy(pthread_attr_t*);
  58 int pthread_attr_getdetachstate(const scope pthread_attr_t*, int*);
  59 int pthread_attr_getschedparam(const scope pthread_attr_t*, sched_param*);
  60 int pthread_attr_init(pthread_attr_t*);
  61 int pthread_attr_setdetachstate(pthread_attr_t*, int);
  62 int pthread_attr_setschedparam(const scope pthread_attr_t*, sched_param*);
  63 int pthread_cancel(pthread_t);
  64 void pthread_cleanup_push(void function(void*), void*);
  65 void pthread_cleanup_pop(int);
  66 int pthread_cond_broadcast(pthread_cond_t*);
  67 int pthread_cond_destroy(pthread_cond_t*);
  68 int pthread_cond_init(const scope pthread_cond_t*, pthread_condattr_t*);
  69 int pthread_cond_signal(pthread_cond_t*);
  70 int pthread_cond_timedwait(pthread_cond_t*, pthread_mutex_t*, const scope timespec*);
  71 int pthread_cond_wait(pthread_cond_t*, pthread_mutex_t*);
  72 int pthread_condattr_destroy(pthread_condattr_t*);
  73 int pthread_condattr_init(pthread_condattr_t*);
  74 int pthread_create(pthread_t*, const scope pthread_attr_t*, void* function(void*), void*);
  75 int pthread_detach(pthread_t);
  76 int pthread_equal(pthread_t, pthread_t);
  77 void pthread_exit(void*);
  78 void* pthread_getspecific(pthread_key_t);
  79 int pthread_join(pthread_t, void**);
  80 int pthread_key_create(pthread_key_t*, void function(void*));
  81 int pthread_key_delete(pthread_key_t);
  82 int pthread_mutex_destroy(pthread_mutex_t*);
  83 int pthread_mutex_init(pthread_mutex_t*, pthread_mutexattr_t*);
  84 int pthread_mutex_lock(pthread_mutex_t*);
  85 int pthread_mutex_trylock(pthread_mutex_t*);
  86 int pthread_mutex_unlock(pthread_mutex_t*);
  87 int pthread_mutexattr_destroy(pthread_mutexattr_t*);
  88 int pthread_mutexattr_init(pthread_mutexattr_t*);
  89 int pthread_once(pthread_once_t*, void function());
  90 int pthread_rwlock_destroy(pthread_rwlock_t*);
  91 int pthread_rwlock_init(pthread_rwlock_t*, const scope pthread_rwlockattr_t*);
  92 int pthread_rwlock_rdlock(pthread_rwlock_t*);
  93 int pthread_rwlock_tryrdlock(pthread_rwlock_t*);
  94 int pthread_rwlock_trywrlock(pthread_rwlock_t*);
  95 int pthread_rwlock_unlock(pthread_rwlock_t*);
  96 int pthread_rwlock_wrlock(pthread_rwlock_t*);
  97 int pthread_rwlockattr_destroy(pthread_rwlockattr_t*);
  98 int pthread_rwlockattr_init(pthread_rwlockattr_t*);
  99 pthread_t pthread_self();
 100 int pthread_setcancelstate(int, int*);
 101 int pthread_setcanceltype(int, int*);
 102 int pthread_setspecific(pthread_key_t, const scope void*);
 103 void pthread_testcancel();
 104 */
 105 version (CRuntime_Glibc)
 106 {
 107     enum
 108     {
 109         PTHREAD_CANCEL_ENABLE,
 110         PTHREAD_CANCEL_DISABLE
 111     }
 112
 113     enum
 114     {
 115         PTHREAD_CANCEL_DEFERRED,
 116         PTHREAD_CANCEL_ASYNCHRONOUS
 117     }
 118
 119     enum PTHREAD_CANCELED = cast(void*) -1;
 120
 121     //enum pthread_mutex_t PTHREAD_COND_INITIALIZER = { __LOCK_ALT_INITIALIZER, 0, "", 0 };
 122
 123     enum
 124     {
 125         PTHREAD_CREATE_JOINABLE,
 126         PTHREAD_CREATE_DETACHED
 127     }
 128
 129     enum
 130     {
 131         PTHREAD_INHERIT_SCHED,
 132         PTHREAD_EXPLICIT_SCHED
 133     }
 134
 135     enum PTHREAD_MUTEX_INITIALIZER  = pthread_mutex_t.init;
 136     enum PTHREAD_ONCE_INIT          = pthread_once_t.init;
 137
 138     enum
 139     {
 140         PTHREAD_PROCESS_PRIVATE,
 141         PTHREAD_PROCESS_SHARED
 142     }
 143 }
 144 else version (Darwin)
 145 {
 146     enum
 147     {
 148         PTHREAD_CANCEL_ENABLE   = 1,
 149         PTHREAD_CANCEL_DISABLE  = 0
 150     }
 151
 152     enum
 153     {
 154         PTHREAD_CANCEL_DEFERRED     = 2,
 155         PTHREAD_CANCEL_ASYNCHRONOUS = 0
 156     }
 157
 158     enum PTHREAD_CANCELED = cast(void*) -1;
 159
 160     //enum pthread_mutex_t PTHREAD_COND_INITIALIZER = { __LOCK_ALT_INITIALIZER, 0, "", 0 };
 161
 162     enum
 163     {
 164         PTHREAD_CREATE_JOINABLE = 1,
 165         PTHREAD_CREATE_DETACHED = 2
 166     }
 167
 168     enum
 169     {
 170         PTHREAD_INHERIT_SCHED   = 1,
 171         PTHREAD_EXPLICIT_SCHED  = 2
 172     }
 173
 174     enum PTHREAD_MUTEX_INITIALIZER  = pthread_mutex_t(0x32AAABA7);
 175     enum PTHREAD_ONCE_INIT          = pthread_once_t(0x30b1bcba);
 176
 177     enum
 178     {
 179         PTHREAD_PROCESS_PRIVATE = 2,
 180         PTHREAD_PROCESS_SHARED  = 1
 181     }
 182 }
 183 else version (FreeBSD)
 184 {
 185     enum
 186     {
 187         PTHREAD_DETACHED            = 0x1,
 188         PTHREAD_INHERIT_SCHED       = 0x4,
 189         PTHREAD_NOFLOAT             = 0x8,
 190
 191         PTHREAD_CREATE_DETACHED     = PTHREAD_DETACHED,
 192         PTHREAD_CREATE_JOINABLE     = 0,
 193         PTHREAD_EXPLICIT_SCHED      = 0,
 194     }
 195
 196     enum
 197     {
 198         PTHREAD_PROCESS_PRIVATE     = 0,
 199         PTHREAD_PROCESS_SHARED      = 1,
 200     }
 201
 202     enum
 203     {
 204         PTHREAD_CANCEL_ENABLE       = 0,
 205         PTHREAD_CANCEL_DISABLE      = 1,
 206         PTHREAD_CANCEL_DEFERRED     = 0,
 207         PTHREAD_CANCEL_ASYNCHRONOUS = 2,
 208     }
 209
 210     enum PTHREAD_CANCELED = cast(void*) -1;
 211
 212     enum PTHREAD_NEEDS_INIT = 0;
 213     enum PTHREAD_DONE_INIT  = 1;
 214
 215     enum PTHREAD_MUTEX_INITIALIZER              = null;
 216     enum PTHREAD_ONCE_INIT                      = null;
 217     enum PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP  = null;
 218     enum PTHREAD_COND_INITIALIZER               = null;
 219     enum PTHREAD_RWLOCK_INITIALIZER             = null;
 220 }
 221 else version (NetBSD)
 222 {
 223     enum PRI_NONE = -1;
 224     enum
 225     {
 226         PTHREAD_INHERIT_SCHED       = 0x0,
 227
 228         PTHREAD_CREATE_DETACHED     = 1,
 229         PTHREAD_CREATE_JOINABLE     = 0,
 230         PTHREAD_EXPLICIT_SCHED      = 1,
 231     }
 232
 233     enum
 234     {
 235         PTHREAD_PROCESS_PRIVATE     = 0,
 236         PTHREAD_PROCESS_SHARED      = 1,
 237     }
 238
 239     enum
 240     {
 241         PTHREAD_CANCEL_ENABLE       = 0,
 242         PTHREAD_CANCEL_DISABLE      = 1,
 243         PTHREAD_CANCEL_DEFERRED     = 0,
 244         PTHREAD_CANCEL_ASYNCHRONOUS = 1,
 245     }
 246
 247     enum PTHREAD_CANCELED = cast(void*) 1;
 248
 249     enum PTHREAD_DONE_INIT  = 1;
 250
 251     enum PTHREAD_MUTEX_INITIALIZER              = pthread_mutex_t(0x33330003);
 252
 253     enum PTHREAD_ONCE_INIT                      = pthread_once_t(PTHREAD_MUTEX_INITIALIZER);
 254     enum PTHREAD_COND_INITIALIZER               = pthread_cond_t(0x55550005);
 255     enum PTHREAD_RWLOCK_INITIALIZER             = pthread_rwlock_t(0x99990009);
 256 }
 257 else version (OpenBSD)
 258 {
 259     enum
 260     {
 261         PTHREAD_DETACHED            = 0x1,
 262         PTHREAD_INHERIT_SCHED       = 0x4,
 263         PTHREAD_NOFLOAT             = 0x8,
 264
 265         PTHREAD_CREATE_DETACHED     = PTHREAD_DETACHED,
 266         PTHREAD_CREATE_JOINABLE     = 0,
 267         PTHREAD_EXPLICIT_SCHED      = 0,
 268     }
 269
 270     enum
 271     {
 272         PTHREAD_PROCESS_PRIVATE     = 0,
 273         PTHREAD_PROCESS_SHARED      = 1,
 274     }
 275
 276     enum
 277     {
 278         PTHREAD_CANCEL_ENABLE       = 0,
 279         PTHREAD_CANCEL_DISABLE      = 1,
 280         PTHREAD_CANCEL_DEFERRED     = 0,
 281         PTHREAD_CANCEL_ASYNCHRONOUS = 2,
 282     }
 283
 284     enum PTHREAD_CANCELED = cast(void*) 1;
 285
 286     enum
 287     {
 288         PTHREAD_NEEDS_INIT = 0,
 289         PTHREAD_DONE_INIT  = 1,
 290     }
 291
 292     enum PTHREAD_MUTEX_INITIALIZER              = null;
 293     enum PTHREAD_ONCE_INIT                      = pthread_once_t.init;
 294     enum PTHREAD_COND_INITIALIZER               = null;
 295     enum PTHREAD_RWLOCK_INITIALIZER             = null;
 296 }
 297 else version (DragonFlyBSD)
 298 {
 299     enum
 300     {
 301         PTHREAD_DETACHED            = 0x1,
 302         //PTHREAD_SCOPE_SYSTEM        = 0x2,    // defined below
 303         PTHREAD_INHERIT_SCHED       = 0x4,
 304         PTHREAD_NOFLOAT             = 0x8,
 305
 306         PTHREAD_CREATE_DETACHED     = PTHREAD_DETACHED,
 307         PTHREAD_CREATE_JOINABLE     = 0,
 308         //PTHREAD_SCOPE_PROCESS       = 0,      // defined below
 309         PTHREAD_EXPLICIT_SCHED      = 0,
 310     }
 311
 312     enum
 313     {
 314         PTHREAD_PROCESS_PRIVATE     = 0,
 315         PTHREAD_PROCESS_SHARED      = 1,
 316     }
 317
 318     enum
 319     {
 320         PTHREAD_CANCEL_ENABLE       = 0,
 321         PTHREAD_CANCEL_DISABLE      = 1,
 322         PTHREAD_CANCEL_DEFERRED     = 0,
 323         PTHREAD_CANCEL_ASYNCHRONOUS = 2,
 324     }
 325
 326     enum PTHREAD_CANCELED = cast(void*) -1;
 327
 328     enum PTHREAD_NEEDS_INIT = 0;
 329     enum PTHREAD_DONE_INIT  = 1;
 330
 331     enum PTHREAD_MUTEX_INITIALIZER              = null;
 332     enum PTHREAD_ONCE_INIT                      = pthread_once_t.init;
 333     enum PTHREAD_COND_INITIALIZER               = null;
 334     enum PTHREAD_RWLOCK_INITIALIZER             = null;
 335 }
 336 else version (Solaris)
 337 {
 338     enum
 339     {
 340         PTHREAD_INHERIT_SCHED = 0x01,
 341         PTHREAD_NOFLOAT = 0x08,
 342         PTHREAD_CREATE_DETACHED = 0x40,
 343         PTHREAD_CREATE_JOINABLE = 0x00,
 344         PTHREAD_EXPLICIT_SCHED = 0x00,
 345     }
 346
 347     enum
 348     {
 349         PTHREAD_PROCESS_PRIVATE = 0,
 350         PTHREAD_PROCESS_SHARED = 1,
 351     }
 352
 353     enum
 354     {
 355         PTHREAD_CANCEL_ENABLE = 0,
 356         PTHREAD_CANCEL_DISABLE = 1,
 357         PTHREAD_CANCEL_DEFERRED = 0,
 358         PTHREAD_CANCEL_ASYNCHRONOUS = 2,
 359     }
 360
 361     enum PTHREAD_CANCELED = cast(void*)-19;
 362
 363     enum PTHREAD_MUTEX_INITIALIZER  = pthread_mutex_t.init;
 364     enum PTHREAD_ONCE_INIT          = pthread_once_t.init;
 365 }
 366 else version (CRuntime_Bionic)
 367 {
 368     enum
 369     {
 370         PTHREAD_CREATE_JOINABLE,
 371         PTHREAD_CREATE_DETACHED
 372     }
 373
 374     enum PTHREAD_MUTEX_INITIALIZER = pthread_mutex_t.init;
 375     enum PTHREAD_ONCE_INIT         = pthread_once_t.init;
 376
 377     enum
 378     {
 379         PTHREAD_PROCESS_PRIVATE,
 380         PTHREAD_PROCESS_SHARED
 381     }
 382 }
 383 else version (CRuntime_Musl)
 384 {
 385     enum
 386     {
 387         PTHREAD_CREATE_JOINABLE = 0,
 388         PTHREAD_CREATE_DETACHED = 1
 389     }
 390
 391     enum PTHREAD_MUTEX_INITIALIZER = pthread_mutex_t.init;
 392     enum PTHREAD_ONCE_INIT = pthread_once_t.init;
 393
 394     enum
 395     {
 396         PTHREAD_PROCESS_PRIVATE = 0,
 397         PTHREAD_PROCESS_SHARED = 1
 398     }
 399 }
 400 else version (CRuntime_UClibc)
 401 {
 402     enum
 403     {
 404         PTHREAD_CANCEL_ENABLE,
 405         PTHREAD_CANCEL_DISABLE
 406     }
 407
 408     enum
 409     {
 410         PTHREAD_CANCEL_DEFERRED,
 411         PTHREAD_CANCEL_ASYNCHRONOUS
 412     }
 413
 414     enum PTHREAD_CANCELED   = cast(void*) -1;
 415
 416     enum PTHREAD_MUTEX_INITIALIZER  = pthread_mutex_t.init;
 417     enum PTHREAD_ONCE_INIT          = pthread_once_t.init;
 418
 419     enum
 420     {
 421         PTHREAD_CREATE_JOINABLE,
 422         PTHREAD_CREATE_DETACHED
 423     }
 424
 425     enum
 426     {
 427         PTHREAD_INHERIT_SCHED,
 428         PTHREAD_EXPLICIT_SCHED
 429     }
 430
 431     enum
 432     {
 433         PTHREAD_PROCESS_PRIVATE,
 434         PTHREAD_PROCESS_SHARED
 435     }
 436 }
 437 else
 438 {
 439     static assert(false, "Unsupported platform");
 440 }
 441
 442 int pthread_atfork(void function(), void function(), void function());
 443 @nogc {
 444     int pthread_atfork(void function() @nogc, void function() @nogc, void function() @nogc);
 445     int pthread_attr_destroy(pthread_attr_t*);
 446     int pthread_attr_getdetachstate(const scope pthread_attr_t*, int*);
 447     int pthread_attr_getschedparam(const scope pthread_attr_t*, sched_param*);
 448     int pthread_attr_init(pthread_attr_t*);
 449     int pthread_attr_setdetachstate(pthread_attr_t*, int);
 450     int pthread_attr_setschedparam(const scope pthread_attr_t*, sched_param*);
 451     int pthread_cancel(pthread_t);
 452 }
 453
 454 alias void function(void*) _pthread_cleanup_routine;
 455 alias void function(void*) @nogc _pthread_cleanup_routine_nogc;
 456 version (CRuntime_Glibc)
 457 {
 458     struct _pthread_cleanup_buffer
 459     {
 460         _pthread_cleanup_routine    __routine;
 461         void*                       __arg;
 462         int                         __canceltype;
 463         _pthread_cleanup_buffer*    __prev;
 464     }
 465
 466     void _pthread_cleanup_push(_pthread_cleanup_buffer*, _pthread_cleanup_routine, void*);
 467     void _pthread_cleanup_push(_pthread_cleanup_buffer*, _pthread_cleanup_routine_nogc, void*) @nogc;
 468     void _pthread_cleanup_pop(_pthread_cleanup_buffer*, int);
 469
 470     struct pthread_cleanup
 471     {
 472         _pthread_cleanup_buffer buffer = void;
 473
 474         extern (D) void push(F: _pthread_cleanup_routine)(F routine, void* arg )
 475         {
 476             _pthread_cleanup_push( &buffer, routine, arg );
 477         }
 478
 479         extern (D) void pop()( int execute )
 480         {
 481             _pthread_cleanup_pop( &buffer, execute );
 482         }
 483     }
 484 }
 485 else version (Darwin)
 486 {
 487     struct _pthread_cleanup_buffer
 488     {
 489         _pthread_cleanup_routine    __routine;
 490         void*                       __arg;
 491         _pthread_cleanup_buffer*    __next;
 492     }
 493
 494     struct pthread_cleanup
 495     {
 496         _pthread_cleanup_buffer buffer = void;
 497
 498         extern (D) void push(F: _pthread_cleanup_routine)(F routine, void* arg )
 499         {
 500             pthread_t self       = pthread_self();
 501             buffer.__routine     = routine;
 502             buffer.__arg         = arg;
 503             buffer.__next        = cast(_pthread_cleanup_buffer*) self.__cleanup_stack;
 504             self.__cleanup_stack = cast(pthread_handler_rec*) &buffer;
 505         }
 506
 507         extern (D) void pop()( int execute )
 508         {
 509             pthread_t self       = pthread_self();
 510             self.__cleanup_stack = cast(pthread_handler_rec*) buffer.__next;
 511             if ( execute )
 512             {
 513                 buffer.__routine( buffer.__arg );
 514             }
 515         }
 516     }
 517 }
 518 else version (FreeBSD)
 519 {
 520     struct _pthread_cleanup_info
 521     {
 522         uintptr_t[8]    pthread_cleanup_pad;
 523     }
 524
 525     struct pthread_cleanup
 526     {
 527         _pthread_cleanup_info __cleanup_info__ = void;
 528
 529         extern (D) void push(F: _pthread_cleanup_routine)(F cleanup_routine, void* cleanup_arg )
 530         {
 531             __pthread_cleanup_push_imp( cleanup_routine, cleanup_arg, &__cleanup_info__ );
 532         }
 533
 534         extern (D) void pop()( int execute )
 535         {
 536             __pthread_cleanup_pop_imp( execute );
 537         }
 538     }
 539
 540     void __pthread_cleanup_push_imp(_pthread_cleanup_routine, void*, _pthread_cleanup_info*);
 541     void __pthread_cleanup_push_imp(_pthread_cleanup_routine_nogc, void*, _pthread_cleanup_info*) @nogc;
 542     void __pthread_cleanup_pop_imp(int);
 543 }
 544 else version (DragonFlyBSD)
 545 {
 546     struct _pthread_cleanup_info
 547     {
 548         uintptr_t[8]    pthread_cleanup_pad;
 549     }
 550
 551     struct pthread_cleanup
 552     {
 553         _pthread_cleanup_info __cleanup_info__ = void;
 554
 555         extern (D) void push()( _pthread_cleanup_routine cleanup_routine, void* cleanup_arg )
 556         {
 557             _pthread_cleanup_push( cleanup_routine, cleanup_arg, &__cleanup_info__ );
 558         }
 559
 560         extern (D) void pop()( int execute )
 561         {
 562             _pthread_cleanup_pop( execute );
 563         }
 564     }
 565
 566     void _pthread_cleanup_push(_pthread_cleanup_routine, void*, _pthread_cleanup_info*);
 567     void _pthread_cleanup_pop(int);
 568 }
 569 else version (NetBSD)
 570 {
 571     struct _pthread_cleanup_store
 572     {
 573         void*[4]    pthread_cleanup_pad;
 574     }
 575
 576     struct pthread_cleanup
 577     {
 578         _pthread_cleanup_store __cleanup_info__ = void;
 579
 580         extern (D) void push()( _pthread_cleanup_routine cleanup_routine, void* cleanup_arg )
 581         {
 582             pthread__cleanup_push( cleanup_routine, cleanup_arg, &__cleanup_info__ );
 583         }
 584
 585         extern (D) void pop()( int execute )
 586         {
 587             pthread__cleanup_pop( execute, &__cleanup_info__ );
 588         }
 589     }
 590
 591     void pthread__cleanup_push(_pthread_cleanup_routine, void*, void*);
 592     void pthread__cleanup_pop(int, void *);
 593 }
 594 else version (OpenBSD)
 595 {
 596     void pthread_cleanup_push(void function(void*), void*);
 597     void pthread_cleanup_pop(int);
 598 }
 599 else version (Solaris)
 600 {
 601     caddr_t _getfp();
 602
 603     struct _pthread_cleanup_info
 604     {
 605         uintptr_t[4] pthread_cleanup_pad;
 606     }
 607
 608     struct pthread_cleanup
 609     {
 610         _pthread_cleanup_info __cleanup_info__ = void;
 611
 612         extern (D) void push(F: _pthread_cleanup_routine)(F cleanup_routine, void* cleanup_arg)
 613         {
 614             __pthread_cleanup_push(cleanup_routine, cleanup_arg, _getfp(), &__cleanup_info__);
 615         }
 616
 617         extern (D) void pop()(int execute)
 618         {
 619             __pthread_cleanup_pop(execute, &__cleanup_info__);
 620         }
 621     }
 622
 623     void __pthread_cleanup_push(_pthread_cleanup_routine, void*, caddr_t, _pthread_cleanup_info*);
 624     void __pthread_cleanup_push(_pthread_cleanup_routine_nogc, void*, caddr_t, _pthread_cleanup_info*) @nogc;
 625     void __pthread_cleanup_pop(int, _pthread_cleanup_info*);
 626 }
 627 else version (CRuntime_Bionic)
 628 {
 629     struct __pthread_cleanup_t
 630     {
 631         __pthread_cleanup_t*     __cleanup_prev;
 632         _pthread_cleanup_routine __cleanup_routine;
 633         void*                    __cleanup_arg;
 634     }
 635
 636     void __pthread_cleanup_push(__pthread_cleanup_t*, _pthread_cleanup_routine, void*);
 637     void __pthread_cleanup_push(__pthread_cleanup_t*, _pthread_cleanup_routine_nogc, void*) @nogc;
 638     void __pthread_cleanup_pop(__pthread_cleanup_t*, int);
 639
 640     struct pthread_cleanup
 641     {
 642         __pthread_cleanup_t __cleanup = void;
 643
 644         extern (D) void push(F: _pthread_cleanup_routine)(F routine, void* arg )
 645         {
 646             __pthread_cleanup_push( &__cleanup, routine, arg );
 647         }
 648
 649         extern (D) void pop()( int execute )
 650         {
 651             __pthread_cleanup_pop( &__cleanup, execute );
 652         }
 653     }
 654 }
 655 else version (CRuntime_Musl)
 656 {
 657     struct __ptcb {
 658         _pthread_cleanup_routine f;
 659         void* __x;
 660         __ptcb* __next;
 661     }
 662     void _pthread_cleanup_push(__ptcb*, _pthread_cleanup_routine, void*);
 663     void _pthread_cleanup_pop(__ptcb*, int);
 664
 665     struct pthread_cleanup
 666     {
 667         __ptcb __cleanup = void;
 668
 669         extern (D) void push(F: _pthread_cleanup_routine)(F routine, void* arg )
 670         {
 671             _pthread_cleanup_push( &__cleanup, routine, arg );
 672         }
 673
 674         extern (D) void pop()( int execute )
 675         {
 676             _pthread_cleanup_pop( &__cleanup, execute );
 677         }
 678     }
 679 }
 680 else version (CRuntime_UClibc)
 681 {
 682     struct _pthread_cleanup_buffer
 683     {
 684         _pthread_cleanup_routine    __routine;
 685         void*                       __arg;
 686         int                         __canceltype;
 687         _pthread_cleanup_buffer*    __prev;
 688     }
 689
 690     void _pthread_cleanup_push(_pthread_cleanup_buffer*, _pthread_cleanup_routine, void*);
 691     void _pthread_cleanup_push(_pthread_cleanup_buffer*, _pthread_cleanup_routine_nogc, void*) @nogc;
 692     void _pthread_cleanup_pop(_pthread_cleanup_buffer*, int);
 693
 694     struct pthread_cleanup
 695     {
 696         _pthread_cleanup_buffer buffer = void;
 697
 698         extern (D) void push(F: _pthread_cleanup_routine)(F routine, void* arg )
 699         {
 700             _pthread_cleanup_push( &buffer, routine, arg );
 701         }
 702
 703         extern (D) void pop()( int execute )
 704         {
 705             _pthread_cleanup_pop( &buffer, execute );
 706         }
 707     }
 708 }
 709 else
 710 {
 711     static assert(false, "Unsupported platform");
 712 }
 713
 714 @nogc:
 715
 716 int pthread_cond_broadcast(pthread_cond_t*);
 717 int pthread_cond_destroy(pthread_cond_t*);
 718 int pthread_cond_init(const scope pthread_cond_t*, pthread_condattr_t*) @trusted;
 719 int pthread_cond_signal(pthread_cond_t*);
 720 int pthread_cond_timedwait(pthread_cond_t*, pthread_mutex_t*, const scope timespec*);
 721 int pthread_cond_wait(pthread_cond_t*, pthread_mutex_t*);
 722 int pthread_condattr_destroy(pthread_condattr_t*);
 723 int pthread_condattr_init(pthread_condattr_t*);
 724 int pthread_create(pthread_t*, const scope pthread_attr_t*, void* function(void*), void*);
 725 int pthread_detach(pthread_t);
 726 int pthread_equal(pthread_t, pthread_t);
 727 void pthread_exit(void*);
 728 void* pthread_getspecific(pthread_key_t);
 729 int pthread_join(pthread_t, void**);
 730 int pthread_key_create(pthread_key_t*, void function(void*));
 731 int pthread_key_delete(pthread_key_t);
 732 int pthread_mutex_destroy(pthread_mutex_t*);
 733 int pthread_mutex_init(pthread_mutex_t*, pthread_mutexattr_t*) @trusted;
 734 int pthread_mutex_lock(pthread_mutex_t*);
 735 int pthread_mutex_lock(shared(pthread_mutex_t)*);
 736 int pthread_mutex_trylock(pthread_mutex_t*);
 737 int pthread_mutex_trylock(shared(pthread_mutex_t)*);
 738 int pthread_mutex_unlock(pthread_mutex_t*);
 739 int pthread_mutex_unlock(shared(pthread_mutex_t)*);
 740 int pthread_mutexattr_destroy(pthread_mutexattr_t*);
 741 int pthread_mutexattr_init(pthread_mutexattr_t*) @trusted;
 742 int pthread_once(pthread_once_t*, void function());
 743 int pthread_rwlock_destroy(pthread_rwlock_t*);
 744 int pthread_rwlock_init(pthread_rwlock_t*, const scope pthread_rwlockattr_t*);
 745 int pthread_rwlock_rdlock(pthread_rwlock_t*);
 746 int pthread_rwlock_tryrdlock(pthread_rwlock_t*);
 747 int pthread_rwlock_trywrlock(pthread_rwlock_t*);
 748 int pthread_rwlock_unlock(pthread_rwlock_t*);
 749 int pthread_rwlock_wrlock(pthread_rwlock_t*);
 750 int pthread_rwlockattr_destroy(pthread_rwlockattr_t*);
 751 int pthread_rwlockattr_init(pthread_rwlockattr_t*);
 752 pthread_t pthread_self();
 753 int pthread_setcancelstate(int, int*);
 754 int pthread_setcanceltype(int, int*);
 755 int pthread_setspecific(pthread_key_t, const scope void*);
 756 void pthread_testcancel();
 757
 758 //
 759 // Barrier (BAR)
 760 //
 761 /*
 762 PTHREAD_BARRIER_SERIAL_THREAD
 763
 764 int pthread_barrier_destroy(pthread_barrier_t*);
 765 int pthread_barrier_init(pthread_barrier_t*, const scope pthread_barrierattr_t*, uint);
 766 int pthread_barrier_wait(pthread_barrier_t*);
 767 int pthread_barrierattr_destroy(pthread_barrierattr_t*);
 768 int pthread_barrierattr_getpshared(const scope pthread_barrierattr_t*, int*); (BAR|TSH)
 769 int pthread_barrierattr_init(pthread_barrierattr_t*);
 770 int pthread_barrierattr_setpshared(pthread_barrierattr_t*, int); (BAR|TSH)
 771 */
 772
 773 version (CRuntime_Glibc)
 774 {
 775     enum PTHREAD_BARRIER_SERIAL_THREAD = -1;
 776
 777     int pthread_barrier_destroy(pthread_barrier_t*);
 778     int pthread_barrier_init(pthread_barrier_t*, const scope pthread_barrierattr_t*, uint);
 779     int pthread_barrier_wait(pthread_barrier_t*);
 780     int pthread_barrierattr_destroy(pthread_barrierattr_t*);
 781     int pthread_barrierattr_getpshared(const scope pthread_barrierattr_t*, int*);
 782     int pthread_barrierattr_init(pthread_barrierattr_t*);
 783     int pthread_barrierattr_setpshared(pthread_barrierattr_t*, int);
 784 }
 785 else version (FreeBSD)
 786 {
 787     enum PTHREAD_BARRIER_SERIAL_THREAD = -1;
 788
 789     int pthread_barrier_destroy(pthread_barrier_t*);
 790     int pthread_barrier_init(pthread_barrier_t*, const scope pthread_barrierattr_t*, uint);
 791     int pthread_barrier_wait(pthread_barrier_t*);
 792     int pthread_barrierattr_destroy(pthread_barrierattr_t*);
 793     int pthread_barrierattr_getpshared(const scope pthread_barrierattr_t*, int*);
 794     int pthread_barrierattr_init(pthread_barrierattr_t*);
 795     int pthread_barrierattr_setpshared(pthread_barrierattr_t*, int);
 796 }
 797 else version (DragonFlyBSD)
 798 {
 799     enum PTHREAD_BARRIER_SERIAL_THREAD = -1;
 800     enum PTHREAD_KEYS_MAX              = 256;
 801     enum PTHREAD_STACK_MIN             = 16384;
 802     enum PTHREAD_THREADS_MAX           = c_ulong.max;
 803
 804     int pthread_barrier_destroy(pthread_barrier_t*);
 805     int pthread_barrier_init(pthread_barrier_t*, const scope pthread_barrierattr_t*, uint);
 806     int pthread_barrier_wait(pthread_barrier_t*);
 807     int pthread_barrierattr_destroy(pthread_barrierattr_t*);
 808     int pthread_barrierattr_getpshared(const scope pthread_barrierattr_t*, int*);
 809     int pthread_barrierattr_init(pthread_barrierattr_t*);
 810     int pthread_barrierattr_setpshared(pthread_barrierattr_t*, int);
 811 }
 812 else version (NetBSD)
 813 {
 814     enum PTHREAD_BARRIER_SERIAL_THREAD = 1234567;
 815
 816     int pthread_barrier_destroy(pthread_barrier_t*);
 817     int pthread_barrier_init(pthread_barrier_t*, const scope pthread_barrierattr_t*, uint);
 818     int pthread_barrier_wait(pthread_barrier_t*);
 819     int pthread_barrierattr_destroy(pthread_barrierattr_t*);
 820     int pthread_barrierattr_getpshared(const scope pthread_barrierattr_t*, int*);
 821     int pthread_barrierattr_init(pthread_barrierattr_t*);
 822     int pthread_barrierattr_setpshared(pthread_barrierattr_t*, int);
 823 }
 824 else version (OpenBSD)
 825 {
 826     enum PTHREAD_BARRIER_SERIAL_THREAD = -1;
 827
 828     int pthread_barrier_destroy(pthread_barrier_t*);
 829     int pthread_barrier_init(pthread_barrier_t*, const scope pthread_barrierattr_t*, uint);
 830     int pthread_barrier_wait(pthread_barrier_t*);
 831     int pthread_barrierattr_destroy(pthread_barrierattr_t*);
 832     int pthread_barrierattr_getpshared(const scope pthread_barrierattr_t*, int*);
 833     int pthread_barrierattr_init(pthread_barrierattr_t*);
 834     int pthread_barrierattr_setpshared(pthread_barrierattr_t*, int);
 835 }
 836 else version (Darwin)
 837 {
 838 }
 839 else version (Solaris)
 840 {
 841     enum PTHREAD_BARRIER_SERIAL_THREAD = -2;
 842
 843     int pthread_barrier_destroy(pthread_barrier_t*);
 844     int pthread_barrier_init(pthread_barrier_t*, const scope pthread_barrierattr_t*, uint);
 845     int pthread_barrier_wait(pthread_barrier_t*);
 846     int pthread_barrierattr_destroy(pthread_barrierattr_t*);
 847     int pthread_barrierattr_getpshared(const scope pthread_barrierattr_t*, int*);
 848     int pthread_barrierattr_init(pthread_barrierattr_t*);
 849     int pthread_barrierattr_setpshared(pthread_barrierattr_t*, int);
 850 }
 851 else version (CRuntime_Bionic)
 852 {
 853 }
 854 else version (CRuntime_Musl)
 855 {
 856     enum PTHREAD_BARRIER_SERIAL_THREAD = -1;
 857
 858     int pthread_barrier_destroy(pthread_barrier_t*);
 859     int pthread_barrier_init(pthread_barrier_t*, const scope pthread_barrierattr_t*, uint);
 860     int pthread_barrier_wait(pthread_barrier_t*);
 861     int pthread_barrierattr_destroy(pthread_barrierattr_t*);
 862     int pthread_barrierattr_getpshared(const scope pthread_barrierattr_t*, int*);
 863     int pthread_barrierattr_init(pthread_barrierattr_t*);
 864     int pthread_barrierattr_setpshared(pthread_barrierattr_t*, int);
 865 }
 866 else version (CRuntime_UClibc)
 867 {
 868     enum PTHREAD_BARRIER_SERIAL_THREAD = -1;
 869
 870     int pthread_barrier_destroy(pthread_barrier_t*);
 871     int pthread_barrier_init(pthread_barrier_t*, const scope pthread_barrierattr_t*, uint);
 872     int pthread_barrier_wait(pthread_barrier_t*);
 873     int pthread_barrierattr_destroy(pthread_barrierattr_t*);
 874     int pthread_barrierattr_getpshared(const scope pthread_barrierattr_t*, int*);
 875     int pthread_barrierattr_init(pthread_barrierattr_t*);
 876     int pthread_barrierattr_setpshared(pthread_barrierattr_t*, int);
 877 }
 878 else
 879 {
 880     static assert(false, "Unsupported platform");
 881 }
 882
 883 //
 884 // Clock (CS)
 885 //
 886 /*
 887 int pthread_condattr_getclock(const scope pthread_condattr_t*, clockid_t*);
 888 int pthread_condattr_setclock(pthread_condattr_t*, clockid_t);
 889 */
 890 version (CRuntime_Glibc)
 891 {
 892     int pthread_condattr_getclock(const scope pthread_condattr_t*, clockid_t*);
 893     int pthread_condattr_setclock(pthread_condattr_t*, clockid_t);
 894 }
 895 else version (FreeBSD)
 896 {
 897     int pthread_condattr_getclock(const scope pthread_condattr_t*, clockid_t*);
 898     int pthread_condattr_setclock(pthread_condattr_t*, clockid_t);
 899 }
 900 else version (DragonFlyBSD)
 901 {
 902     int pthread_condattr_getclock(const scope pthread_condattr_t*, clockid_t*);
 903     int pthread_condattr_setclock(pthread_condattr_t*, clockid_t);
 904 }
 905 else version (NetBSD)
 906 {
 907     int pthread_condattr_setclock(pthread_condattr_t*, clockid_t);
 908 }
 909 else version (OpenBSD)
 910 {
 911     int pthread_condattr_getclock(const scope pthread_condattr_t*, clockid_t*);
 912     int pthread_condattr_setclock(pthread_condattr_t*, clockid_t);
 913 }
 914 else version (Darwin)
 915 {
 916 }
 917 else version (Solaris)
 918 {
 919     int pthread_condattr_getclock(const scope pthread_condattr_t*, clockid_t*);
 920     int pthread_condattr_setclock(pthread_condattr_t*, clockid_t);
 921 }
 922 else version (CRuntime_Bionic)
 923 {
 924 }
 925 else version (CRuntime_Musl)
 926 {
 927     int pthread_condattr_getclock(const scope pthread_condattr_t*, clockid_t*);
 928     int pthread_condattr_setclock(pthread_condattr_t*, clockid_t);
 929 }
 930 else version (CRuntime_UClibc)
 931 {
 932     int pthread_condattr_getclock(const scope pthread_condattr_t*, clockid_t*);
 933     int pthread_condattr_setclock(pthread_condattr_t*, clockid_t);
 934 }
 935 else
 936 {
 937     static assert(false, "Unsupported platform");
 938 }
 939
 940 //
 941 // Spinlock (SPI)
 942 //
 943 /*
 944 int pthread_spin_destroy(pthread_spinlock_t*);
 945 int pthread_spin_init(pthread_spinlock_t*, int);
 946 int pthread_spin_lock(pthread_spinlock_t*);
 947 int pthread_spin_trylock(pthread_spinlock_t*);
 948 int pthread_spin_unlock(pthread_spinlock_t*);
 949 */
 950
 951 version (CRuntime_Glibc)
 952 {
 953     int pthread_spin_destroy(pthread_spinlock_t*);
 954     int pthread_spin_init(pthread_spinlock_t*, int);
 955     int pthread_spin_lock(pthread_spinlock_t*);
 956     int pthread_spin_trylock(pthread_spinlock_t*);
 957     int pthread_spin_unlock(pthread_spinlock_t*);
 958 }
 959 else version (FreeBSD)
 960 {
 961     int pthread_spin_init(pthread_spinlock_t*, int);
 962     int pthread_spin_destroy(pthread_spinlock_t*);
 963     int pthread_spin_lock(pthread_spinlock_t*);
 964     int pthread_spin_trylock(pthread_spinlock_t*);
 965     int pthread_spin_unlock(pthread_spinlock_t*);
 966 }
 967 else version (DragonFlyBSD)
 968 {
 969     int pthread_spin_init(pthread_spinlock_t*, int);
 970     int pthread_spin_destroy(pthread_spinlock_t*);
 971     int pthread_spin_lock(pthread_spinlock_t*);
 972     int pthread_spin_trylock(pthread_spinlock_t*);
 973     int pthread_spin_unlock(pthread_spinlock_t*);
 974 }
 975 else version (NetBSD)
 976 {
 977     int pthread_spin_init(pthread_spinlock_t*, int);
 978     int pthread_spin_destroy(pthread_spinlock_t*);
 979     int pthread_spin_lock(pthread_spinlock_t*);
 980     int pthread_spin_trylock(pthread_spinlock_t*);
 981     int pthread_spin_unlock(pthread_spinlock_t*);
 982 }
 983 else version (OpenBSD)
 984 {
 985     int pthread_spin_init(pthread_spinlock_t*, int);
 986     int pthread_spin_destroy(pthread_spinlock_t*);
 987     int pthread_spin_lock(pthread_spinlock_t*);
 988     int pthread_spin_trylock(pthread_spinlock_t*);
 989     int pthread_spin_unlock(pthread_spinlock_t*);
 990 }
 991 else version (Darwin)
 992 {
 993 }
 994 else version (Solaris)
 995 {
 996     int pthread_spin_init(pthread_spinlock_t*, int);
 997     int pthread_spin_destroy(pthread_spinlock_t*);
 998     int pthread_spin_lock(pthread_spinlock_t*);
 999     int pthread_spin_trylock(pthread_spinlock_t*);
1000     int pthread_spin_unlock(pthread_spinlock_t*);
1001 }
1002 else version (CRuntime_Bionic)
1003 {
1004 }
1005 else version (CRuntime_Musl)
1006 {
1007     int pthread_spin_destroy(pthread_spinlock_t*);
1008     int pthread_spin_init(pthread_spinlock_t*, int);
1009     int pthread_spin_lock(pthread_spinlock_t*);
1010     int pthread_spin_trylock(pthread_spinlock_t*);
1011     int pthread_spin_unlock(pthread_spinlock_t*);
1012 }
1013 else version (CRuntime_UClibc)
1014 {
1015     int pthread_spin_destroy(pthread_spinlock_t*);
1016     int pthread_spin_init(pthread_spinlock_t*, int);
1017     int pthread_spin_lock(pthread_spinlock_t*);
1018     int pthread_spin_trylock(pthread_spinlock_t*);
1019     int pthread_spin_unlock(pthread_spinlock_t*);
1020 }
1021 else
1022 {
1023     static assert(false, "Unsupported platform");
1024 }
1025
1026 //
1027 // XOpen (XSI)
1028 //
1029 /*
1030 PTHREAD_MUTEX_DEFAULT
1031 PTHREAD_MUTEX_ERRORCHECK
1032 PTHREAD_MUTEX_NORMAL
1033 PTHREAD_MUTEX_RECURSIVE
1034
1035 int pthread_attr_getguardsize(const scope pthread_attr_t*, size_t*);
1036 int pthread_attr_setguardsize(pthread_attr_t*, size_t);
1037 int pthread_getconcurrency();
1038 int pthread_mutexattr_gettype(const scope pthread_mutexattr_t*, int*);
1039 int pthread_mutexattr_settype(pthread_mutexattr_t*, int);
1040 int pthread_setconcurrency(int);
1041 */
1042
1043 version (CRuntime_Glibc)
1044 {
1045     enum PTHREAD_MUTEX_NORMAL       = 0;
1046     enum PTHREAD_MUTEX_RECURSIVE    = 1;
1047     enum PTHREAD_MUTEX_ERRORCHECK   = 2;
1048     enum PTHREAD_MUTEX_DEFAULT      = PTHREAD_MUTEX_NORMAL;
1049
1050     int pthread_attr_getguardsize(const scope pthread_attr_t*, size_t*);
1051     int pthread_attr_setguardsize(pthread_attr_t*, size_t);
1052     int pthread_getconcurrency();
1053     int pthread_mutexattr_gettype(const scope pthread_mutexattr_t*, int*);
1054     int pthread_mutexattr_settype(pthread_mutexattr_t*, int) @trusted;
1055     int pthread_setconcurrency(int);
1056 }
1057 else version (Darwin)
1058 {
1059     enum PTHREAD_MUTEX_NORMAL       = 0;
1060     enum PTHREAD_MUTEX_ERRORCHECK   = 1;
1061     enum PTHREAD_MUTEX_RECURSIVE    = 2;
1062     enum PTHREAD_MUTEX_DEFAULT      = PTHREAD_MUTEX_NORMAL;
1063
1064     int pthread_attr_getguardsize(const scope pthread_attr_t*, size_t*);
1065     int pthread_attr_setguardsize(pthread_attr_t*, size_t);
1066     int pthread_getconcurrency();
1067     int pthread_mutexattr_gettype(const scope pthread_mutexattr_t*, int*);
1068     int pthread_mutexattr_settype(pthread_mutexattr_t*, int) @trusted;
1069     int pthread_setconcurrency(int);
1070 }
1071 else version (FreeBSD)
1072 {
1073     enum
1074     {
1075         PTHREAD_MUTEX_ERRORCHECK    = 1,
1076         PTHREAD_MUTEX_RECURSIVE     = 2,
1077         PTHREAD_MUTEX_NORMAL        = 3,
1078         PTHREAD_MUTEX_ADAPTIVE_NP   = 4,
1079         PTHREAD_MUTEX_TYPE_MAX
1080     }
1081     enum PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_ERRORCHECK;
1082
1083     int pthread_attr_getguardsize(const scope pthread_attr_t*, size_t*);
1084     int pthread_attr_setguardsize(pthread_attr_t*, size_t);
1085     int pthread_getconcurrency();
1086     int pthread_mutexattr_gettype(pthread_mutexattr_t*, int*);
1087     int pthread_mutexattr_settype(pthread_mutexattr_t*, int) @trusted;
1088     int pthread_setconcurrency(int);
1089 }
1090 else version (NetBSD)
1091 {
1092     enum
1093     {
1094         PTHREAD_MUTEX_NORMAL        = 0,
1095         PTHREAD_MUTEX_ERRORCHECK    = 1,
1096         PTHREAD_MUTEX_RECURSIVE     = 2,
1097         PTHREAD_MUTEX_TYPE_MAX
1098     }
1099     enum PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_ERRORCHECK;
1100
1101     int pthread_attr_getguardsize(const scope pthread_attr_t*, size_t*);
1102     int pthread_attr_setguardsize(pthread_attr_t*, size_t);
1103     int pthread_getconcurrency();
1104     int pthread_mutexattr_gettype(pthread_mutexattr_t*, int*);
1105     int pthread_mutexattr_settype(pthread_mutexattr_t*, int) @trusted;
1106     int pthread_setconcurrency(int);
1107 }
1108 else version (OpenBSD)
1109 {
1110     enum
1111     {
1112         PTHREAD_MUTEX_ERRORCHECK    = 1,
1113         PTHREAD_MUTEX_RECURSIVE     = 2,
1114         PTHREAD_MUTEX_NORMAL        = 3,
1115         PTHREAD_MUTEX_ADAPTIVE_NP   = 4,
1116         PTHREAD_MUTEX_TYPE_MAX
1117     }
1118     enum PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_ERRORCHECK;
1119
1120     int pthread_attr_getguardsize(const scope pthread_attr_t*, size_t*);
1121     int pthread_attr_setguardsize(pthread_attr_t*, size_t);
1122     int pthread_getconcurrency();
1123     int pthread_mutexattr_gettype(pthread_mutexattr_t*, int*);
1124     int pthread_mutexattr_settype(pthread_mutexattr_t*, int) @trusted;
1125     int pthread_setconcurrency(int);
1126 }
1127 else version (DragonFlyBSD)
1128 {
1129     enum
1130     {
1131         PTHREAD_MUTEX_ERRORCHECK    = 1,
1132         PTHREAD_MUTEX_RECURSIVE     = 2,
1133         PTHREAD_MUTEX_NORMAL        = 3,
1134         PTHREAD_MUTEX_TYPE_MAX
1135     }
1136     enum PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_ERRORCHECK;
1137
1138     int pthread_attr_getguardsize(const scope pthread_attr_t*, size_t*);
1139     int pthread_attr_setguardsize(pthread_attr_t*, size_t);
1140     int pthread_getconcurrency();
1141     int pthread_mutexattr_gettype(pthread_mutexattr_t*, int*);
1142     int pthread_mutexattr_settype(pthread_mutexattr_t*, int) @trusted;
1143     int pthread_setconcurrency(int);
1144 }
1145 else version (Solaris)
1146 {
1147     enum
1148     {
1149         PTHREAD_MUTEX_ERRORCHECK    = 2,
1150         PTHREAD_MUTEX_RECURSIVE     = 4,
1151         PTHREAD_MUTEX_NORMAL        = 0,
1152     }
1153
1154     enum PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_NORMAL;
1155
1156     int pthread_attr_getguardsize(const scope pthread_attr_t*, size_t*);
1157     int pthread_attr_setguardsize(pthread_attr_t*, size_t);
1158     int pthread_getconcurrency();
1159     int pthread_mutexattr_gettype(pthread_mutexattr_t*, int*);
1160     int pthread_mutexattr_settype(pthread_mutexattr_t*, int) @trusted;
1161     int pthread_setconcurrency(int);
1162 }
1163 else version (CRuntime_Bionic)
1164 {
1165     enum PTHREAD_MUTEX_NORMAL     = 0;
1166     enum PTHREAD_MUTEX_RECURSIVE  = 1;
1167     enum PTHREAD_MUTEX_ERRORCHECK = 2;
1168     enum PTHREAD_MUTEX_DEFAULT    = PTHREAD_MUTEX_NORMAL;
1169
1170     int pthread_attr_getguardsize(const scope pthread_attr_t*, size_t*);
1171     int pthread_attr_setguardsize(pthread_attr_t*, size_t);
1172     int pthread_mutexattr_gettype(const scope pthread_mutexattr_t*, int*);
1173     int pthread_mutexattr_settype(pthread_mutexattr_t*, int) @trusted;
1174 }
1175 else version (CRuntime_Musl)
1176 {
1177     enum {
1178         PTHREAD_MUTEX_NORMAL      = 0,
1179         PTHREAD_MUTEX_RECURSIVE   = 1,
1180         PTHREAD_MUTEX_ERRORCHECK  = 2,
1181         PTHREAD_MUTEX_DEFAULT     = PTHREAD_MUTEX_NORMAL,
1182     }
1183     int pthread_mutexattr_settype(pthread_mutexattr_t*, int) @trusted;
1184 }
1185 else version (CRuntime_UClibc)
1186 {
1187     enum
1188     {
1189       PTHREAD_MUTEX_TIMED_NP,
1190       PTHREAD_MUTEX_RECURSIVE_NP,
1191       PTHREAD_MUTEX_ERRORCHECK_NP,
1192       PTHREAD_MUTEX_ADAPTIVE_NP,
1193       PTHREAD_MUTEX_NORMAL = PTHREAD_MUTEX_TIMED_NP,
1194       PTHREAD_MUTEX_RECURSIVE = PTHREAD_MUTEX_RECURSIVE_NP,
1195       PTHREAD_MUTEX_ERRORCHECK = PTHREAD_MUTEX_ERRORCHECK_NP,
1196       PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_NORMAL,
1197       PTHREAD_MUTEX_FAST_NP = PTHREAD_MUTEX_TIMED_NP
1198     }
1199
1200     int pthread_attr_getguardsize(const scope pthread_attr_t*, size_t*);
1201     int pthread_attr_setguardsize(pthread_attr_t*, size_t);
1202     int pthread_getconcurrency();
1203     int pthread_mutexattr_gettype(const scope pthread_mutexattr_t*, int*);
1204     int pthread_mutexattr_settype(pthread_mutexattr_t*, int) @trusted;
1205     int pthread_setconcurrency(int);
1206 }
1207 else
1208 {
1209     static assert(false, "Unsupported platform");
1210 }
1211
1212 //
1213 // CPU Time (TCT)
1214 //
1215 /*
1216 int pthread_getcpuclockid(pthread_t, clockid_t*);
1217 */
1218
1219 version (CRuntime_Glibc)
1220 {
1221     int pthread_getcpuclockid(pthread_t, clockid_t*);
1222 }
1223 else version (FreeBSD)
1224 {
1225     int pthread_getcpuclockid(pthread_t, clockid_t*);
1226 }
1227 else version (DragonFlyBSD)
1228 {
1229     int pthread_getcpuclockid(pthread_t, clockid_t*);
1230 }
1231 else version (NetBSD)
1232 {
1233 }
1234 else version (OpenBSD)
1235 {
1236     int pthread_getcpuclockid(pthread_t, clockid_t*);
1237 }
1238 else version (Darwin)
1239 {
1240 }
1241 else version (Solaris)
1242 {
1243 }
1244 else version (CRuntime_Bionic)
1245 {
1246     int pthread_getcpuclockid(pthread_t, clockid_t*);
1247 }
1248 else version (CRuntime_Musl)
1249 {
1250     int pthread_getcpuclockid(pthread_t, clockid_t*);
1251 }
1252 else version (CRuntime_UClibc)
1253 {
1254     int pthread_getcpuclockid(pthread_t, clockid_t*);
1255 }
1256 else
1257 {
1258     static assert(false, "Unsupported platform");
1259 }
1260
1261 //
1262 // Timeouts (TMO)
1263 //
1264 /*
1265 int pthread_mutex_timedlock(pthread_mutex_t*, const scope timespec*);
1266 int pthread_rwlock_timedrdlock(pthread_rwlock_t*, const scope timespec*);
1267 int pthread_rwlock_timedwrlock(pthread_rwlock_t*, const scope timespec*);
1268 */
1269
1270 version (CRuntime_Glibc)
1271 {
1272     int pthread_mutex_timedlock(pthread_mutex_t*, const scope timespec*);
1273     int pthread_rwlock_timedrdlock(pthread_rwlock_t*, const scope timespec*);
1274     int pthread_rwlock_timedwrlock(pthread_rwlock_t*, const scope timespec*);
1275 }
1276 else version (Darwin)
1277 {
1278     int pthread_mutex_timedlock(pthread_mutex_t*, const scope timespec*);
1279     int pthread_rwlock_timedrdlock(pthread_rwlock_t*, const scope timespec*);
1280     int pthread_rwlock_timedwrlock(pthread_rwlock_t*, const scope timespec*);
1281 }
1282 else version (FreeBSD)
1283 {
1284     int pthread_mutex_timedlock(pthread_mutex_t*, const scope timespec*);
1285     int pthread_rwlock_timedrdlock(pthread_rwlock_t*, const scope timespec*);
1286     int pthread_rwlock_timedwrlock(pthread_rwlock_t*, const scope timespec*);
1287 }
1288 else version (NetBSD)
1289 {
1290     int pthread_mutex_timedlock(pthread_mutex_t*, const scope timespec*);
1291     int pthread_rwlock_timedrdlock(pthread_rwlock_t*, const scope timespec*);
1292     int pthread_rwlock_timedwrlock(pthread_rwlock_t*, const scope timespec*);
1293 }
1294 else version (OpenBSD)
1295 {
1296     int pthread_mutex_timedlock(pthread_mutex_t*, const scope timespec*);
1297     int pthread_rwlock_timedrdlock(pthread_rwlock_t*, const scope timespec*);
1298     int pthread_rwlock_timedwrlock(pthread_rwlock_t*, const scope timespec*);
1299 }
1300 else version (DragonFlyBSD)
1301 {
1302     int pthread_mutex_timedlock(pthread_mutex_t*, const scope timespec*);
1303     int pthread_rwlock_timedrdlock(pthread_rwlock_t*, const scope timespec*);
1304     int pthread_rwlock_timedwrlock(pthread_rwlock_t*, const scope timespec*);
1305 }
1306 else version (Solaris)
1307 {
1308     int pthread_mutex_timedlock(pthread_mutex_t*, const scope timespec*);
1309     int pthread_rwlock_timedrdlock(pthread_rwlock_t*, const scope timespec*);
1310     int pthread_rwlock_timedwrlock(pthread_rwlock_t*, const scope timespec*);
1311 }
1312 else version (CRuntime_Bionic)
1313 {
1314     int pthread_rwlock_timedrdlock(pthread_rwlock_t*, const scope timespec*);
1315     int pthread_rwlock_timedwrlock(pthread_rwlock_t*, const scope timespec*);
1316 }
1317 else version (CRuntime_Musl)
1318 {
1319     int pthread_mutex_timedlock(pthread_mutex_t*, const scope timespec*);
1320     int pthread_rwlock_timedrdlock(pthread_rwlock_t*, const scope timespec*);
1321     int pthread_rwlock_timedwrlock(pthread_rwlock_t*, const scope timespec*);
1322 }
1323 else version (CRuntime_UClibc)
1324 {
1325     int pthread_mutex_timedlock(pthread_mutex_t*, const scope timespec*);
1326     int pthread_rwlock_timedrdlock(pthread_rwlock_t*, const scope timespec*);
1327     int pthread_rwlock_timedwrlock(pthread_rwlock_t*, const scope timespec*);
1328 }
1329 else
1330 {
1331     static assert(false, "Unsupported platform");
1332 }
1333
1334 //
1335 // Priority (TPI|TPP)
1336 //
1337 /*
1338 PTHREAD_PRIO_INHERIT (TPI)
1339 PTHREAD_PRIO_NONE (TPP|TPI)
1340 PTHREAD_PRIO_PROTECT (TPI)
1341
1342 int pthread_mutex_getprioceiling(const scope pthread_mutex_t*, int*); (TPP)
1343 int pthread_mutex_setprioceiling(pthread_mutex_t*, int, int*); (TPP)
1344 int pthread_mutexattr_getprioceiling(pthread_mutexattr_t*, int*); (TPP)
1345 int pthread_mutexattr_getprotocol(const scope pthread_mutexattr_t*, int*); (TPI|TPP)
1346 int pthread_mutexattr_setprioceiling(pthread_mutexattr_t*, int); (TPP)
1347 int pthread_mutexattr_setprotocol(pthread_mutexattr_t*, int); (TPI|TPP)
1348 */
1349 version (Darwin)
1350 {
1351     enum
1352     {
1353         PTHREAD_PRIO_NONE,
1354         PTHREAD_PRIO_INHERIT,
1355         PTHREAD_PRIO_PROTECT
1356     }
1357
1358     int pthread_mutex_getprioceiling(const scope pthread_mutex_t*, int*);
1359     int pthread_mutex_setprioceiling(pthread_mutex_t*, int, int*);
1360     int pthread_mutexattr_getprioceiling(const scope pthread_mutexattr_t*, int*);
1361     int pthread_mutexattr_getprotocol(const scope pthread_mutexattr_t*, int*);
1362     int pthread_mutexattr_setprioceiling(pthread_mutexattr_t*, int);
1363     int pthread_mutexattr_setprotocol(pthread_mutexattr_t*, int);
1364 }
1365 else version (Solaris)
1366 {
1367     enum
1368     {
1369         PTHREAD_PRIO_NONE    = 0x00,
1370         PTHREAD_PRIO_INHERIT = 0x10,
1371         PTHREAD_PRIO_PROTECT = 0x20,
1372     }
1373
1374     int pthread_mutex_getprioceiling(const scope pthread_mutex_t*, int*);
1375     int pthread_mutex_setprioceiling(pthread_mutex_t*, int, int*);
1376     int pthread_mutexattr_getprioceiling(const scope pthread_mutexattr_t*, int*);
1377     int pthread_mutexattr_getprotocol(const scope pthread_mutexattr_t*, int*);
1378     int pthread_mutexattr_setprioceiling(pthread_mutexattr_t*, int);
1379     int pthread_mutexattr_setprotocol(pthread_mutexattr_t*, int);
1380 }
1381
1382 //
1383 // Scheduling (TPS)
1384 //
1385 /*
1386 PTHREAD_SCOPE_PROCESS
1387 PTHREAD_SCOPE_SYSTEM
1388
1389 int pthread_attr_getinheritsched(const scope pthread_attr_t*, int*);
1390 int pthread_attr_getschedpolicy(const scope pthread_attr_t*, int*);
1391 int pthread_attr_getscope(const scope pthread_attr_t*, int*);
1392 int pthread_attr_setinheritsched(pthread_attr_t*, int);
1393 int pthread_attr_setschedpolicy(pthread_attr_t*, int);
1394 int pthread_attr_setscope(pthread_attr_t*, int);
1395 int pthread_getschedparam(pthread_t, int*, sched_param*);
1396 int pthread_setschedparam(pthread_t, int, const scope sched_param*);
1397 int pthread_setschedprio(pthread_t, int);
1398 */
1399
1400 version (CRuntime_Glibc)
1401 {
1402     enum
1403     {
1404         PTHREAD_SCOPE_SYSTEM,
1405         PTHREAD_SCOPE_PROCESS
1406     }
1407
1408     int pthread_attr_getinheritsched(const scope pthread_attr_t*, int*);
1409     int pthread_attr_getschedpolicy(const scope pthread_attr_t*, int*);
1410     int pthread_attr_getscope(const scope pthread_attr_t*, int*);
1411     int pthread_attr_setinheritsched(pthread_attr_t*, int);
1412     int pthread_attr_setschedpolicy(pthread_attr_t*, int);
1413     int pthread_attr_setscope(pthread_attr_t*, int);
1414     int pthread_getschedparam(pthread_t, int*, sched_param*);
1415     int pthread_setschedparam(pthread_t, int, const scope sched_param*);
1416     int pthread_setschedprio(pthread_t, int);
1417 }
1418 else version (Darwin)
1419 {
1420     enum
1421     {
1422         PTHREAD_SCOPE_SYSTEM    = 1,
1423         PTHREAD_SCOPE_PROCESS   = 2
1424     }
1425
1426     int pthread_attr_getinheritsched(const scope pthread_attr_t*, int*);
1427     int pthread_attr_getschedpolicy(const scope pthread_attr_t*, int*);
1428     int pthread_attr_getscope(const scope pthread_attr_t*, int*);
1429     int pthread_attr_setinheritsched(pthread_attr_t*, int);
1430     int pthread_attr_setschedpolicy(pthread_attr_t*, int);
1431     int pthread_attr_setscope(pthread_attr_t*, int);
1432     int pthread_getschedparam(pthread_t, int*, sched_param*);
1433     int pthread_setschedparam(pthread_t, int, const scope sched_param*);
1434     // int pthread_setschedprio(pthread_t, int); // not implemented
1435 }
1436 else version (FreeBSD)
1437 {
1438     enum
1439     {
1440         PTHREAD_SCOPE_PROCESS   = 0,
1441         PTHREAD_SCOPE_SYSTEM    = 0x2
1442     }
1443
1444     int pthread_attr_getinheritsched(const scope pthread_attr_t*, int*);
1445     int pthread_attr_getschedpolicy(const scope pthread_attr_t*, int*);
1446     int pthread_attr_getscope(const scope pthread_attr_t*, int*);
1447     int pthread_attr_setinheritsched(pthread_attr_t*, int);
1448     int pthread_attr_setschedpolicy(pthread_attr_t*, int);
1449     int pthread_attr_setscope(const scope pthread_attr_t*, int);
1450     int pthread_getschedparam(pthread_t, int*, sched_param*);
1451     int pthread_setschedparam(pthread_t, int, sched_param*);
1452     // int pthread_setschedprio(pthread_t, int); // not implemented
1453 }
1454 else version (NetBSD)
1455 {
1456     enum
1457     {
1458         PTHREAD_SCOPE_PROCESS   = 0,
1459         PTHREAD_SCOPE_SYSTEM    = 0x1
1460     }
1461
1462     int pthread_attr_getinheritsched(const scope pthread_attr_t*, int*);
1463     int pthread_attr_getschedpolicy(const scope pthread_attr_t*, int*);
1464     int pthread_attr_getscope(const scope pthread_attr_t*, int*);
1465     int pthread_attr_setinheritsched(pthread_attr_t*, int);
1466     int pthread_attr_setschedpolicy(pthread_attr_t*, int);
1467     int pthread_attr_setscope(const scope pthread_attr_t*, int);
1468     int pthread_getschedparam(pthread_t, int*, sched_param*);
1469     int pthread_setschedparam(pthread_t, int, sched_param*);
1470     //int pthread_setschedprio(pthread_t, int);
1471 }
1472 else version (OpenBSD)
1473 {
1474     enum
1475     {
1476         PTHREAD_SCOPE_PROCESS   = 0,
1477         PTHREAD_SCOPE_SYSTEM    = 0x2
1478     }
1479
1480     int pthread_attr_getinheritsched(const scope pthread_attr_t*, int*);
1481     int pthread_attr_getschedpolicy(const scope pthread_attr_t*, int*);
1482     int pthread_attr_getscope(const scope pthread_attr_t*, int*);
1483     int pthread_attr_setinheritsched(pthread_attr_t*, int);
1484     int pthread_attr_setschedpolicy(pthread_attr_t*, int);
1485     int pthread_attr_setscope(const scope pthread_attr_t*, int);
1486     int pthread_getschedparam(pthread_t, int*, sched_param*);
1487     int pthread_setschedparam(pthread_t, int, sched_param*);
1488     // int pthread_setschedprio(pthread_t, int); // not implemented
1489 }
1490 else version (DragonFlyBSD)
1491 {
1492     enum
1493     {
1494         PTHREAD_SCOPE_PROCESS   = 0,
1495         PTHREAD_SCOPE_SYSTEM    = 0x2
1496     }
1497
1498     int pthread_attr_getinheritsched(const scope pthread_attr_t*, int*);
1499     int pthread_attr_getschedpolicy(const scope pthread_attr_t*, int*);
1500     int pthread_attr_getscope(const scope pthread_attr_t*, int*);
1501     int pthread_attr_setinheritsched(pthread_attr_t*, int);
1502     int pthread_attr_setschedpolicy(pthread_attr_t*, int);
1503     int pthread_attr_setscope(const scope pthread_attr_t*, int);
1504     int pthread_getschedparam(pthread_t, int*, sched_param*);
1505     int pthread_setschedparam(pthread_t, int, sched_param*);
1506 }
1507 else version (Solaris)
1508 {
1509     enum
1510     {
1511         PTHREAD_SCOPE_PROCESS = 0,
1512         PTHREAD_SCOPE_SYSTEM = 1,
1513     }
1514
1515     int pthread_attr_getinheritsched(const scope pthread_attr_t*, int*);
1516     int pthread_attr_getschedpolicy(const scope pthread_attr_t*, int*);
1517     int pthread_attr_getscope(const scope pthread_attr_t*, int*);
1518     int pthread_attr_setinheritsched(pthread_attr_t*, int);
1519     int pthread_attr_setschedpolicy(pthread_attr_t*, int);
1520     int pthread_attr_setscope(const scope pthread_attr_t*, int);
1521     int pthread_getschedparam(pthread_t, int*, sched_param*);
1522     int pthread_setschedparam(pthread_t, int, sched_param*);
1523     int pthread_setschedprio(pthread_t, int);
1524 }
1525 else version (CRuntime_Bionic)
1526 {
1527     enum
1528     {
1529         PTHREAD_SCOPE_SYSTEM,
1530         PTHREAD_SCOPE_PROCESS
1531     }
1532
1533     int pthread_attr_getschedpolicy(const scope pthread_attr_t*, int*);
1534     int pthread_attr_getscope(const scope pthread_attr_t*);
1535     int pthread_attr_setschedpolicy(pthread_attr_t*, int);
1536     int pthread_attr_setscope(pthread_attr_t*, int);
1537     int pthread_getschedparam(pthread_t, int*, sched_param*);
1538     int pthread_setschedparam(pthread_t, int, const scope sched_param*);
1539 }
1540 else version (CRuntime_Musl)
1541 {
1542     enum
1543     {
1544         PTHREAD_SCOPE_SYSTEM,
1545         PTHREAD_SCOPE_PROCESS
1546     }
1547
1548     int pthread_getschedparam(pthread_t, int*, sched_param*);
1549     int pthread_setschedparam(pthread_t, int, const scope sched_param*);
1550     int pthread_setschedprio(pthread_t, int);
1551 }
1552 else version (CRuntime_UClibc)
1553 {
1554     enum
1555     {
1556         PTHREAD_SCOPE_SYSTEM,
1557         PTHREAD_SCOPE_PROCESS
1558     }
1559
1560     int pthread_attr_getinheritsched(const scope pthread_attr_t*, int*);
1561     int pthread_attr_getschedpolicy(const scope pthread_attr_t*, int*);
1562     int pthread_attr_getscope(const scope pthread_attr_t*, int*);
1563     int pthread_attr_setinheritsched(pthread_attr_t*, int);
1564     int pthread_attr_setschedpolicy(pthread_attr_t*, int);
1565     int pthread_attr_setscope(pthread_attr_t*, int);
1566     int pthread_getschedparam(pthread_t, int*, sched_param*);
1567     int pthread_setschedparam(pthread_t, int, const scope sched_param*);
1568     int pthread_setschedprio(pthread_t, int);
1569 }
1570 else
1571 {
1572     static assert(false, "Unsupported platform");
1573 }
1574
1575 //
1576 // Stack (TSA|TSS)
1577 //
1578 /*
1579 int pthread_attr_getstack(const scope pthread_attr_t*, void**, size_t*); (TSA|TSS)
1580 int pthread_attr_getstackaddr(const scope pthread_attr_t*, void**); (TSA)
1581 int pthread_attr_getstacksize(const scope pthread_attr_t*, size_t*); (TSS)
1582 int pthread_attr_setstack(pthread_attr_t*, void*, size_t); (TSA|TSS)
1583 int pthread_attr_setstackaddr(pthread_attr_t*, void*); (TSA)
1584 int pthread_attr_setstacksize(pthread_attr_t*, size_t); (TSS)
1585 */
1586
1587 version (CRuntime_Glibc)
1588 {
1589     int pthread_attr_getstack(const scope pthread_attr_t*, void**, size_t*);
1590     int pthread_attr_getstackaddr(const scope pthread_attr_t*, void**);
1591     int pthread_attr_getstacksize(const scope pthread_attr_t*, size_t*);
1592     int pthread_attr_setstack(pthread_attr_t*, void*, size_t);
1593     int pthread_attr_setstackaddr(pthread_attr_t*, void*);
1594     int pthread_attr_setstacksize(pthread_attr_t*, size_t);
1595 }
1596 else version (Darwin)
1597 {
1598     int pthread_attr_getstack(const scope pthread_attr_t*, void**, size_t*);
1599     int pthread_attr_getstackaddr(const scope pthread_attr_t*, void**);
1600     int pthread_attr_getstacksize(const scope pthread_attr_t*, size_t*);
1601     int pthread_attr_setstack(pthread_attr_t*, void*, size_t);
1602     int pthread_attr_setstackaddr(pthread_attr_t*, void*);
1603     int pthread_attr_setstacksize(pthread_attr_t*, size_t);
1604 }
1605 else version (FreeBSD)
1606 {
1607     int pthread_attr_getstack(const scope pthread_attr_t*, void**, size_t*);
1608     int pthread_attr_getstackaddr(const scope pthread_attr_t*, void**);
1609     int pthread_attr_getstacksize(const scope pthread_attr_t*, size_t*);
1610     int pthread_attr_setstack(pthread_attr_t*, void*, size_t);
1611     int pthread_attr_setstackaddr(pthread_attr_t*, void*);
1612     int pthread_attr_setstacksize(pthread_attr_t*, size_t);
1613 }
1614 else version (NetBSD)
1615 {
1616     int pthread_attr_getstack(const scope pthread_attr_t*, void**, size_t*);
1617     int pthread_attr_getstackaddr(const scope pthread_attr_t*, void**);
1618     int pthread_attr_getstacksize(const scope pthread_attr_t*, size_t*);
1619     int pthread_attr_setstack(pthread_attr_t*, void*, size_t);
1620     int pthread_attr_setstackaddr(pthread_attr_t*, void*);
1621     int pthread_attr_setstacksize(pthread_attr_t*, size_t);
1622 }
1623 else version (OpenBSD)
1624 {
1625     int pthread_attr_getstack(const scope pthread_attr_t*, void**, size_t*);
1626     int pthread_attr_getstackaddr(const scope pthread_attr_t*, void**);
1627     int pthread_attr_getstacksize(const scope pthread_attr_t*, size_t*);
1628     int pthread_attr_setstack(pthread_attr_t*, void*, size_t);
1629     int pthread_attr_setstackaddr(pthread_attr_t*, void*);
1630     int pthread_attr_setstacksize(pthread_attr_t*, size_t);
1631 }
1632 else version (DragonFlyBSD)
1633 {
1634     int pthread_attr_getstack(const scope pthread_attr_t*, void**, size_t*);
1635     int pthread_attr_getstackaddr(const scope pthread_attr_t*, void**);
1636     int pthread_attr_getstacksize(const scope pthread_attr_t*, size_t*);
1637     int pthread_attr_setstack(pthread_attr_t*, void*, size_t);
1638     int pthread_attr_setstackaddr(pthread_attr_t*, void*);
1639     int pthread_attr_setstacksize(pthread_attr_t*, size_t);
1640 }
1641 else version (Solaris)
1642 {
1643     int pthread_attr_getstack(const scope pthread_attr_t*, void**, size_t*);
1644     int pthread_attr_getstackaddr(const scope pthread_attr_t*, void**);
1645     int pthread_attr_getstacksize(const scope pthread_attr_t*, size_t*);
1646     int pthread_attr_setstack(pthread_attr_t*, void*, size_t);
1647     int pthread_attr_setstackaddr(pthread_attr_t*, void*);
1648     int pthread_attr_setstacksize(pthread_attr_t*, size_t);
1649 }
1650 else version (CRuntime_Bionic)
1651 {
1652     int pthread_attr_getstack(const scope pthread_attr_t*, void**, size_t*);
1653     int pthread_attr_getstackaddr(const scope pthread_attr_t*, void**);
1654     int pthread_attr_getstacksize(const scope pthread_attr_t*, size_t*);
1655     int pthread_attr_setstack(pthread_attr_t*, void*, size_t);
1656     int pthread_attr_setstackaddr(pthread_attr_t*, void*);
1657     int pthread_attr_setstacksize(pthread_attr_t*, size_t);
1658 }
1659 else version (CRuntime_Musl)
1660 {
1661     int pthread_attr_getstack(const scope pthread_attr_t*, void**, size_t*);
1662     int pthread_attr_setstacksize(pthread_attr_t*, size_t);
1663 }
1664 else version (CRuntime_UClibc)
1665 {
1666     int pthread_attr_getstack(const scope pthread_attr_t*, void**, size_t*);
1667     int pthread_attr_getstackaddr(const scope pthread_attr_t*, void**);
1668     int pthread_attr_getstacksize(const scope pthread_attr_t*, size_t*);
1669     int pthread_attr_setstack(pthread_attr_t*, void*, size_t);
1670     int pthread_attr_setstackaddr(pthread_attr_t*, void*);
1671     int pthread_attr_setstacksize(pthread_attr_t*, size_t);
1672 }
1673 else
1674 {
1675     static assert(false, "Unsupported platform");
1676 }
1677
1678 //
1679 // Shared Synchronization (TSH)
1680 //
1681 /*
1682 int pthread_condattr_getpshared(const scope pthread_condattr_t*, int*);
1683 int pthread_condattr_setpshared(pthread_condattr_t*, int);
1684 int pthread_mutexattr_getpshared(const scope pthread_mutexattr_t*, int*);
1685 int pthread_mutexattr_setpshared(pthread_mutexattr_t*, int);
1686 int pthread_rwlockattr_getpshared(const scope pthread_rwlockattr_t*, int*);
1687 int pthread_rwlockattr_setpshared(pthread_rwlockattr_t*, int);
1688 */
1689
1690 version (CRuntime_Glibc)
1691 {
1692     int pthread_condattr_getpshared(const scope pthread_condattr_t*, int*);
1693     int pthread_condattr_setpshared(pthread_condattr_t*, int);
1694     int pthread_mutexattr_getpshared(const scope pthread_mutexattr_t*, int*);
1695     int pthread_mutexattr_setpshared(pthread_mutexattr_t*, int);
1696     int pthread_rwlockattr_getpshared(const scope pthread_rwlockattr_t*, int*);
1697     int pthread_rwlockattr_setpshared(pthread_rwlockattr_t*, int);
1698 }
1699 else version (FreeBSD)
1700 {
1701     int pthread_condattr_getpshared(const scope pthread_condattr_t*, int*);
1702     int pthread_condattr_setpshared(pthread_condattr_t*, int);
1703     int pthread_mutexattr_getpshared(const scope pthread_mutexattr_t*, int*);
1704     int pthread_mutexattr_setpshared(pthread_mutexattr_t*, int);
1705     int pthread_rwlockattr_getpshared(const scope pthread_rwlockattr_t*, int*);
1706     int pthread_rwlockattr_setpshared(pthread_rwlockattr_t*, int);
1707 }
1708 else version (NetBSD)
1709 {
1710     int pthread_condattr_getpshared(const scope pthread_condattr_t*, int*);
1711     int pthread_condattr_setpshared(pthread_condattr_t*, int);
1712     int pthread_mutexattr_getpshared(const scope pthread_mutexattr_t*, int*);
1713     int pthread_mutexattr_setpshared(pthread_mutexattr_t*, int);
1714     int pthread_rwlockattr_getpshared(const scope pthread_rwlockattr_t*, int*);
1715     int pthread_rwlockattr_setpshared(pthread_rwlockattr_t*, int);
1716 }
1717 else version (OpenBSD)
1718 {
1719 }
1720 else version (DragonFlyBSD)
1721 {
1722     int pthread_condattr_getpshared(const scope pthread_condattr_t*, int*);
1723     int pthread_condattr_setpshared(pthread_condattr_t*, int);
1724     int pthread_mutexattr_getpshared(const scope pthread_mutexattr_t*, int*);
1725     int pthread_mutexattr_setpshared(pthread_mutexattr_t*, int);
1726     int pthread_rwlockattr_getpshared(const scope pthread_rwlockattr_t*, int*);
1727     int pthread_rwlockattr_setpshared(pthread_rwlockattr_t*, int);
1728 }
1729 else version (Darwin)
1730 {
1731     int pthread_condattr_getpshared(const scope pthread_condattr_t*, int*);
1732     int pthread_condattr_setpshared(pthread_condattr_t*, int);
1733     int pthread_mutexattr_getpshared(const scope pthread_mutexattr_t*, int*);
1734     int pthread_mutexattr_setpshared(pthread_mutexattr_t*, int);
1735     int pthread_rwlockattr_getpshared(const scope pthread_rwlockattr_t*, int*);
1736     int pthread_rwlockattr_setpshared(pthread_rwlockattr_t*, int);
1737 }
1738 else version (Solaris)
1739 {
1740     int pthread_condattr_getpshared(const scope pthread_condattr_t*, int*);
1741     int pthread_condattr_setpshared(pthread_condattr_t*, int);
1742     int pthread_mutexattr_getpshared(const scope pthread_mutexattr_t*, int*);
1743     int pthread_mutexattr_setpshared(pthread_mutexattr_t*, int);
1744     int pthread_rwlockattr_getpshared(const scope pthread_rwlockattr_t*, int*);
1745     int pthread_rwlockattr_setpshared(pthread_rwlockattr_t*, int);
1746 }
1747 else version (CRuntime_Bionic)
1748 {
1749     int pthread_condattr_getpshared(pthread_condattr_t*, int*);
1750     int pthread_condattr_setpshared(pthread_condattr_t*, int);
1751     int pthread_mutexattr_getpshared(pthread_mutexattr_t*, int*);
1752     int pthread_mutexattr_setpshared(pthread_mutexattr_t*, int);
1753     int pthread_rwlockattr_getpshared(pthread_rwlockattr_t*, int*);
1754     int pthread_rwlockattr_setpshared(pthread_rwlockattr_t*, int);
1755 }
1756 else version (CRuntime_Musl)
1757 {
1758     int pthread_condattr_getpshared(pthread_condattr_t*, int*);
1759     int pthread_condattr_setpshared(pthread_condattr_t*, int);
1760     int pthread_mutexattr_getpshared(pthread_mutexattr_t*, int*);
1761     int pthread_mutexattr_setpshared(pthread_mutexattr_t*, int);
1762     int pthread_rwlockattr_getpshared(pthread_rwlockattr_t*, int*);
1763     int pthread_rwlockattr_setpshared(pthread_rwlockattr_t*, int);
1764 }
1765 else version (CRuntime_UClibc)
1766 {
1767     int pthread_condattr_getpshared(const scope pthread_condattr_t*, int*);
1768     int pthread_condattr_setpshared(pthread_condattr_t*, int);
1769     int pthread_mutexattr_getpshared(const scope pthread_mutexattr_t*, int*);
1770     int pthread_mutexattr_setpshared(pthread_mutexattr_t*, int);
1771     int pthread_rwlockattr_getpshared(const scope pthread_rwlockattr_t*, int*);
1772     int pthread_rwlockattr_setpshared(pthread_rwlockattr_t*, int);
1773 }
1774 else
1775 {
1776     static assert(false, "Unsupported platform");
1777 }