1 # threadlib.m4 serial 4 (gettext-0.18)
2 dnl Copyright (C) 2005-2009 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.
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
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],
26 AC_REQUIRE([gl_THREADLIB_EARLY_BODY])
29 dnl The guts of gl_THREADLIB_EARLY. Needs to be expanded only once.
31 AC_DEFUN([gl_THREADLIB_EARLY_BODY],
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
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"
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 ;;
66 1.[0-5].*) gl_use_threads=no ;;
67 *) gl_use_threads=yes ;;
70 *) gl_use_threads=yes ;;
75 if test "$gl_use_threads" = yes || test "$gl_use_threads" = posix; then
76 # For using <pthread.h>:
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"
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>.
92 aix* | freebsd*) CPPFLAGS="$CPPFLAGS -D_THREAD_SAFE" ;;
93 solaris*) CPPFLAGS="$CPPFLAGS -D_REENTRANT" ;;
98 dnl The guts of gl_THREADLIB. Needs to be expanded only once.
100 AC_DEFUN([gl_THREADLIB_BODY],
102 AC_REQUIRE([gl_THREADLIB_EARLY_BODY])
108 if test "$gl_use_threads" != no; then
109 dnl Check whether the compiler and linker support weak declarations.
110 AC_MSG_CHECKING([whether imported symbols can be declared weak])
112 AC_TRY_LINK([extern void xyzzy ();
113 #pragma weak xyzzy], [xyzzy();], [gl_have_weak=yes])
114 AC_MSG_RESULT([$gl_have_weak])
115 if test "$gl_use_threads" = yes || test "$gl_use_threads" = posix; then
116 # On OSF/1, the compiler needs the flag -pthread or -D_REENTRANT so that
117 # it groks <pthread.h>. It's added above, in gl_THREADLIB_EARLY_BODY.
118 AC_CHECK_HEADER([pthread.h],
119 [gl_have_pthread_h=yes], [gl_have_pthread_h=no])
120 if test "$gl_have_pthread_h" = yes; then
121 # Other possible tests:
122 # -lpthreads (FSU threads, PCthreads)
125 # Test whether both pthread_mutex_lock and pthread_mutexattr_init exist
126 # in libc. IRIX 6.5 has the first one in both libc and libpthread, but
127 # the second one only in libpthread, and lock.c needs it.
128 AC_TRY_LINK([#include <pthread.h>],
129 [pthread_mutex_lock((pthread_mutex_t*)0);
130 pthread_mutexattr_init((pthread_mutexattr_t*)0);],
131 [gl_have_pthread=yes])
132 # Test for libpthread by looking for pthread_kill. (Not pthread_self,
133 # since it is defined as a macro on OSF/1.)
134 if test -n "$gl_have_pthread"; then
135 # The program links fine without libpthread. But it may actually
136 # need to link with libpthread in order to create multiple threads.
137 AC_CHECK_LIB([pthread], [pthread_kill],
138 [LIBMULTITHREAD=-lpthread LTLIBMULTITHREAD=-lpthread
139 # On Solaris and HP-UX, most pthread functions exist also in libc.
140 # Therefore pthread_in_use() needs to actually try to create a
141 # thread: pthread_create from libc will fail, whereas
142 # pthread_create will actually create a thread.
145 AC_DEFINE([PTHREAD_IN_USE_DETECTION_HARD], [1],
146 [Define if the pthread_in_use() detection is hard.])
150 # Some library is needed. Try libpthread and libc_r.
151 AC_CHECK_LIB([pthread], [pthread_kill],
153 LIBTHREAD=-lpthread LTLIBTHREAD=-lpthread
154 LIBMULTITHREAD=-lpthread LTLIBMULTITHREAD=-lpthread])
155 if test -z "$gl_have_pthread"; then
157 AC_CHECK_LIB([c_r], [pthread_kill],
159 LIBTHREAD=-lc_r LTLIBTHREAD=-lc_r
160 LIBMULTITHREAD=-lc_r LTLIBMULTITHREAD=-lc_r])
163 if test -n "$gl_have_pthread"; then
165 AC_DEFINE([USE_POSIX_THREADS], [1],
166 [Define if the POSIX multithreading library can be used.])
167 if test -n "$LIBMULTITHREAD" || test -n "$LTLIBMULTITHREAD"; then
168 if test $gl_have_weak = yes; then
169 AC_DEFINE([USE_POSIX_THREADS_WEAK], [1],
170 [Define if references to the POSIX multithreading library should be made weak.])
178 if test -z "$gl_have_pthread"; then
179 if test "$gl_use_threads" = yes || test "$gl_use_threads" = solaris; then
180 gl_have_solaristhread=
182 LIBS="$LIBS -lthread"
183 AC_TRY_LINK([#include <thread.h>
186 [gl_have_solaristhread=yes])
188 if test -n "$gl_have_solaristhread"; then
189 gl_threads_api=solaris
192 LIBMULTITHREAD="$LIBTHREAD"
193 LTLIBMULTITHREAD="$LTLIBTHREAD"
194 AC_DEFINE([USE_SOLARIS_THREADS], [1],
195 [Define if the old Solaris multithreading library can be used.])
196 if test $gl_have_weak = yes; then
197 AC_DEFINE([USE_SOLARIS_THREADS_WEAK], [1],
198 [Define if references to the old Solaris multithreading library should be made weak.])
205 if test "$gl_use_threads" = pth; then
206 gl_save_CPPFLAGS="$CPPFLAGS"
207 AC_LIB_LINKFLAGS([pth])
211 AC_TRY_LINK([#include <pth.h>], [pth_self();], [gl_have_pth=yes])
213 if test -n "$gl_have_pth"; then
216 LTLIBTHREAD="$LTLIBPTH"
217 LIBMULTITHREAD="$LIBTHREAD"
218 LTLIBMULTITHREAD="$LTLIBTHREAD"
219 AC_DEFINE([USE_PTH_THREADS], [1],
220 [Define if the GNU Pth multithreading library can be used.])
221 if test -n "$LIBMULTITHREAD" || test -n "$LTLIBMULTITHREAD"; then
222 if test $gl_have_weak = yes; then
223 AC_DEFINE([USE_PTH_THREADS_WEAK], [1],
224 [Define if references to the GNU Pth multithreading library should be made weak.])
230 CPPFLAGS="$gl_save_CPPFLAGS"
233 if test -z "$gl_have_pthread"; then
234 if test "$gl_use_threads" = yes || test "$gl_use_threads" = win32; then
235 if { case "$host_os" in
241 AC_DEFINE([USE_WIN32_THREADS], [1],
242 [Define if the Win32 multithreading API can be used.])
247 AC_MSG_CHECKING([for multithread API to use])
248 AC_MSG_RESULT([$gl_threads_api])
249 AC_SUBST([LIBTHREAD])
250 AC_SUBST([LTLIBTHREAD])
251 AC_SUBST([LIBMULTITHREAD])
252 AC_SUBST([LTLIBMULTITHREAD])
255 AC_DEFUN([gl_THREADLIB],
257 AC_REQUIRE([gl_THREADLIB_EARLY])
258 AC_REQUIRE([gl_THREADLIB_BODY])
262 dnl gl_DISABLE_THREADS
263 dnl ------------------
264 dnl Sets the gl_THREADLIB default so that threads are not used by default.
265 dnl The user can still override it at installation time, by using the
266 dnl configure option '--enable-threads'.
268 AC_DEFUN([gl_DISABLE_THREADS], [
269 m4_divert_text([INIT_PREPARE], [gl_use_threads_default=no])
273 dnl Survey of platforms:
275 dnl Platform Available Compiler Supports test-lock
276 dnl flavours option weak result
277 dnl --------------- --------- --------- -------- ---------
278 dnl Linux 2.4/glibc posix -lpthread Y OK
280 dnl GNU Hurd/glibc posix
282 dnl FreeBSD 5.3 posix -lc_r Y
284 dnl posix -lpthread ? Y
287 dnl FreeBSD 5.2 posix -lc_r Y
291 dnl FreeBSD 4.0,4.10 posix -lc_r Y OK
295 dnl OpenBSD 3.4 posix -lpthread Y OK
297 dnl MacOS X 10.[123] posix -lpthread Y OK
299 dnl Solaris 7,8,9 posix -lpthread Y Sol 7,8: 0.0; Sol 9: OK
300 dnl solaris -lthread Y Sol 7,8: 0.0; Sol 9: OK
302 dnl HP-UX 11 posix -lpthread N (cc) OK
305 dnl IRIX 6.5 posix -lpthread Y 0.5
307 dnl AIX 4.3,5.1 posix -lpthread N AIX 4: 0.5; AIX 5: OK
309 dnl OSF/1 4.0,5.1 posix -pthread (cc) N OK
310 dnl -lpthread (gcc) Y
312 dnl Cygwin posix -lpthread Y OK
314 dnl Any of the above pth -lpth 0.0
320 dnl The test-lock result shows what happens if in test-lock.c EXPLICIT_YIELD is
322 dnl OK if all three tests terminate OK,
323 dnl 0.5 if the first test terminates OK but the second one loops endlessly,
324 dnl 0.0 if the first test already loops endlessly.