m4/threadlib.m4

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