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