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