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