1 # threadlib.m4 serial 15
2 dnl Copyright (C) 2005-2018 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.
13 dnl Tests for a multithreading library to be used.
14 dnl If the configure.ac contains a definition of the gl_THREADLIB_DEFAULT_NO
15 dnl (it must be placed before the invocation of gl_THREADLIB_EARLY!), then the
16 dnl default is 'no', otherwise it is system dependent. In both cases, the user
17 dnl can change the choice through the options --enable-threads=choice or
18 dnl --disable-threads.
19 dnl Defines at most one of the macros USE_POSIX_THREADS, USE_SOLARIS_THREADS,
20 dnl USE_PTH_THREADS, USE_WINDOWS_THREADS
21 dnl Sets the variables LIBTHREAD and LTLIBTHREAD to the linker options for use
22 dnl in a Makefile (LIBTHREAD for use without libtool, LTLIBTHREAD for use with
24 dnl Sets the variables LIBMULTITHREAD and LTLIBMULTITHREAD similarly, for
25 dnl programs that really need multithread functionality. The difference
26 dnl between LIBTHREAD and LIBMULTITHREAD is that on platforms supporting weak
27 dnl symbols, typically LIBTHREAD is empty whereas LIBMULTITHREAD is not.
28 dnl Adds to CPPFLAGS the flag -D_REENTRANT or -D_THREAD_SAFE if needed for
29 dnl multithread-safe programs.
31 AC_DEFUN([gl_THREADLIB_EARLY],
33 AC_REQUIRE([gl_THREADLIB_EARLY_BODY])
36 dnl The guts of gl_THREADLIB_EARLY. Needs to be expanded only once.
38 AC_DEFUN([gl_THREADLIB_EARLY_BODY],
40 dnl Ordering constraints: This macro modifies CPPFLAGS in a way that
41 dnl influences the result of the autoconf tests that test for *_unlocked
42 dnl declarations, on AIX 5 at least. Therefore it must come early.
43 AC_BEFORE([$0], [gl_FUNC_GLIBC_UNLOCKED_IO])dnl
44 AC_BEFORE([$0], [gl_ARGP])dnl
46 AC_REQUIRE([AC_CANONICAL_HOST])
47 dnl _GNU_SOURCE is needed for pthread_rwlock_t on glibc systems.
48 AC_REQUIRE([AC_USE_SYSTEM_EXTENSIONS])
49 dnl Check for multithreading.
50 m4_ifdef([gl_THREADLIB_DEFAULT_NO],
51 [m4_divert_text([DEFAULTS], [gl_use_threads_default=no])],
52 [m4_divert_text([DEFAULTS], [gl_use_threads_default=])])
53 AC_ARG_ENABLE([threads],
54 AC_HELP_STRING([--enable-threads={posix|solaris|pth|windows}], [specify multithreading API])m4_ifdef([gl_THREADLIB_DEFAULT_NO], [], [
55 AC_HELP_STRING([--disable-threads], [build without multithread safety])]),
56 [gl_use_threads=$enableval],
57 [if test -n "$gl_use_threads_default"; then
58 gl_use_threads="$gl_use_threads_default"
62 dnl Disable multithreading by default on OSF/1, because it interferes
63 dnl with fork()/exec(): When msgexec is linked with -lpthread, its
64 dnl child process gets an endless segmentation fault inside execvp().
65 dnl Disable multithreading by default on Cygwin 1.5.x, because it has
66 dnl bugs that lead to endless loops or crashes. See
67 dnl <https://cygwin.com/ml/cygwin/2009-08/msg00283.html>.
68 osf*) gl_use_threads=no ;;
71 1.[0-5].*) gl_use_threads=no ;;
72 *) gl_use_threads=yes ;;
75 *) gl_use_threads=yes ;;
80 if test "$gl_use_threads" = yes || test "$gl_use_threads" = posix; then
81 # For using <pthread.h>:
84 # On OSF/1, the compiler needs the flag -D_REENTRANT so that it
85 # groks <pthread.h>. cc also understands the flag -pthread, but
86 # we don't use it because 1. gcc-2.95 doesn't understand -pthread,
87 # 2. putting a flag into CPPFLAGS that has an effect on the linker
88 # causes the AC_LINK_IFELSE test below to succeed unexpectedly,
89 # leading to wrong values of LIBTHREAD and LTLIBTHREAD.
90 CPPFLAGS="$CPPFLAGS -D_REENTRANT"
93 # Some systems optimize for single-threaded programs by default, and
94 # need special flags to disable these optimizations. For example, the
95 # definition of 'errno' in <errno.h>.
97 aix* | freebsd*) CPPFLAGS="$CPPFLAGS -D_THREAD_SAFE" ;;
98 solaris*) CPPFLAGS="$CPPFLAGS -D_REENTRANT" ;;
103 dnl The guts of gl_THREADLIB. Needs to be expanded only once.
105 AC_DEFUN([gl_THREADLIB_BODY],
107 AC_REQUIRE([gl_THREADLIB_EARLY_BODY])
113 if test "$gl_use_threads" != no; then
114 dnl Check whether the compiler and linker support weak declarations.
115 AC_CACHE_CHECK([whether imported symbols can be declared weak],
118 dnl First, test whether the compiler accepts it syntactically.
121 [[extern void xyzzy ();
122 #pragma weak xyzzy]],
124 [gl_cv_have_weak=maybe])
125 if test $gl_cv_have_weak = maybe; then
126 dnl Second, test whether it actually works. On Cygwin 1.7.2, with
127 dnl gcc 4.3, symbols declared weak always evaluate to the address 0.
134 return (fputs == NULL);
136 [gl_cv_have_weak=yes],
137 [gl_cv_have_weak=no],
138 [dnl When cross-compiling, assume that only ELF platforms support
140 AC_EGREP_CPP([Extensible Linking Format],
142 Extensible Linking Format
145 [gl_cv_have_weak="guessing yes"],
146 [gl_cv_have_weak="guessing no"])
149 dnl But when linking statically, weak symbols don't work.
151 *" -static "*) gl_cv_have_weak=no ;;
154 dnl Check whether the linker supports the --as-needed/--no-as-needed options.
155 dnl Assume GCC, so that we can use the -Wl option.
156 AC_CACHE_CHECK([whether the linker supports --as-needed],
157 [gl_cv_linker_have_as_needed],
158 [if test -n "$GCC"; then
159 gl_saved_ldflags="$LDFLAGS"
160 LDFLAGS="$gl_saved_ldflags -Wl,--as-needed -Wl,--no-as-needed"
161 AC_LINK_IFELSE([AC_LANG_PROGRAM()],
162 [gl_cv_linker_have_as_needed=yes],
163 [gl_cv_linker_have_as_needed=no])
164 LDFLAGS="$gl_saved_ldflags"
166 gl_cv_linker_have_as_needed=no
169 dnl Check whether the linker supports the --push-state/--pop-state options.
170 dnl Assume GCC, so that we can use the -Wl option.
171 AC_CACHE_CHECK([whether the linker supports --push-state],
172 [gl_cv_linker_have_push_state],
173 [if test -n "$GCC"; then
174 gl_saved_ldflags="$LDFLAGS"
175 LDFLAGS="$gl_saved_ldflags -Wl,--push-state -Wl,--pop-state"
176 AC_LINK_IFELSE([AC_LANG_PROGRAM()],
177 [gl_cv_linker_have_push_state=yes],
178 [gl_cv_linker_have_push_state=no])
179 LDFLAGS="$gl_saved_ldflags"
181 gl_cv_linker_have_push_state=no
184 if test "$gl_use_threads" = yes || test "$gl_use_threads" = posix; then
185 # On OSF/1, the compiler needs the flag -pthread or -D_REENTRANT so that
186 # it groks <pthread.h>. It's added above, in gl_THREADLIB_EARLY_BODY.
187 AC_CHECK_HEADER([pthread.h],
188 [gl_have_pthread_h=yes], [gl_have_pthread_h=no])
189 if test "$gl_have_pthread_h" = yes; then
190 # Other possible tests:
191 # -lpthreads (FSU threads, PCthreads)
194 # Test whether both pthread_mutex_lock and pthread_mutexattr_init exist
195 # in libc. IRIX 6.5 has the first one in both libc and libpthread, but
196 # the second one only in libpthread, and lock.c needs it.
198 # If -pthread works, prefer it to -lpthread, since Ubuntu 14.04
199 # needs -pthread for some reason. See:
200 # https://lists.gnu.org/r/bug-gnulib/2014-09/msg00023.html
202 for gl_pthread in '' '-pthread'; do
203 LIBS="$LIBS $gl_pthread"
206 [[#include <pthread.h>
208 pthread_mutexattr_t ma;
210 [[pthread_mutex_lock (&m);
211 pthread_mutexattr_init (&ma);]])],
213 LIBTHREAD=$gl_pthread LTLIBTHREAD=$gl_pthread
214 LIBMULTITHREAD=$gl_pthread LTLIBMULTITHREAD=$gl_pthread])
216 test -n "$gl_have_pthread" && break
219 # Test for libpthread by looking for pthread_kill. (Not pthread_self,
220 # since it is defined as a macro on OSF/1.)
221 if test -n "$gl_have_pthread" && test -z "$LIBTHREAD"; then
222 # The program links fine without libpthread. But it may actually
223 # need to link with libpthread in order to create multiple threads.
224 AC_CHECK_LIB([pthread], [pthread_kill],
225 [LIBMULTITHREAD=-lpthread LTLIBMULTITHREAD=-lpthread
226 # On Solaris and HP-UX, most pthread functions exist also in libc.
227 # Therefore pthread_in_use() needs to actually try to create a
228 # thread: pthread_create from libc will fail, whereas
229 # pthread_create will actually create a thread.
230 # On Solaris 10 or newer, this test is no longer needed, because
231 # libc contains the fully functional pthread functions.
233 solaris | solaris2.[1-9] | solaris2.[1-9].* | hpux*)
234 AC_DEFINE([PTHREAD_IN_USE_DETECTION_HARD], [1],
235 [Define if the pthread_in_use() detection is hard.])
238 elif test -z "$gl_have_pthread"; then
239 # Some library is needed. Try libpthread and libc_r.
240 AC_CHECK_LIB([pthread], [pthread_kill],
242 LIBTHREAD=-lpthread LTLIBTHREAD=-lpthread
243 LIBMULTITHREAD=-lpthread LTLIBMULTITHREAD=-lpthread])
244 if test -z "$gl_have_pthread"; then
246 AC_CHECK_LIB([c_r], [pthread_kill],
248 LIBTHREAD=-lc_r LTLIBTHREAD=-lc_r
249 LIBMULTITHREAD=-lc_r LTLIBMULTITHREAD=-lc_r])
252 if test -n "$gl_have_pthread"; then
254 AC_DEFINE([USE_POSIX_THREADS], [1],
255 [Define if the POSIX multithreading library can be used.])
256 if test -n "$LIBMULTITHREAD" || test -n "$LTLIBMULTITHREAD"; then
257 if case "$gl_cv_have_weak" in *yes) true;; *) false;; esac; then
258 AC_DEFINE([USE_POSIX_THREADS_WEAK], [1],
259 [Define if references to the POSIX multithreading library should be made weak.])
262 dnl On platforms where GCC enables --as-needed by default, attempt
263 dnl to make sure that LIBMULTITHREAD really links with -lpthread.
264 dnl Otherwise linking with LIBMULTITHREAD has no effect; then
265 dnl the weak symbols are not defined and thus evaluate to NULL.
266 case "$LIBMULTITHREAD" in
269 if test $gl_cv_linker_have_as_needed = yes; then
270 if test $gl_cv_linker_have_push_state = yes; then
271 LIBMULTITHREAD="$LIBMULTITHREAD -Wl,--push-state -Wl,--no-as-needed -lpthread -Wl,--pop-state"
273 LIBMULTITHREAD="$LIBMULTITHREAD -Wl,--no-as-needed -lpthread"
278 if test $gl_cv_linker_have_as_needed = yes; then
279 if test $gl_cv_linker_have_push_state = yes; then
280 LIBMULTITHREAD="-Wl,--push-state -Wl,--no-as-needed $LIBMULTITHREAD -Wl,--pop-state"
282 LIBMULTITHREAD="-Wl,--no-as-needed $LIBMULTITHREAD"
287 # TODO: May need to modify LTLIBMULTITHREAD similarly.
293 if test -z "$gl_have_pthread"; then
294 if test "$gl_use_threads" = yes || test "$gl_use_threads" = solaris; then
295 gl_have_solaristhread=
297 LIBS="$LIBS -lthread"
305 [gl_have_solaristhread=yes])
307 if test -n "$gl_have_solaristhread"; then
308 gl_threads_api=solaris
311 LIBMULTITHREAD="$LIBTHREAD"
312 LTLIBMULTITHREAD="$LTLIBTHREAD"
313 AC_DEFINE([USE_SOLARIS_THREADS], [1],
314 [Define if the old Solaris multithreading library can be used.])
315 if case "$gl_cv_have_weak" in *yes) true;; *) false;; esac; then
316 AC_DEFINE([USE_SOLARIS_THREADS_WEAK], [1],
317 [Define if references to the old Solaris multithreading library should be made weak.])
320 dnl On platforms where GCC enables --as-needed by default, attempt
321 dnl to make sure that LIBMULTITHREAD really links with -lthread.
322 dnl Otherwise linking with LIBMULTITHREAD has no effect; then
323 dnl the weak symbols are not defined and thus evaluate to NULL.
324 if test $gl_cv_linker_have_as_needed = yes; then
325 if test $gl_cv_linker_have_push_state = yes; then
326 LIBMULTITHREAD="-Wl,--push-state -Wl,--no-as-needed $LIBMULTITHREAD -Wl,--pop-state"
328 LIBMULTITHREAD="-Wl,--no-as-needed $LIBMULTITHREAD"
331 # TODO: May need to modify LTLIBMULTITHREAD similarly.
336 if test "$gl_use_threads" = pth; then
337 gl_save_CPPFLAGS="$CPPFLAGS"
338 AC_LIB_LINKFLAGS([pth])
343 [AC_LANG_PROGRAM([[#include <pth.h>]], [[pth_self();]])],
346 if test -n "$gl_have_pth"; then
349 LTLIBTHREAD="$LTLIBPTH"
350 LIBMULTITHREAD="$LIBTHREAD"
351 LTLIBMULTITHREAD="$LTLIBTHREAD"
352 AC_DEFINE([USE_PTH_THREADS], [1],
353 [Define if the GNU Pth multithreading library can be used.])
354 if test -n "$LIBMULTITHREAD" || test -n "$LTLIBMULTITHREAD"; then
355 if case "$gl_cv_have_weak" in *yes) true;; *) false;; esac; then
356 AC_DEFINE([USE_PTH_THREADS_WEAK], [1],
357 [Define if references to the GNU Pth multithreading library should be made weak.])
360 dnl On platforms where GCC enables --as-needed by default, attempt
361 dnl to make sure that LIBMULTITHREAD really links with -lpth.
362 dnl Otherwise linking with LIBMULTITHREAD has no effect; then
363 dnl the weak symbols are not defined and thus evaluate to NULL.
364 if test $gl_cv_linker_have_as_needed = yes; then
365 if test $gl_cv_linker_have_push_state = yes; then
366 LIBMULTITHREAD="-Wl,--push-state -Wl,--no-as-needed $LIBMULTITHREAD -Wl,--pop-state"
368 LIBMULTITHREAD="-Wl,--no-as-needed $LIBMULTITHREAD"
371 # TODO: May need to modify LTLIBMULTITHREAD similarly.
375 CPPFLAGS="$gl_save_CPPFLAGS"
378 if test -z "$gl_have_pthread"; then
379 case "$gl_use_threads" in
380 yes | windows | win32) # The 'win32' is for backward compatibility.
381 if { case "$host_os" in
386 gl_threads_api=windows
387 AC_DEFINE([USE_WINDOWS_THREADS], [1],
388 [Define if the native Windows multithreading API can be used.])
394 AC_MSG_CHECKING([for multithread API to use])
395 AC_MSG_RESULT([$gl_threads_api])
396 AC_SUBST([LIBTHREAD])
397 AC_SUBST([LTLIBTHREAD])
398 AC_SUBST([LIBMULTITHREAD])
399 AC_SUBST([LTLIBMULTITHREAD])
402 AC_DEFUN([gl_THREADLIB],
404 AC_REQUIRE([gl_THREADLIB_EARLY])
405 AC_REQUIRE([gl_THREADLIB_BODY])
409 dnl gl_DISABLE_THREADS
410 dnl ------------------
411 dnl Sets the gl_THREADLIB default so that threads are not used by default.
412 dnl The user can still override it at installation time, by using the
413 dnl configure option '--enable-threads'.
415 AC_DEFUN([gl_DISABLE_THREADS], [
416 m4_divert_text([INIT_PREPARE], [gl_use_threads_default=no])
420 dnl Survey of platforms:
422 dnl Platform Available Compiler Supports test-lock
423 dnl flavours option weak result
424 dnl --------------- --------- --------- -------- ---------
425 dnl Linux 2.4/glibc posix -lpthread Y OK
427 dnl GNU Hurd/glibc posix
429 dnl Ubuntu 14.04 posix -pthread Y OK
431 dnl FreeBSD 5.3 posix -lc_r Y
433 dnl posix -lpthread ? Y
436 dnl FreeBSD 5.2 posix -lc_r Y
440 dnl FreeBSD 4.0,4.10 posix -lc_r Y OK
444 dnl OpenBSD 3.4 posix -lpthread Y OK
446 dnl Mac OS X 10.[123] posix -lpthread Y OK
448 dnl Solaris 7,8,9 posix -lpthread Y Sol 7,8: 0.0; Sol 9: OK
449 dnl solaris -lthread Y Sol 7,8: 0.0; Sol 9: OK
451 dnl HP-UX 11 posix -lpthread N (cc) OK
454 dnl IRIX 6.5 posix -lpthread Y 0.5
456 dnl AIX 4.3,5.1 posix -lpthread N AIX 4: 0.5; AIX 5: OK
458 dnl OSF/1 4.0,5.1 posix -pthread (cc) N OK
459 dnl -lpthread (gcc) Y
461 dnl Cygwin posix -lpthread Y OK
463 dnl Any of the above pth -lpth 0.0
465 dnl Mingw windows N OK
469 dnl The test-lock result shows what happens if in test-lock.c EXPLICIT_YIELD is
471 dnl OK if all three tests terminate OK,
472 dnl 0.5 if the first test terminates OK but the second one loops endlessly,
473 dnl 0.0 if the first test already loops endlessly.