aboutsummaryrefslogtreecommitdiff
path: root/m4/threadlib.m4
diff options
context:
space:
mode:
Diffstat (limited to 'm4/threadlib.m4')
-rw-r--r--m4/threadlib.m4633
1 files changed, 433 insertions, 200 deletions
diff --git a/m4/threadlib.m4 b/m4/threadlib.m4
index b43534ea..20b383a8 100644
--- a/m4/threadlib.m4
+++ b/m4/threadlib.m4
@@ -1,11 +1,351 @@
1# threadlib.m4 serial 11 (gettext-0.18.2) 1# threadlib.m4 serial 29
2dnl Copyright (C) 2005-2016 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 [gl_cv_have_weak=no
88 dnl First, test whether the compiler accepts it syntactically.
89 AC_LINK_IFELSE(
90 [AC_LANG_PROGRAM(
91 [[extern void xyzzy ();
92#pragma weak xyzzy]],
93 [[xyzzy();]])],
94 [gl_cv_have_weak=maybe])
95 if test $gl_cv_have_weak = maybe; then
96 dnl Second, test whether it actually works. On Cygwin 1.7.2, with
97 dnl gcc 4.3, symbols declared weak always evaluate to the address 0.
98 AC_RUN_IFELSE(
99 [AC_LANG_SOURCE([[
100#include <stdio.h>
101#pragma weak fputs
102int main ()
103{
104 return (fputs == NULL);
105}]])],
106 [gl_cv_have_weak=yes],
107 [gl_cv_have_weak=no],
108 [dnl When cross-compiling, assume that only ELF platforms support
109 dnl weak symbols.
110 AC_EGREP_CPP([Extensible Linking Format],
111 [#ifdef __ELF__
112 Extensible Linking Format
113 #endif
114 ],
115 [gl_cv_have_weak="guessing yes"],
116 [gl_cv_have_weak="guessing no"])
117 ])
118 fi
119 dnl But when linking statically, weak symbols don't work.
120 case " $LDFLAGS " in
121 *" -static "*) gl_cv_have_weak=no ;;
122 esac
123 dnl Test for a bug in FreeBSD 11: A link error occurs when using a weak
124 dnl symbol and linking against a shared library that has a dependency on
125 dnl the shared library that defines the symbol.
126 case "$gl_cv_have_weak" in
127 *yes)
128 case "$host_os" in
129 freebsd* | dragonfly*)
130 : > conftest1.c
131 $CC $CPPFLAGS $CFLAGS $LDFLAGS -fPIC -shared -o libempty.so conftest1.c -lpthread >&AS_MESSAGE_LOG_FD 2>&1
132 cat <<EOF > conftest2.c
133#include <pthread.h>
134#pragma weak pthread_mutexattr_gettype
135int main ()
136{
137 return (pthread_mutexattr_gettype != NULL);
138}
139EOF
140 $CC $CPPFLAGS $CFLAGS $LDFLAGS -o conftest conftest2.c libempty.so >&AS_MESSAGE_LOG_FD 2>&1 \
141 || gl_cv_have_weak=no
142 rm -f conftest1.c libempty.so conftest2.c conftest
143 ;;
144 esac
145 ;;
146 esac
147 ])
148 case "$gl_cv_have_weak" in
149 *yes)
150 AC_DEFINE([HAVE_WEAK_SYMBOLS], [1],
151 [Define to 1 if the compiler and linker support weak declarations of symbols.])
152 ;;
153 esac
154])
155
156dnl ============================================================================
157dnl Macros for the POSIX API
158
159dnl gl_PTHREADLIB
160dnl -------------
161dnl Tests for the libraries needs for using the POSIX threads API.
162dnl Sets the variable LIBPTHREAD to the linker options for use in a Makefile.
163dnl Sets the variable LIBPMULTITHREAD, for programs that really need
164dnl multithread functionality. The difference between LIBPTHREAD and
165dnl LIBPMULTITHREAD is that on platforms supporting weak symbols, typically
166dnl LIBPTHREAD is empty whereas LIBPMULTITHREAD is not.
167dnl Sets the variable LIB_SCHED_YIELD to the linker options needed to use the
168dnl sched_yield() function.
169dnl Adds to CPPFLAGS the flag -D_REENTRANT or -D_THREAD_SAFE if needed for
170dnl multithread-safe programs.
171dnl Defines the C macro HAVE_PTHREAD_API if (at least parts of) the POSIX
172dnl threads API is available.
173
174dnl The guts of gl_PTHREADLIB. Needs to be expanded only once.
175
176AC_DEFUN([gl_PTHREADLIB_BODY],
177[
178 AC_REQUIRE([gl_ANYTHREADLIB_EARLY])
179 if test -z "$gl_pthreadlib_body_done"; then
180 gl_pthread_api=no
181 LIBPTHREAD=
182 LIBPMULTITHREAD=
183 # On OSF/1, the compiler needs the flag -pthread or -D_REENTRANT so that
184 # it groks <pthread.h>. It's added above, in gl_ANYTHREADLIB_EARLY.
185 AC_CHECK_HEADER([pthread.h],
186 [gl_have_pthread_h=yes], [gl_have_pthread_h=no])
187 if test "$gl_have_pthread_h" = yes; then
188 # Other possible tests:
189 # -lpthreads (FSU threads, PCthreads)
190 # -lgthreads
191 # Test whether both pthread_mutex_lock and pthread_mutexattr_init exist
192 # in libc. IRIX 6.5 has the first one in both libc and libpthread, but
193 # the second one only in libpthread, and lock.c needs it.
194 #
195 # If -pthread works, prefer it to -lpthread, since Ubuntu 14.04
196 # needs -pthread for some reason. See:
197 # https://lists.gnu.org/r/bug-gnulib/2014-09/msg00023.html
198 save_LIBS=$LIBS
199 for gl_pthread in '' '-pthread'; do
200 LIBS="$LIBS $gl_pthread"
201 AC_LINK_IFELSE(
202 [AC_LANG_PROGRAM(
203 [[#include <pthread.h>
204 pthread_mutex_t m;
205 pthread_mutexattr_t ma;
206 ]],
207 [[pthread_mutex_lock (&m);
208 pthread_mutexattr_init (&ma);]])],
209 [gl_pthread_api=yes
210 LIBPTHREAD=$gl_pthread
211 LIBPMULTITHREAD=$gl_pthread])
212 LIBS=$save_LIBS
213 test $gl_pthread_api = yes && break
214 done
215
216 # Test for libpthread by looking for pthread_kill. (Not pthread_self,
217 # since it is defined as a macro on OSF/1.)
218 if test $gl_pthread_api = yes && test -z "$LIBPTHREAD"; then
219 # The program links fine without libpthread. But it may actually
220 # need to link with libpthread in order to create multiple threads.
221 AC_CHECK_LIB([pthread], [pthread_kill],
222 [LIBPMULTITHREAD=-lpthread
223 # On Solaris and HP-UX, most pthread functions exist also in libc.
224 # Therefore pthread_in_use() needs to actually try to create a
225 # thread: pthread_create from libc will fail, whereas
226 # pthread_create will actually create a thread.
227 # On Solaris 10 or newer, this test is no longer needed, because
228 # libc contains the fully functional pthread functions.
229 case "$host_os" in
230 solaris | solaris2.[1-9] | solaris2.[1-9].* | hpux*)
231 AC_DEFINE([PTHREAD_IN_USE_DETECTION_HARD], [1],
232 [Define if the pthread_in_use() detection is hard.])
233 esac
234 ])
235 elif test $gl_pthread_api != yes; then
236 # Some library is needed. Try libpthread and libc_r.
237 AC_CHECK_LIB([pthread], [pthread_kill],
238 [gl_pthread_api=yes
239 LIBPTHREAD=-lpthread
240 LIBPMULTITHREAD=-lpthread])
241 if test $gl_pthread_api != yes; then
242 # For FreeBSD 4.
243 AC_CHECK_LIB([c_r], [pthread_kill],
244 [gl_pthread_api=yes
245 LIBPTHREAD=-lc_r
246 LIBPMULTITHREAD=-lc_r])
247 fi
248 fi
249 fi
250 AC_MSG_CHECKING([whether POSIX threads API is available])
251 AC_MSG_RESULT([$gl_pthread_api])
252 AC_SUBST([LIBPTHREAD])
253 AC_SUBST([LIBPMULTITHREAD])
254 if test $gl_pthread_api = yes; then
255 AC_DEFINE([HAVE_PTHREAD_API], [1],
256 [Define if you have the <pthread.h> header and the POSIX threads API.])
257 fi
258
259 dnl On some systems, sched_yield is in librt, rather than in libpthread.
260 AC_LINK_IFELSE(
261 [AC_LANG_PROGRAM(
262 [[#include <sched.h>]],
263 [[sched_yield ();]])],
264 [LIB_SCHED_YIELD=
265 ],
266 [dnl Solaris 7...10 has sched_yield in librt, not in libpthread or libc.
267 AC_CHECK_LIB([rt], [sched_yield], [LIB_SCHED_YIELD=-lrt],
268 [dnl Solaris 2.5.1, 2.6 has sched_yield in libposix4, not librt.
269 AC_CHECK_LIB([posix4], [sched_yield], [LIB_SCHED_YIELD=-lposix4])])
270 ])
271 AC_SUBST([LIB_SCHED_YIELD])
272
273 gl_pthreadlib_body_done=done
274 fi
275])
276
277AC_DEFUN([gl_PTHREADLIB],
278[
279 AC_REQUIRE([gl_ANYTHREADLIB_EARLY])
280 gl_PTHREADLIB_BODY
281])
282
283dnl ============================================================================
284dnl Macros for the ISO C API
285
286dnl gl_STDTHREADLIB
287dnl ---------------
288dnl Tests for the libraries needs for using the ISO C threads API.
289dnl Sets the variable LIBSTDTHREAD to the linker options for use in a Makefile.
290dnl Adds to CPPFLAGS the flag -D_REENTRANT or -D_THREAD_SAFE if needed for
291dnl multithread-safe programs.
292dnl Defines the C macro HAVE_THREADS_H if (at least parts of) the ISO C threads
293dnl API is available.
294
295dnl The guts of gl_STDTHREADLIB. Needs to be expanded only once.
296
297AC_DEFUN([gl_STDTHREADLIB_BODY],
298[
299 AC_REQUIRE([gl_ANYTHREADLIB_EARLY])
300 AC_REQUIRE([AC_CANONICAL_HOST])
301 if test -z "$gl_stdthreadlib_body_done"; then
302 AC_CHECK_HEADERS_ONCE([threads.h])
303
304 case "$host_os" in
305 mingw*)
306 LIBSTDTHREAD=
307 ;;
308 *)
309 gl_PTHREADLIB_BODY
310 if test $ac_cv_header_threads_h = yes; then
311 dnl glibc >= 2.29 has thrd_create in libpthread.
312 dnl FreeBSD >= 10 has thrd_create in libstdthreads; this library depends
313 dnl on libpthread (for the symbol 'pthread_mutexattr_gettype').
314 dnl AIX >= 7.1 and Solaris >= 11.4 have thrd_create in libc.
315 AC_CHECK_FUNCS([thrd_create])
316 if test $ac_cv_func_thrd_create = yes; then
317 LIBSTDTHREAD=
318 else
319 AC_CHECK_LIB([stdthreads], [thrd_create], [
320 LIBSTDTHREAD='-lstdthreads -lpthread'
321 ], [
322 dnl Guess that thrd_create is in libpthread.
323 LIBSTDTHREAD="$LIBPMULTITHREAD"
324 ])
325 fi
326 else
327 dnl Libraries needed by thrd.c, mtx.c, cnd.c, tss.c.
328 LIBSTDTHREAD="$LIBPMULTITHREAD $LIB_SCHED_YIELD"
329 fi
330 ;;
331 esac
332 AC_SUBST([LIBSTDTHREAD])
333
334 AC_MSG_CHECKING([whether ISO C threads API is available])
335 AC_MSG_RESULT([$ac_cv_header_threads_h])
336 gl_stdthreadlib_body_done=done
337 fi
338])
339
340AC_DEFUN([gl_STDTHREADLIB],
341[
342 AC_REQUIRE([gl_ANYTHREADLIB_EARLY])
343 gl_STDTHREADLIB_BODY
344])
345
346dnl ============================================================================
347dnl Macros for the Gnulib API
348
9dnl gl_THREADLIB 349dnl gl_THREADLIB
10dnl ------------ 350dnl ------------
11dnl Tests for a multithreading library to be used. 351dnl Tests for a multithreading library to be used.
@@ -14,8 +354,13 @@ 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 354dnl 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 355dnl can change the choice through the options --enable-threads=choice or
16dnl --disable-threads. 356dnl --disable-threads.
17dnl Defines at most one of the macros USE_POSIX_THREADS, USE_SOLARIS_THREADS, 357dnl Defines at most one of the macros USE_ISOC_THREADS, USE_POSIX_THREADS,
18dnl USE_PTH_THREADS, USE_WINDOWS_THREADS 358dnl USE_ISOC_AND_POSIX_THREADS, USE_WINDOWS_THREADS.
359dnl The choice --enable-threads=isoc+posix is available only on platforms that
360dnl have both the ISO C and the POSIX threads APIs. It has the effect of using
361dnl the ISO C API for most things and the POSIX API only for creating and
362dnl controlling threads (because there is no equivalent to pthread_atfork in
363dnl the ISO C API).
19dnl Sets the variables LIBTHREAD and LTLIBTHREAD to the linker options for use 364dnl 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 365dnl in a Makefile (LIBTHREAD for use without libtool, LTLIBTHREAD for use with
21dnl libtool). 366dnl libtool).
@@ -25,6 +370,9 @@ dnl between LIBTHREAD and LIBMULTITHREAD is that on platforms supporting weak
25dnl symbols, typically LIBTHREAD is empty whereas LIBMULTITHREAD is not. 370dnl symbols, typically LIBTHREAD is empty whereas LIBMULTITHREAD is not.
26dnl Adds to CPPFLAGS the flag -D_REENTRANT or -D_THREAD_SAFE if needed for 371dnl Adds to CPPFLAGS the flag -D_REENTRANT or -D_THREAD_SAFE if needed for
27dnl multithread-safe programs. 372dnl multithread-safe programs.
373dnl Since support for GNU pth was removed, $LTLIBTHREAD and $LIBTHREAD have the
374dnl same value, and similarly $LTLIBMULTITHREAD and $LIBMULTITHREAD have the
375dnl same value. Only system libraries are needed.
28 376
29AC_DEFUN([gl_THREADLIB_EARLY], 377AC_DEFUN([gl_THREADLIB_EARLY],
30[ 378[
@@ -43,18 +391,15 @@ AC_DEFUN([gl_THREADLIB_EARLY_BODY],
43 391
44 AC_REQUIRE([AC_CANONICAL_HOST]) 392 AC_REQUIRE([AC_CANONICAL_HOST])
45 dnl _GNU_SOURCE is needed for pthread_rwlock_t on glibc systems. 393 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 394 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. 395 dnl Check for multithreading.
52 m4_ifdef([gl_THREADLIB_DEFAULT_NO], 396 m4_ifdef([gl_THREADLIB_DEFAULT_NO],
53 [m4_divert_text([DEFAULTS], [gl_use_threads_default=no])], 397 [m4_divert_text([DEFAULTS], [gl_use_threads_default=no])],
54 [m4_divert_text([DEFAULTS], [gl_use_threads_default=])]) 398 [m4_divert_text([DEFAULTS], [gl_use_threads_default=])])
399 m4_divert_text([DEFAULTS], [gl_use_winpthreads_default=])
55 AC_ARG_ENABLE([threads], 400 AC_ARG_ENABLE([threads],
56AC_HELP_STRING([--enable-threads={posix|solaris|pth|windows}], [specify multithreading API])m4_ifdef([gl_THREADLIB_DEFAULT_NO], [], [ 401AS_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])]), 402AS_HELP_STRING([--disable-threads], [build without multithread safety])]),
58 [gl_use_threads=$enableval], 403 [gl_use_threads=$enableval],
59 [if test -n "$gl_use_threads_default"; then 404 [if test -n "$gl_use_threads_default"; then
60 gl_use_threads="$gl_use_threads_default" 405 gl_use_threads="$gl_use_threads_default"
@@ -64,41 +409,35 @@ changequote(,)dnl
64 dnl Disable multithreading by default on OSF/1, because it interferes 409 dnl Disable multithreading by default on OSF/1, because it interferes
65 dnl with fork()/exec(): When msgexec is linked with -lpthread, its 410 dnl with fork()/exec(): When msgexec is linked with -lpthread, its
66 dnl child process gets an endless segmentation fault inside execvp(). 411 dnl child process gets an endless segmentation fault inside execvp().
412 osf*) gl_use_threads=no ;;
67 dnl Disable multithreading by default on Cygwin 1.5.x, because it has 413 dnl Disable multithreading by default on Cygwin 1.5.x, because it has
68 dnl bugs that lead to endless loops or crashes. See 414 dnl bugs that lead to endless loops or crashes. See
69 dnl <http://cygwin.com/ml/cygwin/2009-08/msg00283.html>. 415 dnl <https://cygwin.com/ml/cygwin/2009-08/msg00283.html>.
70 osf*) gl_use_threads=no ;;
71 cygwin*) 416 cygwin*)
72 case `uname -r` in 417 case `uname -r` in
73 1.[0-5].*) gl_use_threads=no ;; 418 1.[0-5].*) gl_use_threads=no ;;
74 *) gl_use_threads=yes ;; 419 *) gl_use_threads=yes ;;
75 esac 420 esac
76 ;; 421 ;;
422 dnl Obey gl_AVOID_WINPTHREAD on mingw.
423 mingw*)
424 case "$gl_use_winpthreads_default" in
425 yes) gl_use_threads=posix ;;
426 no) gl_use_threads=windows ;;
427 *) gl_use_threads=yes ;;
428 esac
429 ;;
77 *) gl_use_threads=yes ;; 430 *) gl_use_threads=yes ;;
78 esac 431 esac
79changequote([,])dnl 432changequote([,])dnl
80 fi 433 fi
81 ]) 434 ])
82 if test "$gl_use_threads" = yes || test "$gl_use_threads" = posix; then 435 if test "$gl_use_threads" = yes \
83 # For using <pthread.h>: 436 || test "$gl_use_threads" = isoc \
84 case "$host_os" in 437 || test "$gl_use_threads" = posix \
85 osf*) 438 || test "$gl_use_threads" = isoc+posix; then
86 # On OSF/1, the compiler needs the flag -D_REENTRANT so that it 439 # For using <threads.h> or <pthread.h>:
87 # groks <pthread.h>. cc also understands the flag -pthread, but 440 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 441 fi
103]) 442])
104 443
@@ -114,108 +453,31 @@ AC_DEFUN([gl_THREADLIB_BODY],
114 LTLIBMULTITHREAD= 453 LTLIBMULTITHREAD=
115 if test "$gl_use_threads" != no; then 454 if test "$gl_use_threads" != no; then
116 dnl Check whether the compiler and linker support weak declarations. 455 dnl Check whether the compiler and linker support weak declarations.
117 AC_CACHE_CHECK([whether imported symbols can be declared weak], 456 gl_WEAK_SYMBOLS
118 [gl_cv_have_weak], 457 if case "$gl_cv_have_weak" in *yes) true;; *) false;; esac; then
119 [gl_cv_have_weak=no 458 dnl If we use weak symbols to implement pthread_in_use / pth_in_use /
120 dnl First, test whether the compiler accepts it syntactically. 459 dnl thread_in_use, we also need to test whether the ISO C 11 thrd_create
121 AC_LINK_IFELSE( 460 dnl facility is in use.
122 [AC_LANG_PROGRAM( 461 AC_CHECK_HEADERS_ONCE([threads.h])
123 [[extern void xyzzy (); 462 :
124#pragma weak xyzzy]], 463 fi
125 [[xyzzy();]])], 464 if test "$gl_use_threads" = isoc || test "$gl_use_threads" = isoc+posix; then
126 [gl_cv_have_weak=maybe]) 465 AC_CHECK_HEADERS_ONCE([threads.h])
127 if test $gl_cv_have_weak = maybe; then 466 gl_have_isoc_threads="$ac_cv_header_threads_h"
128 dnl Second, test whether it actually works. On Cygwin 1.7.2, with 467 fi
129 dnl gcc 4.3, symbols declared weak always evaluate to the address 0. 468 if test "$gl_use_threads" = yes \
130 AC_RUN_IFELSE( 469 || test "$gl_use_threads" = posix \
131 [AC_LANG_SOURCE([[ 470 || test "$gl_use_threads" = isoc+posix; then
132#include <stdio.h> 471 gl_PTHREADLIB_BODY
133#pragma weak fputs 472 LIBTHREAD=$LIBPTHREAD LTLIBTHREAD=$LIBPTHREAD
134int main () 473 LIBMULTITHREAD=$LIBPMULTITHREAD LTLIBMULTITHREAD=$LIBPMULTITHREAD
135{ 474 if test $gl_pthread_api = yes; then
136 return (fputs == NULL); 475 if test "$gl_use_threads" = isoc+posix && test "$gl_have_isoc_threads" = yes; then
137}]])], 476 gl_threads_api='isoc+posix'
138 [gl_cv_have_weak=yes], 477 AC_DEFINE([USE_ISOC_AND_POSIX_THREADS], [1],
139 [gl_cv_have_weak=no], 478 [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 479 LIBTHREAD= LTLIBTHREAD=
141 dnl weak symbols. 480 else
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 #
166 # If -pthread works, prefer it to -lpthread, since Ubuntu 14.04
167 # needs -pthread for some reason. See:
168 # http://lists.gnu.org/archive/html/bug-gnulib/2014-09/msg00023.html
169 save_LIBS=$LIBS
170 for gl_pthread in '' '-pthread'; do
171 LIBS="$LIBS $gl_pthread"
172 AC_LINK_IFELSE(
173 [AC_LANG_PROGRAM(
174 [[#include <pthread.h>
175 pthread_mutex_t m;
176 pthread_mutexattr_t ma;
177 ]],
178 [[pthread_mutex_lock (&m);
179 pthread_mutexattr_init (&ma);]])],
180 [gl_have_pthread=yes
181 LIBTHREAD=$gl_pthread LTLIBTHREAD=$gl_pthread
182 LIBMULTITHREAD=$gl_pthread LTLIBMULTITHREAD=$gl_pthread])
183 LIBS=$save_LIBS
184 test -n "$gl_have_pthread" && break
185 done
186
187 # Test for libpthread by looking for pthread_kill. (Not pthread_self,
188 # since it is defined as a macro on OSF/1.)
189 if test -n "$gl_have_pthread" && test -z "$LIBTHREAD"; then
190 # The program links fine without libpthread. But it may actually
191 # need to link with libpthread in order to create multiple threads.
192 AC_CHECK_LIB([pthread], [pthread_kill],
193 [LIBMULTITHREAD=-lpthread LTLIBMULTITHREAD=-lpthread
194 # On Solaris and HP-UX, most pthread functions exist also in libc.
195 # Therefore pthread_in_use() needs to actually try to create a
196 # thread: pthread_create from libc will fail, whereas
197 # pthread_create will actually create a thread.
198 case "$host_os" in
199 solaris* | hpux*)
200 AC_DEFINE([PTHREAD_IN_USE_DETECTION_HARD], [1],
201 [Define if the pthread_in_use() detection is hard.])
202 esac
203 ])
204 elif test -z "$gl_have_pthread"; then
205 # Some library is needed. Try libpthread and libc_r.
206 AC_CHECK_LIB([pthread], [pthread_kill],
207 [gl_have_pthread=yes
208 LIBTHREAD=-lpthread LTLIBTHREAD=-lpthread
209 LIBMULTITHREAD=-lpthread LTLIBMULTITHREAD=-lpthread])
210 if test -z "$gl_have_pthread"; then
211 # For FreeBSD 4.
212 AC_CHECK_LIB([c_r], [pthread_kill],
213 [gl_have_pthread=yes
214 LIBTHREAD=-lc_r LTLIBTHREAD=-lc_r
215 LIBMULTITHREAD=-lc_r LTLIBMULTITHREAD=-lc_r])
216 fi
217 fi
218 if test -n "$gl_have_pthread"; then
219 gl_threads_api=posix 481 gl_threads_api=posix
220 AC_DEFINE([USE_POSIX_THREADS], [1], 482 AC_DEFINE([USE_POSIX_THREADS], [1],
221 [Define if the POSIX multithreading library can be used.]) 483 [Define if the POSIX multithreading library can be used.])
@@ -223,75 +485,34 @@ int main ()
223 if case "$gl_cv_have_weak" in *yes) true;; *) false;; esac; then 485 if case "$gl_cv_have_weak" in *yes) true;; *) false;; esac; then
224 AC_DEFINE([USE_POSIX_THREADS_WEAK], [1], 486 AC_DEFINE([USE_POSIX_THREADS_WEAK], [1],
225 [Define if references to the POSIX multithreading library should be made weak.]) 487 [Define if references to the POSIX multithreading library should be made weak.])
226 LIBTHREAD= 488 LIBTHREAD= LTLIBTHREAD=
227 LTLIBTHREAD= 489 else
490 case "$host_os" in
491 freebsd* | dragonfly*)
492 if test "x$LIBTHREAD" != "x$LIBMULTITHREAD"; then
493 dnl If weak symbols can't tell whether pthread_create(), pthread_key_create()
494 dnl etc. will succeed, we need a runtime test.
495 AC_DEFINE([PTHREAD_IN_USE_DETECTION_HARD], [1],
496 [Define if the pthread_in_use() detection is hard.])
497 fi
498 ;;
499 esac
228 fi 500 fi
229 fi 501 fi
230 fi 502 fi
231 fi 503 fi
232 fi 504 fi
233 if test -z "$gl_have_pthread"; then 505 if test $gl_threads_api = none; then
234 if test "$gl_use_threads" = yes || test "$gl_use_threads" = solaris; then 506 if test "$gl_use_threads" = isoc && test "$gl_have_isoc_threads" = yes; then
235 gl_have_solaristhread= 507 gl_STDTHREADLIB_BODY
236 gl_save_LIBS="$LIBS" 508 LIBTHREAD=$LIBSTDTHREAD LTLIBTHREAD=$LIBSTDTHREAD
237 LIBS="$LIBS -lthread" 509 LIBMULTITHREAD=$LIBSTDTHREAD LTLIBMULTITHREAD=$LIBSTDTHREAD
238 AC_LINK_IFELSE( 510 gl_threads_api=isoc
239 [AC_LANG_PROGRAM( 511 AC_DEFINE([USE_ISOC_THREADS], [1],
240 [[ 512 [Define if the ISO C multithreading library can be used.])
241#include <thread.h>
242#include <synch.h>
243 ]],
244 [[thr_self();]])],
245 [gl_have_solaristhread=yes])
246 LIBS="$gl_save_LIBS"
247 if test -n "$gl_have_solaristhread"; then
248 gl_threads_api=solaris
249 LIBTHREAD=-lthread
250 LTLIBTHREAD=-lthread
251 LIBMULTITHREAD="$LIBTHREAD"
252 LTLIBMULTITHREAD="$LTLIBTHREAD"
253 AC_DEFINE([USE_SOLARIS_THREADS], [1],
254 [Define if the old Solaris multithreading library can be used.])
255 if case "$gl_cv_have_weak" in *yes) true;; *) false;; esac; then
256 AC_DEFINE([USE_SOLARIS_THREADS_WEAK], [1],
257 [Define if references to the old Solaris multithreading library should be made weak.])
258 LIBTHREAD=
259 LTLIBTHREAD=
260 fi
261 fi
262 fi
263 fi
264 if test "$gl_use_threads" = pth; then
265 gl_save_CPPFLAGS="$CPPFLAGS"
266 AC_LIB_LINKFLAGS([pth])
267 gl_have_pth=
268 gl_save_LIBS="$LIBS"
269 LIBS="$LIBS $LIBPTH"
270 AC_LINK_IFELSE(
271 [AC_LANG_PROGRAM([[#include <pth.h>]], [[pth_self();]])],
272 [gl_have_pth=yes])
273 LIBS="$gl_save_LIBS"
274 if test -n "$gl_have_pth"; then
275 gl_threads_api=pth
276 LIBTHREAD="$LIBPTH"
277 LTLIBTHREAD="$LTLIBPTH"
278 LIBMULTITHREAD="$LIBTHREAD"
279 LTLIBMULTITHREAD="$LTLIBTHREAD"
280 AC_DEFINE([USE_PTH_THREADS], [1],
281 [Define if the GNU Pth multithreading library can be used.])
282 if test -n "$LIBMULTITHREAD" || test -n "$LTLIBMULTITHREAD"; then
283 if case "$gl_cv_have_weak" in *yes) true;; *) false;; esac; then
284 AC_DEFINE([USE_PTH_THREADS_WEAK], [1],
285 [Define if references to the GNU Pth multithreading library should be made weak.])
286 LIBTHREAD=
287 LTLIBTHREAD=
288 fi
289 fi
290 else
291 CPPFLAGS="$gl_save_CPPFLAGS"
292 fi 513 fi
293 fi 514 fi
294 if test -z "$gl_have_pthread"; then 515 if test $gl_threads_api = none; then
295 case "$gl_use_threads" in 516 case "$gl_use_threads" in
296 yes | windows | win32) # The 'win32' is for backward compatibility. 517 yes | windows | win32) # The 'win32' is for backward compatibility.
297 if { case "$host_os" in 518 if { case "$host_os" in
@@ -333,6 +554,21 @@ AC_DEFUN([gl_DISABLE_THREADS], [
333]) 554])
334 555
335 556
557dnl gl_AVOID_WINPTHREAD
558dnl -------------------
559dnl Sets the gl_THREADLIB default so that on mingw, a dependency to the
560dnl libwinpthread DLL (mingw-w64 winpthreads library) is avoided.
561dnl The user can still override it at installation time, by using the
562dnl configure option '--enable-threads'.
563
564AC_DEFUN([gl_AVOID_WINPTHREAD], [
565 m4_divert_text([INIT_PREPARE], [gl_use_winpthreads_default=no])
566])
567
568
569dnl ============================================================================
570
571
336dnl Survey of platforms: 572dnl Survey of platforms:
337dnl 573dnl
338dnl Platform Available Compiler Supports test-lock 574dnl Platform Available Compiler Supports test-lock
@@ -362,7 +598,6 @@ dnl
362dnl Mac OS X 10.[123] posix -lpthread Y OK 598dnl Mac OS X 10.[123] posix -lpthread Y OK
363dnl 599dnl
364dnl Solaris 7,8,9 posix -lpthread Y Sol 7,8: 0.0; Sol 9: OK 600dnl Solaris 7,8,9 posix -lpthread Y Sol 7,8: 0.0; Sol 9: OK
365dnl solaris -lthread Y Sol 7,8: 0.0; Sol 9: OK
366dnl 601dnl
367dnl HP-UX 11 posix -lpthread N (cc) OK 602dnl HP-UX 11 posix -lpthread N (cc) OK
368dnl Y (gcc) 603dnl Y (gcc)
@@ -376,8 +611,6 @@ dnl -lpthread (gcc) Y
376dnl 611dnl
377dnl Cygwin posix -lpthread Y OK 612dnl Cygwin posix -lpthread Y OK
378dnl 613dnl
379dnl Any of the above pth -lpth 0.0
380dnl
381dnl Mingw windows N OK 614dnl Mingw windows N OK
382dnl 615dnl
383dnl BeOS 5 -- 616dnl BeOS 5 --
generated by cgit v1.2.3 (git 2.39.1) at 2024-05-20 15:59:58 +0000