m4/threadlib.m4

   1 # threadlib.m4 serial 10 (gettext-0.18.2)
   2 dnl Copyright (C) 2005-2014 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 If the configure.ac contains a definition of the gl_THREADLIB_DEFAULT_NO
  13 dnl (it must be placed before the invocation of gl_THREADLIB_EARLY!), then the
  14 dnl default is 'no', otherwise it is system dependent. In both cases, the user
  15 dnl can change the choice through the options --enable-threads=choice or
  16 dnl --disable-threads.
  17 dnl Defines at most one of the macros USE_POSIX_THREADS, USE_SOLARIS_THREADS,
  18 dnl USE_PTH_THREADS, USE_WINDOWS_THREADS
  19 dnl Sets the variables LIBTHREAD and LTLIBTHREAD to the linker options for use
  20 dnl in a Makefile (LIBTHREAD for use without libtool, LTLIBTHREAD for use with
  21 dnl libtool).
  22 dnl Sets the variables LIBMULTITHREAD and LTLIBMULTITHREAD similarly, for
  23 dnl programs that really need multithread functionality. The difference
  24 dnl between LIBTHREAD and LIBMULTITHREAD is that on platforms supporting weak
  25 dnl symbols, typically LIBTHREAD="" whereas LIBMULTITHREAD="-lpthread".
  26 dnl Adds to CPPFLAGS the flag -D_REENTRANT or -D_THREAD_SAFE if needed for
  27 dnl multithread-safe programs.
  28
  29 AC_DEFUN([gl_THREADLIB_EARLY],
  30 [
  31   AC_REQUIRE([gl_THREADLIB_EARLY_BODY])
  32 ])
  33
  34 dnl The guts of gl_THREADLIB_EARLY. Needs to be expanded only once.
  35
  36 AC_DEFUN([gl_THREADLIB_EARLY_BODY],
  37 [
  38   dnl Ordering constraints: This macro modifies CPPFLAGS in a way that
  39   dnl influences the result of the autoconf tests that test for *_unlocked
  40   dnl declarations, on AIX 5 at least. Therefore it must come early.
  41   AC_BEFORE([$0], [gl_FUNC_GLIBC_UNLOCKED_IO])dnl
  42   AC_BEFORE([$0], [gl_ARGP])dnl
  43
  44   AC_REQUIRE([AC_CANONICAL_HOST])
  45   dnl _GNU_SOURCE is needed for pthread_rwlock_t on glibc systems.
  46   dnl AC_USE_SYSTEM_EXTENSIONS was introduced in autoconf 2.60 and obsoletes
  47   dnl AC_GNU_SOURCE.
  48   m4_ifdef([AC_USE_SYSTEM_EXTENSIONS],
  49     [AC_REQUIRE([AC_USE_SYSTEM_EXTENSIONS])],
  50     [AC_REQUIRE([AC_GNU_SOURCE])])
  51   dnl Check for multithreading.
  52   m4_ifdef([gl_THREADLIB_DEFAULT_NO],
  53     [m4_divert_text([DEFAULTS], [gl_use_threads_default=no])],
  54     [m4_divert_text([DEFAULTS], [gl_use_threads_default=])])
  55   AC_ARG_ENABLE([threads],
  56 AC_HELP_STRING([--enable-threads={posix|solaris|pth|windows}], [specify multithreading API])m4_ifdef([gl_THREADLIB_DEFAULT_NO], [], [
  57 AC_HELP_STRING([--disable-threads], [build without multithread safety])]),
  58     [gl_use_threads=$enableval],
  59     [if test -n "$gl_use_threads_default"; then
  60        gl_use_threads="$gl_use_threads_default"
  61      else
  62 changequote(,)dnl
  63        case "$host_os" in
  64          dnl Disable multithreading by default on OSF/1, because it interferes
  65          dnl with fork()/exec(): When msgexec is linked with -lpthread, its
  66          dnl child process gets an endless segmentation fault inside execvp().
  67          dnl Disable multithreading by default on Cygwin 1.5.x, because it has
  68          dnl bugs that lead to endless loops or crashes. See
  69          dnl <http://cygwin.com/ml/cygwin/2009-08/msg00283.html>.
  70          osf*) gl_use_threads=no ;;
  71          cygwin*)
  72                case `uname -r` in
  73                  1.[0-5].*) gl_use_threads=no ;;
  74                  *)         gl_use_threads=yes ;;
  75                esac
  76                ;;
  77          *)    gl_use_threads=yes ;;
  78        esac
  79 changequote([,])dnl
  80      fi
  81     ])
  82   if test "$gl_use_threads" = yes || test "$gl_use_threads" = posix; then
  83     # For using <pthread.h>:
  84     case "$host_os" in
  85       osf*)
  86         # On OSF/1, the compiler needs the flag -D_REENTRANT so that it
  87         # groks <pthread.h>. cc also understands the flag -pthread, but
  88         # we don't use it because 1. gcc-2.95 doesn't understand -pthread,
  89         # 2. putting a flag into CPPFLAGS that has an effect on the linker
  90         # causes the AC_LINK_IFELSE test below to succeed unexpectedly,
  91         # leading to wrong values of LIBTHREAD and LTLIBTHREAD.
  92         CPPFLAGS="$CPPFLAGS -D_REENTRANT"
  93         ;;
  94     esac
  95     # Some systems optimize for single-threaded programs by default, and
  96     # need special flags to disable these optimizations. For example, the
  97     # definition of 'errno' in <errno.h>.
  98     case "$host_os" in
  99       aix* | freebsd*) CPPFLAGS="$CPPFLAGS -D_THREAD_SAFE" ;;
 100       solaris*) CPPFLAGS="$CPPFLAGS -D_REENTRANT" ;;
 101     esac
 102   fi
 103 ])
 104
 105 dnl The guts of gl_THREADLIB. Needs to be expanded only once.
 106
 107 AC_DEFUN([gl_THREADLIB_BODY],
 108 [
 109   AC_REQUIRE([gl_THREADLIB_EARLY_BODY])
 110   gl_threads_api=none
 111   LIBTHREAD=
 112   LTLIBTHREAD=
 113   LIBMULTITHREAD=
 114   LTLIBMULTITHREAD=
 115   if test "$gl_use_threads" != no; then
 116     dnl Check whether the compiler and linker support weak declarations.
 117     AC_CACHE_CHECK([whether imported symbols can be declared weak],
 118       [gl_cv_have_weak],
 119       [gl_cv_have_weak=no
 120        dnl First, test whether the compiler accepts it syntactically.
 121        AC_LINK_IFELSE(
 122          [AC_LANG_PROGRAM(
 123             [[extern void xyzzy ();
 124 #pragma weak xyzzy]],
 125             [[xyzzy();]])],
 126          [gl_cv_have_weak=maybe])
 127        if test $gl_cv_have_weak = maybe; then
 128          dnl Second, test whether it actually works. On Cygwin 1.7.2, with
 129          dnl gcc 4.3, symbols declared weak always evaluate to the address 0.
 130          AC_RUN_IFELSE(
 131            [AC_LANG_SOURCE([[
 132 #include <stdio.h>
 133 #pragma weak fputs
 134 int main ()
 135 {
 136   return (fputs == NULL);
 137 }]])],
 138            [gl_cv_have_weak=yes],
 139            [gl_cv_have_weak=no],
 140            [dnl When cross-compiling, assume that only ELF platforms support
 141             dnl weak symbols.
 142             AC_EGREP_CPP([Extensible Linking Format],
 143               [#ifdef __ELF__
 144                Extensible Linking Format
 145                #endif
 146               ],
 147               [gl_cv_have_weak="guessing yes"],
 148               [gl_cv_have_weak="guessing no"])
 149            ])
 150        fi
 151       ])
 152     if test "$gl_use_threads" = yes || test "$gl_use_threads" = posix; then
 153       # On OSF/1, the compiler needs the flag -pthread or -D_REENTRANT so that
 154       # it groks <pthread.h>. It's added above, in gl_THREADLIB_EARLY_BODY.
 155       AC_CHECK_HEADER([pthread.h],
 156         [gl_have_pthread_h=yes], [gl_have_pthread_h=no])
 157       if test "$gl_have_pthread_h" = yes; then
 158         # Other possible tests:
 159         #   -lpthreads (FSU threads, PCthreads)
 160         #   -lgthreads
 161         gl_have_pthread=
 162         # Test whether both pthread_mutex_lock and pthread_mutexattr_init exist
 163         # in libc. IRIX 6.5 has the first one in both libc and libpthread, but
 164         # the second one only in libpthread, and lock.c needs it.
 165         AC_LINK_IFELSE(
 166           [AC_LANG_PROGRAM(
 167              [[#include <pthread.h>]],
 168              [[pthread_mutex_lock((pthread_mutex_t*)0);
 169                pthread_mutexattr_init((pthread_mutexattr_t*)0);]])],
 170           [gl_have_pthread=yes])
 171         # Test for libpthread by looking for pthread_kill. (Not pthread_self,
 172         # since it is defined as a macro on OSF/1.)
 173         if test -n "$gl_have_pthread"; then
 174           # The program links fine without libpthread. But it may actually
 175           # need to link with libpthread in order to create multiple threads.
 176           AC_CHECK_LIB([pthread], [pthread_kill],
 177             [LIBMULTITHREAD=-lpthread LTLIBMULTITHREAD=-lpthread
 178              # On Solaris and HP-UX, most pthread functions exist also in libc.
 179              # Therefore pthread_in_use() needs to actually try to create a
 180              # thread: pthread_create from libc will fail, whereas
 181              # pthread_create will actually create a thread.
 182              case "$host_os" in
 183                solaris* | hpux*)
 184                  AC_DEFINE([PTHREAD_IN_USE_DETECTION_HARD], [1],
 185                    [Define if the pthread_in_use() detection is hard.])
 186              esac
 187             ])
 188         else
 189           # Some library is needed. Try libpthread and libc_r.
 190           AC_CHECK_LIB([pthread], [pthread_kill],
 191             [gl_have_pthread=yes
 192              LIBTHREAD=-lpthread LTLIBTHREAD=-lpthread
 193              LIBMULTITHREAD=-lpthread LTLIBMULTITHREAD=-lpthread])
 194           if test -z "$gl_have_pthread"; then
 195             # For FreeBSD 4.
 196             AC_CHECK_LIB([c_r], [pthread_kill],
 197               [gl_have_pthread=yes
 198                LIBTHREAD=-lc_r LTLIBTHREAD=-lc_r
 199                LIBMULTITHREAD=-lc_r LTLIBMULTITHREAD=-lc_r])
 200           fi
 201         fi
 202         if test -n "$gl_have_pthread"; then
 203           gl_threads_api=posix
 204           AC_DEFINE([USE_POSIX_THREADS], [1],
 205             [Define if the POSIX multithreading library can be used.])
 206           if test -n "$LIBMULTITHREAD" || test -n "$LTLIBMULTITHREAD"; then
 207             if case "$gl_cv_have_weak" in *yes) true;; *) false;; esac; then
 208               AC_DEFINE([USE_POSIX_THREADS_WEAK], [1],
 209                 [Define if references to the POSIX multithreading library should be made weak.])
 210               LIBTHREAD=
 211               LTLIBTHREAD=
 212             fi
 213           fi
 214         fi
 215       fi
 216     fi
 217     if test -z "$gl_have_pthread"; then
 218       if test "$gl_use_threads" = yes || test "$gl_use_threads" = solaris; then
 219         gl_have_solaristhread=
 220         gl_save_LIBS="$LIBS"
 221         LIBS="$LIBS -lthread"
 222         AC_LINK_IFELSE(
 223           [AC_LANG_PROGRAM(
 224              [[
 225 #include <thread.h>
 226 #include <synch.h>
 227              ]],
 228              [[thr_self();]])],
 229           [gl_have_solaristhread=yes])
 230         LIBS="$gl_save_LIBS"
 231         if test -n "$gl_have_solaristhread"; then
 232           gl_threads_api=solaris
 233           LIBTHREAD=-lthread
 234           LTLIBTHREAD=-lthread
 235           LIBMULTITHREAD="$LIBTHREAD"
 236           LTLIBMULTITHREAD="$LTLIBTHREAD"
 237           AC_DEFINE([USE_SOLARIS_THREADS], [1],
 238             [Define if the old Solaris multithreading library can be used.])
 239           if case "$gl_cv_have_weak" in *yes) true;; *) false;; esac; then
 240             AC_DEFINE([USE_SOLARIS_THREADS_WEAK], [1],
 241               [Define if references to the old Solaris multithreading library should be made weak.])
 242             LIBTHREAD=
 243             LTLIBTHREAD=
 244           fi
 245         fi
 246       fi
 247     fi
 248     if test "$gl_use_threads" = pth; then
 249       gl_save_CPPFLAGS="$CPPFLAGS"
 250       AC_LIB_LINKFLAGS([pth])
 251       gl_have_pth=
 252       gl_save_LIBS="$LIBS"
 253       LIBS="$LIBS $LIBPTH"
 254       AC_LINK_IFELSE(
 255         [AC_LANG_PROGRAM([[#include <pth.h>]], [[pth_self();]])],
 256         [gl_have_pth=yes])
 257       LIBS="$gl_save_LIBS"
 258       if test -n "$gl_have_pth"; then
 259         gl_threads_api=pth
 260         LIBTHREAD="$LIBPTH"
 261         LTLIBTHREAD="$LTLIBPTH"
 262         LIBMULTITHREAD="$LIBTHREAD"
 263         LTLIBMULTITHREAD="$LTLIBTHREAD"
 264         AC_DEFINE([USE_PTH_THREADS], [1],
 265           [Define if the GNU Pth multithreading library can be used.])
 266         if test -n "$LIBMULTITHREAD" || test -n "$LTLIBMULTITHREAD"; then
 267           if case "$gl_cv_have_weak" in *yes) true;; *) false;; esac; then
 268             AC_DEFINE([USE_PTH_THREADS_WEAK], [1],
 269               [Define if references to the GNU Pth multithreading library should be made weak.])
 270             LIBTHREAD=
 271             LTLIBTHREAD=
 272           fi
 273         fi
 274       else
 275         CPPFLAGS="$gl_save_CPPFLAGS"
 276       fi
 277     fi
 278     if test -z "$gl_have_pthread"; then
 279       case "$gl_use_threads" in
 280         yes | windows | win32) # The 'win32' is for backward compatibility.
 281           if { case "$host_os" in
 282                  mingw*) true;;
 283                  *) false;;
 284                esac
 285              }; then
 286             gl_threads_api=windows
 287             AC_DEFINE([USE_WINDOWS_THREADS], [1],
 288               [Define if the native Windows multithreading API can be used.])
 289           fi
 290           ;;
 291       esac
 292     fi
 293   fi
 294   AC_MSG_CHECKING([for multithread API to use])
 295   AC_MSG_RESULT([$gl_threads_api])
 296   AC_SUBST([LIBTHREAD])
 297   AC_SUBST([LTLIBTHREAD])
 298   AC_SUBST([LIBMULTITHREAD])
 299   AC_SUBST([LTLIBMULTITHREAD])
 300 ])
 301
 302 AC_DEFUN([gl_THREADLIB],
 303 [
 304   AC_REQUIRE([gl_THREADLIB_EARLY])
 305   AC_REQUIRE([gl_THREADLIB_BODY])
 306 ])
 307
 308
 309 dnl gl_DISABLE_THREADS
 310 dnl ------------------
 311 dnl Sets the gl_THREADLIB default so that threads are not used by default.
 312 dnl The user can still override it at installation time, by using the
 313 dnl configure option '--enable-threads'.
 314
 315 AC_DEFUN([gl_DISABLE_THREADS], [
 316   m4_divert_text([INIT_PREPARE], [gl_use_threads_default=no])
 317 ])
 318
 319
 320 dnl Survey of platforms:
 321 dnl
 322 dnl Platform           Available  Compiler    Supports   test-lock
 323 dnl                    flavours   option      weak       result
 324 dnl ---------------    ---------  ---------   --------   ---------
 325 dnl Linux 2.4/glibc    posix      -lpthread       Y      OK
 326 dnl
 327 dnl GNU Hurd/glibc     posix
 328 dnl
 329 dnl FreeBSD 5.3        posix      -lc_r           Y
 330 dnl                    posix      -lkse ?         Y
 331 dnl                    posix      -lpthread ?     Y
 332 dnl                    posix      -lthr           Y
 333 dnl
 334 dnl FreeBSD 5.2        posix      -lc_r           Y
 335 dnl                    posix      -lkse           Y
 336 dnl                    posix      -lthr           Y
 337 dnl
 338 dnl FreeBSD 4.0,4.10   posix      -lc_r           Y      OK
 339 dnl
 340 dnl NetBSD 1.6         --
 341 dnl
 342 dnl OpenBSD 3.4        posix      -lpthread       Y      OK
 343 dnl
 344 dnl Mac OS X 10.[123]  posix      -lpthread       Y      OK
 345 dnl
 346 dnl Solaris 7,8,9      posix      -lpthread       Y      Sol 7,8: 0.0; Sol 9: OK
 347 dnl                    solaris    -lthread        Y      Sol 7,8: 0.0; Sol 9: OK
 348 dnl
 349 dnl HP-UX 11           posix      -lpthread       N (cc) OK
 350 dnl                                               Y (gcc)
 351 dnl
 352 dnl IRIX 6.5           posix      -lpthread       Y      0.5
 353 dnl
 354 dnl AIX 4.3,5.1        posix      -lpthread       N      AIX 4: 0.5; AIX 5: OK
 355 dnl
 356 dnl OSF/1 4.0,5.1      posix      -pthread (cc)   N      OK
 357 dnl                               -lpthread (gcc) Y
 358 dnl
 359 dnl Cygwin             posix      -lpthread       Y      OK
 360 dnl
 361 dnl Any of the above   pth        -lpth                  0.0
 362 dnl
 363 dnl Mingw              windows                    N      OK
 364 dnl
 365 dnl BeOS 5             --
 366 dnl
 367 dnl The test-lock result shows what happens if in test-lock.c EXPLICIT_YIELD is
 368 dnl turned off:
 369 dnl   OK if all three tests terminate OK,
 370 dnl   0.5 if the first test terminates OK but the second one loops endlessly,
 371 dnl   0.0 if the first test already loops endlessly.