aboutsummaryrefslogtreecommitdiff
path: root/m4/threadlib.m4
diff options
context:
space:
mode:
Diffstat (limited to 'm4/threadlib.m4')
-rw-r--r--m4/threadlib.m4389
1 files changed, 389 insertions, 0 deletions
diff --git a/m4/threadlib.m4 b/m4/threadlib.m4
new file mode 100644
index 0000000..dc9a3d8
--- /dev/null
+++ b/m4/threadlib.m4
@@ -0,0 +1,389 @@
1# threadlib.m4 serial 11 (gettext-0.18.2)
2dnl Copyright (C) 2005-2014 Free Software Foundation, Inc.
3dnl This file is free software; the Free Software Foundation
4dnl gives unlimited permission to copy and/or distribute it,
5dnl with or without modifications, as long as this notice is preserved.
6
7dnl From Bruno Haible.
8
9dnl gl_THREADLIB
10dnl ------------
11dnl Tests for a multithreading library to be used.
12dnl If the configure.ac contains a definition of the gl_THREADLIB_DEFAULT_NO
13dnl (it must be placed before the invocation of gl_THREADLIB_EARLY!), then the
14dnl default is 'no', otherwise it is system dependent. In both cases, the user
15dnl can change the choice through the options --enable-threads=choice or
16dnl --disable-threads.
17dnl Defines at most one of the macros USE_POSIX_THREADS, USE_SOLARIS_THREADS,
18dnl USE_PTH_THREADS, USE_WINDOWS_THREADS
19dnl Sets the variables LIBTHREAD and LTLIBTHREAD to the linker options for use
20dnl in a Makefile (LIBTHREAD for use without libtool, LTLIBTHREAD for use with
21dnl libtool).
22dnl Sets the variables LIBMULTITHREAD and LTLIBMULTITHREAD similarly, for
23dnl programs that really need multithread functionality. The difference
24dnl between LIBTHREAD and LIBMULTITHREAD is that on platforms supporting weak
25dnl symbols, typically LIBTHREAD is empty whereas LIBMULTITHREAD is not.
26dnl Adds to CPPFLAGS the flag -D_REENTRANT or -D_THREAD_SAFE if needed for
27dnl multithread-safe programs.
28
29AC_DEFUN([gl_THREADLIB_EARLY],
30[
31 AC_REQUIRE([gl_THREADLIB_EARLY_BODY])
32])
33
34dnl The guts of gl_THREADLIB_EARLY. Needs to be expanded only once.
35
36AC_DEFUN([gl_THREADLIB_EARLY_BODY],
37[
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
43
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
47 dnl AC_GNU_SOURCE.
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],
56AC_HELP_STRING([--enable-threads={posix|solaris|pth|windows}], [specify multithreading API])m4_ifdef([gl_THREADLIB_DEFAULT_NO], [], [
57AC_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"
61 else
62changequote(,)dnl
63 case "$host_os" in
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 ;;
71 cygwin*)
72 case `uname -r` in
73 1.[0-5].*) gl_use_threads=no ;;
74 *) gl_use_threads=yes ;;
75 esac
76 ;;
77 *) gl_use_threads=yes ;;
78 esac
79changequote([,])dnl
80 fi
81 ])
82 if test "$gl_use_threads" = yes || test "$gl_use_threads" = posix; then
83 # For using <pthread.h>:
84 case "$host_os" in
85 osf*)
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"
93 ;;
94 esac
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>.
98 case "$host_os" in
99 aix* | freebsd*) CPPFLAGS="$CPPFLAGS -D_THREAD_SAFE" ;;
100 solaris*) CPPFLAGS="$CPPFLAGS -D_REENTRANT" ;;
101 esac
102 fi
103])
104
105dnl The guts of gl_THREADLIB. Needs to be expanded only once.
106
107AC_DEFUN([gl_THREADLIB_BODY],
108[
109 AC_REQUIRE([gl_THREADLIB_EARLY_BODY])
110 gl_threads_api=none
111 LIBTHREAD=
112 LTLIBTHREAD=
113 LIBMULTITHREAD=
114 LTLIBMULTITHREAD=
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],
118 [gl_cv_have_weak],
119 [gl_cv_have_weak=no
120 dnl First, test whether the compiler accepts it syntactically.
121 AC_LINK_IFELSE(
122 [AC_LANG_PROGRAM(
123 [[extern void xyzzy ();
124#pragma weak xyzzy]],
125 [[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.
130 AC_RUN_IFELSE(
131 [AC_LANG_SOURCE([[
132#include <stdio.h>
133#pragma weak fputs
134int main ()
135{
136 return (fputs == NULL);
137}]])],
138 [gl_cv_have_weak=yes],
139 [gl_cv_have_weak=no],
140 [dnl When cross-compiling, assume that only ELF platforms support
141 dnl weak symbols.
142 AC_EGREP_CPP([Extensible Linking Format],
143 [#ifdef __ELF__
144 Extensible Linking Format
145 #endif
146 ],
147 [gl_cv_have_weak="guessing yes"],
148 [gl_cv_have_weak="guessing no"])
149 ])
150 fi
151 ])
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)
160 # -lgthreads
161 gl_have_pthread=
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.
165 #
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
169 save_LIBS=$LIBS
170 for gl_pthread in '' '-pthread'; do
171 LIBS="$LIBS $gl_pthread"
172 AC_LINK_IFELSE(
173 [AC_LANG_PROGRAM(
174 [[#include <pthread.h>
175 pthread_mutex_t m;
176 pthread_mutexattr_t ma;
177 ]],
178 [[pthread_mutex_lock (&m);
179 pthread_mutexattr_init (&ma);]])],
180 [gl_have_pthread=yes
181 LIBTHREAD=$gl_pthread LTLIBTHREAD=$gl_pthread
182 LIBMULTITHREAD=$gl_pthread LTLIBMULTITHREAD=$gl_pthread])
183 LIBS=$save_LIBS
184 test -n "$gl_have_pthread" && break
185 done
186
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.
198 case "$host_os" in
199 solaris* | hpux*)
200 AC_DEFINE([PTHREAD_IN_USE_DETECTION_HARD], [1],
201 [Define if the pthread_in_use() detection is hard.])
202 esac
203 ])
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],
207 [gl_have_pthread=yes
208 LIBTHREAD=-lpthread LTLIBTHREAD=-lpthread
209 LIBMULTITHREAD=-lpthread LTLIBMULTITHREAD=-lpthread])
210 if test -z "$gl_have_pthread"; then
211 # For FreeBSD 4.
212 AC_CHECK_LIB([c_r], [pthread_kill],
213 [gl_have_pthread=yes
214 LIBTHREAD=-lc_r LTLIBTHREAD=-lc_r
215 LIBMULTITHREAD=-lc_r LTLIBMULTITHREAD=-lc_r])
216 fi
217 fi
218 if test -n "$gl_have_pthread"; then
219 gl_threads_api=posix
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.])
226 LIBTHREAD=
227 LTLIBTHREAD=
228 fi
229 fi
230 fi
231 fi
232 fi
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=
236 gl_save_LIBS="$LIBS"
237 LIBS="$LIBS -lthread"
238 AC_LINK_IFELSE(
239 [AC_LANG_PROGRAM(
240 [[
241#include <thread.h>
242#include <synch.h>
243 ]],
244 [[thr_self();]])],
245 [gl_have_solaristhread=yes])
246 LIBS="$gl_save_LIBS"
247 if test -n "$gl_have_solaristhread"; then
248 gl_threads_api=solaris
249 LIBTHREAD=-lthread
250 LTLIBTHREAD=-lthread
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.])
258 LIBTHREAD=
259 LTLIBTHREAD=
260 fi
261 fi
262 fi
263 fi
264 if test "$gl_use_threads" = pth; then
265 gl_save_CPPFLAGS="$CPPFLAGS"
266 AC_LIB_LINKFLAGS([pth])
267 gl_have_pth=
268 gl_save_LIBS="$LIBS"
269 LIBS="$LIBS $LIBPTH"
270 AC_LINK_IFELSE(
271 [AC_LANG_PROGRAM([[#include <pth.h>]], [[pth_self();]])],
272 [gl_have_pth=yes])
273 LIBS="$gl_save_LIBS"
274 if test -n "$gl_have_pth"; then
275 gl_threads_api=pth
276 LIBTHREAD="$LIBPTH"
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.])
286 LIBTHREAD=
287 LTLIBTHREAD=
288 fi
289 fi
290 else
291 CPPFLAGS="$gl_save_CPPFLAGS"
292 fi
293 fi
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
298 mingw*) true;;
299 *) false;;
300 esac
301 }; then
302 gl_threads_api=windows
303 AC_DEFINE([USE_WINDOWS_THREADS], [1],
304 [Define if the native Windows multithreading API can be used.])
305 fi
306 ;;
307 esac
308 fi
309 fi
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])
316])
317
318AC_DEFUN([gl_THREADLIB],
319[
320 AC_REQUIRE([gl_THREADLIB_EARLY])
321 AC_REQUIRE([gl_THREADLIB_BODY])
322])
323
324
325dnl gl_DISABLE_THREADS
326dnl ------------------
327dnl Sets the gl_THREADLIB default so that threads are not used by default.
328dnl The user can still override it at installation time, by using the
329dnl configure option '--enable-threads'.
330
331AC_DEFUN([gl_DISABLE_THREADS], [
332 m4_divert_text([INIT_PREPARE], [gl_use_threads_default=no])
333])
334
335
336dnl Survey of platforms:
337dnl
338dnl Platform Available Compiler Supports test-lock
339dnl flavours option weak result
340dnl --------------- --------- --------- -------- ---------
341dnl Linux 2.4/glibc posix -lpthread Y OK
342dnl
343dnl GNU Hurd/glibc posix
344dnl
345dnl Ubuntu 14.04 posix -pthread Y OK
346dnl
347dnl FreeBSD 5.3 posix -lc_r Y
348dnl posix -lkse ? Y
349dnl posix -lpthread ? Y
350dnl posix -lthr Y
351dnl
352dnl FreeBSD 5.2 posix -lc_r Y
353dnl posix -lkse Y
354dnl posix -lthr Y
355dnl
356dnl FreeBSD 4.0,4.10 posix -lc_r Y OK
357dnl
358dnl NetBSD 1.6 --
359dnl
360dnl OpenBSD 3.4 posix -lpthread Y OK
361dnl
362dnl Mac OS X 10.[123] posix -lpthread Y OK
363dnl
364dnl Solaris 7,8,9 posix -lpthread Y Sol 7,8: 0.0; Sol 9: OK
365dnl solaris -lthread Y Sol 7,8: 0.0; Sol 9: OK
366dnl
367dnl HP-UX 11 posix -lpthread N (cc) OK
368dnl Y (gcc)
369dnl
370dnl IRIX 6.5 posix -lpthread Y 0.5
371dnl
372dnl AIX 4.3,5.1 posix -lpthread N AIX 4: 0.5; AIX 5: OK
373dnl
374dnl OSF/1 4.0,5.1 posix -pthread (cc) N OK
375dnl -lpthread (gcc) Y
376dnl
377dnl Cygwin posix -lpthread Y OK
378dnl
379dnl Any of the above pth -lpth 0.0
380dnl
381dnl Mingw windows N OK
382dnl
383dnl BeOS 5 --
384dnl
385dnl The test-lock result shows what happens if in test-lock.c EXPLICIT_YIELD is
386dnl turned off:
387dnl OK if all three tests terminate OK,
388dnl 0.5 if the first test terminates OK but the second one loops endlessly,
389dnl 0.0 if the first test already loops endlessly.