git.gag.com Git - debian/gzip/blob - m4/threadlib.m4

   1 # threadlib.m4 serial 13
   2 dnl Copyright (C) 2005-2018 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 is empty whereas LIBMULTITHREAD is not.
  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 <https://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        dnl But when linking statically, weak symbols don't work.
 152        case " $LDFLAGS " in
 153          *" -static "*) gl_cv_have_weak=no ;;
 154        esac
 155       ])
 156     if test "$gl_use_threads" = yes || test "$gl_use_threads" = posix; then
 157       # On OSF/1, the compiler needs the flag -pthread or -D_REENTRANT so that
 158       # it groks <pthread.h>. It's added above, in gl_THREADLIB_EARLY_BODY.
 159       AC_CHECK_HEADER([pthread.h],
 160         [gl_have_pthread_h=yes], [gl_have_pthread_h=no])
 161       if test "$gl_have_pthread_h" = yes; then
 162         # Other possible tests:
 163         #   -lpthreads (FSU threads, PCthreads)
 164         #   -lgthreads
 165         gl_have_pthread=
 166         # Test whether both pthread_mutex_lock and pthread_mutexattr_init exist
 167         # in libc. IRIX 6.5 has the first one in both libc and libpthread, but
 168         # the second one only in libpthread, and lock.c needs it.
 169         #
 170         # If -pthread works, prefer it to -lpthread, since Ubuntu 14.04
 171         # needs -pthread for some reason.  See:
 172         # https://lists.gnu.org/r/bug-gnulib/2014-09/msg00023.html
 173         save_LIBS=$LIBS
 174         for gl_pthread in '' '-pthread'; do
 175           LIBS="$LIBS $gl_pthread"
 176           AC_LINK_IFELSE(
 177             [AC_LANG_PROGRAM(
 178                [[#include <pthread.h>
 179                  pthread_mutex_t m;
 180                  pthread_mutexattr_t ma;
 181                ]],
 182                [[pthread_mutex_lock (&m);
 183                  pthread_mutexattr_init (&ma);]])],
 184             [gl_have_pthread=yes
 185              LIBTHREAD=$gl_pthread LTLIBTHREAD=$gl_pthread
 186              LIBMULTITHREAD=$gl_pthread LTLIBMULTITHREAD=$gl_pthread])
 187           LIBS=$save_LIBS
 188           test -n "$gl_have_pthread" && break
 189         done
 190
 191         # Test for libpthread by looking for pthread_kill. (Not pthread_self,
 192         # since it is defined as a macro on OSF/1.)
 193         if test -n "$gl_have_pthread" && test -z "$LIBTHREAD"; then
 194           # The program links fine without libpthread. But it may actually
 195           # need to link with libpthread in order to create multiple threads.
 196           AC_CHECK_LIB([pthread], [pthread_kill],
 197             [LIBMULTITHREAD=-lpthread LTLIBMULTITHREAD=-lpthread
 198              # On Solaris and HP-UX, most pthread functions exist also in libc.
 199              # Therefore pthread_in_use() needs to actually try to create a
 200              # thread: pthread_create from libc will fail, whereas
 201              # pthread_create will actually create a thread.
 202              # On Solaris 10 or newer, this test is no longer needed, because
 203              # libc contains the fully functional pthread functions.
 204              case "$host_os" in
 205                solaris | solaris2.[1-9] | solaris2.[1-9].* | hpux*)
 206                  AC_DEFINE([PTHREAD_IN_USE_DETECTION_HARD], [1],
 207                    [Define if the pthread_in_use() detection is hard.])
 208              esac
 209             ])
 210         elif test -z "$gl_have_pthread"; then
 211           # Some library is needed. Try libpthread and libc_r.
 212           AC_CHECK_LIB([pthread], [pthread_kill],
 213             [gl_have_pthread=yes
 214              LIBTHREAD=-lpthread LTLIBTHREAD=-lpthread
 215              LIBMULTITHREAD=-lpthread LTLIBMULTITHREAD=-lpthread])
 216           if test -z "$gl_have_pthread"; then
 217             # For FreeBSD 4.
 218             AC_CHECK_LIB([c_r], [pthread_kill],
 219               [gl_have_pthread=yes
 220                LIBTHREAD=-lc_r LTLIBTHREAD=-lc_r
 221                LIBMULTITHREAD=-lc_r LTLIBMULTITHREAD=-lc_r])
 222           fi
 223         fi
 224         if test -n "$gl_have_pthread"; then
 225           gl_threads_api=posix
 226           AC_DEFINE([USE_POSIX_THREADS], [1],
 227             [Define if the POSIX multithreading library can be used.])
 228           if test -n "$LIBMULTITHREAD" || test -n "$LTLIBMULTITHREAD"; then
 229             if case "$gl_cv_have_weak" in *yes) true;; *) false;; esac; then
 230               AC_DEFINE([USE_POSIX_THREADS_WEAK], [1],
 231                 [Define if references to the POSIX multithreading library should be made weak.])
 232               LIBTHREAD=
 233               LTLIBTHREAD=
 234             fi
 235           fi
 236         fi
 237       fi
 238     fi
 239     if test -z "$gl_have_pthread"; then
 240       if test "$gl_use_threads" = yes || test "$gl_use_threads" = solaris; then
 241         gl_have_solaristhread=
 242         gl_save_LIBS="$LIBS"
 243         LIBS="$LIBS -lthread"
 244         AC_LINK_IFELSE(
 245           [AC_LANG_PROGRAM(
 246              [[
 247 #include <thread.h>
 248 #include <synch.h>
 249              ]],
 250              [[thr_self();]])],
 251           [gl_have_solaristhread=yes])
 252         LIBS="$gl_save_LIBS"
 253         if test -n "$gl_have_solaristhread"; then
 254           gl_threads_api=solaris
 255           LIBTHREAD=-lthread
 256           LTLIBTHREAD=-lthread
 257           LIBMULTITHREAD="$LIBTHREAD"
 258           LTLIBMULTITHREAD="$LTLIBTHREAD"
 259           AC_DEFINE([USE_SOLARIS_THREADS], [1],
 260             [Define if the old Solaris multithreading library can be used.])
 261           if case "$gl_cv_have_weak" in *yes) true;; *) false;; esac; then
 262             AC_DEFINE([USE_SOLARIS_THREADS_WEAK], [1],
 263               [Define if references to the old Solaris multithreading library should be made weak.])
 264             LIBTHREAD=
 265             LTLIBTHREAD=
 266           fi
 267         fi
 268       fi
 269     fi
 270     if test "$gl_use_threads" = pth; then
 271       gl_save_CPPFLAGS="$CPPFLAGS"
 272       AC_LIB_LINKFLAGS([pth])
 273       gl_have_pth=
 274       gl_save_LIBS="$LIBS"
 275       LIBS="$LIBS $LIBPTH"
 276       AC_LINK_IFELSE(
 277         [AC_LANG_PROGRAM([[#include <pth.h>]], [[pth_self();]])],
 278         [gl_have_pth=yes])
 279       LIBS="$gl_save_LIBS"
 280       if test -n "$gl_have_pth"; then
 281         gl_threads_api=pth
 282         LIBTHREAD="$LIBPTH"
 283         LTLIBTHREAD="$LTLIBPTH"
 284         LIBMULTITHREAD="$LIBTHREAD"
 285         LTLIBMULTITHREAD="$LTLIBTHREAD"
 286         AC_DEFINE([USE_PTH_THREADS], [1],
 287           [Define if the GNU Pth multithreading library can be used.])
 288         if test -n "$LIBMULTITHREAD" || test -n "$LTLIBMULTITHREAD"; then
 289           if case "$gl_cv_have_weak" in *yes) true;; *) false;; esac; then
 290             AC_DEFINE([USE_PTH_THREADS_WEAK], [1],
 291               [Define if references to the GNU Pth multithreading library should be made weak.])
 292             LIBTHREAD=
 293             LTLIBTHREAD=
 294           fi
 295         fi
 296       else
 297         CPPFLAGS="$gl_save_CPPFLAGS"
 298       fi
 299     fi
 300     if test -z "$gl_have_pthread"; then
 301       case "$gl_use_threads" in
 302         yes | windows | win32) # The 'win32' is for backward compatibility.
 303           if { case "$host_os" in
 304                  mingw*) true;;
 305                  *) false;;
 306                esac
 307              }; then
 308             gl_threads_api=windows
 309             AC_DEFINE([USE_WINDOWS_THREADS], [1],
 310               [Define if the native Windows multithreading API can be used.])
 311           fi
 312           ;;
 313       esac
 314     fi
 315   fi
 316   AC_MSG_CHECKING([for multithread API to use])
 317   AC_MSG_RESULT([$gl_threads_api])
 318   AC_SUBST([LIBTHREAD])
 319   AC_SUBST([LTLIBTHREAD])
 320   AC_SUBST([LIBMULTITHREAD])
 321   AC_SUBST([LTLIBMULTITHREAD])
 322 ])
 323
 324 AC_DEFUN([gl_THREADLIB],
 325 [
 326   AC_REQUIRE([gl_THREADLIB_EARLY])
 327   AC_REQUIRE([gl_THREADLIB_BODY])
 328 ])
 329
 330
 331 dnl gl_DISABLE_THREADS
 332 dnl ------------------
 333 dnl Sets the gl_THREADLIB default so that threads are not used by default.
 334 dnl The user can still override it at installation time, by using the
 335 dnl configure option '--enable-threads'.
 336
 337 AC_DEFUN([gl_DISABLE_THREADS], [
 338   m4_divert_text([INIT_PREPARE], [gl_use_threads_default=no])
 339 ])
 340
 341
 342 dnl Survey of platforms:
 343 dnl
 344 dnl Platform           Available  Compiler    Supports   test-lock
 345 dnl                    flavours   option      weak       result
 346 dnl ---------------    ---------  ---------   --------   ---------
 347 dnl Linux 2.4/glibc    posix      -lpthread       Y      OK
 348 dnl
 349 dnl GNU Hurd/glibc     posix
 350 dnl
 351 dnl Ubuntu 14.04       posix      -pthread        Y      OK
 352 dnl
 353 dnl FreeBSD 5.3        posix      -lc_r           Y
 354 dnl                    posix      -lkse ?         Y
 355 dnl                    posix      -lpthread ?     Y
 356 dnl                    posix      -lthr           Y
 357 dnl
 358 dnl FreeBSD 5.2        posix      -lc_r           Y
 359 dnl                    posix      -lkse           Y
 360 dnl                    posix      -lthr           Y
 361 dnl
 362 dnl FreeBSD 4.0,4.10   posix      -lc_r           Y      OK
 363 dnl
 364 dnl NetBSD 1.6         --
 365 dnl
 366 dnl OpenBSD 3.4        posix      -lpthread       Y      OK
 367 dnl
 368 dnl Mac OS X 10.[123]  posix      -lpthread       Y      OK
 369 dnl
 370 dnl Solaris 7,8,9      posix      -lpthread       Y      Sol 7,8: 0.0; Sol 9: OK
 371 dnl                    solaris    -lthread        Y      Sol 7,8: 0.0; Sol 9: OK
 372 dnl
 373 dnl HP-UX 11           posix      -lpthread       N (cc) OK
 374 dnl                                               Y (gcc)
 375 dnl
 376 dnl IRIX 6.5           posix      -lpthread       Y      0.5
 377 dnl
 378 dnl AIX 4.3,5.1        posix      -lpthread       N      AIX 4: 0.5; AIX 5: OK
 379 dnl
 380 dnl OSF/1 4.0,5.1      posix      -pthread (cc)   N      OK
 381 dnl                               -lpthread (gcc) Y
 382 dnl
 383 dnl Cygwin             posix      -lpthread       Y      OK
 384 dnl
 385 dnl Any of the above   pth        -lpth                  0.0
 386 dnl
 387 dnl Mingw              windows                    N      OK
 388 dnl
 389 dnl BeOS 5             --
 390 dnl
 391 dnl The test-lock result shows what happens if in test-lock.c EXPLICIT_YIELD is
 392 dnl turned off:
 393 dnl   OK if all three tests terminate OK,
 394 dnl   0.5 if the first test terminates OK but the second one loops endlessly,
 395 dnl   0.0 if the first test already loops endlessly.