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