diff --git a/.gitignore b/.gitignore
index 7da629a..cb598ef 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1 +1 @@
-grep-*.tar.xz
+/grep-*.tar.xz
diff --git a/grep-3.6-gnulib-c-stack-fix.patch b/grep-3.6-gnulib-c-stack-fix.patch
new file mode 100644
index 0000000..e494b88
--- /dev/null
+++ b/grep-3.6-gnulib-c-stack-fix.patch
@@ -0,0 +1,686 @@
+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
diff --git a/grep.spec b/grep.spec
index 7422568..6214008 100644
--- a/grep.spec
+++ b/grep.spec
@@ -1,7 +1,7 @@
Summary: Pattern matching utilities
Name: grep
Version: 3.6
-Release: 2%{?dist}
+Release: 3%{?dist}
License: GPLv3+
URL: https://www.gnu.org/software/grep/
@@ -14,12 +14,20 @@ Source4: grepconf.sh
Patch0: grep-3.5-man-fix-gs.patch
# upstream ticket 39445
Patch1: grep-3.5-help-align.patch
+# backported from upstream
+# it can be dropped for grep release newer than 3.6
+Patch2: grep-3.6-gnulib-c-stack-fix.patch
BuildRequires: gcc
-BuildRequires: pcre-devel >= 3.9-10, texinfo, gettext
-BuildRequires: autoconf automake glibc-all-langpacks
+BuildRequires: pcre-devel >= 3.9-10
+BuildRequires: texinfo
+BuildRequires: gettext
+BuildRequires: autoconf
+BuildRequires: automake
+Buildrequires: glibc-all-langpacks
BuildRequires: perl-FileHandle
BuildRequires: make
+BuildRequires: libsigsegv-devel
# https://fedorahosted.org/fpc/ticket/174
Provides: bundled(gnulib)
# for backward compatibility (rhbz#1540485)
@@ -35,9 +43,7 @@ prints the matching lines. GNU's grep utilities include grep, egrep and fgrep.
GNU grep is needed by many scripts, so it shall be installed on every system.
%prep
-%setup -q
-%patch0 -p1 -b .man-fix-gs
-%patch1 -p1 -b .help-align
+%autosetup -p1
%build
%global BUILD_FLAGS $RPM_OPT_FLAGS
@@ -79,6 +85,9 @@ make check
%{_libexecdir}/grepconf.sh
%changelog
+* Wed Jun 23 2021 Jaroslav Škarvada <jskarvad@redhat.com> - 3.6-3
+- Fixed stack overflow detection
+
* Tue Jan 26 2021 Fedora Release Engineering <releng@fedoraproject.org> - 3.6-2
- Rebuilt for https://fedoraproject.org/wiki/Fedora_34_Mass_Rebuild