git.sesse.net Git - vlc/blob - m4/lock.m4

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