1 # threadlib.m4 serial 6 (gettext-0.18.2)
2 dnl Copyright (C) 2005-2010 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_THREADLIB_EARLY],
26 AC_REQUIRE([gl_THREADLIB_EARLY_BODY])
29 dnl The guts of gl_THREADLIB_EARLY. Needs to be expanded only once.
31 AC_DEFUN([gl_THREADLIB_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"
57 dnl Disable multithreading by default on OSF/1, because it interferes
58 dnl with fork()/exec(): When msgexec is linked with -lpthread, its
59 dnl child process gets an endless segmentation fault inside execvp().
60 dnl Disable multithreading by default on Cygwin 1.5.x, because it has
61 dnl bugs that lead to endless loops or crashes. See
62 dnl <http://cygwin.com/ml/cygwin/2009-08/msg00283.html>.
63 osf*) gl_use_threads=no ;;
66 1.[0-5].*) gl_use_threads=no ;;
67 *) gl_use_threads=yes ;;
70 *) gl_use_threads=yes ;;
75 if test "$gl_use_threads" = yes || test "$gl_use_threads" = posix; then
76 # For using <pthread.h>:
79 # On OSF/1, the compiler needs the flag -D_REENTRANT so that it
80 # groks <pthread.h>. cc also understands the flag -pthread, but
81 # we don't use it because 1. gcc-2.95 doesn't understand -pthread,
82 # 2. putting a flag into CPPFLAGS that has an effect on the linker
83 # causes the AC_LINK_IFELSE test below to succeed unexpectedly,
84 # leading to wrong values of LIBTHREAD and LTLIBTHREAD.
85 CPPFLAGS="$CPPFLAGS -D_REENTRANT"
88 # Some systems optimize for single-threaded programs by default, and
89 # need special flags to disable these optimizations. For example, the
90 # definition of 'errno' in <errno.h>.
92 aix* | freebsd*) CPPFLAGS="$CPPFLAGS -D_THREAD_SAFE" ;;
93 solaris*) CPPFLAGS="$CPPFLAGS -D_REENTRANT" ;;
98 dnl The guts of gl_THREADLIB. Needs to be expanded only once.
100 AC_DEFUN([gl_THREADLIB_BODY],
102 AC_REQUIRE([gl_THREADLIB_EARLY_BODY])
108 if test "$gl_use_threads" != no; then
109 dnl Check whether the compiler and linker support weak declarations.
110 AC_CACHE_CHECK([whether imported symbols can be declared weak],
113 dnl First, test whether the compiler accepts it syntactically.
116 [[extern void xyzzy ();
117 #pragma weak xyzzy]],
119 [gl_cv_have_weak=maybe])
120 if test $gl_cv_have_weak = maybe; then
121 dnl Second, test whether it actually works. On Cygwin 1.7.2, with
122 dnl gcc 4.3, symbols declared weak always evaluate to the address 0.
129 return (fputs == NULL);
131 [gl_cv_have_weak=yes],
132 [gl_cv_have_weak=no],
133 [dnl When cross-compiling, assume that only ELF platforms support
135 AC_EGREP_CPP([Extensible Linking Format],
137 Extensible Linking Format
140 [gl_cv_have_weak="guessing yes"],
141 [gl_cv_have_weak="guessing no"])
145 if test "$gl_use_threads" = yes || test "$gl_use_threads" = posix; then
146 # On OSF/1, the compiler needs the flag -pthread or -D_REENTRANT so that
147 # it groks <pthread.h>. It's added above, in gl_THREADLIB_EARLY_BODY.
148 AC_CHECK_HEADER([pthread.h],
149 [gl_have_pthread_h=yes], [gl_have_pthread_h=no])
150 if test "$gl_have_pthread_h" = yes; then
151 # Other possible tests:
152 # -lpthreads (FSU threads, PCthreads)
155 # Test whether both pthread_mutex_lock and pthread_mutexattr_init exist
156 # in libc. IRIX 6.5 has the first one in both libc and libpthread, but
157 # the second one only in libpthread, and lock.c needs it.
160 [[#include <pthread.h>]],
161 [[pthread_mutex_lock((pthread_mutex_t*)0);
162 pthread_mutexattr_init((pthread_mutexattr_t*)0);]])],
163 [gl_have_pthread=yes])
164 # Test for libpthread by looking for pthread_kill. (Not pthread_self,
165 # since it is defined as a macro on OSF/1.)
166 if test -n "$gl_have_pthread"; then
167 # The program links fine without libpthread. But it may actually
168 # need to link with libpthread in order to create multiple threads.
169 AC_CHECK_LIB([pthread], [pthread_kill],
170 [LIBMULTITHREAD=-lpthread LTLIBMULTITHREAD=-lpthread
171 # On Solaris and HP-UX, most pthread functions exist also in libc.
172 # Therefore pthread_in_use() needs to actually try to create a
173 # thread: pthread_create from libc will fail, whereas
174 # pthread_create will actually create a thread.
177 AC_DEFINE([PTHREAD_IN_USE_DETECTION_HARD], [1],
178 [Define if the pthread_in_use() detection is hard.])
182 # Some library is needed. Try libpthread and libc_r.
183 AC_CHECK_LIB([pthread], [pthread_kill],
185 LIBTHREAD=-lpthread LTLIBTHREAD=-lpthread
186 LIBMULTITHREAD=-lpthread LTLIBMULTITHREAD=-lpthread])
187 if test -z "$gl_have_pthread"; then
189 AC_CHECK_LIB([c_r], [pthread_kill],
191 LIBTHREAD=-lc_r LTLIBTHREAD=-lc_r
192 LIBMULTITHREAD=-lc_r LTLIBMULTITHREAD=-lc_r])
195 if test -n "$gl_have_pthread"; then
197 AC_DEFINE([USE_POSIX_THREADS], [1],
198 [Define if the POSIX multithreading library can be used.])
199 if test -n "$LIBMULTITHREAD" || test -n "$LTLIBMULTITHREAD"; then
200 if case "$gl_cv_have_weak" in *yes) true;; *) false;; esac; then
201 AC_DEFINE([USE_POSIX_THREADS_WEAK], [1],
202 [Define if references to the POSIX multithreading library should be made weak.])
210 if test -z "$gl_have_pthread"; then
211 if test "$gl_use_threads" = yes || test "$gl_use_threads" = solaris; then
212 gl_have_solaristhread=
214 LIBS="$LIBS -lthread"
222 [gl_have_solaristhread=yes])
224 if test -n "$gl_have_solaristhread"; then
225 gl_threads_api=solaris
228 LIBMULTITHREAD="$LIBTHREAD"
229 LTLIBMULTITHREAD="$LTLIBTHREAD"
230 AC_DEFINE([USE_SOLARIS_THREADS], [1],
231 [Define if the old Solaris multithreading library can be used.])
232 if case "$gl_cv_have_weak" in *yes) true;; *) false;; esac; then
233 AC_DEFINE([USE_SOLARIS_THREADS_WEAK], [1],
234 [Define if references to the old Solaris multithreading library should be made weak.])
241 if test "$gl_use_threads" = pth; then
242 gl_save_CPPFLAGS="$CPPFLAGS"
243 AC_LIB_LINKFLAGS([pth])
248 [AC_LANG_PROGRAM([[#include <pth.h>]], [[pth_self();]])],
251 if test -n "$gl_have_pth"; then
254 LTLIBTHREAD="$LTLIBPTH"
255 LIBMULTITHREAD="$LIBTHREAD"
256 LTLIBMULTITHREAD="$LTLIBTHREAD"
257 AC_DEFINE([USE_PTH_THREADS], [1],
258 [Define if the GNU Pth multithreading library can be used.])
259 if test -n "$LIBMULTITHREAD" || test -n "$LTLIBMULTITHREAD"; then
260 if case "$gl_cv_have_weak" in *yes) true;; *) false;; esac; then
261 AC_DEFINE([USE_PTH_THREADS_WEAK], [1],
262 [Define if references to the GNU Pth multithreading library should be made weak.])
268 CPPFLAGS="$gl_save_CPPFLAGS"
271 if test -z "$gl_have_pthread"; then
272 if test "$gl_use_threads" = yes || test "$gl_use_threads" = win32; then
273 if { case "$host_os" in
279 AC_DEFINE([USE_WIN32_THREADS], [1],
280 [Define if the Win32 multithreading API can be used.])
285 AC_MSG_CHECKING([for multithread API to use])
286 AC_MSG_RESULT([$gl_threads_api])
287 AC_SUBST([LIBTHREAD])
288 AC_SUBST([LTLIBTHREAD])
289 AC_SUBST([LIBMULTITHREAD])
290 AC_SUBST([LTLIBMULTITHREAD])
293 AC_DEFUN([gl_THREADLIB],
295 AC_REQUIRE([gl_THREADLIB_EARLY])
296 AC_REQUIRE([gl_THREADLIB_BODY])
300 dnl gl_DISABLE_THREADS
301 dnl ------------------
302 dnl Sets the gl_THREADLIB default so that threads are not used by default.
303 dnl The user can still override it at installation time, by using the
304 dnl configure option '--enable-threads'.
306 AC_DEFUN([gl_DISABLE_THREADS], [
307 m4_divert_text([INIT_PREPARE], [gl_use_threads_default=no])
311 dnl Survey of platforms:
313 dnl Platform Available Compiler Supports test-lock
314 dnl flavours option weak result
315 dnl --------------- --------- --------- -------- ---------
316 dnl Linux 2.4/glibc posix -lpthread Y OK
318 dnl GNU Hurd/glibc posix
320 dnl FreeBSD 5.3 posix -lc_r Y
322 dnl posix -lpthread ? Y
325 dnl FreeBSD 5.2 posix -lc_r Y
329 dnl FreeBSD 4.0,4.10 posix -lc_r Y OK
333 dnl OpenBSD 3.4 posix -lpthread Y OK
335 dnl MacOS X 10.[123] posix -lpthread Y OK
337 dnl Solaris 7,8,9 posix -lpthread Y Sol 7,8: 0.0; Sol 9: OK
338 dnl solaris -lthread Y Sol 7,8: 0.0; Sol 9: OK
340 dnl HP-UX 11 posix -lpthread N (cc) OK
343 dnl IRIX 6.5 posix -lpthread Y 0.5
345 dnl AIX 4.3,5.1 posix -lpthread N AIX 4: 0.5; AIX 5: OK
347 dnl OSF/1 4.0,5.1 posix -pthread (cc) N OK
348 dnl -lpthread (gcc) Y
350 dnl Cygwin posix -lpthread Y OK
352 dnl Any of the above pth -lpth 0.0
358 dnl The test-lock result shows what happens if in test-lock.c EXPLICIT_YIELD is
360 dnl OK if all three tests terminate OK,
361 dnl 0.5 if the first test terminates OK but the second one loops endlessly,
362 dnl 0.0 if the first test already loops endlessly.