pintos-os.org Git - pspp/blob - m4/threadlib.m4

   1 # threadlib.m4 serial 4 (gettext-0.18)
   2 dnl Copyright (C) 2005-2009 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_THREADLIB
  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_THREADLIB_EARLY],
  25 [
  26   AC_REQUIRE([gl_THREADLIB_EARLY_BODY])
  27 ])
  28
  29 dnl The guts of gl_THREADLIB_EARLY. Needs to be expanded only once.
  30
  31 AC_DEFUN([gl_THREADLIB_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          dnl Disable multithreading by default on Cygwin 1.5.x, because it has
  60          dnl bugs that lead to endless loops or crashes. See
  61          dnl <http://cygwin.com/ml/cygwin/2009-08/msg00283.html>.
  62          osf*) gl_use_threads=no ;;
  63          cygwin*)
  64                case `uname -r` in
  65                  1.[0-5].*) gl_use_threads=no ;;
  66                  *)         gl_use_threads=yes ;;
  67                esac
  68                ;;
  69          *)    gl_use_threads=yes ;;
  70        esac
  71      fi
  72     ])
  73   if test "$gl_use_threads" = yes || test "$gl_use_threads" = posix; then
  74     # For using <pthread.h>:
  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     # Some systems optimize for single-threaded programs by default, and
  87     # need special flags to disable these optimizations. For example, the
  88     # definition of 'errno' in <errno.h>.
  89     case "$host_os" in
  90       aix* | freebsd*) CPPFLAGS="$CPPFLAGS -D_THREAD_SAFE" ;;
  91       solaris*) CPPFLAGS="$CPPFLAGS -D_REENTRANT" ;;
  92     esac
  93   fi
  94 ])
  95
  96 dnl The guts of gl_THREADLIB. Needs to be expanded only once.
  97
  98 AC_DEFUN([gl_THREADLIB_BODY],
  99 [
 100   AC_REQUIRE([gl_THREADLIB_EARLY_BODY])
 101   gl_threads_api=none
 102   LIBTHREAD=
 103   LTLIBTHREAD=
 104   LIBMULTITHREAD=
 105   LTLIBMULTITHREAD=
 106   if test "$gl_use_threads" != no; then
 107     dnl Check whether the compiler and linker support weak declarations.
 108     AC_MSG_CHECKING([whether imported symbols can be declared weak])
 109     gl_have_weak=no
 110     AC_TRY_LINK([extern void xyzzy ();
 111 #pragma weak xyzzy], [xyzzy();], [gl_have_weak=yes])
 112     AC_MSG_RESULT([$gl_have_weak])
 113     if test "$gl_use_threads" = yes || test "$gl_use_threads" = posix; then
 114       # On OSF/1, the compiler needs the flag -pthread or -D_REENTRANT so that
 115       # it groks <pthread.h>. It's added above, in gl_THREADLIB_EARLY_BODY.
 116       AC_CHECK_HEADER([pthread.h],
 117         [gl_have_pthread_h=yes], [gl_have_pthread_h=no])
 118       if test "$gl_have_pthread_h" = yes; then
 119         # Other possible tests:
 120         #   -lpthreads (FSU threads, PCthreads)
 121         #   -lgthreads
 122         gl_have_pthread=
 123         # Test whether both pthread_mutex_lock and pthread_mutexattr_init exist
 124         # in libc. IRIX 6.5 has the first one in both libc and libpthread, but
 125         # the second one only in libpthread, and lock.c needs it.
 126         AC_TRY_LINK([#include <pthread.h>],
 127           [pthread_mutex_lock((pthread_mutex_t*)0);
 128            pthread_mutexattr_init((pthread_mutexattr_t*)0);],
 129           [gl_have_pthread=yes])
 130         # Test for libpthread by looking for pthread_kill. (Not pthread_self,
 131         # since it is defined as a macro on OSF/1.)
 132         if test -n "$gl_have_pthread"; then
 133           # The program links fine without libpthread. But it may actually
 134           # need to link with libpthread in order to create multiple threads.
 135           AC_CHECK_LIB([pthread], [pthread_kill],
 136             [LIBMULTITHREAD=-lpthread LTLIBMULTITHREAD=-lpthread
 137              # On Solaris and HP-UX, most pthread functions exist also in libc.
 138              # Therefore pthread_in_use() needs to actually try to create a
 139              # thread: pthread_create from libc will fail, whereas
 140              # pthread_create will actually create a thread.
 141              case "$host_os" in
 142                solaris* | hpux*)
 143                  AC_DEFINE([PTHREAD_IN_USE_DETECTION_HARD], [1],
 144                    [Define if the pthread_in_use() detection is hard.])
 145              esac
 146             ])
 147         else
 148           # Some library is needed. Try libpthread and libc_r.
 149           AC_CHECK_LIB([pthread], [pthread_kill],
 150             [gl_have_pthread=yes
 151              LIBTHREAD=-lpthread LTLIBTHREAD=-lpthread
 152              LIBMULTITHREAD=-lpthread LTLIBMULTITHREAD=-lpthread])
 153           if test -z "$gl_have_pthread"; then
 154             # For FreeBSD 4.
 155             AC_CHECK_LIB([c_r], [pthread_kill],
 156               [gl_have_pthread=yes
 157                LIBTHREAD=-lc_r LTLIBTHREAD=-lc_r
 158                LIBMULTITHREAD=-lc_r LTLIBMULTITHREAD=-lc_r])
 159           fi
 160         fi
 161         if test -n "$gl_have_pthread"; then
 162           gl_threads_api=posix
 163           AC_DEFINE([USE_POSIX_THREADS], [1],
 164             [Define if the POSIX multithreading library can be used.])
 165           if test -n "$LIBMULTITHREAD" || test -n "$LTLIBMULTITHREAD"; then
 166             if test $gl_have_weak = yes; then
 167               AC_DEFINE([USE_POSIX_THREADS_WEAK], [1],
 168                 [Define if references to the POSIX multithreading library should be made weak.])
 169               LIBTHREAD=
 170               LTLIBTHREAD=
 171             fi
 172           fi
 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_THREADLIB],
 254 [
 255   AC_REQUIRE([gl_THREADLIB_EARLY])
 256   AC_REQUIRE([gl_THREADLIB_BODY])
 257 ])
 258
 259
 260 dnl gl_DISABLE_THREADS
 261 dnl ------------------
 262 dnl Sets the gl_THREADLIB default so that threads are not used by default.
 263 dnl The user can still override it at installation time, by using the
 264 dnl configure option '--enable-threads'.
 265
 266 AC_DEFUN([gl_DISABLE_THREADS], [
 267   m4_divert_text([INIT_PREPARE], [gl_use_threads_default=no])
 268 ])
 269
 270
 271 dnl Survey of platforms:
 272 dnl
 273 dnl Platform          Available   Compiler    Supports   test-lock
 274 dnl                   flavours    option      weak       result
 275 dnl ---------------   ---------   ---------   --------   ---------
 276 dnl Linux 2.4/glibc   posix       -lpthread       Y      OK
 277 dnl
 278 dnl GNU Hurd/glibc    posix
 279 dnl
 280 dnl FreeBSD 5.3       posix       -lc_r           Y
 281 dnl                   posix       -lkse ?         Y
 282 dnl                   posix       -lpthread ?     Y
 283 dnl                   posix       -lthr           Y
 284 dnl
 285 dnl FreeBSD 5.2       posix       -lc_r           Y
 286 dnl                   posix       -lkse           Y
 287 dnl                   posix       -lthr           Y
 288 dnl
 289 dnl FreeBSD 4.0,4.10  posix       -lc_r           Y      OK
 290 dnl
 291 dnl NetBSD 1.6        --
 292 dnl
 293 dnl OpenBSD 3.4       posix       -lpthread       Y      OK
 294 dnl
 295 dnl MacOS X 10.[123]  posix       -lpthread       Y      OK
 296 dnl
 297 dnl Solaris 7,8,9     posix       -lpthread       Y      Sol 7,8: 0.0; Sol 9: OK
 298 dnl                   solaris     -lthread        Y      Sol 7,8: 0.0; Sol 9: OK
 299 dnl
 300 dnl HP-UX 11          posix       -lpthread       N (cc) OK
 301 dnl                                               Y (gcc)
 302 dnl
 303 dnl IRIX 6.5          posix       -lpthread       Y      0.5
 304 dnl
 305 dnl AIX 4.3,5.1       posix       -lpthread       N      AIX 4: 0.5; AIX 5: OK
 306 dnl
 307 dnl OSF/1 4.0,5.1     posix       -pthread (cc)   N      OK
 308 dnl                               -lpthread (gcc) Y
 309 dnl
 310 dnl Cygwin            posix       -lpthread       Y      OK
 311 dnl
 312 dnl Any of the above  pth         -lpth                  0.0
 313 dnl
 314 dnl Mingw             win32                       N      OK
 315 dnl
 316 dnl BeOS 5            --
 317 dnl
 318 dnl The test-lock result shows what happens if in test-lock.c EXPLICIT_YIELD is
 319 dnl turned off:
 320 dnl   OK if all three tests terminate OK,
 321 dnl   0.5 if the first test terminates OK but the second one loops endlessly,
 322 dnl   0.0 if the first test already loops endlessly.