# threadlib.m4 serial 27

dnl Copyright (C) 2005-2020 Free Software Foundation, Inc.

dnl This file is free software; the Free Software Foundation

dnl gives unlimited permission to copy and/or distribute it,

dnl with or without modifications, as long as this notice is preserved.

dnl From Bruno Haible.

AC_PREREQ([2.60])

dnl The general structure of the multithreading modules in gnulib is that we

dnl have three set of modules:

dnl

dnl   * POSIX API:

dnl     pthread, which combines

dnl       pthread-h

dnl       pthread-thread

dnl       pthread-once

dnl       pthread-mutex

dnl       pthread-rwlock

dnl       pthread-cond

dnl       pthread-tss

dnl       pthread-spin

dnl     sched_yield

dnl

dnl   * ISO C API:

dnl     threads, which combines

dnl       threads-h

dnl       thrd

dnl       mtx

dnl       cnd

dnl       tss

dnl

dnl   * Gnulib API, with an implementation that can be chosen at configure

dnl     time through the option --enable-threads=...

dnl       thread

dnl       lock

dnl       cond

dnl       tls

dnl       yield

dnl

dnl They are independent, except for the fact that

dnl   - the implementation of the ISO C API may use the POSIX (or some other

dnl     platform dependent) API,

dnl   - the implementation of the Gnulib API may use the POSIX or ISO C or

dnl     some other platform dependent API, depending on the --enable-threads

dnl     option.

dnl

dnl This file contains macros for all of these APIs!

dnl ============================================================================

dnl Macros for all thread APIs

AC_DEFUN([gl_ANYTHREADLIB_EARLY],

[

  AC_REQUIRE([AC_CANONICAL_HOST])

  if test -z "$gl_anythreadlib_early_done"; then

    case "$host_os" in

      osf*)

        # On OSF/1, the compiler needs the flag -D_REENTRANT so that it

        # groks <pthread.h>. cc also understands the flag -pthread, but

        # we don't use it because 1. gcc-2.95 doesn't understand -pthread,

        # 2. putting a flag into CPPFLAGS that has an effect on the linker

        # causes the AC_LINK_IFELSE test below to succeed unexpectedly,

        # leading to wrong values of LIBTHREAD and LTLIBTHREAD.

        CPPFLAGS="$CPPFLAGS -D_REENTRANT"

        ;;

    esac

    # Some systems optimize for single-threaded programs by default, and

    # need special flags to disable these optimizations. For example, the

    # definition of 'errno' in <errno.h>.

    case "$host_os" in

      aix* | freebsd*) CPPFLAGS="$CPPFLAGS -D_THREAD_SAFE" ;;

      solaris*) CPPFLAGS="$CPPFLAGS -D_REENTRANT" ;;

    esac

    gl_anythreadlib_early_done=done

  fi

])

dnl Checks whether the compiler and linker support weak declarations of symbols.

AC_DEFUN([gl_WEAK_SYMBOLS],

[

  AC_REQUIRE([AC_CANONICAL_HOST])

  AC_CACHE_CHECK([whether imported symbols can be declared weak],

    [gl_cv_have_weak],

    [gl_cv_have_weak=no

     dnl First, test whether the compiler accepts it syntactically.

     AC_LINK_IFELSE(

       [AC_LANG_PROGRAM(

          [[extern void xyzzy ();

#pragma weak xyzzy]],

          [[xyzzy();]])],

       [gl_cv_have_weak=maybe])

     if test $gl_cv_have_weak = maybe; then

       dnl Second, test whether it actually works. On Cygwin 1.7.2, with

       dnl gcc 4.3, symbols declared weak always evaluate to the address 0.

       AC_RUN_IFELSE(

         [AC_LANG_SOURCE([[

#include <stdio.h>

#pragma weak fputs

int main ()

{

  return (fputs == NULL);

}]])],

         [gl_cv_have_weak=yes],

         [gl_cv_have_weak=no],

         [dnl When cross-compiling, assume that only ELF platforms support

          dnl weak symbols.

          AC_EGREP_CPP([Extensible Linking Format],

            [#ifdef __ELF__

             Extensible Linking Format

             #endif

            ],

            [gl_cv_have_weak="guessing yes"],

            [gl_cv_have_weak="guessing no"])

         ])

     fi

     dnl But when linking statically, weak symbols don't work.

     case " $LDFLAGS " in

       *" -static "*) gl_cv_have_weak=no ;;

     esac

     dnl Test for a bug in FreeBSD 11: A link error occurs when using a weak

     dnl symbol and linking against a shared library that has a dependency on

     dnl the shared library that defines the symbol.

     case "$gl_cv_have_weak" in

       *yes)

         case "$host_os" in

           freebsd* | dragonfly*)

             : > conftest1.c

             $CC $CPPFLAGS $CFLAGS $LDFLAGS -fPIC -shared -o libempty.so conftest1.c -lpthread >&AS_MESSAGE_LOG_FD 2>&1

             cat <<EOF > conftest2.c

#include <pthread.h>

#pragma weak pthread_mutexattr_gettype

int main ()

{

  return (pthread_mutexattr_gettype != NULL);

}

EOF

             $CC $CPPFLAGS $CFLAGS $LDFLAGS -o conftest conftest2.c libempty.so >&AS_MESSAGE_LOG_FD 2>&1 \

               || gl_cv_have_weak=no

             rm -f conftest1.c libempty.so conftest2.c conftest

             ;;

         esac

         ;;

     esac

    ])

  case "$gl_cv_have_weak" in

    *yes)

      AC_DEFINE([HAVE_WEAK_SYMBOLS], [1],

        [Define to 1 if the compiler and linker support weak declarations of symbols.])

      ;;

  esac

])

dnl ============================================================================

dnl Macros for the POSIX API

dnl gl_PTHREADLIB

dnl -------------

dnl Tests for the libraries needs for using the POSIX threads API.

dnl Sets the variable LIBPTHREAD to the linker options for use in a Makefile.

dnl Sets the variable LIBPMULTITHREAD, for programs that really need

dnl multithread functionality. The difference between LIBPTHREAD and

dnl LIBPMULTITHREAD is that on platforms supporting weak symbols, typically

dnl LIBPTHREAD is empty whereas LIBPMULTITHREAD is not.

dnl Sets the variable LIB_SCHED_YIELD to the linker options needed to use the

dnl sched_yield() function.

dnl Adds to CPPFLAGS the flag -D_REENTRANT or -D_THREAD_SAFE if needed for

dnl multithread-safe programs.

dnl Defines the C macro HAVE_PTHREAD_API if (at least parts of) the POSIX

dnl threads API is available.

dnl The guts of gl_PTHREADLIB. Needs to be expanded only once.

AC_DEFUN([gl_PTHREADLIB_BODY],

[

  AC_REQUIRE([gl_ANYTHREADLIB_EARLY])

  if test -z "$gl_pthreadlib_body_done"; then

    gl_pthread_api=no

    LIBPTHREAD=

    LIBPMULTITHREAD=

    # On OSF/1, the compiler needs the flag -pthread or -D_REENTRANT so that

    # it groks <pthread.h>. It's added above, in gl_ANYTHREADLIB_EARLY.

    AC_CHECK_HEADER([pthread.h],

      [gl_have_pthread_h=yes], [gl_have_pthread_h=no])

    if test "$gl_have_pthread_h" = yes; then

      # Other possible tests:

      #   -lpthreads (FSU threads, PCthreads)

      #   -lgthreads

      # Test whether both pthread_mutex_lock and pthread_mutexattr_init exist

      # in libc. IRIX 6.5 has the first one in both libc and libpthread, but

      # the second one only in libpthread, and lock.c needs it.

      #

      # If -pthread works, prefer it to -lpthread, since Ubuntu 14.04

      # needs -pthread for some reason.  See:

      # https://lists.gnu.org/r/bug-gnulib/2014-09/msg00023.html

      save_LIBS=$LIBS

      for gl_pthread in '' '-pthread'; do

        LIBS="$LIBS $gl_pthread"

        AC_LINK_IFELSE(

          [AC_LANG_PROGRAM(

             [[#include <pthread.h>

               pthread_mutex_t m;

               pthread_mutexattr_t ma;

             ]],

             [[pthread_mutex_lock (&m);

               pthread_mutexattr_init (&ma);]])],

          [gl_pthread_api=yes

           LIBPTHREAD=$gl_pthread

           LIBPMULTITHREAD=$gl_pthread])

        LIBS=$save_LIBS

        test $gl_pthread_api = yes && break

      done

      # Test for libpthread by looking for pthread_kill. (Not pthread_self,

      # since it is defined as a macro on OSF/1.)

      if test $gl_pthread_api = yes && test -z "$LIBPTHREAD"; then

        # The program links fine without libpthread. But it may actually

        # need to link with libpthread in order to create multiple threads.

        AC_CHECK_LIB([pthread], [pthread_kill],

          [LIBPMULTITHREAD=-lpthread

           # On Solaris and HP-UX, most pthread functions exist also in libc.

           # Therefore pthread_in_use() needs to actually try to create a

           # thread: pthread_create from libc will fail, whereas

           # pthread_create will actually create a thread.

           # On Solaris 10 or newer, this test is no longer needed, because

           # libc contains the fully functional pthread functions.

           case "$host_os" in

             solaris | solaris2.[1-9] | solaris2.[1-9].* | hpux*)

               AC_DEFINE([PTHREAD_IN_USE_DETECTION_HARD], [1],

                 [Define if the pthread_in_use() detection is hard.])

           esac

          ])

      elif test $gl_pthread_api != yes; then

        # Some library is needed. Try libpthread and libc_r.

        AC_CHECK_LIB([pthread], [pthread_kill],

          [gl_pthread_api=yes

           LIBPTHREAD=-lpthread

           LIBPMULTITHREAD=-lpthread])

        if test $gl_pthread_api != yes; then

          # For FreeBSD 4.

          AC_CHECK_LIB([c_r], [pthread_kill],

            [gl_pthread_api=yes

             LIBPTHREAD=-lc_r

             LIBPMULTITHREAD=-lc_r])

        fi

      fi

    fi

    AC_MSG_CHECKING([whether POSIX threads API is available])

    AC_MSG_RESULT([$gl_pthread_api])

    AC_SUBST([LIBPTHREAD])

    AC_SUBST([LIBPMULTITHREAD])

    if test $gl_pthread_api = yes; then

      AC_DEFINE([HAVE_PTHREAD_API], [1],

        [Define if you have the <pthread.h> header and the POSIX threads API.])

    fi

    dnl On some systems, sched_yield is in librt, rather than in libpthread.

    AC_LINK_IFELSE(

      [AC_LANG_PROGRAM(

         [[#include <sched.h>]],

         [[sched_yield ();]])],

      [LIB_SCHED_YIELD=

      ],

      [dnl Solaris 7...10 has sched_yield in librt, not in libpthread or libc.

       AC_CHECK_LIB([rt], [sched_yield], [LIB_SCHED_YIELD=-lrt],

         [dnl Solaris 2.5.1, 2.6 has sched_yield in libposix4, not librt.

          AC_CHECK_LIB([posix4], [sched_yield], [LIB_SCHED_YIELD=-lposix4])])

      ])

    AC_SUBST([LIB_SCHED_YIELD])

    gl_pthreadlib_body_done=done

  fi

])

AC_DEFUN([gl_PTHREADLIB],

[

  AC_REQUIRE([gl_ANYTHREADLIB_EARLY])

  gl_PTHREADLIB_BODY

])

dnl ============================================================================

dnl Macros for the ISO C API

dnl gl_STDTHREADLIB

dnl ---------------

dnl Tests for the libraries needs for using the ISO C threads API.

dnl Sets the variable LIBSTDTHREAD to the linker options for use in a Makefile.

dnl Adds to CPPFLAGS the flag -D_REENTRANT or -D_THREAD_SAFE if needed for

dnl multithread-safe programs.

dnl Defines the C macro HAVE_THREADS_H if (at least parts of) the ISO C threads

dnl API is available.

dnl The guts of gl_STDTHREADLIB. Needs to be expanded only once.

AC_DEFUN([gl_STDTHREADLIB_BODY],

[

  AC_REQUIRE([gl_ANYTHREADLIB_EARLY])

  AC_REQUIRE([AC_CANONICAL_HOST])

  if test -z "$gl_stdthreadlib_body_done"; then

    AC_CHECK_HEADERS_ONCE([threads.h])

    case "$host_os" in

      mingw*)

        LIBSTDTHREAD=

        ;;

      *)

        gl_PTHREADLIB_BODY

        if test $ac_cv_header_threads_h = yes; then

          dnl glibc >= 2.29 has thrd_create in libpthread.

          dnl FreeBSD >= 10 has thrd_create in libstdthreads; this library depends

          dnl on libpthread (for the symbol 'pthread_mutexattr_gettype').

          dnl AIX >= 7.1 and Solaris >= 11.4 have thrd_create in libc.

          AC_CHECK_FUNCS([thrd_create])

          if test $ac_cv_func_thrd_create = yes; then

            LIBSTDTHREAD=

          else

            AC_CHECK_LIB([stdthreads], [thrd_create], [

              LIBSTDTHREAD='-lstdthreads -lpthread'

            ], [

              dnl Guess that thrd_create is in libpthread.

              LIBSTDTHREAD="$LIBPMULTITHREAD"

            ])

          fi

        else

          dnl Libraries needed by thrd.c, mtx.c, cnd.c, tss.c.

          LIBSTDTHREAD="$LIBPMULTITHREAD $LIB_SCHED_YIELD"

        fi

        ;;

    esac

    AC_SUBST([LIBSTDTHREAD])

    AC_MSG_CHECKING([whether ISO C threads API is available])

    AC_MSG_RESULT([$ac_cv_header_threads_h])

    gl_stdthreadlib_body_done=done

  fi

])

AC_DEFUN([gl_STDTHREADLIB],

[

  AC_REQUIRE([gl_ANYTHREADLIB_EARLY])

  gl_STDTHREADLIB_BODY

])

dnl ============================================================================

dnl Macros for the Gnulib API

dnl gl_THREADLIB

dnl ------------

dnl Tests for a multithreading library to be used.

dnl If the configure.ac contains a definition of the gl_THREADLIB_DEFAULT_NO

dnl (it must be placed before the invocation of gl_THREADLIB_EARLY!), then the

dnl default is 'no', otherwise it is system dependent. In both cases, the user

dnl can change the choice through the options --enable-threads=choice or

dnl --disable-threads.

dnl Defines at most one of the macros USE_ISOC_THREADS, USE_POSIX_THREADS,

dnl USE_ISOC_AND_POSIX_THREADS, USE_WINDOWS_THREADS.

dnl The choice --enable-threads=isoc+posix is available only on platforms that

dnl have both the ISO C and the POSIX threads APIs. It has the effect of using

dnl the ISO C API for most things and the POSIX API only for creating and

dnl controlling threads (because there is no equivalent to pthread_atfork in

dnl the ISO C API).

dnl Sets the variables LIBTHREAD and LTLIBTHREAD to the linker options for use

dnl in a Makefile (LIBTHREAD for use without libtool, LTLIBTHREAD for use with

dnl libtool).

dnl Sets the variables LIBMULTITHREAD and LTLIBMULTITHREAD similarly, for

dnl programs that really need multithread functionality. The difference

dnl between LIBTHREAD and LIBMULTITHREAD is that on platforms supporting weak

dnl symbols, typically LIBTHREAD is empty whereas LIBMULTITHREAD is not.

dnl Adds to CPPFLAGS the flag -D_REENTRANT or -D_THREAD_SAFE if needed for

dnl multithread-safe programs.

dnl Since support for GNU pth was removed, $LTLIBTHREAD and $LIBTHREAD have the

dnl same value, and similarly $LTLIBMULTITHREAD and $LIBMULTITHREAD have the

dnl same value. Only system libraries are needed.

AC_DEFUN([gl_THREADLIB_EARLY],

[

  AC_REQUIRE([gl_THREADLIB_EARLY_BODY])

])

dnl The guts of gl_THREADLIB_EARLY. Needs to be expanded only once.

AC_DEFUN([gl_THREADLIB_EARLY_BODY],

[

  dnl Ordering constraints: This macro modifies CPPFLAGS in a way that

  dnl influences the result of the autoconf tests that test for *_unlocked

  dnl declarations, on AIX 5 at least. Therefore it must come early.

  AC_BEFORE([$0], [gl_FUNC_GLIBC_UNLOCKED_IO])dnl

  AC_BEFORE([$0], [gl_ARGP])dnl

  AC_REQUIRE([AC_CANONICAL_HOST])

  dnl _GNU_SOURCE is needed for pthread_rwlock_t on glibc systems.

  AC_REQUIRE([AC_USE_SYSTEM_EXTENSIONS])

  dnl Check for multithreading.

  m4_ifdef([gl_THREADLIB_DEFAULT_NO],

    [m4_divert_text([DEFAULTS], [gl_use_threads_default=no])],

    [m4_divert_text([DEFAULTS], [gl_use_threads_default=])])

  m4_divert_text([DEFAULTS], [gl_use_winpthreads_default=])

  AC_ARG_ENABLE([threads],

AC_HELP_STRING([--enable-threads={isoc|posix|isoc+posix|windows}], [specify multithreading API])m4_ifdef([gl_THREADLIB_DEFAULT_NO], [], [

AC_HELP_STRING([--disable-threads], [build without multithread safety])]),

    [gl_use_threads=$enableval],

    [if test -n "$gl_use_threads_default"; then

       gl_use_threads="$gl_use_threads_default"

     else

changequote(,)dnl

       case "$host_os" in

         dnl Disable multithreading by default on OSF/1, because it interferes

         dnl with fork()/exec(): When msgexec is linked with -lpthread, its

         dnl child process gets an endless segmentation fault inside execvp().

         osf*) gl_use_threads=no ;;

         dnl Disable multithreading by default on Cygwin 1.5.x, because it has

         dnl bugs that lead to endless loops or crashes. See

         dnl <https://cygwin.com/ml/cygwin/2009-08/msg00283.html>.

         cygwin*)

               case `uname -r` in

                 1.[0-5].*) gl_use_threads=no ;;

                 *)         gl_use_threads=yes ;;

               esac

               ;;

         dnl Obey gl_AVOID_WINPTHREAD on mingw.

         mingw*)

               case "$gl_use_winpthreads_default" in

                 yes) gl_use_threads=posix ;;

                 no)  gl_use_threads=windows ;;

                 *)   gl_use_threads=yes ;;

               esac

               ;;

         *)    gl_use_threads=yes ;;

       esac

changequote([,])dnl

     fi

    ])

  if test "$gl_use_threads" = yes \

     || test "$gl_use_threads" = isoc \

     || test "$gl_use_threads" = posix \

     || test "$gl_use_threads" = isoc+posix; then

    # For using <threads.h> or <pthread.h>:

    gl_ANYTHREADLIB_EARLY

  fi

])

dnl The guts of gl_THREADLIB. Needs to be expanded only once.

AC_DEFUN([gl_THREADLIB_BODY],

[

  AC_REQUIRE([gl_THREADLIB_EARLY_BODY])

  gl_threads_api=none

  LIBTHREAD=

  LTLIBTHREAD=

  LIBMULTITHREAD=

  LTLIBMULTITHREAD=

  if test "$gl_use_threads" != no; then

    dnl Check whether the compiler and linker support weak declarations.

    gl_WEAK_SYMBOLS

    if case "$gl_cv_have_weak" in *yes) true;; *) false;; esac; then

      dnl If we use weak symbols to implement pthread_in_use / pth_in_use /

      dnl thread_in_use, we also need to test whether the ISO C 11 thrd_create

      dnl facility is in use.

      AC_CHECK_HEADERS_ONCE([threads.h])

      :

    fi

    if test "$gl_use_threads" = isoc || test "$gl_use_threads" = isoc+posix; then

      AC_CHECK_HEADERS_ONCE([threads.h])

      gl_have_isoc_threads="$ac_cv_header_threads_h"

    fi

    if test "$gl_use_threads" = yes \

       || test "$gl_use_threads" = posix \

       || test "$gl_use_threads" = isoc+posix; then

      gl_PTHREADLIB_BODY

      LIBTHREAD=$LIBPTHREAD LTLIBTHREAD=$LIBPTHREAD

      LIBMULTITHREAD=$LIBPMULTITHREAD LTLIBMULTITHREAD=$LIBPMULTITHREAD

      if test $gl_pthread_api = yes; then

        if test "$gl_use_threads" = isoc+posix && test "$gl_have_isoc_threads" = yes; then

          gl_threads_api='isoc+posix'

          AC_DEFINE([USE_ISOC_AND_POSIX_THREADS], [1],

            [Define if the combination of the ISO C and POSIX multithreading APIs can be used.])

          LIBTHREAD= LTLIBTHREAD=

        else

          gl_threads_api=posix

          AC_DEFINE([USE_POSIX_THREADS], [1],

            [Define if the POSIX multithreading library can be used.])

          if test -n "$LIBMULTITHREAD" || test -n "$LTLIBMULTITHREAD"; then

            if case "$gl_cv_have_weak" in *yes) true;; *) false;; esac; then

              AC_DEFINE([USE_POSIX_THREADS_WEAK], [1],

                [Define if references to the POSIX multithreading library should be made weak.])

              LIBTHREAD= LTLIBTHREAD=

            fi

          fi

        fi

      fi

    fi

    if test $gl_threads_api = none; then

      if test "$gl_use_threads" = isoc && test "$gl_have_isoc_threads" = yes; then

        gl_STDTHREADLIB_BODY

        LIBTHREAD=$LIBSTDTHREAD LTLIBTHREAD=$LIBSTDTHREAD

        LIBMULTITHREAD=$LIBSTDTHREAD LTLIBMULTITHREAD=$LIBSTDTHREAD

        gl_threads_api=isoc

        AC_DEFINE([USE_ISOC_THREADS], [1],

          [Define if the ISO C multithreading library can be used.])

      fi

    fi

    if test $gl_threads_api = none; then

      case "$gl_use_threads" in

        yes | windows | win32) # The 'win32' is for backward compatibility.

          if { case "$host_os" in

                 mingw*) true;;

                 *) false;;

               esac

             }; then

            gl_threads_api=windows

            AC_DEFINE([USE_WINDOWS_THREADS], [1],

              [Define if the native Windows multithreading API can be used.])

          fi

          ;;

      esac

    fi

  fi

  AC_MSG_CHECKING([for multithread API to use])

  AC_MSG_RESULT([$gl_threads_api])

  AC_SUBST([LIBTHREAD])

  AC_SUBST([LTLIBTHREAD])

  AC_SUBST([LIBMULTITHREAD])

  AC_SUBST([LTLIBMULTITHREAD])

])

AC_DEFUN([gl_THREADLIB],

[

  AC_REQUIRE([gl_THREADLIB_EARLY])

  AC_REQUIRE([gl_THREADLIB_BODY])

])

dnl gl_DISABLE_THREADS

dnl ------------------

dnl Sets the gl_THREADLIB default so that threads are not used by default.

dnl The user can still override it at installation time, by using the

dnl configure option '--enable-threads'.

AC_DEFUN([gl_DISABLE_THREADS], [

  m4_divert_text([INIT_PREPARE], [gl_use_threads_default=no])

])

dnl gl_AVOID_WINPTHREAD

dnl -------------------

dnl Sets the gl_THREADLIB default so that on mingw, a dependency to the

dnl libwinpthread DLL (mingw-w64 winpthreads library) is avoided.

dnl The user can still override it at installation time, by using the

dnl configure option '--enable-threads'.

AC_DEFUN([gl_AVOID_WINPTHREAD], [

  m4_divert_text([INIT_PREPARE], [gl_use_winpthreads_default=no])

])

dnl ============================================================================

dnl Survey of platforms:

dnl

dnl Platform           Available  Compiler    Supports   test-lock

dnl                    flavours   option      weak       result

dnl ---------------    ---------  ---------   --------   ---------

dnl Linux 2.4/glibc    posix      -lpthread       Y      OK

dnl

dnl GNU Hurd/glibc     posix

dnl

dnl Ubuntu 14.04       posix      -pthread        Y      OK

dnl

dnl FreeBSD 5.3        posix      -lc_r           Y

dnl                    posix      -lkse ?         Y

dnl                    posix      -lpthread ?     Y

dnl                    posix      -lthr           Y

dnl

dnl FreeBSD 5.2        posix      -lc_r           Y

dnl                    posix      -lkse           Y

dnl                    posix      -lthr           Y

dnl

dnl FreeBSD 4.0,4.10   posix      -lc_r           Y      OK

dnl

dnl NetBSD 1.6         --

dnl

dnl OpenBSD 3.4        posix      -lpthread       Y      OK

dnl

dnl Mac OS X 10.[123]  posix      -lpthread       Y      OK

dnl

dnl Solaris 7,8,9      posix      -lpthread       Y      Sol 7,8: 0.0; Sol 9: OK

dnl

dnl HP-UX 11           posix      -lpthread       N (cc) OK

dnl                                               Y (gcc)

dnl

dnl IRIX 6.5           posix      -lpthread       Y      0.5

dnl

dnl AIX 4.3,5.1        posix      -lpthread       N      AIX 4: 0.5; AIX 5: OK

dnl

dnl OSF/1 4.0,5.1      posix      -pthread (cc)   N      OK

dnl                               -lpthread (gcc) Y

dnl

dnl Cygwin             posix      -lpthread       Y      OK

dnl

dnl Mingw              windows                    N      OK

dnl

dnl BeOS 5             --

dnl

dnl The test-lock result shows what happens if in test-lock.c EXPLICIT_YIELD is

dnl turned off:

dnl   OK if all three tests terminate OK,

dnl   0.5 if the first test terminates OK but the second one loops endlessly,

dnl   0.0 if the first test already loops endlessly.