m4/lock.m4

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