1 # lock.m4 serial 7 (gettext-0.17)
2 dnl Copyright (C) 2005-2007 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 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
14 dnl libtool).
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],
23 [
24 AC_REQUIRE([gl_LOCK_EARLY_BODY])
25 ])
27 dnl The guts of gl_LOCK_EARLY. Needs to be expanded only once.
29 AC_DEFUN([gl_LOCK_EARLY_BODY],
30 [
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 dnl _GNU_SOURCE is needed for pthread_rwlock_t on glibc systems.
39 dnl AC_USE_SYSTEM_EXTENSIONS was introduced in autoconf 2.60 and obsoletes
40 dnl AC_GNU_SOURCE.
41 m4_ifdef([AC_USE_SYSTEM_EXTENSIONS],
42 [AC_REQUIRE([AC_USE_SYSTEM_EXTENSIONS])],
43 [AC_REQUIRE([AC_GNU_SOURCE])])
44 dnl Check for multithreading.
45 AC_ARG_ENABLE(threads,
46 AC_HELP_STRING([--enable-threads={posix|solaris|pth|win32}], [specify multithreading API])
47 AC_HELP_STRING([--disable-threads], [build without multithread safety]),
48 [gl_use_threads=$enableval],
49 [case "$host_os" in
50 dnl Disable multithreading by default on OSF/1, because it interferes
51 dnl with fork()/exec(): When msgexec is linked with -lpthread, its child
52 dnl process gets an endless segmentation fault inside execvp().
53 osf*) gl_use_threads=no ;;
54 *) gl_use_threads=yes ;;
55 esac
56 ])
57 if test "$gl_use_threads" = yes || test "$gl_use_threads" = posix; then
58 # For using <pthread.h>:
59 case "$host_os" in
60 osf*)
61 # On OSF/1, the compiler needs the flag -D_REENTRANT so that it
62 # groks <pthread.h>. cc also understands the flag -pthread, but
63 # we don't use it because 1. gcc-2.95 doesn't understand -pthread,
64 # 2. putting a flag into CPPFLAGS that has an effect on the linker
65 # causes the AC_TRY_LINK test below to succeed unexpectedly,
66 # leading to wrong values of LIBTHREAD and LTLIBTHREAD.
67 CPPFLAGS="$CPPFLAGS -D_REENTRANT"
68 ;;
69 esac
70 # Some systems optimize for single-threaded programs by default, and
71 # need special flags to disable these optimizations. For example, the
72 # definition of 'errno' in <errno.h>.
73 case "$host_os" in
74 aix* | freebsd*) CPPFLAGS="$CPPFLAGS -D_THREAD_SAFE" ;;
75 solaris*) CPPFLAGS="$CPPFLAGS -D_REENTRANT" ;;
76 esac
77 fi
78 ])
80 dnl The guts of gl_LOCK. Needs to be expanded only once.
82 AC_DEFUN([gl_LOCK_BODY],
83 [
84 AC_REQUIRE([gl_LOCK_EARLY_BODY])
85 gl_threads_api=none
86 LIBTHREAD=
87 LTLIBTHREAD=
88 LIBMULTITHREAD=
89 LTLIBMULTITHREAD=
90 if test "$gl_use_threads" != no; then
91 dnl Check whether the compiler and linker support weak declarations.
92 AC_MSG_CHECKING([whether imported symbols can be declared weak])
93 gl_have_weak=no
94 AC_TRY_LINK([extern void xyzzy ();
95 #pragma weak xyzzy], [xyzzy();], [gl_have_weak=yes])
96 AC_MSG_RESULT([$gl_have_weak])
97 if test "$gl_use_threads" = yes || test "$gl_use_threads" = posix; then
98 # On OSF/1, the compiler needs the flag -pthread or -D_REENTRANT so that
99 # it groks <pthread.h>. It's added above, in gl_LOCK_EARLY_BODY.
100 AC_CHECK_HEADER(pthread.h, gl_have_pthread_h=yes, gl_have_pthread_h=no)
101 if test "$gl_have_pthread_h" = yes; then
102 # Other possible tests:
103 # -lpthreads (FSU threads, PCthreads)
104 # -lgthreads
105 gl_have_pthread=
106 # Test whether both pthread_mutex_lock and pthread_mutexattr_init exist
107 # in libc. IRIX 6.5 has the first one in both libc and libpthread, but
108 # the second one only in libpthread, and lock.c needs it.
109 AC_TRY_LINK([#include <pthread.h>],
110 [pthread_mutex_lock((pthread_mutex_t*)0);
111 pthread_mutexattr_init((pthread_mutexattr_t*)0);],
112 [gl_have_pthread=yes])
113 # Test for libpthread by looking for pthread_kill. (Not pthread_self,
114 # since it is defined as a macro on OSF/1.)
115 if test -n "$gl_have_pthread"; then
116 # The program links fine without libpthread. But it may actually
117 # need to link with libpthread in order to create multiple threads.
118 AC_CHECK_LIB(pthread, pthread_kill,
119 [LIBMULTITHREAD=-lpthread LTLIBMULTITHREAD=-lpthread
120 # On Solaris and HP-UX, most pthread functions exist also in libc.
121 # Therefore pthread_in_use() needs to actually try to create a
122 # thread: pthread_create from libc will fail, whereas
123 # pthread_create will actually create a thread.
124 case "$host_os" in
125 solaris* | hpux*)
126 AC_DEFINE([PTHREAD_IN_USE_DETECTION_HARD], 1,
127 [Define if the pthread_in_use() detection is hard.])
128 esac
129 ])
130 else
131 # Some library is needed. Try libpthread and libc_r.
132 AC_CHECK_LIB(pthread, pthread_kill,
133 [gl_have_pthread=yes
134 LIBTHREAD=-lpthread LTLIBTHREAD=-lpthread
135 LIBMULTITHREAD=-lpthread LTLIBMULTITHREAD=-lpthread])
136 if test -z "$gl_have_pthread"; then
137 # For FreeBSD 4.
138 AC_CHECK_LIB(c_r, pthread_kill,
139 [gl_have_pthread=yes
140 LIBTHREAD=-lc_r LTLIBTHREAD=-lc_r
141 LIBMULTITHREAD=-lc_r LTLIBMULTITHREAD=-lc_r])
142 fi
143 fi
144 if test -n "$gl_have_pthread"; then
145 gl_threads_api=posix
146 AC_DEFINE([USE_POSIX_THREADS], 1,
147 [Define if the POSIX multithreading library can be used.])
148 if test -n "$LIBMULTITHREAD" || test -n "$LTLIBMULTITHREAD"; then
149 if test $gl_have_weak = yes; then
150 AC_DEFINE([USE_POSIX_THREADS_WEAK], 1,
151 [Define if references to the POSIX multithreading library should be made weak.])
152 LIBTHREAD=
153 LTLIBTHREAD=
154 fi
155 fi
156 # OSF/1 4.0 and MacOS X 10.1 lack the pthread_rwlock_t type and the
157 # pthread_rwlock_* functions.
158 AC_CHECK_TYPE([pthread_rwlock_t],
159 [AC_DEFINE([HAVE_PTHREAD_RWLOCK], 1,
160 [Define if the POSIX multithreading library has read/write locks.])],
161 [],
162 [#include <pthread.h>])
163 # glibc defines PTHREAD_MUTEX_RECURSIVE as enum, not as a macro.
164 AC_TRY_COMPILE([#include <pthread.h>],
165 [#if __FreeBSD__ == 4
166 error "No, in FreeBSD 4.0 recursive mutexes actually don't work."
167 #else
168 int x = (int)PTHREAD_MUTEX_RECURSIVE;
169 return !x;
170 #endif],
171 [AC_DEFINE([HAVE_PTHREAD_MUTEX_RECURSIVE], 1,
172 [Define if the <pthread.h> defines PTHREAD_MUTEX_RECURSIVE.])])
173 fi
174 fi
175 fi
176 if test -z "$gl_have_pthread"; then
177 if test "$gl_use_threads" = yes || test "$gl_use_threads" = solaris; then
178 gl_have_solaristhread=
179 gl_save_LIBS="$LIBS"
180 LIBS="$LIBS -lthread"
181 AC_TRY_LINK([#include <thread.h>
182 #include <synch.h>],
183 [thr_self();],
184 [gl_have_solaristhread=yes])
185 LIBS="$gl_save_LIBS"
186 if test -n "$gl_have_solaristhread"; then
187 gl_threads_api=solaris
188 LIBTHREAD=-lthread
189 LTLIBTHREAD=-lthread
190 LIBMULTITHREAD="$LIBTHREAD"
191 LTLIBMULTITHREAD="$LTLIBTHREAD"
192 AC_DEFINE([USE_SOLARIS_THREADS], 1,
193 [Define if the old Solaris multithreading library can be used.])
194 if test $gl_have_weak = yes; then
195 AC_DEFINE([USE_SOLARIS_THREADS_WEAK], 1,
196 [Define if references to the old Solaris multithreading library should be made weak.])
197 LIBTHREAD=
198 LTLIBTHREAD=
199 fi
200 fi
201 fi
202 fi
203 if test "$gl_use_threads" = pth; then
204 gl_save_CPPFLAGS="$CPPFLAGS"
205 AC_LIB_LINKFLAGS(pth)
206 gl_have_pth=
207 gl_save_LIBS="$LIBS"
208 LIBS="$LIBS -lpth"
209 AC_TRY_LINK([#include <pth.h>], [pth_self();], gl_have_pth=yes)
210 LIBS="$gl_save_LIBS"
211 if test -n "$gl_have_pth"; then
212 gl_threads_api=pth
213 LIBTHREAD="$LIBPTH"
214 LTLIBTHREAD="$LTLIBPTH"
215 LIBMULTITHREAD="$LIBTHREAD"
216 LTLIBMULTITHREAD="$LTLIBTHREAD"
217 AC_DEFINE([USE_PTH_THREADS], 1,
218 [Define if the GNU Pth multithreading library can be used.])
219 if test -n "$LIBMULTITHREAD" || test -n "$LTLIBMULTITHREAD"; then
220 if test $gl_have_weak = yes; then
221 AC_DEFINE([USE_PTH_THREADS_WEAK], 1,
222 [Define if references to the GNU Pth multithreading library should be made weak.])
223 LIBTHREAD=
224 LTLIBTHREAD=
225 fi
226 fi
227 else
228 CPPFLAGS="$gl_save_CPPFLAGS"
229 fi
230 fi
231 if test -z "$gl_have_pthread"; then
232 if test "$gl_use_threads" = yes || test "$gl_use_threads" = win32; then
233 if { case "$host_os" in
234 mingw*) true;;
235 *) false;;
236 esac
237 }; then
238 gl_threads_api=win32
239 AC_DEFINE([USE_WIN32_THREADS], 1,
240 [Define if the Win32 multithreading API can be used.])
241 fi
242 fi
243 fi
244 fi
245 AC_MSG_CHECKING([for multithread API to use])
246 AC_MSG_RESULT([$gl_threads_api])
247 AC_SUBST(LIBTHREAD)
248 AC_SUBST(LTLIBTHREAD)
249 AC_SUBST(LIBMULTITHREAD)
250 AC_SUBST(LTLIBMULTITHREAD)
251 ])
253 AC_DEFUN([gl_LOCK],
254 [
255 AC_REQUIRE([gl_LOCK_EARLY])
256 AC_REQUIRE([gl_LOCK_BODY])
257 gl_PREREQ_LOCK
258 ])
260 # Prerequisites of lib/lock.c.
261 AC_DEFUN([gl_PREREQ_LOCK], [
262 AC_REQUIRE([AC_C_INLINE])
263 ])
265 dnl Survey of platforms:
266 dnl
267 dnl Platform Available Compiler Supports test-lock
268 dnl flavours option weak result
269 dnl --------------- --------- --------- -------- ---------
270 dnl Linux 2.4/glibc posix -lpthread Y OK
271 dnl
272 dnl GNU Hurd/glibc posix
273 dnl
274 dnl FreeBSD 5.3 posix -lc_r Y
275 dnl posix -lkse ? Y
276 dnl posix -lpthread ? Y
277 dnl posix -lthr Y
278 dnl
279 dnl FreeBSD 5.2 posix -lc_r Y
280 dnl posix -lkse Y
281 dnl posix -lthr Y
282 dnl
283 dnl FreeBSD 4.0,4.10 posix -lc_r Y OK
284 dnl
285 dnl NetBSD 1.6 --
286 dnl
287 dnl OpenBSD 3.4 posix -lpthread Y OK
288 dnl
289 dnl MacOS X 10.[123] posix -lpthread Y OK
290 dnl
291 dnl Solaris 7,8,9 posix -lpthread Y Sol 7,8: 0.0; Sol 9: OK
292 dnl solaris -lthread Y Sol 7,8: 0.0; Sol 9: OK
293 dnl
294 dnl HP-UX 11 posix -lpthread N (cc) OK
295 dnl Y (gcc)
296 dnl
297 dnl IRIX 6.5 posix -lpthread Y 0.5
298 dnl
299 dnl AIX 4.3,5.1 posix -lpthread N AIX 4: 0.5; AIX 5: OK
300 dnl
301 dnl OSF/1 4.0,5.1 posix -pthread (cc) N OK
302 dnl -lpthread (gcc) Y
303 dnl
304 dnl Cygwin posix -lpthread Y OK
305 dnl
306 dnl Any of the above pth -lpth 0.0
307 dnl
308 dnl Mingw win32 N OK
309 dnl
310 dnl BeOS 5 --
311 dnl
312 dnl The test-lock result shows what happens if in test-lock.c EXPLICIT_YIELD is
313 dnl turned off:
314 dnl OK if all three tests terminate OK,
315 dnl 0.5 if the first test terminates OK but the second one loops endlessly,
316 dnl 0.0 if the first test already loops endlessly.