m4/threadlib.m4

   1 # threadlib.m4 serial 30
   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
 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* | midnightbsd*)
 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.