1
# threadlib.m4 serial 9 (gettext-0.18.2)
2
dnl Copyright (C) 2005-2012 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 If the configure.ac contains a definition of the gl_THREADLIB_DEFAULT_NO
13
dnl (it must be placed before the invocation of gl_THREADLIB_EARLY!), then the
14
dnl default is 'no', otherwise it is system dependent. In both cases, the user
15
dnl can change the choice through the options --enable-threads=choice or
16
dnl --disable-threads.
17
dnl Defines at most one of the macros USE_POSIX_THREADS, USE_SOLARIS_THREADS,
18
dnl USE_PTH_THREADS, USE_WINDOWS_THREADS
19
dnl Sets the variables LIBTHREAD and LTLIBTHREAD to the linker options for use
20
dnl in a Makefile (LIBTHREAD for use without libtool, LTLIBTHREAD for use with
22
dnl Sets the variables LIBMULTITHREAD and LTLIBMULTITHREAD similarly, for
23
dnl programs that really need multithread functionality. The difference
24
dnl between LIBTHREAD and LIBMULTITHREAD is that on platforms supporting weak
25
dnl symbols, typically LIBTHREAD="" whereas LIBMULTITHREAD="-lpthread".
26
dnl Adds to CPPFLAGS the flag -D_REENTRANT or -D_THREAD_SAFE if needed for
27
dnl multithread-safe programs.
29
AC_DEFUN([gl_THREADLIB_EARLY],
31
AC_REQUIRE([gl_THREADLIB_EARLY_BODY])
34
dnl The guts of gl_THREADLIB_EARLY. Needs to be expanded only once.
36
AC_DEFUN([gl_THREADLIB_EARLY_BODY],
38
dnl Ordering constraints: This macro modifies CPPFLAGS in a way that
39
dnl influences the result of the autoconf tests that test for *_unlocked
40
dnl declarations, on AIX 5 at least. Therefore it must come early.
41
AC_BEFORE([$0], [gl_FUNC_GLIBC_UNLOCKED_IO])dnl
42
AC_BEFORE([$0], [gl_ARGP])dnl
44
AC_REQUIRE([AC_CANONICAL_HOST])
45
dnl _GNU_SOURCE is needed for pthread_rwlock_t on glibc systems.
46
dnl AC_USE_SYSTEM_EXTENSIONS was introduced in autoconf 2.60 and obsoletes
48
m4_ifdef([AC_USE_SYSTEM_EXTENSIONS],
49
[AC_REQUIRE([AC_USE_SYSTEM_EXTENSIONS])],
50
[AC_REQUIRE([AC_GNU_SOURCE])])
51
dnl Check for multithreading.
52
m4_ifdef([gl_THREADLIB_DEFAULT_NO],
53
[m4_divert_text([DEFAULTS], [gl_use_threads_default=no])],
54
[m4_divert_text([DEFAULTS], [gl_use_threads_default=])])
55
AC_ARG_ENABLE([threads],
56
AC_HELP_STRING([--enable-threads={posix|solaris|pth|windows}], [specify multithreading API])m4_ifdef([gl_THREADLIB_DEFAULT_NO], [], [
57
AC_HELP_STRING([--disable-threads], [build without multithread safety])]),
58
[gl_use_threads=$enableval],
59
[if test -n "$gl_use_threads_default"; then
60
gl_use_threads="$gl_use_threads_default"
64
dnl Disable multithreading by default on OSF/1, because it interferes
65
dnl with fork()/exec(): When msgexec is linked with -lpthread, its
66
dnl child process gets an endless segmentation fault inside execvp().
67
dnl Disable multithreading by default on Cygwin 1.5.x, because it has
68
dnl bugs that lead to endless loops or crashes. See
69
dnl <http://cygwin.com/ml/cygwin/2009-08/msg00283.html>.
70
osf*) gl_use_threads=no ;;
73
1.[0-5].*) gl_use_threads=no ;;
74
*) gl_use_threads=yes ;;
77
*) gl_use_threads=yes ;;
82
if test "$gl_use_threads" = yes || test "$gl_use_threads" = posix; then
83
# For using <pthread.h>:
86
# On OSF/1, the compiler needs the flag -D_REENTRANT so that it
87
# groks <pthread.h>. cc also understands the flag -pthread, but
88
# we don't use it because 1. gcc-2.95 doesn't understand -pthread,
89
# 2. putting a flag into CPPFLAGS that has an effect on the linker
90
# causes the AC_LINK_IFELSE test below to succeed unexpectedly,
91
# leading to wrong values of LIBTHREAD and LTLIBTHREAD.
92
CPPFLAGS="$CPPFLAGS -D_REENTRANT"
95
# Some systems optimize for single-threaded programs by default, and
96
# need special flags to disable these optimizations. For example, the
97
# definition of 'errno' in <errno.h>.
99
aix* | freebsd*) CPPFLAGS="$CPPFLAGS -D_THREAD_SAFE" ;;
100
solaris*) CPPFLAGS="$CPPFLAGS -D_REENTRANT" ;;
105
dnl The guts of gl_THREADLIB. Needs to be expanded only once.
107
AC_DEFUN([gl_THREADLIB_BODY],
109
AC_REQUIRE([gl_THREADLIB_EARLY_BODY])
115
if test "$gl_use_threads" != no; then
116
dnl Check whether the compiler and linker support weak declarations.
117
AC_CACHE_CHECK([whether imported symbols can be declared weak],
120
dnl First, test whether the compiler accepts it syntactically.
123
[[extern void xyzzy ();
124
#pragma weak xyzzy]],
126
[gl_cv_have_weak=maybe])
127
if test $gl_cv_have_weak = maybe; then
128
dnl Second, test whether it actually works. On Cygwin 1.7.2, with
129
dnl gcc 4.3, symbols declared weak always evaluate to the address 0.
136
return (fputs == NULL);
138
[gl_cv_have_weak=yes],
139
[gl_cv_have_weak=no],
140
[dnl When cross-compiling, assume that only ELF platforms support
142
AC_EGREP_CPP([Extensible Linking Format],
144
Extensible Linking Format
147
[gl_cv_have_weak="guessing yes"],
148
[gl_cv_have_weak="guessing no"])
152
if test "$gl_use_threads" = yes || test "$gl_use_threads" = posix; then
153
# On OSF/1, the compiler needs the flag -pthread or -D_REENTRANT so that
154
# it groks <pthread.h>. It's added above, in gl_THREADLIB_EARLY_BODY.
155
AC_CHECK_HEADER([pthread.h],
156
[gl_have_pthread_h=yes], [gl_have_pthread_h=no])
157
if test "$gl_have_pthread_h" = yes; then
158
# Other possible tests:
159
# -lpthreads (FSU threads, PCthreads)
162
# Test whether both pthread_mutex_lock and pthread_mutexattr_init exist
163
# in libc. IRIX 6.5 has the first one in both libc and libpthread, but
164
# the second one only in libpthread, and lock.c needs it.
167
[[#include <pthread.h>]],
168
[[pthread_mutex_lock((pthread_mutex_t*)0);
169
pthread_mutexattr_init((pthread_mutexattr_t*)0);]])],
170
[gl_have_pthread=yes])
171
# Test for libpthread by looking for pthread_kill. (Not pthread_self,
172
# since it is defined as a macro on OSF/1.)
173
if test -n "$gl_have_pthread"; then
174
# The program links fine without libpthread. But it may actually
175
# need to link with libpthread in order to create multiple threads.
176
AC_CHECK_LIB([pthread], [pthread_kill],
177
[LIBMULTITHREAD=-lpthread LTLIBMULTITHREAD=-lpthread
178
# On Solaris and HP-UX, most pthread functions exist also in libc.
179
# Therefore pthread_in_use() needs to actually try to create a
180
# thread: pthread_create from libc will fail, whereas
181
# pthread_create will actually create a thread.
184
AC_DEFINE([PTHREAD_IN_USE_DETECTION_HARD], [1],
185
[Define if the pthread_in_use() detection is hard.])
189
# Some library is needed. Try libpthread and libc_r.
190
AC_CHECK_LIB([pthread], [pthread_kill],
192
LIBTHREAD=-lpthread LTLIBTHREAD=-lpthread
193
LIBMULTITHREAD=-lpthread LTLIBMULTITHREAD=-lpthread])
194
if test -z "$gl_have_pthread"; then
196
AC_CHECK_LIB([c_r], [pthread_kill],
198
LIBTHREAD=-lc_r LTLIBTHREAD=-lc_r
199
LIBMULTITHREAD=-lc_r LTLIBMULTITHREAD=-lc_r])
202
if test -n "$gl_have_pthread"; then
204
AC_DEFINE([USE_POSIX_THREADS], [1],
205
[Define if the POSIX multithreading library can be used.])
206
if test -n "$LIBMULTITHREAD" || test -n "$LTLIBMULTITHREAD"; then
207
if case "$gl_cv_have_weak" in *yes) true;; *) false;; esac; then
208
AC_DEFINE([USE_POSIX_THREADS_WEAK], [1],
209
[Define if references to the POSIX multithreading library should be made weak.])
217
if test -z "$gl_have_pthread"; then
218
if test "$gl_use_threads" = yes || test "$gl_use_threads" = solaris; then
219
gl_have_solaristhread=
221
LIBS="$LIBS -lthread"
229
[gl_have_solaristhread=yes])
231
if test -n "$gl_have_solaristhread"; then
232
gl_threads_api=solaris
235
LIBMULTITHREAD="$LIBTHREAD"
236
LTLIBMULTITHREAD="$LTLIBTHREAD"
237
AC_DEFINE([USE_SOLARIS_THREADS], [1],
238
[Define if the old Solaris multithreading library can be used.])
239
if case "$gl_cv_have_weak" in *yes) true;; *) false;; esac; then
240
AC_DEFINE([USE_SOLARIS_THREADS_WEAK], [1],
241
[Define if references to the old Solaris multithreading library should be made weak.])
248
if test "$gl_use_threads" = pth; then
249
gl_save_CPPFLAGS="$CPPFLAGS"
250
AC_LIB_LINKFLAGS([pth])
255
[AC_LANG_PROGRAM([[#include <pth.h>]], [[pth_self();]])],
258
if test -n "$gl_have_pth"; then
261
LTLIBTHREAD="$LTLIBPTH"
262
LIBMULTITHREAD="$LIBTHREAD"
263
LTLIBMULTITHREAD="$LTLIBTHREAD"
264
AC_DEFINE([USE_PTH_THREADS], [1],
265
[Define if the GNU Pth multithreading library can be used.])
266
if test -n "$LIBMULTITHREAD" || test -n "$LTLIBMULTITHREAD"; then
267
if case "$gl_cv_have_weak" in *yes) true;; *) false;; esac; then
268
AC_DEFINE([USE_PTH_THREADS_WEAK], [1],
269
[Define if references to the GNU Pth multithreading library should be made weak.])
275
CPPFLAGS="$gl_save_CPPFLAGS"
278
if test -z "$gl_have_pthread"; then
279
case "$gl_use_threads" in
280
yes | windows | win32) # The 'win32' is for backward compatibility.
281
if { case "$host_os" in
286
gl_threads_api=windows
287
AC_DEFINE([USE_WINDOWS_THREADS], [1],
288
[Define if the native Windows multithreading API can be used.])
294
AC_MSG_CHECKING([for multithread API to use])
295
AC_MSG_RESULT([$gl_threads_api])
296
AC_SUBST([LIBTHREAD])
297
AC_SUBST([LTLIBTHREAD])
298
AC_SUBST([LIBMULTITHREAD])
299
AC_SUBST([LTLIBMULTITHREAD])
302
AC_DEFUN([gl_THREADLIB],
304
AC_REQUIRE([gl_THREADLIB_EARLY])
305
AC_REQUIRE([gl_THREADLIB_BODY])
309
dnl gl_DISABLE_THREADS
310
dnl ------------------
311
dnl Sets the gl_THREADLIB default so that threads are not used by default.
312
dnl The user can still override it at installation time, by using the
313
dnl configure option '--enable-threads'.
315
AC_DEFUN([gl_DISABLE_THREADS], [
316
m4_divert_text([INIT_PREPARE], [gl_use_threads_default=no])
320
dnl Survey of platforms:
322
dnl Platform Available Compiler Supports test-lock
323
dnl flavours option weak result
324
dnl --------------- --------- --------- -------- ---------
325
dnl Linux 2.4/glibc posix -lpthread Y OK
327
dnl GNU Hurd/glibc posix
329
dnl FreeBSD 5.3 posix -lc_r Y
331
dnl posix -lpthread ? Y
334
dnl FreeBSD 5.2 posix -lc_r Y
338
dnl FreeBSD 4.0,4.10 posix -lc_r Y OK
342
dnl OpenBSD 3.4 posix -lpthread Y OK
344
dnl MacOS X 10.[123] posix -lpthread Y OK
346
dnl Solaris 7,8,9 posix -lpthread Y Sol 7,8: 0.0; Sol 9: OK
347
dnl solaris -lthread Y Sol 7,8: 0.0; Sol 9: OK
349
dnl HP-UX 11 posix -lpthread N (cc) OK
352
dnl IRIX 6.5 posix -lpthread Y 0.5
354
dnl AIX 4.3,5.1 posix -lpthread N AIX 4: 0.5; AIX 5: OK
356
dnl OSF/1 4.0,5.1 posix -pthread (cc) N OK
357
dnl -lpthread (gcc) Y
359
dnl Cygwin posix -lpthread Y OK
361
dnl Any of the above pth -lpth 0.0
363
dnl Mingw windows N OK
367
dnl The test-lock result shows what happens if in test-lock.c EXPLICIT_YIELD is
369
dnl OK if all three tests terminate OK,
370
dnl 0.5 if the first test terminates OK but the second one loops endlessly,
371
dnl 0.0 if the first test already loops endlessly.
added
removed
m4/threadlib.m4
