# lock.m4 serial 7 (gettext-0.17)

dnl Copyright (C) 2005-2007 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.

dnl Tests for a multithreading library to be used.

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

dnl USE_PTH_THREADS, USE_WIN32_THREADS

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="" whereas LIBMULTITHREAD="-lpthread".

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

dnl multithread-safe programs.

AC_DEFUN([gl_LOCK_EARLY],

[

  AC_REQUIRE([gl_LOCK_EARLY_BODY])

])

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

AC_DEFUN([gl_LOCK_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.

  dnl AC_USE_SYSTEM_EXTENSIONS was introduced in autoconf 2.60 and obsoletes

  dnl AC_GNU_SOURCE.

  m4_ifdef([AC_USE_SYSTEM_EXTENSIONS],

    [AC_REQUIRE([AC_USE_SYSTEM_EXTENSIONS])],

    [AC_REQUIRE([AC_GNU_SOURCE])])

  dnl Check for multithreading.

  AC_ARG_ENABLE(threads,

AC_HELP_STRING([--enable-threads={posix|solaris|pth|win32}], [specify multithreading API])

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

    [gl_use_threads=$enableval],

    [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 child

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

       osf*) gl_use_threads=no ;;

       *)    gl_use_threads=yes ;;

     esac

    ])

  if test "$gl_use_threads" = yes || test "$gl_use_threads" = posix; then

    # For using <pthread.h>:

    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_TRY_LINK 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

  fi

])

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

AC_DEFUN([gl_LOCK_BODY],

[

  AC_REQUIRE([gl_LOCK_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.

    AC_MSG_CHECKING([whether imported symbols can be declared weak])

    gl_have_weak=no

    AC_TRY_LINK([extern void xyzzy ();

#pragma weak xyzzy], [xyzzy();], [gl_have_weak=yes])

    AC_MSG_RESULT([$gl_have_weak])

    if test "$gl_use_threads" = yes || test "$gl_use_threads" = posix; then

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

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

      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

        gl_have_pthread=

        # 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.

        AC_TRY_LINK([#include <pthread.h>],

          [pthread_mutex_lock((pthread_mutex_t*)0);

           pthread_mutexattr_init((pthread_mutexattr_t*)0);],

          [gl_have_pthread=yes])

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

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

        if test -n "$gl_have_pthread"; 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,

            [LIBMULTITHREAD=-lpthread LTLIBMULTITHREAD=-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.

             case "$host_os" in

               solaris* | hpux*)

                 AC_DEFINE([PTHREAD_IN_USE_DETECTION_HARD], 1,

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

             esac

            ])

        else

          # Some library is needed. Try libpthread and libc_r.

          AC_CHECK_LIB(pthread, pthread_kill,

            [gl_have_pthread=yes

             LIBTHREAD=-lpthread LTLIBTHREAD=-lpthread

             LIBMULTITHREAD=-lpthread LTLIBMULTITHREAD=-lpthread])

          if test -z "$gl_have_pthread"; then

            # For FreeBSD 4.

            AC_CHECK_LIB(c_r, pthread_kill,

              [gl_have_pthread=yes

               LIBTHREAD=-lc_r LTLIBTHREAD=-lc_r

               LIBMULTITHREAD=-lc_r LTLIBMULTITHREAD=-lc_r])

          fi

        fi

        if test -n "$gl_have_pthread"; then

          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 test $gl_have_weak = yes; then

              AC_DEFINE([USE_POSIX_THREADS_WEAK], 1,

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

              LIBTHREAD=

              LTLIBTHREAD=

            fi

          fi

          # OSF/1 4.0 and MacOS X 10.1 lack the pthread_rwlock_t type and the

          # pthread_rwlock_* functions.

          AC_CHECK_TYPE([pthread_rwlock_t],

            [AC_DEFINE([HAVE_PTHREAD_RWLOCK], 1,

               [Define if the POSIX multithreading library has read/write locks.])],

            [],

            [#include <pthread.h>])

          # glibc defines PTHREAD_MUTEX_RECURSIVE as enum, not as a macro.

          AC_TRY_COMPILE([#include <pthread.h>],

            [#if __FreeBSD__ == 4

error "No, in FreeBSD 4.0 recursive mutexes actually don't work."

#else

int x = (int)PTHREAD_MUTEX_RECURSIVE;

return !x;

#endif],

            [AC_DEFINE([HAVE_PTHREAD_MUTEX_RECURSIVE], 1,

               [Define if the <pthread.h> defines PTHREAD_MUTEX_RECURSIVE.])])

        fi

      fi

    fi

    if test -z "$gl_have_pthread"; then

      if test "$gl_use_threads" = yes || test "$gl_use_threads" = solaris; then

        gl_have_solaristhread=

        gl_save_LIBS="$LIBS"

        LIBS="$LIBS -lthread"

        AC_TRY_LINK([#include <thread.h>

#include <synch.h>],

          [thr_self();],

          [gl_have_solaristhread=yes])

        LIBS="$gl_save_LIBS"

        if test -n "$gl_have_solaristhread"; then

          gl_threads_api=solaris

          LIBTHREAD=-lthread

          LTLIBTHREAD=-lthread

          LIBMULTITHREAD="$LIBTHREAD"

          LTLIBMULTITHREAD="$LTLIBTHREAD"

          AC_DEFINE([USE_SOLARIS_THREADS], 1,

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

          if test $gl_have_weak = yes; then

            AC_DEFINE([USE_SOLARIS_THREADS_WEAK], 1,

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

            LIBTHREAD=

            LTLIBTHREAD=

          fi

        fi

      fi

    fi

    if test "$gl_use_threads" = pth; then

      gl_save_CPPFLAGS="$CPPFLAGS"

      AC_LIB_LINKFLAGS(pth)

      gl_have_pth=

      gl_save_LIBS="$LIBS"

      LIBS="$LIBS -lpth"

      AC_TRY_LINK([#include <pth.h>], [pth_self();], gl_have_pth=yes)

      LIBS="$gl_save_LIBS"

      if test -n "$gl_have_pth"; then

        gl_threads_api=pth

        LIBTHREAD="$LIBPTH"

        LTLIBTHREAD="$LTLIBPTH"

        LIBMULTITHREAD="$LIBTHREAD"

        LTLIBMULTITHREAD="$LTLIBTHREAD"

        AC_DEFINE([USE_PTH_THREADS], 1,

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

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

          if test $gl_have_weak = yes; then

            AC_DEFINE([USE_PTH_THREADS_WEAK], 1,

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

            LIBTHREAD=

            LTLIBTHREAD=

          fi

        fi

      else

        CPPFLAGS="$gl_save_CPPFLAGS"

      fi

    fi

    if test -z "$gl_have_pthread"; then

      if test "$gl_use_threads" = yes || test "$gl_use_threads" = win32; then

        if { case "$host_os" in

               mingw*) true;;

               *) false;;

             esac

           }; then

          gl_threads_api=win32

          AC_DEFINE([USE_WIN32_THREADS], 1,

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

        fi

      fi

    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_LOCK],

[

  AC_REQUIRE([gl_LOCK_EARLY])

  AC_REQUIRE([gl_LOCK_BODY])

  gl_PREREQ_LOCK

])

# Prerequisites of lib/lock.c.

AC_DEFUN([gl_PREREQ_LOCK], [

  AC_REQUIRE([AC_C_INLINE])

])

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 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 MacOS 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                   solaris     -lthread        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 Any of the above  pth         -lpth                  0.0

dnl

dnl Mingw             win32                       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.