libphobos/libdruntime/core/sys/posix/sys/types.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,
   7               Alex Rønne Petersen
   8  * Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
   9  */
  10
  11 /*          Copyright Sean Kelly 2005 - 2009.
  12  * Distributed under the Boost Software License, Version 1.0.
  13  *    (See accompanying file LICENSE or copy at
  14  *          http://www.boost.org/LICENSE_1_0.txt)
  15  */
  16 module core.sys.posix.sys.types;
  17
  18 import core.sys.posix.config;
  19 import core.stdc.stdint;
  20 public import core.stdc.stddef;
  21
  22 version (OSX)
  23     version = Darwin;
  24 else version (iOS)
  25     version = Darwin;
  26 else version (TVOS)
  27     version = Darwin;
  28 else version (WatchOS)
  29     version = Darwin;
  30
  31 version (Posix):
  32 extern (C):
  33
  34 //
  35 // bits/typesizes.h -- underlying types for *_t.
  36 //
  37 /*
  38 __syscall_slong_t
  39 __syscall_ulong_t
  40 */
  41 version (CRuntime_Glibc)
  42 {
  43     version (X86_64)
  44     {
  45         version (D_X32)
  46         {
  47             // X32 kernel interface is 64-bit.
  48             alias long slong_t;
  49             alias ulong ulong_t;
  50         }
  51         else
  52         {
  53             alias c_long slong_t;
  54             alias c_ulong ulong_t;
  55         }
  56     }
  57     else
  58     {
  59         alias c_long slong_t;
  60         alias c_ulong ulong_t;
  61     }
  62 }
  63 else
  64 {
  65     alias c_long slong_t;
  66     alias c_ulong ulong_t;
  67 }
  68
  69 //
  70 // Required
  71 //
  72 /*
  73 blkcnt_t
  74 blksize_t
  75 dev_t
  76 gid_t
  77 ino_t
  78 mode_t
  79 nlink_t
  80 off_t
  81 pid_t
  82 size_t
  83 ssize_t
  84 time_t
  85 uid_t
  86 */
  87
  88 version (linux)
  89 {
  90   static if ( __USE_FILE_OFFSET64 )
  91   {
  92     alias long      blkcnt_t;
  93     alias ulong     ino_t;
  94     alias long      off_t;
  95   }
  96   else
  97   {
  98     alias slong_t   blkcnt_t;
  99     alias ulong_t   ino_t;
 100     alias slong_t   off_t;
 101   }
 102     alias slong_t   blksize_t;
 103     alias ulong     dev_t;
 104     alias uint      gid_t;
 105     alias uint      mode_t;
 106     alias ulong_t   nlink_t;
 107     alias int       pid_t;
 108     //size_t (defined in core.stdc.stddef)
 109     alias c_long    ssize_t;
 110     alias uint      uid_t;
 111
 112     version (CRuntime_Musl)
 113     {
 114         /**
 115          * Musl versions before v1.2.0 (up to v1.1.24) had different
 116          * definitions for `time_t` for 32 bits.
 117          * This was changed to always be 64 bits in v1.2.0:
 118          * https://musl.libc.org/time64.html
 119          * This change was only for 32 bits system and
 120          * didn't affect 64 bits systems
 121          *
 122          * To check previous definitions, `grep` for `time_t` in `arch/`,
 123          * and the result should be (in v1.1.24):
 124          * ---
 125          * // arch/riscv64/bits/alltypes.h.in:20:TYPEDEF long time_t;
 126          * // arch/s390x/bits/alltypes.h.in:17:TYPEDEF long time_t;
 127          * // arch/sh/bits/alltypes.h.in:21:TYPEDEF long time_t;
 128          * ---
 129          *
 130          * In order to be compatible with old versions of Musl,
 131          * one can recompile druntime with `CRuntime_Musl_Pre_Time64`.
 132          */
 133         version (D_X32)
 134            alias long   time_t;
 135         else version (CRuntime_Musl_Pre_Time64)
 136             alias c_long time_t;
 137         else
 138             alias long  time_t;
 139     }
 140     else
 141     {
 142         alias slong_t   time_t;
 143     }
 144 }
 145 else version (Darwin)
 146 {
 147     alias long      blkcnt_t;
 148     alias int       blksize_t;
 149     alias int       dev_t;
 150     alias uint      gid_t;
 151     alias ulong     ino_t;
 152     alias ushort    mode_t;
 153     alias ushort    nlink_t;
 154     alias long      off_t;
 155     alias int       pid_t;
 156     //size_t (defined in core.stdc.stddef)
 157     alias c_long    ssize_t;
 158     alias c_long    time_t;
 159     alias uint      uid_t;
 160 }
 161 else version (FreeBSD)
 162 {
 163     import core.sys.freebsd.config;
 164
 165     // https://github.com/freebsd/freebsd/blob/master/sys/sys/_types.h
 166     alias long      blkcnt_t;
 167     alias uint      blksize_t;
 168
 169     static if (__FreeBSD_version >= 1200000)
 170     {
 171         alias ulong dev_t;
 172         alias ulong ino_t;
 173         alias ulong nlink_t;
 174     }
 175     else
 176     {
 177         alias uint   dev_t;
 178         alias uint   ino_t;
 179         alias ushort nlink_t;
 180     }
 181
 182     alias uint      gid_t;
 183     alias ushort    mode_t;
 184     alias long      off_t;
 185     alias int       pid_t;
 186     //size_t (defined in core.stdc.stddef)
 187     alias c_long    ssize_t;
 188     alias c_long    time_t;
 189     alias uint      uid_t;
 190     alias uint      fflags_t;
 191 }
 192 else version (NetBSD)
 193 {
 194     alias long      blkcnt_t;
 195     alias int       blksize_t;
 196     alias ulong     dev_t;
 197     alias uint      gid_t;
 198     alias ulong     ino_t;
 199     alias uint      mode_t;
 200     alias uint      nlink_t;
 201     alias ulong     off_t;
 202     alias int       pid_t;
 203     //size_t (defined in core.stdc.stddef)
 204     alias c_long      ssize_t;
 205     alias c_long      time_t;
 206     alias uint        uid_t;
 207 }
 208 else version (OpenBSD)
 209 {
 210     alias char*     caddr_t;
 211     alias long      blkcnt_t;
 212     alias int       blksize_t;
 213     alias int       dev_t;
 214     alias uint      gid_t;
 215     alias ulong     ino_t;
 216     alias uint      mode_t;
 217     alias uint      nlink_t;
 218     alias long      off_t;
 219     alias int       pid_t;
 220     //size_t (defined in core.stdc.stddef)
 221     alias c_long    ssize_t;
 222     alias long      time_t;
 223     alias uint      uid_t;
 224 }
 225 else version (DragonFlyBSD)
 226 {
 227     alias long      blkcnt_t;
 228     alias long      blksize_t;
 229     alias uint      dev_t;
 230     alias uint      gid_t;
 231     alias long      ino_t;
 232     alias ushort    mode_t;
 233     alias uint      nlink_t;
 234     alias long      off_t;      //__off_t (defined in /usr/include/sys/stdint.h -> core.stdc.stddef)
 235     alias int       pid_t;      // size_t (defined in /usr/include/sys/stdint.h -> core.stdc.stddef)
 236     alias c_long    ssize_t;
 237     alias long      time_t;
 238     alias uint      uid_t;
 239 }
 240 else version (Solaris)
 241 {
 242     alias char* caddr_t;
 243     alias c_long daddr_t;
 244     alias short cnt_t;
 245
 246     static if (__USE_FILE_OFFSET64)
 247     {
 248         alias long blkcnt_t;
 249         alias ulong ino_t;
 250         alias long off_t;
 251     }
 252     else
 253     {
 254         alias c_long blkcnt_t;
 255         alias c_ulong ino_t;
 256         alias c_long off_t;
 257     }
 258
 259     version (D_LP64)
 260     {
 261         alias blkcnt_t blkcnt64_t;
 262         alias ino_t ino64_t;
 263         alias off_t off64_t;
 264     }
 265     else
 266     {
 267         alias long blkcnt64_t;
 268         alias ulong ino64_t;
 269         alias long off64_t;
 270     }
 271
 272     alias uint blksize_t;
 273     alias c_ulong dev_t;
 274     alias uid_t gid_t;
 275     alias uint mode_t;
 276     alias uint nlink_t;
 277     alias int pid_t;
 278     alias c_long ssize_t;
 279     alias c_long time_t;
 280     alias uint uid_t;
 281 }
 282 else
 283 {
 284     static assert(false, "Unsupported platform");
 285 }
 286
 287 //
 288 // XOpen (XSI)
 289 //
 290 /*
 291 clock_t
 292 fsblkcnt_t
 293 fsfilcnt_t
 294 id_t
 295 key_t
 296 suseconds_t
 297 useconds_t
 298 */
 299
 300 version (linux)
 301 {
 302   static if ( __USE_FILE_OFFSET64 )
 303   {
 304     alias ulong     fsblkcnt_t;
 305     alias ulong     fsfilcnt_t;
 306   }
 307   else
 308   {
 309     alias ulong_t   fsblkcnt_t;
 310     alias ulong_t   fsfilcnt_t;
 311   }
 312     alias slong_t   clock_t;
 313     alias uint      id_t;
 314     alias int       key_t;
 315     alias slong_t   suseconds_t;
 316     alias uint      useconds_t;
 317 }
 318 else version (Darwin)
 319 {
 320     alias uint   fsblkcnt_t;
 321     alias uint   fsfilcnt_t;
 322     alias c_long clock_t;
 323     alias uint   id_t;
 324     alias int    key_t;
 325     alias int    suseconds_t;
 326     alias uint   useconds_t;
 327 }
 328 else version (FreeBSD)
 329 {
 330     alias ulong     fsblkcnt_t;
 331     alias ulong     fsfilcnt_t;
 332     alias c_long    clock_t;
 333     alias long      id_t;
 334     alias c_long    key_t;
 335     alias c_long    suseconds_t;
 336     alias uint      useconds_t;
 337 }
 338 else version (NetBSD)
 339 {
 340     alias ulong     fsblkcnt_t;
 341     alias ulong     fsfilcnt_t;
 342     alias c_long    clock_t;
 343     alias long      id_t;
 344     alias c_long    key_t;
 345     alias c_long    suseconds_t;
 346     alias uint      useconds_t;
 347 }
 348 else version (OpenBSD)
 349 {
 350     alias ulong     fsblkcnt_t;
 351     alias ulong     fsfilcnt_t;
 352     alias long      clock_t;
 353     alias uint      id_t;
 354     alias c_long    key_t;
 355     alias c_long    suseconds_t;
 356     alias uint      useconds_t;
 357 }
 358 else version (DragonFlyBSD)
 359 {
 360     alias ulong     fsblkcnt_t;
 361     alias ulong     fsfilcnt_t;
 362     alias c_long    clock_t;
 363     alias long      id_t;
 364     alias c_long    key_t;
 365     alias c_long    suseconds_t;
 366     alias uint      useconds_t;
 367 }
 368 else version (Solaris)
 369 {
 370     static if (__USE_FILE_OFFSET64)
 371     {
 372         alias ulong fsblkcnt_t;
 373         alias ulong fsfilcnt_t;
 374     }
 375     else
 376     {
 377         alias c_ulong fsblkcnt_t;
 378         alias c_ulong fsfilcnt_t;
 379     }
 380
 381     alias c_long clock_t;
 382     alias int id_t;
 383     alias int key_t;
 384     alias c_long suseconds_t;
 385     alias uint useconds_t;
 386
 387     alias id_t taskid_t;
 388     alias id_t projid_t;
 389     alias id_t poolid_t;
 390     alias id_t zoneid_t;
 391     alias id_t ctid_t;
 392 }
 393 else
 394 {
 395     static assert(false, "Unsupported platform");
 396 }
 397
 398 //
 399 // Thread (THR)
 400 //
 401 /*
 402 pthread_attr_t
 403 pthread_cond_t
 404 pthread_condattr_t
 405 pthread_key_t
 406 pthread_mutex_t
 407 pthread_mutexattr_t
 408 pthread_once_t
 409 pthread_rwlock_t
 410 pthread_rwlockattr_t
 411 pthread_t
 412 */
 413
 414 version (CRuntime_Glibc)
 415 {
 416     version (X86)
 417     {
 418         enum __SIZEOF_PTHREAD_ATTR_T = 36;
 419         enum __SIZEOF_PTHREAD_MUTEX_T = 24;
 420         enum __SIZEOF_PTHREAD_MUTEXATTR_T = 4;
 421         enum __SIZEOF_PTHREAD_COND_T = 48;
 422         enum __SIZEOF_PTHREAD_CONDATTR_T = 4;
 423         enum __SIZEOF_PTHREAD_RWLOCK_T = 32;
 424         enum __SIZEOF_PTHREAD_RWLOCKATTR_T = 8;
 425         enum __SIZEOF_PTHREAD_BARRIER_T = 20;
 426         enum __SIZEOF_PTHREAD_BARRIERATTR_T = 4;
 427     }
 428     else version (X86_64)
 429     {
 430         static if (__WORDSIZE == 64)
 431         {
 432             enum __SIZEOF_PTHREAD_ATTR_T = 56;
 433             enum __SIZEOF_PTHREAD_MUTEX_T = 40;
 434             enum __SIZEOF_PTHREAD_MUTEXATTR_T = 4;
 435             enum __SIZEOF_PTHREAD_COND_T = 48;
 436             enum __SIZEOF_PTHREAD_CONDATTR_T = 4;
 437             enum __SIZEOF_PTHREAD_RWLOCK_T = 56;
 438             enum __SIZEOF_PTHREAD_RWLOCKATTR_T = 8;
 439             enum __SIZEOF_PTHREAD_BARRIER_T = 32;
 440             enum __SIZEOF_PTHREAD_BARRIERATTR_T = 4;
 441         }
 442         else
 443         {
 444             enum __SIZEOF_PTHREAD_ATTR_T = 32;
 445             enum __SIZEOF_PTHREAD_MUTEX_T = 32;
 446             enum __SIZEOF_PTHREAD_MUTEXATTR_T = 4;
 447             enum __SIZEOF_PTHREAD_COND_T = 48;
 448             enum __SIZEOF_PTHREAD_CONDATTR_T = 4;
 449             enum __SIZEOF_PTHREAD_RWLOCK_T = 44;
 450             enum __SIZEOF_PTHREAD_RWLOCKATTR_T = 8;
 451             enum __SIZEOF_PTHREAD_BARRIER_T = 20;
 452             enum __SIZEOF_PTHREAD_BARRIERATTR_T = 4;
 453         }
 454     }
 455     else version (AArch64)
 456     {
 457         enum __SIZEOF_PTHREAD_ATTR_T = 64;
 458         enum __SIZEOF_PTHREAD_MUTEX_T = 48;
 459         enum __SIZEOF_PTHREAD_MUTEXATTR_T = 8;
 460         enum __SIZEOF_PTHREAD_COND_T = 48;
 461         enum __SIZEOF_PTHREAD_CONDATTR_T = 8;
 462         enum __SIZEOF_PTHREAD_RWLOCK_T = 56;
 463         enum __SIZEOF_PTHREAD_RWLOCKATTR_T = 8;
 464         enum __SIZEOF_PTHREAD_BARRIER_T = 32;
 465         enum __SIZEOF_PTHREAD_BARRIERATTR_T = 8;
 466     }
 467     else version (ARM)
 468     {
 469         enum __SIZEOF_PTHREAD_ATTR_T = 36;
 470         enum __SIZEOF_PTHREAD_MUTEX_T = 24;
 471         enum __SIZEOF_PTHREAD_MUTEXATTR_T = 4;
 472         enum __SIZEOF_PTHREAD_COND_T = 48;
 473         enum __SIZEOF_PTHREAD_CONDATTR_T = 4;
 474         enum __SIZEOF_PTHREAD_RWLOCK_T = 32;
 475         enum __SIZEOF_PTHREAD_RWLOCKATTR_T = 8;
 476         enum __SIZEOF_PTHREAD_BARRIER_T = 20;
 477         enum __SIZEOF_PTHREAD_BARRIERATTR_T = 4;
 478     }
 479     else version (HPPA)
 480     {
 481         enum __SIZEOF_PTHREAD_ATTR_T = 36;
 482         enum __SIZEOF_PTHREAD_MUTEX_T = 48;
 483         enum __SIZEOF_PTHREAD_MUTEXATTR_T = 4;
 484         enum __SIZEOF_PTHREAD_COND_T = 48;
 485         enum __SIZEOF_PTHREAD_CONDATTR_T = 4;
 486         enum __SIZEOF_PTHREAD_RWLOCK_T = 64;
 487         enum __SIZEOF_PTHREAD_RWLOCKATTR_T = 8;
 488         enum __SIZEOF_PTHREAD_BARRIER_T = 48;
 489         enum __SIZEOF_PTHREAD_BARRIERATTR_T = 4;
 490     }
 491     else version (IA64)
 492     {
 493         enum __SIZEOF_PTHREAD_ATTR_T = 56;
 494         enum __SIZEOF_PTHREAD_MUTEX_T = 40;
 495         enum __SIZEOF_PTHREAD_MUTEXATTR_T = 4;
 496         enum __SIZEOF_PTHREAD_COND_T = 48;
 497         enum __SIZEOF_PTHREAD_CONDATTR_T = 4;
 498         enum __SIZEOF_PTHREAD_RWLOCK_T = 56;
 499         enum __SIZEOF_PTHREAD_RWLOCKATTR_T = 8;
 500         enum __SIZEOF_PTHREAD_BARRIER_T = 32;
 501         enum __SIZEOF_PTHREAD_BARRIERATTR_T = 4;
 502     }
 503     else version (MIPS32)
 504     {
 505         enum __SIZEOF_PTHREAD_ATTR_T = 36;
 506         enum __SIZEOF_PTHREAD_MUTEX_T = 24;
 507         enum __SIZEOF_PTHREAD_MUTEXATTR_T = 4;
 508         enum __SIZEOF_PTHREAD_COND_T = 48;
 509         enum __SIZEOF_PTHREAD_CONDATTR_T = 4;
 510         enum __SIZEOF_PTHREAD_RWLOCK_T = 32;
 511         enum __SIZEOF_PTHREAD_RWLOCKATTR_T = 8;
 512         enum __SIZEOF_PTHREAD_BARRIER_T = 20;
 513         enum __SIZEOF_PTHREAD_BARRIERATTR_T = 4;
 514     }
 515     else version (MIPS64)
 516     {
 517         enum __SIZEOF_PTHREAD_ATTR_T = 56;
 518         enum __SIZEOF_PTHREAD_MUTEX_T = 40;
 519         enum __SIZEOF_PTHREAD_MUTEXATTR_T = 4;
 520         enum __SIZEOF_PTHREAD_COND_T = 48;
 521         enum __SIZEOF_PTHREAD_CONDATTR_T = 4;
 522         enum __SIZEOF_PTHREAD_RWLOCK_T = 56;
 523         enum __SIZEOF_PTHREAD_RWLOCKATTR_T = 8;
 524         enum __SIZEOF_PTHREAD_BARRIER_T = 32;
 525         enum __SIZEOF_PTHREAD_BARRIERATTR_T = 4;
 526     }
 527     else version (PPC)
 528     {
 529         enum __SIZEOF_PTHREAD_ATTR_T = 36;
 530         enum __SIZEOF_PTHREAD_MUTEX_T = 24;
 531         enum __SIZEOF_PTHREAD_MUTEXATTR_T = 4;
 532         enum __SIZEOF_PTHREAD_COND_T = 48;
 533         enum __SIZEOF_PTHREAD_CONDATTR_T = 4;
 534         enum __SIZEOF_PTHREAD_RWLOCK_T = 32;
 535         enum __SIZEOF_PTHREAD_RWLOCKATTR_T = 8;
 536         enum __SIZEOF_PTHREAD_BARRIER_T = 20;
 537         enum __SIZEOF_PTHREAD_BARRIERATTR_T = 4;
 538     }
 539     else version (PPC64)
 540     {
 541         enum __SIZEOF_PTHREAD_ATTR_T = 56;
 542         enum __SIZEOF_PTHREAD_MUTEX_T = 40;
 543         enum __SIZEOF_PTHREAD_MUTEXATTR_T = 4;
 544         enum __SIZEOF_PTHREAD_COND_T = 48;
 545         enum __SIZEOF_PTHREAD_CONDATTR_T = 4;
 546         enum __SIZEOF_PTHREAD_RWLOCK_T = 56;
 547         enum __SIZEOF_PTHREAD_RWLOCKATTR_T = 8;
 548         enum __SIZEOF_PTHREAD_BARRIER_T = 32;
 549         enum __SIZEOF_PTHREAD_BARRIERATTR_T = 4;
 550     }
 551     else version (RISCV32)
 552     {
 553         enum __SIZEOF_PTHREAD_ATTR_T = 36;
 554         enum __SIZEOF_PTHREAD_MUTEX_T = 24;
 555         enum __SIZEOF_PTHREAD_MUTEXATTR_T = 4;
 556         enum __SIZEOF_PTHREAD_COND_T = 48;
 557         enum __SIZEOF_PTHREAD_CONDATTR_T = 4;
 558         enum __SIZEOF_PTHREAD_RWLOCK_T = 32;
 559         enum __SIZEOF_PTHREAD_RWLOCKATTR_T = 8;
 560         enum __SIZEOF_PTHREAD_BARRIER_T = 20;
 561         enum __SIZEOF_PTHREAD_BARRIERATTR_T = 4;
 562     }
 563     else version (RISCV64)
 564     {
 565         enum __SIZEOF_PTHREAD_ATTR_T = 56;
 566         enum __SIZEOF_PTHREAD_MUTEX_T = 40;
 567         enum __SIZEOF_PTHREAD_MUTEXATTR_T = 4;
 568         enum __SIZEOF_PTHREAD_COND_T = 48;
 569         enum __SIZEOF_PTHREAD_CONDATTR_T = 4;
 570         enum __SIZEOF_PTHREAD_RWLOCK_T = 56;
 571         enum __SIZEOF_PTHREAD_RWLOCKATTR_T = 8;
 572         enum __SIZEOF_PTHREAD_BARRIER_T = 32;
 573         enum __SIZEOF_PTHREAD_BARRIERATTR_T = 4;
 574     }
 575     else version (SPARC)
 576     {
 577         enum __SIZEOF_PTHREAD_ATTR_T = 36;
 578         enum __SIZEOF_PTHREAD_MUTEX_T = 24;
 579         enum __SIZEOF_PTHREAD_MUTEXATTR_T = 4;
 580         enum __SIZEOF_PTHREAD_COND_T = 48;
 581         enum __SIZEOF_PTHREAD_CONDATTR_T = 4;
 582         enum __SIZEOF_PTHREAD_RWLOCK_T = 32;
 583         enum __SIZEOF_PTHREAD_RWLOCKATTR_T = 8;
 584         enum __SIZEOF_PTHREAD_BARRIER_T = 20;
 585         enum __SIZEOF_PTHREAD_BARRIERATTR_T = 4;
 586     }
 587     else version (SPARC64)
 588     {
 589         enum __SIZEOF_PTHREAD_ATTR_T = 56;
 590         enum __SIZEOF_PTHREAD_MUTEX_T = 40;
 591         enum __SIZEOF_PTHREAD_MUTEXATTR_T = 4;
 592         enum __SIZEOF_PTHREAD_COND_T = 48;
 593         enum __SIZEOF_PTHREAD_CONDATTR_T = 4;
 594         enum __SIZEOF_PTHREAD_RWLOCK_T = 56;
 595         enum __SIZEOF_PTHREAD_RWLOCKATTR_T = 8;
 596         enum __SIZEOF_PTHREAD_BARRIER_T = 32;
 597         enum __SIZEOF_PTHREAD_BARRIERATTR_T = 4;
 598     }
 599     else version (S390)
 600     {
 601         enum __SIZEOF_PTHREAD_ATTR_T = 36;
 602         enum __SIZEOF_PTHREAD_MUTEX_T = 24;
 603         enum __SIZEOF_PTHREAD_MUTEXATTR_T = 4;
 604         enum __SIZEOF_PTHREAD_COND_T = 48;
 605         enum __SIZEOF_PTHREAD_CONDATTR_T = 4;
 606         enum __SIZEOF_PTHREAD_RWLOCK_T = 32;
 607         enum __SIZEOF_PTHREAD_RWLOCKATTR_T = 8;
 608         enum __SIZEOF_PTHREAD_BARRIER_T = 20;
 609         enum __SIZEOF_PTHREAD_BARRIERATTR_T = 4;
 610     }
 611     else version (SystemZ)
 612     {
 613         enum __SIZEOF_PTHREAD_ATTR_T = 56;
 614         enum __SIZEOF_PTHREAD_MUTEX_T = 40;
 615         enum __SIZEOF_PTHREAD_MUTEXATTR_T = 4;
 616         enum __SIZEOF_PTHREAD_COND_T = 48;
 617         enum __SIZEOF_PTHREAD_CONDATTR_T = 4;
 618         enum __SIZEOF_PTHREAD_RWLOCK_T = 56;
 619         enum __SIZEOF_PTHREAD_RWLOCKATTR_T = 8;
 620         enum __SIZEOF_PTHREAD_BARRIER_T = 32;
 621         enum __SIZEOF_PTHREAD_BARRIERATTR_T = 4;
 622     }
 623     else version (LoongArch64)
 624     {
 625         enum __SIZEOF_PTHREAD_ATTR_T = 56;
 626         enum __SIZEOF_PTHREAD_MUTEX_T = 40;
 627         enum __SIZEOF_PTHREAD_MUTEXATTR_T = 4;
 628         enum __SIZEOF_PTHREAD_COND_T = 48;
 629         enum __SIZEOF_PTHREAD_CONDATTR_T = 4;
 630         enum __SIZEOF_PTHREAD_RWLOCK_T = 56;
 631         enum __SIZEOF_PTHREAD_RWLOCKATTR_T = 8;
 632         enum __SIZEOF_PTHREAD_BARRIER_T = 32;
 633         enum __SIZEOF_PTHREAD_BARRIERATTR_T = 4;
 634     }
 635     else
 636     {
 637         static assert (false, "Unsupported platform");
 638     }
 639
 640     union pthread_attr_t
 641     {
 642         byte[__SIZEOF_PTHREAD_ATTR_T] __size;
 643         c_long __align;
 644     }
 645
 646     private alias int __atomic_lock_t;
 647
 648     private struct _pthread_fastlock
 649     {
 650         c_long          __status;
 651         __atomic_lock_t __spinlock;
 652     }
 653
 654     private alias void* _pthread_descr;
 655
 656     union pthread_cond_t
 657     {
 658         byte[__SIZEOF_PTHREAD_COND_T] __size;
 659         long  __align;
 660     }
 661
 662     union pthread_condattr_t
 663     {
 664         byte[__SIZEOF_PTHREAD_CONDATTR_T] __size;
 665         int __align;
 666     }
 667
 668     alias uint pthread_key_t;
 669
 670     union pthread_mutex_t
 671     {
 672         byte[__SIZEOF_PTHREAD_MUTEX_T] __size;
 673         c_long __align;
 674     }
 675
 676     union pthread_mutexattr_t
 677     {
 678         byte[__SIZEOF_PTHREAD_MUTEXATTR_T] __size;
 679         int __align;
 680     }
 681
 682     alias int pthread_once_t;
 683
 684     struct pthread_rwlock_t
 685     {
 686         byte[__SIZEOF_PTHREAD_RWLOCK_T] __size;
 687         c_long __align;
 688     }
 689
 690     struct pthread_rwlockattr_t
 691     {
 692         byte[__SIZEOF_PTHREAD_RWLOCKATTR_T] __size;
 693         c_long __align;
 694     }
 695
 696     alias c_ulong pthread_t;
 697 }
 698 else version (CRuntime_Musl)
 699 {
 700     version (D_LP64)
 701     {
 702         union pthread_attr_t
 703         {
 704             int[14] __i;
 705             ulong[7] __s;
 706         }
 707
 708         union pthread_cond_t
 709         {
 710             int[12] __i;
 711             void*[6] __p;
 712         }
 713
 714         union pthread_mutex_t
 715         {
 716             int[10] __i;
 717             void*[5] __p;
 718         }
 719
 720         union pthread_rwlock_t
 721         {
 722             int[14] __i;
 723             void*[7] __p;
 724         }
 725     }
 726     else
 727     {
 728         union pthread_attr_t
 729         {
 730             int[9] __i;
 731             uint[9] __s;
 732         }
 733
 734         union pthread_cond_t
 735         {
 736             int[12] __i;
 737             void*[12] __p;
 738         }
 739
 740         union pthread_mutex_t
 741         {
 742             int[6] __i;
 743             void*[6] __p;
 744         }
 745
 746         union pthread_rwlock_t
 747         {
 748             int[8] __i;
 749             void*[8] __p;
 750         }
 751     }
 752
 753     struct pthread_rwlockattr_t
 754     {
 755         uint[2] __attr;
 756     }
 757
 758     alias uint pthread_key_t;
 759
 760     struct pthread_condattr_t
 761     {
 762         uint __attr;
 763     }
 764
 765     struct pthread_mutexattr_t
 766     {
 767         uint __attr;
 768     }
 769
 770     alias int pthread_once_t;
 771
 772     alias c_ulong pthread_t;
 773 }
 774 else version (Darwin)
 775 {
 776     version (D_LP64)
 777     {
 778         enum __PTHREAD_SIZE__               = 8176;
 779         enum __PTHREAD_ATTR_SIZE__          = 56;
 780         enum __PTHREAD_MUTEXATTR_SIZE__     = 8;
 781         enum __PTHREAD_MUTEX_SIZE__         = 56;
 782         enum __PTHREAD_CONDATTR_SIZE__      = 8;
 783         enum __PTHREAD_COND_SIZE__          = 40;
 784         enum __PTHREAD_ONCE_SIZE__          = 8;
 785         enum __PTHREAD_RWLOCK_SIZE__        = 192;
 786         enum __PTHREAD_RWLOCKATTR_SIZE__    = 16;
 787     }
 788     else
 789     {
 790         enum __PTHREAD_SIZE__               = 4088;
 791         enum __PTHREAD_ATTR_SIZE__          = 36;
 792         enum __PTHREAD_MUTEXATTR_SIZE__     = 8;
 793         enum __PTHREAD_MUTEX_SIZE__         = 40;
 794         enum __PTHREAD_CONDATTR_SIZE__      = 4;
 795         enum __PTHREAD_COND_SIZE__          = 24;
 796         enum __PTHREAD_ONCE_SIZE__          = 4;
 797         enum __PTHREAD_RWLOCK_SIZE__        = 124;
 798         enum __PTHREAD_RWLOCKATTR_SIZE__    = 12;
 799     }
 800
 801     struct pthread_handler_rec
 802     {
 803       void function(void*)  __routine;
 804       void*                 __arg;
 805       pthread_handler_rec*  __next;
 806     }
 807
 808     struct pthread_attr_t
 809     {
 810         c_long                              __sig;
 811         byte[__PTHREAD_ATTR_SIZE__]         __opaque;
 812     }
 813
 814     struct pthread_cond_t
 815     {
 816         c_long                              __sig;
 817         byte[__PTHREAD_COND_SIZE__]         __opaque;
 818     }
 819
 820     struct pthread_condattr_t
 821     {
 822         c_long                              __sig;
 823         byte[__PTHREAD_CONDATTR_SIZE__]     __opaque;
 824     }
 825
 826     alias c_ulong pthread_key_t;
 827
 828     struct pthread_mutex_t
 829     {
 830         c_long                              __sig;
 831         byte[__PTHREAD_MUTEX_SIZE__]        __opaque;
 832     }
 833
 834     struct pthread_mutexattr_t
 835     {
 836         c_long                              __sig;
 837         byte[__PTHREAD_MUTEXATTR_SIZE__]    __opaque;
 838     }
 839
 840     struct pthread_once_t
 841     {
 842         c_long                              __sig;
 843         byte[__PTHREAD_ONCE_SIZE__]         __opaque;
 844     }
 845
 846     struct pthread_rwlock_t
 847     {
 848         c_long                              __sig;
 849         byte[__PTHREAD_RWLOCK_SIZE__]       __opaque;
 850     }
 851
 852     struct pthread_rwlockattr_t
 853     {
 854         c_long                              __sig;
 855         byte[__PTHREAD_RWLOCKATTR_SIZE__]   __opaque;
 856     }
 857
 858     private struct _opaque_pthread_t
 859     {
 860         c_long                  __sig;
 861         pthread_handler_rec*    __cleanup_stack;
 862         byte[__PTHREAD_SIZE__]  __opaque;
 863     }
 864
 865     alias _opaque_pthread_t* pthread_t;
 866 }
 867 else version (FreeBSD)
 868 {
 869     alias int lwpid_t;
 870
 871     alias void* pthread_attr_t;
 872     alias void* pthread_cond_t;
 873     alias void* pthread_condattr_t;
 874     alias void* pthread_key_t;
 875     alias void* pthread_mutex_t;
 876     alias void* pthread_mutexattr_t;
 877     alias void* pthread_once_t;
 878     alias void* pthread_rwlock_t;
 879     alias void* pthread_rwlockattr_t;
 880     alias void* pthread_t;
 881 }
 882 else version (NetBSD)
 883 {
 884    struct pthread_queue_t {
 885          void*  ptqh_first;
 886          void** ptqh_last;
 887    }
 888
 889     alias lwpid_t = int;
 890     alias pthread_spin_t = ubyte;
 891     struct pthread_attr_t {
 892         uint    pta_magic;
 893         int     pta_flags;
 894         void*   pta_private;
 895     }
 896     struct  pthread_spinlock_t {
 897         uint    pts_magic;
 898         pthread_spin_t  pts_spin;
 899         int             pts_flags;
 900     }
 901     struct pthread_cond_t {
 902         uint    ptc_magic;
 903         pthread_spin_t  ptc_lock;
 904         pthread_queue_t ptc_waiters;
 905         pthread_mutex_t *ptc_mutex;
 906         void*   ptc_private;
 907     }
 908     struct pthread_condattr_t {
 909         uint    ptca_magic;
 910         void    *ptca_private;
 911     }
 912     struct pthread_mutex_t {
 913         uint ptm_magic;
 914         pthread_spin_t  ptm_errorcheck;
 915         ubyte[3]         ptm_pad1;
 916         pthread_spin_t  ptm_interlock;
 917         ubyte[3] ptm_pad2;
 918         pthread_t ptm_owner;
 919         void* ptm_waiters;
 920         uint  ptm_recursed;
 921         void* ptm_spare2;
 922     }
 923     struct pthread_mutexattr_t{
 924         uint    ptma_magic;
 925         void*   ptma_private;
 926     }
 927     struct pthread_once_t{
 928         pthread_mutex_t pto_mutex;
 929         int     pto_done;
 930     }
 931     struct pthread_rwlock_t{
 932         uint    ptr_magic;
 933
 934         pthread_spin_t  ptr_interlock;
 935
 936         pthread_queue_t ptr_rblocked;
 937         pthread_queue_t ptr_wblocked;
 938         uint    ptr_nreaders;
 939         pthread_t ptr_owner;
 940         void    *ptr_private;
 941     }
 942     struct pthread_rwlockattr_t{
 943         uint    ptra_magic;
 944         void*   ptra_private;
 945     }
 946
 947     alias uint pthread_key_t;
 948     alias void* pthread_t;
 949 }
 950 else version (OpenBSD)
 951 {
 952     alias void* pthread_attr_t;
 953     alias void* pthread_cond_t;
 954     alias void* pthread_condattr_t;
 955     alias int   pthread_key_t;
 956     alias void* pthread_mutex_t;
 957     alias void* pthread_mutexattr_t;
 958
 959     private struct pthread_once
 960     {
 961         int state;
 962         pthread_mutex_t mutex;
 963     }
 964     alias pthread_once pthread_once_t;
 965
 966     alias void* pthread_rwlock_t;
 967     alias void* pthread_rwlockattr_t;
 968     alias void* pthread_t;
 969 }
 970 else version (DragonFlyBSD)
 971 {
 972     alias int lwpid_t;
 973
 974     alias void* pthread_attr_t;
 975     alias void* pthread_cond_t;
 976     alias void* pthread_condattr_t;
 977     alias void* pthread_key_t;
 978     alias void* pthread_mutex_t;
 979     alias void* pthread_mutexattr_t;
 980
 981     private struct pthread_once
 982     {
 983         int state;
 984         pthread_mutex_t mutex;
 985     }
 986     alias pthread_once pthread_once_t;
 987
 988     alias void* pthread_rwlock_t;
 989     alias void* pthread_rwlockattr_t;
 990     alias void* pthread_t;
 991 }
 992 else version (Solaris)
 993 {
 994     alias uint pthread_t;
 995
 996     struct pthread_attr_t
 997     {
 998         void* __pthread_attrp;
 999     }
1000
1001     struct pthread_cond_t
1002     {
1003         struct ___pthread_cond_flags
1004         {
1005             ubyte[4] __pthread_cond_flags;
1006             ushort __pthread_cond_type;
1007             ushort __pthread_cond_magic;
1008         }
1009
1010         ___pthread_cond_flags __pthread_cond_flags;
1011         ulong __pthread_cond_data;
1012     }
1013
1014     struct pthread_condattr_t
1015     {
1016         void* __pthread_condattrp;
1017     }
1018
1019     struct pthread_rwlock_t
1020     {
1021         int __pthread_rwlock_readers;
1022         ushort __pthread_rwlock_type;
1023         ushort __pthread_rwlock_magic;
1024         pthread_mutex_t __pthread_rwlock_mutex;
1025         pthread_cond_t __pthread_rwlock_readercv;
1026         pthread_cond_t __pthread_rwlock_writercv;
1027     }
1028
1029     struct pthread_rwlockattr_t
1030     {
1031         void* __pthread_rwlockattrp;
1032     }
1033
1034     struct pthread_mutex_t
1035     {
1036         struct ___pthread_mutex_flags
1037         {
1038             ushort __pthread_mutex_flag1;
1039             ubyte __pthread_mutex_flag2;
1040             ubyte __pthread_mutex_ceiling;
1041             ushort __pthread_mutex_type;
1042             ushort __pthread_mutex_magic;
1043         }
1044
1045         ___pthread_mutex_flags __pthread_mutex_flags;
1046
1047         union ___pthread_mutex_lock
1048         {
1049             struct ___pthread_mutex_lock64
1050             {
1051                 ubyte[8] __pthread_mutex_pad;
1052             }
1053
1054             ___pthread_mutex_lock64 __pthread_mutex_lock64;
1055
1056             struct ___pthread_mutex_lock32
1057             {
1058                 uint __pthread_ownerpid;
1059                 uint __pthread_lockword;
1060             }
1061
1062             ___pthread_mutex_lock32 __pthread_mutex_lock32;
1063             ulong __pthread_mutex_owner64;
1064         }
1065
1066         ___pthread_mutex_lock __pthread_mutex_lock;
1067         ulong __pthread_mutex_data;
1068     }
1069
1070     struct pthread_mutexattr_t
1071     {
1072         void* __pthread_mutexattrp;
1073     }
1074
1075     struct pthread_once_t
1076     {
1077         ulong[4] __pthread_once_pad;
1078     }
1079
1080     alias uint pthread_key_t;
1081 }
1082 else version (CRuntime_Bionic)
1083 {
1084     struct pthread_attr_t
1085     {
1086         uint    flags;
1087         void*   stack_base;
1088         size_t  stack_size;
1089         size_t  guard_size;
1090         int     sched_policy;
1091         int     sched_priority;
1092         version (D_LP64) char[16] __reserved = 0;
1093     }
1094
1095     struct pthread_cond_t
1096     {
1097         version (D_LP64)
1098             int[12] __private;
1099         else
1100             int[1] __private;
1101     }
1102
1103     alias c_long pthread_condattr_t;
1104     alias int    pthread_key_t;
1105
1106     struct pthread_mutex_t
1107     {
1108         version (D_LP64)
1109             int[10] __private;
1110         else
1111             int[1] __private;
1112     }
1113
1114     alias c_long pthread_mutexattr_t;
1115     alias int    pthread_once_t;
1116
1117     struct pthread_rwlock_t
1118     {
1119         version (D_LP64)
1120             int[14] __private;
1121         else
1122             int[10] __private;
1123     }
1124
1125     alias c_long pthread_rwlockattr_t;
1126     alias c_long pthread_t;
1127 }
1128 else version (CRuntime_UClibc)
1129 {
1130      version (X86_64)
1131      {
1132         enum __SIZEOF_PTHREAD_ATTR_T        = 56;
1133         enum __SIZEOF_PTHREAD_MUTEX_T       = 40;
1134         enum __SIZEOF_PTHREAD_MUTEXATTR_T   = 4;
1135         enum __SIZEOF_PTHREAD_COND_T        = 48;
1136         enum __SIZEOF_PTHREAD_CONDATTR_T    = 4;
1137         enum __SIZEOF_PTHREAD_RWLOCK_T      = 56;
1138         enum __SIZEOF_PTHREAD_RWLOCKATTR_T  = 8;
1139         enum __SIZEOF_PTHREAD_BARRIER_T     = 32;
1140         enum __SIZEOF_PTHREAD_BARRIERATTR_T = 4;
1141      }
1142      else version (MIPS32)
1143      {
1144         enum __SIZEOF_PTHREAD_ATTR_T        = 36;
1145         enum __SIZEOF_PTHREAD_MUTEX_T       = 24;
1146         enum __SIZEOF_PTHREAD_MUTEXATTR_T   = 4;
1147         enum __SIZEOF_PTHREAD_COND_T        = 48;
1148         enum __SIZEOF_PTHREAD_CONDATTR_T    = 4;
1149         enum __SIZEOF_PTHREAD_RWLOCK_T      = 32;
1150         enum __SIZEOF_PTHREAD_RWLOCKATTR_T  = 8;
1151         enum __SIZEOF_PTHREAD_BARRIER_T     = 20;
1152         enum __SIZEOF_PTHREAD_BARRIERATTR_T = 4;
1153      }
1154      else version (MIPS64)
1155      {
1156         enum __SIZEOF_PTHREAD_ATTR_T        = 56;
1157         enum __SIZEOF_PTHREAD_MUTEX_T       = 40;
1158         enum __SIZEOF_PTHREAD_MUTEXATTR_T   = 4;
1159         enum __SIZEOF_PTHREAD_COND_T        = 48;
1160         enum __SIZEOF_PTHREAD_CONDATTR_T    = 4;
1161         enum __SIZEOF_PTHREAD_RWLOCK_T      = 56;
1162         enum __SIZEOF_PTHREAD_RWLOCKATTR_T  = 8;
1163         enum __SIZEOF_PTHREAD_BARRIER_T     = 32;
1164         enum __SIZEOF_PTHREAD_BARRIERATTR_T = 4;
1165      }
1166      else version (ARM)
1167      {
1168         enum __SIZEOF_PTHREAD_ATTR_T = 36;
1169         enum __SIZEOF_PTHREAD_MUTEX_T = 24;
1170         enum __SIZEOF_PTHREAD_MUTEXATTR_T = 4;
1171         enum __SIZEOF_PTHREAD_COND_T = 48;
1172         enum __SIZEOF_PTHREAD_COND_COMPAT_T = 12;
1173         enum __SIZEOF_PTHREAD_CONDATTR_T = 4;
1174         enum __SIZEOF_PTHREAD_RWLOCK_T = 32;
1175         enum __SIZEOF_PTHREAD_RWLOCKATTR_T = 8;
1176         enum __SIZEOF_PTHREAD_BARRIER_T = 20;
1177         enum __SIZEOF_PTHREAD_BARRIERATTR_T = 4;
1178      }
1179      else
1180      {
1181         static assert (false, "Architecture unsupported");
1182      }
1183
1184     union pthread_attr_t
1185     {
1186         byte[__SIZEOF_PTHREAD_ATTR_T] __size;
1187         c_long __align;
1188     }
1189
1190     union pthread_cond_t
1191     {
1192         struct data
1193         {
1194             int __lock;
1195             uint __futex;
1196             ulong __total_seq;
1197             ulong __wakeup_seq;
1198             ulong __woken_seq;
1199             void *__mutex;
1200             uint __nwaiters;
1201             uint __broadcast_seq;
1202         } data __data;
1203         byte[__SIZEOF_PTHREAD_COND_T] __size;
1204         long  __align;
1205     }
1206
1207     union pthread_condattr_t
1208     {
1209         byte[__SIZEOF_PTHREAD_CONDATTR_T] __size;
1210         c_long __align;
1211     }
1212
1213     alias uint pthread_key_t;
1214
1215     struct __pthread_slist_t
1216     {
1217       __pthread_slist_t* __next;
1218     }
1219
1220     union pthread_mutex_t
1221     {
1222       struct __pthread_mutex_s
1223       {
1224         int __lock;
1225         uint __count;
1226         int __owner;
1227         /* KIND must stay at this position in the structure to maintain
1228            binary compatibility.  */
1229         int __kind;
1230         uint __nusers;
1231         union
1232         {
1233           int __spins;
1234           __pthread_slist_t __list;
1235         }
1236       }
1237       __pthread_mutex_s __data;
1238         byte[__SIZEOF_PTHREAD_MUTEX_T] __size;
1239         c_long __align;
1240     }
1241
1242     union pthread_mutexattr_t
1243     {
1244         byte[__SIZEOF_PTHREAD_MUTEXATTR_T] __size;
1245         c_long __align;
1246     }
1247
1248     alias int pthread_once_t;
1249
1250     struct pthread_rwlock_t
1251     {
1252         struct data
1253         {
1254             int __lock;
1255             uint __nr_readers;
1256             uint __readers_wakeup;
1257             uint __writer_wakeup;
1258             uint __nr_readers_queued;
1259             uint __nr_writers_queued;
1260             version (BigEndian)
1261             {
1262                 ubyte __pad1;
1263                 ubyte __pad2;
1264                 ubyte __shared;
1265                 ubyte __flags;
1266             }
1267             else
1268             {
1269                 ubyte __flags;
1270                 ubyte __shared;
1271                 ubyte __pad1;
1272                 ubyte __pad2;
1273             }
1274             int __writer;
1275         } data __data;
1276         byte[__SIZEOF_PTHREAD_RWLOCK_T] __size;
1277         c_long __align;
1278     }
1279
1280     struct pthread_rwlockattr_t
1281     {
1282         byte[__SIZEOF_PTHREAD_RWLOCKATTR_T] __size;
1283         c_long __align;
1284     }
1285
1286     alias c_ulong pthread_t;
1287 }
1288 else
1289 {
1290     static assert(false, "Unsupported platform");
1291 }
1292
1293 //
1294 // Barrier (BAR)
1295 //
1296 /*
1297 pthread_barrier_t
1298 pthread_barrierattr_t
1299 */
1300
1301 version (CRuntime_Glibc)
1302 {
1303     struct pthread_barrier_t
1304     {
1305         byte[__SIZEOF_PTHREAD_BARRIER_T] __size;
1306         c_long __align;
1307     }
1308
1309     struct pthread_barrierattr_t
1310     {
1311         byte[__SIZEOF_PTHREAD_BARRIERATTR_T] __size;
1312         int __align;
1313     }
1314 }
1315 else version (FreeBSD)
1316 {
1317     alias void* pthread_barrier_t;
1318     alias void* pthread_barrierattr_t;
1319 }
1320 else version (NetBSD)
1321 {
1322     alias void* pthread_barrier_t;
1323     alias void* pthread_barrierattr_t;
1324 }
1325 else version (OpenBSD)
1326 {
1327     alias void* pthread_barrier_t;
1328     alias void* pthread_barrierattr_t;
1329 }
1330 else version (DragonFlyBSD)
1331 {
1332     alias void* pthread_barrier_t;
1333     alias void* pthread_barrierattr_t;
1334 }
1335 else version (Darwin)
1336 {
1337 }
1338 else version (Solaris)
1339 {
1340     struct pthread_barrier_t
1341     {
1342         uint __pthread_barrier_count;
1343         uint __pthread_barrier_current;
1344         ulong __pthread_barrier_cycle;
1345         ulong __pthread_barrier_reserved;
1346         pthread_mutex_t __pthread_barrier_lock;
1347         pthread_cond_t __pthread_barrier_cond;
1348     }
1349
1350     struct pthread_barrierattr_t
1351     {
1352         void* __pthread_barrierattrp;
1353     }
1354 }
1355 else version (CRuntime_Bionic)
1356 {
1357 }
1358 else version (CRuntime_Musl)
1359 {
1360     version (D_LP64)
1361     {
1362         union pthread_barrier_t
1363         {
1364             int[8] __i;
1365             void*[4] __p;
1366         }
1367     }
1368     else
1369     {
1370         union pthread_barrier_t
1371         {
1372             int[5] __i;
1373             void*[5] __p;
1374         }
1375     }
1376
1377     struct pthread_barrierattr_t
1378     {
1379         uint __attr;
1380     }
1381 }
1382 else version (CRuntime_UClibc)
1383 {
1384     struct pthread_barrier_t
1385     {
1386         byte[__SIZEOF_PTHREAD_BARRIER_T] __size;
1387         c_long __align;
1388     }
1389
1390     struct pthread_barrierattr_t
1391     {
1392         byte[__SIZEOF_PTHREAD_BARRIERATTR_T] __size;
1393         int __align;
1394     }
1395 }
1396 else
1397 {
1398     static assert(false, "Unsupported platform");
1399 }
1400
1401 //
1402 // Spin (SPN)
1403 //
1404 /*
1405 pthread_spinlock_t
1406 */
1407
1408 version (CRuntime_Glibc)
1409 {
1410     alias int pthread_spinlock_t; // volatile
1411 }
1412 else version (FreeBSD)
1413 {
1414     alias void* pthread_spinlock_t;
1415 }
1416 else version (NetBSD)
1417 {
1418     //already defined
1419 }
1420 else version (OpenBSD)
1421 {
1422     alias void* pthread_spinlock_t;
1423 }
1424 else version (DragonFlyBSD)
1425 {
1426     alias void* pthread_spinlock_t;
1427 }
1428 else version (Solaris)
1429 {
1430     alias pthread_mutex_t pthread_spinlock_t;
1431 }
1432 else version (CRuntime_UClibc)
1433 {
1434     alias int pthread_spinlock_t; // volatile
1435 }
1436 else version (CRuntime_Musl)
1437 {
1438     alias int pthread_spinlock_t;
1439 }
1440
1441 //
1442 // Timer (TMR)
1443 //
1444 /*
1445 clockid_t
1446 timer_t
1447 */
1448
1449 //
1450 // Trace (TRC)
1451 //
1452 /*
1453 trace_attr_t
1454 trace_event_id_t
1455 trace_event_set_t
1456 trace_id_t
1457 */