m4/lock.m4

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