1 # threadlib.m4 serial 5 (gettext-0.18)
2 dnl Copyright (C) 2005-2010 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.
7 dnl From Bruno Haible.
9 dnl gl_THREADLIB
10 dnl ------------
11 dnl Tests for a multithreading library to be used.
12 dnl Defines at most one of the macros USE_POSIX_THREADS, USE_SOLARIS_THREADS,
13 dnl USE_PTH_THREADS, USE_WIN32_THREADS
14 dnl Sets the variables LIBTHREAD and LTLIBTHREAD to the linker options for use
15 dnl in a Makefile (LIBTHREAD for use without libtool, LTLIBTHREAD for use with
16 dnl libtool).
17 dnl Sets the variables LIBMULTITHREAD and LTLIBMULTITHREAD similarly, for
18 dnl programs that really need multithread functionality. The difference
19 dnl between LIBTHREAD and LIBMULTITHREAD is that on platforms supporting weak
20 dnl symbols, typically LIBTHREAD="" whereas LIBMULTITHREAD="-lpthread".
21 dnl Adds to CPPFLAGS the flag -D_REENTRANT or -D_THREAD_SAFE if needed for
22 dnl multithread-safe programs.
24 AC_DEFUN([gl_THREADLIB_EARLY],
25 [
26 AC_REQUIRE([gl_THREADLIB_EARLY_BODY])
27 ])
29 dnl The guts of gl_THREADLIB_EARLY. Needs to be expanded only once.
31 AC_DEFUN([gl_THREADLIB_EARLY_BODY],
32 [
33 dnl Ordering constraints: This macro modifies CPPFLAGS in a way that
34 dnl influences the result of the autoconf tests that test for *_unlocked
35 dnl declarations, on AIX 5 at least. Therefore it must come early.
36 AC_BEFORE([$0], [gl_FUNC_GLIBC_UNLOCKED_IO])dnl
37 AC_BEFORE([$0], [gl_ARGP])dnl
39 AC_REQUIRE([AC_CANONICAL_HOST])
40 dnl _GNU_SOURCE is needed for pthread_rwlock_t on glibc systems.
41 dnl AC_USE_SYSTEM_EXTENSIONS was introduced in autoconf 2.60 and obsoletes
42 dnl AC_GNU_SOURCE.
43 m4_ifdef([AC_USE_SYSTEM_EXTENSIONS],
44 [AC_REQUIRE([AC_USE_SYSTEM_EXTENSIONS])],
45 [AC_REQUIRE([AC_GNU_SOURCE])])
46 dnl Check for multithreading.
47 m4_divert_text([DEFAULTS], [gl_use_threads_default=])
48 AC_ARG_ENABLE([threads],
49 AC_HELP_STRING([--enable-threads={posix|solaris|pth|win32}], [specify multithreading API])
50 AC_HELP_STRING([--disable-threads], [build without multithread safety]),
51 [gl_use_threads=$enableval],
52 [if test -n "$gl_use_threads_default"; then
53 gl_use_threads="$gl_use_threads_default"
54 else
55 changequote(,)dnl
56 case "$host_os" in
57 dnl Disable multithreading by default on OSF/1, because it interferes
58 dnl with fork()/exec(): When msgexec is linked with -lpthread, its
59 dnl child process gets an endless segmentation fault inside execvp().
60 dnl Disable multithreading by default on Cygwin 1.5.x, because it has
61 dnl bugs that lead to endless loops or crashes. See
62 dnl <http://cygwin.com/ml/cygwin/2009-08/msg00283.html>.
63 osf*) gl_use_threads=no ;;
64 cygwin*)
65 case `uname -r` in
66 1.[0-5].*) gl_use_threads=no ;;
67 *) gl_use_threads=yes ;;
68 esac
69 ;;
70 *) gl_use_threads=yes ;;
71 esac
72 changequote([,])dnl
73 fi
74 ])
75 if test "$gl_use_threads" = yes || test "$gl_use_threads" = posix; then
76 # For using <pthread.h>:
77 case "$host_os" in
78 osf*)
79 # On OSF/1, the compiler needs the flag -D_REENTRANT so that it
80 # groks <pthread.h>. cc also understands the flag -pthread, but
81 # we don't use it because 1. gcc-2.95 doesn't understand -pthread,
82 # 2. putting a flag into CPPFLAGS that has an effect on the linker
83 # causes the AC_TRY_LINK test below to succeed unexpectedly,
84 # leading to wrong values of LIBTHREAD and LTLIBTHREAD.
85 CPPFLAGS="$CPPFLAGS -D_REENTRANT"
86 ;;
87 esac
88 # Some systems optimize for single-threaded programs by default, and
89 # need special flags to disable these optimizations. For example, the
90 # definition of 'errno' in <errno.h>.
91 case "$host_os" in
92 aix* | freebsd*) CPPFLAGS="$CPPFLAGS -D_THREAD_SAFE" ;;
93 solaris*) CPPFLAGS="$CPPFLAGS -D_REENTRANT" ;;
94 esac
95 fi
96 ])
98 dnl The guts of gl_THREADLIB. Needs to be expanded only once.
100 AC_DEFUN([gl_THREADLIB_BODY],
101 [
102 AC_REQUIRE([gl_THREADLIB_EARLY_BODY])
103 gl_threads_api=none
104 LIBTHREAD=
105 LTLIBTHREAD=
106 LIBMULTITHREAD=
107 LTLIBMULTITHREAD=
108 if test "$gl_use_threads" != no; then
109 dnl Check whether the compiler and linker support weak declarations.
110 AC_CACHE_CHECK([whether imported symbols can be declared weak],
111 [gl_cv_have_weak],
112 [gl_cv_have_weak=no
113 dnl First, test whether the compiler accepts it syntactically.
114 AC_TRY_LINK([extern void xyzzy ();
115 #pragma weak xyzzy], [xyzzy();], [gl_cv_have_weak=maybe])
116 if test $gl_cv_have_weak = maybe; then
117 dnl Second, test whether it actually works. On Cygwin 1.7.2, with
118 dnl gcc 4.3, symbols declared weak always evaluate to the address 0.
119 AC_TRY_RUN([
120 #include <stdio.h>
121 #pragma weak fputs
122 int main ()
123 {
124 return (fputs == NULL);
125 }], [gl_cv_have_weak=yes], [gl_cv_have_weak=no],
126 [dnl When cross-compiling, assume that only ELF platforms support
127 dnl weak symbols.
128 AC_EGREP_CPP([Extensible Linking Format],
129 [#ifdef __ELF__
130 Extensible Linking Format
131 #endif
132 ],
133 [gl_cv_have_weak="guessing yes"],
134 [gl_cv_have_weak="guessing no"])
135 ])
136 fi
137 ])
138 if test "$gl_use_threads" = yes || test "$gl_use_threads" = posix; then
139 # On OSF/1, the compiler needs the flag -pthread or -D_REENTRANT so that
140 # it groks <pthread.h>. It's added above, in gl_THREADLIB_EARLY_BODY.
141 AC_CHECK_HEADER([pthread.h],
142 [gl_have_pthread_h=yes], [gl_have_pthread_h=no])
143 if test "$gl_have_pthread_h" = yes; then
144 # Other possible tests:
145 # -lpthreads (FSU threads, PCthreads)
146 # -lgthreads
147 gl_have_pthread=
148 # Test whether both pthread_mutex_lock and pthread_mutexattr_init exist
149 # in libc. IRIX 6.5 has the first one in both libc and libpthread, but
150 # the second one only in libpthread, and lock.c needs it.
151 AC_TRY_LINK([#include <pthread.h>],
152 [pthread_mutex_lock((pthread_mutex_t*)0);
153 pthread_mutexattr_init((pthread_mutexattr_t*)0);],
154 [gl_have_pthread=yes])
155 # Test for libpthread by looking for pthread_kill. (Not pthread_self,
156 # since it is defined as a macro on OSF/1.)
157 if test -n "$gl_have_pthread"; then
158 # The program links fine without libpthread. But it may actually
159 # need to link with libpthread in order to create multiple threads.
160 AC_CHECK_LIB([pthread], [pthread_kill],
161 [LIBMULTITHREAD=-lpthread LTLIBMULTITHREAD=-lpthread
162 # On Solaris and HP-UX, most pthread functions exist also in libc.
163 # Therefore pthread_in_use() needs to actually try to create a
164 # thread: pthread_create from libc will fail, whereas
165 # pthread_create will actually create a thread.
166 case "$host_os" in
167 solaris* | hpux*)
168 AC_DEFINE([PTHREAD_IN_USE_DETECTION_HARD], [1],
169 [Define if the pthread_in_use() detection is hard.])
170 esac
171 ])
172 else
173 # Some library is needed. Try libpthread and libc_r.
174 AC_CHECK_LIB([pthread], [pthread_kill],
175 [gl_have_pthread=yes
176 LIBTHREAD=-lpthread LTLIBTHREAD=-lpthread
177 LIBMULTITHREAD=-lpthread LTLIBMULTITHREAD=-lpthread])
178 if test -z "$gl_have_pthread"; then
179 # For FreeBSD 4.
180 AC_CHECK_LIB([c_r], [pthread_kill],
181 [gl_have_pthread=yes
182 LIBTHREAD=-lc_r LTLIBTHREAD=-lc_r
183 LIBMULTITHREAD=-lc_r LTLIBMULTITHREAD=-lc_r])
184 fi
185 fi
186 if test -n "$gl_have_pthread"; then
187 gl_threads_api=posix
188 AC_DEFINE([USE_POSIX_THREADS], [1],
189 [Define if the POSIX multithreading library can be used.])
190 if test -n "$LIBMULTITHREAD" || test -n "$LTLIBMULTITHREAD"; then
191 if case "$gl_cv_have_weak" in *yes) true;; *) false;; esac; then
192 AC_DEFINE([USE_POSIX_THREADS_WEAK], [1],
193 [Define if references to the POSIX multithreading library should be made weak.])
194 LIBTHREAD=
195 LTLIBTHREAD=
196 fi
197 fi
198 fi
199 fi
200 fi
201 if test -z "$gl_have_pthread"; then
202 if test "$gl_use_threads" = yes || test "$gl_use_threads" = solaris; then
203 gl_have_solaristhread=
204 gl_save_LIBS="$LIBS"
205 LIBS="$LIBS -lthread"
206 AC_TRY_LINK([#include <thread.h>
207 #include <synch.h>],
208 [thr_self();],
209 [gl_have_solaristhread=yes])
210 LIBS="$gl_save_LIBS"
211 if test -n "$gl_have_solaristhread"; then
212 gl_threads_api=solaris
213 LIBTHREAD=-lthread
214 LTLIBTHREAD=-lthread
215 LIBMULTITHREAD="$LIBTHREAD"
216 LTLIBMULTITHREAD="$LTLIBTHREAD"
217 AC_DEFINE([USE_SOLARIS_THREADS], [1],
218 [Define if the old Solaris multithreading library can be used.])
219 if case "$gl_cv_have_weak" in *yes) true;; *) false;; esac; then
220 AC_DEFINE([USE_SOLARIS_THREADS_WEAK], [1],
221 [Define if references to the old Solaris multithreading library should be made weak.])
222 LIBTHREAD=
223 LTLIBTHREAD=
224 fi
225 fi
226 fi
227 fi
228 if test "$gl_use_threads" = pth; then
229 gl_save_CPPFLAGS="$CPPFLAGS"
230 AC_LIB_LINKFLAGS([pth])
231 gl_have_pth=
232 gl_save_LIBS="$LIBS"
233 LIBS="$LIBS -lpth"
234 AC_TRY_LINK([#include <pth.h>], [pth_self();], [gl_have_pth=yes])
235 LIBS="$gl_save_LIBS"
236 if test -n "$gl_have_pth"; then
237 gl_threads_api=pth
238 LIBTHREAD="$LIBPTH"
239 LTLIBTHREAD="$LTLIBPTH"
240 LIBMULTITHREAD="$LIBTHREAD"
241 LTLIBMULTITHREAD="$LTLIBTHREAD"
242 AC_DEFINE([USE_PTH_THREADS], [1],
243 [Define if the GNU Pth multithreading library can be used.])
244 if test -n "$LIBMULTITHREAD" || test -n "$LTLIBMULTITHREAD"; then
245 if case "$gl_cv_have_weak" in *yes) true;; *) false;; esac; then
246 AC_DEFINE([USE_PTH_THREADS_WEAK], [1],
247 [Define if references to the GNU Pth multithreading library should be made weak.])
248 LIBTHREAD=
249 LTLIBTHREAD=
250 fi
251 fi
252 else
253 CPPFLAGS="$gl_save_CPPFLAGS"
254 fi
255 fi
256 if test -z "$gl_have_pthread"; then
257 if test "$gl_use_threads" = yes || test "$gl_use_threads" = win32; then
258 if { case "$host_os" in
259 mingw*) true;;
260 *) false;;
261 esac
262 }; then
263 gl_threads_api=win32
264 AC_DEFINE([USE_WIN32_THREADS], [1],
265 [Define if the Win32 multithreading API can be used.])
266 fi
267 fi
268 fi
269 fi
270 AC_MSG_CHECKING([for multithread API to use])
271 AC_MSG_RESULT([$gl_threads_api])
272 AC_SUBST([LIBTHREAD])
273 AC_SUBST([LTLIBTHREAD])
274 AC_SUBST([LIBMULTITHREAD])
275 AC_SUBST([LTLIBMULTITHREAD])
276 ])
278 AC_DEFUN([gl_THREADLIB],
279 [
280 AC_REQUIRE([gl_THREADLIB_EARLY])
281 AC_REQUIRE([gl_THREADLIB_BODY])
282 ])
285 dnl gl_DISABLE_THREADS
286 dnl ------------------
287 dnl Sets the gl_THREADLIB default so that threads are not used by default.
288 dnl The user can still override it at installation time, by using the
289 dnl configure option '--enable-threads'.
291 AC_DEFUN([gl_DISABLE_THREADS], [
292 m4_divert_text([INIT_PREPARE], [gl_use_threads_default=no])
293 ])
296 dnl Survey of platforms:
297 dnl
298 dnl Platform Available Compiler Supports test-lock
299 dnl flavours option weak result
300 dnl --------------- --------- --------- -------- ---------
301 dnl Linux 2.4/glibc posix -lpthread Y OK
302 dnl
303 dnl GNU Hurd/glibc posix
304 dnl
305 dnl FreeBSD 5.3 posix -lc_r Y
306 dnl posix -lkse ? Y
307 dnl posix -lpthread ? Y
308 dnl posix -lthr Y
309 dnl
310 dnl FreeBSD 5.2 posix -lc_r Y
311 dnl posix -lkse Y
312 dnl posix -lthr Y
313 dnl
314 dnl FreeBSD 4.0,4.10 posix -lc_r Y OK
315 dnl
316 dnl NetBSD 1.6 --
317 dnl
318 dnl OpenBSD 3.4 posix -lpthread Y OK
319 dnl
320 dnl MacOS X 10.[123] posix -lpthread Y OK
321 dnl
322 dnl Solaris 7,8,9 posix -lpthread Y Sol 7,8: 0.0; Sol 9: OK
323 dnl solaris -lthread Y Sol 7,8: 0.0; Sol 9: OK
324 dnl
325 dnl HP-UX 11 posix -lpthread N (cc) OK
326 dnl Y (gcc)
327 dnl
328 dnl IRIX 6.5 posix -lpthread Y 0.5
329 dnl
330 dnl AIX 4.3,5.1 posix -lpthread N AIX 4: 0.5; AIX 5: OK
331 dnl
332 dnl OSF/1 4.0,5.1 posix -pthread (cc) N OK
333 dnl -lpthread (gcc) Y
334 dnl
335 dnl Cygwin posix -lpthread Y OK
336 dnl
337 dnl Any of the above pth -lpth 0.0
338 dnl
339 dnl Mingw win32 N OK
340 dnl
341 dnl BeOS 5 --
342 dnl
343 dnl The test-lock result shows what happens if in test-lock.c EXPLICIT_YIELD is
344 dnl turned off:
345 dnl OK if all three tests terminate OK,
346 dnl 0.5 if the first test terminates OK but the second one loops endlessly,
347 dnl 0.0 if the first test already loops endlessly.