m4/threadlib.m4

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