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

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