1# threadlib.m4 serial 27 2dnl Copyright (C) 2005-2020 Free Software Foundation, Inc. 3dnl This file is free software; the Free Software Foundation 4dnl gives unlimited permission to copy and/or distribute it, 5dnl with or without modifications, as long as this notice is preserved. 6 7dnl From Bruno Haible. 8 9AC_PREREQ([2.60]) 10 11dnl The general structure of the multithreading modules in gnulib is that we 12dnl have three set of modules: 13dnl 14dnl * POSIX API: 15dnl pthread, which combines 16dnl pthread-h 17dnl pthread-thread 18dnl pthread-once 19dnl pthread-mutex 20dnl pthread-rwlock 21dnl pthread-cond 22dnl pthread-tss 23dnl pthread-spin 24dnl sched_yield 25dnl 26dnl * ISO C API: 27dnl threads, which combines 28dnl threads-h 29dnl thrd 30dnl mtx 31dnl cnd 32dnl tss 33dnl 34dnl * Gnulib API, with an implementation that can be chosen at configure 35dnl time through the option --enable-threads=... 36dnl thread 37dnl lock 38dnl cond 39dnl tls 40dnl yield 41dnl 42dnl They are independent, except for the fact that 43dnl - the implementation of the ISO C API may use the POSIX (or some other 44dnl platform dependent) API, 45dnl - the implementation of the Gnulib API may use the POSIX or ISO C or 46dnl some other platform dependent API, depending on the --enable-threads 47dnl option. 48dnl 49dnl This file contains macros for all of these APIs! 50 51dnl ============================================================================ 52dnl Macros for all thread APIs 53 54AC_DEFUN([gl_ANYTHREADLIB_EARLY], 55[ 56 AC_REQUIRE([AC_CANONICAL_HOST]) 57 if test -z "$gl_anythreadlib_early_done"; then 58 case "$host_os" in 59 osf*) 60 # On OSF/1, the compiler needs the flag -D_REENTRANT so that it 61 # groks <pthread.h>. cc also understands the flag -pthread, but 62 # we don't use it because 1. gcc-2.95 doesn't understand -pthread, 63 # 2. putting a flag into CPPFLAGS that has an effect on the linker 64 # causes the AC_LINK_IFELSE test below to succeed unexpectedly, 65 # leading to wrong values of LIBTHREAD and LTLIBTHREAD. 66 CPPFLAGS="$CPPFLAGS -D_REENTRANT" 67 ;; 68 esac 69 # Some systems optimize for single-threaded programs by default, and 70 # need special flags to disable these optimizations. For example, the 71 # definition of 'errno' in <errno.h>. 72 case "$host_os" in 73 aix* | freebsd*) CPPFLAGS="$CPPFLAGS -D_THREAD_SAFE" ;; 74 solaris*) CPPFLAGS="$CPPFLAGS -D_REENTRANT" ;; 75 esac 76 gl_anythreadlib_early_done=done 77 fi 78]) 79 80dnl Checks whether the compiler and linker support weak declarations of symbols. 81 82AC_DEFUN([gl_WEAK_SYMBOLS], 83[ 84 AC_REQUIRE([AC_CANONICAL_HOST]) 85 AC_CACHE_CHECK([whether imported symbols can be declared weak], 86 [gl_cv_have_weak], 87 [gl_cv_have_weak=no 88 dnl First, test whether the compiler accepts it syntactically. 89 AC_LINK_IFELSE( 90 [AC_LANG_PROGRAM( 91 [[extern void xyzzy (); 92#pragma weak xyzzy]], 93 [[xyzzy();]])], 94 [gl_cv_have_weak=maybe]) 95 if test $gl_cv_have_weak = maybe; then 96 dnl Second, test whether it actually works. On Cygwin 1.7.2, with 97 dnl gcc 4.3, symbols declared weak always evaluate to the address 0. 98 AC_RUN_IFELSE( 99 [AC_LANG_SOURCE([[ 100#include <stdio.h> 101#pragma weak fputs 102int main () 103{ 104 return (fputs == NULL); 105}]])], 106 [gl_cv_have_weak=yes], 107 [gl_cv_have_weak=no], 108 [dnl When cross-compiling, assume that only ELF platforms support 109 dnl weak symbols. 110 AC_EGREP_CPP([Extensible Linking Format], 111 [#ifdef __ELF__ 112 Extensible Linking Format 113 #endif 114 ], 115 [gl_cv_have_weak="guessing yes"], 116 [gl_cv_have_weak="guessing no"]) 117 ]) 118 fi 119 dnl But when linking statically, weak symbols don't work. 120 case " $LDFLAGS " in 121 *" -static "*) gl_cv_have_weak=no ;; 122 esac 123 dnl Test for a bug in FreeBSD 11: A link error occurs when using a weak 124 dnl symbol and linking against a shared library that has a dependency on 125 dnl the shared library that defines the symbol. 126 case "$gl_cv_have_weak" in 127 *yes) 128 case "$host_os" in 129 freebsd* | dragonfly*) 130 : > conftest1.c 131 $CC $CPPFLAGS $CFLAGS $LDFLAGS -fPIC -shared -o libempty.so conftest1.c -lpthread >&AS_MESSAGE_LOG_FD 2>&1 132 cat <<EOF > conftest2.c 133#include <pthread.h> 134#pragma weak pthread_mutexattr_gettype 135int main () 136{ 137 return (pthread_mutexattr_gettype != NULL); 138} 139EOF 140 $CC $CPPFLAGS $CFLAGS $LDFLAGS -o conftest conftest2.c libempty.so >&AS_MESSAGE_LOG_FD 2>&1 \ 141 || gl_cv_have_weak=no 142 rm -f conftest1.c libempty.so conftest2.c conftest 143 ;; 144 esac 145 ;; 146 esac 147 ]) 148 case "$gl_cv_have_weak" in 149 *yes) 150 AC_DEFINE([HAVE_WEAK_SYMBOLS], [1], 151 [Define to 1 if the compiler and linker support weak declarations of symbols.]) 152 ;; 153 esac 154]) 155 156dnl ============================================================================ 157dnl Macros for the POSIX API 158 159dnl gl_PTHREADLIB 160dnl ------------- 161dnl Tests for the libraries needs for using the POSIX threads API. 162dnl Sets the variable LIBPTHREAD to the linker options for use in a Makefile. 163dnl Sets the variable LIBPMULTITHREAD, for programs that really need 164dnl multithread functionality. The difference between LIBPTHREAD and 165dnl LIBPMULTITHREAD is that on platforms supporting weak symbols, typically 166dnl LIBPTHREAD is empty whereas LIBPMULTITHREAD is not. 167dnl Sets the variable LIB_SCHED_YIELD to the linker options needed to use the 168dnl sched_yield() function. 169dnl Adds to CPPFLAGS the flag -D_REENTRANT or -D_THREAD_SAFE if needed for 170dnl multithread-safe programs. 171dnl Defines the C macro HAVE_PTHREAD_API if (at least parts of) the POSIX 172dnl threads API is available. 173 174dnl The guts of gl_PTHREADLIB. Needs to be expanded only once. 175 176AC_DEFUN([gl_PTHREADLIB_BODY], 177[ 178 AC_REQUIRE([gl_ANYTHREADLIB_EARLY]) 179 if test -z "$gl_pthreadlib_body_done"; then 180 gl_pthread_api=no 181 LIBPTHREAD= 182 LIBPMULTITHREAD= 183 # On OSF/1, the compiler needs the flag -pthread or -D_REENTRANT so that 184 # it groks <pthread.h>. It's added above, in gl_ANYTHREADLIB_EARLY. 185 AC_CHECK_HEADER([pthread.h], 186 [gl_have_pthread_h=yes], [gl_have_pthread_h=no]) 187 if test "$gl_have_pthread_h" = yes; then 188 # Other possible tests: 189 # -lpthreads (FSU threads, PCthreads) 190 # -lgthreads 191 # Test whether both pthread_mutex_lock and pthread_mutexattr_init exist 192 # in libc. IRIX 6.5 has the first one in both libc and libpthread, but 193 # the second one only in libpthread, and lock.c needs it. 194 # 195 # If -pthread works, prefer it to -lpthread, since Ubuntu 14.04 196 # needs -pthread for some reason. See: 197 # https://lists.gnu.org/r/bug-gnulib/2014-09/msg00023.html 198 save_LIBS=$LIBS 199 for gl_pthread in '' '-pthread'; do 200 LIBS="$LIBS $gl_pthread" 201 AC_LINK_IFELSE( 202 [AC_LANG_PROGRAM( 203 [[#include <pthread.h> 204 pthread_mutex_t m; 205 pthread_mutexattr_t ma; 206 ]], 207 [[pthread_mutex_lock (&m); 208 pthread_mutexattr_init (&ma);]])], 209 [gl_pthread_api=yes 210 LIBPTHREAD=$gl_pthread 211 LIBPMULTITHREAD=$gl_pthread]) 212 LIBS=$save_LIBS 213 test $gl_pthread_api = yes && break 214 done 215 216 # Test for libpthread by looking for pthread_kill. (Not pthread_self, 217 # since it is defined as a macro on OSF/1.) 218 if test $gl_pthread_api = yes && test -z "$LIBPTHREAD"; then 219 # The program links fine without libpthread. But it may actually 220 # need to link with libpthread in order to create multiple threads. 221 AC_CHECK_LIB([pthread], [pthread_kill], 222 [LIBPMULTITHREAD=-lpthread 223 # On Solaris and HP-UX, most pthread functions exist also in libc. 224 # Therefore pthread_in_use() needs to actually try to create a 225 # thread: pthread_create from libc will fail, whereas 226 # pthread_create will actually create a thread. 227 # On Solaris 10 or newer, this test is no longer needed, because 228 # libc contains the fully functional pthread functions. 229 case "$host_os" in 230 solaris | solaris2.[1-9] | solaris2.[1-9].* | hpux*) 231 AC_DEFINE([PTHREAD_IN_USE_DETECTION_HARD], [1], 232 [Define if the pthread_in_use() detection is hard.]) 233 esac 234 ]) 235 elif test $gl_pthread_api != yes; then 236 # Some library is needed. Try libpthread and libc_r. 237 AC_CHECK_LIB([pthread], [pthread_kill], 238 [gl_pthread_api=yes 239 LIBPTHREAD=-lpthread 240 LIBPMULTITHREAD=-lpthread]) 241 if test $gl_pthread_api != yes; then 242 # For FreeBSD 4. 243 AC_CHECK_LIB([c_r], [pthread_kill], 244 [gl_pthread_api=yes 245 LIBPTHREAD=-lc_r 246 LIBPMULTITHREAD=-lc_r]) 247 fi 248 fi 249 fi 250 AC_MSG_CHECKING([whether POSIX threads API is available]) 251 AC_MSG_RESULT([$gl_pthread_api]) 252 AC_SUBST([LIBPTHREAD]) 253 AC_SUBST([LIBPMULTITHREAD]) 254 if test $gl_pthread_api = yes; then 255 AC_DEFINE([HAVE_PTHREAD_API], [1], 256 [Define if you have the <pthread.h> header and the POSIX threads API.]) 257 fi 258 259 dnl On some systems, sched_yield is in librt, rather than in libpthread. 260 AC_LINK_IFELSE( 261 [AC_LANG_PROGRAM( 262 [[#include <sched.h>]], 263 [[sched_yield ();]])], 264 [LIB_SCHED_YIELD= 265 ], 266 [dnl Solaris 7...10 has sched_yield in librt, not in libpthread or libc. 267 AC_CHECK_LIB([rt], [sched_yield], [LIB_SCHED_YIELD=-lrt], 268 [dnl Solaris 2.5.1, 2.6 has sched_yield in libposix4, not librt. 269 AC_CHECK_LIB([posix4], [sched_yield], [LIB_SCHED_YIELD=-lposix4])]) 270 ]) 271 AC_SUBST([LIB_SCHED_YIELD]) 272 273 gl_pthreadlib_body_done=done 274 fi 275]) 276 277AC_DEFUN([gl_PTHREADLIB], 278[ 279 AC_REQUIRE([gl_ANYTHREADLIB_EARLY]) 280 gl_PTHREADLIB_BODY 281]) 282 283dnl ============================================================================ 284dnl Macros for the ISO C API 285 286dnl gl_STDTHREADLIB 287dnl --------------- 288dnl Tests for the libraries needs for using the ISO C threads API. 289dnl Sets the variable LIBSTDTHREAD to the linker options for use in a Makefile. 290dnl Adds to CPPFLAGS the flag -D_REENTRANT or -D_THREAD_SAFE if needed for 291dnl multithread-safe programs. 292dnl Defines the C macro HAVE_THREADS_H if (at least parts of) the ISO C threads 293dnl API is available. 294 295dnl The guts of gl_STDTHREADLIB. Needs to be expanded only once. 296 297AC_DEFUN([gl_STDTHREADLIB_BODY], 298[ 299 AC_REQUIRE([gl_ANYTHREADLIB_EARLY]) 300 AC_REQUIRE([AC_CANONICAL_HOST]) 301 if test -z "$gl_stdthreadlib_body_done"; then 302 AC_CHECK_HEADERS_ONCE([threads.h]) 303 304 case "$host_os" in 305 mingw*) 306 LIBSTDTHREAD= 307 ;; 308 *) 309 gl_PTHREADLIB_BODY 310 if test $ac_cv_header_threads_h = yes; then 311 dnl glibc >= 2.29 has thrd_create in libpthread. 312 dnl FreeBSD >= 10 has thrd_create in libstdthreads; this library depends 313 dnl on libpthread (for the symbol 'pthread_mutexattr_gettype'). 314 dnl AIX >= 7.1 and Solaris >= 11.4 have thrd_create in libc. 315 AC_CHECK_FUNCS([thrd_create]) 316 if test $ac_cv_func_thrd_create = yes; then 317 LIBSTDTHREAD= 318 else 319 AC_CHECK_LIB([stdthreads], [thrd_create], [ 320 LIBSTDTHREAD='-lstdthreads -lpthread' 321 ], [ 322 dnl Guess that thrd_create is in libpthread. 323 LIBSTDTHREAD="$LIBPMULTITHREAD" 324 ]) 325 fi 326 else 327 dnl Libraries needed by thrd.c, mtx.c, cnd.c, tss.c. 328 LIBSTDTHREAD="$LIBPMULTITHREAD $LIB_SCHED_YIELD" 329 fi 330 ;; 331 esac 332 AC_SUBST([LIBSTDTHREAD]) 333 334 AC_MSG_CHECKING([whether ISO C threads API is available]) 335 AC_MSG_RESULT([$ac_cv_header_threads_h]) 336 gl_stdthreadlib_body_done=done 337 fi 338]) 339 340AC_DEFUN([gl_STDTHREADLIB], 341[ 342 AC_REQUIRE([gl_ANYTHREADLIB_EARLY]) 343 gl_STDTHREADLIB_BODY 344]) 345 346dnl ============================================================================ 347dnl Macros for the Gnulib API 348 349dnl gl_THREADLIB 350dnl ------------ 351dnl Tests for a multithreading library to be used. 352dnl If the configure.ac contains a definition of the gl_THREADLIB_DEFAULT_NO 353dnl (it must be placed before the invocation of gl_THREADLIB_EARLY!), then the 354dnl default is 'no', otherwise it is system dependent. In both cases, the user 355dnl can change the choice through the options --enable-threads=choice or 356dnl --disable-threads. 357dnl Defines at most one of the macros USE_ISOC_THREADS, USE_POSIX_THREADS, 358dnl USE_ISOC_AND_POSIX_THREADS, USE_WINDOWS_THREADS. 359dnl The choice --enable-threads=isoc+posix is available only on platforms that 360dnl have both the ISO C and the POSIX threads APIs. It has the effect of using 361dnl the ISO C API for most things and the POSIX API only for creating and 362dnl controlling threads (because there is no equivalent to pthread_atfork in 363dnl the ISO C API). 364dnl Sets the variables LIBTHREAD and LTLIBTHREAD to the linker options for use 365dnl in a Makefile (LIBTHREAD for use without libtool, LTLIBTHREAD for use with 366dnl libtool). 367dnl Sets the variables LIBMULTITHREAD and LTLIBMULTITHREAD similarly, for 368dnl programs that really need multithread functionality. The difference 369dnl between LIBTHREAD and LIBMULTITHREAD is that on platforms supporting weak 370dnl symbols, typically LIBTHREAD is empty whereas LIBMULTITHREAD is not. 371dnl Adds to CPPFLAGS the flag -D_REENTRANT or -D_THREAD_SAFE if needed for 372dnl multithread-safe programs. 373dnl Since support for GNU pth was removed, $LTLIBTHREAD and $LIBTHREAD have the 374dnl same value, and similarly $LTLIBMULTITHREAD and $LIBMULTITHREAD have the 375dnl same value. Only system libraries are needed. 376 377AC_DEFUN([gl_THREADLIB_EARLY], 378[ 379 AC_REQUIRE([gl_THREADLIB_EARLY_BODY]) 380]) 381 382dnl The guts of gl_THREADLIB_EARLY. Needs to be expanded only once. 383 384AC_DEFUN([gl_THREADLIB_EARLY_BODY], 385[ 386 dnl Ordering constraints: This macro modifies CPPFLAGS in a way that 387 dnl influences the result of the autoconf tests that test for *_unlocked 388 dnl declarations, on AIX 5 at least. Therefore it must come early. 389 AC_BEFORE([$0], [gl_FUNC_GLIBC_UNLOCKED_IO])dnl 390 AC_BEFORE([$0], [gl_ARGP])dnl 391 392 AC_REQUIRE([AC_CANONICAL_HOST]) 393 dnl _GNU_SOURCE is needed for pthread_rwlock_t on glibc systems. 394 AC_REQUIRE([AC_USE_SYSTEM_EXTENSIONS]) 395 dnl Check for multithreading. 396 m4_ifdef([gl_THREADLIB_DEFAULT_NO], 397 [m4_divert_text([DEFAULTS], [gl_use_threads_default=no])], 398 [m4_divert_text([DEFAULTS], [gl_use_threads_default=])]) 399 m4_divert_text([DEFAULTS], [gl_use_winpthreads_default=]) 400 AC_ARG_ENABLE([threads], 401AC_HELP_STRING([--enable-threads={isoc|posix|isoc+posix|windows}], [specify multithreading API])m4_ifdef([gl_THREADLIB_DEFAULT_NO], [], [ 402AC_HELP_STRING([--disable-threads], [build without multithread safety])]), 403 [gl_use_threads=$enableval], 404 [if test -n "$gl_use_threads_default"; then 405 gl_use_threads="$gl_use_threads_default" 406 else 407changequote(,)dnl 408 case "$host_os" in 409 dnl Disable multithreading by default on OSF/1, because it interferes 410 dnl with fork()/exec(): When msgexec is linked with -lpthread, its 411 dnl child process gets an endless segmentation fault inside execvp(). 412 osf*) gl_use_threads=no ;; 413 dnl Disable multithreading by default on Cygwin 1.5.x, because it has 414 dnl bugs that lead to endless loops or crashes. See 415 dnl <https://cygwin.com/ml/cygwin/2009-08/msg00283.html>. 416 cygwin*) 417 case `uname -r` in 418 1.[0-5].*) gl_use_threads=no ;; 419 *) gl_use_threads=yes ;; 420 esac 421 ;; 422 dnl Obey gl_AVOID_WINPTHREAD on mingw. 423 mingw*) 424 case "$gl_use_winpthreads_default" in 425 yes) gl_use_threads=posix ;; 426 no) gl_use_threads=windows ;; 427 *) gl_use_threads=yes ;; 428 esac 429 ;; 430 *) gl_use_threads=yes ;; 431 esac 432changequote([,])dnl 433 fi 434 ]) 435 if test "$gl_use_threads" = yes \ 436 || test "$gl_use_threads" = isoc \ 437 || test "$gl_use_threads" = posix \ 438 || test "$gl_use_threads" = isoc+posix; then 439 # For using <threads.h> or <pthread.h>: 440 gl_ANYTHREADLIB_EARLY 441 fi 442]) 443 444dnl The guts of gl_THREADLIB. Needs to be expanded only once. 445 446AC_DEFUN([gl_THREADLIB_BODY], 447[ 448 AC_REQUIRE([gl_THREADLIB_EARLY_BODY]) 449 gl_threads_api=none 450 LIBTHREAD= 451 LTLIBTHREAD= 452 LIBMULTITHREAD= 453 LTLIBMULTITHREAD= 454 if test "$gl_use_threads" != no; then 455 dnl Check whether the compiler and linker support weak declarations. 456 gl_WEAK_SYMBOLS 457 if case "$gl_cv_have_weak" in *yes) true;; *) false;; esac; then 458 dnl If we use weak symbols to implement pthread_in_use / pth_in_use / 459 dnl thread_in_use, we also need to test whether the ISO C 11 thrd_create 460 dnl facility is in use. 461 AC_CHECK_HEADERS_ONCE([threads.h]) 462 : 463 fi 464 if test "$gl_use_threads" = isoc || test "$gl_use_threads" = isoc+posix; then 465 AC_CHECK_HEADERS_ONCE([threads.h]) 466 gl_have_isoc_threads="$ac_cv_header_threads_h" 467 fi 468 if test "$gl_use_threads" = yes \ 469 || test "$gl_use_threads" = posix \ 470 || test "$gl_use_threads" = isoc+posix; then 471 gl_PTHREADLIB_BODY 472 LIBTHREAD=$LIBPTHREAD LTLIBTHREAD=$LIBPTHREAD 473 LIBMULTITHREAD=$LIBPMULTITHREAD LTLIBMULTITHREAD=$LIBPMULTITHREAD 474 if test $gl_pthread_api = yes; then 475 if test "$gl_use_threads" = isoc+posix && test "$gl_have_isoc_threads" = yes; then 476 gl_threads_api='isoc+posix' 477 AC_DEFINE([USE_ISOC_AND_POSIX_THREADS], [1], 478 [Define if the combination of the ISO C and POSIX multithreading APIs can be used.]) 479 LIBTHREAD= LTLIBTHREAD= 480 else 481 gl_threads_api=posix 482 AC_DEFINE([USE_POSIX_THREADS], [1], 483 [Define if the POSIX multithreading library can be used.]) 484 if test -n "$LIBMULTITHREAD" || test -n "$LTLIBMULTITHREAD"; then 485 if case "$gl_cv_have_weak" in *yes) true;; *) false;; esac; then 486 AC_DEFINE([USE_POSIX_THREADS_WEAK], [1], 487 [Define if references to the POSIX multithreading library should be made weak.]) 488 LIBTHREAD= LTLIBTHREAD= 489 fi 490 fi 491 fi 492 fi 493 fi 494 if test $gl_threads_api = none; then 495 if test "$gl_use_threads" = isoc && test "$gl_have_isoc_threads" = yes; then 496 gl_STDTHREADLIB_BODY 497 LIBTHREAD=$LIBSTDTHREAD LTLIBTHREAD=$LIBSTDTHREAD 498 LIBMULTITHREAD=$LIBSTDTHREAD LTLIBMULTITHREAD=$LIBSTDTHREAD 499 gl_threads_api=isoc 500 AC_DEFINE([USE_ISOC_THREADS], [1], 501 [Define if the ISO C multithreading library can be used.]) 502 fi 503 fi 504 if test $gl_threads_api = none; then 505 case "$gl_use_threads" in 506 yes | windows | win32) # The 'win32' is for backward compatibility. 507 if { case "$host_os" in 508 mingw*) true;; 509 *) false;; 510 esac 511 }; then 512 gl_threads_api=windows 513 AC_DEFINE([USE_WINDOWS_THREADS], [1], 514 [Define if the native Windows multithreading API can be used.]) 515 fi 516 ;; 517 esac 518 fi 519 fi 520 AC_MSG_CHECKING([for multithread API to use]) 521 AC_MSG_RESULT([$gl_threads_api]) 522 AC_SUBST([LIBTHREAD]) 523 AC_SUBST([LTLIBTHREAD]) 524 AC_SUBST([LIBMULTITHREAD]) 525 AC_SUBST([LTLIBMULTITHREAD]) 526]) 527 528AC_DEFUN([gl_THREADLIB], 529[ 530 AC_REQUIRE([gl_THREADLIB_EARLY]) 531 AC_REQUIRE([gl_THREADLIB_BODY]) 532]) 533 534 535dnl gl_DISABLE_THREADS 536dnl ------------------ 537dnl Sets the gl_THREADLIB default so that threads are not used by default. 538dnl The user can still override it at installation time, by using the 539dnl configure option '--enable-threads'. 540 541AC_DEFUN([gl_DISABLE_THREADS], [ 542 m4_divert_text([INIT_PREPARE], [gl_use_threads_default=no]) 543]) 544 545 546dnl gl_AVOID_WINPTHREAD 547dnl ------------------- 548dnl Sets the gl_THREADLIB default so that on mingw, a dependency to the 549dnl libwinpthread DLL (mingw-w64 winpthreads library) is avoided. 550dnl The user can still override it at installation time, by using the 551dnl configure option '--enable-threads'. 552 553AC_DEFUN([gl_AVOID_WINPTHREAD], [ 554 m4_divert_text([INIT_PREPARE], [gl_use_winpthreads_default=no]) 555]) 556 557 558dnl ============================================================================ 559 560 561dnl Survey of platforms: 562dnl 563dnl Platform Available Compiler Supports test-lock 564dnl flavours option weak result 565dnl --------------- --------- --------- -------- --------- 566dnl Linux 2.4/glibc posix -lpthread Y OK 567dnl 568dnl GNU Hurd/glibc posix 569dnl 570dnl Ubuntu 14.04 posix -pthread Y OK 571dnl 572dnl FreeBSD 5.3 posix -lc_r Y 573dnl posix -lkse ? Y 574dnl posix -lpthread ? Y 575dnl posix -lthr Y 576dnl 577dnl FreeBSD 5.2 posix -lc_r Y 578dnl posix -lkse Y 579dnl posix -lthr Y 580dnl 581dnl FreeBSD 4.0,4.10 posix -lc_r Y OK 582dnl 583dnl NetBSD 1.6 -- 584dnl 585dnl OpenBSD 3.4 posix -lpthread Y OK 586dnl 587dnl Mac OS X 10.[123] posix -lpthread Y OK 588dnl 589dnl Solaris 7,8,9 posix -lpthread Y Sol 7,8: 0.0; Sol 9: OK 590dnl 591dnl HP-UX 11 posix -lpthread N (cc) OK 592dnl Y (gcc) 593dnl 594dnl IRIX 6.5 posix -lpthread Y 0.5 595dnl 596dnl AIX 4.3,5.1 posix -lpthread N AIX 4: 0.5; AIX 5: OK 597dnl 598dnl OSF/1 4.0,5.1 posix -pthread (cc) N OK 599dnl -lpthread (gcc) Y 600dnl 601dnl Cygwin posix -lpthread Y OK 602dnl 603dnl Mingw windows N OK 604dnl 605dnl BeOS 5 -- 606dnl 607dnl The test-lock result shows what happens if in test-lock.c EXPLICIT_YIELD is 608dnl turned off: 609dnl OK if all three tests terminate OK, 610dnl 0.5 if the first test terminates OK but the second one loops endlessly, 611dnl 0.0 if the first test already loops endlessly. 612