m4/threadlib.m4

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