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.
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_EARLY_BODY])
27
dnl The guts of gl_LOCK_EARLY. Needs to be expanded only once.
29
AC_DEFUN([gl_LOCK_EARLY_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
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
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],
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 ;;
57
if test "$gl_use_threads" = yes || test "$gl_use_threads" = posix; then
58
# For using <pthread.h>:
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"
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>.
74
aix* | freebsd*) CPPFLAGS="$CPPFLAGS -D_THREAD_SAFE" ;;
75
solaris*) CPPFLAGS="$CPPFLAGS -D_REENTRANT" ;;
80
dnl The guts of gl_LOCK. Needs to be expanded only once.
82
AC_DEFUN([gl_LOCK_BODY],
84
AC_REQUIRE([gl_LOCK_EARLY_BODY])
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])
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)
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.
126
AC_DEFINE([PTHREAD_IN_USE_DETECTION_HARD], 1,
127
[Define if the pthread_in_use() detection is hard.])
131
# Some library is needed. Try libpthread and libc_r.
132
AC_CHECK_LIB(pthread, pthread_kill,
134
LIBTHREAD=-lpthread LTLIBTHREAD=-lpthread
135
LIBMULTITHREAD=-lpthread LTLIBMULTITHREAD=-lpthread])
136
if test -z "$gl_have_pthread"; then
138
AC_CHECK_LIB(c_r, pthread_kill,
140
LIBTHREAD=-lc_r LTLIBTHREAD=-lc_r
141
LIBMULTITHREAD=-lc_r LTLIBMULTITHREAD=-lc_r])
144
if test -n "$gl_have_pthread"; then
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.])
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.])],
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."
168
int x = (int)PTHREAD_MUTEX_RECURSIVE;
171
[AC_DEFINE([HAVE_PTHREAD_MUTEX_RECURSIVE], 1,
172
[Define if the <pthread.h> defines PTHREAD_MUTEX_RECURSIVE.])])
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=
180
LIBS="$LIBS -lthread"
181
AC_TRY_LINK([#include <thread.h>
184
[gl_have_solaristhread=yes])
186
if test -n "$gl_have_solaristhread"; then
187
gl_threads_api=solaris
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.])
203
if test "$gl_use_threads" = pth; then
204
gl_save_CPPFLAGS="$CPPFLAGS"
205
AC_LIB_LINKFLAGS(pth)
209
AC_TRY_LINK([#include <pth.h>], [pth_self();], gl_have_pth=yes)
211
if test -n "$gl_have_pth"; then
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.])
228
CPPFLAGS="$gl_save_CPPFLAGS"
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
239
AC_DEFINE([USE_WIN32_THREADS], 1,
240
[Define if the Win32 multithreading API can be used.])
245
AC_MSG_CHECKING([for multithread API to use])
246
AC_MSG_RESULT([$gl_threads_api])
248
AC_SUBST(LTLIBTHREAD)
249
AC_SUBST(LIBMULTITHREAD)
250
AC_SUBST(LTLIBMULTITHREAD)
255
AC_REQUIRE([gl_LOCK_EARLY])
256
AC_REQUIRE([gl_LOCK_BODY])
260
# Prerequisites of lib/lock.c.
261
AC_DEFUN([gl_PREREQ_LOCK], [
262
AC_REQUIRE([AC_C_INLINE])
265
dnl Survey of platforms:
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
272
dnl GNU Hurd/glibc posix
274
dnl FreeBSD 5.3 posix -lc_r Y
276
dnl posix -lpthread ? Y
279
dnl FreeBSD 5.2 posix -lc_r Y
283
dnl FreeBSD 4.0,4.10 posix -lc_r Y OK
287
dnl OpenBSD 3.4 posix -lpthread Y OK
289
dnl MacOS X 10.[123] posix -lpthread Y OK
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
294
dnl HP-UX 11 posix -lpthread N (cc) OK
297
dnl IRIX 6.5 posix -lpthread Y 0.5
299
dnl AIX 4.3,5.1 posix -lpthread N AIX 4: 0.5; AIX 5: OK
301
dnl OSF/1 4.0,5.1 posix -pthread (cc) N OK
302
dnl -lpthread (gcc) Y
304
dnl Cygwin posix -lpthread Y OK
306
dnl Any of the above pth -lpth 0.0
312
dnl The test-lock result shows what happens if in test-lock.c EXPLICIT_YIELD is
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.
added
removed
m4/lock.m4
