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