threadlib.m4 (23018B)
1 # threadlib.m4 serial 29 2 dnl Copyright (C) 2005-2021 Free Software Foundation, Inc. 3 dnl This file is free software; the Free Software Foundation 4 dnl gives unlimited permission to copy and/or distribute it, 5 dnl with or without modifications, as long as this notice is preserved. 6 7 dnl From Bruno Haible. 8 9 AC_PREREQ([2.60]) 10 11 dnl The general structure of the multithreading modules in gnulib is that we 12 dnl have three set of modules: 13 dnl 14 dnl * POSIX API: 15 dnl pthread, which combines 16 dnl pthread-h 17 dnl pthread-thread 18 dnl pthread-once 19 dnl pthread-mutex 20 dnl pthread-rwlock 21 dnl pthread-cond 22 dnl pthread-tss 23 dnl pthread-spin 24 dnl sched_yield 25 dnl 26 dnl * ISO C API: 27 dnl threads, which combines 28 dnl threads-h 29 dnl thrd 30 dnl mtx 31 dnl cnd 32 dnl tss 33 dnl 34 dnl * Gnulib API, with an implementation that can be chosen at configure 35 dnl time through the option --enable-threads=... 36 dnl thread 37 dnl lock 38 dnl cond 39 dnl tls 40 dnl yield 41 dnl 42 dnl They are independent, except for the fact that 43 dnl - the implementation of the ISO C API may use the POSIX (or some other 44 dnl platform dependent) API, 45 dnl - the implementation of the Gnulib API may use the POSIX or ISO C or 46 dnl some other platform dependent API, depending on the --enable-threads 47 dnl option. 48 dnl 49 dnl This file contains macros for all of these APIs! 50 51 dnl ============================================================================ 52 dnl Macros for all thread APIs 53 54 AC_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 80 dnl Checks whether the compiler and linker support weak declarations of symbols. 81 82 AC_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 102 int 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 135 int main () 136 { 137 return (pthread_mutexattr_gettype != NULL); 138 } 139 EOF 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 156 dnl ============================================================================ 157 dnl Macros for the POSIX API 158 159 dnl gl_PTHREADLIB 160 dnl ------------- 161 dnl Tests for the libraries needs for using the POSIX threads API. 162 dnl Sets the variable LIBPTHREAD to the linker options for use in a Makefile. 163 dnl Sets the variable LIBPMULTITHREAD, for programs that really need 164 dnl multithread functionality. The difference between LIBPTHREAD and 165 dnl LIBPMULTITHREAD is that on platforms supporting weak symbols, typically 166 dnl LIBPTHREAD is empty whereas LIBPMULTITHREAD is not. 167 dnl Sets the variable LIB_SCHED_YIELD to the linker options needed to use the 168 dnl sched_yield() function. 169 dnl Adds to CPPFLAGS the flag -D_REENTRANT or -D_THREAD_SAFE if needed for 170 dnl multithread-safe programs. 171 dnl Defines the C macro HAVE_PTHREAD_API if (at least parts of) the POSIX 172 dnl threads API is available. 173 174 dnl The guts of gl_PTHREADLIB. Needs to be expanded only once. 175 176 AC_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 277 AC_DEFUN([gl_PTHREADLIB], 278 [ 279 AC_REQUIRE([gl_ANYTHREADLIB_EARLY]) 280 gl_PTHREADLIB_BODY 281 ]) 282 283 dnl ============================================================================ 284 dnl Macros for the ISO C API 285 286 dnl gl_STDTHREADLIB 287 dnl --------------- 288 dnl Tests for the libraries needs for using the ISO C threads API. 289 dnl Sets the variable LIBSTDTHREAD to the linker options for use in a Makefile. 290 dnl Adds to CPPFLAGS the flag -D_REENTRANT or -D_THREAD_SAFE if needed for 291 dnl multithread-safe programs. 292 dnl Defines the C macro HAVE_THREADS_H if (at least parts of) the ISO C threads 293 dnl API is available. 294 295 dnl The guts of gl_STDTHREADLIB. Needs to be expanded only once. 296 297 AC_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 340 AC_DEFUN([gl_STDTHREADLIB], 341 [ 342 AC_REQUIRE([gl_ANYTHREADLIB_EARLY]) 343 gl_STDTHREADLIB_BODY 344 ]) 345 346 dnl ============================================================================ 347 dnl Macros for the Gnulib API 348 349 dnl gl_THREADLIB 350 dnl ------------ 351 dnl Tests for a multithreading library to be used. 352 dnl If the configure.ac contains a definition of the gl_THREADLIB_DEFAULT_NO 353 dnl (it must be placed before the invocation of gl_THREADLIB_EARLY!), then the 354 dnl default is 'no', otherwise it is system dependent. In both cases, the user 355 dnl can change the choice through the options --enable-threads=choice or 356 dnl --disable-threads. 357 dnl Defines at most one of the macros USE_ISOC_THREADS, USE_POSIX_THREADS, 358 dnl USE_ISOC_AND_POSIX_THREADS, USE_WINDOWS_THREADS. 359 dnl The choice --enable-threads=isoc+posix is available only on platforms that 360 dnl have both the ISO C and the POSIX threads APIs. It has the effect of using 361 dnl the ISO C API for most things and the POSIX API only for creating and 362 dnl controlling threads (because there is no equivalent to pthread_atfork in 363 dnl the ISO C API). 364 dnl Sets the variables LIBTHREAD and LTLIBTHREAD to the linker options for use 365 dnl in a Makefile (LIBTHREAD for use without libtool, LTLIBTHREAD for use with 366 dnl libtool). 367 dnl Sets the variables LIBMULTITHREAD and LTLIBMULTITHREAD similarly, for 368 dnl programs that really need multithread functionality. The difference 369 dnl between LIBTHREAD and LIBMULTITHREAD is that on platforms supporting weak 370 dnl symbols, typically LIBTHREAD is empty whereas LIBMULTITHREAD is not. 371 dnl Adds to CPPFLAGS the flag -D_REENTRANT or -D_THREAD_SAFE if needed for 372 dnl multithread-safe programs. 373 dnl Since support for GNU pth was removed, $LTLIBTHREAD and $LIBTHREAD have the 374 dnl same value, and similarly $LTLIBMULTITHREAD and $LIBMULTITHREAD have the 375 dnl same value. Only system libraries are needed. 376 377 AC_DEFUN([gl_THREADLIB_EARLY], 378 [ 379 AC_REQUIRE([gl_THREADLIB_EARLY_BODY]) 380 ]) 381 382 dnl The guts of gl_THREADLIB_EARLY. Needs to be expanded only once. 383 384 AC_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], 401 AS_HELP_STRING([--enable-threads={isoc|posix|isoc+posix|windows}], [specify multithreading API])m4_ifdef([gl_THREADLIB_DEFAULT_NO], [], [ 402 AS_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 407 changequote(,)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 432 changequote([,])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 444 dnl The guts of gl_THREADLIB. Needs to be expanded only once. 445 446 AC_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 else 490 case "$host_os" in 491 freebsd* | dragonfly*) 492 if test "x$LIBTHREAD" != "x$LIBMULTITHREAD"; then 493 dnl If weak symbols can't tell whether pthread_create(), pthread_key_create() 494 dnl etc. will succeed, we need a runtime test. 495 AC_DEFINE([PTHREAD_IN_USE_DETECTION_HARD], [1], 496 [Define if the pthread_in_use() detection is hard.]) 497 fi 498 ;; 499 esac 500 fi 501 fi 502 fi 503 fi 504 fi 505 if test $gl_threads_api = none; then 506 if test "$gl_use_threads" = isoc && test "$gl_have_isoc_threads" = yes; then 507 gl_STDTHREADLIB_BODY 508 LIBTHREAD=$LIBSTDTHREAD LTLIBTHREAD=$LIBSTDTHREAD 509 LIBMULTITHREAD=$LIBSTDTHREAD LTLIBMULTITHREAD=$LIBSTDTHREAD 510 gl_threads_api=isoc 511 AC_DEFINE([USE_ISOC_THREADS], [1], 512 [Define if the ISO C multithreading library can be used.]) 513 fi 514 fi 515 if test $gl_threads_api = none; then 516 case "$gl_use_threads" in 517 yes | windows | win32) # The 'win32' is for backward compatibility. 518 if { case "$host_os" in 519 mingw*) true;; 520 *) false;; 521 esac 522 }; then 523 gl_threads_api=windows 524 AC_DEFINE([USE_WINDOWS_THREADS], [1], 525 [Define if the native Windows multithreading API can be used.]) 526 fi 527 ;; 528 esac 529 fi 530 fi 531 AC_MSG_CHECKING([for multithread API to use]) 532 AC_MSG_RESULT([$gl_threads_api]) 533 AC_SUBST([LIBTHREAD]) 534 AC_SUBST([LTLIBTHREAD]) 535 AC_SUBST([LIBMULTITHREAD]) 536 AC_SUBST([LTLIBMULTITHREAD]) 537 ]) 538 539 AC_DEFUN([gl_THREADLIB], 540 [ 541 AC_REQUIRE([gl_THREADLIB_EARLY]) 542 AC_REQUIRE([gl_THREADLIB_BODY]) 543 ]) 544 545 546 dnl gl_DISABLE_THREADS 547 dnl ------------------ 548 dnl Sets the gl_THREADLIB default so that threads are not used by default. 549 dnl The user can still override it at installation time, by using the 550 dnl configure option '--enable-threads'. 551 552 AC_DEFUN([gl_DISABLE_THREADS], [ 553 m4_divert_text([INIT_PREPARE], [gl_use_threads_default=no]) 554 ]) 555 556 557 dnl gl_AVOID_WINPTHREAD 558 dnl ------------------- 559 dnl Sets the gl_THREADLIB default so that on mingw, a dependency to the 560 dnl libwinpthread DLL (mingw-w64 winpthreads library) is avoided. 561 dnl The user can still override it at installation time, by using the 562 dnl configure option '--enable-threads'. 563 564 AC_DEFUN([gl_AVOID_WINPTHREAD], [ 565 m4_divert_text([INIT_PREPARE], [gl_use_winpthreads_default=no]) 566 ]) 567 568 569 dnl ============================================================================ 570 571 572 dnl Survey of platforms: 573 dnl 574 dnl Platform Available Compiler Supports test-lock 575 dnl flavours option weak result 576 dnl --------------- --------- --------- -------- --------- 577 dnl Linux 2.4/glibc posix -lpthread Y OK 578 dnl 579 dnl GNU Hurd/glibc posix 580 dnl 581 dnl Ubuntu 14.04 posix -pthread Y OK 582 dnl 583 dnl FreeBSD 5.3 posix -lc_r Y 584 dnl posix -lkse ? Y 585 dnl posix -lpthread ? Y 586 dnl posix -lthr Y 587 dnl 588 dnl FreeBSD 5.2 posix -lc_r Y 589 dnl posix -lkse Y 590 dnl posix -lthr Y 591 dnl 592 dnl FreeBSD 4.0,4.10 posix -lc_r Y OK 593 dnl 594 dnl NetBSD 1.6 -- 595 dnl 596 dnl OpenBSD 3.4 posix -lpthread Y OK 597 dnl 598 dnl Mac OS X 10.[123] posix -lpthread Y OK 599 dnl 600 dnl Solaris 7,8,9 posix -lpthread Y Sol 7,8: 0.0; Sol 9: OK 601 dnl 602 dnl HP-UX 11 posix -lpthread N (cc) OK 603 dnl Y (gcc) 604 dnl 605 dnl IRIX 6.5 posix -lpthread Y 0.5 606 dnl 607 dnl AIX 4.3,5.1 posix -lpthread N AIX 4: 0.5; AIX 5: OK 608 dnl 609 dnl OSF/1 4.0,5.1 posix -pthread (cc) N OK 610 dnl -lpthread (gcc) Y 611 dnl 612 dnl Cygwin posix -lpthread Y OK 613 dnl 614 dnl Mingw windows N OK 615 dnl 616 dnl BeOS 5 -- 617 dnl 618 dnl The test-lock result shows what happens if in test-lock.c EXPLICIT_YIELD is 619 dnl turned off: 620 dnl OK if all three tests terminate OK, 621 dnl 0.5 if the first test terminates OK but the second one loops endlessly, 622 dnl 0.0 if the first test already loops endlessly.