linsys: use vlc_strerror_c()
[vlc.git] / m4 / threadlib.m4
1 # threadlib.m4 serial 10 (gettext-0.18.2)
2 dnl Copyright (C) 2005-2013 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_WINDOWS_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|windows}], [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       case "$gl_use_threads" in
280         yes | windows | win32) # The 'win32' is for backward compatibility.
281           if { case "$host_os" in
282                  mingw*) true;;
283                  *) false;;
284                esac
285              }; then
286             gl_threads_api=windows
287             AC_DEFINE([USE_WINDOWS_THREADS], [1],
288               [Define if the native Windows multithreading API can be used.])
289           fi
290           ;;
291       esac
292     fi
293   fi
294   AC_MSG_CHECKING([for multithread API to use])
295   AC_MSG_RESULT([$gl_threads_api])
296   AC_SUBST([LIBTHREAD])
297   AC_SUBST([LTLIBTHREAD])
298   AC_SUBST([LIBMULTITHREAD])
299   AC_SUBST([LTLIBMULTITHREAD])
300 ])
301
302 AC_DEFUN([gl_THREADLIB],
303 [
304   AC_REQUIRE([gl_THREADLIB_EARLY])
305   AC_REQUIRE([gl_THREADLIB_BODY])
306 ])
307
308
309 dnl gl_DISABLE_THREADS
310 dnl ------------------
311 dnl Sets the gl_THREADLIB default so that threads are not used by default.
312 dnl The user can still override it at installation time, by using the
313 dnl configure option '--enable-threads'.
314
315 AC_DEFUN([gl_DISABLE_THREADS], [
316   m4_divert_text([INIT_PREPARE], [gl_use_threads_default=no])
317 ])
318
319
320 dnl Survey of platforms:
321 dnl
322 dnl Platform           Available  Compiler    Supports   test-lock
323 dnl                    flavours   option      weak       result
324 dnl ---------------    ---------  ---------   --------   ---------
325 dnl Linux 2.4/glibc    posix      -lpthread       Y      OK
326 dnl
327 dnl GNU Hurd/glibc     posix
328 dnl
329 dnl FreeBSD 5.3        posix      -lc_r           Y
330 dnl                    posix      -lkse ?         Y
331 dnl                    posix      -lpthread ?     Y
332 dnl                    posix      -lthr           Y
333 dnl
334 dnl FreeBSD 5.2        posix      -lc_r           Y
335 dnl                    posix      -lkse           Y
336 dnl                    posix      -lthr           Y
337 dnl
338 dnl FreeBSD 4.0,4.10   posix      -lc_r           Y      OK
339 dnl
340 dnl NetBSD 1.6         --
341 dnl
342 dnl OpenBSD 3.4        posix      -lpthread       Y      OK
343 dnl
344 dnl Mac OS X 10.[123]  posix      -lpthread       Y      OK
345 dnl
346 dnl Solaris 7,8,9      posix      -lpthread       Y      Sol 7,8: 0.0; Sol 9: OK
347 dnl                    solaris    -lthread        Y      Sol 7,8: 0.0; Sol 9: OK
348 dnl
349 dnl HP-UX 11           posix      -lpthread       N (cc) OK
350 dnl                                               Y (gcc)
351 dnl
352 dnl IRIX 6.5           posix      -lpthread       Y      0.5
353 dnl
354 dnl AIX 4.3,5.1        posix      -lpthread       N      AIX 4: 0.5; AIX 5: OK
355 dnl
356 dnl OSF/1 4.0,5.1      posix      -pthread (cc)   N      OK
357 dnl                               -lpthread (gcc) Y
358 dnl
359 dnl Cygwin             posix      -lpthread       Y      OK
360 dnl
361 dnl Any of the above   pth        -lpth                  0.0
362 dnl
363 dnl Mingw              windows                    N      OK
364 dnl
365 dnl BeOS 5             --
366 dnl
367 dnl The test-lock result shows what happens if in test-lock.c EXPLICIT_YIELD is
368 dnl turned off:
369 dnl   OK if all three tests terminate OK,
370 dnl   0.5 if the first test terminates OK but the second one loops endlessly,
371 dnl   0.0 if the first test already loops endlessly.