1 # lock.m4 serial 1 (gettext-0.15)
2 dnl Copyright (C) 2005 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.
24 dnl Ordering constraints: This macro modifies CPPFLAGS in a way that
25 dnl influences the result of the autoconf tests that test for *_unlocked
26 dnl declarations, on AIX 5 at least. Therefore it must come early.
27 AC_BEFORE([$0], [gl_FUNC_GLIBC_UNLOCKED_IO])dnl
28 AC_BEFORE([$0], [gl_ARGP])dnl
30 AC_REQUIRE([AC_CANONICAL_HOST])
31 AC_REQUIRE([AC_GNU_SOURCE]) dnl needed for pthread_rwlock_t on glibc systems
32 dnl Check for multithreading.
33 AC_ARG_ENABLE(threads,
34 AC_HELP_STRING([--enable-threads={posix|solaris|pth|win32}], [specify multithreading API])
35 AC_HELP_STRING([--disable-threads], [build without multithread safety]),
36 gl_use_threads=$enableval, gl_use_threads=yes)
42 if test "$gl_use_threads" != no; then
43 dnl Check whether the compiler and linker support weak declarations.
44 AC_MSG_CHECKING([whether imported symbols can be declared weak])
46 AC_TRY_LINK([extern void xyzzy ();
47 #pragma weak xyzzy], [xyzzy();], [gl_have_weak=yes])
48 AC_MSG_RESULT([$gl_have_weak])
49 if test "$gl_use_threads" = yes || test "$gl_use_threads" = posix; then
50 # On OSF/1, the compiler needs the flag -pthread or -D_REENTRANT so that
51 # it groks <pthread.h>.
52 gl_save_CPPFLAGS="$CPPFLAGS"
53 CPPFLAGS="$CPPFLAGS -D_REENTRANT"
54 AC_CHECK_HEADER(pthread.h, gl_have_pthread_h=yes, gl_have_pthread_h=no)
55 CPPFLAGS="$gl_save_CPPFLAGS"
56 if test "$gl_have_pthread_h" = yes; then
57 # Other possible tests:
58 # -lpthreads (FSU threads, PCthreads)
62 # On OSF/1, the compiler needs the flag -D_REENTRANT so that it
63 # groks <pthread.h>. cc also understands the flag -pthread, but
64 # we don't use it because 1. gcc-2.95 doesn't understand -pthread,
65 # 2. putting a flag into CPPFLAGS that has an effect on the linker
66 # causes the AC_TRY_LINK test below to succeed unexpectedly,
67 # leading to wrong values of LIBTHREAD and LTLIBTHREAD.
68 CPPFLAGS="$CPPFLAGS -D_REENTRANT"
72 # Test whether both pthread_mutex_lock and pthread_mutexattr_init exist
73 # in libc. IRIX 6.5 has the first one in both libc and libpthread, but
74 # the second one only in libpthread, and lock.c needs it.
75 AC_TRY_LINK([#include <pthread.h>],
76 [pthread_mutex_lock((pthread_mutex_t*)0);
77 pthread_mutexattr_init((pthread_mutexattr_t*)0);],
78 [gl_have_pthread=yes])
79 # Test for libpthread by looking for pthread_kill. (Not pthread_self,
80 # since it is defined as a macro on OSF/1.)
81 if test -n "$gl_have_pthread"; then
82 # The program links fine without libpthread. But it may actually
83 # need to link with libpthread in order to create multiple threads.
84 AC_CHECK_LIB(pthread, pthread_kill,
85 [LIBMULTITHREAD=-lpthread LTLIBMULTITHREAD=-lpthread
86 # On Solaris and HP-UX, most pthread functions exist also in libc.
87 # Therefore pthread_in_use() needs to actually try to create a
88 # thread: pthread_create from libc will fail, whereas
89 # pthread_create will actually create a thread.
92 AC_DEFINE([PTHREAD_IN_USE_DETECTION_HARD], 1,
93 [Define if the pthread_in_use() detection is hard.])
97 # Some library is needed. Try libpthread and libc_r.
98 AC_CHECK_LIB(pthread, pthread_kill,
100 LIBTHREAD=-lpthread LTLIBTHREAD=-lpthread
101 LIBMULTITHREAD=-lpthread LTLIBMULTITHREAD=-lpthread])
102 if test -z "$gl_have_pthread"; then
104 AC_CHECK_LIB(c_r, pthread_kill,
106 LIBTHREAD=-lc_r LTLIBTHREAD=-lc_r
107 LIBMULTITHREAD=-lc_r LTLIBMULTITHREAD=-lc_r])
110 if test -n "$gl_have_pthread"; then
112 AC_DEFINE([USE_POSIX_THREADS], 1,
113 [Define if the POSIX multithreading library can be used.])
114 if test -n "$LIBMULTITHREAD" || test -n "$LTLIBMULTITHREAD"; then
115 if test $gl_have_weak = yes; then
116 AC_DEFINE([USE_POSIX_THREADS_WEAK], 1,
117 [Define if references to the POSIX multithreading library should be made weak.])
122 # OSF/1 4.0 and MacOS X 10.1 lack the pthread_rwlock_t type and the
123 # pthread_rwlock_* functions.
124 AC_CHECK_TYPE([pthread_rwlock_t],
125 [AC_DEFINE([HAVE_PTHREAD_RWLOCK], 1,
126 [Define if the POSIX multithreading library has read/write locks.])],
128 [#include <pthread.h>])
129 # glibc defines PTHREAD_MUTEX_RECURSIVE as enum, not as a macro.
130 AC_TRY_COMPILE([#include <pthread.h>],
131 [#if __FreeBSD__ == 4
132 error "No, in FreeBSD 4.0 recursive mutexes actually don't work."
134 int x = (int)PTHREAD_MUTEX_RECURSIVE;
136 [AC_DEFINE([HAVE_PTHREAD_MUTEX_RECURSIVE], 1,
137 [Define if the <pthread.h> defines PTHREAD_MUTEX_RECURSIVE.])])
138 # Some systems optimize for single-threaded programs by default, and
139 # need special flags to disable these optimizations. For example, the
140 # definition of 'errno' in <errno.h>.
142 aix* | freebsd*) CPPFLAGS="$CPPFLAGS -D_THREAD_SAFE" ;;
143 solaris*) CPPFLAGS="$CPPFLAGS -D_REENTRANT" ;;
148 if test -z "$gl_have_pthread"; then
149 if test "$gl_use_threads" = yes || test "$gl_use_threads" = solaris; then
150 gl_have_solaristhread=
152 LIBS="$LIBS -lthread"
153 AC_TRY_LINK([#include <thread.h>
156 [gl_have_solaristhread=yes])
158 if test -n "$gl_have_solaristhread"; then
159 gl_threads_api=solaris
162 LIBMULTITHREAD="$LIBTHREAD"
163 LTLIBMULTITHREAD="$LTLIBTHREAD"
164 AC_DEFINE([USE_SOLARIS_THREADS], 1,
165 [Define if the old Solaris multithreading library can be used.])
166 if test $gl_have_weak = yes; then
167 AC_DEFINE([USE_SOLARIS_THREADS_WEAK], 1,
168 [Define if references to the old Solaris multithreading library should be made weak.])
175 if test "$gl_use_threads" = pth; then
176 gl_save_CPPFLAGS="$CPPFLAGS"
177 AC_LIB_LINKFLAGS(pth)
181 AC_TRY_LINK([#include <pth.h>], [pth_self();], gl_have_pth=yes)
183 if test -n "$gl_have_pth"; then
186 LTLIBTHREAD="$LTLIBPTH"
187 LIBMULTITHREAD="$LIBTHREAD"
188 LTLIBMULTITHREAD="$LTLIBTHREAD"
189 AC_DEFINE([USE_PTH_THREADS], 1,
190 [Define if the GNU Pth multithreading library can be used.])
191 if test -n "$LIBMULTITHREAD" || test -n "$LTLIBMULTITHREAD"; then
192 if test $gl_have_weak = yes; then
193 AC_DEFINE([USE_PTH_THREADS_WEAK], 1,
194 [Define if references to the GNU Pth multithreading library should be made weak.])
200 CPPFLAGS="$gl_save_CPPFLAGS"
203 if test -z "$gl_have_pthread"; then
204 if test "$gl_use_threads" = yes || test "$gl_use_threads" = win32; then
205 if { case "$host_os" in
211 AC_DEFINE([USE_WIN32_THREADS], 1,
212 [Define if the Win32 multithreading API can be used.])
217 AC_MSG_CHECKING([for multithread API to use])
218 AC_MSG_RESULT([$gl_threads_api])
220 AC_SUBST(LTLIBTHREAD)
221 AC_SUBST(LIBMULTITHREAD)
222 AC_SUBST(LTLIBMULTITHREAD)
226 # Prerequisites of lib/lock.c.
227 AC_DEFUN([gl_PREREQ_LOCK], [
228 AC_REQUIRE([AC_C_INLINE])
231 dnl Survey of platforms:
233 dnl Platform Available Compiler Supports test-lock
234 dnl flavours option weak result
235 dnl --------------- --------- --------- -------- ---------
236 dnl Linux 2.4/glibc posix -lpthread Y OK
238 dnl GNU Hurd/glibc posix
240 dnl FreeBSD 5.3 posix -lc_r Y
242 dnl posix -lpthread ? Y
245 dnl FreeBSD 5.2 posix -lc_r Y
249 dnl FreeBSD 4.0,4.10 posix -lc_r Y OK
253 dnl OpenBSD 3.4 posix -lpthread Y OK
255 dnl MacOS X 10.[123] posix -lpthread Y OK
257 dnl Solaris 7,8,9 posix -lpthread Y Sol 7,8: 0.0; Sol 9: OK
258 dnl solaris -lthread Y Sol 7,8: 0.0; Sol 9: OK
260 dnl HP-UX 11 posix -lpthread N (cc) OK
263 dnl IRIX 6.5 posix -lpthread Y 0.5
265 dnl AIX 4.3,5.1 posix -lpthread N AIX 4: 0.5; AIX 5: OK
267 dnl OSF/1 4.0,5.1 posix -pthread (cc) N OK
268 dnl -lpthread (gcc) Y
270 dnl Cygwin posix -lpthread Y OK
272 dnl Any of the above pth -lpth 0.0
278 dnl The test-lock result shows what happens if in test-lock.c EXPLICIT_YIELD is
280 dnl OK if all three tests terminate OK,
281 dnl 0.5 if the first test terminates OK but the second one loops endlessly,
282 dnl 0.0 if the first test already loops endlessly.