m4/lock.m4

   1 # lock.m4 serial 1 (gettext-0.15)
   2 dnl Copyright (C) 2005 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 Tests for a multithreading library to be used.
  10 dnl Defines at most one of the macros USE_POSIX_THREADS, USE_SOLARIS_THREADS,
  11 dnl USE_PTH_THREADS, USE_WIN32_THREADS
  12 dnl Sets the variables LIBTHREAD and LTLIBTHREAD to the linker options for use
  13 dnl in a Makefile (LIBTHREAD for use without libtool, LTLIBTHREAD for use with
  14 dnl libtool).
  15 dnl Sets the variables LIBMULTITHREAD and LTLIBMULTITHREAD similarly, for
  16 dnl programs that really need multithread functionality. The difference
  17 dnl between LIBTHREAD and LIBMULTITHREAD is that on platforms supporting weak
  18 dnl symbols, typically LIBTHREAD="" whereas LIBMULTITHREAD="-lpthread".
  19 dnl Adds to CPPFLAGS the flag -D_REENTRANT or -D_THREAD_SAFE if needed for
  20 dnl multithread-safe programs.
  21
  22 AC_DEFUN([gl_LOCK],
  23 [
  24   dnl Ordering constraints: This macro modifies CPPFLAGS in a way that
  25   dnl influences the result of the autoconf tests that test for *_unlocked
  26   dnl declarations, on AIX 5 at least. Therefore it must come early.
  27   AC_BEFORE([$0], [gl_FUNC_GLIBC_UNLOCKED_IO])dnl
  28   AC_BEFORE([$0], [gl_ARGP])dnl
  29
  30   AC_REQUIRE([AC_CANONICAL_HOST])
  31   AC_REQUIRE([AC_GNU_SOURCE]) dnl needed for pthread_rwlock_t on glibc systems
  32   dnl Check for multithreading.
  33   AC_ARG_ENABLE(threads,
  34 AC_HELP_STRING([--enable-threads={posix|solaris|pth|win32}], [specify multithreading API])
  35 AC_HELP_STRING([--disable-threads], [build without multithread safety]),
  36     gl_use_threads=$enableval, gl_use_threads=yes)
  37   gl_threads_api=none
  38   LIBTHREAD=
  39   LTLIBTHREAD=
  40   LIBMULTITHREAD=
  41   LTLIBMULTITHREAD=
  42   if test "$gl_use_threads" != no; then
  43     dnl Check whether the compiler and linker support weak declarations.
  44     AC_MSG_CHECKING([whether imported symbols can be declared weak])
  45     gl_have_weak=no
  46     AC_TRY_LINK([extern void xyzzy ();
  47 #pragma weak xyzzy], [xyzzy();], [gl_have_weak=yes])
  48     AC_MSG_RESULT([$gl_have_weak])
  49     if test "$gl_use_threads" = yes || test "$gl_use_threads" = posix; then
  50       # On OSF/1, the compiler needs the flag -pthread or -D_REENTRANT so that
  51       # it groks <pthread.h>.
  52       gl_save_CPPFLAGS="$CPPFLAGS"
  53       CPPFLAGS="$CPPFLAGS -D_REENTRANT"
  54       AC_CHECK_HEADER(pthread.h, gl_have_pthread_h=yes, gl_have_pthread_h=no)
  55       CPPFLAGS="$gl_save_CPPFLAGS"
  56       if test "$gl_have_pthread_h" = yes; then
  57         # Other possible tests:
  58         #   -lpthreads (FSU threads, PCthreads)
  59         #   -lgthreads
  60         case "$host_os" in
  61           osf*)
  62             # On OSF/1, the compiler needs the flag -D_REENTRANT so that it
  63             # groks <pthread.h>. cc also understands the flag -pthread, but
  64             # we don't use it because 1. gcc-2.95 doesn't understand -pthread,
  65             # 2. putting a flag into CPPFLAGS that has an effect on the linker
  66             # causes the AC_TRY_LINK test below to succeed unexpectedly,
  67             # leading to wrong values of LIBTHREAD and LTLIBTHREAD.
  68             CPPFLAGS="$CPPFLAGS -D_REENTRANT"
  69             ;;
  70         esac
  71         gl_have_pthread=
  72         # Test whether both pthread_mutex_lock and pthread_mutexattr_init exist
  73         # in libc. IRIX 6.5 has the first one in both libc and libpthread, but
  74         # the second one only in libpthread, and lock.c needs it.
  75         AC_TRY_LINK([#include <pthread.h>],
  76           [pthread_mutex_lock((pthread_mutex_t*)0);
  77            pthread_mutexattr_init((pthread_mutexattr_t*)0);],
  78           [gl_have_pthread=yes])
  79         # Test for libpthread by looking for pthread_kill. (Not pthread_self,
  80         # since it is defined as a macro on OSF/1.)
  81         if test -n "$gl_have_pthread"; then
  82           # The program links fine without libpthread. But it may actually
  83           # need to link with libpthread in order to create multiple threads.
  84           AC_CHECK_LIB(pthread, pthread_kill,
  85             [LIBMULTITHREAD=-lpthread LTLIBMULTITHREAD=-lpthread
  86              # On Solaris and HP-UX, most pthread functions exist also in libc.
  87              # Therefore pthread_in_use() needs to actually try to create a
  88              # thread: pthread_create from libc will fail, whereas
  89              # pthread_create will actually create a thread.
  90              case "$host_os" in
  91                solaris* | hpux*)
  92                  AC_DEFINE([PTHREAD_IN_USE_DETECTION_HARD], 1,
  93                    [Define if the pthread_in_use() detection is hard.])
  94              esac
  95             ])
  96         else
  97           # Some library is needed. Try libpthread and libc_r.
  98           AC_CHECK_LIB(pthread, pthread_kill,
  99             [gl_have_pthread=yes
 100              LIBTHREAD=-lpthread LTLIBTHREAD=-lpthread
 101              LIBMULTITHREAD=-lpthread LTLIBMULTITHREAD=-lpthread])
 102           if test -z "$gl_have_pthread"; then
 103             # For FreeBSD 4.
 104             AC_CHECK_LIB(c_r, pthread_kill,
 105               [gl_have_pthread=yes
 106                LIBTHREAD=-lc_r LTLIBTHREAD=-lc_r
 107                LIBMULTITHREAD=-lc_r LTLIBMULTITHREAD=-lc_r])
 108           fi
 109         fi
 110         if test -n "$gl_have_pthread"; then
 111           gl_threads_api=posix
 112           AC_DEFINE([USE_POSIX_THREADS], 1,
 113             [Define if the POSIX multithreading library can be used.])
 114           if test -n "$LIBMULTITHREAD" || test -n "$LTLIBMULTITHREAD"; then
 115             if test $gl_have_weak = yes; then
 116               AC_DEFINE([USE_POSIX_THREADS_WEAK], 1,
 117                 [Define if references to the POSIX multithreading library should be made weak.])
 118               LIBTHREAD=
 119               LTLIBTHREAD=
 120             fi
 121           fi
 122           # OSF/1 4.0 and MacOS X 10.1 lack the pthread_rwlock_t type and the
 123           # pthread_rwlock_* functions.
 124           AC_CHECK_TYPE([pthread_rwlock_t],
 125             [AC_DEFINE([HAVE_PTHREAD_RWLOCK], 1,
 126                [Define if the POSIX multithreading library has read/write locks.])],
 127             [],
 128             [#include <pthread.h>])
 129           # glibc defines PTHREAD_MUTEX_RECURSIVE as enum, not as a macro.
 130           AC_TRY_COMPILE([#include <pthread.h>],
 131             [#if __FreeBSD__ == 4
 132 error "No, in FreeBSD 4.0 recursive mutexes actually don't work."
 133 #else
 134 int x = (int)PTHREAD_MUTEX_RECURSIVE;
 135 #endif],
 136             [AC_DEFINE([HAVE_PTHREAD_MUTEX_RECURSIVE], 1,
 137                [Define if the <pthread.h> defines PTHREAD_MUTEX_RECURSIVE.])])
 138           # Some systems optimize for single-threaded programs by default, and
 139           # need special flags to disable these optimizations. For example, the
 140           # definition of 'errno' in <errno.h>.
 141           case "$host_os" in
 142             aix* | freebsd*) CPPFLAGS="$CPPFLAGS -D_THREAD_SAFE" ;;
 143             solaris*) CPPFLAGS="$CPPFLAGS -D_REENTRANT" ;;
 144           esac
 145         fi
 146       fi
 147     fi
 148     if test -z "$gl_have_pthread"; then
 149       if test "$gl_use_threads" = yes || test "$gl_use_threads" = solaris; then
 150         gl_have_solaristhread=
 151         gl_save_LIBS="$LIBS"
 152         LIBS="$LIBS -lthread"
 153         AC_TRY_LINK([#include <thread.h>
 154 #include <synch.h>],
 155           [thr_self();],
 156           [gl_have_solaristhread=yes])
 157         LIBS="$gl_save_LIBS"
 158         if test -n "$gl_have_solaristhread"; then
 159           gl_threads_api=solaris
 160           LIBTHREAD=-lthread
 161           LTLIBTHREAD=-lthread
 162           LIBMULTITHREAD="$LIBTHREAD"
 163           LTLIBMULTITHREAD="$LTLIBTHREAD"
 164           AC_DEFINE([USE_SOLARIS_THREADS], 1,
 165             [Define if the old Solaris multithreading library can be used.])
 166           if test $gl_have_weak = yes; then
 167             AC_DEFINE([USE_SOLARIS_THREADS_WEAK], 1,
 168               [Define if references to the old Solaris multithreading library should be made weak.])
 169             LIBTHREAD=
 170             LTLIBTHREAD=
 171           fi
 172         fi
 173       fi
 174     fi
 175     if test "$gl_use_threads" = pth; then
 176       gl_save_CPPFLAGS="$CPPFLAGS"
 177       AC_LIB_LINKFLAGS(pth)
 178       gl_have_pth=
 179       gl_save_LIBS="$LIBS"
 180       LIBS="$LIBS -lpth"
 181       AC_TRY_LINK([#include <pth.h>], [pth_self();], gl_have_pth=yes)
 182       LIBS="$gl_save_LIBS"
 183       if test -n "$gl_have_pth"; then
 184         gl_threads_api=pth
 185         LIBTHREAD="$LIBPTH"
 186         LTLIBTHREAD="$LTLIBPTH"
 187         LIBMULTITHREAD="$LIBTHREAD"
 188         LTLIBMULTITHREAD="$LTLIBTHREAD"
 189         AC_DEFINE([USE_PTH_THREADS], 1,
 190           [Define if the GNU Pth multithreading library can be used.])
 191         if test -n "$LIBMULTITHREAD" || test -n "$LTLIBMULTITHREAD"; then
 192           if test $gl_have_weak = yes; then
 193             AC_DEFINE([USE_PTH_THREADS_WEAK], 1,
 194               [Define if references to the GNU Pth multithreading library should be made weak.])
 195             LIBTHREAD=
 196             LTLIBTHREAD=
 197           fi
 198         fi
 199       else
 200         CPPFLAGS="$gl_save_CPPFLAGS"
 201       fi
 202     fi
 203     if test -z "$gl_have_pthread"; then
 204       if test "$gl_use_threads" = yes || test "$gl_use_threads" = win32; then
 205         if { case "$host_os" in
 206                mingw*) true;;
 207                *) false;;
 208              esac
 209            }; then
 210           gl_threads_api=win32
 211           AC_DEFINE([USE_WIN32_THREADS], 1,
 212             [Define if the Win32 multithreading API can be used.])
 213         fi
 214       fi
 215     fi
 216   fi
 217   AC_MSG_CHECKING([for multithread API to use])
 218   AC_MSG_RESULT([$gl_threads_api])
 219   AC_SUBST(LIBTHREAD)
 220   AC_SUBST(LTLIBTHREAD)
 221   AC_SUBST(LIBMULTITHREAD)
 222   AC_SUBST(LTLIBMULTITHREAD)
 223   gl_PREREQ_LOCK
 224 ])
 225
 226 # Prerequisites of lib/lock.c.
 227 AC_DEFUN([gl_PREREQ_LOCK], [
 228   AC_REQUIRE([AC_C_INLINE])
 229 ])
 230
 231 dnl Survey of platforms:
 232 dnl
 233 dnl Platform          Available   Compiler    Supports   test-lock
 234 dnl                   flavours    option      weak       result
 235 dnl ---------------   ---------   ---------   --------   ---------
 236 dnl Linux 2.4/glibc   posix       -lpthread       Y      OK
 237 dnl
 238 dnl GNU Hurd/glibc    posix
 239 dnl
 240 dnl FreeBSD 5.3       posix       -lc_r           Y
 241 dnl                   posix       -lkse ?         Y
 242 dnl                   posix       -lpthread ?     Y
 243 dnl                   posix       -lthr           Y
 244 dnl
 245 dnl FreeBSD 5.2       posix       -lc_r           Y
 246 dnl                   posix       -lkse           Y
 247 dnl                   posix       -lthr           Y
 248 dnl
 249 dnl FreeBSD 4.0,4.10  posix       -lc_r           Y      OK
 250 dnl
 251 dnl NetBSD 1.6        --
 252 dnl
 253 dnl OpenBSD 3.4       posix       -lpthread       Y      OK
 254 dnl
 255 dnl MacOS X 10.[123]  posix       -lpthread       Y      OK
 256 dnl
 257 dnl Solaris 7,8,9     posix       -lpthread       Y      Sol 7,8: 0.0; Sol 9: OK
 258 dnl                   solaris     -lthread        Y      Sol 7,8: 0.0; Sol 9: OK
 259 dnl
 260 dnl HP-UX 11          posix       -lpthread       N (cc) OK
 261 dnl                                               Y (gcc)
 262 dnl
 263 dnl IRIX 6.5          posix       -lpthread       Y      0.5
 264 dnl
 265 dnl AIX 4.3,5.1       posix       -lpthread       N      AIX 4: 0.5; AIX 5: OK
 266 dnl
 267 dnl OSF/1 4.0,5.1     posix       -pthread (cc)   Y      OK
 268 dnl                               -lpthread (gcc) Y
 269 dnl
 270 dnl Cygwin            posix       -lpthread       Y      OK
 271 dnl
 272 dnl Any of the above  pth         -lpth                  0.0
 273 dnl
 274 dnl Mingw             win32                       N      OK
 275 dnl
 276 dnl BeOS 5            --
 277 dnl
 278 dnl The test-lock result shows what happens if in test-lock.c EXPLICIT_YIELD is
 279 dnl turned off:
 280 dnl   OK if all three tests terminate OK,
 281 dnl   0.5 if the first test terminates OK but the second one loops endlessly,
 282 dnl   0.0 if the first test already loops endlessly.