nexmon – Blame information for rev 1

Subversion Repositories:
Rev:
Rev Author Line No. Line
1 office 1 # threadlib.m4 serial 8 (gettext-0.18.2)
2 dnl Copyright (C) 2005-2011 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.
6  
7 dnl From Bruno Haible.
8  
9 dnl gl_THREADLIB
10 dnl ------------
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_WIN32_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
21 dnl libtool).
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.
28  
29 AC_DEFUN([gl_THREADLIB_EARLY],
30 [
31 AC_REQUIRE([gl_THREADLIB_EARLY_BODY])
32 ])
33  
34 dnl The guts of gl_THREADLIB_EARLY. Needs to be expanded only once.
35  
36 AC_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],
56 AC_HELP_STRING([--enable-threads={posix|solaris|pth|win32}], [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"
61 else
62 changequote(,)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
79 changequote([,])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  
105 dnl The guts of gl_THREADLIB. Needs to be expanded only once.
106  
107 AC_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
134 int 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 AC_LINK_IFELSE(
166 [AC_LANG_PROGRAM(
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.
182 case "$host_os" in
183 solaris* | hpux*)
184 AC_DEFINE([PTHREAD_IN_USE_DETECTION_HARD], [1],
185 [Define if the pthread_in_use() detection is hard.])
186 esac
187 ])
188 else
189 # Some library is needed. Try libpthread and libc_r.
190 AC_CHECK_LIB([pthread], [pthread_kill],
191 [gl_have_pthread=yes
192 LIBTHREAD=-lpthread LTLIBTHREAD=-lpthread
193 LIBMULTITHREAD=-lpthread LTLIBMULTITHREAD=-lpthread])
194 if test -z "$gl_have_pthread"; then
195 # For FreeBSD 4.
196 AC_CHECK_LIB([c_r], [pthread_kill],
197 [gl_have_pthread=yes
198 LIBTHREAD=-lc_r LTLIBTHREAD=-lc_r
199 LIBMULTITHREAD=-lc_r LTLIBMULTITHREAD=-lc_r])
200 fi
201 fi
202 if test -n "$gl_have_pthread"; then
203 gl_threads_api=posix
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.])
210 LIBTHREAD=
211 LTLIBTHREAD=
212 fi
213 fi
214 fi
215 fi
216 fi
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=
220 gl_save_LIBS="$LIBS"
221 LIBS="$LIBS -lthread"
222 AC_LINK_IFELSE(
223 [AC_LANG_PROGRAM(
224 [[
225 #include <thread.h>
226 #include <synch.h>
227 ]],
228 [[thr_self();]])],
229 [gl_have_solaristhread=yes])
230 LIBS="$gl_save_LIBS"
231 if test -n "$gl_have_solaristhread"; then
232 gl_threads_api=solaris
233 LIBTHREAD=-lthread
234 LTLIBTHREAD=-lthread
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.])
242 LIBTHREAD=
243 LTLIBTHREAD=
244 fi
245 fi
246 fi
247 fi
248 if test "$gl_use_threads" = pth; then
249 gl_save_CPPFLAGS="$CPPFLAGS"
250 AC_LIB_LINKFLAGS([pth])
251 gl_have_pth=
252 gl_save_LIBS="$LIBS"
253 LIBS="$LIBS $LIBPTH"
254 AC_LINK_IFELSE(
255 [AC_LANG_PROGRAM([[#include <pth.h>]], [[pth_self();]])],
256 [gl_have_pth=yes])
257 LIBS="$gl_save_LIBS"
258 if test -n "$gl_have_pth"; then
259 gl_threads_api=pth
260 LIBTHREAD="$LIBPTH"
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.])
270 LIBTHREAD=
271 LTLIBTHREAD=
272 fi
273 fi
274 else
275 CPPFLAGS="$gl_save_CPPFLAGS"
276 fi
277 fi
278 if test -z "$gl_have_pthread"; then
279 if test "$gl_use_threads" = yes || test "$gl_use_threads" = win32; then
280 if { case "$host_os" in
281 mingw*) true;;
282 *) false;;
283 esac
284 }; then
285 gl_threads_api=win32
286 AC_DEFINE([USE_WIN32_THREADS], [1],
287 [Define if the Win32 multithreading API can be used.])
288 fi
289 fi
290 fi
291 fi
292 AC_MSG_CHECKING([for multithread API to use])
293 AC_MSG_RESULT([$gl_threads_api])
294 AC_SUBST([LIBTHREAD])
295 AC_SUBST([LTLIBTHREAD])
296 AC_SUBST([LIBMULTITHREAD])
297 AC_SUBST([LTLIBMULTITHREAD])
298 ])
299  
300 AC_DEFUN([gl_THREADLIB],
301 [
302 AC_REQUIRE([gl_THREADLIB_EARLY])
303 AC_REQUIRE([gl_THREADLIB_BODY])
304 ])
305  
306  
307 dnl gl_DISABLE_THREADS
308 dnl ------------------
309 dnl Sets the gl_THREADLIB default so that threads are not used by default.
310 dnl The user can still override it at installation time, by using the
311 dnl configure option '--enable-threads'.
312  
313 AC_DEFUN([gl_DISABLE_THREADS], [
314 m4_divert_text([INIT_PREPARE], [gl_use_threads_default=no])
315 ])
316  
317  
318 dnl Survey of platforms:
319 dnl
320 dnl Platform Available Compiler Supports test-lock
321 dnl flavours option weak result
322 dnl --------------- --------- --------- -------- ---------
323 dnl Linux 2.4/glibc posix -lpthread Y OK
324 dnl
325 dnl GNU Hurd/glibc posix
326 dnl
327 dnl FreeBSD 5.3 posix -lc_r Y
328 dnl posix -lkse ? Y
329 dnl posix -lpthread ? Y
330 dnl posix -lthr Y
331 dnl
332 dnl FreeBSD 5.2 posix -lc_r Y
333 dnl posix -lkse Y
334 dnl posix -lthr Y
335 dnl
336 dnl FreeBSD 4.0,4.10 posix -lc_r Y OK
337 dnl
338 dnl NetBSD 1.6 --
339 dnl
340 dnl OpenBSD 3.4 posix -lpthread Y OK
341 dnl
342 dnl MacOS X 10.[123] posix -lpthread Y OK
343 dnl
344 dnl Solaris 7,8,9 posix -lpthread Y Sol 7,8: 0.0; Sol 9: OK
345 dnl solaris -lthread Y Sol 7,8: 0.0; Sol 9: OK
346 dnl
347 dnl HP-UX 11 posix -lpthread N (cc) OK
348 dnl Y (gcc)
349 dnl
350 dnl IRIX 6.5 posix -lpthread Y 0.5
351 dnl
352 dnl AIX 4.3,5.1 posix -lpthread N AIX 4: 0.5; AIX 5: OK
353 dnl
354 dnl OSF/1 4.0,5.1 posix -pthread (cc) N OK
355 dnl -lpthread (gcc) Y
356 dnl
357 dnl Cygwin posix -lpthread Y OK
358 dnl
359 dnl Any of the above pth -lpth 0.0
360 dnl
361 dnl Mingw win32 N OK
362 dnl
363 dnl BeOS 5 --
364 dnl
365 dnl The test-lock result shows what happens if in test-lock.c EXPLICIT_YIELD is
366 dnl turned off:
367 dnl OK if all three tests terminate OK,
368 dnl 0.5 if the first test terminates OK but the second one loops endlessly,
369 dnl 0.0 if the first test already loops endlessly.