Annotation of embedaddon/libiconv/srcm4/threadlib.m4, revision 1.1.1.1
1.1 misho 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.
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 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.
23:
24: AC_DEFUN([gl_THREADLIB_EARLY],
25: [
26: AC_REQUIRE([gl_THREADLIB_EARLY_BODY])
27: ])
28:
29: dnl The guts of gl_THREADLIB_EARLY. Needs to be expanded only once.
30:
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
38:
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: ])
86:
87: dnl The guts of gl_THREADLIB. Needs to be expanded only once.
88:
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: ])
243:
244: AC_DEFUN([gl_THREADLIB],
245: [
246: AC_REQUIRE([gl_THREADLIB_EARLY])
247: AC_REQUIRE([gl_THREADLIB_BODY])
248: ])
249:
250:
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'.
256:
257: AC_DEFUN([gl_DISABLE_THREADS], [
258: m4_divert_text([INIT_PREPARE], [gl_use_threads_default=no])
259: ])
260:
261:
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.
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