root/maint/gnulib/lib/pthread.in.h

/* [previous][next][first][last][top][bottom][index][help] */
   1 /* Implement the most essential subset of POSIX 1003.1-2008 pthread.h.
   2 
   3    Copyright (C) 2009-2021 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
 100 typedef glwthread_thread_t pthread_t;
 101 typedef 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
 110 typedef int pthread_t;
 111 typedef 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
 122 typedef int pthread_t;
 123 typedef 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
 142 typedef 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
 152 typedef 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
 161 typedef 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
 180 typedef 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;
 191 typedef 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
 202 typedef int pthread_mutex_t;
 203 typedef 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
 224 typedef int pthread_mutex_t;
 225 typedef 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
 253 typedef glwthread_timedrwlock_t pthread_rwlock_t;
 254 typedef 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
 265 typedef int pthread_rwlock_t;
 266 typedef 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
 278 typedef 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;
 287 typedef 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
 300 typedef int pthread_rwlock_t;
 301 typedef 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
 319 typedef glwthread_cond_t pthread_cond_t;
 320 typedef 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
 331 typedef int pthread_cond_t;
 332 typedef 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
 341 typedef int pthread_cond_t;
 342 typedef 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
 359 typedef 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
 369 typedef 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
 378 typedef 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
 395 typedef 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
 403 typedef 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
 415 typedef 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
 429 typedef int pthread_barrier_t;
 430 typedef 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 #endif /* _@GUARD_PREFIX@_PTHREAD_H_ */
1972 #endif /* _@GUARD_PREFIX@_PTHREAD_H_ */
1973 #endif

/* [previous][next][first][last][top][bottom][index][help] */