Annotation of embedaddon/libiconv/srcm4/threadlib.m4, revision 1.1.1.2
1.1.1.2 ! misho 1: # threadlib.m4 serial 8 (gettext-0.18.2)
! 2: dnl Copyright (C) 2005-2011 Free Software Foundation, Inc.
1.1 misho 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.
1.1.1.2 ! misho 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.
1.1 misho 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.
1.1.1.2 ! misho 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=])])
1.1 misho 55: AC_ARG_ENABLE([threads],
1.1.1.2 ! misho 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])]),
1.1 misho 58: [gl_use_threads=$enableval],
59: [if test -n "$gl_use_threads_default"; then
60: gl_use_threads="$gl_use_threads_default"
61: else
1.1.1.2 ! misho 62: changequote(,)dnl
1.1 misho 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().
1.1.1.2 ! misho 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>.
1.1 misho 70: osf*) gl_use_threads=no ;;
1.1.1.2 ! misho 71: cygwin*)
! 72: case `uname -r` in
! 73: 1.[0-5].*) gl_use_threads=no ;;
! 74: *) gl_use_threads=yes ;;
! 75: esac
! 76: ;;
1.1 misho 77: *) gl_use_threads=yes ;;
78: esac
1.1.1.2 ! misho 79: changequote([,])dnl
1.1 misho 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
1.1.1.2 ! misho 90: # causes the AC_LINK_IFELSE test below to succeed unexpectedly,
1.1 misho 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.
1.1.1.2 ! misho 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: ])
1.1 misho 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.
1.1.1.2 ! misho 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);]])],
1.1 misho 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
1.1.1.2 ! misho 207: if case "$gl_cv_have_weak" in *yes) true;; *) false;; esac; then
1.1 misho 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"
1.1.1.2 ! misho 222: AC_LINK_IFELSE(
! 223: [AC_LANG_PROGRAM(
! 224: [[
! 225: #include <thread.h>
! 226: #include <synch.h>
! 227: ]],
! 228: [[thr_self();]])],
1.1 misho 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.])
1.1.1.2 ! misho 239: if case "$gl_cv_have_weak" in *yes) true;; *) false;; esac; then
1.1 misho 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"
1.1.1.2 ! misho 253: LIBS="$LIBS $LIBPTH"
! 254: AC_LINK_IFELSE(
! 255: [AC_LANG_PROGRAM([[#include <pth.h>]], [[pth_self();]])],
! 256: [gl_have_pth=yes])
1.1 misho 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
1.1.1.2 ! misho 267: if case "$gl_cv_have_weak" in *yes) true;; *) false;; esac; then
1.1 misho 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.
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to threadlib.m4 CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libiconv / srcm4