m4/threadlib.m4

   1 # threadlib.m4 serial 5 (gettext-0.18)
   2 dnl Copyright (C) 2005-2010 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_CACHE_CHECK([whether imported symbols can be declared weak],
 111       [gl_cv_have_weak],
 112       [gl_cv_have_weak=no
 113        dnl First, test whether the compiler accepts it syntactically.
 114        AC_TRY_LINK([extern void xyzzy ();
 115 #pragma weak xyzzy], [xyzzy();], [gl_cv_have_weak=maybe])
 116        if test $gl_cv_have_weak = maybe; then
 117          dnl Second, test whether it actually works. On Cygwin 1.7.2, with
 118          dnl gcc 4.3, symbols declared weak always evaluate to the address 0.
 119          AC_TRY_RUN([
 120 #include <stdio.h>
 121 #pragma weak fputs
 122 int main ()
 123 {
 124   return (fputs == NULL);
 125 }], [gl_cv_have_weak=yes], [gl_cv_have_weak=no],
 126            [dnl When cross-compiling, assume that only ELF platforms support
 127             dnl weak symbols.
 128             AC_EGREP_CPP([Extensible Linking Format],
 129               [#ifdef __ELF__
 130                Extensible Linking Format
 131                #endif
 132               ],
 133               [gl_cv_have_weak="guessing yes"],
 134               [gl_cv_have_weak="guessing no"])
 135            ])
 136        fi
 137       ])
 138     if test "$gl_use_threads" = yes || test "$gl_use_threads" = posix; then
 139       # On OSF/1, the compiler needs the flag -pthread or -D_REENTRANT so that
 140       # it groks <pthread.h>. It's added above, in gl_THREADLIB_EARLY_BODY.
 141       AC_CHECK_HEADER([pthread.h],
 142         [gl_have_pthread_h=yes], [gl_have_pthread_h=no])
 143       if test "$gl_have_pthread_h" = yes; then
 144         # Other possible tests:
 145         #   -lpthreads (FSU threads, PCthreads)
 146         #   -lgthreads
 147         gl_have_pthread=
 148         # Test whether both pthread_mutex_lock and pthread_mutexattr_init exist
 149         # in libc. IRIX 6.5 has the first one in both libc and libpthread, but
 150         # the second one only in libpthread, and lock.c needs it.
 151         AC_TRY_LINK([#include <pthread.h>],
 152           [pthread_mutex_lock((pthread_mutex_t*)0);
 153            pthread_mutexattr_init((pthread_mutexattr_t*)0);],
 154           [gl_have_pthread=yes])
 155         # Test for libpthread by looking for pthread_kill. (Not pthread_self,
 156         # since it is defined as a macro on OSF/1.)
 157         if test -n "$gl_have_pthread"; then
 158           # The program links fine without libpthread. But it may actually
 159           # need to link with libpthread in order to create multiple threads.
 160           AC_CHECK_LIB([pthread], [pthread_kill],
 161             [LIBMULTITHREAD=-lpthread LTLIBMULTITHREAD=-lpthread
 162              # On Solaris and HP-UX, most pthread functions exist also in libc.
 163              # Therefore pthread_in_use() needs to actually try to create a
 164              # thread: pthread_create from libc will fail, whereas
 165              # pthread_create will actually create a thread.
 166              case "$host_os" in
 167                solaris* | hpux*)
 168                  AC_DEFINE([PTHREAD_IN_USE_DETECTION_HARD], [1],
 169                    [Define if the pthread_in_use() detection is hard.])
 170              esac
 171             ])
 172         else
 173           # Some library is needed. Try libpthread and libc_r.
 174           AC_CHECK_LIB([pthread], [pthread_kill],
 175             [gl_have_pthread=yes
 176              LIBTHREAD=-lpthread LTLIBTHREAD=-lpthread
 177              LIBMULTITHREAD=-lpthread LTLIBMULTITHREAD=-lpthread])
 178           if test -z "$gl_have_pthread"; then
 179             # For FreeBSD 4.
 180             AC_CHECK_LIB([c_r], [pthread_kill],
 181               [gl_have_pthread=yes
 182                LIBTHREAD=-lc_r LTLIBTHREAD=-lc_r
 183                LIBMULTITHREAD=-lc_r LTLIBMULTITHREAD=-lc_r])
 184           fi
 185         fi
 186         if test -n "$gl_have_pthread"; then
 187           gl_threads_api=posix
 188           AC_DEFINE([USE_POSIX_THREADS], [1],
 189             [Define if the POSIX multithreading library can be used.])
 190           if test -n "$LIBMULTITHREAD" || test -n "$LTLIBMULTITHREAD"; then
 191             if case "$gl_cv_have_weak" in *yes) true;; *) false;; esac; then
 192               AC_DEFINE([USE_POSIX_THREADS_WEAK], [1],
 193                 [Define if references to the POSIX multithreading library should be made weak.])
 194               LIBTHREAD=
 195               LTLIBTHREAD=
 196             fi
 197           fi
 198         fi
 199       fi
 200     fi
 201     if test -z "$gl_have_pthread"; then
 202       if test "$gl_use_threads" = yes || test "$gl_use_threads" = solaris; then
 203         gl_have_solaristhread=
 204         gl_save_LIBS="$LIBS"
 205         LIBS="$LIBS -lthread"
 206         AC_TRY_LINK([#include <thread.h>
 207 #include <synch.h>],
 208           [thr_self();],
 209           [gl_have_solaristhread=yes])
 210         LIBS="$gl_save_LIBS"
 211         if test -n "$gl_have_solaristhread"; then
 212           gl_threads_api=solaris
 213           LIBTHREAD=-lthread
 214           LTLIBTHREAD=-lthread
 215           LIBMULTITHREAD="$LIBTHREAD"
 216           LTLIBMULTITHREAD="$LTLIBTHREAD"
 217           AC_DEFINE([USE_SOLARIS_THREADS], [1],
 218             [Define if the old Solaris multithreading library can be used.])
 219           if case "$gl_cv_have_weak" in *yes) true;; *) false;; esac; then
 220             AC_DEFINE([USE_SOLARIS_THREADS_WEAK], [1],
 221               [Define if references to the old Solaris multithreading library should be made weak.])
 222             LIBTHREAD=
 223             LTLIBTHREAD=
 224           fi
 225         fi
 226       fi
 227     fi
 228     if test "$gl_use_threads" = pth; then
 229       gl_save_CPPFLAGS="$CPPFLAGS"
 230       AC_LIB_LINKFLAGS([pth])
 231       gl_have_pth=
 232       gl_save_LIBS="$LIBS"
 233       LIBS="$LIBS -lpth"
 234       AC_TRY_LINK([#include <pth.h>], [pth_self();], [gl_have_pth=yes])
 235       LIBS="$gl_save_LIBS"
 236       if test -n "$gl_have_pth"; then
 237         gl_threads_api=pth
 238         LIBTHREAD="$LIBPTH"
 239         LTLIBTHREAD="$LTLIBPTH"
 240         LIBMULTITHREAD="$LIBTHREAD"
 241         LTLIBMULTITHREAD="$LTLIBTHREAD"
 242         AC_DEFINE([USE_PTH_THREADS], [1],
 243           [Define if the GNU Pth multithreading library can be used.])
 244         if test -n "$LIBMULTITHREAD" || test -n "$LTLIBMULTITHREAD"; then
 245           if case "$gl_cv_have_weak" in *yes) true;; *) false;; esac; then
 246             AC_DEFINE([USE_PTH_THREADS_WEAK], [1],
 247               [Define if references to the GNU Pth multithreading library should be made weak.])
 248             LIBTHREAD=
 249             LTLIBTHREAD=
 250           fi
 251         fi
 252       else
 253         CPPFLAGS="$gl_save_CPPFLAGS"
 254       fi
 255     fi
 256     if test -z "$gl_have_pthread"; then
 257       if test "$gl_use_threads" = yes || test "$gl_use_threads" = win32; then
 258         if { case "$host_os" in
 259                mingw*) true;;
 260                *) false;;
 261              esac
 262            }; then
 263           gl_threads_api=win32
 264           AC_DEFINE([USE_WIN32_THREADS], [1],
 265             [Define if the Win32 multithreading API can be used.])
 266         fi
 267       fi
 268     fi
 269   fi
 270   AC_MSG_CHECKING([for multithread API to use])
 271   AC_MSG_RESULT([$gl_threads_api])
 272   AC_SUBST([LIBTHREAD])
 273   AC_SUBST([LTLIBTHREAD])
 274   AC_SUBST([LIBMULTITHREAD])
 275   AC_SUBST([LTLIBMULTITHREAD])
 276 ])
 277
 278 AC_DEFUN([gl_THREADLIB],
 279 [
 280   AC_REQUIRE([gl_THREADLIB_EARLY])
 281   AC_REQUIRE([gl_THREADLIB_BODY])
 282 ])
 283
 284
 285 dnl gl_DISABLE_THREADS
 286 dnl ------------------
 287 dnl Sets the gl_THREADLIB default so that threads are not used by default.
 288 dnl The user can still override it at installation time, by using the
 289 dnl configure option '--enable-threads'.
 290
 291 AC_DEFUN([gl_DISABLE_THREADS], [
 292   m4_divert_text([INIT_PREPARE], [gl_use_threads_default=no])
 293 ])
 294
 295
 296 dnl Survey of platforms:
 297 dnl
 298 dnl Platform          Available   Compiler    Supports   test-lock
 299 dnl                   flavours    option      weak       result
 300 dnl ---------------   ---------   ---------   --------   ---------
 301 dnl Linux 2.4/glibc   posix       -lpthread       Y      OK
 302 dnl
 303 dnl GNU Hurd/glibc    posix
 304 dnl
 305 dnl FreeBSD 5.3       posix       -lc_r           Y
 306 dnl                   posix       -lkse ?         Y
 307 dnl                   posix       -lpthread ?     Y
 308 dnl                   posix       -lthr           Y
 309 dnl
 310 dnl FreeBSD 5.2       posix       -lc_r           Y
 311 dnl                   posix       -lkse           Y
 312 dnl                   posix       -lthr           Y
 313 dnl
 314 dnl FreeBSD 4.0,4.10  posix       -lc_r           Y      OK
 315 dnl
 316 dnl NetBSD 1.6        --
 317 dnl
 318 dnl OpenBSD 3.4       posix       -lpthread       Y      OK
 319 dnl
 320 dnl MacOS X 10.[123]  posix       -lpthread       Y      OK
 321 dnl
 322 dnl Solaris 7,8,9     posix       -lpthread       Y      Sol 7,8: 0.0; Sol 9: OK
 323 dnl                   solaris     -lthread        Y      Sol 7,8: 0.0; Sol 9: OK
 324 dnl
 325 dnl HP-UX 11          posix       -lpthread       N (cc) OK
 326 dnl                                               Y (gcc)
 327 dnl
 328 dnl IRIX 6.5          posix       -lpthread       Y      0.5
 329 dnl
 330 dnl AIX 4.3,5.1       posix       -lpthread       N      AIX 4: 0.5; AIX 5: OK
 331 dnl
 332 dnl OSF/1 4.0,5.1     posix       -pthread (cc)   N      OK
 333 dnl                               -lpthread (gcc) Y
 334 dnl
 335 dnl Cygwin            posix       -lpthread       Y      OK
 336 dnl
 337 dnl Any of the above  pth         -lpth                  0.0
 338 dnl
 339 dnl Mingw             win32                       N      OK
 340 dnl
 341 dnl BeOS 5            --
 342 dnl
 343 dnl The test-lock result shows what happens if in test-lock.c EXPLICIT_YIELD is
 344 dnl turned off:
 345 dnl   OK if all three tests terminate OK,
 346 dnl   0.5 if the first test terminates OK but the second one loops endlessly,
 347 dnl   0.0 if the first test already loops endlessly.