1# threadlib.m4 serial 31 2dnl Copyright (C) 2005-2021 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* | midnightbsd*) 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 echo "$as_me:__oline__: gl_pthread_api=$gl_pthread_api" >&AS_MESSAGE_LOG_FD 216 echo "$as_me:__oline__: LIBPTHREAD=$LIBPTHREAD" >&AS_MESSAGE_LOG_FD 217 218 gl_pthread_in_glibc=no 219 # On Linux with glibc >= 2.34, libc contains the fully functional 220 # pthread functions. 221 case "$host_os" in 222 linux*) 223 AC_EGREP_CPP([Lucky user], 224 [#include <features.h> 225 #ifdef __GNU_LIBRARY__ 226 #if (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 34) || (__GLIBC__ > 2) 227 Lucky user 228 #endif 229 #endif 230 ], 231 [gl_pthread_in_glibc=yes], 232 []) 233 ;; 234 esac 235 echo "$as_me:__oline__: gl_pthread_in_glibc=$gl_pthread_in_glibc" >&AS_MESSAGE_LOG_FD 236 237 # Test for libpthread by looking for pthread_kill. (Not pthread_self, 238 # since it is defined as a macro on OSF/1.) 239 if test $gl_pthread_api = yes && test -z "$LIBPTHREAD"; then 240 # The program links fine without libpthread. But it may actually 241 # need to link with libpthread in order to create multiple threads. 242 AC_CHECK_LIB([pthread], [pthread_kill], 243 [if test $gl_pthread_in_glibc = yes; then 244 LIBPMULTITHREAD= 245 else 246 LIBPMULTITHREAD=-lpthread 247 # On Solaris and HP-UX, most pthread functions exist also in libc. 248 # Therefore pthread_in_use() needs to actually try to create a 249 # thread: pthread_create from libc will fail, whereas 250 # pthread_create will actually create a thread. 251 # On Solaris 10 or newer, this test is no longer needed, because 252 # libc contains the fully functional pthread functions. 253 case "$host_os" in 254 solaris | solaris2.[1-9] | solaris2.[1-9].* | hpux*) 255 AC_DEFINE([PTHREAD_IN_USE_DETECTION_HARD], [1], 256 [Define if the pthread_in_use() detection is hard.]) 257 esac 258 fi 259 ]) 260 elif test $gl_pthread_api != yes; then 261 # Some library is needed. Try libpthread and libc_r. 262 AC_CHECK_LIB([pthread], [pthread_kill], 263 [gl_pthread_api=yes 264 LIBPTHREAD=-lpthread 265 LIBPMULTITHREAD=-lpthread]) 266 if test $gl_pthread_api != yes; then 267 # For FreeBSD 4. 268 AC_CHECK_LIB([c_r], [pthread_kill], 269 [gl_pthread_api=yes 270 LIBPTHREAD=-lc_r 271 LIBPMULTITHREAD=-lc_r]) 272 fi 273 fi 274 echo "$as_me:__oline__: LIBPMULTITHREAD=$LIBPMULTITHREAD" >&AS_MESSAGE_LOG_FD 275 fi 276 AC_MSG_CHECKING([whether POSIX threads API is available]) 277 AC_MSG_RESULT([$gl_pthread_api]) 278 AC_SUBST([LIBPTHREAD]) 279 AC_SUBST([LIBPMULTITHREAD]) 280 if test $gl_pthread_api = yes; then 281 AC_DEFINE([HAVE_PTHREAD_API], [1], 282 [Define if you have the <pthread.h> header and the POSIX threads API.]) 283 fi 284 285 dnl On some systems, sched_yield is in librt, rather than in libpthread. 286 AC_LINK_IFELSE( 287 [AC_LANG_PROGRAM( 288 [[#include <sched.h>]], 289 [[sched_yield ();]])], 290 [LIB_SCHED_YIELD= 291 ], 292 [dnl Solaris 7...10 has sched_yield in librt, not in libpthread or libc. 293 AC_CHECK_LIB([rt], [sched_yield], [LIB_SCHED_YIELD=-lrt], 294 [dnl Solaris 2.5.1, 2.6 has sched_yield in libposix4, not librt. 295 AC_CHECK_LIB([posix4], [sched_yield], [LIB_SCHED_YIELD=-lposix4])]) 296 ]) 297 AC_SUBST([LIB_SCHED_YIELD]) 298 299 gl_pthreadlib_body_done=done 300 fi 301]) 302 303AC_DEFUN([gl_PTHREADLIB], 304[ 305 AC_REQUIRE([gl_ANYTHREADLIB_EARLY]) 306 gl_PTHREADLIB_BODY 307]) 308 309dnl ============================================================================ 310dnl Macros for the ISO C API 311 312dnl gl_STDTHREADLIB 313dnl --------------- 314dnl Tests for the libraries needs for using the ISO C threads API. 315dnl Sets the variable LIBSTDTHREAD to the linker options for use in a Makefile. 316dnl Adds to CPPFLAGS the flag -D_REENTRANT or -D_THREAD_SAFE if needed for 317dnl multithread-safe programs. 318dnl Defines the C macro HAVE_THREADS_H if (at least parts of) the ISO C threads 319dnl API is available. 320 321dnl The guts of gl_STDTHREADLIB. Needs to be expanded only once. 322 323AC_DEFUN([gl_STDTHREADLIB_BODY], 324[ 325 AC_REQUIRE([gl_ANYTHREADLIB_EARLY]) 326 AC_REQUIRE([AC_CANONICAL_HOST]) 327 if test -z "$gl_stdthreadlib_body_done"; then 328 AC_CHECK_HEADERS_ONCE([threads.h]) 329 330 case "$host_os" in 331 mingw*) 332 LIBSTDTHREAD= 333 ;; 334 *) 335 gl_PTHREADLIB_BODY 336 if test $ac_cv_header_threads_h = yes; then 337 dnl glibc >= 2.29 has thrd_create in libpthread. 338 dnl FreeBSD >= 10 has thrd_create in libstdthreads; this library depends 339 dnl on libpthread (for the symbol 'pthread_mutexattr_gettype'). 340 dnl glibc >= 2.34, AIX >= 7.1, and Solaris >= 11.4 have thrd_create in 341 dnl libc. 342 AC_CHECK_FUNCS([thrd_create]) 343 if test $ac_cv_func_thrd_create = yes; then 344 LIBSTDTHREAD= 345 else 346 AC_CHECK_LIB([stdthreads], [thrd_create], [ 347 LIBSTDTHREAD='-lstdthreads -lpthread' 348 ], [ 349 dnl Guess that thrd_create is in libpthread. 350 LIBSTDTHREAD="$LIBPMULTITHREAD" 351 ]) 352 fi 353 else 354 dnl Libraries needed by thrd.c, mtx.c, cnd.c, tss.c. 355 LIBSTDTHREAD="$LIBPMULTITHREAD $LIB_SCHED_YIELD" 356 fi 357 ;; 358 esac 359 AC_SUBST([LIBSTDTHREAD]) 360 361 AC_MSG_CHECKING([whether ISO C threads API is available]) 362 AC_MSG_RESULT([$ac_cv_header_threads_h]) 363 gl_stdthreadlib_body_done=done 364 fi 365]) 366 367AC_DEFUN([gl_STDTHREADLIB], 368[ 369 AC_REQUIRE([gl_ANYTHREADLIB_EARLY]) 370 gl_STDTHREADLIB_BODY 371]) 372 373dnl ============================================================================ 374dnl Macros for the Gnulib API 375 376dnl gl_THREADLIB 377dnl ------------ 378dnl Tests for a multithreading library to be used. 379dnl If the configure.ac contains a definition of the gl_THREADLIB_DEFAULT_NO 380dnl (it must be placed before the invocation of gl_THREADLIB_EARLY!), then the 381dnl default is 'no', otherwise it is system dependent. In both cases, the user 382dnl can change the choice through the options --enable-threads=choice or 383dnl --disable-threads. 384dnl Defines at most one of the macros USE_ISOC_THREADS, USE_POSIX_THREADS, 385dnl USE_ISOC_AND_POSIX_THREADS, USE_WINDOWS_THREADS. 386dnl The choice --enable-threads=isoc+posix is available only on platforms that 387dnl have both the ISO C and the POSIX threads APIs. It has the effect of using 388dnl the ISO C API for most things and the POSIX API only for creating and 389dnl controlling threads (because there is no equivalent to pthread_atfork in 390dnl the ISO C API). 391dnl Sets the variables LIBTHREAD and LTLIBTHREAD to the linker options for use 392dnl in a Makefile (LIBTHREAD for use without libtool, LTLIBTHREAD for use with 393dnl libtool). 394dnl Sets the variables LIBMULTITHREAD and LTLIBMULTITHREAD similarly, for 395dnl programs that really need multithread functionality. The difference 396dnl between LIBTHREAD and LIBMULTITHREAD is that on platforms supporting weak 397dnl symbols, typically LIBTHREAD is empty whereas LIBMULTITHREAD is not. 398dnl Adds to CPPFLAGS the flag -D_REENTRANT or -D_THREAD_SAFE if needed for 399dnl multithread-safe programs. 400dnl Since support for GNU pth was removed, $LTLIBTHREAD and $LIBTHREAD have the 401dnl same value, and similarly $LTLIBMULTITHREAD and $LIBMULTITHREAD have the 402dnl same value. Only system libraries are needed. 403 404AC_DEFUN([gl_THREADLIB_EARLY], 405[ 406 AC_REQUIRE([gl_THREADLIB_EARLY_BODY]) 407]) 408 409dnl The guts of gl_THREADLIB_EARLY. Needs to be expanded only once. 410 411AC_DEFUN([gl_THREADLIB_EARLY_BODY], 412[ 413 dnl Ordering constraints: This macro modifies CPPFLAGS in a way that 414 dnl influences the result of the autoconf tests that test for *_unlocked 415 dnl declarations, on AIX 5 at least. Therefore it must come early. 416 AC_BEFORE([$0], [gl_FUNC_GLIBC_UNLOCKED_IO])dnl 417 AC_BEFORE([$0], [gl_ARGP])dnl 418 419 AC_REQUIRE([AC_CANONICAL_HOST]) 420 dnl _GNU_SOURCE is needed for pthread_rwlock_t on glibc systems. 421 AC_REQUIRE([AC_USE_SYSTEM_EXTENSIONS]) 422 dnl Check for multithreading. 423 m4_ifdef([gl_THREADLIB_DEFAULT_NO], 424 [m4_divert_text([DEFAULTS], [gl_use_threads_default=no])], 425 [m4_divert_text([DEFAULTS], [gl_use_threads_default=])]) 426 m4_divert_text([DEFAULTS], [gl_use_winpthreads_default=]) 427 AC_ARG_ENABLE([threads], 428AS_HELP_STRING([--enable-threads={isoc|posix|isoc+posix|windows}], [specify multithreading API])m4_ifdef([gl_THREADLIB_DEFAULT_NO], [], [ 429AS_HELP_STRING([--disable-threads], [build without multithread safety])]), 430 [gl_use_threads=$enableval], 431 [if test -n "$gl_use_threads_default"; then 432 gl_use_threads="$gl_use_threads_default" 433 else 434changequote(,)dnl 435 case "$host_os" in 436 dnl Disable multithreading by default on OSF/1, because it interferes 437 dnl with fork()/exec(): When msgexec is linked with -lpthread, its 438 dnl child process gets an endless segmentation fault inside execvp(). 439 osf*) gl_use_threads=no ;; 440 dnl Disable multithreading by default on Cygwin 1.5.x, because it has 441 dnl bugs that lead to endless loops or crashes. See 442 dnl <https://cygwin.com/ml/cygwin/2009-08/msg00283.html>. 443 cygwin*) 444 case `uname -r` in 445 1.[0-5].*) gl_use_threads=no ;; 446 *) gl_use_threads=yes ;; 447 esac 448 ;; 449 dnl Obey gl_AVOID_WINPTHREAD on mingw. 450 mingw*) 451 case "$gl_use_winpthreads_default" in 452 yes) gl_use_threads=posix ;; 453 no) gl_use_threads=windows ;; 454 *) gl_use_threads=yes ;; 455 esac 456 ;; 457 *) gl_use_threads=yes ;; 458 esac 459changequote([,])dnl 460 fi 461 ]) 462 if test "$gl_use_threads" = yes \ 463 || test "$gl_use_threads" = isoc \ 464 || test "$gl_use_threads" = posix \ 465 || test "$gl_use_threads" = isoc+posix; then 466 # For using <threads.h> or <pthread.h>: 467 gl_ANYTHREADLIB_EARLY 468 fi 469]) 470 471dnl The guts of gl_THREADLIB. Needs to be expanded only once. 472 473AC_DEFUN([gl_THREADLIB_BODY], 474[ 475 AC_REQUIRE([gl_THREADLIB_EARLY_BODY]) 476 gl_threads_api=none 477 LIBTHREAD= 478 LTLIBTHREAD= 479 LIBMULTITHREAD= 480 LTLIBMULTITHREAD= 481 if test "$gl_use_threads" != no; then 482 dnl Check whether the compiler and linker support weak declarations. 483 gl_WEAK_SYMBOLS 484 if case "$gl_cv_have_weak" in *yes) true;; *) false;; esac; then 485 dnl If we use weak symbols to implement pthread_in_use / pth_in_use / 486 dnl thread_in_use, we also need to test whether the ISO C 11 thrd_create 487 dnl facility is in use. 488 AC_CHECK_HEADERS_ONCE([threads.h]) 489 : 490 fi 491 if test "$gl_use_threads" = isoc || test "$gl_use_threads" = isoc+posix; then 492 AC_CHECK_HEADERS_ONCE([threads.h]) 493 gl_have_isoc_threads="$ac_cv_header_threads_h" 494 fi 495 if test "$gl_use_threads" = yes \ 496 || test "$gl_use_threads" = posix \ 497 || test "$gl_use_threads" = isoc+posix; then 498 gl_PTHREADLIB_BODY 499 LIBTHREAD=$LIBPTHREAD LTLIBTHREAD=$LIBPTHREAD 500 LIBMULTITHREAD=$LIBPMULTITHREAD LTLIBMULTITHREAD=$LIBPMULTITHREAD 501 if test $gl_pthread_api = yes; then 502 if test "$gl_use_threads" = isoc+posix && test "$gl_have_isoc_threads" = yes; then 503 gl_threads_api='isoc+posix' 504 AC_DEFINE([USE_ISOC_AND_POSIX_THREADS], [1], 505 [Define if the combination of the ISO C and POSIX multithreading APIs can be used.]) 506 LIBTHREAD= LTLIBTHREAD= 507 else 508 gl_threads_api=posix 509 AC_DEFINE([USE_POSIX_THREADS], [1], 510 [Define if the POSIX multithreading library can be used.]) 511 if test -z "$LIBMULTITHREAD" && test -z "$LTLIBMULTITHREAD"; then 512 AC_DEFINE([USE_POSIX_THREADS_FROM_LIBC], [1], 513 [Define if references to the POSIX multithreading library are satisfied by libc.]) 514 else 515 if case "$gl_cv_have_weak" in *yes) true;; *) false;; esac; then 516 AC_DEFINE([USE_POSIX_THREADS_WEAK], [1], 517 [Define if references to the POSIX multithreading library should be made weak.]) 518 LIBTHREAD= LTLIBTHREAD= 519 else 520 case "$host_os" in 521 freebsd* | dragonfly* | midnightbsd*) 522 if test "x$LIBTHREAD" != "x$LIBMULTITHREAD"; then 523 dnl If weak symbols can't tell whether pthread_create(), pthread_key_create() 524 dnl etc. will succeed, we need a runtime test. 525 AC_DEFINE([PTHREAD_IN_USE_DETECTION_HARD], [1], 526 [Define if the pthread_in_use() detection is hard.]) 527 fi 528 ;; 529 esac 530 fi 531 fi 532 fi 533 fi 534 fi 535 if test $gl_threads_api = none; then 536 if test "$gl_use_threads" = isoc && test "$gl_have_isoc_threads" = yes; then 537 gl_STDTHREADLIB_BODY 538 LIBTHREAD=$LIBSTDTHREAD LTLIBTHREAD=$LIBSTDTHREAD 539 LIBMULTITHREAD=$LIBSTDTHREAD LTLIBMULTITHREAD=$LIBSTDTHREAD 540 gl_threads_api=isoc 541 AC_DEFINE([USE_ISOC_THREADS], [1], 542 [Define if the ISO C multithreading library can be used.]) 543 fi 544 fi 545 if test $gl_threads_api = none; then 546 case "$gl_use_threads" in 547 yes | windows | win32) # The 'win32' is for backward compatibility. 548 if { case "$host_os" in 549 mingw*) true;; 550 *) false;; 551 esac 552 }; then 553 gl_threads_api=windows 554 AC_DEFINE([USE_WINDOWS_THREADS], [1], 555 [Define if the native Windows multithreading API can be used.]) 556 fi 557 ;; 558 esac 559 fi 560 fi 561 AC_MSG_CHECKING([for multithread API to use]) 562 AC_MSG_RESULT([$gl_threads_api]) 563 AC_SUBST([LIBTHREAD]) 564 AC_SUBST([LTLIBTHREAD]) 565 AC_SUBST([LIBMULTITHREAD]) 566 AC_SUBST([LTLIBMULTITHREAD]) 567]) 568 569AC_DEFUN([gl_THREADLIB], 570[ 571 AC_REQUIRE([gl_THREADLIB_EARLY]) 572 AC_REQUIRE([gl_THREADLIB_BODY]) 573]) 574 575 576dnl gl_DISABLE_THREADS 577dnl ------------------ 578dnl Sets the gl_THREADLIB default so that threads are not used by default. 579dnl The user can still override it at installation time, by using the 580dnl configure option '--enable-threads'. 581 582AC_DEFUN([gl_DISABLE_THREADS], [ 583 m4_divert_text([INIT_PREPARE], [gl_use_threads_default=no]) 584]) 585 586 587dnl gl_AVOID_WINPTHREAD 588dnl ------------------- 589dnl Sets the gl_THREADLIB default so that on mingw, a dependency to the 590dnl libwinpthread DLL (mingw-w64 winpthreads library) is avoided. 591dnl The user can still override it at installation time, by using the 592dnl configure option '--enable-threads'. 593 594AC_DEFUN([gl_AVOID_WINPTHREAD], [ 595 m4_divert_text([INIT_PREPARE], [gl_use_winpthreads_default=no]) 596]) 597 598 599dnl ============================================================================ 600 601 602dnl Survey of platforms: 603dnl 604dnl Platform Available Compiler Supports test-lock 605dnl flavours option weak result 606dnl --------------- --------- --------- -------- --------- 607dnl Linux 2.4/glibc posix -lpthread Y OK 608dnl 609dnl Linux/glibc 2.34 posix Y OK 610dnl 611dnl GNU Hurd/glibc posix -lpthread Y OK 612dnl 613dnl Ubuntu 14.04 posix -pthread Y OK 614dnl 615dnl FreeBSD 5.3 posix -lc_r Y 616dnl posix -lkse ? Y 617dnl posix -lpthread ? Y 618dnl posix -lthr Y 619dnl 620dnl FreeBSD 5.2 posix -lc_r Y 621dnl posix -lkse Y 622dnl posix -lthr Y 623dnl 624dnl FreeBSD 4.0,4.10 posix -lc_r Y OK 625dnl 626dnl NetBSD 1.6 -- 627dnl 628dnl OpenBSD 3.4 posix -lpthread Y OK 629dnl 630dnl Mac OS X 10.[123] posix -lpthread Y OK 631dnl 632dnl Solaris 7,8,9 posix -lpthread Y Sol 7,8: 0.0; Sol 9: OK 633dnl 634dnl HP-UX 11 posix -lpthread N (cc) OK 635dnl Y (gcc) 636dnl 637dnl IRIX 6.5 posix -lpthread Y 0.5 638dnl 639dnl AIX 4.3,5.1 posix -lpthread N AIX 4: 0.5; AIX 5: OK 640dnl 641dnl OSF/1 4.0,5.1 posix -pthread (cc) N OK 642dnl -lpthread (gcc) Y 643dnl 644dnl Cygwin posix -lpthread Y OK 645dnl 646dnl Mingw windows N OK 647dnl 648dnl BeOS 5 -- 649dnl 650dnl The test-lock result shows what happens if in test-lock.c EXPLICIT_YIELD is 651dnl turned off: 652dnl OK if all three tests terminate OK, 653dnl 0.5 if the first test terminates OK but the second one loops endlessly, 654dnl 0.0 if the first test already loops endlessly. 655