| blob | b536b04750574542c045a1e818e750efeac56d3c |
1 # threadlib.m4 serial 32a
2 dnl Copyright (C) 2005-2023 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.
7 dnl From Bruno Haible.
9 AC_PREREQ([2.60])
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!
51 dnl ============================================================================
52 dnl Macros for all thread APIs
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 ])
80 dnl Checks whether the compiler and linker support weak declarations of symbols.
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 [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
110 int 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
145 int main ()
146 {
147 return (pthread_mutexattr_gettype != NULL);
148 }
149 EOF
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 ])
166 dnl ============================================================================
167 dnl Macros for the POSIX API
169 dnl gl_PTHREADLIB
170 dnl -------------
171 dnl Tests for the libraries needs for using the POSIX threads API.
172 dnl Sets the variable LIBPTHREAD to the linker options for use in a Makefile.
173 dnl Sets the variable LIBPMULTITHREAD, for programs that really need
174 dnl multithread functionality. The difference between LIBPTHREAD and
175 dnl LIBPMULTITHREAD is that on platforms supporting weak symbols, typically
176 dnl LIBPTHREAD is empty whereas LIBPMULTITHREAD is not.
177 dnl Sets the variable LIB_SCHED_YIELD to the linker options needed to use the
178 dnl sched_yield() function.
179 dnl Adds to CPPFLAGS the flag -D_REENTRANT or -D_THREAD_SAFE if needed for
180 dnl multithread-safe programs.
181 dnl Defines the C macro HAVE_PTHREAD_API if (at least parts of) the POSIX
182 dnl threads API is available.
184 dnl The guts of gl_PTHREADLIB. Needs to be expanded only once.
186 AC_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
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
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 changequote(,)dnl
265 solaris | solaris2.[1-9] | solaris2.[1-9].* | hpux*)
266 changequote([,])dnl
267 AC_DEFINE([PTHREAD_IN_USE_DETECTION_HARD], [1],
268 [Define if the pthread_in_use() detection is hard.])
269 esac
270 fi
271 ])
272 elif test $gl_pthread_api != yes; then
273 # Some library is needed. Try libpthread and libc_r.
274 AC_CHECK_LIB([pthread], [pthread_kill],
275 [gl_pthread_api=yes
276 LIBPTHREAD=-lpthread
277 LIBPMULTITHREAD=-lpthread])
278 if test $gl_pthread_api != yes; then
279 # For FreeBSD 4.
280 AC_CHECK_LIB([c_r], [pthread_kill],
281 [gl_pthread_api=yes
282 LIBPTHREAD=-lc_r
283 LIBPMULTITHREAD=-lc_r])
284 fi
285 fi
286 echo "$as_me:__oline__: LIBPMULTITHREAD=$LIBPMULTITHREAD" >&AS_MESSAGE_LOG_FD
287 fi
288 AC_MSG_CHECKING([whether POSIX threads API is available])
289 AC_MSG_RESULT([$gl_pthread_api])
290 AC_SUBST([LIBPTHREAD])
291 AC_SUBST([LIBPMULTITHREAD])
292 if test $gl_pthread_api = yes; then
293 AC_DEFINE([HAVE_PTHREAD_API], [1],
294 [Define if you have the <pthread.h> header and the POSIX threads API.])
295 fi
297 dnl On some systems, sched_yield is in librt, rather than in libpthread.
298 AC_LINK_IFELSE(
299 [AC_LANG_PROGRAM(
300 [[#include <sched.h>]],
301 [[sched_yield ();]])],
302 [LIB_SCHED_YIELD=
303 ],
304 [dnl Solaris 7...10 has sched_yield in librt, not in libpthread or libc.
305 AC_CHECK_LIB([rt], [sched_yield], [LIB_SCHED_YIELD=-lrt],
306 [dnl Solaris 2.5.1, 2.6 has sched_yield in libposix4, not librt.
307 AC_CHECK_LIB([posix4], [sched_yield], [LIB_SCHED_YIELD=-lposix4])])
308 ])
309 AC_SUBST([LIB_SCHED_YIELD])
311 gl_pthreadlib_body_done=done
312 fi
313 ])
315 AC_DEFUN([gl_PTHREADLIB],
316 [
317 AC_REQUIRE([gl_ANYTHREADLIB_EARLY])
318 gl_PTHREADLIB_BODY
319 ])
321 dnl ============================================================================
322 dnl Macros for the ISO C API
324 dnl gl_STDTHREADLIB
325 dnl ---------------
326 dnl Tests for the libraries needs for using the ISO C threads API.
327 dnl Sets the variable LIBSTDTHREAD to the linker options for use in a Makefile.
328 dnl Adds to CPPFLAGS the flag -D_REENTRANT or -D_THREAD_SAFE if needed for
329 dnl multithread-safe programs.
330 dnl Defines the C macro HAVE_THREADS_H if (at least parts of) the ISO C threads
331 dnl API is available.
333 dnl The guts of gl_STDTHREADLIB. Needs to be expanded only once.
335 AC_DEFUN([gl_STDTHREADLIB_BODY],
336 [
337 AC_REQUIRE([gl_ANYTHREADLIB_EARLY])
338 AC_REQUIRE([AC_CANONICAL_HOST])
339 if test -z "$gl_stdthreadlib_body_done"; then
340 AC_CHECK_HEADERS_ONCE([threads.h])
342 case "$host_os" in
343 mingw*)
344 LIBSTDTHREAD=
345 ;;
346 *)
347 gl_PTHREADLIB_BODY
348 if test $ac_cv_header_threads_h = yes; then
349 dnl glibc >= 2.29 has thrd_create in libpthread.
350 dnl FreeBSD >= 10 has thrd_create in libstdthreads; this library depends
351 dnl on libpthread (for the symbol 'pthread_mutexattr_gettype').
352 dnl glibc >= 2.34, AIX >= 7.1, and Solaris >= 11.4 have thrd_create in
353 dnl libc.
354 AC_CHECK_FUNCS([thrd_create])
355 if test $ac_cv_func_thrd_create = yes; then
356 LIBSTDTHREAD=
357 else
358 AC_CHECK_LIB([stdthreads], [thrd_create], [
359 LIBSTDTHREAD='-lstdthreads -lpthread'
360 ], [
361 dnl Guess that thrd_create is in libpthread.
362 LIBSTDTHREAD="$LIBPMULTITHREAD"
363 ])
364 fi
365 else
366 dnl Libraries needed by thrd.c, mtx.c, cnd.c, tss.c.
367 LIBSTDTHREAD="$LIBPMULTITHREAD $LIB_SCHED_YIELD"
368 fi
369 ;;
370 esac
371 AC_SUBST([LIBSTDTHREAD])
373 AC_MSG_CHECKING([whether ISO C threads API is available])
374 AC_MSG_RESULT([$ac_cv_header_threads_h])
375 gl_stdthreadlib_body_done=done
376 fi
377 ])
379 AC_DEFUN([gl_STDTHREADLIB],
380 [
381 AC_REQUIRE([gl_ANYTHREADLIB_EARLY])
382 gl_STDTHREADLIB_BODY
383 ])
385 dnl ============================================================================
386 dnl Macros for the Gnulib API
388 dnl gl_THREADLIB
389 dnl ------------
390 dnl Tests for a multithreading library to be used.
391 dnl If the configure.ac contains a definition of the gl_THREADLIB_DEFAULT_NO
392 dnl (it must be placed before the invocation of gl_THREADLIB_EARLY!), then the
393 dnl default is 'no', otherwise it is system dependent. In both cases, the user
394 dnl can change the choice through the options --enable-threads=choice or
395 dnl --disable-threads.
396 dnl Defines at most one of the macros USE_ISOC_THREADS, USE_POSIX_THREADS,
397 dnl USE_ISOC_AND_POSIX_THREADS, USE_WINDOWS_THREADS.
398 dnl The choice --enable-threads=isoc+posix is available only on platforms that
399 dnl have both the ISO C and the POSIX threads APIs. It has the effect of using
400 dnl the ISO C API for most things and the POSIX API only for creating and
401 dnl controlling threads (because there is no equivalent to pthread_atfork in
402 dnl the ISO C API).
403 dnl Sets the variables LIBTHREAD and LTLIBTHREAD to the linker options for use
404 dnl in a Makefile (LIBTHREAD for use without libtool, LTLIBTHREAD for use with
405 dnl libtool).
406 dnl Sets the variables LIBMULTITHREAD and LTLIBMULTITHREAD similarly, for
407 dnl programs that really need multithread functionality. The difference
408 dnl between LIBTHREAD and LIBMULTITHREAD is that on platforms supporting weak
409 dnl symbols, typically LIBTHREAD is empty whereas LIBMULTITHREAD is not.
410 dnl Adds to CPPFLAGS the flag -D_REENTRANT or -D_THREAD_SAFE if needed for
411 dnl multithread-safe programs.
412 dnl Since support for GNU pth was removed, $LTLIBTHREAD and $LIBTHREAD have the
413 dnl same value, and similarly $LTLIBMULTITHREAD and $LIBMULTITHREAD have the
414 dnl same value. Only system libraries are needed.
416 AC_DEFUN([gl_THREADLIB_EARLY],
417 [
418 AC_REQUIRE([gl_THREADLIB_EARLY_BODY])
419 ])
421 dnl The guts of gl_THREADLIB_EARLY. Needs to be expanded only once.
423 AC_DEFUN([gl_THREADLIB_EARLY_BODY],
424 [
425 dnl Ordering constraints: This macro modifies CPPFLAGS in a way that
426 dnl influences the result of the autoconf tests that test for *_unlocked
427 dnl declarations, on AIX 5 at least. Therefore it must come early.
428 AC_BEFORE([$0], [gl_FUNC_GLIBC_UNLOCKED_IO])dnl
429 AC_BEFORE([$0], [gl_ARGP])dnl
431 AC_REQUIRE([AC_CANONICAL_HOST])
432 dnl _GNU_SOURCE is needed for pthread_rwlock_t on glibc systems.
433 AC_REQUIRE([AC_USE_SYSTEM_EXTENSIONS])
434 dnl Check for multithreading.
435 m4_ifdef([gl_THREADLIB_DEFAULT_NO],
436 [m4_divert_text([DEFAULTS], [gl_use_threads_default=no])],
437 [m4_divert_text([DEFAULTS], [gl_use_threads_default=])])
438 m4_divert_text([DEFAULTS], [gl_use_winpthreads_default=])
439 AC_ARG_ENABLE([threads],
440 AS_HELP_STRING([--enable-threads={isoc|posix|isoc+posix|windows}], [specify multithreading API])m4_ifdef([gl_THREADLIB_DEFAULT_NO], [], [
441 AS_HELP_STRING([--disable-threads], [build without multithread safety])]),
442 [gl_use_threads=$enableval],
443 [if test -n "$gl_use_threads_default"; then
444 gl_use_threads="$gl_use_threads_default"
445 else
446 changequote(,)dnl
447 case "$host_os" in
448 dnl Disable multithreading by default on OSF/1, because it interferes
449 dnl with fork()/exec(): When msgexec is linked with -lpthread, its
450 dnl child process gets an endless segmentation fault inside execvp().
451 osf*) gl_use_threads=no ;;
452 dnl Disable multithreading by default on Cygwin 1.5.x, because it has
453 dnl bugs that lead to endless loops or crashes. See
454 dnl <https://cygwin.com/ml/cygwin/2009-08/msg00283.html>.
455 cygwin*)
456 case `uname -r` in
457 1.[0-5].*) gl_use_threads=no ;;
458 *) gl_use_threads=yes ;;
459 esac
460 ;;
461 dnl Obey gl_AVOID_WINPTHREAD on mingw.
462 mingw*)
463 case "$gl_use_winpthreads_default" in
464 yes) gl_use_threads=posix ;;
465 no) gl_use_threads=windows ;;
466 *) gl_use_threads=yes ;;
467 esac
468 ;;
469 *) gl_use_threads=yes ;;
470 esac
471 changequote([,])dnl
472 fi
473 ])
474 if test "$gl_use_threads" = yes \
475 || test "$gl_use_threads" = isoc \
476 || test "$gl_use_threads" = posix \
477 || test "$gl_use_threads" = isoc+posix; then
478 # For using <threads.h> or <pthread.h>:
479 gl_ANYTHREADLIB_EARLY
480 fi
481 ])
483 dnl The guts of gl_THREADLIB. Needs to be expanded only once.
485 AC_DEFUN([gl_THREADLIB_BODY],
486 [
487 AC_REQUIRE([gl_THREADLIB_EARLY_BODY])
488 gl_threads_api=none
489 LIBTHREAD=
490 LTLIBTHREAD=
491 LIBMULTITHREAD=
492 LTLIBMULTITHREAD=
493 if test "$gl_use_threads" != no; then
494 dnl Check whether the compiler and linker support weak declarations.
495 gl_WEAK_SYMBOLS
496 if case "$gl_cv_have_weak" in *yes) true;; *) false;; esac; then
497 dnl If we use weak symbols to implement pthread_in_use / pth_in_use /
498 dnl thread_in_use, we also need to test whether the ISO C 11 thrd_create
499 dnl facility is in use.
500 AC_CHECK_HEADERS_ONCE([threads.h])
501 :
502 fi
503 if test "$gl_use_threads" = isoc || test "$gl_use_threads" = isoc+posix; then
504 AC_CHECK_HEADERS_ONCE([threads.h])
505 gl_have_isoc_threads="$ac_cv_header_threads_h"
506 fi
507 if test "$gl_use_threads" = yes \
508 || test "$gl_use_threads" = posix \
509 || test "$gl_use_threads" = isoc+posix; then
510 gl_PTHREADLIB_BODY
511 LIBTHREAD=$LIBPTHREAD LTLIBTHREAD=$LIBPTHREAD
512 LIBMULTITHREAD=$LIBPMULTITHREAD LTLIBMULTITHREAD=$LIBPMULTITHREAD
513 if test $gl_pthread_api = yes; then
514 if test "$gl_use_threads" = isoc+posix && test "$gl_have_isoc_threads" = yes; then
515 gl_threads_api='isoc+posix'
516 AC_DEFINE([USE_ISOC_AND_POSIX_THREADS], [1],
517 [Define if the combination of the ISO C and POSIX multithreading APIs can be used.])
518 LIBTHREAD= LTLIBTHREAD=
519 else
520 gl_threads_api=posix
521 AC_DEFINE([USE_POSIX_THREADS], [1],
522 [Define if the POSIX multithreading library can be used.])
523 if test -z "$LIBMULTITHREAD" && test -z "$LTLIBMULTITHREAD"; then
524 AC_DEFINE([USE_POSIX_THREADS_FROM_LIBC], [1],
525 [Define if references to the POSIX multithreading library are satisfied by libc.])
526 else
527 if case "$gl_cv_have_weak" in *yes) true;; *) false;; esac; then
528 AC_DEFINE([USE_POSIX_THREADS_WEAK], [1],
529 [Define if references to the POSIX multithreading library should be made weak.])
530 LIBTHREAD= LTLIBTHREAD=
531 else
532 case "$host_os" in
533 freebsd* | dragonfly* | midnightbsd*)
534 if test "x$LIBTHREAD" != "x$LIBMULTITHREAD"; then
535 dnl If weak symbols can't tell whether pthread_create(), pthread_key_create()
536 dnl etc. will succeed, we need a runtime test.
537 AC_DEFINE([PTHREAD_IN_USE_DETECTION_HARD], [1],
538 [Define if the pthread_in_use() detection is hard.])
539 fi
540 ;;
541 esac
542 fi
543 fi
544 fi
545 fi
546 fi
547 if test $gl_threads_api = none; then
548 if test "$gl_use_threads" = isoc && test "$gl_have_isoc_threads" = yes; then
549 gl_STDTHREADLIB_BODY
550 LIBTHREAD=$LIBSTDTHREAD LTLIBTHREAD=$LIBSTDTHREAD
551 LIBMULTITHREAD=$LIBSTDTHREAD LTLIBMULTITHREAD=$LIBSTDTHREAD
552 gl_threads_api=isoc
553 AC_DEFINE([USE_ISOC_THREADS], [1],
554 [Define if the ISO C multithreading library can be used.])
555 fi
556 fi
557 if test $gl_threads_api = none; then
558 case "$gl_use_threads" in
559 yes | windows | win32) # The 'win32' is for backward compatibility.
560 if { case "$host_os" in
561 mingw*) true;;
562 *) false;;
563 esac
564 }; then
565 gl_threads_api=windows
566 AC_DEFINE([USE_WINDOWS_THREADS], [1],
567 [Define if the native Windows multithreading API can be used.])
568 fi
569 ;;
570 esac
571 fi
572 fi
573 AC_MSG_CHECKING([for multithread API to use])
574 AC_MSG_RESULT([$gl_threads_api])
575 AC_SUBST([LIBTHREAD])
576 AC_SUBST([LTLIBTHREAD])
577 AC_SUBST([LIBMULTITHREAD])
578 AC_SUBST([LTLIBMULTITHREAD])
579 ])
581 AC_DEFUN([gl_THREADLIB],
582 [
583 AC_REQUIRE([gl_THREADLIB_EARLY])
584 AC_REQUIRE([gl_THREADLIB_BODY])
585 ])
588 dnl gl_DISABLE_THREADS
589 dnl ------------------
590 dnl Sets the gl_THREADLIB default so that threads are not used by default.
591 dnl The user can still override it at installation time, by using the
592 dnl configure option '--enable-threads'.
594 AC_DEFUN([gl_DISABLE_THREADS], [
595 m4_divert_text([INIT_PREPARE], [gl_use_threads_default=no])
596 ])
599 dnl gl_AVOID_WINPTHREAD
600 dnl -------------------
601 dnl Sets the gl_THREADLIB default so that on mingw, a dependency to the
602 dnl libwinpthread DLL (mingw-w64 winpthreads library) is avoided.
603 dnl The user can still override it at installation time, by using the
604 dnl configure option '--enable-threads'.
606 AC_DEFUN([gl_AVOID_WINPTHREAD], [
607 m4_divert_text([INIT_PREPARE], [gl_use_winpthreads_default=no])
608 ])
611 dnl ============================================================================
614 dnl Survey of platforms:
615 dnl
616 dnl Platform Available Compiler Supports test-lock
617 dnl flavours option weak result
618 dnl --------------- --------- --------- -------- ---------
619 dnl Linux 2.4/glibc posix -lpthread Y OK
620 dnl
621 dnl Linux/glibc 2.34 posix Y OK
622 dnl
623 dnl GNU Hurd/glibc posix -lpthread Y OK
624 dnl
625 dnl Ubuntu 14.04 posix -pthread Y OK
626 dnl
627 dnl FreeBSD 5.3 posix -lc_r Y
628 dnl posix -lkse ? Y
629 dnl posix -lpthread ? Y
630 dnl posix -lthr Y
631 dnl
632 dnl FreeBSD 5.2 posix -lc_r Y
633 dnl posix -lkse Y
634 dnl posix -lthr Y
635 dnl
636 dnl FreeBSD 4.0,4.10 posix -lc_r Y OK
637 dnl
638 dnl NetBSD 1.6 --
639 dnl
640 dnl OpenBSD 3.4 posix -lpthread Y OK
641 dnl
642 dnl Mac OS X 10.[123] posix -lpthread Y OK
643 dnl
644 dnl Solaris 7,8,9 posix -lpthread Y Sol 7,8: 0.0; Sol 9: OK
645 dnl
646 dnl HP-UX 11 posix -lpthread N (cc) OK
647 dnl Y (gcc)
648 dnl
649 dnl IRIX 6.5 posix -lpthread Y 0.5
650 dnl
651 dnl AIX 4.3,5.1 posix -lpthread N AIX 4: 0.5; AIX 5: OK
652 dnl
653 dnl OSF/1 4.0,5.1 posix -pthread (cc) N OK
654 dnl -lpthread (gcc) Y
655 dnl
656 dnl Cygwin posix -lpthread Y OK
657 dnl
658 dnl Mingw windows N OK
659 dnl
660 dnl BeOS 5 --
661 dnl
662 dnl The test-lock result shows what happens if in test-lock.c EXPLICIT_YIELD is
663 dnl turned off:
664 dnl OK if all three tests terminate OK,
665 dnl 0.5 if the first test terminates OK but the second one loops endlessly,
666 dnl 0.0 if the first test already loops endlessly.