m4/lock.m4

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