threadlib.m4@ 3627

Last change on this file since 3627 was 2595, checked in by bird, 13 years ago
gnu grep version 2.12 (grep-2.12.tar.xz, md5sum=8d2f0346d08b13c18afb81f0e8aa1e2f)
File size: 14.1 KB

Line
1	# threadlib.m4 serial 9 (gettext-0.18.2)
2	dnl Copyright (C) 2005-2012 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	dnl gl_THREADLIB
10	dnl ------------
11	dnl Tests for a multithreading library to be used.
12	dnl If the configure.ac contains a definition of the gl_THREADLIB_DEFAULT_NO
13	dnl (it must be placed before the invocation of gl_THREADLIB_EARLY!), then the
14	dnl default is 'no', otherwise it is system dependent. In both cases, the user
15	dnl can change the choice through the options --enable-threads=choice or
16	dnl --disable-threads.
17	dnl Defines at most one of the macros USE_POSIX_THREADS, USE_SOLARIS_THREADS,
18	dnl USE_PTH_THREADS, USE_WINDOWS_THREADS
19	dnl Sets the variables LIBTHREAD and LTLIBTHREAD to the linker options for use
20	dnl in a Makefile (LIBTHREAD for use without libtool, LTLIBTHREAD for use with
21	dnl libtool).
22	dnl Sets the variables LIBMULTITHREAD and LTLIBMULTITHREAD similarly, for
23	dnl programs that really need multithread functionality. The difference
24	dnl between LIBTHREAD and LIBMULTITHREAD is that on platforms supporting weak
25	dnl symbols, typically LIBTHREAD="" whereas LIBMULTITHREAD="-lpthread".
26	dnl Adds to CPPFLAGS the flag -D_REENTRANT or -D_THREAD_SAFE if needed for
27	dnl multithread-safe programs.
28
29	AC_DEFUN([gl_THREADLIB_EARLY],
30	[
31	AC_REQUIRE([gl_THREADLIB_EARLY_BODY])
32	])
33
34	dnl The guts of gl_THREADLIB_EARLY. Needs to be expanded only once.
35
36	AC_DEFUN([gl_THREADLIB_EARLY_BODY],
37	[
38	dnl Ordering constraints: This macro modifies CPPFLAGS in a way that
39	dnl influences the result of the autoconf tests that test for *_unlocked
40	dnl declarations, on AIX 5 at least. Therefore it must come early.
41	AC_BEFORE([$0], [gl_FUNC_GLIBC_UNLOCKED_IO])dnl
42	AC_BEFORE([$0], [gl_ARGP])dnl
43
44	AC_REQUIRE([AC_CANONICAL_HOST])
45	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
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.
52	m4_ifdef([gl_THREADLIB_DEFAULT_NO],
53	[m4_divert_text([DEFAULTS], [gl_use_threads_default=no])],
54	[m4_divert_text([DEFAULTS], [gl_use_threads_default=])])
55	AC_ARG_ENABLE([threads],
56	AC_HELP_STRING([--enable-threads={posix\|solaris\|pth\|windows}], [specify multithreading API])m4_ifdef([gl_THREADLIB_DEFAULT_NO], [], [
57	AC_HELP_STRING([--disable-threads], [build without multithread safety])]),
58	[gl_use_threads=$enableval],
59	[if test -n "$gl_use_threads_default"; then
60	gl_use_threads="$gl_use_threads_default"
61	else
62	changequote(,)dnl
63	case "$host_os" in
64	dnl Disable multithreading by default on OSF/1, because it interferes
65	dnl with fork()/exec(): When msgexec is linked with -lpthread, its
66	dnl child process gets an endless segmentation fault inside execvp().
67	dnl Disable multithreading by default on Cygwin 1.5.x, because it has
68	dnl bugs that lead to endless loops or crashes. See
69	dnl <http://cygwin.com/ml/cygwin/2009-08/msg00283.html>.
70	osf*) gl_use_threads=no ;;
71	cygwin*)
72	case `uname -r` in
73	1.[0-5].*) gl_use_threads=no ;;
74	*) gl_use_threads=yes ;;
75	esac
76	;;
77	*) gl_use_threads=yes ;;
78	esac
79	changequote([,])dnl
80	fi
81	])
82	if test "$gl_use_threads" = yes \|\| test "$gl_use_threads" = posix; then
83	# For using <pthread.h>:
84	case "$host_os" in
85	osf*)
86	# On OSF/1, the compiler needs the flag -D_REENTRANT so that it
87	# groks <pthread.h>. cc also understands the flag -pthread, but
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
103	])
104
105	dnl The guts of gl_THREADLIB. Needs to be expanded only once.
106
107	AC_DEFUN([gl_THREADLIB_BODY],
108	[
109	AC_REQUIRE([gl_THREADLIB_EARLY_BODY])
110	gl_threads_api=none
111	LIBTHREAD=
112	LTLIBTHREAD=
113	LIBMULTITHREAD=
114	LTLIBMULTITHREAD=
115	if test "$gl_use_threads" != no; then
116	dnl Check whether the compiler and linker support weak declarations.
117	AC_CACHE_CHECK([whether imported symbols can be declared weak],
118	[gl_cv_have_weak],
119	[gl_cv_have_weak=no
120	dnl First, test whether the compiler accepts it syntactically.
121	AC_LINK_IFELSE(
122	[AC_LANG_PROGRAM(
123	[[extern void xyzzy ();
124	#pragma weak xyzzy]],
125	[[xyzzy();]])],
126	[gl_cv_have_weak=maybe])
127	if test $gl_cv_have_weak = maybe; then
128	dnl Second, test whether it actually works. On Cygwin 1.7.2, with
129	dnl gcc 4.3, symbols declared weak always evaluate to the address 0.
130	AC_RUN_IFELSE(
131	[AC_LANG_SOURCE([[
132	#include <stdio.h>
133	#pragma weak fputs
134	int main ()
135	{
136	return (fputs == NULL);
137	}]])],
138	[gl_cv_have_weak=yes],
139	[gl_cv_have_weak=no],
140	[dnl When cross-compiling, assume that only ELF platforms support
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
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
204	AC_DEFINE([USE_POSIX_THREADS], [1],
205	[Define if the POSIX multithreading library can be used.])
206	if test -n "$LIBMULTITHREAD" \|\| test -n "$LTLIBMULTITHREAD"; then
207	if case "$gl_cv_have_weak" in yes) true;; ) false;; esac; then
208	AC_DEFINE([USE_POSIX_THREADS_WEAK], [1],
209	[Define if references to the POSIX multithreading library should be made weak.])
210	LIBTHREAD=
211	LTLIBTHREAD=
212	fi
213	fi
214	fi
215	fi
216	fi
217	if test -z "$gl_have_pthread"; then
218	if test "$gl_use_threads" = yes \|\| test "$gl_use_threads" = solaris; then
219	gl_have_solaristhread=
220	gl_save_LIBS="$LIBS"
221	LIBS="$LIBS -lthread"
222	AC_LINK_IFELSE(
223	[AC_LANG_PROGRAM(
224	[[
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
247	fi
248	if test "$gl_use_threads" = pth; 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
280	yes \| windows \| win32) # The 'win32' is for backward compatibility.
281	if { case "$host_os" in
282	mingw*) true;;
283	*) false;;
284	esac
285	}; then
286	gl_threads_api=windows
287	AC_DEFINE([USE_WINDOWS_THREADS], [1],
288	[Define if the native Windows multithreading API can be used.])
289	fi
290	;;
291	esac
292	fi
293	fi
294	AC_MSG_CHECKING([for multithread API to use])
295	AC_MSG_RESULT([$gl_threads_api])
296	AC_SUBST([LIBTHREAD])
297	AC_SUBST([LTLIBTHREAD])
298	AC_SUBST([LIBMULTITHREAD])
299	AC_SUBST([LTLIBMULTITHREAD])
300	])
301
302	AC_DEFUN([gl_THREADLIB],
303	[
304	AC_REQUIRE([gl_THREADLIB_EARLY])
305	AC_REQUIRE([gl_THREADLIB_BODY])
306	])
307
308
309	dnl gl_DISABLE_THREADS
310	dnl ------------------
311	dnl Sets the gl_THREADLIB default so that threads are not used by default.
312	dnl The user can still override it at installation time, by using the
313	dnl configure option '--enable-threads'.
314
315	AC_DEFUN([gl_DISABLE_THREADS], [
316	m4_divert_text([INIT_PREPARE], [gl_use_threads_default=no])
317	])
318
319
320	dnl Survey of platforms:
321	dnl
322	dnl Platform Available Compiler Supports test-lock
323	dnl flavours option weak result
324	dnl --------------- --------- --------- -------- ---------
325	dnl Linux 2.4/glibc posix -lpthread Y OK
326	dnl
327	dnl GNU Hurd/glibc posix
328	dnl
329	dnl FreeBSD 5.3 posix -lc_r Y
330	dnl posix -lkse ? Y
331	dnl posix -lpthread ? Y
332	dnl posix -lthr Y
333	dnl
334	dnl FreeBSD 5.2 posix -lc_r Y
335	dnl posix -lkse Y
336	dnl posix -lthr Y
337	dnl
338	dnl FreeBSD 4.0,4.10 posix -lc_r Y OK
339	dnl
340	dnl NetBSD 1.6 --
341	dnl
342	dnl OpenBSD 3.4 posix -lpthread Y OK
343	dnl
344	dnl MacOS X 10.[123] posix -lpthread Y OK
345	dnl
346	dnl Solaris 7,8,9 posix -lpthread Y Sol 7,8: 0.0; Sol 9: OK
347	dnl solaris -lthread Y Sol 7,8: 0.0; Sol 9: OK
348	dnl
349	dnl HP-UX 11 posix -lpthread N (cc) OK
350	dnl Y (gcc)
351	dnl
352	dnl IRIX 6.5 posix -lpthread Y 0.5
353	dnl
354	dnl AIX 4.3,5.1 posix -lpthread N AIX 4: 0.5; AIX 5: OK
355	dnl
356	dnl OSF/1 4.0,5.1 posix -pthread (cc) N OK
357	dnl -lpthread (gcc) Y
358	dnl
359	dnl Cygwin posix -lpthread Y OK
360	dnl
361	dnl Any of the above pth -lpth 0.0
362	dnl
363	dnl Mingw windows N OK
364	dnl
365	dnl BeOS 5 --
366	dnl
367	dnl The test-lock result shows what happens if in test-lock.c EXPLICIT_YIELD is
368	dnl turned off:
369	dnl OK if all three tests terminate OK,
370	dnl 0.5 if the first test terminates OK but the second one loops endlessly,
371	dnl 0.0 if the first test already loops endlessly.

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

source: kBuild/vendor/grep/2.12/m4/threadlib.m4@ 3627

Download in other formats: