m4/threadlib.m4

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