"Fossies" - the Fresh Open Source Software Archive

Member "gawk-5.1.0/m4/threadlib.m4" (6 Feb 2020, 15159 Bytes) of package /linux/misc/gawk-5.1.0.tar.xz:


As a special service "Fossies" has tried to format the requested text file into HTML format (style: standard) with prefixed line numbers. Alternatively you can here view or download the uninterpreted source code file. See also the latest Fossies "Diffs" side-by-side code changes report for "threadlib.m4": 5.0.1_vs_5.1.0.

    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* | msys*)
   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.