m4/threadlib.m4

   1 # threadlib.m4 serial 31
   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* | 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
 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       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
 303 AC_DEFUN([gl_PTHREADLIB],
 304 [
 305   AC_REQUIRE([gl_ANYTHREADLIB_EARLY])
 306   gl_PTHREADLIB_BODY
 307 ])
 308
 309 dnl ============================================================================
 310 dnl Macros for the ISO C API
 311
 312 dnl gl_STDTHREADLIB
 313 dnl ---------------
 314 dnl Tests for the libraries needs for using the ISO C threads API.
 315 dnl Sets the variable LIBSTDTHREAD to the linker options for use in a Makefile.
 316 dnl Adds to CPPFLAGS the flag -D_REENTRANT or -D_THREAD_SAFE if needed for
 317 dnl multithread-safe programs.
 318 dnl Defines the C macro HAVE_THREADS_H if (at least parts of) the ISO C threads
 319 dnl API is available.
 320
 321 dnl The guts of gl_STDTHREADLIB. Needs to be expanded only once.
 322
 323 AC_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
 367 AC_DEFUN([gl_STDTHREADLIB],
 368 [
 369   AC_REQUIRE([gl_ANYTHREADLIB_EARLY])
 370   gl_STDTHREADLIB_BODY
 371 ])
 372
 373 dnl ============================================================================
 374 dnl Macros for the Gnulib API
 375
 376 dnl gl_THREADLIB
 377 dnl ------------
 378 dnl Tests for a multithreading library to be used.
 379 dnl If the configure.ac contains a definition of the gl_THREADLIB_DEFAULT_NO
 380 dnl (it must be placed before the invocation of gl_THREADLIB_EARLY!), then the
 381 dnl default is 'no', otherwise it is system dependent. In both cases, the user
 382 dnl can change the choice through the options --enable-threads=choice or
 383 dnl --disable-threads.
 384 dnl Defines at most one of the macros USE_ISOC_THREADS, USE_POSIX_THREADS,
 385 dnl USE_ISOC_AND_POSIX_THREADS, USE_WINDOWS_THREADS.
 386 dnl The choice --enable-threads=isoc+posix is available only on platforms that
 387 dnl have both the ISO C and the POSIX threads APIs. It has the effect of using
 388 dnl the ISO C API for most things and the POSIX API only for creating and
 389 dnl controlling threads (because there is no equivalent to pthread_atfork in
 390 dnl the ISO C API).
 391 dnl Sets the variables LIBTHREAD and LTLIBTHREAD to the linker options for use
 392 dnl in a Makefile (LIBTHREAD for use without libtool, LTLIBTHREAD for use with
 393 dnl libtool).
 394 dnl Sets the variables LIBMULTITHREAD and LTLIBMULTITHREAD similarly, for
 395 dnl programs that really need multithread functionality. The difference
 396 dnl between LIBTHREAD and LIBMULTITHREAD is that on platforms supporting weak
 397 dnl symbols, typically LIBTHREAD is empty whereas LIBMULTITHREAD is not.
 398 dnl Adds to CPPFLAGS the flag -D_REENTRANT or -D_THREAD_SAFE if needed for
 399 dnl multithread-safe programs.
 400 dnl Since support for GNU pth was removed, $LTLIBTHREAD and $LIBTHREAD have the
 401 dnl same value, and similarly $LTLIBMULTITHREAD and $LIBMULTITHREAD have the
 402 dnl same value. Only system libraries are needed.
 403
 404 AC_DEFUN([gl_THREADLIB_EARLY],
 405 [
 406   AC_REQUIRE([gl_THREADLIB_EARLY_BODY])
 407 ])
 408
 409 dnl The guts of gl_THREADLIB_EARLY. Needs to be expanded only once.
 410
 411 AC_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],
 428 AS_HELP_STRING([--enable-threads={isoc|posix|isoc+posix|windows}], [specify multithreading API])m4_ifdef([gl_THREADLIB_DEFAULT_NO], [], [
 429 AS_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
 434 changequote(,)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
 459 changequote([,])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
 471 dnl The guts of gl_THREADLIB. Needs to be expanded only once.
 472
 473 AC_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
 569 AC_DEFUN([gl_THREADLIB],
 570 [
 571   AC_REQUIRE([gl_THREADLIB_EARLY])
 572   AC_REQUIRE([gl_THREADLIB_BODY])
 573 ])
 574
 575
 576 dnl gl_DISABLE_THREADS
 577 dnl ------------------
 578 dnl Sets the gl_THREADLIB default so that threads are not used by default.
 579 dnl The user can still override it at installation time, by using the
 580 dnl configure option '--enable-threads'.
 581
 582 AC_DEFUN([gl_DISABLE_THREADS], [
 583   m4_divert_text([INIT_PREPARE], [gl_use_threads_default=no])
 584 ])
 585
 586
 587 dnl gl_AVOID_WINPTHREAD
 588 dnl -------------------
 589 dnl Sets the gl_THREADLIB default so that on mingw, a dependency to the
 590 dnl libwinpthread DLL (mingw-w64 winpthreads library) is avoided.
 591 dnl The user can still override it at installation time, by using the
 592 dnl configure option '--enable-threads'.
 593
 594 AC_DEFUN([gl_AVOID_WINPTHREAD], [
 595   m4_divert_text([INIT_PREPARE], [gl_use_winpthreads_default=no])
 596 ])
 597
 598
 599 dnl ============================================================================
 600
 601
 602 dnl Survey of platforms:
 603 dnl
 604 dnl Platform           Available  Compiler    Supports   test-lock
 605 dnl                    flavours   option      weak       result
 606 dnl ---------------    ---------  ---------   --------   ---------
 607 dnl Linux 2.4/glibc    posix      -lpthread       Y      OK
 608 dnl
 609 dnl Linux/glibc 2.34   posix                      Y      OK
 610 dnl
 611 dnl GNU Hurd/glibc     posix      -lpthread       Y      OK
 612 dnl
 613 dnl Ubuntu 14.04       posix      -pthread        Y      OK
 614 dnl
 615 dnl FreeBSD 5.3        posix      -lc_r           Y
 616 dnl                    posix      -lkse ?         Y
 617 dnl                    posix      -lpthread ?     Y
 618 dnl                    posix      -lthr           Y
 619 dnl
 620 dnl FreeBSD 5.2        posix      -lc_r           Y
 621 dnl                    posix      -lkse           Y
 622 dnl                    posix      -lthr           Y
 623 dnl
 624 dnl FreeBSD 4.0,4.10   posix      -lc_r           Y      OK
 625 dnl
 626 dnl NetBSD 1.6         --
 627 dnl
 628 dnl OpenBSD 3.4        posix      -lpthread       Y      OK
 629 dnl
 630 dnl Mac OS X 10.[123]  posix      -lpthread       Y      OK
 631 dnl
 632 dnl Solaris 7,8,9      posix      -lpthread       Y      Sol 7,8: 0.0; Sol 9: OK
 633 dnl
 634 dnl HP-UX 11           posix      -lpthread       N (cc) OK
 635 dnl                                               Y (gcc)
 636 dnl
 637 dnl IRIX 6.5           posix      -lpthread       Y      0.5
 638 dnl
 639 dnl AIX 4.3,5.1        posix      -lpthread       N      AIX 4: 0.5; AIX 5: OK
 640 dnl
 641 dnl OSF/1 4.0,5.1      posix      -pthread (cc)   N      OK
 642 dnl                               -lpthread (gcc) Y
 643 dnl
 644 dnl Cygwin             posix      -lpthread       Y      OK
 645 dnl
 646 dnl Mingw              windows                    N      OK
 647 dnl
 648 dnl BeOS 5             --
 649 dnl
 650 dnl The test-lock result shows what happens if in test-lock.c EXPLICIT_YIELD is
 651 dnl turned off:
 652 dnl   OK if all three tests terminate OK,
 653 dnl   0.5 if the first test terminates OK but the second one loops endlessly,
 654 dnl   0.0 if the first test already loops endlessly.