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