gl/m4/threadlib.m4

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