git.gag.com Git - debian/amanda/blob - config/gnulib/threadlib.m4

   1 # threadlib.m4 serial 6 (gettext-0.18.2)
   2 dnl Copyright (C) 2005-2010 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 changequote(,)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
  72 changequote([,])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_LINK_IFELSE 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
  98 dnl The guts of gl_THREADLIB. Needs to be expanded only once.
  99
 100 AC_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_LINK_IFELSE(
 115          [AC_LANG_PROGRAM(
 116             [[extern void xyzzy ();
 117 #pragma weak xyzzy]],
 118             [[xyzzy();]])],
 119          [gl_cv_have_weak=maybe])
 120        if test $gl_cv_have_weak = maybe; then
 121          dnl Second, test whether it actually works. On Cygwin 1.7.2, with
 122          dnl gcc 4.3, symbols declared weak always evaluate to the address 0.
 123          AC_RUN_IFELSE(
 124            [AC_LANG_SOURCE([[
 125 #include <stdio.h>
 126 #pragma weak fputs
 127 int main ()
 128 {
 129   return (fputs == NULL);
 130 }]])],
 131            [gl_cv_have_weak=yes],
 132            [gl_cv_have_weak=no],
 133            [dnl When cross-compiling, assume that only ELF platforms support
 134             dnl weak symbols.
 135             AC_EGREP_CPP([Extensible Linking Format],
 136               [#ifdef __ELF__
 137                Extensible Linking Format
 138                #endif
 139               ],
 140               [gl_cv_have_weak="guessing yes"],
 141               [gl_cv_have_weak="guessing no"])
 142            ])
 143        fi
 144       ])
 145     if test "$gl_use_threads" = yes || test "$gl_use_threads" = posix; then
 146       # On OSF/1, the compiler needs the flag -pthread or -D_REENTRANT so that
 147       # it groks <pthread.h>. It's added above, in gl_THREADLIB_EARLY_BODY.
 148       AC_CHECK_HEADER([pthread.h],
 149         [gl_have_pthread_h=yes], [gl_have_pthread_h=no])
 150       if test "$gl_have_pthread_h" = yes; then
 151         # Other possible tests:
 152         #   -lpthreads (FSU threads, PCthreads)
 153         #   -lgthreads
 154         gl_have_pthread=
 155         # Test whether both pthread_mutex_lock and pthread_mutexattr_init exist
 156         # in libc. IRIX 6.5 has the first one in both libc and libpthread, but
 157         # the second one only in libpthread, and lock.c needs it.
 158         AC_LINK_IFELSE(
 159           [AC_LANG_PROGRAM(
 160              [[#include <pthread.h>]],
 161              [[pthread_mutex_lock((pthread_mutex_t*)0);
 162                pthread_mutexattr_init((pthread_mutexattr_t*)0);]])],
 163           [gl_have_pthread=yes])
 164         # Test for libpthread by looking for pthread_kill. (Not pthread_self,
 165         # since it is defined as a macro on OSF/1.)
 166         if test -n "$gl_have_pthread"; then
 167           # The program links fine without libpthread. But it may actually
 168           # need to link with libpthread in order to create multiple threads.
 169           AC_CHECK_LIB([pthread], [pthread_kill],
 170             [LIBMULTITHREAD=-lpthread LTLIBMULTITHREAD=-lpthread
 171              # On Solaris and HP-UX, most pthread functions exist also in libc.
 172              # Therefore pthread_in_use() needs to actually try to create a
 173              # thread: pthread_create from libc will fail, whereas
 174              # pthread_create will actually create a thread.
 175              case "$host_os" in
 176                solaris* | hpux*)
 177                  AC_DEFINE([PTHREAD_IN_USE_DETECTION_HARD], [1],
 178                    [Define if the pthread_in_use() detection is hard.])
 179              esac
 180             ])
 181         else
 182           # Some library is needed. Try libpthread and libc_r.
 183           AC_CHECK_LIB([pthread], [pthread_kill],
 184             [gl_have_pthread=yes
 185              LIBTHREAD=-lpthread LTLIBTHREAD=-lpthread
 186              LIBMULTITHREAD=-lpthread LTLIBMULTITHREAD=-lpthread])
 187           if test -z "$gl_have_pthread"; then
 188             # For FreeBSD 4.
 189             AC_CHECK_LIB([c_r], [pthread_kill],
 190               [gl_have_pthread=yes
 191                LIBTHREAD=-lc_r LTLIBTHREAD=-lc_r
 192                LIBMULTITHREAD=-lc_r LTLIBMULTITHREAD=-lc_r])
 193           fi
 194         fi
 195         if test -n "$gl_have_pthread"; then
 196           gl_threads_api=posix
 197           AC_DEFINE([USE_POSIX_THREADS], [1],
 198             [Define if the POSIX multithreading library can be used.])
 199           if test -n "$LIBMULTITHREAD" || test -n "$LTLIBMULTITHREAD"; then
 200             if case "$gl_cv_have_weak" in *yes) true;; *) false;; esac; then
 201               AC_DEFINE([USE_POSIX_THREADS_WEAK], [1],
 202                 [Define if references to the POSIX multithreading library should be made weak.])
 203               LIBTHREAD=
 204               LTLIBTHREAD=
 205             fi
 206           fi
 207         fi
 208       fi
 209     fi
 210     if test -z "$gl_have_pthread"; then
 211       if test "$gl_use_threads" = yes || test "$gl_use_threads" = solaris; then
 212         gl_have_solaristhread=
 213         gl_save_LIBS="$LIBS"
 214         LIBS="$LIBS -lthread"
 215         AC_LINK_IFELSE(
 216           [AC_LANG_PROGRAM(
 217              [[
 218 #include <thread.h>
 219 #include <synch.h>
 220              ]],
 221              [[thr_self();]])],
 222           [gl_have_solaristhread=yes])
 223         LIBS="$gl_save_LIBS"
 224         if test -n "$gl_have_solaristhread"; then
 225           gl_threads_api=solaris
 226           LIBTHREAD=-lthread
 227           LTLIBTHREAD=-lthread
 228           LIBMULTITHREAD="$LIBTHREAD"
 229           LTLIBMULTITHREAD="$LTLIBTHREAD"
 230           AC_DEFINE([USE_SOLARIS_THREADS], [1],
 231             [Define if the old Solaris multithreading library can be used.])
 232           if case "$gl_cv_have_weak" in *yes) true;; *) false;; esac; then
 233             AC_DEFINE([USE_SOLARIS_THREADS_WEAK], [1],
 234               [Define if references to the old Solaris multithreading library should be made weak.])
 235             LIBTHREAD=
 236             LTLIBTHREAD=
 237           fi
 238         fi
 239       fi
 240     fi
 241     if test "$gl_use_threads" = pth; then
 242       gl_save_CPPFLAGS="$CPPFLAGS"
 243       AC_LIB_LINKFLAGS([pth])
 244       gl_have_pth=
 245       gl_save_LIBS="$LIBS"
 246       LIBS="$LIBS -lpth"
 247       AC_LINK_IFELSE(
 248         [AC_LANG_PROGRAM([[#include <pth.h>]], [[pth_self();]])],
 249         [gl_have_pth=yes])
 250       LIBS="$gl_save_LIBS"
 251       if test -n "$gl_have_pth"; then
 252         gl_threads_api=pth
 253         LIBTHREAD="$LIBPTH"
 254         LTLIBTHREAD="$LTLIBPTH"
 255         LIBMULTITHREAD="$LIBTHREAD"
 256         LTLIBMULTITHREAD="$LTLIBTHREAD"
 257         AC_DEFINE([USE_PTH_THREADS], [1],
 258           [Define if the GNU Pth multithreading library can be used.])
 259         if test -n "$LIBMULTITHREAD" || test -n "$LTLIBMULTITHREAD"; then
 260           if case "$gl_cv_have_weak" in *yes) true;; *) false;; esac; then
 261             AC_DEFINE([USE_PTH_THREADS_WEAK], [1],
 262               [Define if references to the GNU Pth multithreading library should be made weak.])
 263             LIBTHREAD=
 264             LTLIBTHREAD=
 265           fi
 266         fi
 267       else
 268         CPPFLAGS="$gl_save_CPPFLAGS"
 269       fi
 270     fi
 271     if test -z "$gl_have_pthread"; then
 272       if test "$gl_use_threads" = yes || test "$gl_use_threads" = win32; then
 273         if { case "$host_os" in
 274                mingw*) true;;
 275                *) false;;
 276              esac
 277            }; then
 278           gl_threads_api=win32
 279           AC_DEFINE([USE_WIN32_THREADS], [1],
 280             [Define if the Win32 multithreading API can be used.])
 281         fi
 282       fi
 283     fi
 284   fi
 285   AC_MSG_CHECKING([for multithread API to use])
 286   AC_MSG_RESULT([$gl_threads_api])
 287   AC_SUBST([LIBTHREAD])
 288   AC_SUBST([LTLIBTHREAD])
 289   AC_SUBST([LIBMULTITHREAD])
 290   AC_SUBST([LTLIBMULTITHREAD])
 291 ])
 292
 293 AC_DEFUN([gl_THREADLIB],
 294 [
 295   AC_REQUIRE([gl_THREADLIB_EARLY])
 296   AC_REQUIRE([gl_THREADLIB_BODY])
 297 ])
 298
 299
 300 dnl gl_DISABLE_THREADS
 301 dnl ------------------
 302 dnl Sets the gl_THREADLIB default so that threads are not used by default.
 303 dnl The user can still override it at installation time, by using the
 304 dnl configure option '--enable-threads'.
 305
 306 AC_DEFUN([gl_DISABLE_THREADS], [
 307   m4_divert_text([INIT_PREPARE], [gl_use_threads_default=no])
 308 ])
 309
 310
 311 dnl Survey of platforms:
 312 dnl
 313 dnl Platform          Available   Compiler    Supports   test-lock
 314 dnl                   flavours    option      weak       result
 315 dnl ---------------   ---------   ---------   --------   ---------
 316 dnl Linux 2.4/glibc   posix       -lpthread       Y      OK
 317 dnl
 318 dnl GNU Hurd/glibc    posix
 319 dnl
 320 dnl FreeBSD 5.3       posix       -lc_r           Y
 321 dnl                   posix       -lkse ?         Y
 322 dnl                   posix       -lpthread ?     Y
 323 dnl                   posix       -lthr           Y
 324 dnl
 325 dnl FreeBSD 5.2       posix       -lc_r           Y
 326 dnl                   posix       -lkse           Y
 327 dnl                   posix       -lthr           Y
 328 dnl
 329 dnl FreeBSD 4.0,4.10  posix       -lc_r           Y      OK
 330 dnl
 331 dnl NetBSD 1.6        --
 332 dnl
 333 dnl OpenBSD 3.4       posix       -lpthread       Y      OK
 334 dnl
 335 dnl MacOS X 10.[123]  posix       -lpthread       Y      OK
 336 dnl
 337 dnl Solaris 7,8,9     posix       -lpthread       Y      Sol 7,8: 0.0; Sol 9: OK
 338 dnl                   solaris     -lthread        Y      Sol 7,8: 0.0; Sol 9: OK
 339 dnl
 340 dnl HP-UX 11          posix       -lpthread       N (cc) OK
 341 dnl                                               Y (gcc)
 342 dnl
 343 dnl IRIX 6.5          posix       -lpthread       Y      0.5
 344 dnl
 345 dnl AIX 4.3,5.1       posix       -lpthread       N      AIX 4: 0.5; AIX 5: OK
 346 dnl
 347 dnl OSF/1 4.0,5.1     posix       -pthread (cc)   N      OK
 348 dnl                               -lpthread (gcc) Y
 349 dnl
 350 dnl Cygwin            posix       -lpthread       Y      OK
 351 dnl
 352 dnl Any of the above  pth         -lpth                  0.0
 353 dnl
 354 dnl Mingw             win32                       N      OK
 355 dnl
 356 dnl BeOS 5            --
 357 dnl
 358 dnl The test-lock result shows what happens if in test-lock.c EXPLICIT_YIELD is
 359 dnl turned off:
 360 dnl   OK if all three tests terminate OK,
 361 dnl   0.5 if the first test terminates OK but the second one loops endlessly,
 362 dnl   0.0 if the first test already loops endlessly.