source: trunk/src/sed/gnulib-tests/pthread.in.h@ 3613

Last change on this file since 3613 was 3611, checked in by bird, 10 months ago

vendor/sed/current: GNU sed 4.9 (sed-4.9.tar.xz sha256:6e226b732e1cd739464ad6862bd1a1aba42d7982922da7a53519631d24975181)
File size: 70.7 KB
Line 
1/* Implement the most essential subset of POSIX 1003.1-2008 pthread.h.
2
3 Copyright (C) 2009-2022 Free Software Foundation, Inc.
4
5 This file is free software: you can redistribute it and/or modify
6 it under the terms of the GNU Lesser General Public License as
7 published by the Free Software Foundation; either version 2.1 of the
8 License, or (at your option) any later version.
9
10 This file is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU Lesser General Public License for more details.
14
15 You should have received a copy of the GNU Lesser General Public License
16 along with this program. If not, see <https://www.gnu.org/licenses/>. */
17
18/* Written by Paul Eggert, Glen Lenker, and Bruno Haible. */
19
20#if __GNUC__ >= 3
21@PRAGMA_SYSTEM_HEADER@
22#endif
23@PRAGMA_COLUMNS@
24
25#if defined _GL_ALREADY_INCLUDING_PTHREAD_H
26/* Special invocation convention:
27 On Android, we have a sequence of nested includes
28 <pthread.h> -> <time.h> -> <sys/time.h> -> <sys/select.h> ->
29 <signal.h> -> <pthread.h>.
30 In this situation, PTHREAD_COND_INITIALIZER is not yet defined,
31 therefore we should not attempt to define PTHREAD_MUTEX_NORMAL etc. */
32
33#@INCLUDE_NEXT@ @NEXT_PTHREAD_H@
34
35#else
36/* Normal invocation convention. */
37
38#ifndef _@GUARD_PREFIX@_PTHREAD_H_
39
40#if @HAVE_PTHREAD_H@
41
42# define _GL_ALREADY_INCLUDING_PTHREAD_H
43
44/* The include_next requires a split double-inclusion guard. */
45# @INCLUDE_NEXT@ @NEXT_PTHREAD_H@
46
47# undef _GL_ALREADY_INCLUDING_PTHREAD_H
48
49#endif
50
51#ifndef _@GUARD_PREFIX@_PTHREAD_H_
52#define _@GUARD_PREFIX@_PTHREAD_H_
53
54#define __need_system_stdlib_h
55#include <stdlib.h>
56#undef __need_system_stdlib_h
57
58
59/* The pthreads-win32 <pthread.h> defines a couple of broken macros. */
60#undef asctime_r
61#undef ctime_r
62#undef gmtime_r
63#undef localtime_r
64#undef rand_r
65#undef strtok_r
66
67#include <errno.h>
68#include <sched.h>
69#include <sys/types.h>
70#include <time.h>
71
72/* The __attribute__ feature is available in gcc versions 2.5 and later.
73 The attribute __pure__ was added in gcc 2.96. */
74#ifndef _GL_ATTRIBUTE_PURE
75# if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 96) || defined __clang__
76# define _GL_ATTRIBUTE_PURE __attribute__ ((__pure__))
77# else
78# define _GL_ATTRIBUTE_PURE /* empty */
79# endif
80#endif
81
82/* The definitions of _GL_FUNCDECL_RPL etc. are copied here. */
83
84/* The definition of _Noreturn is copied here. */
85
86/* The definition of _GL_ARG_NONNULL is copied here. */
87
88/* The definition of _GL_WARN_ON_USE is copied here. */
89
90/* =========== Thread types and macros =========== */
91
92#if (defined _WIN32 && ! defined __CYGWIN__) && USE_WINDOWS_THREADS
93# if @GNULIB_PTHREAD_THREAD@
94# include "windows-thread.h"
95# if @HAVE_PTHREAD_T@
96# define pthread_t rpl_pthread_t
97# define pthread_attr_t rpl_pthread_attr_t
98# endif
99# if !GNULIB_defined_pthread_thread_types
100typedef glwthread_thread_t pthread_t;
101typedef unsigned int pthread_attr_t;
102# define GNULIB_defined_pthread_thread_types 1
103# endif
104# else
105# if @HAVE_PTHREAD_T@
106# define pthread_t rpl_pthread_t
107# define pthread_attr_t rpl_pthread_attr_t
108# endif
109# if !GNULIB_defined_pthread_thread_types
110typedef int pthread_t;
111typedef unsigned int pthread_attr_t;
112# define GNULIB_defined_pthread_thread_types 1
113# endif
114# endif
115# undef PTHREAD_CREATE_JOINABLE
116# undef PTHREAD_CREATE_DETACHED
117# define PTHREAD_CREATE_JOINABLE 0
118# define PTHREAD_CREATE_DETACHED 1
119#else
120# if !@HAVE_PTHREAD_T@
121# if !GNULIB_defined_pthread_thread_types
122typedef int pthread_t;
123typedef unsigned int pthread_attr_t;
124# define GNULIB_defined_pthread_thread_types 1
125# endif
126# endif
127# if !@HAVE_PTHREAD_CREATE_DETACHED@
128# define PTHREAD_CREATE_JOINABLE 0
129# define PTHREAD_CREATE_DETACHED 1
130# endif
131#endif
132
133/* =========== Once-only control (initialization) types and macros ========== */
134
135#if (defined _WIN32 && ! defined __CYGWIN__) && USE_WINDOWS_THREADS
136# if @GNULIB_PTHREAD_ONCE@
137# include "windows-once.h"
138# if @HAVE_PTHREAD_T@
139# define pthread_once_t rpl_pthread_once_t
140# endif
141# if !GNULIB_defined_pthread_once_types
142typedef glwthread_once_t pthread_once_t;
143# define GNULIB_defined_pthread_once_types 1
144# endif
145# undef PTHREAD_ONCE_INIT
146# define PTHREAD_ONCE_INIT GLWTHREAD_ONCE_INIT
147# else
148# if @HAVE_PTHREAD_T@
149# define pthread_once_t rpl_pthread_once_t
150# endif
151# if !GNULIB_defined_pthread_once_types
152typedef int pthread_once_t;
153# define GNULIB_defined_pthread_once_types 1
154# endif
155# undef PTHREAD_ONCE_INIT
156# define PTHREAD_ONCE_INIT { 0 }
157# endif
158#else
159# if !@HAVE_PTHREAD_T@
160# if !GNULIB_defined_pthread_once_types
161typedef int pthread_once_t;
162# define GNULIB_defined_pthread_once_types 1
163# endif
164# undef PTHREAD_ONCE_INIT
165# define PTHREAD_ONCE_INIT { 0 }
166# endif
167#endif
168
169/* =========== Mutex types and macros =========== */
170
171#if (defined _WIN32 && ! defined __CYGWIN__) && USE_WINDOWS_THREADS
172# if @GNULIB_PTHREAD_MUTEX@
173# include "windows-timedmutex.h"
174# include "windows-timedrecmutex.h"
175# if @HAVE_PTHREAD_T@
176# define pthread_mutex_t rpl_pthread_mutex_t
177# define pthread_mutexattr_t rpl_pthread_mutexattr_t
178# endif
179# if !GNULIB_defined_pthread_mutex_types
180typedef struct
181 {
182 int type;
183 union
184 {
185 glwthread_timedmutex_t u_timedmutex;
186 glwthread_timedrecmutex_t u_timedrecmutex;
187 }
188 u;
189 }
190 pthread_mutex_t;
191typedef unsigned int pthread_mutexattr_t;
192# define GNULIB_defined_pthread_mutex_types 1
193# endif
194# undef PTHREAD_MUTEX_INITIALIZER
195# define PTHREAD_MUTEX_INITIALIZER { 1, { GLWTHREAD_TIMEDMUTEX_INIT } }
196# else
197# if @HAVE_PTHREAD_T@
198# define pthread_mutex_t rpl_pthread_mutex_t
199# define pthread_mutexattr_t rpl_pthread_mutexattr_t
200# endif
201# if !GNULIB_defined_pthread_mutex_types
202typedef int pthread_mutex_t;
203typedef unsigned int pthread_mutexattr_t;
204# define GNULIB_defined_pthread_mutex_types 1
205# endif
206# undef PTHREAD_MUTEX_INITIALIZER
207# define PTHREAD_MUTEX_INITIALIZER { 0 }
208# endif
209# undef PTHREAD_MUTEX_DEFAULT
210# undef PTHREAD_MUTEX_NORMAL
211# undef PTHREAD_MUTEX_ERRORCHECK
212# undef PTHREAD_MUTEX_RECURSIVE
213# define PTHREAD_MUTEX_DEFAULT PTHREAD_MUTEX_NORMAL
214# define PTHREAD_MUTEX_NORMAL 0
215# define PTHREAD_MUTEX_ERRORCHECK 1
216# define PTHREAD_MUTEX_RECURSIVE 2
217# undef PTHREAD_MUTEX_STALLED
218# undef PTHREAD_MUTEX_ROBUST
219# define PTHREAD_MUTEX_STALLED 0
220# define PTHREAD_MUTEX_ROBUST 1
221#else
222# if !@HAVE_PTHREAD_T@
223# if !GNULIB_defined_pthread_mutex_types
224typedef int pthread_mutex_t;
225typedef unsigned int pthread_mutexattr_t;
226# define GNULIB_defined_pthread_mutex_types 1
227# endif
228# undef PTHREAD_MUTEX_INITIALIZER
229# define PTHREAD_MUTEX_INITIALIZER { 0 }
230# endif
231# if !@HAVE_PTHREAD_MUTEX_RECURSIVE@
232# define PTHREAD_MUTEX_DEFAULT PTHREAD_MUTEX_NORMAL
233# define PTHREAD_MUTEX_NORMAL 0
234# define PTHREAD_MUTEX_ERRORCHECK 1
235# define PTHREAD_MUTEX_RECURSIVE 2
236# endif
237# if !@HAVE_PTHREAD_MUTEX_ROBUST@
238# define PTHREAD_MUTEX_STALLED 0
239# define PTHREAD_MUTEX_ROBUST 1
240# endif
241#endif
242
243/* =========== Read-write lock types and macros =========== */
244
245#if (defined _WIN32 && ! defined __CYGWIN__) && USE_WINDOWS_THREADS
246# if @GNULIB_PTHREAD_RWLOCK@
247# include "windows-timedrwlock.h"
248# if @HAVE_PTHREAD_T@
249# define pthread_rwlock_t rpl_pthread_rwlock_t
250# define pthread_rwlockattr_t rpl_pthread_rwlockattr_t
251# endif
252# if !GNULIB_defined_pthread_rwlock_types
253typedef glwthread_timedrwlock_t pthread_rwlock_t;
254typedef unsigned int pthread_rwlockattr_t;
255# define GNULIB_defined_pthread_rwlock_types 1
256# endif
257# undef PTHREAD_RWLOCK_INITIALIZER
258# define PTHREAD_RWLOCK_INITIALIZER GLWTHREAD_TIMEDRWLOCK_INIT
259# else
260# if @HAVE_PTHREAD_T@
261# define pthread_rwlock_t rpl_pthread_rwlock_t
262# define pthread_rwlockattr_t rpl_pthread_rwlockattr_t
263# endif
264# if !GNULIB_defined_pthread_rwlock_types
265typedef int pthread_rwlock_t;
266typedef unsigned int pthread_rwlockattr_t;
267# define GNULIB_defined_pthread_rwlock_types 1
268# endif
269# undef PTHREAD_RWLOCK_INITIALIZER
270# define PTHREAD_RWLOCK_INITIALIZER { 0 }
271# endif
272#elif @GNULIB_PTHREAD_RWLOCK@ && @REPLACE_PTHREAD_RWLOCK_INIT@ /* i.e. PTHREAD_RWLOCK_UNIMPLEMENTED */
273# if @HAVE_PTHREAD_T@
274# define pthread_rwlock_t rpl_pthread_rwlock_t
275# define pthread_rwlockattr_t rpl_pthread_rwlockattr_t
276# endif
277# if !GNULIB_defined_pthread_rwlock_types
278typedef struct
279 {
280 pthread_mutex_t lock; /* protects the remaining fields */
281 pthread_cond_t waiting_readers; /* waiting readers */
282 pthread_cond_t waiting_writers; /* waiting writers */
283 unsigned int waiting_writers_count; /* number of waiting writers */
284 int runcount; /* number of readers running, or -1 when a writer runs */
285 }
286 pthread_rwlock_t;
287typedef unsigned int pthread_rwlockattr_t;
288# define GNULIB_defined_pthread_rwlock_types 1
289# endif
290# undef PTHREAD_RWLOCK_INITIALIZER
291# define PTHREAD_RWLOCK_INITIALIZER \
292 { PTHREAD_MUTEX_INITIALIZER, PTHREAD_COND_INITIALIZER, PTHREAD_COND_INITIALIZER, 0, 0 }
293#else
294# if @HAVE_PTHREAD_T@
295# if !defined PTHREAD_RWLOCK_INITIALIZER && defined PTHREAD_RWLOCK_INITIALIZER_NP /* z/OS */
296# define PTHREAD_RWLOCK_INITIALIZER PTHREAD_RWLOCK_INITIALIZER_NP
297# endif
298# else
299# if !GNULIB_defined_pthread_rwlock_types
300typedef int pthread_rwlock_t;
301typedef unsigned int pthread_rwlockattr_t;
302# define GNULIB_defined_pthread_rwlock_types 1
303# endif
304# undef PTHREAD_RWLOCK_INITIALIZER
305# define PTHREAD_RWLOCK_INITIALIZER { 0 }
306# endif
307#endif
308
309/* =========== Condition variable types and macros =========== */
310
311#if (defined _WIN32 && ! defined __CYGWIN__) && USE_WINDOWS_THREADS
312# if @GNULIB_PTHREAD_COND@
313# include "windows-cond.h"
314# if @HAVE_PTHREAD_T@
315# define pthread_cond_t rpl_pthread_cond_t
316# define pthread_condattr_t rpl_pthread_condattr_t
317# endif
318# if !GNULIB_defined_pthread_cond_types
319typedef glwthread_cond_t pthread_cond_t;
320typedef unsigned int pthread_condattr_t;
321# define GNULIB_defined_pthread_cond_types 1
322# endif
323# undef PTHREAD_COND_INITIALIZER
324# define PTHREAD_COND_INITIALIZER GLWTHREAD_COND_INIT
325# else
326# if @HAVE_PTHREAD_T@
327# define pthread_cond_t rpl_pthread_cond_t
328# define pthread_condattr_t rpl_pthread_condattr_t
329# endif
330# if !GNULIB_defined_pthread_cond_types
331typedef int pthread_cond_t;
332typedef unsigned int pthread_condattr_t;
333# define GNULIB_defined_pthread_cond_types 1
334# endif
335# undef PTHREAD_COND_INITIALIZER
336# define PTHREAD_COND_INITIALIZER { 0 }
337# endif
338#else
339# if !@HAVE_PTHREAD_T@
340# if !GNULIB_defined_pthread_cond_types
341typedef int pthread_cond_t;
342typedef unsigned int pthread_condattr_t;
343# define GNULIB_defined_pthread_cond_types 1
344# endif
345# undef PTHREAD_COND_INITIALIZER
346# define PTHREAD_COND_INITIALIZER { 0 }
347# endif
348#endif
349
350/* =========== Thread-specific storage types and macros =========== */
351
352#if (defined _WIN32 && ! defined __CYGWIN__) && USE_WINDOWS_THREADS
353# if @GNULIB_PTHREAD_TSS@
354# include "windows-tls.h"
355# if @HAVE_PTHREAD_T@
356# define pthread_key_t rpl_pthread_key_t
357# endif
358# if !GNULIB_defined_pthread_tss_types
359typedef glwthread_tls_key_t pthread_key_t;
360# define GNULIB_defined_pthread_tss_types 1
361# endif
362# undef PTHREAD_DESTRUCTOR_ITERATIONS
363# define PTHREAD_DESTRUCTOR_ITERATIONS GLWTHREAD_DESTRUCTOR_ITERATIONS
364# else
365# if @HAVE_PTHREAD_T@
366# define pthread_key_t rpl_pthread_key_t
367# endif
368# if !GNULIB_defined_pthread_tss_types
369typedef void ** pthread_key_t;
370# define GNULIB_defined_pthread_tss_types 1
371# endif
372# undef PTHREAD_DESTRUCTOR_ITERATIONS
373# define PTHREAD_DESTRUCTOR_ITERATIONS 0
374# endif
375#else
376# if !@HAVE_PTHREAD_T@
377# if !GNULIB_defined_pthread_tss_types
378typedef void ** pthread_key_t;
379# define GNULIB_defined_pthread_tss_types 1
380# endif
381# undef PTHREAD_DESTRUCTOR_ITERATIONS
382# define PTHREAD_DESTRUCTOR_ITERATIONS 0
383# endif
384#endif
385
386/* =========== Spinlock types and macros =========== */
387
388#if (defined _WIN32 && ! defined __CYGWIN__) && USE_WINDOWS_THREADS
389# if @GNULIB_PTHREAD_SPIN@
390# include "windows-spin.h"
391# if @HAVE_PTHREAD_T@
392# define pthread_spinlock_t rpl_pthread_spinlock_t
393# endif
394# if !GNULIB_defined_pthread_spin_types
395typedef glwthread_spinlock_t pthread_spinlock_t;
396# define GNULIB_defined_pthread_spin_types 1
397# endif
398# else
399# if @HAVE_PTHREAD_T@
400# define pthread_spinlock_t rpl_pthread_spinlock_t
401# endif
402# if !GNULIB_defined_pthread_spin_types
403typedef pthread_mutex_t pthread_spinlock_t;
404# define GNULIB_defined_pthread_spin_types 1
405# endif
406# endif
407# undef PTHREAD_PROCESS_PRIVATE
408# undef PTHREAD_PROCESS_SHARED
409# define PTHREAD_PROCESS_PRIVATE 0
410# define PTHREAD_PROCESS_SHARED 1
411#else
412# if !@HAVE_PTHREAD_SPINLOCK_T@
413/* Approximate spinlocks with mutexes. */
414# if !GNULIB_defined_pthread_spin_types
415typedef pthread_mutex_t pthread_spinlock_t;
416# define GNULIB_defined_pthread_spin_types 1
417# endif
418# endif
419# if !@HAVE_PTHREAD_PROCESS_SHARED@
420# define PTHREAD_PROCESS_PRIVATE 0
421# define PTHREAD_PROCESS_SHARED 1
422# endif
423#endif
424
425/* =========== Other types and macros =========== */
426
427#if !@HAVE_PTHREAD_T@
428# if !GNULIB_defined_other_pthread_types
429typedef int pthread_barrier_t;
430typedef unsigned int pthread_barrierattr_t;
431# define GNULIB_defined_other_pthread_types 1
432# endif
433#endif
434
435#if !defined PTHREAD_CANCELED
436
437# define PTHREAD_BARRIER_SERIAL_THREAD (-1)
438
439# define PTHREAD_CANCEL_DEFERRED 0
440# define PTHREAD_CANCEL_ASYNCHRONOUS 1
441
442# define PTHREAD_CANCEL_ENABLE 0
443# define PTHREAD_CANCEL_DISABLE 1
444
445# define PTHREAD_CANCELED ((void *) -1)
446
447# define PTHREAD_INHERIT_SCHED 0
448# define PTHREAD_EXPLICIT_SCHED 1
449
450# define PTHREAD_PRIO_NONE 0
451# define PTHREAD_PRIO_INHERIT 1
452# define PTHREAD_PRIO_PROTECT 2
453
454# define PTHREAD_SCOPE_SYSTEM 0
455# define PTHREAD_SCOPE_PROCESS 1
456
457#endif
458
459/* =========== Thread functions =========== */
460
461#if @GNULIB_PTHREAD_THREAD@
462/* The 'restrict' qualifier on ARG is nonsense, but POSIX specifies it this way.
463 Sigh. */
464# if @REPLACE_PTHREAD_CREATE@
465# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
466# undef pthread_create
467# define pthread_create rpl_pthread_create
468# endif
469_GL_FUNCDECL_RPL (pthread_create, int,
470 (pthread_t *restrict threadp,
471 const pthread_attr_t *restrict attr,
472 void * (*mainfunc) (void *), void *restrict arg)
473 _GL_ARG_NONNULL ((1, 3)));
474_GL_CXXALIAS_RPL (pthread_create, int,
475 (pthread_t *restrict threadp,
476 const pthread_attr_t *restrict attr,
477 void * (*mainfunc) (void *), void *restrict arg));
478# else
479# if !@HAVE_PTHREAD_CREATE@
480_GL_FUNCDECL_SYS (pthread_create, int,
481 (pthread_t *restrict threadp,
482 const pthread_attr_t *restrict attr,
483 void * (*mainfunc) (void *), void *restrict arg)
484 _GL_ARG_NONNULL ((1, 3)));
485# endif
486_GL_CXXALIAS_SYS_CAST (pthread_create, int,
487 (pthread_t *restrict threadp,
488 const pthread_attr_t *restrict attr,
489 void * (*mainfunc) (void *), void *restrict arg));
490# endif
491# if __GLIBC__ >= 2
492_GL_CXXALIASWARN (pthread_create);
493# endif
494#elif defined GNULIB_POSIXCHECK
495# undef pthread_create
496# if HAVE_RAW_DECL_PTHREAD_CREATE
497_GL_WARN_ON_USE (pthread_create, "pthread_create is not portable - "
498 "use gnulib module pthread-thread for portability");
499# endif
500#endif
501
502#if @GNULIB_PTHREAD_THREAD@
503# if @REPLACE_PTHREAD_ATTR_INIT@
504# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
505# undef pthread_attr_init
506# define pthread_attr_init rpl_pthread_attr_init
507# endif
508_GL_FUNCDECL_RPL (pthread_attr_init, int, (pthread_attr_t *attr)
509 _GL_ARG_NONNULL ((1)));
510_GL_CXXALIAS_RPL (pthread_attr_init, int, (pthread_attr_t *attr));
511# else
512# if !@HAVE_PTHREAD_ATTR_INIT@
513_GL_FUNCDECL_SYS (pthread_attr_init, int, (pthread_attr_t *attr)
514 _GL_ARG_NONNULL ((1)));
515# endif
516_GL_CXXALIAS_SYS (pthread_attr_init, int, (pthread_attr_t *attr));
517# endif
518# if __GLIBC__ >= 2
519_GL_CXXALIASWARN (pthread_attr_init);
520# endif
521#elif defined GNULIB_POSIXCHECK
522# undef pthread_attr_init
523# if HAVE_RAW_DECL_PTHREAD_ATTR_INIT
524_GL_WARN_ON_USE (pthread_attr_init, "pthread_attr_init is not portable - "
525 "use gnulib module pthread-thread for portability");
526# endif
527#endif
528
529#if @GNULIB_PTHREAD_THREAD@
530# if @REPLACE_PTHREAD_ATTR_GETDETACHSTATE@
531# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
532# undef pthread_attr_getdetachstate
533# define pthread_attr_getdetachstate rpl_pthread_attr_getdetachstate
534# endif
535_GL_FUNCDECL_RPL (pthread_attr_getdetachstate, int,
536 (const pthread_attr_t *attr, int *detachstatep)
537 _GL_ARG_NONNULL ((1, 2)));
538_GL_CXXALIAS_RPL (pthread_attr_getdetachstate, int,
539 (const pthread_attr_t *attr, int *detachstatep));
540# else
541# if !@HAVE_PTHREAD_ATTR_GETDETACHSTATE@
542_GL_FUNCDECL_SYS (pthread_attr_getdetachstate, int,
543 (const pthread_attr_t *attr, int *detachstatep)
544 _GL_ARG_NONNULL ((1, 2)));
545# endif
546_GL_CXXALIAS_SYS (pthread_attr_getdetachstate, int,
547 (const pthread_attr_t *attr, int *detachstatep));
548# endif
549# if __GLIBC__ >= 2
550_GL_CXXALIASWARN (pthread_attr_getdetachstate);
551# endif
552#elif defined GNULIB_POSIXCHECK
553# undef pthread_attr_getdetachstate
554# if HAVE_RAW_DECL_PTHREAD_ATTR_GETDETACHSTATE
555_GL_WARN_ON_USE (pthread_attr_getdetachstate, "pthread_attr_getdetachstate is not portable - "
556 "use gnulib module pthread-thread for portability");
557# endif
558#endif
559
560#if @GNULIB_PTHREAD_THREAD@
561# if @REPLACE_PTHREAD_ATTR_SETDETACHSTATE@
562# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
563# undef pthread_attr_setdetachstate
564# define pthread_attr_setdetachstate rpl_pthread_attr_setdetachstate
565# endif
566_GL_FUNCDECL_RPL (pthread_attr_setdetachstate, int,
567 (pthread_attr_t *attr, int detachstate)
568 _GL_ARG_NONNULL ((1)));
569_GL_CXXALIAS_RPL (pthread_attr_setdetachstate, int,
570 (pthread_attr_t *attr, int detachstate));
571# else
572# if !@HAVE_PTHREAD_ATTR_SETDETACHSTATE@
573_GL_FUNCDECL_SYS (pthread_attr_setdetachstate, int,
574 (pthread_attr_t *attr, int detachstate)
575 _GL_ARG_NONNULL ((1)));
576# endif
577_GL_CXXALIAS_SYS (pthread_attr_setdetachstate, int,
578 (pthread_attr_t *attr, int detachstate));
579# endif
580# if __GLIBC__ >= 2
581_GL_CXXALIASWARN (pthread_attr_setdetachstate);
582# endif
583#elif defined GNULIB_POSIXCHECK
584# undef pthread_attr_setdetachstate
585# if HAVE_RAW_DECL_PTHREAD_ATTR_SETDETACHSTATE
586_GL_WARN_ON_USE (pthread_attr_setdetachstate, "pthread_attr_setdetachstate is not portable - "
587 "use gnulib module pthread-thread for portability");
588# endif
589#endif
590
591#if @GNULIB_PTHREAD_THREAD@
592# if @REPLACE_PTHREAD_ATTR_DESTROY@
593# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
594# undef pthread_attr_destroy
595# define pthread_attr_destroy rpl_pthread_attr_destroy
596# endif
597_GL_FUNCDECL_RPL (pthread_attr_destroy, int, (pthread_attr_t *attr)
598 _GL_ARG_NONNULL ((1)));
599_GL_CXXALIAS_RPL (pthread_attr_destroy, int, (pthread_attr_t *attr));
600# else
601# if !@HAVE_PTHREAD_ATTR_DESTROY@
602_GL_FUNCDECL_SYS (pthread_attr_destroy, int, (pthread_attr_t *attr)
603 _GL_ARG_NONNULL ((1)));
604# endif
605_GL_CXXALIAS_SYS (pthread_attr_destroy, int, (pthread_attr_t *attr));
606# endif
607# if __GLIBC__ >= 2
608_GL_CXXALIASWARN (pthread_attr_destroy);
609# endif
610#elif defined GNULIB_POSIXCHECK
611# undef pthread_attr_destroy
612# if HAVE_RAW_DECL_PTHREAD_ATTR_DESTROY
613_GL_WARN_ON_USE (pthread_attr_destroy, "pthread_attr_destroy is not portable - "
614 "use gnulib module pthread-thread for portability");
615# endif
616#endif
617
618#if @GNULIB_PTHREAD_THREAD@
619# if @REPLACE_PTHREAD_SELF@
620# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
621# undef pthread_self
622# define pthread_self rpl_pthread_self
623# endif
624_GL_FUNCDECL_RPL (pthread_self, pthread_t, (void) _GL_ATTRIBUTE_PURE);
625_GL_CXXALIAS_RPL (pthread_self, pthread_t, (void));
626# else
627# if !@HAVE_PTHREAD_SELF@
628_GL_FUNCDECL_SYS (pthread_self, pthread_t, (void) _GL_ATTRIBUTE_PURE);
629# endif
630_GL_CXXALIAS_SYS (pthread_self, pthread_t, (void));
631# endif
632# if __GLIBC__ >= 2
633_GL_CXXALIASWARN (pthread_self);
634# endif
635#elif defined GNULIB_POSIXCHECK
636# undef pthread_self
637# if HAVE_RAW_DECL_PTHREAD_SELF
638_GL_WARN_ON_USE (pthread_self, "pthread_self is not portable - "
639 "use gnulib module pthread-thread for portability");
640# endif
641#endif
642
643#if @GNULIB_PTHREAD_THREAD@
644# if @REPLACE_PTHREAD_EQUAL@
645# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
646# undef pthread_equal
647# define pthread_equal rpl_pthread_equal
648# endif
649_GL_FUNCDECL_RPL (pthread_equal, int, (pthread_t thread1, pthread_t thread2));
650_GL_CXXALIAS_RPL (pthread_equal, int, (pthread_t thread1, pthread_t thread2));
651# else
652# if !@HAVE_PTHREAD_EQUAL@
653_GL_FUNCDECL_SYS (pthread_equal, int, (pthread_t thread1, pthread_t thread2));
654# endif
655_GL_CXXALIAS_SYS (pthread_equal, int, (pthread_t thread1, pthread_t thread2));
656# endif
657# if __GLIBC__ >= 2
658_GL_CXXALIASWARN (pthread_equal);
659# endif
660#elif defined GNULIB_POSIXCHECK
661# undef pthread_equal
662# if HAVE_RAW_DECL_PTHREAD_EQUAL
663_GL_WARN_ON_USE (pthread_equal, "pthread_equal is not portable - "
664 "use gnulib module pthread-thread for portability");
665# endif
666#endif
667
668#if @GNULIB_PTHREAD_THREAD@
669# if @REPLACE_PTHREAD_DETACH@
670# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
671# undef pthread_detach
672# define pthread_detach rpl_pthread_detach
673# endif
674_GL_FUNCDECL_RPL (pthread_detach, int, (pthread_t thread));
675_GL_CXXALIAS_RPL (pthread_detach, int, (pthread_t thread));
676# else
677# if !@HAVE_PTHREAD_DETACH@
678_GL_FUNCDECL_SYS (pthread_detach, int, (pthread_t thread));
679# endif
680_GL_CXXALIAS_SYS (pthread_detach, int, (pthread_t thread));
681# endif
682# if __GLIBC__ >= 2
683_GL_CXXALIASWARN (pthread_detach);
684# endif
685#elif defined GNULIB_POSIXCHECK
686# undef pthread_detach
687# if HAVE_RAW_DECL_PTHREAD_DETACH
688_GL_WARN_ON_USE (pthread_detach, "pthread_detach is not portable - "
689 "use gnulib module pthread-thread for portability");
690# endif
691#endif
692
693#if @GNULIB_PTHREAD_THREAD@
694# if @REPLACE_PTHREAD_JOIN@
695# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
696# undef pthread_join
697# define pthread_join rpl_pthread_join
698# endif
699_GL_FUNCDECL_RPL (pthread_join, int, (pthread_t thread, void **valuep));
700_GL_CXXALIAS_RPL (pthread_join, int, (pthread_t thread, void **valuep));
701# else
702# if !@HAVE_PTHREAD_JOIN@
703_GL_FUNCDECL_SYS (pthread_join, int, (pthread_t thread, void **valuep));
704# endif
705_GL_CXXALIAS_SYS (pthread_join, int, (pthread_t thread, void **valuep));
706# endif
707# if __GLIBC__ >= 2
708_GL_CXXALIASWARN (pthread_join);
709# endif
710#elif defined GNULIB_POSIXCHECK
711# undef pthread_join
712# if HAVE_RAW_DECL_PTHREAD_JOIN
713_GL_WARN_ON_USE (pthread_join, "pthread_join is not portable - "
714 "use gnulib module pthread-thread for portability");
715# endif
716#endif
717
718#if @GNULIB_PTHREAD_THREAD@
719# if @REPLACE_PTHREAD_EXIT@
720# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
721# undef pthread_exit
722# define pthread_exit rpl_pthread_exit
723# endif
724_GL_FUNCDECL_RPL (pthread_exit, _Noreturn void, (void *value));
725_GL_CXXALIAS_RPL (pthread_exit, void, (void *value));
726# else
727# if !@HAVE_PTHREAD_EXIT@
728_GL_FUNCDECL_SYS (pthread_exit, _Noreturn void, (void *value));
729# endif
730/* Need to cast because of AIX with xlclang++. */
731_GL_CXXALIAS_SYS_CAST (pthread_exit, void, (void *value));
732# endif
733# if __GLIBC__ >= 2
734_GL_CXXALIASWARN (pthread_exit);
735# endif
736#elif defined GNULIB_POSIXCHECK
737# undef pthread_exit
738# if HAVE_RAW_DECL_PTHREAD_EXIT
739_GL_WARN_ON_USE (pthread_exit, "pthread_exit is not portable - "
740 "use gnulib module pthread-thread for portability");
741# endif
742#endif
743
744/* =========== Once-only control (initialization) functions =========== */
745
746#if @GNULIB_PTHREAD_ONCE@
747# if @REPLACE_PTHREAD_ONCE@
748# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
749# undef pthread_once
750# define pthread_once rpl_pthread_once
751# endif
752_GL_FUNCDECL_RPL (pthread_once, int,
753 (pthread_once_t *once_control, void (*initfunction) (void))
754 _GL_ARG_NONNULL ((1, 2)));
755_GL_CXXALIAS_RPL (pthread_once, int,
756 (pthread_once_t *once_control, void (*initfunction) (void)));
757# else
758# if !@HAVE_PTHREAD_ONCE@
759_GL_FUNCDECL_SYS (pthread_once, int,
760 (pthread_once_t *once_control, void (*initfunction) (void))
761 _GL_ARG_NONNULL ((1, 2)));
762# endif
763_GL_CXXALIAS_SYS_CAST (pthread_once, int,
764 (pthread_once_t *once_control,
765 void (*initfunction) (void)));
766# endif
767# if __GLIBC__ >= 2
768_GL_CXXALIASWARN (pthread_once);
769# endif
770#elif defined GNULIB_POSIXCHECK
771# undef pthread_once
772# if HAVE_RAW_DECL_PTHREAD_ONCE
773_GL_WARN_ON_USE (pthread_once, "pthread_once is not portable - "
774 "use gnulib module pthread-once for portability");
775# endif
776#endif
777
778/* =========== Mutex functions =========== */
779
780#if @GNULIB_PTHREAD_MUTEX@
781# if @REPLACE_PTHREAD_MUTEX_INIT@
782# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
783# undef pthread_mutex_init
784# define pthread_mutex_init rpl_pthread_mutex_init
785# endif
786_GL_FUNCDECL_RPL (pthread_mutex_init, int,
787 (pthread_mutex_t *restrict mutex,
788 const pthread_mutexattr_t *restrict attr)
789 _GL_ARG_NONNULL ((1)));
790_GL_CXXALIAS_RPL (pthread_mutex_init, int,
791 (pthread_mutex_t *restrict mutex,
792 const pthread_mutexattr_t *restrict attr));
793# else
794# if !@HAVE_PTHREAD_MUTEX_INIT@
795_GL_FUNCDECL_SYS (pthread_mutex_init, int,
796 (pthread_mutex_t *restrict mutex,
797 const pthread_mutexattr_t *restrict attr)
798 _GL_ARG_NONNULL ((1)));
799# endif
800_GL_CXXALIAS_SYS (pthread_mutex_init, int,
801 (pthread_mutex_t *restrict mutex,
802 const pthread_mutexattr_t *restrict attr));
803# endif
804# if __GLIBC__ >= 2
805_GL_CXXALIASWARN (pthread_mutex_init);
806# endif
807#elif defined GNULIB_POSIXCHECK
808# undef pthread_mutex_init
809# if HAVE_RAW_DECL_PTHREAD_MUTEX_INIT
810_GL_WARN_ON_USE (pthread_mutex_init, "pthread_mutex_init is not portable - "
811 "use gnulib module pthread-mutex for portability");
812# endif
813#endif
814
815#if @GNULIB_PTHREAD_MUTEX@
816# if @REPLACE_PTHREAD_MUTEXATTR_INIT@
817# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
818# undef pthread_mutexattr_init
819# define pthread_mutexattr_init rpl_pthread_mutexattr_init
820# endif
821_GL_FUNCDECL_RPL (pthread_mutexattr_init, int, (pthread_mutexattr_t *attr)
822 _GL_ARG_NONNULL ((1)));
823_GL_CXXALIAS_RPL (pthread_mutexattr_init, int, (pthread_mutexattr_t *attr));
824# else
825# if !@HAVE_PTHREAD_MUTEXATTR_INIT@
826_GL_FUNCDECL_SYS (pthread_mutexattr_init, int, (pthread_mutexattr_t *attr)
827 _GL_ARG_NONNULL ((1)));
828# endif
829_GL_CXXALIAS_SYS (pthread_mutexattr_init, int, (pthread_mutexattr_t *attr));
830# endif
831# if __GLIBC__ >= 2
832_GL_CXXALIASWARN (pthread_mutexattr_init);
833# endif
834#elif defined GNULIB_POSIXCHECK
835# undef pthread_mutexattr_init
836# if HAVE_RAW_DECL_PTHREAD_MUTEXATTR_INIT
837_GL_WARN_ON_USE (pthread_mutexattr_init, "pthread_mutexattr_init is not portable - "
838 "use gnulib module pthread-mutex for portability");
839# endif
840#endif
841
842#if @GNULIB_PTHREAD_MUTEX@
843# if @REPLACE_PTHREAD_MUTEXATTR_GETTYPE@
844# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
845# undef pthread_mutexattr_gettype
846# define pthread_mutexattr_gettype rpl_pthread_mutexattr_gettype
847# endif
848_GL_FUNCDECL_RPL (pthread_mutexattr_gettype, int,
849 (const pthread_mutexattr_t *restrict attr,
850 int *restrict typep)
851 _GL_ARG_NONNULL ((1, 2)));
852_GL_CXXALIAS_RPL (pthread_mutexattr_gettype, int,
853 (const pthread_mutexattr_t *restrict attr,
854 int *restrict typep));
855# else
856# if !@HAVE_PTHREAD_MUTEXATTR_GETTYPE@
857_GL_FUNCDECL_SYS (pthread_mutexattr_gettype, int,
858 (const pthread_mutexattr_t *restrict attr,
859 int *restrict typep)
860 _GL_ARG_NONNULL ((1, 2)));
861# endif
862/* Need to cast, because on FreeBSD the first parameter is
863 pthread_mutexattr_t *attr. */
864_GL_CXXALIAS_SYS_CAST (pthread_mutexattr_gettype, int,
865 (const pthread_mutexattr_t *restrict attr,
866 int *restrict typep));
867# endif
868# if __GLIBC__ >= 2
869_GL_CXXALIASWARN (pthread_mutexattr_gettype);
870# endif
871#elif defined GNULIB_POSIXCHECK
872# undef pthread_mutexattr_gettype
873# if HAVE_RAW_DECL_PTHREAD_MUTEXATTR_GETTYPE
874_GL_WARN_ON_USE (pthread_mutexattr_gettype, "pthread_mutexattr_gettype is not portable - "
875 "use gnulib module pthread-mutex for portability");
876# endif
877#endif
878
879#if @GNULIB_PTHREAD_MUTEX@
880# if @REPLACE_PTHREAD_MUTEXATTR_SETTYPE@
881# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
882# undef pthread_mutexattr_settype
883# define pthread_mutexattr_settype rpl_pthread_mutexattr_settype
884# endif
885_GL_FUNCDECL_RPL (pthread_mutexattr_settype, int,
886 (pthread_mutexattr_t *attr, int type) _GL_ARG_NONNULL ((1)));
887_GL_CXXALIAS_RPL (pthread_mutexattr_settype, int,
888 (pthread_mutexattr_t *attr, int type));
889# else
890# if !@HAVE_PTHREAD_MUTEXATTR_SETTYPE@
891_GL_FUNCDECL_SYS (pthread_mutexattr_settype, int,
892 (pthread_mutexattr_t *attr, int type) _GL_ARG_NONNULL ((1)));
893# endif
894_GL_CXXALIAS_SYS (pthread_mutexattr_settype, int,
895 (pthread_mutexattr_t *attr, int type));
896# endif
897# if __GLIBC__ >= 2
898_GL_CXXALIASWARN (pthread_mutexattr_settype);
899# endif
900#elif defined GNULIB_POSIXCHECK
901# undef pthread_mutexattr_settype
902# if HAVE_RAW_DECL_PTHREAD_MUTEXATTR_SETTYPE
903_GL_WARN_ON_USE (pthread_mutexattr_settype, "pthread_mutexattr_settype is not portable - "
904 "use gnulib module pthread-mutex for portability");
905# endif
906#endif
907
908#if @GNULIB_PTHREAD_MUTEX@
909# if @REPLACE_PTHREAD_MUTEXATTR_GETROBUST@
910# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
911# undef pthread_mutexattr_getrobust
912# define pthread_mutexattr_getrobust rpl_pthread_mutexattr_getrobust
913# endif
914_GL_FUNCDECL_RPL (pthread_mutexattr_getrobust, int,
915 (const pthread_mutexattr_t *restrict attr,
916 int *restrict robustp)
917 _GL_ARG_NONNULL ((1, 2)));
918_GL_CXXALIAS_RPL (pthread_mutexattr_getrobust, int,
919 (const pthread_mutexattr_t *restrict attr,
920 int *restrict robustp));
921# else
922# if !@HAVE_PTHREAD_MUTEXATTR_GETROBUST@
923_GL_FUNCDECL_SYS (pthread_mutexattr_getrobust, int,
924 (const pthread_mutexattr_t *restrict attr,
925 int *restrict robustp)
926 _GL_ARG_NONNULL ((1, 2)));
927# endif
928/* Need to cast, because on FreeBSD the first parameter is
929 pthread_mutexattr_t *attr. */
930_GL_CXXALIAS_SYS_CAST (pthread_mutexattr_getrobust, int,
931 (const pthread_mutexattr_t *restrict attr,
932 int *restrict robustp));
933# endif
934# if __GLIBC__ >= 2
935_GL_CXXALIASWARN (pthread_mutexattr_getrobust);
936# endif
937#elif defined GNULIB_POSIXCHECK
938# undef pthread_mutexattr_getrobust
939# if HAVE_RAW_DECL_PTHREAD_MUTEXATTR_GETROBUST
940_GL_WARN_ON_USE (pthread_mutexattr_getrobust, "pthread_mutexattr_getrobust is not portable - "
941 "use gnulib module pthread-mutex for portability");
942# endif
943#endif
944
945#if @GNULIB_PTHREAD_MUTEX@
946# if @REPLACE_PTHREAD_MUTEXATTR_SETROBUST@
947# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
948# undef pthread_mutexattr_setrobust
949# define pthread_mutexattr_setrobust rpl_pthread_mutexattr_setrobust
950# endif
951_GL_FUNCDECL_RPL (pthread_mutexattr_setrobust, int,
952 (pthread_mutexattr_t *attr, int robust)
953 _GL_ARG_NONNULL ((1)));
954_GL_CXXALIAS_RPL (pthread_mutexattr_setrobust, int,
955 (pthread_mutexattr_t *attr, int robust));
956# else
957# if !@HAVE_PTHREAD_MUTEXATTR_SETROBUST@
958_GL_FUNCDECL_SYS (pthread_mutexattr_setrobust, int,
959 (pthread_mutexattr_t *attr, int robust)
960 _GL_ARG_NONNULL ((1)));
961# endif
962_GL_CXXALIAS_SYS (pthread_mutexattr_setrobust, int,
963 (pthread_mutexattr_t *attr, int robust));
964# endif
965# if __GLIBC__ >= 2
966_GL_CXXALIASWARN (pthread_mutexattr_setrobust);
967# endif
968#elif defined GNULIB_POSIXCHECK
969# undef pthread_mutexattr_setrobust
970# if HAVE_RAW_DECL_PTHREAD_MUTEXATTR_SETROBUST
971_GL_WARN_ON_USE (pthread_mutexattr_setrobust, "pthread_mutexattr_setrobust is not portable - "
972 "use gnulib module pthread-mutex for portability");
973# endif
974#endif
975
976#if @GNULIB_PTHREAD_MUTEX@
977# if @REPLACE_PTHREAD_MUTEXATTR_DESTROY@
978# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
979# undef pthread_mutexattr_destroy
980# define pthread_mutexattr_destroy rpl_pthread_mutexattr_destroy
981# endif
982_GL_FUNCDECL_RPL (pthread_mutexattr_destroy, int, (pthread_mutexattr_t *attr)
983 _GL_ARG_NONNULL ((1)));
984_GL_CXXALIAS_RPL (pthread_mutexattr_destroy, int, (pthread_mutexattr_t *attr));
985# else
986# if !@HAVE_PTHREAD_MUTEXATTR_DESTROY@
987_GL_FUNCDECL_SYS (pthread_mutexattr_destroy, int, (pthread_mutexattr_t *attr)
988 _GL_ARG_NONNULL ((1)));
989# endif
990_GL_CXXALIAS_SYS (pthread_mutexattr_destroy, int, (pthread_mutexattr_t *attr));
991# endif
992# if __GLIBC__ >= 2
993_GL_CXXALIASWARN (pthread_mutexattr_destroy);
994# endif
995#elif defined GNULIB_POSIXCHECK
996# undef pthread_mutexattr_destroy
997# if HAVE_RAW_DECL_PTHREAD_MUTEXATTR_DESTROY
998_GL_WARN_ON_USE (pthread_mutexattr_destroy, "pthread_mutexattr_destroy is not portable - "
999 "use gnulib module pthread-mutex for portability");
1000# endif
1001#endif
1002
1003#if @GNULIB_PTHREAD_MUTEX@
1004# if @REPLACE_PTHREAD_MUTEX_LOCK@
1005# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1006# undef pthread_mutex_lock
1007# define pthread_mutex_lock rpl_pthread_mutex_lock
1008# endif
1009_GL_FUNCDECL_RPL (pthread_mutex_lock, int, (pthread_mutex_t *mutex)
1010 _GL_ARG_NONNULL ((1)));
1011_GL_CXXALIAS_RPL (pthread_mutex_lock, int, (pthread_mutex_t *mutex));
1012# else
1013# if !@HAVE_PTHREAD_MUTEX_LOCK@
1014_GL_FUNCDECL_SYS (pthread_mutex_lock, int, (pthread_mutex_t *mutex)
1015 _GL_ARG_NONNULL ((1)));
1016# endif
1017_GL_CXXALIAS_SYS (pthread_mutex_lock, int, (pthread_mutex_t *mutex));
1018# endif
1019# if __GLIBC__ >= 2
1020_GL_CXXALIASWARN (pthread_mutex_lock);
1021# endif
1022#elif defined GNULIB_POSIXCHECK
1023# undef pthread_mutex_lock
1024# if HAVE_RAW_DECL_PTHREAD_MUTEX_LOCK
1025_GL_WARN_ON_USE (pthread_mutex_lock, "pthread_mutex_lock is not portable - "
1026 "use gnulib module pthread-mutex for portability");
1027# endif
1028#endif
1029
1030#if @GNULIB_PTHREAD_MUTEX@
1031# if @REPLACE_PTHREAD_MUTEX_TRYLOCK@
1032# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1033# undef pthread_mutex_trylock
1034# define pthread_mutex_trylock rpl_pthread_mutex_trylock
1035# endif
1036_GL_FUNCDECL_RPL (pthread_mutex_trylock, int, (pthread_mutex_t *mutex)
1037 _GL_ARG_NONNULL ((1)));
1038_GL_CXXALIAS_RPL (pthread_mutex_trylock, int, (pthread_mutex_t *mutex));
1039# else
1040# if !@HAVE_PTHREAD_MUTEX_TRYLOCK@
1041_GL_FUNCDECL_SYS (pthread_mutex_trylock, int, (pthread_mutex_t *mutex)
1042 _GL_ARG_NONNULL ((1)));
1043# endif
1044_GL_CXXALIAS_SYS (pthread_mutex_trylock, int, (pthread_mutex_t *mutex));
1045# endif
1046# if __GLIBC__ >= 2
1047_GL_CXXALIASWARN (pthread_mutex_trylock);
1048# endif
1049#elif defined GNULIB_POSIXCHECK
1050# undef pthread_mutex_trylock
1051# if HAVE_RAW_DECL_PTHREAD_MUTEX_TRYLOCK
1052_GL_WARN_ON_USE (pthread_mutex_trylock, "pthread_mutex_trylock is not portable - "
1053 "use gnulib module pthread-mutex for portability");
1054# endif
1055#endif
1056
1057#if @GNULIB_PTHREAD_MUTEX_TIMEDLOCK@
1058# if @REPLACE_PTHREAD_MUTEX_TIMEDLOCK@
1059# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1060# undef pthread_mutex_timedlock
1061# define pthread_mutex_timedlock rpl_pthread_mutex_timedlock
1062# endif
1063_GL_FUNCDECL_RPL (pthread_mutex_timedlock, int,
1064 (pthread_mutex_t *restrict mutex,
1065 const struct timespec *restrict abstime)
1066 _GL_ARG_NONNULL ((1, 2)));
1067_GL_CXXALIAS_RPL (pthread_mutex_timedlock, int,
1068 (pthread_mutex_t *restrict mutex,
1069 const struct timespec *restrict abstime));
1070# else
1071# if !@HAVE_PTHREAD_MUTEX_TIMEDLOCK@
1072_GL_FUNCDECL_SYS (pthread_mutex_timedlock, int,
1073 (pthread_mutex_t *restrict mutex,
1074 const struct timespec *restrict abstime)
1075 _GL_ARG_NONNULL ((1, 2)));
1076# endif
1077_GL_CXXALIAS_SYS (pthread_mutex_timedlock, int,
1078 (pthread_mutex_t *restrict mutex,
1079 const struct timespec *restrict abstime));
1080# endif
1081# if __GLIBC__ >= 2
1082_GL_CXXALIASWARN (pthread_mutex_timedlock);
1083# endif
1084#elif defined GNULIB_POSIXCHECK
1085# undef pthread_mutex_timedlock
1086# if HAVE_RAW_DECL_PTHREAD_MUTEX_TIMEDLOCK
1087_GL_WARN_ON_USE (pthread_mutex_timedlock, "pthread_mutex_timedlock is not portable - "
1088 "use gnulib module pthread_mutex_timedlock for portability");
1089# endif
1090#endif
1091
1092#if @GNULIB_PTHREAD_MUTEX@
1093# if @REPLACE_PTHREAD_MUTEX_UNLOCK@
1094# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1095# undef pthread_mutex_unlock
1096# define pthread_mutex_unlock rpl_pthread_mutex_unlock
1097# endif
1098_GL_FUNCDECL_RPL (pthread_mutex_unlock, int, (pthread_mutex_t *mutex)
1099 _GL_ARG_NONNULL ((1)));
1100_GL_CXXALIAS_RPL (pthread_mutex_unlock, int, (pthread_mutex_t *mutex));
1101# else
1102# if !@HAVE_PTHREAD_MUTEX_UNLOCK@
1103_GL_FUNCDECL_SYS (pthread_mutex_unlock, int, (pthread_mutex_t *mutex)
1104 _GL_ARG_NONNULL ((1)));
1105# endif
1106_GL_CXXALIAS_SYS (pthread_mutex_unlock, int, (pthread_mutex_t *mutex));
1107# endif
1108# if __GLIBC__ >= 2
1109_GL_CXXALIASWARN (pthread_mutex_unlock);
1110# endif
1111#elif defined GNULIB_POSIXCHECK
1112# undef pthread_mutex_unlock
1113# if HAVE_RAW_DECL_PTHREAD_MUTEX_UNLOCK
1114_GL_WARN_ON_USE (pthread_mutex_unlock, "pthread_mutex_unlock is not portable - "
1115 "use gnulib module pthread-mutex for portability");
1116# endif
1117#endif
1118
1119#if @GNULIB_PTHREAD_MUTEX@
1120# if @REPLACE_PTHREAD_MUTEX_DESTROY@
1121# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1122# undef pthread_mutex_destroy
1123# define pthread_mutex_destroy rpl_pthread_mutex_destroy
1124# endif
1125_GL_FUNCDECL_RPL (pthread_mutex_destroy, int, (pthread_mutex_t *mutex)
1126 _GL_ARG_NONNULL ((1)));
1127_GL_CXXALIAS_RPL (pthread_mutex_destroy, int, (pthread_mutex_t *mutex));
1128# else
1129# if !@HAVE_PTHREAD_MUTEX_DESTROY@
1130_GL_FUNCDECL_SYS (pthread_mutex_destroy, int, (pthread_mutex_t *mutex)
1131 _GL_ARG_NONNULL ((1)));
1132# endif
1133_GL_CXXALIAS_SYS (pthread_mutex_destroy, int, (pthread_mutex_t *mutex));
1134# endif
1135# if __GLIBC__ >= 2
1136_GL_CXXALIASWARN (pthread_mutex_destroy);
1137# endif
1138#elif defined GNULIB_POSIXCHECK
1139# undef pthread_mutex_destroy
1140# if HAVE_RAW_DECL_PTHREAD_MUTEX_DESTROY
1141_GL_WARN_ON_USE (pthread_mutex_destroy, "pthread_mutex_destroy is not portable - "
1142 "use gnulib module pthread-mutex for portability");
1143# endif
1144#endif
1145
1146/* =========== Read-write lock functions =========== */
1147
1148#if @GNULIB_PTHREAD_RWLOCK@
1149# if @REPLACE_PTHREAD_RWLOCK_INIT@
1150# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1151# undef pthread_rwlock_init
1152# define pthread_rwlock_init rpl_pthread_rwlock_init
1153# endif
1154_GL_FUNCDECL_RPL (pthread_rwlock_init, int,
1155 (pthread_rwlock_t *restrict lock,
1156 const pthread_rwlockattr_t *restrict attr)
1157 _GL_ARG_NONNULL ((1)));
1158_GL_CXXALIAS_RPL (pthread_rwlock_init, int,
1159 (pthread_rwlock_t *restrict lock,
1160 const pthread_rwlockattr_t *restrict attr));
1161# else
1162# if !@HAVE_PTHREAD_RWLOCK_INIT@
1163_GL_FUNCDECL_SYS (pthread_rwlock_init, int,
1164 (pthread_rwlock_t *restrict lock,
1165 const pthread_rwlockattr_t *restrict attr)
1166 _GL_ARG_NONNULL ((1)));
1167# endif
1168_GL_CXXALIAS_SYS (pthread_rwlock_init, int,
1169 (pthread_rwlock_t *restrict lock,
1170 const pthread_rwlockattr_t *restrict attr));
1171# endif
1172# if __GLIBC__ >= 2
1173_GL_CXXALIASWARN (pthread_rwlock_init);
1174# endif
1175#elif defined GNULIB_POSIXCHECK
1176# undef pthread_rwlock_init
1177# if HAVE_RAW_DECL_PTHREAD_RWLOCK_INIT
1178_GL_WARN_ON_USE (pthread_rwlock_init, "pthread_rwlock_init is not portable - "
1179 "use gnulib module pthread-rwlock for portability");
1180# endif
1181#endif
1182
1183#if @GNULIB_PTHREAD_RWLOCK@
1184# if @REPLACE_PTHREAD_RWLOCKATTR_INIT@
1185# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1186# undef pthread_rwlockattr_init
1187# define pthread_rwlockattr_init rpl_pthread_rwlockattr_init
1188# endif
1189_GL_FUNCDECL_RPL (pthread_rwlockattr_init, int, (pthread_rwlockattr_t *attr)
1190 _GL_ARG_NONNULL ((1)));
1191_GL_CXXALIAS_RPL (pthread_rwlockattr_init, int, (pthread_rwlockattr_t *attr));
1192# else
1193# if !@HAVE_PTHREAD_RWLOCKATTR_INIT@
1194_GL_FUNCDECL_SYS (pthread_rwlockattr_init, int, (pthread_rwlockattr_t *attr)
1195 _GL_ARG_NONNULL ((1)));
1196# endif
1197_GL_CXXALIAS_SYS (pthread_rwlockattr_init, int, (pthread_rwlockattr_t *attr));
1198# endif
1199# if __GLIBC__ >= 2
1200_GL_CXXALIASWARN (pthread_rwlockattr_init);
1201# endif
1202#elif defined GNULIB_POSIXCHECK
1203# undef pthread_rwlockattr_init
1204# if HAVE_RAW_DECL_PTHREAD_RWLOCKATTR_INIT
1205_GL_WARN_ON_USE (pthread_rwlockattr_init, "pthread_rwlockattr_init is not portable - "
1206 "use gnulib module pthread-rwlock for portability");
1207# endif
1208#endif
1209
1210#if @GNULIB_PTHREAD_RWLOCK@
1211# if @REPLACE_PTHREAD_RWLOCKATTR_DESTROY@
1212# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1213# undef pthread_rwlockattr_destroy
1214# define pthread_rwlockattr_destroy rpl_pthread_rwlockattr_destroy
1215# endif
1216_GL_FUNCDECL_RPL (pthread_rwlockattr_destroy, int,
1217 (pthread_rwlockattr_t *attr) _GL_ARG_NONNULL ((1)));
1218_GL_CXXALIAS_RPL (pthread_rwlockattr_destroy, int,
1219 (pthread_rwlockattr_t *attr));
1220# else
1221# if !@HAVE_PTHREAD_RWLOCKATTR_DESTROY@
1222_GL_FUNCDECL_SYS (pthread_rwlockattr_destroy, int,
1223 (pthread_rwlockattr_t *attr) _GL_ARG_NONNULL ((1)));
1224# endif
1225_GL_CXXALIAS_SYS (pthread_rwlockattr_destroy, int,
1226 (pthread_rwlockattr_t *attr));
1227# endif
1228# if __GLIBC__ >= 2
1229_GL_CXXALIASWARN (pthread_rwlockattr_destroy);
1230# endif
1231#elif defined GNULIB_POSIXCHECK
1232# undef pthread_rwlockattr_destroy
1233# if HAVE_RAW_DECL_PTHREAD_RWLOCKATTR_DESTROY
1234_GL_WARN_ON_USE (pthread_rwlockattr_destroy, "pthread_rwlockattr_destroy is not portable - "
1235 "use gnulib module pthread-rwlock for portability");
1236# endif
1237#endif
1238
1239#if @GNULIB_PTHREAD_RWLOCK@
1240# if @REPLACE_PTHREAD_RWLOCK_RDLOCK@
1241# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1242# undef pthread_rwlock_rdlock
1243# define pthread_rwlock_rdlock rpl_pthread_rwlock_rdlock
1244# endif
1245_GL_FUNCDECL_RPL (pthread_rwlock_rdlock, int, (pthread_rwlock_t *lock)
1246 _GL_ARG_NONNULL ((1)));
1247_GL_CXXALIAS_RPL (pthread_rwlock_rdlock, int, (pthread_rwlock_t *lock));
1248# else
1249# if !@HAVE_PTHREAD_RWLOCK_RDLOCK@
1250_GL_FUNCDECL_SYS (pthread_rwlock_rdlock, int, (pthread_rwlock_t *lock)
1251 _GL_ARG_NONNULL ((1)));
1252# endif
1253_GL_CXXALIAS_SYS (pthread_rwlock_rdlock, int, (pthread_rwlock_t *lock));
1254# endif
1255# if __GLIBC__ >= 2
1256_GL_CXXALIASWARN (pthread_rwlock_rdlock);
1257# endif
1258#elif defined GNULIB_POSIXCHECK
1259# undef pthread_rwlock_rdlock
1260# if HAVE_RAW_DECL_PTHREAD_RWLOCK_RDLOCK
1261_GL_WARN_ON_USE (pthread_rwlock_rdlock, "pthread_rwlock_rdlock is not portable - "
1262 "use gnulib module pthread-rwlock for portability");
1263# endif
1264#endif
1265
1266#if @GNULIB_PTHREAD_RWLOCK@
1267# if @REPLACE_PTHREAD_RWLOCK_WRLOCK@
1268# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1269# undef pthread_rwlock_wrlock
1270# define pthread_rwlock_wrlock rpl_pthread_rwlock_wrlock
1271# endif
1272_GL_FUNCDECL_RPL (pthread_rwlock_wrlock, int, (pthread_rwlock_t *lock)
1273 _GL_ARG_NONNULL ((1)));
1274_GL_CXXALIAS_RPL (pthread_rwlock_wrlock, int, (pthread_rwlock_t *lock));
1275# else
1276# if !@HAVE_PTHREAD_RWLOCK_WRLOCK@
1277_GL_FUNCDECL_SYS (pthread_rwlock_wrlock, int, (pthread_rwlock_t *lock)
1278 _GL_ARG_NONNULL ((1)));
1279# endif
1280_GL_CXXALIAS_SYS (pthread_rwlock_wrlock, int, (pthread_rwlock_t *lock));
1281# endif
1282# if __GLIBC__ >= 2
1283_GL_CXXALIASWARN (pthread_rwlock_wrlock);
1284# endif
1285#elif defined GNULIB_POSIXCHECK
1286# undef pthread_rwlock_wrlock
1287# if HAVE_RAW_DECL_PTHREAD_RWLOCK_WRLOCK
1288_GL_WARN_ON_USE (pthread_rwlock_wrlock, "pthread_rwlock_wrlock is not portable - "
1289 "use gnulib module pthread-rwlock for portability");
1290# endif
1291#endif
1292
1293#if @GNULIB_PTHREAD_RWLOCK@
1294# if @REPLACE_PTHREAD_RWLOCK_TRYRDLOCK@
1295# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1296# undef pthread_rwlock_tryrdlock
1297# define pthread_rwlock_tryrdlock rpl_pthread_rwlock_tryrdlock
1298# endif
1299_GL_FUNCDECL_RPL (pthread_rwlock_tryrdlock, int, (pthread_rwlock_t *lock)
1300 _GL_ARG_NONNULL ((1)));
1301_GL_CXXALIAS_RPL (pthread_rwlock_tryrdlock, int, (pthread_rwlock_t *lock));
1302# else
1303# if !@HAVE_PTHREAD_RWLOCK_TRYRDLOCK@
1304_GL_FUNCDECL_SYS (pthread_rwlock_tryrdlock, int, (pthread_rwlock_t *lock)
1305 _GL_ARG_NONNULL ((1)));
1306# endif
1307_GL_CXXALIAS_SYS (pthread_rwlock_tryrdlock, int, (pthread_rwlock_t *lock));
1308# endif
1309# if __GLIBC__ >= 2
1310_GL_CXXALIASWARN (pthread_rwlock_tryrdlock);
1311# endif
1312#elif defined GNULIB_POSIXCHECK
1313# undef pthread_rwlock_tryrdlock
1314# if HAVE_RAW_DECL_PTHREAD_RWLOCK_TRYRDLOCK
1315_GL_WARN_ON_USE (pthread_rwlock_tryrdlock, "pthread_rwlock_tryrdlock is not portable - "
1316 "use gnulib module pthread-rwlock for portability");
1317# endif
1318#endif
1319
1320#if @GNULIB_PTHREAD_RWLOCK@
1321# if @REPLACE_PTHREAD_RWLOCK_TRYWRLOCK@
1322# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1323# undef pthread_rwlock_trywrlock
1324# define pthread_rwlock_trywrlock rpl_pthread_rwlock_trywrlock
1325# endif
1326_GL_FUNCDECL_RPL (pthread_rwlock_trywrlock, int, (pthread_rwlock_t *lock)
1327 _GL_ARG_NONNULL ((1)));
1328_GL_CXXALIAS_RPL (pthread_rwlock_trywrlock, int, (pthread_rwlock_t *lock));
1329# else
1330# if !@HAVE_PTHREAD_RWLOCK_TRYWRLOCK@
1331_GL_FUNCDECL_SYS (pthread_rwlock_trywrlock, int, (pthread_rwlock_t *lock)
1332 _GL_ARG_NONNULL ((1)));
1333# endif
1334_GL_CXXALIAS_SYS (pthread_rwlock_trywrlock, int, (pthread_rwlock_t *lock));
1335# endif
1336# if __GLIBC__ >= 2
1337_GL_CXXALIASWARN (pthread_rwlock_trywrlock);
1338# endif
1339#elif defined GNULIB_POSIXCHECK
1340# undef pthread_rwlock_trywrlock
1341# if HAVE_RAW_DECL_PTHREAD_RWLOCK_TRYWRLOCK
1342_GL_WARN_ON_USE (pthread_rwlock_trywrlock, "pthread_rwlock_trywrlock is not portable - "
1343 "use gnulib module pthread-rwlock for portability");
1344# endif
1345#endif
1346
1347#if @GNULIB_PTHREAD_RWLOCK@
1348# if @REPLACE_PTHREAD_RWLOCK_TIMEDRDLOCK@
1349# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1350# undef pthread_rwlock_timedrdlock
1351# define pthread_rwlock_timedrdlock rpl_pthread_rwlock_timedrdlock
1352# endif
1353_GL_FUNCDECL_RPL (pthread_rwlock_timedrdlock, int,
1354 (pthread_rwlock_t *restrict lock,
1355 const struct timespec *restrict abstime)
1356 _GL_ARG_NONNULL ((1, 2)));
1357_GL_CXXALIAS_RPL (pthread_rwlock_timedrdlock, int,
1358 (pthread_rwlock_t *restrict lock,
1359 const struct timespec *restrict abstime));
1360# else
1361# if !@HAVE_PTHREAD_RWLOCK_TIMEDRDLOCK@
1362_GL_FUNCDECL_SYS (pthread_rwlock_timedrdlock, int,
1363 (pthread_rwlock_t *restrict lock,
1364 const struct timespec *restrict abstime)
1365 _GL_ARG_NONNULL ((1, 2)));
1366# endif
1367_GL_CXXALIAS_SYS (pthread_rwlock_timedrdlock, int,
1368 (pthread_rwlock_t *restrict lock,
1369 const struct timespec *restrict abstime));
1370# endif
1371# if __GLIBC__ >= 2
1372_GL_CXXALIASWARN (pthread_rwlock_timedrdlock);
1373# endif
1374#elif defined GNULIB_POSIXCHECK
1375# undef pthread_rwlock_timedrdlock
1376# if HAVE_RAW_DECL_PTHREAD_RWLOCK_TIMEDRDLOCK
1377_GL_WARN_ON_USE (pthread_rwlock_timedrdlock, "pthread_rwlock_timedrdlock is not portable - "
1378 "use gnulib module pthread-rwlock for portability");
1379# endif
1380#endif
1381
1382#if @GNULIB_PTHREAD_RWLOCK@
1383# if @REPLACE_PTHREAD_RWLOCK_TIMEDWRLOCK@
1384# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1385# undef pthread_rwlock_timedwrlock
1386# define pthread_rwlock_timedwrlock rpl_pthread_rwlock_timedwrlock
1387# endif
1388_GL_FUNCDECL_RPL (pthread_rwlock_timedwrlock, int,
1389 (pthread_rwlock_t *restrict lock,
1390 const struct timespec *restrict abstime)
1391 _GL_ARG_NONNULL ((1, 2)));
1392_GL_CXXALIAS_RPL (pthread_rwlock_timedwrlock, int,
1393 (pthread_rwlock_t *restrict lock,
1394 const struct timespec *restrict abstime));
1395# else
1396# if !@HAVE_PTHREAD_RWLOCK_TIMEDWRLOCK@
1397_GL_FUNCDECL_SYS (pthread_rwlock_timedwrlock, int,
1398 (pthread_rwlock_t *restrict lock,
1399 const struct timespec *restrict abstime)
1400 _GL_ARG_NONNULL ((1, 2)));
1401# endif
1402_GL_CXXALIAS_SYS (pthread_rwlock_timedwrlock, int,
1403 (pthread_rwlock_t *restrict lock,
1404 const struct timespec *restrict abstime));
1405# endif
1406# if __GLIBC__ >= 2
1407_GL_CXXALIASWARN (pthread_rwlock_timedwrlock);
1408# endif
1409#elif defined GNULIB_POSIXCHECK
1410# undef pthread_rwlock_timedwrlock
1411# if HAVE_RAW_DECL_PTHREAD_RWLOCK_TIMEDWRLOCK
1412_GL_WARN_ON_USE (pthread_rwlock_timedwrlock, "pthread_rwlock_timedwrlock is not portable - "
1413 "use gnulib module pthread-rwlock for portability");
1414# endif
1415#endif
1416
1417#if @GNULIB_PTHREAD_RWLOCK@
1418# if @REPLACE_PTHREAD_RWLOCK_UNLOCK@
1419# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1420# undef pthread_rwlock_unlock
1421# define pthread_rwlock_unlock rpl_pthread_rwlock_unlock
1422# endif
1423_GL_FUNCDECL_RPL (pthread_rwlock_unlock, int, (pthread_rwlock_t *lock)
1424 _GL_ARG_NONNULL ((1)));
1425_GL_CXXALIAS_RPL (pthread_rwlock_unlock, int, (pthread_rwlock_t *lock));
1426# else
1427# if !@HAVE_PTHREAD_RWLOCK_UNLOCK@
1428_GL_FUNCDECL_SYS (pthread_rwlock_unlock, int, (pthread_rwlock_t *lock)
1429 _GL_ARG_NONNULL ((1)));
1430# endif
1431_GL_CXXALIAS_SYS (pthread_rwlock_unlock, int, (pthread_rwlock_t *lock));
1432# endif
1433# if __GLIBC__ >= 2
1434_GL_CXXALIASWARN (pthread_rwlock_unlock);
1435# endif
1436#elif defined GNULIB_POSIXCHECK
1437# undef pthread_rwlock_unlock
1438# if HAVE_RAW_DECL_PTHREAD_RWLOCK_UNLOCK
1439_GL_WARN_ON_USE (pthread_rwlock_unlock, "pthread_rwlock_unlock is not portable - "
1440 "use gnulib module pthread-rwlock for portability");
1441# endif
1442#endif
1443
1444#if @GNULIB_PTHREAD_RWLOCK@
1445# if @REPLACE_PTHREAD_RWLOCK_DESTROY@
1446# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1447# undef pthread_rwlock_destroy
1448# define pthread_rwlock_destroy rpl_pthread_rwlock_destroy
1449# endif
1450_GL_FUNCDECL_RPL (pthread_rwlock_destroy, int, (pthread_rwlock_t *lock)
1451 _GL_ARG_NONNULL ((1)));
1452_GL_CXXALIAS_RPL (pthread_rwlock_destroy, int, (pthread_rwlock_t *lock));
1453# else
1454# if !@HAVE_PTHREAD_RWLOCK_DESTROY@
1455_GL_FUNCDECL_SYS (pthread_rwlock_destroy, int, (pthread_rwlock_t *lock)
1456 _GL_ARG_NONNULL ((1)));
1457# endif
1458_GL_CXXALIAS_SYS (pthread_rwlock_destroy, int, (pthread_rwlock_t *lock));
1459# endif
1460# if __GLIBC__ >= 2
1461_GL_CXXALIASWARN (pthread_rwlock_destroy);
1462# endif
1463#elif defined GNULIB_POSIXCHECK
1464# undef pthread_rwlock_destroy
1465# if HAVE_RAW_DECL_PTHREAD_RWLOCK_DESTROY
1466_GL_WARN_ON_USE (pthread_rwlock_destroy, "pthread_rwlock_destroy is not portable - "
1467 "use gnulib module pthread-rwlock for portability");
1468# endif
1469#endif
1470
1471/* =========== Condition variable functions =========== */
1472
1473#if @GNULIB_PTHREAD_COND@
1474# if @REPLACE_PTHREAD_COND_INIT@
1475# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1476# undef pthread_cond_init
1477# define pthread_cond_init rpl_pthread_cond_init
1478# endif
1479_GL_FUNCDECL_RPL (pthread_cond_init, int,
1480 (pthread_cond_t *restrict cond,
1481 const pthread_condattr_t *restrict attr)
1482 _GL_ARG_NONNULL ((1)));
1483_GL_CXXALIAS_RPL (pthread_cond_init, int,
1484 (pthread_cond_t *restrict cond,
1485 const pthread_condattr_t *restrict attr));
1486# else
1487# if !@HAVE_PTHREAD_COND_INIT@
1488_GL_FUNCDECL_SYS (pthread_cond_init, int,
1489 (pthread_cond_t *restrict cond,
1490 const pthread_condattr_t *restrict attr)
1491 _GL_ARG_NONNULL ((1)));
1492# endif
1493_GL_CXXALIAS_SYS (pthread_cond_init, int,
1494 (pthread_cond_t *restrict cond,
1495 const pthread_condattr_t *restrict attr));
1496# endif
1497# if __GLIBC__ >= 2
1498_GL_CXXALIASWARN (pthread_cond_init);
1499# endif
1500#elif defined GNULIB_POSIXCHECK
1501# undef pthread_cond_init
1502# if HAVE_RAW_DECL_PTHREAD_COND_INIT
1503_GL_WARN_ON_USE (pthread_cond_init, "pthread_cond_init is not portable - "
1504 "use gnulib module pthread-cond for portability");
1505# endif
1506#endif
1507
1508#if @GNULIB_PTHREAD_COND@
1509# if @REPLACE_PTHREAD_CONDATTR_INIT@
1510# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1511# undef pthread_condattr_init
1512# define pthread_condattr_init rpl_pthread_condattr_init
1513# endif
1514_GL_FUNCDECL_RPL (pthread_condattr_init, int, (pthread_condattr_t *attr)
1515 _GL_ARG_NONNULL ((1)));
1516_GL_CXXALIAS_RPL (pthread_condattr_init, int, (pthread_condattr_t *attr));
1517# else
1518# if !@HAVE_PTHREAD_CONDATTR_INIT@
1519_GL_FUNCDECL_SYS (pthread_condattr_init, int, (pthread_condattr_t *attr)
1520 _GL_ARG_NONNULL ((1)));
1521# endif
1522_GL_CXXALIAS_SYS (pthread_condattr_init, int, (pthread_condattr_t *attr));
1523# endif
1524# if __GLIBC__ >= 2
1525_GL_CXXALIASWARN (pthread_condattr_init);
1526# endif
1527#elif defined GNULIB_POSIXCHECK
1528# undef pthread_condattr_init
1529# if HAVE_RAW_DECL_PTHREAD_CONDATTR_INIT
1530_GL_WARN_ON_USE (pthread_condattr_init, "pthread_condattr_init is not portable - "
1531 "use gnulib module pthread-cond for portability");
1532# endif
1533#endif
1534
1535#if @GNULIB_PTHREAD_COND@
1536# if @REPLACE_PTHREAD_CONDATTR_DESTROY@
1537# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1538# undef pthread_condattr_destroy
1539# define pthread_condattr_destroy rpl_pthread_condattr_destroy
1540# endif
1541_GL_FUNCDECL_RPL (pthread_condattr_destroy, int, (pthread_condattr_t *attr)
1542 _GL_ARG_NONNULL ((1)));
1543_GL_CXXALIAS_RPL (pthread_condattr_destroy, int, (pthread_condattr_t *attr));
1544# else
1545# if !@HAVE_PTHREAD_CONDATTR_DESTROY@
1546_GL_FUNCDECL_SYS (pthread_condattr_destroy, int, (pthread_condattr_t *attr)
1547 _GL_ARG_NONNULL ((1)));
1548# endif
1549_GL_CXXALIAS_SYS (pthread_condattr_destroy, int, (pthread_condattr_t *attr));
1550# endif
1551# if __GLIBC__ >= 2
1552_GL_CXXALIASWARN (pthread_condattr_destroy);
1553# endif
1554#elif defined GNULIB_POSIXCHECK
1555# undef pthread_condattr_destroy
1556# if HAVE_RAW_DECL_PTHREAD_CONDATTR_DESTROY
1557_GL_WARN_ON_USE (pthread_condattr_destroy, "pthread_condattr_destroy is not portable - "
1558 "use gnulib module pthread-cond for portability");
1559# endif
1560#endif
1561
1562#if @GNULIB_PTHREAD_COND@
1563# if @REPLACE_PTHREAD_COND_WAIT@
1564# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1565# undef pthread_cond_wait
1566# define pthread_cond_wait rpl_pthread_cond_wait
1567# endif
1568_GL_FUNCDECL_RPL (pthread_cond_wait, int,
1569 (pthread_cond_t *restrict cond,
1570 pthread_mutex_t *restrict mutex)
1571 _GL_ARG_NONNULL ((1, 2)));
1572_GL_CXXALIAS_RPL (pthread_cond_wait, int,
1573 (pthread_cond_t *restrict cond,
1574 pthread_mutex_t *restrict mutex));
1575# else
1576# if !@HAVE_PTHREAD_COND_WAIT@
1577_GL_FUNCDECL_SYS (pthread_cond_wait, int,
1578 (pthread_cond_t *restrict cond,
1579 pthread_mutex_t *restrict mutex)
1580 _GL_ARG_NONNULL ((1, 2)));
1581# endif
1582_GL_CXXALIAS_SYS (pthread_cond_wait, int,
1583 (pthread_cond_t *restrict cond,
1584 pthread_mutex_t *restrict mutex));
1585# endif
1586# if __GLIBC__ >= 2
1587_GL_CXXALIASWARN (pthread_cond_wait);
1588# endif
1589#elif defined GNULIB_POSIXCHECK
1590# undef pthread_cond_wait
1591# if HAVE_RAW_DECL_PTHREAD_COND_WAIT
1592_GL_WARN_ON_USE (pthread_cond_wait, "pthread_cond_wait is not portable - "
1593 "use gnulib module pthread-cond for portability");
1594# endif
1595#endif
1596
1597#if @GNULIB_PTHREAD_COND@
1598# if @REPLACE_PTHREAD_COND_TIMEDWAIT@
1599# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1600# undef pthread_cond_timedwait
1601# define pthread_cond_timedwait rpl_pthread_cond_timedwait
1602# endif
1603_GL_FUNCDECL_RPL (pthread_cond_timedwait, int,
1604 (pthread_cond_t *restrict cond,
1605 pthread_mutex_t *restrict mutex,
1606 const struct timespec *restrict abstime)
1607 _GL_ARG_NONNULL ((1, 2, 3)));
1608_GL_CXXALIAS_RPL (pthread_cond_timedwait, int,
1609 (pthread_cond_t *restrict cond,
1610 pthread_mutex_t *restrict mutex,
1611 const struct timespec *restrict abstime));
1612# else
1613# if !@HAVE_PTHREAD_COND_TIMEDWAIT@
1614_GL_FUNCDECL_SYS (pthread_cond_timedwait, int,
1615 (pthread_cond_t *restrict cond,
1616 pthread_mutex_t *restrict mutex,
1617 const struct timespec *restrict abstime)
1618 _GL_ARG_NONNULL ((1, 2, 3)));
1619# endif
1620_GL_CXXALIAS_SYS (pthread_cond_timedwait, int,
1621 (pthread_cond_t *restrict cond,
1622 pthread_mutex_t *restrict mutex,
1623 const struct timespec *restrict abstime));
1624# endif
1625# if __GLIBC__ >= 2
1626_GL_CXXALIASWARN (pthread_cond_timedwait);
1627# endif
1628#elif defined GNULIB_POSIXCHECK
1629# undef pthread_cond_timedwait
1630# if HAVE_RAW_DECL_PTHREAD_COND_TIMEDWAIT
1631_GL_WARN_ON_USE (pthread_cond_timedwait, "pthread_cond_timedwait is not portable - "
1632 "use gnulib module pthread-cond for portability");
1633# endif
1634#endif
1635
1636#if @GNULIB_PTHREAD_COND@
1637# if @REPLACE_PTHREAD_COND_SIGNAL@
1638# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1639# undef pthread_cond_signal
1640# define pthread_cond_signal rpl_pthread_cond_signal
1641# endif
1642_GL_FUNCDECL_RPL (pthread_cond_signal, int, (pthread_cond_t *cond)
1643 _GL_ARG_NONNULL ((1)));
1644_GL_CXXALIAS_RPL (pthread_cond_signal, int, (pthread_cond_t *cond));
1645# else
1646# if !@HAVE_PTHREAD_COND_SIGNAL@
1647_GL_FUNCDECL_SYS (pthread_cond_signal, int, (pthread_cond_t *cond)
1648 _GL_ARG_NONNULL ((1)));
1649# endif
1650_GL_CXXALIAS_SYS (pthread_cond_signal, int, (pthread_cond_t *cond));
1651# endif
1652# if __GLIBC__ >= 2
1653_GL_CXXALIASWARN (pthread_cond_signal);
1654# endif
1655#elif defined GNULIB_POSIXCHECK
1656# undef pthread_cond_signal
1657# if HAVE_RAW_DECL_PTHREAD_COND_SIGNAL
1658_GL_WARN_ON_USE (pthread_cond_signal, "pthread_cond_signal is not portable - "
1659 "use gnulib module pthread-cond for portability");
1660# endif
1661#endif
1662
1663#if @GNULIB_PTHREAD_COND@
1664# if @REPLACE_PTHREAD_COND_BROADCAST@
1665# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1666# undef pthread_cond_broadcast
1667# define pthread_cond_broadcast rpl_pthread_cond_broadcast
1668# endif
1669_GL_FUNCDECL_RPL (pthread_cond_broadcast, int, (pthread_cond_t *cond)
1670 _GL_ARG_NONNULL ((1)));
1671_GL_CXXALIAS_RPL (pthread_cond_broadcast, int, (pthread_cond_t *cond));
1672# else
1673# if !@HAVE_PTHREAD_COND_BROADCAST@
1674_GL_FUNCDECL_SYS (pthread_cond_broadcast, int, (pthread_cond_t *cond)
1675 _GL_ARG_NONNULL ((1)));
1676# endif
1677_GL_CXXALIAS_SYS (pthread_cond_broadcast, int, (pthread_cond_t *cond));
1678# endif
1679# if __GLIBC__ >= 2
1680_GL_CXXALIASWARN (pthread_cond_broadcast);
1681# endif
1682#elif defined GNULIB_POSIXCHECK
1683# undef pthread_cond_broadcast
1684# if HAVE_RAW_DECL_PTHREAD_COND_BROADCAST
1685_GL_WARN_ON_USE (pthread_cond_broadcast, "pthread_cond_broadcast is not portable - "
1686 "use gnulib module pthread-cond for portability");
1687# endif
1688#endif
1689
1690#if @GNULIB_PTHREAD_COND@
1691# if @REPLACE_PTHREAD_COND_DESTROY@
1692# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1693# undef pthread_cond_destroy
1694# define pthread_cond_destroy rpl_pthread_cond_destroy
1695# endif
1696_GL_FUNCDECL_RPL (pthread_cond_destroy, int, (pthread_cond_t *cond)
1697 _GL_ARG_NONNULL ((1)));
1698_GL_CXXALIAS_RPL (pthread_cond_destroy, int, (pthread_cond_t *cond));
1699# else
1700# if !@HAVE_PTHREAD_COND_DESTROY@
1701_GL_FUNCDECL_SYS (pthread_cond_destroy, int, (pthread_cond_t *cond)
1702 _GL_ARG_NONNULL ((1)));
1703# endif
1704_GL_CXXALIAS_SYS (pthread_cond_destroy, int, (pthread_cond_t *cond));
1705# endif
1706# if __GLIBC__ >= 2
1707_GL_CXXALIASWARN (pthread_cond_destroy);
1708# endif
1709#elif defined GNULIB_POSIXCHECK
1710# undef pthread_cond_destroy
1711# if HAVE_RAW_DECL_PTHREAD_COND_DESTROY
1712_GL_WARN_ON_USE (pthread_cond_destroy, "pthread_cond_destroy is not portable - "
1713 "use gnulib module pthread-cond for portability");
1714# endif
1715#endif
1716
1717/* =========== Thread-specific storage functions =========== */
1718
1719#if @GNULIB_PTHREAD_TSS@
1720# if @REPLACE_PTHREAD_KEY_CREATE@
1721# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1722# undef pthread_key_create
1723# define pthread_key_create rpl_pthread_key_create
1724# endif
1725_GL_FUNCDECL_RPL (pthread_key_create, int,
1726 (pthread_key_t *keyp, void (*destructor) (void *))
1727 _GL_ARG_NONNULL ((1)));
1728_GL_CXXALIAS_RPL (pthread_key_create, int,
1729 (pthread_key_t *keyp, void (*destructor) (void *)));
1730# else
1731# if !@HAVE_PTHREAD_KEY_CREATE@
1732_GL_FUNCDECL_SYS (pthread_key_create, int,
1733 (pthread_key_t *keyp, void (*destructor) (void *))
1734 _GL_ARG_NONNULL ((1)));
1735# endif
1736_GL_CXXALIAS_SYS_CAST (pthread_key_create, int,
1737 (pthread_key_t *keyp, void (*destructor) (void *)));
1738# endif
1739# if __GLIBC__ >= 2
1740_GL_CXXALIASWARN (pthread_key_create);
1741# endif
1742#elif defined GNULIB_POSIXCHECK
1743# undef pthread_key_create
1744# if HAVE_RAW_DECL_PTHREAD_KEY_CREATE
1745_GL_WARN_ON_USE (pthread_key_create, "pthread_key_create is not portable - "
1746 "use gnulib module pthread-tss for portability");
1747# endif
1748#endif
1749
1750#if @GNULIB_PTHREAD_TSS@
1751# if @REPLACE_PTHREAD_SETSPECIFIC@
1752# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1753# undef pthread_setspecific
1754# define pthread_setspecific rpl_pthread_setspecific
1755# endif
1756_GL_FUNCDECL_RPL (pthread_setspecific, int,
1757 (pthread_key_t key, const void *value));
1758_GL_CXXALIAS_RPL (pthread_setspecific, int,
1759 (pthread_key_t key, const void *value));
1760# else
1761# if !@HAVE_PTHREAD_SETSPECIFIC@
1762_GL_FUNCDECL_SYS (pthread_setspecific, int,
1763 (pthread_key_t key, const void *value));
1764# endif
1765_GL_CXXALIAS_SYS (pthread_setspecific, int,
1766 (pthread_key_t key, const void *value));
1767# endif
1768# if __GLIBC__ >= 2
1769_GL_CXXALIASWARN (pthread_setspecific);
1770# endif
1771#elif defined GNULIB_POSIXCHECK
1772# undef pthread_setspecific
1773# if HAVE_RAW_DECL_PTHREAD_SETSPECIFIC
1774_GL_WARN_ON_USE (pthread_setspecific, "pthread_setspecific is not portable - "
1775 "use gnulib module pthread-tss for portability");
1776# endif
1777#endif
1778
1779#if @GNULIB_PTHREAD_TSS@
1780# if @REPLACE_PTHREAD_GETSPECIFIC@
1781# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1782# undef pthread_getspecific
1783# define pthread_getspecific rpl_pthread_getspecific
1784# endif
1785_GL_FUNCDECL_RPL (pthread_getspecific, void *, (pthread_key_t key));
1786_GL_CXXALIAS_RPL (pthread_getspecific, void *, (pthread_key_t key));
1787# else
1788# if !@HAVE_PTHREAD_GETSPECIFIC@
1789_GL_FUNCDECL_SYS (pthread_getspecific, void *, (pthread_key_t key));
1790# endif
1791_GL_CXXALIAS_SYS (pthread_getspecific, void *, (pthread_key_t key));
1792# endif
1793# if __GLIBC__ >= 2
1794_GL_CXXALIASWARN (pthread_getspecific);
1795# endif
1796#elif defined GNULIB_POSIXCHECK
1797# undef pthread_getspecific
1798# if HAVE_RAW_DECL_PTHREAD_GETSPECIFIC
1799_GL_WARN_ON_USE (pthread_getspecific, "pthread_getspecific is not portable - "
1800 "use gnulib module pthread-tss for portability");
1801# endif
1802#endif
1803
1804#if @GNULIB_PTHREAD_TSS@
1805# if @REPLACE_PTHREAD_KEY_DELETE@
1806# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1807# undef pthread_key_delete
1808# define pthread_key_delete rpl_pthread_key_delete
1809# endif
1810_GL_FUNCDECL_RPL (pthread_key_delete, int, (pthread_key_t key));
1811_GL_CXXALIAS_RPL (pthread_key_delete, int, (pthread_key_t key));
1812# else
1813# if !@HAVE_PTHREAD_KEY_DELETE@
1814_GL_FUNCDECL_SYS (pthread_key_delete, int, (pthread_key_t key));
1815# endif
1816_GL_CXXALIAS_SYS (pthread_key_delete, int, (pthread_key_t key));
1817# endif
1818# if __GLIBC__ >= 2
1819_GL_CXXALIASWARN (pthread_key_delete);
1820# endif
1821#elif defined GNULIB_POSIXCHECK
1822# undef pthread_key_delete
1823# if HAVE_RAW_DECL_PTHREAD_KEY_DELETE
1824_GL_WARN_ON_USE (pthread_key_delete, "pthread_key_delete is not portable - "
1825 "use gnulib module pthread-tss for portability");
1826# endif
1827#endif
1828
1829/* =========== Spinlock functions =========== */
1830
1831#if @GNULIB_PTHREAD_SPIN@
1832# if @REPLACE_PTHREAD_SPIN_INIT@
1833# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1834# undef pthread_spin_init
1835# define pthread_spin_init rpl_pthread_spin_init
1836# endif
1837_GL_FUNCDECL_RPL (pthread_spin_init, int,
1838 (pthread_spinlock_t *lock, int shared_across_processes)
1839 _GL_ARG_NONNULL ((1)));
1840_GL_CXXALIAS_RPL (pthread_spin_init, int,
1841 (pthread_spinlock_t *lock, int shared_across_processes));
1842# else
1843# if !@HAVE_PTHREAD_SPIN_INIT@
1844_GL_FUNCDECL_SYS (pthread_spin_init, int,
1845 (pthread_spinlock_t *lock, int shared_across_processes)
1846 _GL_ARG_NONNULL ((1)));
1847# endif
1848_GL_CXXALIAS_SYS (pthread_spin_init, int,
1849 (pthread_spinlock_t *lock, int shared_across_processes));
1850# endif
1851# if __GLIBC__ >= 2
1852_GL_CXXALIASWARN (pthread_spin_init);
1853# endif
1854#elif defined GNULIB_POSIXCHECK
1855# undef pthread_spin_init
1856# if HAVE_RAW_DECL_PTHREAD_SPIN_INIT
1857_GL_WARN_ON_USE (pthread_spin_init, "pthread_spin_init is not portable - "
1858 "use gnulib module pthread-spin for portability");
1859# endif
1860#endif
1861
1862#if @GNULIB_PTHREAD_SPIN@
1863# if @REPLACE_PTHREAD_SPIN_LOCK@
1864# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1865# undef pthread_spin_lock
1866# define pthread_spin_lock rpl_pthread_spin_lock
1867# endif
1868_GL_FUNCDECL_RPL (pthread_spin_lock, int, (pthread_spinlock_t *lock)
1869 _GL_ARG_NONNULL ((1)));
1870_GL_CXXALIAS_RPL (pthread_spin_lock, int, (pthread_spinlock_t *lock));
1871# else
1872# if !@HAVE_PTHREAD_SPIN_LOCK@
1873_GL_FUNCDECL_SYS (pthread_spin_lock, int, (pthread_spinlock_t *lock)
1874 _GL_ARG_NONNULL ((1)));
1875# endif
1876_GL_CXXALIAS_SYS (pthread_spin_lock, int, (pthread_spinlock_t *lock));
1877# endif
1878# if __GLIBC__ >= 2
1879_GL_CXXALIASWARN (pthread_spin_lock);
1880# endif
1881#elif defined GNULIB_POSIXCHECK
1882# undef pthread_spin_lock
1883# if HAVE_RAW_DECL_PTHREAD_SPIN_LOCK
1884_GL_WARN_ON_USE (pthread_spin_lock, "pthread_spin_lock is not portable - "
1885 "use gnulib module pthread-spin for portability");
1886# endif
1887#endif
1888
1889#if @GNULIB_PTHREAD_SPIN@
1890# if @REPLACE_PTHREAD_SPIN_TRYLOCK@
1891# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1892# undef pthread_spin_trylock
1893# define pthread_spin_trylock rpl_pthread_spin_trylock
1894# endif
1895_GL_FUNCDECL_RPL (pthread_spin_trylock, int, (pthread_spinlock_t *lock)
1896 _GL_ARG_NONNULL ((1)));
1897_GL_CXXALIAS_RPL (pthread_spin_trylock, int, (pthread_spinlock_t *lock));
1898# else
1899# if !@HAVE_PTHREAD_SPIN_TRYLOCK@
1900_GL_FUNCDECL_SYS (pthread_spin_trylock, int, (pthread_spinlock_t *lock)
1901 _GL_ARG_NONNULL ((1)));
1902# endif
1903_GL_CXXALIAS_SYS (pthread_spin_trylock, int, (pthread_spinlock_t *lock));
1904# endif
1905# if __GLIBC__ >= 2
1906_GL_CXXALIASWARN (pthread_spin_trylock);
1907# endif
1908#elif defined GNULIB_POSIXCHECK
1909# undef pthread_spin_trylock
1910# if HAVE_RAW_DECL_PTHREAD_SPIN_TRYLOCK
1911_GL_WARN_ON_USE (pthread_spin_trylock, "pthread_spin_trylock is not portable - "
1912 "use gnulib module pthread-spin for portability");
1913# endif
1914#endif
1915
1916#if @GNULIB_PTHREAD_SPIN@
1917# if @REPLACE_PTHREAD_SPIN_UNLOCK@
1918# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1919# undef pthread_spin_unlock
1920# define pthread_spin_unlock rpl_pthread_spin_unlock
1921# endif
1922_GL_FUNCDECL_RPL (pthread_spin_unlock, int, (pthread_spinlock_t *lock)
1923 _GL_ARG_NONNULL ((1)));
1924_GL_CXXALIAS_RPL (pthread_spin_unlock, int, (pthread_spinlock_t *lock));
1925# else
1926# if !@HAVE_PTHREAD_SPIN_UNLOCK@
1927_GL_FUNCDECL_SYS (pthread_spin_unlock, int, (pthread_spinlock_t *lock)
1928 _GL_ARG_NONNULL ((1)));
1929# endif
1930_GL_CXXALIAS_SYS (pthread_spin_unlock, int, (pthread_spinlock_t *lock));
1931# endif
1932# if __GLIBC__ >= 2
1933_GL_CXXALIASWARN (pthread_spin_unlock);
1934# endif
1935#elif defined GNULIB_POSIXCHECK
1936# undef pthread_spin_unlock
1937# if HAVE_RAW_DECL_PTHREAD_SPIN_UNLOCK
1938_GL_WARN_ON_USE (pthread_spin_unlock, "pthread_spin_unlock is not portable - "
1939 "use gnulib module pthread-spin for portability");
1940# endif
1941#endif
1942
1943#if @GNULIB_PTHREAD_SPIN@
1944# if @REPLACE_PTHREAD_SPIN_DESTROY@
1945# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1946# undef pthread_spin_destroy
1947# define pthread_spin_destroy rpl_pthread_spin_destroy
1948# endif
1949_GL_FUNCDECL_RPL (pthread_spin_destroy, int, (pthread_spinlock_t *lock)
1950 _GL_ARG_NONNULL ((1)));
1951_GL_CXXALIAS_RPL (pthread_spin_destroy, int, (pthread_spinlock_t *lock));
1952# else
1953# if !@HAVE_PTHREAD_SPIN_DESTROY@
1954_GL_FUNCDECL_SYS (pthread_spin_destroy, int, (pthread_spinlock_t *lock)
1955 _GL_ARG_NONNULL ((1)));
1956# endif
1957_GL_CXXALIAS_SYS (pthread_spin_destroy, int, (pthread_spinlock_t *lock));
1958# endif
1959# if __GLIBC__ >= 2
1960_GL_CXXALIASWARN (pthread_spin_destroy);
1961# endif
1962#elif defined GNULIB_POSIXCHECK
1963# undef pthread_spin_destroy
1964# if HAVE_RAW_DECL_PTHREAD_SPIN_DESTROY
1965_GL_WARN_ON_USE (pthread_spin_destroy, "pthread_spin_destroy is not portable - "
1966 "use gnulib module pthread-spin for portability");
1967# endif
1968#endif
1969
1970
1971#if defined __cplusplus && defined GNULIB_NAMESPACE && !@HAVE_PTHREAD_H@ && defined __MINGW32__
1972/* Provide the symbols required by mingw's <bits/gthr-default.h>. */
1973using GNULIB_NAMESPACE::pthread_create;
1974using GNULIB_NAMESPACE::pthread_self;
1975using GNULIB_NAMESPACE::pthread_equal;
1976using GNULIB_NAMESPACE::pthread_detach;
1977using GNULIB_NAMESPACE::pthread_join;
1978using GNULIB_NAMESPACE::pthread_once;
1979using GNULIB_NAMESPACE::pthread_mutex_init;
1980using GNULIB_NAMESPACE::pthread_mutexattr_init;
1981using GNULIB_NAMESPACE::pthread_mutexattr_settype;
1982using GNULIB_NAMESPACE::pthread_mutexattr_destroy;
1983using GNULIB_NAMESPACE::pthread_mutex_lock;
1984using GNULIB_NAMESPACE::pthread_mutex_trylock;
1985using GNULIB_NAMESPACE::pthread_mutex_timedlock;
1986using GNULIB_NAMESPACE::pthread_mutex_unlock;
1987using GNULIB_NAMESPACE::pthread_mutex_destroy;
1988using GNULIB_NAMESPACE::pthread_cond_wait;
1989using GNULIB_NAMESPACE::pthread_cond_timedwait;
1990using GNULIB_NAMESPACE::pthread_cond_signal;
1991using GNULIB_NAMESPACE::pthread_cond_broadcast;
1992using GNULIB_NAMESPACE::pthread_cond_destroy;
1993using GNULIB_NAMESPACE::pthread_key_create;
1994using GNULIB_NAMESPACE::pthread_setspecific;
1995using GNULIB_NAMESPACE::pthread_getspecific;
1996using GNULIB_NAMESPACE::pthread_key_delete;
1997#endif
1998
1999
2000#endif /* _@GUARD_PREFIX@_PTHREAD_H_ */
2001#endif /* _@GUARD_PREFIX@_PTHREAD_H_ */
2002#endif
Note: See TracBrowser for help on using the repository browser.