m4/lock.m4

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