1
# threadlib.m4 serial 11 (gettext-0.18.2)
2
dnl Copyright (C) 2005-2015 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 is empty whereas LIBMULTITHREAD is not.
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
AS_HELP_STRING([--enable-threads={posix|solaris|pth|windows}], [specify multithreading API])m4_ifdef([gl_THREADLIB_DEFAULT_NO], [], [
57
AS_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.
166
# If -pthread works, prefer it to -lpthread, since Ubuntu 14.04
167
# needs -pthread for some reason. See:
168
# http://lists.gnu.org/archive/html/bug-gnulib/2014-09/msg00023.html
170
for gl_pthread in '' '-pthread'; do
171
LIBS="$LIBS $gl_pthread"
174
[[#include <pthread.h>
176
pthread_mutexattr_t ma;
178
[[pthread_mutex_lock (&m);
179
pthread_mutexattr_init (&ma);]])],
181
LIBTHREAD=$gl_pthread LTLIBTHREAD=$gl_pthread
182
LIBMULTITHREAD=$gl_pthread LTLIBMULTITHREAD=$gl_pthread])
184
test -n "$gl_have_pthread" && break
187
# Test for libpthread by looking for pthread_kill. (Not pthread_self,
188
# since it is defined as a macro on OSF/1.)
189
if test -n "$gl_have_pthread" && test -z "$LIBTHREAD"; then
190
# The program links fine without libpthread. But it may actually
191
# need to link with libpthread in order to create multiple threads.
192
AC_CHECK_LIB([pthread], [pthread_kill],
193
[LIBMULTITHREAD=-lpthread LTLIBMULTITHREAD=-lpthread
194
# On Solaris and HP-UX, most pthread functions exist also in libc.
195
# Therefore pthread_in_use() needs to actually try to create a
196
# thread: pthread_create from libc will fail, whereas
197
# pthread_create will actually create a thread.
200
AC_DEFINE([PTHREAD_IN_USE_DETECTION_HARD], [1],
201
[Define if the pthread_in_use() detection is hard.])
204
elif test -z "$gl_have_pthread"; then
205
# Some library is needed. Try libpthread and libc_r.
206
AC_CHECK_LIB([pthread], [pthread_kill],
208
LIBTHREAD=-lpthread LTLIBTHREAD=-lpthread
209
LIBMULTITHREAD=-lpthread LTLIBMULTITHREAD=-lpthread])
210
if test -z "$gl_have_pthread"; then
212
AC_CHECK_LIB([c_r], [pthread_kill],
214
LIBTHREAD=-lc_r LTLIBTHREAD=-lc_r
215
LIBMULTITHREAD=-lc_r LTLIBMULTITHREAD=-lc_r])
218
if test -n "$gl_have_pthread"; then
220
AC_DEFINE([USE_POSIX_THREADS], [1],
221
[Define if the POSIX multithreading library can be used.])
222
if test -n "$LIBMULTITHREAD" || test -n "$LTLIBMULTITHREAD"; then
223
if case "$gl_cv_have_weak" in *yes) true;; *) false;; esac; then
224
AC_DEFINE([USE_POSIX_THREADS_WEAK], [1],
225
[Define if references to the POSIX multithreading library should be made weak.])
233
if test -z "$gl_have_pthread"; then
234
if test "$gl_use_threads" = yes || test "$gl_use_threads" = solaris; then
235
gl_have_solaristhread=
237
LIBS="$LIBS -lthread"
245
[gl_have_solaristhread=yes])
247
if test -n "$gl_have_solaristhread"; then
248
gl_threads_api=solaris
251
LIBMULTITHREAD="$LIBTHREAD"
252
LTLIBMULTITHREAD="$LTLIBTHREAD"
253
AC_DEFINE([USE_SOLARIS_THREADS], [1],
254
[Define if the old Solaris multithreading library can be used.])
255
if case "$gl_cv_have_weak" in *yes) true;; *) false;; esac; then
256
AC_DEFINE([USE_SOLARIS_THREADS_WEAK], [1],
257
[Define if references to the old Solaris multithreading library should be made weak.])
264
if test "$gl_use_threads" = pth; then
265
gl_save_CPPFLAGS="$CPPFLAGS"
266
AC_LIB_LINKFLAGS([pth])
271
[AC_LANG_PROGRAM([[#include <pth.h>]], [[pth_self();]])],
274
if test -n "$gl_have_pth"; then
277
LTLIBTHREAD="$LTLIBPTH"
278
LIBMULTITHREAD="$LIBTHREAD"
279
LTLIBMULTITHREAD="$LTLIBTHREAD"
280
AC_DEFINE([USE_PTH_THREADS], [1],
281
[Define if the GNU Pth multithreading library can be used.])
282
if test -n "$LIBMULTITHREAD" || test -n "$LTLIBMULTITHREAD"; then
283
if case "$gl_cv_have_weak" in *yes) true;; *) false;; esac; then
284
AC_DEFINE([USE_PTH_THREADS_WEAK], [1],
285
[Define if references to the GNU Pth multithreading library should be made weak.])
291
CPPFLAGS="$gl_save_CPPFLAGS"
294
if test -z "$gl_have_pthread"; then
295
case "$gl_use_threads" in
296
yes | windows | win32) # The 'win32' is for backward compatibility.
297
if { case "$host_os" in
302
gl_threads_api=windows
303
AC_DEFINE([USE_WINDOWS_THREADS], [1],
304
[Define if the native Windows multithreading API can be used.])
310
AC_MSG_CHECKING([for multithread API to use])
311
AC_MSG_RESULT([$gl_threads_api])
312
AC_SUBST([LIBTHREAD])
313
AC_SUBST([LTLIBTHREAD])
314
AC_SUBST([LIBMULTITHREAD])
315
AC_SUBST([LTLIBMULTITHREAD])
318
AC_DEFUN([gl_THREADLIB],
320
AC_REQUIRE([gl_THREADLIB_EARLY])
321
AC_REQUIRE([gl_THREADLIB_BODY])
325
dnl gl_DISABLE_THREADS
326
dnl ------------------
327
dnl Sets the gl_THREADLIB default so that threads are not used by default.
328
dnl The user can still override it at installation time, by using the
329
dnl configure option '--enable-threads'.
331
AC_DEFUN([gl_DISABLE_THREADS], [
332
m4_divert_text([INIT_PREPARE], [gl_use_threads_default=no])
336
dnl Survey of platforms:
338
dnl Platform Available Compiler Supports test-lock
339
dnl flavours option weak result
340
dnl --------------- --------- --------- -------- ---------
341
dnl Linux 2.4/glibc posix -lpthread Y OK
343
dnl GNU Hurd/glibc posix
345
dnl Ubuntu 14.04 posix -pthread Y OK
347
dnl FreeBSD 5.3 posix -lc_r Y
349
dnl posix -lpthread ? Y
352
dnl FreeBSD 5.2 posix -lc_r Y
356
dnl FreeBSD 4.0,4.10 posix -lc_r Y OK
360
dnl OpenBSD 3.4 posix -lpthread Y OK
362
dnl Mac OS X 10.[123] posix -lpthread Y OK
364
dnl Solaris 7,8,9 posix -lpthread Y Sol 7,8: 0.0; Sol 9: OK
365
dnl solaris -lthread Y Sol 7,8: 0.0; Sol 9: OK
367
dnl HP-UX 11 posix -lpthread N (cc) OK
370
dnl IRIX 6.5 posix -lpthread Y 0.5
372
dnl AIX 4.3,5.1 posix -lpthread N AIX 4: 0.5; AIX 5: OK
374
dnl OSF/1 4.0,5.1 posix -pthread (cc) N OK
375
dnl -lpthread (gcc) Y
377
dnl Cygwin posix -lpthread Y OK
379
dnl Any of the above pth -lpth 0.0
381
dnl Mingw windows N OK
385
dnl The test-lock result shows what happens if in test-lock.c EXPLICIT_YIELD is
387
dnl OK if all three tests terminate OK,
388
dnl 0.5 if the first test terminates OK but the second one loops endlessly,
389
dnl 0.0 if the first test already loops endlessly.
added
removed
m4/threadlib.m4
