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