• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1# threadlib.m4 serial 10 (gettext-0.18.2)
2dnl Copyright (C) 2005-2012 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 If the configure.ac contains a definition of the gl_THREADLIB_DEFAULT_NO
13dnl (it must be placed before the invocation of gl_THREADLIB_EARLY!), then the
14dnl default is 'no', otherwise it is system dependent. In both cases, the user
15dnl can change the choice through the options --enable-threads=choice or
16dnl --disable-threads.
17dnl Defines at most one of the macros USE_POSIX_THREADS, USE_SOLARIS_THREADS,
18dnl USE_PTH_THREADS, USE_WINDOWS_THREADS
19dnl Sets the variables LIBTHREAD and LTLIBTHREAD to the linker options for use
20dnl in a Makefile (LIBTHREAD for use without libtool, LTLIBTHREAD for use with
21dnl libtool).
22dnl Sets the variables LIBMULTITHREAD and LTLIBMULTITHREAD similarly, for
23dnl programs that really need multithread functionality. The difference
24dnl between LIBTHREAD and LIBMULTITHREAD is that on platforms supporting weak
25dnl symbols, typically LIBTHREAD="" whereas LIBMULTITHREAD="-lpthread".
26dnl Adds to CPPFLAGS the flag -D_REENTRANT or -D_THREAD_SAFE if needed for
27dnl multithread-safe programs.
28
29AC_DEFUN([gl_THREADLIB_EARLY],
30[
31  AC_REQUIRE([gl_THREADLIB_EARLY_BODY])
32])
33
34dnl The guts of gl_THREADLIB_EARLY. Needs to be expanded only once.
35
36AC_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],
56AC_HELP_STRING([--enable-threads={posix|solaris|pth|windows}], [specify multithreading API])m4_ifdef([gl_THREADLIB_DEFAULT_NO], [], [
57AC_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
62changequote(,)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
79changequote([,])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
105dnl The guts of gl_THREADLIB. Needs to be expanded only once.
106
107AC_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
134int 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
302AC_DEFUN([gl_THREADLIB],
303[
304  AC_REQUIRE([gl_THREADLIB_EARLY])
305  AC_REQUIRE([gl_THREADLIB_BODY])
306])
307
308
309dnl gl_DISABLE_THREADS
310dnl ------------------
311dnl Sets the gl_THREADLIB default so that threads are not used by default.
312dnl The user can still override it at installation time, by using the
313dnl configure option '--enable-threads'.
314
315AC_DEFUN([gl_DISABLE_THREADS], [
316  m4_divert_text([INIT_PREPARE], [gl_use_threads_default=no])
317])
318
319
320dnl Survey of platforms:
321dnl
322dnl Platform           Available  Compiler    Supports   test-lock
323dnl                    flavours   option      weak       result
324dnl ---------------    ---------  ---------   --------   ---------
325dnl Linux 2.4/glibc    posix      -lpthread       Y      OK
326dnl
327dnl GNU Hurd/glibc     posix
328dnl
329dnl FreeBSD 5.3        posix      -lc_r           Y
330dnl                    posix      -lkse ?         Y
331dnl                    posix      -lpthread ?     Y
332dnl                    posix      -lthr           Y
333dnl
334dnl FreeBSD 5.2        posix      -lc_r           Y
335dnl                    posix      -lkse           Y
336dnl                    posix      -lthr           Y
337dnl
338dnl FreeBSD 4.0,4.10   posix      -lc_r           Y      OK
339dnl
340dnl NetBSD 1.6         --
341dnl
342dnl OpenBSD 3.4        posix      -lpthread       Y      OK
343dnl
344dnl Mac OS X 10.[123]  posix      -lpthread       Y      OK
345dnl
346dnl Solaris 7,8,9      posix      -lpthread       Y      Sol 7,8: 0.0; Sol 9: OK
347dnl                    solaris    -lthread        Y      Sol 7,8: 0.0; Sol 9: OK
348dnl
349dnl HP-UX 11           posix      -lpthread       N (cc) OK
350dnl                                               Y (gcc)
351dnl
352dnl IRIX 6.5           posix      -lpthread       Y      0.5
353dnl
354dnl AIX 4.3,5.1        posix      -lpthread       N      AIX 4: 0.5; AIX 5: OK
355dnl
356dnl OSF/1 4.0,5.1      posix      -pthread (cc)   N      OK
357dnl                               -lpthread (gcc) Y
358dnl
359dnl Cygwin             posix      -lpthread       Y      OK
360dnl
361dnl Any of the above   pth        -lpth                  0.0
362dnl
363dnl Mingw              windows                    N      OK
364dnl
365dnl BeOS 5             --
366dnl
367dnl The test-lock result shows what happens if in test-lock.c EXPLICIT_YIELD is
368dnl turned off:
369dnl   OK if all three tests terminate OK,
370dnl   0.5 if the first test terminates OK but the second one loops endlessly,
371dnl   0.0 if the first test already loops endlessly.
372