threadlib.m4

Last change on this file was 3529, checked in by bird, 3 years ago
Imported grep 3.7 from grep-3.7.tar.gz (sha256: c22b0cf2d4f6bbe599c902387e8058990e1eee99aef333a203829e5fd3dbb342), applying minimal auto-props.
Property svn:eol-style set to `LF`
File size: 23.8 KB

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

Note: See TracBrowser for help on using the repository browser.

source: kBuild/vendor/grep/current/m4/threadlib.m4

Download in other formats: