m4/threadlib.m4

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