# pthread_sigmask.m4 serial 18

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

AC_DEFUN([gl_FUNC_PTHREAD_SIGMASK],

[

  AC_REQUIRE([gl_SIGNAL_H_DEFAULTS])

  AC_CHECK_FUNCS_ONCE([pthread_sigmask])

  dnl On MinGW pthread_sigmask is just a macro which always returns 0.

  dnl It does not exist as a real function, which is required by POSIX.

  AC_CACHE_CHECK([whether pthread_sigmask is a macro],

    [gl_cv_func_pthread_sigmask_macro],

    [AC_EGREP_CPP([headers_define_pthread_sigmask], [

#include <pthread.h>

#include <signal.h>

#ifdef pthread_sigmask

 headers_define_pthread_sigmask

#endif],

       [gl_cv_func_pthread_sigmask_macro=yes],

       [gl_cv_func_pthread_sigmask_macro=no])

    ])

  LIB_PTHREAD_SIGMASK=

  if test $gl_cv_func_pthread_sigmask_macro = yes; then

    dnl pthread_sigmask is a dummy macro.

    HAVE_PTHREAD_SIGMASK=0

    dnl Make sure to '#undef pthread_sigmask' before defining it.

    REPLACE_PTHREAD_SIGMASK=1

  else

    dnl Test whether the gnulib module 'threadlib' is in use.

    dnl Some packages like Emacs use --avoid=threadlib.

    dnl Write the symbol in such a way that it does not cause 'aclocal' to pick

    dnl the threadlib.m4 file that is installed in $PREFIX/share/aclocal/.

    m4_ifdef([gl_][THREADLIB], [

      AC_REQUIRE([gl_][THREADLIB])

      if test "$gl_threads_api" = posix; then

        if test $ac_cv_func_pthread_sigmask = yes; then

          dnl pthread_sigmask is available without -lpthread.

          :

        else

          if test -n "$LIBMULTITHREAD"; then

            AC_CACHE_CHECK([for pthread_sigmask in $LIBMULTITHREAD],

              [gl_cv_func_pthread_sigmask_in_LIBMULTITHREAD],

              [gl_save_LIBS="$LIBS"

               LIBS="$LIBS $LIBMULTITHREAD"

               AC_LINK_IFELSE(

                 [AC_LANG_PROGRAM(

                    [[#include <pthread.h>

                      #include <signal.h>

                    ]],

                    [[return pthread_sigmask (0, (sigset_t *) 0, (sigset_t *) 0);]])

                 ],

                 [gl_cv_func_pthread_sigmask_in_LIBMULTITHREAD=yes],

                 [gl_cv_func_pthread_sigmask_in_LIBMULTITHREAD=no])

               LIBS="$gl_save_LIBS"

              ])

            if test $gl_cv_func_pthread_sigmask_in_LIBMULTITHREAD = yes; then

              dnl pthread_sigmask is available with -pthread or -lpthread.

              LIB_PTHREAD_SIGMASK="$LIBMULTITHREAD"

            else

              dnl pthread_sigmask is not available at all.

              HAVE_PTHREAD_SIGMASK=0

            fi

          else

            dnl pthread_sigmask is not available at all.

            HAVE_PTHREAD_SIGMASK=0

          fi

        fi

      else

        dnl pthread_sigmask may exist but does not interoperate with the chosen

        dnl multithreading facility.

        if test $ac_cv_func_pthread_sigmask = yes; then

          REPLACE_PTHREAD_SIGMASK=1

        else

          HAVE_PTHREAD_SIGMASK=0

        fi

      fi

    ], [

      dnl The module 'threadlib' is not in use, due to --avoid=threadlib being

      dnl specified.

      dnl The package either has prepared CPPFLAGS and LIBS for use of

      dnl POSIX:2008 threads, or wants to build single-threaded programs.

      if test $ac_cv_func_pthread_sigmask = yes; then

        dnl pthread_sigmask exists and does not require extra libraries.

        dnl Assume that it is declared.

        :

      else

        dnl pthread_sigmask either does not exist or needs extra libraries.

        HAVE_PTHREAD_SIGMASK=0

        dnl Define the symbol rpl_pthread_sigmask, not pthread_sigmask,

        dnl so as to not accidentally override the system's pthread_sigmask

        dnl symbol from libpthread. This is necessary on IRIX 6.5.

        REPLACE_PTHREAD_SIGMASK=1

      fi

    ])

  fi

  AC_SUBST([LIB_PTHREAD_SIGMASK])

  dnl We don't need a variable LTLIB_PTHREAD_SIGMASK, because when

  dnl "$gl_threads_api" = posix, $LTLIBMULTITHREAD and $LIBMULTITHREAD are the

  dnl same.

  dnl Now test for some bugs in the system function.

  if test $HAVE_PTHREAD_SIGMASK = 1; then

    AC_REQUIRE([AC_PROG_CC])

    AC_REQUIRE([AC_CANONICAL_HOST]) dnl for cross-compiles

    dnl On FreeBSD 6.4, HP-UX 11.31, Solaris 9, in programs that are not linked

    dnl with -lpthread, the pthread_sigmask() function always returns 0 and has

    dnl no effect.

    if test -z "$LIB_PTHREAD_SIGMASK"; then

      case " $LIBS " in

        *' -pthread '*) ;;

        *' -lpthread '*) ;;

        *)

          AC_CACHE_CHECK([whether pthread_sigmask works without -lpthread],

            [gl_cv_func_pthread_sigmask_in_libc_works],

            [

              AC_RUN_IFELSE(

                [AC_LANG_SOURCE([[

                   #include <pthread.h>

                   #include <signal.h>

                   #include <stddef.h>

                   int main ()

                   {

                     sigset_t set;

                     sigemptyset (&set);

                     return pthread_sigmask (1729, &set, NULL) != 0;

                   }]])],

                [gl_cv_func_pthread_sigmask_in_libc_works=no],

                [gl_cv_func_pthread_sigmask_in_libc_works=yes],

                [

                 changequote(,)dnl

                 case "$host_os" in

                   freebsd* | hpux* | solaris | solaris2.[2-9]*)

                     gl_cv_func_pthread_sigmask_in_libc_works="guessing no";;

                   *)

                     gl_cv_func_pthread_sigmask_in_libc_works="guessing yes";;

                 esac

                 changequote([,])dnl

                ])

            ])

          case "$gl_cv_func_pthread_sigmask_in_libc_works" in

            *no)

              REPLACE_PTHREAD_SIGMASK=1

              AC_DEFINE([PTHREAD_SIGMASK_INEFFECTIVE], [1],

                [Define to 1 if pthread_sigmask may return 0 and have no effect.])

              ;;

          esac;;

      esac

    fi

    dnl On Cygwin 1.7.5, the pthread_sigmask() has a wrong return value

    dnl convention: Upon failure, it returns -1 and sets errno.

    AC_CACHE_CHECK([whether pthread_sigmask returns error numbers],

      [gl_cv_func_pthread_sigmask_return_works],

      [

        gl_save_LIBS="$LIBS"

        LIBS="$LIBS $LIB_PTHREAD_SIGMASK"

        AC_RUN_IFELSE(

          [AC_LANG_SOURCE([[

#include <pthread.h>

#include <signal.h>

#include <stddef.h>

int main ()

{

  sigset_t set;

  sigemptyset (&set);

  if (pthread_sigmask (1729, &set, NULL) == -1)

    return 1;

  return 0;

}]])],

          [gl_cv_func_pthread_sigmask_return_works=yes],

          [gl_cv_func_pthread_sigmask_return_works=no],

          [case "$host_os" in

             cygwin*)

               gl_cv_func_pthread_sigmask_return_works="guessing no";;

             *)

               gl_cv_func_pthread_sigmask_return_works="guessing yes";;

           esac

          ])

        LIBS="$gl_save_LIBS"

      ])

    case "$gl_cv_func_pthread_sigmask_return_works" in

      *no)

        REPLACE_PTHREAD_SIGMASK=1

        AC_DEFINE([PTHREAD_SIGMASK_FAILS_WITH_ERRNO], [1],

          [Define to 1 if pthread_sigmask(), when it fails, returns -1 and sets errno.])

        ;;

    esac

    dnl On IRIX 6.5, in a single-threaded program, pending signals are not

    dnl immediately delivered when they are unblocked through pthread_sigmask,

    dnl only a little while later.

    AC_CACHE_CHECK([whether pthread_sigmask unblocks signals correctly],

      [gl_cv_func_pthread_sigmask_unblock_works],

      [

        case "$host_os" in

          irix*)

            gl_cv_func_pthread_sigmask_unblock_works="guessing no";;

          *)

            gl_cv_func_pthread_sigmask_unblock_works="guessing yes";;

        esac

        m4_ifdef([gl_][THREADLIB],

          [dnl Link against $LIBMULTITHREAD, not only $LIB_PTHREAD_SIGMASK.

           dnl Otherwise we get a false positive on those platforms where

           dnl $gl_cv_func_pthread_sigmask_in_libc_works is "no".

           gl_save_LIBS=$LIBS

           LIBS="$LIBS $LIBMULTITHREAD"])

        AC_RUN_IFELSE(

          [AC_LANG_SOURCE([[

#include <pthread.h>

#include <signal.h>

#include <stdio.h>

#include <stdlib.h>

#include <unistd.h>

static volatile int sigint_occurred;

static void

sigint_handler (int sig)

{

  sigint_occurred++;

}

int main ()

{

  sigset_t set;

  int pid = getpid ();

  char command[80];

  signal (SIGINT, sigint_handler);

  sigemptyset (&set);

  sigaddset (&set, SIGINT);

  if (!(pthread_sigmask (SIG_BLOCK, &set, NULL) == 0))

    return 1;

  sprintf (command, "sh -c 'sleep 1; kill -%d %d' &", SIGINT, pid);

  if (!(system (command) == 0))

    return 2;

  sleep (2);

  if (!(sigint_occurred == 0))

    return 3;

  if (!(pthread_sigmask (SIG_UNBLOCK, &set, NULL) == 0))

    return 4;

  if (!(sigint_occurred == 1)) /* This fails on IRIX.  */

    return 5;

  return 0;

}]])],

          [:],

          [gl_cv_func_pthread_sigmask_unblock_works=no],

          [:])

        m4_ifdef([gl_][THREADLIB], [LIBS=$gl_save_LIBS])

      ])

    case "$gl_cv_func_pthread_sigmask_unblock_works" in

      *no)

        REPLACE_PTHREAD_SIGMASK=1

        AC_DEFINE([PTHREAD_SIGMASK_UNBLOCK_BUG], [1],

          [Define to 1 if pthread_sigmask() unblocks signals incorrectly.])

        ;;

    esac

  fi

])

# Prerequisite of lib/pthread_sigmask.c.

AC_DEFUN([gl_PREREQ_PTHREAD_SIGMASK],

[

  if test $HAVE_PTHREAD_SIGMASK = 1; then

    AC_DEFINE([HAVE_PTHREAD_SIGMASK], [1],

      [Define to 1 if the pthread_sigmask function can be used (despite bugs).])

  fi

])