summaryrefslogtreecommitdiffstats
path: root/gl/m4/threadlib.m4
diff options
context:
space:
mode:
Diffstat (limited to 'gl/m4/threadlib.m4')
-rw-r--r--gl/m4/threadlib.m4665
1 files changed, 479 insertions, 186 deletions
diff --git a/gl/m4/threadlib.m4 b/gl/m4/threadlib.m4
index 26bdeb58..6b43bbdf 100644
--- a/gl/m4/threadlib.m4
+++ b/gl/m4/threadlib.m4
@@ -1,11 +1,388 @@
1# threadlib.m4 serial 10 (gettext-0.18.2) 1# threadlib.m4 serial 32
2dnl Copyright (C) 2005-2013 Free Software Foundation, Inc. 2dnl Copyright (C) 2005-2021 Free Software Foundation, Inc.
3dnl This file is free software; the Free Software Foundation 3dnl This file is free software; the Free Software Foundation
4dnl gives unlimited permission to copy and/or distribute it, 4dnl gives unlimited permission to copy and/or distribute it,
5dnl with or without modifications, as long as this notice is preserved. 5dnl with or without modifications, as long as this notice is preserved.
6 6
7dnl From Bruno Haible. 7dnl From Bruno Haible.
8 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
9dnl gl_THREADLIB 386dnl gl_THREADLIB
10dnl ------------ 387dnl ------------
11dnl Tests for a multithreading library to be used. 388dnl Tests for a multithreading library to be used.
@@ -14,17 +391,25 @@ dnl (it must be placed before the invocation of gl_THREADLIB_EARLY!), then the
14dnl default is 'no', otherwise it is system dependent. In both cases, the user 391dnl default is 'no', otherwise it is system dependent. In both cases, the user
15dnl can change the choice through the options --enable-threads=choice or 392dnl can change the choice through the options --enable-threads=choice or
16dnl --disable-threads. 393dnl --disable-threads.
17dnl Defines at most one of the macros USE_POSIX_THREADS, USE_SOLARIS_THREADS, 394dnl Defines at most one of the macros USE_ISOC_THREADS, USE_POSIX_THREADS,
18dnl USE_PTH_THREADS, USE_WINDOWS_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).
19dnl Sets the variables LIBTHREAD and LTLIBTHREAD to the linker options for use 401dnl Sets the variables LIBTHREAD and LTLIBTHREAD to the linker options for use
20dnl in a Makefile (LIBTHREAD for use without libtool, LTLIBTHREAD for use with 402dnl in a Makefile (LIBTHREAD for use without libtool, LTLIBTHREAD for use with
21dnl libtool). 403dnl libtool).
22dnl Sets the variables LIBMULTITHREAD and LTLIBMULTITHREAD similarly, for 404dnl Sets the variables LIBMULTITHREAD and LTLIBMULTITHREAD similarly, for
23dnl programs that really need multithread functionality. The difference 405dnl programs that really need multithread functionality. The difference
24dnl between LIBTHREAD and LIBMULTITHREAD is that on platforms supporting weak 406dnl between LIBTHREAD and LIBMULTITHREAD is that on platforms supporting weak
25dnl symbols, typically LIBTHREAD="" whereas LIBMULTITHREAD="-lpthread". 407dnl symbols, typically LIBTHREAD is empty whereas LIBMULTITHREAD is not.
26dnl Adds to CPPFLAGS the flag -D_REENTRANT or -D_THREAD_SAFE if needed for 408dnl Adds to CPPFLAGS the flag -D_REENTRANT or -D_THREAD_SAFE if needed for
27dnl multithread-safe programs. 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.
28 413
29AC_DEFUN([gl_THREADLIB_EARLY], 414AC_DEFUN([gl_THREADLIB_EARLY],
30[ 415[
@@ -43,18 +428,15 @@ AC_DEFUN([gl_THREADLIB_EARLY_BODY],
43 428
44 AC_REQUIRE([AC_CANONICAL_HOST]) 429 AC_REQUIRE([AC_CANONICAL_HOST])
45 dnl _GNU_SOURCE is needed for pthread_rwlock_t on glibc systems. 430 dnl _GNU_SOURCE is needed for pthread_rwlock_t on glibc systems.
46 dnl AC_USE_SYSTEM_EXTENSIONS was introduced in autoconf 2.60 and obsoletes 431 AC_REQUIRE([AC_USE_SYSTEM_EXTENSIONS])
47 dnl AC_GNU_SOURCE.
48 m4_ifdef([AC_USE_SYSTEM_EXTENSIONS],
49 [AC_REQUIRE([AC_USE_SYSTEM_EXTENSIONS])],
50 [AC_REQUIRE([AC_GNU_SOURCE])])
51 dnl Check for multithreading. 432 dnl Check for multithreading.
52 m4_ifdef([gl_THREADLIB_DEFAULT_NO], 433 m4_ifdef([gl_THREADLIB_DEFAULT_NO],
53 [m4_divert_text([DEFAULTS], [gl_use_threads_default=no])], 434 [m4_divert_text([DEFAULTS], [gl_use_threads_default=no])],
54 [m4_divert_text([DEFAULTS], [gl_use_threads_default=])]) 435 [m4_divert_text([DEFAULTS], [gl_use_threads_default=])])
436 m4_divert_text([DEFAULTS], [gl_use_winpthreads_default=])
55 AC_ARG_ENABLE([threads], 437 AC_ARG_ENABLE([threads],
56AC_HELP_STRING([--enable-threads={posix|solaris|pth|windows}], [specify multithreading API])m4_ifdef([gl_THREADLIB_DEFAULT_NO], [], [ 438AS_HELP_STRING([--enable-threads={isoc|posix|isoc+posix|windows}], [specify multithreading API])m4_ifdef([gl_THREADLIB_DEFAULT_NO], [], [
57AC_HELP_STRING([--disable-threads], [build without multithread safety])]), 439AS_HELP_STRING([--disable-threads], [build without multithread safety])]),
58 [gl_use_threads=$enableval], 440 [gl_use_threads=$enableval],
59 [if test -n "$gl_use_threads_default"; then 441 [if test -n "$gl_use_threads_default"; then
60 gl_use_threads="$gl_use_threads_default" 442 gl_use_threads="$gl_use_threads_default"
@@ -64,41 +446,35 @@ changequote(,)dnl
64 dnl Disable multithreading by default on OSF/1, because it interferes 446 dnl Disable multithreading by default on OSF/1, because it interferes
65 dnl with fork()/exec(): When msgexec is linked with -lpthread, its 447 dnl with fork()/exec(): When msgexec is linked with -lpthread, its
66 dnl child process gets an endless segmentation fault inside execvp(). 448 dnl child process gets an endless segmentation fault inside execvp().
449 osf*) gl_use_threads=no ;;
67 dnl Disable multithreading by default on Cygwin 1.5.x, because it has 450 dnl Disable multithreading by default on Cygwin 1.5.x, because it has
68 dnl bugs that lead to endless loops or crashes. See 451 dnl bugs that lead to endless loops or crashes. See
69 dnl <http://cygwin.com/ml/cygwin/2009-08/msg00283.html>. 452 dnl <https://cygwin.com/ml/cygwin/2009-08/msg00283.html>.
70 osf*) gl_use_threads=no ;;
71 cygwin*) 453 cygwin*)
72 case `uname -r` in 454 case `uname -r` in
73 1.[0-5].*) gl_use_threads=no ;; 455 1.[0-5].*) gl_use_threads=no ;;
74 *) gl_use_threads=yes ;; 456 *) gl_use_threads=yes ;;
75 esac 457 esac
76 ;; 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 ;;
77 *) gl_use_threads=yes ;; 467 *) gl_use_threads=yes ;;
78 esac 468 esac
79changequote([,])dnl 469changequote([,])dnl
80 fi 470 fi
81 ]) 471 ])
82 if test "$gl_use_threads" = yes || test "$gl_use_threads" = posix; then 472 if test "$gl_use_threads" = yes \
83 # For using <pthread.h>: 473 || test "$gl_use_threads" = isoc \
84 case "$host_os" in 474 || test "$gl_use_threads" = posix \
85 osf*) 475 || test "$gl_use_threads" = isoc+posix; then
86 # On OSF/1, the compiler needs the flag -D_REENTRANT so that it 476 # For using <threads.h> or <pthread.h>:
87 # groks <pthread.h>. cc also understands the flag -pthread, but 477 gl_ANYTHREADLIB_EARLY
88 # we don't use it because 1. gcc-2.95 doesn't understand -pthread,
89 # 2. putting a flag into CPPFLAGS that has an effect on the linker
90 # causes the AC_LINK_IFELSE test below to succeed unexpectedly,
91 # leading to wrong values of LIBTHREAD and LTLIBTHREAD.
92 CPPFLAGS="$CPPFLAGS -D_REENTRANT"
93 ;;
94 esac
95 # Some systems optimize for single-threaded programs by default, and
96 # need special flags to disable these optimizations. For example, the
97 # definition of 'errno' in <errno.h>.
98 case "$host_os" in
99 aix* | freebsd*) CPPFLAGS="$CPPFLAGS -D_THREAD_SAFE" ;;
100 solaris*) CPPFLAGS="$CPPFLAGS -D_REENTRANT" ;;
101 esac
102 fi 478 fi
103]) 479])
104 480
@@ -114,168 +490,69 @@ AC_DEFUN([gl_THREADLIB_BODY],
114 LTLIBMULTITHREAD= 490 LTLIBMULTITHREAD=
115 if test "$gl_use_threads" != no; then 491 if test "$gl_use_threads" != no; then
116 dnl Check whether the compiler and linker support weak declarations. 492 dnl Check whether the compiler and linker support weak declarations.
117 AC_CACHE_CHECK([whether imported symbols can be declared weak], 493 gl_WEAK_SYMBOLS
118 [gl_cv_have_weak], 494 if case "$gl_cv_have_weak" in *yes) true;; *) false;; esac; then
119 [gl_cv_have_weak=no 495 dnl If we use weak symbols to implement pthread_in_use / pth_in_use /
120 dnl First, test whether the compiler accepts it syntactically. 496 dnl thread_in_use, we also need to test whether the ISO C 11 thrd_create
121 AC_LINK_IFELSE( 497 dnl facility is in use.
122 [AC_LANG_PROGRAM( 498 AC_CHECK_HEADERS_ONCE([threads.h])
123 [[extern void xyzzy (); 499 :
124#pragma weak xyzzy]], 500 fi
125 [[xyzzy();]])], 501 if test "$gl_use_threads" = isoc || test "$gl_use_threads" = isoc+posix; then
126 [gl_cv_have_weak=maybe]) 502 AC_CHECK_HEADERS_ONCE([threads.h])
127 if test $gl_cv_have_weak = maybe; then 503 gl_have_isoc_threads="$ac_cv_header_threads_h"
128 dnl Second, test whether it actually works. On Cygwin 1.7.2, with 504 fi
129 dnl gcc 4.3, symbols declared weak always evaluate to the address 0. 505 if test "$gl_use_threads" = yes \
130 AC_RUN_IFELSE( 506 || test "$gl_use_threads" = posix \
131 [AC_LANG_SOURCE([[ 507 || test "$gl_use_threads" = isoc+posix; then
132#include <stdio.h> 508 gl_PTHREADLIB_BODY
133#pragma weak fputs 509 LIBTHREAD=$LIBPTHREAD LTLIBTHREAD=$LIBPTHREAD
134int main () 510 LIBMULTITHREAD=$LIBPMULTITHREAD LTLIBMULTITHREAD=$LIBPMULTITHREAD
135{ 511 if test $gl_pthread_api = yes; then
136 return (fputs == NULL); 512 if test "$gl_use_threads" = isoc+posix && test "$gl_have_isoc_threads" = yes; then
137}]])], 513 gl_threads_api='isoc+posix'
138 [gl_cv_have_weak=yes], 514 AC_DEFINE([USE_ISOC_AND_POSIX_THREADS], [1],
139 [gl_cv_have_weak=no], 515 [Define if the combination of the ISO C and POSIX multithreading APIs can be used.])
140 [dnl When cross-compiling, assume that only ELF platforms support 516 LIBTHREAD= LTLIBTHREAD=
141 dnl weak symbols.
142 AC_EGREP_CPP([Extensible Linking Format],
143 [#ifdef __ELF__
144 Extensible Linking Format
145 #endif
146 ],
147 [gl_cv_have_weak="guessing yes"],
148 [gl_cv_have_weak="guessing no"])
149 ])
150 fi
151 ])
152 if test "$gl_use_threads" = yes || test "$gl_use_threads" = posix; then
153 # On OSF/1, the compiler needs the flag -pthread or -D_REENTRANT so that
154 # it groks <pthread.h>. It's added above, in gl_THREADLIB_EARLY_BODY.
155 AC_CHECK_HEADER([pthread.h],
156 [gl_have_pthread_h=yes], [gl_have_pthread_h=no])
157 if test "$gl_have_pthread_h" = yes; then
158 # Other possible tests:
159 # -lpthreads (FSU threads, PCthreads)
160 # -lgthreads
161 gl_have_pthread=
162 # Test whether both pthread_mutex_lock and pthread_mutexattr_init exist
163 # in libc. IRIX 6.5 has the first one in both libc and libpthread, but
164 # the second one only in libpthread, and lock.c needs it.
165 AC_LINK_IFELSE(
166 [AC_LANG_PROGRAM(
167 [[#include <pthread.h>]],
168 [[pthread_mutex_lock((pthread_mutex_t*)0);
169 pthread_mutexattr_init((pthread_mutexattr_t*)0);]])],
170 [gl_have_pthread=yes])
171 # Test for libpthread by looking for pthread_kill. (Not pthread_self,
172 # since it is defined as a macro on OSF/1.)
173 if test -n "$gl_have_pthread"; then
174 # The program links fine without libpthread. But it may actually
175 # need to link with libpthread in order to create multiple threads.
176 AC_CHECK_LIB([pthread], [pthread_kill],
177 [LIBMULTITHREAD=-lpthread LTLIBMULTITHREAD=-lpthread
178 # On Solaris and HP-UX, most pthread functions exist also in libc.
179 # Therefore pthread_in_use() needs to actually try to create a
180 # thread: pthread_create from libc will fail, whereas
181 # pthread_create will actually create a thread.
182 case "$host_os" in
183 solaris* | hpux*)
184 AC_DEFINE([PTHREAD_IN_USE_DETECTION_HARD], [1],
185 [Define if the pthread_in_use() detection is hard.])
186 esac
187 ])
188 else 517 else
189 # Some library is needed. Try libpthread and libc_r.
190 AC_CHECK_LIB([pthread], [pthread_kill],
191 [gl_have_pthread=yes
192 LIBTHREAD=-lpthread LTLIBTHREAD=-lpthread
193 LIBMULTITHREAD=-lpthread LTLIBMULTITHREAD=-lpthread])
194 if test -z "$gl_have_pthread"; then
195 # For FreeBSD 4.
196 AC_CHECK_LIB([c_r], [pthread_kill],
197 [gl_have_pthread=yes
198 LIBTHREAD=-lc_r LTLIBTHREAD=-lc_r
199 LIBMULTITHREAD=-lc_r LTLIBMULTITHREAD=-lc_r])
200 fi
201 fi
202 if test -n "$gl_have_pthread"; then
203 gl_threads_api=posix 518 gl_threads_api=posix
204 AC_DEFINE([USE_POSIX_THREADS], [1], 519 AC_DEFINE([USE_POSIX_THREADS], [1],
205 [Define if the POSIX multithreading library can be used.]) 520 [Define if the POSIX multithreading library can be used.])
206 if test -n "$LIBMULTITHREAD" || test -n "$LTLIBMULTITHREAD"; then 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
207 if case "$gl_cv_have_weak" in *yes) true;; *) false;; esac; then 525 if case "$gl_cv_have_weak" in *yes) true;; *) false;; esac; then
208 AC_DEFINE([USE_POSIX_THREADS_WEAK], [1], 526 AC_DEFINE([USE_POSIX_THREADS_WEAK], [1],
209 [Define if references to the POSIX multithreading library should be made weak.]) 527 [Define if references to the POSIX multithreading library should be made weak.])
210 LIBTHREAD= 528 LIBTHREAD= LTLIBTHREAD=
211 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
212 fi 540 fi
213 fi 541 fi
214 fi 542 fi
215 fi 543 fi
216 fi 544 fi
217 if test -z "$gl_have_pthread"; then 545 if test $gl_threads_api = none; then
218 if test "$gl_use_threads" = yes || test "$gl_use_threads" = solaris; then 546 if test "$gl_use_threads" = isoc && test "$gl_have_isoc_threads" = yes; then
219 gl_have_solaristhread= 547 gl_STDTHREADLIB_BODY
220 gl_save_LIBS="$LIBS" 548 LIBTHREAD=$LIBSTDTHREAD LTLIBTHREAD=$LIBSTDTHREAD
221 LIBS="$LIBS -lthread" 549 LIBMULTITHREAD=$LIBSTDTHREAD LTLIBMULTITHREAD=$LIBSTDTHREAD
222 AC_LINK_IFELSE( 550 gl_threads_api=isoc
223 [AC_LANG_PROGRAM( 551 AC_DEFINE([USE_ISOC_THREADS], [1],
224 [[ 552 [Define if the ISO C multithreading library can be used.])
225#include <thread.h>
226#include <synch.h>
227 ]],
228 [[thr_self();]])],
229 [gl_have_solaristhread=yes])
230 LIBS="$gl_save_LIBS"
231 if test -n "$gl_have_solaristhread"; then
232 gl_threads_api=solaris
233 LIBTHREAD=-lthread
234 LTLIBTHREAD=-lthread
235 LIBMULTITHREAD="$LIBTHREAD"
236 LTLIBMULTITHREAD="$LTLIBTHREAD"
237 AC_DEFINE([USE_SOLARIS_THREADS], [1],
238 [Define if the old Solaris multithreading library can be used.])
239 if case "$gl_cv_have_weak" in *yes) true;; *) false;; esac; then
240 AC_DEFINE([USE_SOLARIS_THREADS_WEAK], [1],
241 [Define if references to the old Solaris multithreading library should be made weak.])
242 LIBTHREAD=
243 LTLIBTHREAD=
244 fi
245 fi
246 fi 553 fi
247 fi 554 fi
248 if test "$gl_use_threads" = pth; then 555 if test $gl_threads_api = none; then
249 gl_save_CPPFLAGS="$CPPFLAGS"
250 AC_LIB_LINKFLAGS([pth])
251 gl_have_pth=
252 gl_save_LIBS="$LIBS"
253 LIBS="$LIBS $LIBPTH"
254 AC_LINK_IFELSE(
255 [AC_LANG_PROGRAM([[#include <pth.h>]], [[pth_self();]])],
256 [gl_have_pth=yes])
257 LIBS="$gl_save_LIBS"
258 if test -n "$gl_have_pth"; then
259 gl_threads_api=pth
260 LIBTHREAD="$LIBPTH"
261 LTLIBTHREAD="$LTLIBPTH"
262 LIBMULTITHREAD="$LIBTHREAD"
263 LTLIBMULTITHREAD="$LTLIBTHREAD"
264 AC_DEFINE([USE_PTH_THREADS], [1],
265 [Define if the GNU Pth multithreading library can be used.])
266 if test -n "$LIBMULTITHREAD" || test -n "$LTLIBMULTITHREAD"; then
267 if case "$gl_cv_have_weak" in *yes) true;; *) false;; esac; then
268 AC_DEFINE([USE_PTH_THREADS_WEAK], [1],
269 [Define if references to the GNU Pth multithreading library should be made weak.])
270 LIBTHREAD=
271 LTLIBTHREAD=
272 fi
273 fi
274 else
275 CPPFLAGS="$gl_save_CPPFLAGS"
276 fi
277 fi
278 if test -z "$gl_have_pthread"; then
279 case "$gl_use_threads" in 556 case "$gl_use_threads" in
280 yes | windows | win32) # The 'win32' is for backward compatibility. 557 yes | windows | win32) # The 'win32' is for backward compatibility.
281 if { case "$host_os" in 558 if { case "$host_os" in
@@ -317,6 +594,21 @@ AC_DEFUN([gl_DISABLE_THREADS], [
317]) 594])
318 595
319 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
320dnl Survey of platforms: 612dnl Survey of platforms:
321dnl 613dnl
322dnl Platform Available Compiler Supports test-lock 614dnl Platform Available Compiler Supports test-lock
@@ -324,7 +616,11 @@ dnl flavours option weak result
324dnl --------------- --------- --------- -------- --------- 616dnl --------------- --------- --------- -------- ---------
325dnl Linux 2.4/glibc posix -lpthread Y OK 617dnl Linux 2.4/glibc posix -lpthread Y OK
326dnl 618dnl
327dnl GNU Hurd/glibc posix 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
328dnl 624dnl
329dnl FreeBSD 5.3 posix -lc_r Y 625dnl FreeBSD 5.3 posix -lc_r Y
330dnl posix -lkse ? Y 626dnl posix -lkse ? Y
@@ -344,7 +640,6 @@ dnl
344dnl Mac OS X 10.[123] posix -lpthread Y OK 640dnl Mac OS X 10.[123] posix -lpthread Y OK
345dnl 641dnl
346dnl Solaris 7,8,9 posix -lpthread Y Sol 7,8: 0.0; Sol 9: OK 642dnl Solaris 7,8,9 posix -lpthread Y Sol 7,8: 0.0; Sol 9: OK
347dnl solaris -lthread Y Sol 7,8: 0.0; Sol 9: OK
348dnl 643dnl
349dnl HP-UX 11 posix -lpthread N (cc) OK 644dnl HP-UX 11 posix -lpthread N (cc) OK
350dnl Y (gcc) 645dnl Y (gcc)
@@ -358,8 +653,6 @@ dnl -lpthread (gcc) Y
358dnl 653dnl
359dnl Cygwin posix -lpthread Y OK 654dnl Cygwin posix -lpthread Y OK
360dnl 655dnl
361dnl Any of the above pth -lpth 0.0
362dnl
363dnl Mingw windows N OK 656dnl Mingw windows N OK
364dnl 657dnl
365dnl BeOS 5 -- 658dnl BeOS 5 --