xref: /netbsd-src/external/gpl3/gdb/dist/gnulib/import/m4/threadlib.m4 (revision 4b169a6ba595ae283ca507b26b15fdff40495b1c)
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