1 # lock.m4 serial 8 (gettext-0.18)
2 dnl Copyright (C) 2005-2008 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_LOCK_EARLY],
26 AC_REQUIRE([gl_LOCK_EARLY_BODY])
29 dnl The guts of gl_LOCK_EARLY. Needs to be expanded only once.
31 AC_DEFUN([gl_LOCK_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"
56 dnl Disable multithreading by default on OSF/1, because it interferes
57 dnl with fork()/exec(): When msgexec is linked with -lpthread, its
58 dnl child process gets an endless segmentation fault inside execvp().
59 osf*) gl_use_threads=no ;;
60 *) gl_use_threads=yes ;;
64 if test "$gl_use_threads" = yes || test "$gl_use_threads" = posix; then
65 # For using <pthread.h>:
68 # On OSF/1, the compiler needs the flag -D_REENTRANT so that it
69 # groks <pthread.h>. cc also understands the flag -pthread, but
70 # we don't use it because 1. gcc-2.95 doesn't understand -pthread,
71 # 2. putting a flag into CPPFLAGS that has an effect on the linker
72 # causes the AC_TRY_LINK test below to succeed unexpectedly,
73 # leading to wrong values of LIBTHREAD and LTLIBTHREAD.
74 CPPFLAGS="$CPPFLAGS -D_REENTRANT"
77 # Some systems optimize for single-threaded programs by default, and
78 # need special flags to disable these optimizations. For example, the
79 # definition of 'errno' in <errno.h>.
81 aix* | freebsd*) CPPFLAGS="$CPPFLAGS -D_THREAD_SAFE" ;;
82 solaris*) CPPFLAGS="$CPPFLAGS -D_REENTRANT" ;;
87 dnl The guts of gl_LOCK. Needs to be expanded only once.
89 AC_DEFUN([gl_LOCK_BODY],
91 AC_REQUIRE([gl_LOCK_EARLY_BODY])
97 if test "$gl_use_threads" != no; then
98 dnl Check whether the compiler and linker support weak declarations.
99 AC_MSG_CHECKING([whether imported symbols can be declared weak])
101 AC_TRY_LINK([extern void xyzzy ();
102 #pragma weak xyzzy], [xyzzy();], [gl_have_weak=yes])
103 AC_MSG_RESULT([$gl_have_weak])
104 if test "$gl_use_threads" = yes || test "$gl_use_threads" = posix; then
105 # On OSF/1, the compiler needs the flag -pthread or -D_REENTRANT so that
106 # it groks <pthread.h>. It's added above, in gl_LOCK_EARLY_BODY.
107 AC_CHECK_HEADER(pthread.h, gl_have_pthread_h=yes, gl_have_pthread_h=no)
108 if test "$gl_have_pthread_h" = yes; then
109 # Other possible tests:
110 # -lpthreads (FSU threads, PCthreads)
113 # Test whether both pthread_mutex_lock and pthread_mutexattr_init exist
114 # in libc. IRIX 6.5 has the first one in both libc and libpthread, but
115 # the second one only in libpthread, and lock.c needs it.
116 AC_TRY_LINK([#include <pthread.h>],
117 [pthread_mutex_lock((pthread_mutex_t*)0);
118 pthread_mutexattr_init((pthread_mutexattr_t*)0);],
119 [gl_have_pthread=yes])
120 # Test for libpthread by looking for pthread_kill. (Not pthread_self,
121 # since it is defined as a macro on OSF/1.)
122 if test -n "$gl_have_pthread"; then
123 # The program links fine without libpthread. But it may actually
124 # need to link with libpthread in order to create multiple threads.
125 AC_CHECK_LIB(pthread, pthread_kill,
126 [LIBMULTITHREAD=-lpthread LTLIBMULTITHREAD=-lpthread
127 # On Solaris and HP-UX, most pthread functions exist also in libc.
128 # Therefore pthread_in_use() needs to actually try to create a
129 # thread: pthread_create from libc will fail, whereas
130 # pthread_create will actually create a thread.
133 AC_DEFINE([PTHREAD_IN_USE_DETECTION_HARD], 1,
134 [Define if the pthread_in_use() detection is hard.])
138 # Some library is needed. Try libpthread and libc_r.
139 AC_CHECK_LIB(pthread, pthread_kill,
141 LIBTHREAD=-lpthread LTLIBTHREAD=-lpthread
142 LIBMULTITHREAD=-lpthread LTLIBMULTITHREAD=-lpthread])
143 if test -z "$gl_have_pthread"; then
145 AC_CHECK_LIB(c_r, pthread_kill,
147 LIBTHREAD=-lc_r LTLIBTHREAD=-lc_r
148 LIBMULTITHREAD=-lc_r LTLIBMULTITHREAD=-lc_r])
151 if test -n "$gl_have_pthread"; then
153 AC_DEFINE([USE_POSIX_THREADS], 1,
154 [Define if the POSIX multithreading library can be used.])
155 if test -n "$LIBMULTITHREAD" || test -n "$LTLIBMULTITHREAD"; then
156 if test $gl_have_weak = yes; then
157 AC_DEFINE([USE_POSIX_THREADS_WEAK], 1,
158 [Define if references to the POSIX multithreading library should be made weak.])
163 # OSF/1 4.0 and MacOS X 10.1 lack the pthread_rwlock_t type and the
164 # pthread_rwlock_* functions.
165 AC_CHECK_TYPE([pthread_rwlock_t],
166 [AC_DEFINE([HAVE_PTHREAD_RWLOCK], 1,
167 [Define if the POSIX multithreading library has read/write locks.])],
169 [#include <pthread.h>])
170 # glibc defines PTHREAD_MUTEX_RECURSIVE as enum, not as a macro.
171 AC_TRY_COMPILE([#include <pthread.h>],
172 [#if __FreeBSD__ == 4
173 error "No, in FreeBSD 4.0 recursive mutexes actually don't work."
175 int x = (int)PTHREAD_MUTEX_RECURSIVE;
178 [AC_DEFINE([HAVE_PTHREAD_MUTEX_RECURSIVE], 1,
179 [Define if the <pthread.h> defines PTHREAD_MUTEX_RECURSIVE.])])
183 if test -z "$gl_have_pthread"; then
184 if test "$gl_use_threads" = yes || test "$gl_use_threads" = solaris; then
185 gl_have_solaristhread=
187 LIBS="$LIBS -lthread"
188 AC_TRY_LINK([#include <thread.h>
191 [gl_have_solaristhread=yes])
193 if test -n "$gl_have_solaristhread"; then
194 gl_threads_api=solaris
197 LIBMULTITHREAD="$LIBTHREAD"
198 LTLIBMULTITHREAD="$LTLIBTHREAD"
199 AC_DEFINE([USE_SOLARIS_THREADS], 1,
200 [Define if the old Solaris multithreading library can be used.])
201 if test $gl_have_weak = yes; then
202 AC_DEFINE([USE_SOLARIS_THREADS_WEAK], 1,
203 [Define if references to the old Solaris multithreading library should be made weak.])
210 if test "$gl_use_threads" = pth; then
211 gl_save_CPPFLAGS="$CPPFLAGS"
212 AC_LIB_LINKFLAGS(pth)
216 AC_TRY_LINK([#include <pth.h>], [pth_self();], gl_have_pth=yes)
218 if test -n "$gl_have_pth"; then
221 LTLIBTHREAD="$LTLIBPTH"
222 LIBMULTITHREAD="$LIBTHREAD"
223 LTLIBMULTITHREAD="$LTLIBTHREAD"
224 AC_DEFINE([USE_PTH_THREADS], 1,
225 [Define if the GNU Pth multithreading library can be used.])
226 if test -n "$LIBMULTITHREAD" || test -n "$LTLIBMULTITHREAD"; then
227 if test $gl_have_weak = yes; then
228 AC_DEFINE([USE_PTH_THREADS_WEAK], 1,
229 [Define if references to the GNU Pth multithreading library should be made weak.])
235 CPPFLAGS="$gl_save_CPPFLAGS"
238 if test -z "$gl_have_pthread"; then
239 if test "$gl_use_threads" = yes || test "$gl_use_threads" = win32; then
240 if { case "$host_os" in
246 AC_DEFINE([USE_WIN32_THREADS], 1,
247 [Define if the Win32 multithreading API can be used.])
252 AC_MSG_CHECKING([for multithread API to use])
253 AC_MSG_RESULT([$gl_threads_api])
255 AC_SUBST(LTLIBTHREAD)
256 AC_SUBST(LIBMULTITHREAD)
257 AC_SUBST(LTLIBMULTITHREAD)
262 AC_REQUIRE([gl_LOCK_EARLY])
263 AC_REQUIRE([gl_LOCK_BODY])
267 # Prerequisites of lib/lock.c.
268 AC_DEFUN([gl_PREREQ_LOCK], [
269 AC_REQUIRE([AC_C_INLINE])
273 dnl gl_DISABLE_THREADS
274 dnl ------------------
275 dnl Sets the gl_LOCK default so that threads are not used by default.
276 dnl The user can still override it at installation time, by using the
277 dnl configure option '--enable-threads'.
279 AC_DEFUN([gl_DISABLE_THREADS], [
280 m4_divert_text([INIT_PREPARE], [gl_use_threads_default=no])
284 dnl Survey of platforms:
286 dnl Platform Available Compiler Supports test-lock
287 dnl flavours option weak result
288 dnl --------------- --------- --------- -------- ---------
289 dnl Linux 2.4/glibc posix -lpthread Y OK
291 dnl GNU Hurd/glibc posix
293 dnl FreeBSD 5.3 posix -lc_r Y
295 dnl posix -lpthread ? Y
298 dnl FreeBSD 5.2 posix -lc_r Y
302 dnl FreeBSD 4.0,4.10 posix -lc_r Y OK
306 dnl OpenBSD 3.4 posix -lpthread Y OK
308 dnl MacOS X 10.[123] posix -lpthread Y OK
310 dnl Solaris 7,8,9 posix -lpthread Y Sol 7,8: 0.0; Sol 9: OK
311 dnl solaris -lthread Y Sol 7,8: 0.0; Sol 9: OK
313 dnl HP-UX 11 posix -lpthread N (cc) OK
316 dnl IRIX 6.5 posix -lpthread Y 0.5
318 dnl AIX 4.3,5.1 posix -lpthread N AIX 4: 0.5; AIX 5: OK
320 dnl OSF/1 4.0,5.1 posix -pthread (cc) N OK
321 dnl -lpthread (gcc) Y
323 dnl Cygwin posix -lpthread Y OK
325 dnl Any of the above pth -lpth 0.0
331 dnl The test-lock result shows what happens if in test-lock.c EXPLICIT_YIELD is
333 dnl OK if all three tests terminate OK,
334 dnl 0.5 if the first test terminates OK but the second one loops endlessly,
335 dnl 0.0 if the first test already loops endlessly.