1# threadlib.m4 serial 5 (gettext-0.18)
2dnl Copyright (C) 2005-2010 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 Defines at most one of the macros USE_POSIX_THREADS, USE_SOLARIS_THREADS,
13dnl USE_PTH_THREADS, USE_WIN32_THREADS
14dnl Sets the variables LIBTHREAD and LTLIBTHREAD to the linker options for use
15dnl in a Makefile (LIBTHREAD for use without libtool, LTLIBTHREAD for use with
16dnl libtool).
17dnl Sets the variables LIBMULTITHREAD and LTLIBMULTITHREAD similarly, for
18dnl programs that really need multithread functionality. The difference
19dnl between LIBTHREAD and LIBMULTITHREAD is that on platforms supporting weak
20dnl symbols, typically LIBTHREAD="" whereas LIBMULTITHREAD="-lpthread".
21dnl Adds to CPPFLAGS the flag -D_REENTRANT or -D_THREAD_SAFE if needed for
22dnl multithread-safe programs.
23
24AC_DEFUN([gl_THREADLIB_EARLY],
25[
26  AC_REQUIRE([gl_THREADLIB_EARLY_BODY])
27])
28
29dnl The guts of gl_THREADLIB_EARLY. Needs to be expanded only once.
30
31AC_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],
49AC_HELP_STRING([--enable-threads={posix|solaris|pth|win32}], [specify multithreading API])
50AC_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
55changequote(,)dnl
56       case "$host_os" in
57         dnl Disable multithreading by default on OSF/1, because it interferes
58         dnl with fork()/exec(): When msgexec is linked with -lpthread, its
59         dnl child process gets an endless segmentation fault inside execvp().
60         dnl Disable multithreading by default on Cygwin 1.5.x, because it has
61         dnl bugs that lead to endless loops or crashes. See
62         dnl <http://cygwin.com/ml/cygwin/2009-08/msg00283.html>.
63         osf*) gl_use_threads=no ;;
64         cygwin*)
65               case `uname -r` in
66                 1.[0-5].*) gl_use_threads=no ;;
67                 *)         gl_use_threads=yes ;;
68               esac
69               ;;
70         *)    gl_use_threads=yes ;;
71       esac
72changequote([,])dnl
73     fi
74    ])
75  if test "$gl_use_threads" = yes || test "$gl_use_threads" = posix; then
76    # For using <pthread.h>:
77    case "$host_os" in
78      osf*)
79        # On OSF/1, the compiler needs the flag -D_REENTRANT so that it
80        # groks <pthread.h>. cc also understands the flag -pthread, but
81        # we don't use it because 1. gcc-2.95 doesn't understand -pthread,
82        # 2. putting a flag into CPPFLAGS that has an effect on the linker
83        # causes the AC_TRY_LINK test below to succeed unexpectedly,
84        # leading to wrong values of LIBTHREAD and LTLIBTHREAD.
85        CPPFLAGS="$CPPFLAGS -D_REENTRANT"
86        ;;
87    esac
88    # Some systems optimize for single-threaded programs by default, and
89    # need special flags to disable these optimizations. For example, the
90    # definition of 'errno' in <errno.h>.
91    case "$host_os" in
92      aix* | freebsd*) CPPFLAGS="$CPPFLAGS -D_THREAD_SAFE" ;;
93      solaris*) CPPFLAGS="$CPPFLAGS -D_REENTRANT" ;;
94    esac
95  fi
96])
97
98dnl The guts of gl_THREADLIB. Needs to be expanded only once.
99
100AC_DEFUN([gl_THREADLIB_BODY],
101[
102  AC_REQUIRE([gl_THREADLIB_EARLY_BODY])
103  gl_threads_api=none
104  LIBTHREAD=
105  LTLIBTHREAD=
106  LIBMULTITHREAD=
107  LTLIBMULTITHREAD=
108  if test "$gl_use_threads" != no; then
109    dnl Check whether the compiler and linker support weak declarations.
110    AC_CACHE_CHECK([whether imported symbols can be declared weak],
111      [gl_cv_have_weak],
112      [gl_cv_have_weak=no
113       dnl First, test whether the compiler accepts it syntactically.
114       AC_TRY_LINK([extern void xyzzy ();
115#pragma weak xyzzy], [xyzzy();], [gl_cv_have_weak=maybe])
116       if test $gl_cv_have_weak = maybe; then
117         dnl Second, test whether it actually works. On Cygwin 1.7.2, with
118         dnl gcc 4.3, symbols declared weak always evaluate to the address 0.
119         AC_TRY_RUN([
120#include <stdio.h>
121#pragma weak fputs
122int main ()
123{
124  return (fputs == NULL);
125}], [gl_cv_have_weak=yes], [gl_cv_have_weak=no],
126           [dnl When cross-compiling, assume that only ELF platforms support
127            dnl weak symbols.
128            AC_EGREP_CPP([Extensible Linking Format],
129              [#ifdef __ELF__
130               Extensible Linking Format
131               #endif
132              ],
133              [gl_cv_have_weak="guessing yes"],
134              [gl_cv_have_weak="guessing no"])
135           ])
136       fi
137      ])
138    if test "$gl_use_threads" = yes || test "$gl_use_threads" = posix; then
139      # On OSF/1, the compiler needs the flag -pthread or -D_REENTRANT so that
140      # it groks <pthread.h>. It's added above, in gl_THREADLIB_EARLY_BODY.
141      AC_CHECK_HEADER([pthread.h],
142        [gl_have_pthread_h=yes], [gl_have_pthread_h=no])
143      if test "$gl_have_pthread_h" = yes; then
144        # Other possible tests:
145        #   -lpthreads (FSU threads, PCthreads)
146        #   -lgthreads
147        gl_have_pthread=
148        # Test whether both pthread_mutex_lock and pthread_mutexattr_init exist
149        # in libc. IRIX 6.5 has the first one in both libc and libpthread, but
150        # the second one only in libpthread, and lock.c needs it.
151        AC_TRY_LINK([#include <pthread.h>],
152          [pthread_mutex_lock((pthread_mutex_t*)0);
153           pthread_mutexattr_init((pthread_mutexattr_t*)0);],
154          [gl_have_pthread=yes])
155        # Test for libpthread by looking for pthread_kill. (Not pthread_self,
156        # since it is defined as a macro on OSF/1.)
157        if test -n "$gl_have_pthread"; then
158          # The program links fine without libpthread. But it may actually
159          # need to link with libpthread in order to create multiple threads.
160          AC_CHECK_LIB([pthread], [pthread_kill],
161            [LIBMULTITHREAD=-lpthread LTLIBMULTITHREAD=-lpthread
162             # On Solaris and HP-UX, most pthread functions exist also in libc.
163             # Therefore pthread_in_use() needs to actually try to create a
164             # thread: pthread_create from libc will fail, whereas
165             # pthread_create will actually create a thread.
166             case "$host_os" in
167               solaris* | hpux*)
168                 AC_DEFINE([PTHREAD_IN_USE_DETECTION_HARD], [1],
169                   [Define if the pthread_in_use() detection is hard.])
170             esac
171            ])
172        else
173          # Some library is needed. Try libpthread and libc_r.
174          AC_CHECK_LIB([pthread], [pthread_kill],
175            [gl_have_pthread=yes
176             LIBTHREAD=-lpthread LTLIBTHREAD=-lpthread
177             LIBMULTITHREAD=-lpthread LTLIBMULTITHREAD=-lpthread])
178          if test -z "$gl_have_pthread"; then
179            # For FreeBSD 4.
180            AC_CHECK_LIB([c_r], [pthread_kill],
181              [gl_have_pthread=yes
182               LIBTHREAD=-lc_r LTLIBTHREAD=-lc_r
183               LIBMULTITHREAD=-lc_r LTLIBMULTITHREAD=-lc_r])
184          fi
185        fi
186        if test -n "$gl_have_pthread"; then
187          gl_threads_api=posix
188          AC_DEFINE([USE_POSIX_THREADS], [1],
189            [Define if the POSIX multithreading library can be used.])
190          if test -n "$LIBMULTITHREAD" || test -n "$LTLIBMULTITHREAD"; then
191            if case "$gl_cv_have_weak" in *yes) true;; *) false;; esac; then
192              AC_DEFINE([USE_POSIX_THREADS_WEAK], [1],
193                [Define if references to the POSIX multithreading library should be made weak.])
194              LIBTHREAD=
195              LTLIBTHREAD=
196            fi
197          fi
198        fi
199      fi
200    fi
201    if test -z "$gl_have_pthread"; then
202      if test "$gl_use_threads" = yes || test "$gl_use_threads" = solaris; then
203        gl_have_solaristhread=
204        gl_save_LIBS="$LIBS"
205        LIBS="$LIBS -lthread"
206        AC_TRY_LINK([#include <thread.h>
207#include <synch.h>],
208          [thr_self();],
209          [gl_have_solaristhread=yes])
210        LIBS="$gl_save_LIBS"
211        if test -n "$gl_have_solaristhread"; then
212          gl_threads_api=solaris
213          LIBTHREAD=-lthread
214          LTLIBTHREAD=-lthread
215          LIBMULTITHREAD="$LIBTHREAD"
216          LTLIBMULTITHREAD="$LTLIBTHREAD"
217          AC_DEFINE([USE_SOLARIS_THREADS], [1],
218            [Define if the old Solaris multithreading library can be used.])
219          if case "$gl_cv_have_weak" in *yes) true;; *) false;; esac; then
220            AC_DEFINE([USE_SOLARIS_THREADS_WEAK], [1],
221              [Define if references to the old Solaris multithreading library should be made weak.])
222            LIBTHREAD=
223            LTLIBTHREAD=
224          fi
225        fi
226      fi
227    fi
228    if test "$gl_use_threads" = pth; then
229      gl_save_CPPFLAGS="$CPPFLAGS"
230      AC_LIB_LINKFLAGS([pth])
231      gl_have_pth=
232      gl_save_LIBS="$LIBS"
233      LIBS="$LIBS -lpth"
234      AC_TRY_LINK([#include <pth.h>], [pth_self();], [gl_have_pth=yes])
235      LIBS="$gl_save_LIBS"
236      if test -n "$gl_have_pth"; then
237        gl_threads_api=pth
238        LIBTHREAD="$LIBPTH"
239        LTLIBTHREAD="$LTLIBPTH"
240        LIBMULTITHREAD="$LIBTHREAD"
241        LTLIBMULTITHREAD="$LTLIBTHREAD"
242        AC_DEFINE([USE_PTH_THREADS], [1],
243          [Define if the GNU Pth multithreading library can be used.])
244        if test -n "$LIBMULTITHREAD" || test -n "$LTLIBMULTITHREAD"; then
245          if case "$gl_cv_have_weak" in *yes) true;; *) false;; esac; then
246            AC_DEFINE([USE_PTH_THREADS_WEAK], [1],
247              [Define if references to the GNU Pth multithreading library should be made weak.])
248            LIBTHREAD=
249            LTLIBTHREAD=
250          fi
251        fi
252      else
253        CPPFLAGS="$gl_save_CPPFLAGS"
254      fi
255    fi
256    if test -z "$gl_have_pthread"; then
257      if test "$gl_use_threads" = yes || test "$gl_use_threads" = win32; then
258        if { case "$host_os" in
259               mingw*) true;;
260               *) false;;
261             esac
262           }; then
263          gl_threads_api=win32
264          AC_DEFINE([USE_WIN32_THREADS], [1],
265            [Define if the Win32 multithreading API can be used.])
266        fi
267      fi
268    fi
269  fi
270  AC_MSG_CHECKING([for multithread API to use])
271  AC_MSG_RESULT([$gl_threads_api])
272  AC_SUBST([LIBTHREAD])
273  AC_SUBST([LTLIBTHREAD])
274  AC_SUBST([LIBMULTITHREAD])
275  AC_SUBST([LTLIBMULTITHREAD])
276])
277
278AC_DEFUN([gl_THREADLIB],
279[
280  AC_REQUIRE([gl_THREADLIB_EARLY])
281  AC_REQUIRE([gl_THREADLIB_BODY])
282])
283
284
285dnl gl_DISABLE_THREADS
286dnl ------------------
287dnl Sets the gl_THREADLIB default so that threads are not used by default.
288dnl The user can still override it at installation time, by using the
289dnl configure option '--enable-threads'.
290
291AC_DEFUN([gl_DISABLE_THREADS], [
292  m4_divert_text([INIT_PREPARE], [gl_use_threads_default=no])
293])
294
295
296dnl Survey of platforms:
297dnl
298dnl Platform          Available   Compiler    Supports   test-lock
299dnl                   flavours    option      weak       result
300dnl ---------------   ---------   ---------   --------   ---------
301dnl Linux 2.4/glibc   posix       -lpthread       Y      OK
302dnl
303dnl GNU Hurd/glibc    posix
304dnl
305dnl FreeBSD 5.3       posix       -lc_r           Y
306dnl                   posix       -lkse ?         Y
307dnl                   posix       -lpthread ?     Y
308dnl                   posix       -lthr           Y
309dnl
310dnl FreeBSD 5.2       posix       -lc_r           Y
311dnl                   posix       -lkse           Y
312dnl                   posix       -lthr           Y
313dnl
314dnl FreeBSD 4.0,4.10  posix       -lc_r           Y      OK
315dnl
316dnl NetBSD 1.6        --
317dnl
318dnl OpenBSD 3.4       posix       -lpthread       Y      OK
319dnl
320dnl MacOS X 10.[123]  posix       -lpthread       Y      OK
321dnl
322dnl Solaris 7,8,9     posix       -lpthread       Y      Sol 7,8: 0.0; Sol 9: OK
323dnl                   solaris     -lthread        Y      Sol 7,8: 0.0; Sol 9: OK
324dnl
325dnl HP-UX 11          posix       -lpthread       N (cc) OK
326dnl                                               Y (gcc)
327dnl
328dnl IRIX 6.5          posix       -lpthread       Y      0.5
329dnl
330dnl AIX 4.3,5.1       posix       -lpthread       N      AIX 4: 0.5; AIX 5: OK
331dnl
332dnl OSF/1 4.0,5.1     posix       -pthread (cc)   N      OK
333dnl                               -lpthread (gcc) Y
334dnl
335dnl Cygwin            posix       -lpthread       Y      OK
336dnl
337dnl Any of the above  pth         -lpth                  0.0
338dnl
339dnl Mingw             win32                       N      OK
340dnl
341dnl BeOS 5            --
342dnl
343dnl The test-lock result shows what happens if in test-lock.c EXPLICIT_YIELD is
344dnl turned off:
345dnl   OK if all three tests terminate OK,
346dnl   0.5 if the first test terminates OK but the second one loops endlessly,
347dnl   0.0 if the first test already loops endlessly.
348