1 # lock.m4 serial 5 (gettext-0.15.1)
2 dnl Copyright (C) 2005-2006 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.
9 dnl Tests for a multithreading library to be used.
10 dnl Defines at most one of the macros USE_POSIX_THREADS, USE_SOLARIS_THREADS,
11 dnl USE_PTH_THREADS, USE_WIN32_THREADS
12 dnl Sets the variables LIBTHREAD and LTLIBTHREAD to the linker options for use
13 dnl in a Makefile (LIBTHREAD for use without libtool, LTLIBTHREAD for use with
15 dnl Sets the variables LIBMULTITHREAD and LTLIBMULTITHREAD similarly, for
16 dnl programs that really need multithread functionality. The difference
17 dnl between LIBTHREAD and LIBMULTITHREAD is that on platforms supporting weak
18 dnl symbols, typically LIBTHREAD="" whereas LIBMULTITHREAD="-lpthread".
19 dnl Adds to CPPFLAGS the flag -D_REENTRANT or -D_THREAD_SAFE if needed for
20 dnl multithread-safe programs.
22 AC_DEFUN([gl_LOCK_EARLY],
24 AC_REQUIRE([gl_LOCK_BODY])
27 dnl The guts of gl_LOCK_EARLY. Needs to be expanded only once.
29 AC_DEFUN([gl_LOCK_BODY],
31 dnl Ordering constraints: This macro modifies CPPFLAGS in a way that
32 dnl influences the result of the autoconf tests that test for *_unlocked
33 dnl declarations, on AIX 5 at least. Therefore it must come early.
34 AC_BEFORE([$0], [gl_FUNC_GLIBC_UNLOCKED_IO])dnl
35 AC_BEFORE([$0], [gl_ARGP])dnl
37 AC_REQUIRE([AC_CANONICAL_HOST])
38 AC_REQUIRE([AC_GNU_SOURCE]) dnl needed for pthread_rwlock_t on glibc systems
39 dnl Check for multithreading.
40 AC_ARG_ENABLE(threads,
41 AC_HELP_STRING([--enable-threads={posix|solaris|pth|win32}], [specify multithreading API])
42 AC_HELP_STRING([--disable-threads], [build without multithread safety]),
43 [gl_use_threads=$enableval],
45 dnl Disable multithreading by default on OSF/1, because it interferes
46 dnl with fork()/exec(): When msgexec is linked with -lpthread, its child
47 dnl process gets an endless segmentation fault inside execvp().
48 osf*) gl_use_threads=no ;;
49 *) gl_use_threads=yes ;;
57 if test "$gl_use_threads" != no; then
58 dnl Check whether the compiler and linker support weak declarations.
59 AC_MSG_CHECKING([whether imported symbols can be declared weak])
61 AC_TRY_LINK([extern void xyzzy ();
62 #pragma weak xyzzy], [xyzzy();], [gl_have_weak=yes])
63 AC_MSG_RESULT([$gl_have_weak])
64 if test "$gl_use_threads" = yes || test "$gl_use_threads" = posix; then
65 # On OSF/1, the compiler needs the flag -pthread or -D_REENTRANT so that
66 # it groks <pthread.h>.
67 gl_save_CPPFLAGS="$CPPFLAGS"
68 CPPFLAGS="$CPPFLAGS -D_REENTRANT"
69 AC_CHECK_HEADER(pthread.h, gl_have_pthread_h=yes, gl_have_pthread_h=no)
70 CPPFLAGS="$gl_save_CPPFLAGS"
71 if test "$gl_have_pthread_h" = yes; then
72 # Other possible tests:
73 # -lpthreads (FSU threads, PCthreads)
77 # On OSF/1, the compiler needs the flag -D_REENTRANT so that it
78 # groks <pthread.h>. cc also understands the flag -pthread, but
79 # we don't use it because 1. gcc-2.95 doesn't understand -pthread,
80 # 2. putting a flag into CPPFLAGS that has an effect on the linker
81 # causes the AC_TRY_LINK test below to succeed unexpectedly,
82 # leading to wrong values of LIBTHREAD and LTLIBTHREAD.
83 CPPFLAGS="$CPPFLAGS -D_REENTRANT"
87 # Test whether both pthread_mutex_lock and pthread_mutexattr_init exist
88 # in libc. IRIX 6.5 has the first one in both libc and libpthread, but
89 # the second one only in libpthread, and lock.c needs it.
90 AC_TRY_LINK([#include <pthread.h>],
91 [pthread_mutex_lock((pthread_mutex_t*)0);
92 pthread_mutexattr_init((pthread_mutexattr_t*)0);],
93 [gl_have_pthread=yes])
94 # Test for libpthread by looking for pthread_kill. (Not pthread_self,
95 # since it is defined as a macro on OSF/1.)
96 if test -n "$gl_have_pthread"; then
97 # The program links fine without libpthread. But it may actually
98 # need to link with libpthread in order to create multiple threads.
99 AC_CHECK_LIB(pthread, pthread_kill,
100 [LIBMULTITHREAD=-lpthread LTLIBMULTITHREAD=-lpthread
101 # On Solaris and HP-UX, most pthread functions exist also in libc.
102 # Therefore pthread_in_use() needs to actually try to create a
103 # thread: pthread_create from libc will fail, whereas
104 # pthread_create will actually create a thread.
107 AC_DEFINE([PTHREAD_IN_USE_DETECTION_HARD], 1,
108 [Define if the pthread_in_use() detection is hard.])
112 # Some library is needed. Try libpthread and libc_r.
113 AC_CHECK_LIB(pthread, pthread_kill,
115 LIBTHREAD=-lpthread LTLIBTHREAD=-lpthread
116 LIBMULTITHREAD=-lpthread LTLIBMULTITHREAD=-lpthread])
117 if test -z "$gl_have_pthread"; then
119 AC_CHECK_LIB(c_r, pthread_kill,
121 LIBTHREAD=-lc_r LTLIBTHREAD=-lc_r
122 LIBMULTITHREAD=-lc_r LTLIBMULTITHREAD=-lc_r])
125 if test -n "$gl_have_pthread"; then
127 AC_DEFINE([USE_POSIX_THREADS], 1,
128 [Define if the POSIX multithreading library can be used.])
129 if test -n "$LIBMULTITHREAD" || test -n "$LTLIBMULTITHREAD"; then
130 if test $gl_have_weak = yes; then
131 AC_DEFINE([USE_POSIX_THREADS_WEAK], 1,
132 [Define if references to the POSIX multithreading library should be made weak.])
137 # OSF/1 4.0 and MacOS X 10.1 lack the pthread_rwlock_t type and the
138 # pthread_rwlock_* functions.
139 AC_CHECK_TYPE([pthread_rwlock_t],
140 [AC_DEFINE([HAVE_PTHREAD_RWLOCK], 1,
141 [Define if the POSIX multithreading library has read/write locks.])],
143 [#include <pthread.h>])
144 # glibc defines PTHREAD_MUTEX_RECURSIVE as enum, not as a macro.
145 AC_TRY_COMPILE([#include <pthread.h>],
146 [#if __FreeBSD__ == 4
147 error "No, in FreeBSD 4.0 recursive mutexes actually don't work."
149 int x = (int)PTHREAD_MUTEX_RECURSIVE;
152 [AC_DEFINE([HAVE_PTHREAD_MUTEX_RECURSIVE], 1,
153 [Define if the <pthread.h> defines PTHREAD_MUTEX_RECURSIVE.])])
154 # Some systems optimize for single-threaded programs by default, and
155 # need special flags to disable these optimizations. For example, the
156 # definition of 'errno' in <errno.h>.
158 aix* | freebsd*) CPPFLAGS="$CPPFLAGS -D_THREAD_SAFE" ;;
159 solaris*) CPPFLAGS="$CPPFLAGS -D_REENTRANT" ;;
164 if test -z "$gl_have_pthread"; then
165 if test "$gl_use_threads" = yes || test "$gl_use_threads" = solaris; then
166 gl_have_solaristhread=
168 LIBS="$LIBS -lthread"
169 AC_TRY_LINK([#include <thread.h>
172 [gl_have_solaristhread=yes])
174 if test -n "$gl_have_solaristhread"; then
175 gl_threads_api=solaris
178 LIBMULTITHREAD="$LIBTHREAD"
179 LTLIBMULTITHREAD="$LTLIBTHREAD"
180 AC_DEFINE([USE_SOLARIS_THREADS], 1,
181 [Define if the old Solaris multithreading library can be used.])
182 if test $gl_have_weak = yes; then
183 AC_DEFINE([USE_SOLARIS_THREADS_WEAK], 1,
184 [Define if references to the old Solaris multithreading library should be made weak.])
191 if test "$gl_use_threads" = pth; then
192 gl_save_CPPFLAGS="$CPPFLAGS"
193 AC_LIB_LINKFLAGS(pth)
197 AC_TRY_LINK([#include <pth.h>], [pth_self();], gl_have_pth=yes)
199 if test -n "$gl_have_pth"; then
202 LTLIBTHREAD="$LTLIBPTH"
203 LIBMULTITHREAD="$LIBTHREAD"
204 LTLIBMULTITHREAD="$LTLIBTHREAD"
205 AC_DEFINE([USE_PTH_THREADS], 1,
206 [Define if the GNU Pth multithreading library can be used.])
207 if test -n "$LIBMULTITHREAD" || test -n "$LTLIBMULTITHREAD"; then
208 if test $gl_have_weak = yes; then
209 AC_DEFINE([USE_PTH_THREADS_WEAK], 1,
210 [Define if references to the GNU Pth multithreading library should be made weak.])
216 CPPFLAGS="$gl_save_CPPFLAGS"
219 if test -z "$gl_have_pthread"; then
220 if test "$gl_use_threads" = yes || test "$gl_use_threads" = win32; then
221 if { case "$host_os" in
227 AC_DEFINE([USE_WIN32_THREADS], 1,
228 [Define if the Win32 multithreading API can be used.])
233 AC_MSG_CHECKING([for multithread API to use])
234 AC_MSG_RESULT([$gl_threads_api])
236 AC_SUBST(LTLIBTHREAD)
237 AC_SUBST(LIBMULTITHREAD)
238 AC_SUBST(LTLIBMULTITHREAD)
243 AC_REQUIRE([gl_LOCK_EARLY])
247 # Prerequisites of lib/lock.c.
248 AC_DEFUN([gl_PREREQ_LOCK], [
249 AC_REQUIRE([AC_C_INLINE])
252 dnl Survey of platforms:
254 dnl Platform Available Compiler Supports test-lock
255 dnl flavours option weak result
256 dnl --------------- --------- --------- -------- ---------
257 dnl Linux 2.4/glibc posix -lpthread Y OK
259 dnl GNU Hurd/glibc posix
261 dnl FreeBSD 5.3 posix -lc_r Y
263 dnl posix -lpthread ? Y
266 dnl FreeBSD 5.2 posix -lc_r Y
270 dnl FreeBSD 4.0,4.10 posix -lc_r Y OK
274 dnl OpenBSD 3.4 posix -lpthread Y OK
276 dnl MacOS X 10.[123] posix -lpthread Y OK
278 dnl Solaris 7,8,9 posix -lpthread Y Sol 7,8: 0.0; Sol 9: OK
279 dnl solaris -lthread Y Sol 7,8: 0.0; Sol 9: OK
281 dnl HP-UX 11 posix -lpthread N (cc) OK
284 dnl IRIX 6.5 posix -lpthread Y 0.5
286 dnl AIX 4.3,5.1 posix -lpthread N AIX 4: 0.5; AIX 5: OK
288 dnl OSF/1 4.0,5.1 posix -pthread (cc) N OK
289 dnl -lpthread (gcc) Y
291 dnl Cygwin posix -lpthread Y OK
293 dnl Any of the above pth -lpth 0.0
299 dnl The test-lock result shows what happens if in test-lock.c EXPLICIT_YIELD is
301 dnl OK if all three tests terminate OK,
302 dnl 0.5 if the first test terminates OK but the second one loops endlessly,
303 dnl 0.0 if the first test already loops endlessly.