diff --git a/gnulib-tests/Makefile.in b/gnulib-tests/Makefile.in

index aa979f4..194cc7d 100644

--- a/gnulib-tests/Makefile.in

+++ b/gnulib-tests/Makefile.in

@@ -3100,7 +3100,7 @@ test_argmatch_LDADD = $(LDADD) @LIBINTL@ $(LIB_MBRTOWC)

 test_bind_LDADD = $(LDADD) @LIBSOCKET@ $(INET_PTON_LIB)

 test_btowc_LDADD = $(LDADD) $(LIB_SETLOCALE)

 test_c_ctype_LDADD = $(LDADD) $(LIB_SETLOCALE)

-test_c_stack_LDADD = $(LDADD) $(LIBCSTACK) @LIBINTL@

+test_c_stack_LDADD = $(LDADD) -lsigsegv @LIBINTL@

 test_c_strcasecmp_LDADD = $(LDADD) $(LIB_SETLOCALE)

 test_c_strncasecmp_LDADD = $(LDADD) $(LIB_SETLOCALE)

 test_connect_LDADD = $(LDADD) @LIBSOCKET@ $(INET_PTON_LIB)

diff --git a/gnulib-tests/gnulib.mk b/gnulib-tests/gnulib.mk

index b1dc6f9..ba0594e 100644

--- a/gnulib-tests/gnulib.mk

+++ b/gnulib-tests/gnulib.mk

@@ -209,7 +209,7 @@ EXTRA_DIST += test-c-ctype.c macros.h

 TESTS += test-c-stack.sh test-c-stack2.sh

 TESTS_ENVIRONMENT += LIBSIGSEGV='@LIBSIGSEGV@'

 check_PROGRAMS += test-c-stack

-test_c_stack_LDADD = $(LDADD) $(LIBCSTACK) @LIBINTL@

+test_c_stack_LDADD = $(LDADD) -lsigsegv @LIBINTL@

 MOSTLYCLEANFILES += t-c-stack.tmp t-c-stack2.tmp

 EXTRA_DIST += test-c-stack.c test-c-stack.sh test-c-stack2.sh macros.h

diff --git a/lib/c-stack.c b/lib/c-stack.c

index 3aea16a..b0e5cb1 100644

--- a/lib/c-stack.c

+++ b/lib/c-stack.c

@@ -1,6 +1,6 @@

 /* Stack overflow handling.

-   Copyright (C) 2002, 2004, 2006, 2008-2020 Free Software Foundation, Inc.

+   Copyright (C) 2002, 2004, 2006, 2008-2021 Free Software Foundation, Inc.

    This program is free software: you can redistribute it and/or modify

    it under the terms of the GNU General Public License as published by

@@ -37,54 +37,28 @@

 #include "c-stack.h"

-#include "gettext.h"

-#define _(msgid) gettext (msgid)

-

 #include <errno.h>

 #include <inttypes.h>

-

 #include <signal.h>

-#if ! HAVE_STACK_T && ! defined stack_t

-typedef struct sigaltstack stack_t;

-#endif

-

-#include <stdbool.h>

 #include <stddef.h>

 #include <stdlib.h>

 #include <string.h>

-

-/* Pre-2008 POSIX declared ucontext_t in ucontext.h instead of signal.h.  */

-#if HAVE_UCONTEXT_H

-# include <ucontext.h>

-#endif

-

 #include <unistd.h>

 #if DEBUG

 # include <stdio.h>

 #endif

-/* Use libsigsegv only if needed; kernels like Solaris can detect

-   stack overflow without the overhead of an external library.  */

-#define USE_LIBSIGSEGV (!HAVE_XSI_STACK_OVERFLOW_HEURISTIC && HAVE_LIBSIGSEGV)

-

-#if USE_LIBSIGSEGV

-# include <sigsegv.h>

-#endif

+#include <sigsegv.h>

 #include "exitfail.h"

-#include "ignore-value.h"

-#include "intprops.h"

 #include "getprogname.h"

+#include "ignore-value.h"

-#if defined SA_ONSTACK && defined SA_SIGINFO

-# define SIGINFO_WORKS 1

-#else

-# define SIGINFO_WORKS 0

-# ifndef SA_ONSTACK

-#  define SA_ONSTACK 0

-# endif

-#endif

+#include "gettext.h"

+#define _(msgid) gettext (msgid)

+

+#if HAVE_STACK_OVERFLOW_RECOVERY

 /* Storage for the alternate signal stack.

    64 KiB is not too large for Gnulib-using apps, and is large enough

@@ -106,9 +80,6 @@ static _GL_ASYNC_SAFE void (* volatile segv_action) (int);

 static char const * volatile program_error_message;

 static char const * volatile stack_overflow_message;

-#if (USE_LIBSIGSEGV                                           \

-     || (HAVE_DECL_SIGALTSTACK && HAVE_STACK_OVERFLOW_HANDLING))

-

 /* Output an error message, then exit with status EXIT_FAILURE if it

    appears to have been a stack overflow, or with a core dump

    otherwise.  This function is async-signal-safe.  */

@@ -118,12 +89,6 @@ static char const * volatile progname;

 static _GL_ASYNC_SAFE _Noreturn void

 die (int signo)

 {

-# if !SIGINFO_WORKS && !USE_LIBSIGSEGV

-  /* We can't easily determine whether it is a stack overflow; so

-     assume that the rest of our program is perfect (!) and that

-     this segmentation violation is a stack overflow.  */

-  signo = 0;

-# endif

   segv_action (signo);

   char const *message = signo ? program_error_message : stack_overflow_message;

@@ -164,12 +129,8 @@ null_action (int signo _GL_UNUSED)

 {

 }

-#endif /* SIGALTSTACK || LIBSIGSEGV */

-

-#if USE_LIBSIGSEGV

-

 /* Pacify GCC 9.3.1, which otherwise would complain about segv_handler.  */

-# if __GNUC_PREREQ (4, 6)

+# if 4 < __GNUC__ + (6 <= __GNUC_MINOR__)

 #  pragma GCC diagnostic ignored "-Wsuggest-attribute=pure"

 # endif

@@ -240,132 +201,7 @@ c_stack_action (_GL_ASYNC_SAFE void (*action) (int))

   return 0;

 }

-#elif HAVE_DECL_SIGALTSTACK && HAVE_STACK_OVERFLOW_HANDLING

-

-# if SIGINFO_WORKS

-

-static size_t volatile page_size;

-

-/* Handle a segmentation violation and exit.  This function is

-   async-signal-safe.  */

-

-static _GL_ASYNC_SAFE _Noreturn void

-segv_handler (int signo, siginfo_t *info, void *context _GL_UNUSED)

-{

-  /* Clear SIGNO if it seems to have been a stack overflow.  */

-

-  /* If si_code is nonpositive, something like raise (SIGSEGV) occurred

-     so it cannot be a stack overflow.  */

-  bool cannot_be_stack_overflow = info->si_code <= 0;

-

-  /* An unaligned address cannot be a stack overflow.  */

-#  if FAULT_YIELDS_SIGBUS

-  cannot_be_stack_overflow |= signo == SIGBUS && info->si_code == BUS_ADRALN;

-#  endif

-

-  /* If we can't easily determine that it is not a stack overflow,

-     assume that the rest of our program is perfect (!) and that

-     this segmentation violation is a stack overflow.

-

-     Note that although both Linux and Solaris provide

-     sigaltstack, SA_ONSTACK, and SA_SIGINFO, currently only

-     Solaris satisfies the XSI heuristic.  This is because

-     Solaris populates uc_stack with the details of the

-     interrupted stack, while Linux populates it with the details

-     of the current stack.  */

-  if (!cannot_be_stack_overflow)

-    {

-      /* If the faulting address is within the stack, or within one

-         page of the stack, assume that it is a stack overflow.  */

-      uintptr_t faulting_address = (uintptr_t) info->si_addr;

-

-      /* On all platforms we know of, the first page is not in the

-         stack to catch null pointer dereferening.  However, all other

-         pages might be in the stack.  */

-      void *stack_base = (void *) (uintptr_t) page_size;

-      uintptr_t stack_size = 0; stack_size -= page_size;

-#  if HAVE_XSI_STACK_OVERFLOW_HEURISTIC

-      /* Tighten the stack bounds via the XSI heuristic.  */

-      ucontext_t const *user_context = context;

-      stack_base = user_context->uc_stack.ss_sp;

-      stack_size = user_context->uc_stack.ss_size;

-#  endif

-      uintptr_t base = (uintptr_t) stack_base,

-        lo = (INT_SUBTRACT_WRAPV (base, page_size, &lo) || lo < page_size

-              ? page_size : lo),

-        hi = ((INT_ADD_WRAPV (base, stack_size, &hi)

-               || INT_ADD_WRAPV (hi, page_size - 1, &hi))

-              ? UINTPTR_MAX : hi);

-      if (lo <= faulting_address && faulting_address <= hi)

-        signo = 0;

-

-#   if DEBUG

-      {

-        char buf[1024];

-        ignore_value (write (STDERR_FILENO, buf,

-                             sprintf (buf,

-                                      ("segv_handler code=%d fault=%p base=%p"

-                                       " size=0x%zx page=0x%zx signo=%d\n"),

-                                      info->si_code, info->si_addr, stack_base,

-                                      stack_size, page_size, signo)));

-      }

-#  endif

-    }

-

-  die (signo);

-}

-# endif

-

-int

-c_stack_action (_GL_ASYNC_SAFE void (*action) (int))

-{

-  stack_t st;

-  st.ss_flags = 0;

-  st.ss_sp = alternate_signal_stack;

-  st.ss_size = sizeof alternate_signal_stack;

-# if SIGALTSTACK_SS_REVERSED

-  /* Irix mistakenly treats ss_sp as the upper bound, rather than

-     lower bound, of the alternate stack.  */

-  st.ss_size -= sizeof (void *);

-  char *ss_sp = st.ss_sp;

-  st.ss_sp = ss_sp + st.ss_size;

-# endif

-  int r = sigaltstack (&st, NULL);

-  if (r != 0)

-    return r;

-

-  segv_action = action ? action : null_action;

-  program_error_message = _("program error");

-  stack_overflow_message = _("stack overflow");

-  progname = getprogname ();

-

-# if SIGINFO_WORKS

-  page_size = sysconf (_SC_PAGESIZE);

-# endif

-

-  struct sigaction act;

-  sigemptyset (&act.sa_mask);

-

-# if SIGINFO_WORKS

-  /* POSIX 1003.1-2001 says SA_RESETHAND implies SA_NODEFER, but

-     this is not true on Solaris 8 at least.  It doesn't hurt to use

-     SA_NODEFER here, so leave it in.  */

-  act.sa_flags = SA_NODEFER | SA_ONSTACK | SA_RESETHAND | SA_SIGINFO;

-  act.sa_sigaction = segv_handler;

-# else

-  act.sa_flags = SA_NODEFER | SA_ONSTACK | SA_RESETHAND;

-  act.sa_handler = die;

-# endif

-

-# if FAULT_YIELDS_SIGBUS

-  if (sigaction (SIGBUS, &act, NULL) < 0)

-    return -1;

-# endif

-  return sigaction (SIGSEGV, &act, NULL);

-}

-

-#else /* ! (USE_LIBSIGSEGV

-            || (HAVE_DECL_SIGALTSTACK && HAVE_STACK_OVERFLOW_HANDLING)) */

+#else /* !HAVE_STACK_OVERFLOW_RECOVERY */

 int

 c_stack_action (_GL_ASYNC_SAFE void (*action) (int)  _GL_UNUSED)

diff --git a/m4/c-stack.m4 b/m4/c-stack.m4

index 85107f4..7cccb06 100644

--- a/m4/c-stack.m4

+++ b/m4/c-stack.m4

@@ -1,376 +1,21 @@

 # Check prerequisites for compiling lib/c-stack.c.

-# Copyright (C) 2002-2004, 2008-2020 Free Software Foundation, Inc.

+# Copyright (C) 2002-2004, 2008-2021 Free Software Foundation, Inc.

 # This file is free software; the Free Software Foundation

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

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

 # Written by Paul Eggert.

-# serial 20

-

-AC_DEFUN([AC_SYS_XSI_STACK_OVERFLOW_HEURISTIC],

-  [

-   AC_REQUIRE([AC_CANONICAL_HOST])

-   AC_CHECK_FUNCS_ONCE([setrlimit])

-   AC_CHECK_HEADERS_ONCE([ucontext.h])

-

-   dnl List of signals that are sent when an invalid virtual memory address

-   dnl is accessed, or when the stack overflows.

-   dnl Either { SIGSEGV } or { SIGSEGV, SIGBUS }.

-   case "$host_os" in

-     sunos4* | freebsd* | dragonfly* | openbsd* | mirbsd* | netbsd* | kfreebsd* | knetbsd*) # BSD systems

-       FAULT_YIELDS_SIGBUS=1 ;;

-     hpux*) # HP-UX

-       FAULT_YIELDS_SIGBUS=1 ;;

-     macos* | darwin*) # Mac OS X

-       FAULT_YIELDS_SIGBUS=1 ;;

-     gnu*) # Hurd

-       FAULT_YIELDS_SIGBUS=1 ;;

-     *)

-       FAULT_YIELDS_SIGBUS=0 ;;

-   esac

-   AC_DEFINE_UNQUOTED([FAULT_YIELDS_SIGBUS], [$FAULT_YIELDS_SIGBUS],

-     [Define to 1 if an invalid memory address access may yield a SIGBUS.])

-

-   AC_CACHE_CHECK([for working C stack overflow detection],

-     [gl_cv_sys_stack_overflow_works],

-     [AC_RUN_IFELSE([AC_LANG_SOURCE(

-           [[

-            #include <unistd.h>

-            #include <signal.h>

-            #if HAVE_SETRLIMIT

-            # include <sys/types.h>

-            # include <sys/time.h>

-            # include <sys/resource.h>

-            #endif

-            #ifndef SIGSTKSZ

-            # define SIGSTKSZ 16384

-            #endif

-

-            static union

-            {

-              char buffer[2 * SIGSTKSZ];

-              long double ld;

-              long u;

-              void *p;

-            } alternate_signal_stack;

-

-            static void

-            segv_handler (int signo)

-            {

-              _exit (0);

-            }

-

-            static int

-            c_stack_action ()

-            {

-              stack_t st;

-              struct sigaction act;

-              int r;

-

-              st.ss_flags = 0;

-              /* Use the midpoint to avoid Irix sigaltstack bug.  */

-              st.ss_sp = alternate_signal_stack.buffer + SIGSTKSZ;

-              st.ss_size = SIGSTKSZ;

-              r = sigaltstack (&st, 0);

-              if (r != 0)

-                return 1;

-

-              sigemptyset (&act.sa_mask);

-              act.sa_flags = SA_NODEFER | SA_ONSTACK | SA_RESETHAND;

-              act.sa_handler = segv_handler;

-              #if FAULT_YIELDS_SIGBUS

-              if (sigaction (SIGBUS, &act, 0) < 0)

-                return 2;

-              #endif

-              if (sigaction (SIGSEGV, &act, 0) < 0)

-                return 3;

-              return 0;

-            }

-            static volatile int *

-            recurse_1 (volatile int n, volatile int *p)

-            {

-              if (n >= 0)

-                *recurse_1 (n + 1, p) += n;

-              return p;

-            }

-            static int

-            recurse (volatile int n)

-            {

-              int sum = 0;

-              return *recurse_1 (n, &sum);

-            }

-            int

-            main ()

-            {

-              int result;

-              #if HAVE_SETRLIMIT && defined RLIMIT_STACK

-              /* Before starting the endless recursion, try to be friendly

-                 to the user's machine.  On some Linux 2.2.x systems, there

-                 is no stack limit for user processes at all.  We don't want

-                 to kill such systems.  */

-              struct rlimit rl;

-              rl.rlim_cur = rl.rlim_max = 0x100000; /* 1 MB */

-              setrlimit (RLIMIT_STACK, &rl);

-              #endif

-

-              result = c_stack_action ();

-              if (result != 0)

-                return result;

-              return recurse (0);

-            }

-           ]])],

-        [gl_cv_sys_stack_overflow_works=yes],

-        [gl_cv_sys_stack_overflow_works=no],

-        [case "$host_os" in

-                   # Guess no on native Windows.

-           mingw*) gl_cv_sys_stack_overflow_works="guessing no" ;;

-           *)      gl_cv_sys_stack_overflow_works=cross-compiling ;;

-         esac

-        ])

-     ])

-

-  if test "$gl_cv_sys_stack_overflow_works" = yes; then

-   AC_DEFINE([HAVE_STACK_OVERFLOW_HANDLING], [1],

-     [Define to 1 if extending the stack slightly past the limit causes

-      a SIGSEGV which can be handled on an alternate stack established

-      with sigaltstack.])

-

-    dnl The ss_sp field of a stack_t is, according to POSIX, the lowest address

-    dnl of the memory block designated as an alternate stack. But IRIX 5.3

-    dnl interprets it as the highest address!

-    AC_CACHE_CHECK([for correct stack_t interpretation],

-      [gl_cv_sigaltstack_low_base], [

-      AC_RUN_IFELSE([

-        AC_LANG_SOURCE([[

-#include <stdlib.h>

-#include <signal.h>

-#if HAVE_SYS_SIGNAL_H

-# include <sys/signal.h>

-#endif

-#ifndef SIGSTKSZ

-# define SIGSTKSZ 16384

-#endif

-volatile char *stack_lower_bound;

-volatile char *stack_upper_bound;

-static void check_stack_location (volatile char *addr)

-{

-  if (addr >= stack_lower_bound && addr <= stack_upper_bound)

-    exit (0);

-  else

-    exit (1);

-}

-static void stackoverflow_handler (int sig)

-{

-  char dummy;

-  check_stack_location (&dummy);

-}

-int main ()

-{

-  char mystack[2 * SIGSTKSZ];

-  stack_t altstack;

-  struct sigaction action;

-  /* Install the alternate stack.  */

-  altstack.ss_sp = mystack + SIGSTKSZ;

-  altstack.ss_size = SIGSTKSZ;

-  stack_lower_bound = (char *) altstack.ss_sp;

-  stack_upper_bound = (char *) altstack.ss_sp + altstack.ss_size - 1;

-  altstack.ss_flags = 0; /* no SS_DISABLE */

-  if (sigaltstack (&altstack, NULL) < 0)

-    exit (2);

-  /* Install the SIGSEGV handler.  */

-  sigemptyset (&action.sa_mask);

-  action.sa_handler = &stackoverflow_handler;

-  action.sa_flags = SA_ONSTACK;

-  if (sigaction (SIGSEGV, &action, (struct sigaction *) NULL) < 0)

-    exit(3);

-  /* Provoke a SIGSEGV.  */

-  raise (SIGSEGV);

-  exit (4);

-}]])],

-      [gl_cv_sigaltstack_low_base=yes],

-      [gl_cv_sigaltstack_low_base=no],

-      [gl_cv_sigaltstack_low_base=cross-compiling])])

-   if test "$gl_cv_sigaltstack_low_base" = no; then

-      AC_DEFINE([SIGALTSTACK_SS_REVERSED], [1],

-        [Define if sigaltstack() interprets the stack_t.ss_sp field

-         incorrectly, as the highest address of the alternate stack range

-         rather than as the lowest address.])

-    fi

-

-   AC_CACHE_CHECK([for precise C stack overflow detection],

-     [gl_cv_sys_xsi_stack_overflow_heuristic],

-     [dnl On Linux/sparc64 (both in 32-bit and 64-bit mode), it would be wrong

-      dnl to set HAVE_XSI_STACK_OVERFLOW_HEURISTIC to 1, because the third

-      dnl argument passed to the segv_handler is a 'struct sigcontext *', not

-      dnl an 'ucontext_t *'.  It would lead to a failure of test-c-stack2.sh.

-      case "${host_os}--${host_cpu}" in

-        linux*--sparc*)

-          gl_cv_sys_xsi_stack_overflow_heuristic=no

-          ;;

-        *)

-          AC_RUN_IFELSE(

-            [AC_LANG_SOURCE(

-               [[

-                #include <unistd.h>

-                #include <signal.h>

-                #if HAVE_UCONTEXT_H

-                # include <ucontext.h>

-                #endif

-                #if HAVE_SETRLIMIT

-                # include <sys/types.h>

-                # include <sys/time.h>

-                # include <sys/resource.h>

-                #endif

-                #ifndef SIGSTKSZ

-                # define SIGSTKSZ 16384

-                #endif

-

-                static union

-                {

-                  char buffer[2 * SIGSTKSZ];

-                  long double ld;

-                  long u;

-                  void *p;

-                } alternate_signal_stack;

-

-                #if STACK_DIRECTION

-                # define find_stack_direction(ptr) STACK_DIRECTION

-                #else

-                static int

-                find_stack_direction (char const *addr)

-                {

-                  char dummy;

-                  return (! addr ? find_stack_direction (&dummy)

-                          : addr < &dummy ? 1 : -1);

-                }

-                #endif

-

-                static void

-                segv_handler (int signo, siginfo_t *info, void *context)

-                {

-                  if (0 < info->si_code)

-                    {

-                      /* For XSI heuristics to work, we need uc_stack to

-                         describe the interrupted stack (as on Solaris), and

-                         not the currently executing stack (as on Linux).  */

-                      ucontext_t const *user_context = context;

-                      char const *stack_min = user_context->uc_stack.ss_sp;

-                      size_t stack_size = user_context->uc_stack.ss_size;

-                      char const *faulting_address = info->si_addr;

-                      size_t s = faulting_address - stack_min;

-                      size_t page_size = sysconf (_SC_PAGESIZE);

-                      if (find_stack_direction (0) < 0)

-                        s += page_size;

-                      if (s < stack_size + page_size)

-                        _exit (0);

-                      _exit (4);

-                    }

-                  _exit (5);

-                }

-

-                static int

-                c_stack_action ()

-                {

-                  stack_t st;

-                  struct sigaction act;

-                  int r;

-

-                  st.ss_flags = 0;

-                  /* Use the midpoint to avoid Irix sigaltstack bug.  */

-                  st.ss_sp = alternate_signal_stack.buffer + SIGSTKSZ;

-                  st.ss_size = SIGSTKSZ;

-                  r = sigaltstack (&st, 0);

-                  if (r != 0)

-                    return 1;

-

-                  sigemptyset (&act.sa_mask);

-                  act.sa_flags = SA_NODEFER | SA_ONSTACK | SA_RESETHAND | SA_SIGINFO;

-                  act.sa_sigaction = segv_handler;

-                  #if FAULT_YIELDS_SIGBUS

-                  if (sigaction (SIGBUS, &act, 0) < 0)

-                    return 2;

-                  #endif

-                  if (sigaction (SIGSEGV, &act, 0) < 0)

-                    return 3;

-                  return 0;

-                }

-                static volatile int *

-                recurse_1 (volatile int n, volatile int *p)

-                {

-                  if (n >= 0)

-                    *recurse_1 (n + 1, p) += n;

-                  return p;

-                }

-                static int

-                recurse (volatile int n)

-                {

-                  int sum = 0;

-                  return *recurse_1 (n, &sum);

-                }

-                int

-                main ()

-                {

-                  int result;

-                  #if HAVE_SETRLIMIT && defined RLIMIT_STACK

-                  /* Before starting the endless recursion, try to be friendly

-                     to the user's machine.  On some Linux 2.2.x systems, there

-                     is no stack limit for user processes at all.  We don't want

-                     to kill such systems.  */

-                  struct rlimit rl;

-                  rl.rlim_cur = rl.rlim_max = 0x100000; /* 1 MB */

-                  setrlimit (RLIMIT_STACK, &rl);

-                  #endif

-

-                  result = c_stack_action ();

-                  if (result != 0)

-                    return result;

-                  return recurse (0);

-                }

-               ]])],

-            [gl_cv_sys_xsi_stack_overflow_heuristic=yes],

-            [gl_cv_sys_xsi_stack_overflow_heuristic=no],

-            [gl_cv_sys_xsi_stack_overflow_heuristic=cross-compiling])

-          ;;

-      esac

-     ])

-

-   if test "$gl_cv_sys_xsi_stack_overflow_heuristic" = yes; then

-     AC_DEFINE([HAVE_XSI_STACK_OVERFLOW_HEURISTIC], [1],

-       [Define to 1 if extending the stack slightly past the limit causes

-        a SIGSEGV, and an alternate stack can be established with sigaltstack,

-        and the signal handler is passed a context that specifies the

-        run time stack.  This behavior is defined by POSIX 1003.1-2001

-        with the X/Open System Interface (XSI) option

-        and is a standardized way to implement a SEGV-based stack

-        overflow detection heuristic.])

-   fi

-  fi])

-

-

-AC_DEFUN([gl_PREREQ_C_STACK],

-  [AC_REQUIRE([AC_SYS_XSI_STACK_OVERFLOW_HEURISTIC])

-

-   AC_CHECK_FUNCS_ONCE([sigaltstack])

-   AC_CHECK_DECLS([sigaltstack], , , [[#include <signal.h>]])

-

-   AC_CHECK_HEADERS_ONCE([ucontext.h])

-

-   AC_CHECK_TYPES([stack_t], , , [[#include <signal.h>]])

-

-   dnl c-stack does not need -lsigsegv if the system has XSI heuristics.

-   if test "$gl_cv_sys_xsi_stack_overflow_heuristic" != yes; then

-     gl_LIBSIGSEGV

-     if test "$gl_cv_lib_sigsegv" = yes; then

-       AC_SUBST([LIBCSTACK], [$LIBSIGSEGV])

-       AC_SUBST([LTLIBCSTACK], [$LTLIBSIGSEGV])

-     fi

-   fi

-])

+# serial 23

 AC_DEFUN([gl_C_STACK],

 [

-  dnl Prerequisites of lib/c-stack.c.

-  gl_PREREQ_C_STACK

+  dnl 'c-stack' needs -lsigsegv if and only if the 'sigsegv' module needs it.

+  if test "$with_libsigsegv" = yes; then

+    if test "$gl_cv_lib_sigsegv" = yes; then

+      AC_SUBST([LIBCSTACK], [$LIBSIGSEGV])

+      AC_SUBST([LTLIBCSTACK], [$LTLIBSIGSEGV])

+    fi

+  fi

 ])

diff --git a/src/Makefile.am b/src/Makefile.am

index 1aebcf7..055ee17 100644

--- a/src/Makefile.am

+++ b/src/Makefile.am

@@ -45,7 +45,7 @@ LDADD = \

   ../lib/libgreputils.a $(LIBINTL) ../lib/libgreputils.a $(LIBICONV) \

   $(LIBTHREAD)

-grep_LDADD = $(LDADD) $(PCRE_LIBS) $(LIBCSTACK)

+grep_LDADD = $(LDADD) $(PCRE_LIBS) -lsigsegv

 localedir = $(datadir)/locale

 AM_CPPFLAGS = -I$(top_builddir)/lib -I$(top_srcdir)/lib

diff --git a/src/Makefile.in b/src/Makefile.in

index 20c43b5..a276db8 100644

--- a/src/Makefile.in

+++ b/src/Makefile.in

@@ -1541,7 +1541,7 @@ LDADD = \

   ../lib/libgreputils.a $(LIBINTL) ../lib/libgreputils.a $(LIBICONV) \

   $(LIBTHREAD)

-grep_LDADD = $(LDADD) $(PCRE_LIBS) $(LIBCSTACK)

+grep_LDADD = $(LDADD) $(PCRE_LIBS) -lsigsegv

 AM_CPPFLAGS = -I$(top_builddir)/lib -I$(top_srcdir)/lib

 EXTRA_DIST = egrep.sh

 CLEANFILES = egrep fgrep *-t