Adding upstream version 1:0.1.9998svn3589+dfsg.upstream/1%0.1.9998svn3589+dfsg

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1374 insertions, 0 deletions

diff --git a/src/grep/lib/sigsegv.c b/src/grep/lib/sigsegv.c
new file mode 100644
index 0000000..998c827
--- /dev/null
+++ b/src/grep/lib/sigsegv.c
@@ -0,0 +1,1374 @@
+/* Page fault handling library.
+   Copyright (C) 1993-2021 Free Software Foundation, Inc.
+   Copyright (C) 2018  Nylon Chen <nylon7@andestech.com>
+
+   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
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
+
+/* Written by Bruno Haible and Nylon Chen.  */
+
+#include <config.h>
+
+/* Specification.  */
+#include "sigsegv.h"
+
+#include <errno.h>
+#include <stdio.h> /* declares perror */
+#include <stdint.h> /* defines uintptr_t */
+#include <stdlib.h>
+#include <signal.h>
+#if HAVE_GETRLIMIT
+# include <sys/resource.h> /* declares struct rlimit */
+#endif
+
+#ifdef __OpenBSD__
+# include <sys/param.h> /* defines macro OpenBSD */
+#endif
+
+
+/* Version number.  */
+int libsigsegv_version = LIBSIGSEGV_VERSION;
+
+
+/* ======================= Fault handler information ======================= */
+
+/* Define:
+
+     SIGSEGV_FAULT_HANDLER_ARGLIST
+          is the argument list for the actual fault handler.
+
+   and if available (optional):
+
+     SIGSEGV_FAULT_ADDRESS
+          is a macro for fetching the fault address.
+
+     SIGSEGV_FAULT_CONTEXT
+          is a macro giving a pointer to the entire fault context (i.e.
+          the register set etc.).
+
+     SIGSEGV_FAULT_STACKPOINTER
+          is a macro for fetching the stackpointer at the moment the fault
+          occurred.
+ */
+
+#if defined __linux__ || defined __ANDROID__ /* Linux */
+
+# define SIGSEGV_FAULT_HANDLER_ARGLIST  int sig, siginfo_t *sip, void *ucp
+# define SIGSEGV_FAULT_ADDRESS  sip->si_addr
+# define SIGSEGV_FAULT_CONTEXT  ((ucontext_t *) ucp)
+# define SIGSEGV_FAULT_ADDRESS_FROM_SIGINFO
+
+# if defined __alpha__
+
+/* See glibc/sysdeps/unix/sysv/linux/alpha/sys/ucontext.h
+   and the definition of GET_STACK in
+   glibc/sysdeps/unix/sysv/linux/alpha/sigcontextinfo.h.
+   Note that the 'mcontext_t' defined in
+   glibc/sysdeps/unix/sysv/linux/alpha/sys/ucontext.h
+   and the 'struct sigcontext' defined in <asm/sigcontext.h>
+   are actually the same.  */
+
+#  define SIGSEGV_FAULT_STACKPOINTER  ((ucontext_t *) ucp)->uc_mcontext.sc_regs[30]
+
+# elif defined __arm64__ /* 64-bit */
+
+/* See glibc/sysdeps/unix/sysv/linux/aarch64/sys/ucontext.h.
+   Note that the 'mcontext_t' defined in
+   glibc/sysdeps/unix/sysv/linux/aarch64/sys/ucontext.h
+   and the 'struct sigcontext' defined in <asm/sigcontext.h>
+   are actually the same.  */
+
+#  define SIGSEGV_FAULT_STACKPOINTER  ((ucontext_t *) ucp)->uc_mcontext.sp
+
+# elif defined __arm__ || defined __armhf__ /* 32-bit */
+
+/* See glibc/sysdeps/unix/sysv/linux/arm/sys/ucontext.h
+   and the definition of GET_STACK in
+   glibc/sysdeps/unix/sysv/linux/arm/sigcontextinfo.h.
+   Note that the 'mcontext_t' defined in
+   glibc/sysdeps/unix/sysv/linux/arm/sys/ucontext.h
+   and the 'struct sigcontext' defined in <asm/sigcontext.h>
+   are actually the same.  */
+
+#  define SIGSEGV_FAULT_STACKPOINTER  ((ucontext_t *) ucp)->uc_mcontext.arm_sp
+
+# elif defined __cris__
+
+/* See glibc-ports/sysdeps/unix/sysv/linux/cris/sys/ucontext.h.
+   Note that the 'mcontext_t' defined in
+   glibc-ports/sysdeps/unix/sysv/linux/cris/sys/ucontext.h
+   and the 'struct sigcontext' defined in <asm/sigcontext.h>
+   are actually the same.  */
+
+#  define SIGSEGV_FAULT_STACKPOINTER  ((ucontext_t *) ucp)->uc_mcontext.usp
+
+# elif defined __hppa__
+
+/* See glibc/sysdeps/unix/sysv/linux/hppa/sys/ucontext.h.
+   Note that the 'mcontext_t' defined in
+   glibc/sysdeps/unix/sysv/linux/hppa/sys/ucontext.h
+   and the 'struct sigcontext' defined in <asm/sigcontext.h>
+   are actually the same.  */
+
+#  define SIGSEGV_FAULT_STACKPOINTER  ((ucontext_t *) ucp)->uc_mcontext.sc_gr[30]
+
+# elif defined __x86_64__ /* 64 bit registers */
+
+/* See glibc/sysdeps/unix/sysv/linux/x86/sys/ucontext.h
+   and the definition of GET_STACK in
+   glibc/sysdeps/unix/sysv/linux/x86_64/sigcontextinfo.h.
+   Note that the 'mcontext_t' defined in
+   glibc/sysdeps/unix/sysv/linux/x86/sys/ucontext.h
+   and the 'struct sigcontext' defined in
+   glibc/sysdeps/unix/sysv/linux/x86/bits/sigcontext.h
+   (see also <asm/sigcontext.h>)
+   are effectively the same.  */
+
+#  define SIGSEGV_FAULT_STACKPOINTER  ((ucontext_t *) ucp)->uc_mcontext.gregs[REG_RSP]
+
+# elif defined __i386__ /* 32 bit registers */
+
+/* See glibc/sysdeps/unix/sysv/linux/x86/sys/ucontext.h
+   and the definition of GET_STACK in
+   glibc/sysdeps/unix/sysv/linux/i386/sigcontextinfo.h.
+   Note that the 'mcontext_t' defined in
+   glibc/sysdeps/unix/sysv/linux/x86/sys/ucontext.h
+   and the 'struct sigcontext_ia32' defined in <asm/sigcontext32.h>
+   are effectively the same.  */
+
+#  define SIGSEGV_FAULT_STACKPOINTER  ((ucontext_t *) ucp)->uc_mcontext.gregs[REG_ESP]
+                     /* same value as ((ucontext_t *) ucp)->uc_mcontext.gregs[REG_UESP] */
+
+# elif defined __ia64__
+
+/* See glibc/sysdeps/unix/sysv/linux/ia64/sys/ucontext.h.
+   Note that the 'mcontext_t' defined in
+   glibc/sysdeps/unix/sysv/linux/ia64/sys/ucontext.h
+   and the 'struct sigcontext' defined in
+   glibc/sysdeps/unix/sysv/linux/ia64/bits/sigcontext.h
+   (see also <asm/sigcontext.h>)
+   are actually the same.  */
+
+/* IA-64 has two stack pointers, one that grows down, called $r12, and one
+   that grows up, called $bsp/$bspstore.  */
+#  define SIGSEGV_FAULT_STACKPOINTER  ((ucontext_t *) ucp)->uc_mcontext.sc_gr[12]
+
+/* It would be better to access $bspstore instead of $bsp but I don't know
+   where to find it in 'struct sigcontext'.  Anyway, it doesn't matter
+   because $bsp and $bspstore never differ by more than ca. 1 KB.  */
+#  define SIGSEGV_FAULT_BSP_POINTER  ((ucontext_t *) ucp)->uc_mcontext.sc_ar_bsp
+
+# elif defined __m68k__
+
+/* See glibc/sysdeps/unix/sysv/linux/m68k/sys/ucontext.h
+   and the definition of GET_STACK in
+   glibc/sysdeps/unix/sysv/linux/m68k/sigcontextinfo.h.
+   Note that the 'mcontext_t' defined in
+   glibc/sysdeps/unix/sysv/linux/m68k/sys/ucontext.h
+   and the 'struct sigcontext' defined in <asm/sigcontext.h>
+   are quite different types.  */
+
+#  define SIGSEGV_FAULT_STACKPOINTER  ((ucontext_t *) ucp)->uc_mcontext.gregs[R_SP]
+
+# elif defined __mips__ || defined __mipsn32__ || defined __mips64__
+
+/* See glibc/sysdeps/unix/sysv/linux/mips/sys/ucontext.h
+   and the definition of GET_STACK in
+   glibc/sysdeps/unix/sysv/linux/mips/sigcontextinfo.h.
+   Note that the 'mcontext_t' defined in
+   glibc/sysdeps/unix/sysv/linux/mips/sys/ucontext.h
+   and the 'struct sigcontext' defined in
+   glibc/sysdeps/unix/sysv/linux/mips/bits/sigcontext.h
+   (see also <asm/sigcontext.h>)
+   are effectively the same.  */
+
+#  define SIGSEGV_FAULT_STACKPOINTER  ((ucontext_t *) ucp)->uc_mcontext.gregs[29]
+
+# elif defined __nds32__
+
+/* See glibc/sysdeps/unix/sysv/linux/nds32/sys/ucontext.h
+   and the definition of GET_STACK in
+   glibc/sysdeps/unix/sysv/linux/nds32/sigcontextinfo.h.
+   Both are found in <https://patches-gcc.linaro.org/cover/4409/> part 08/11
+   <https://sourceware.org/ml/libc-alpha/2018-05/msg00125.html>.  */
+
+#  define SIGSEGV_FAULT_STACKPOINTER  ((ucontext_t *) ucp)->uc_mcontext.nds32_sp
+
+# elif defined __powerpc__ || defined __powerpc64__ || defined __powerpc64_elfv2__
+
+/* See glibc/sysdeps/unix/sysv/linux/powerpc/sys/ucontext.h
+   and the definition of GET_STACK in
+   glibc/sysdeps/unix/sysv/linux/powerpc/sigcontextinfo.h.
+   Note that the 'mcontext_t' defined in
+   glibc/sysdeps/unix/sysv/linux/powerpc/sys/ucontext.h,
+   the 'struct sigcontext' defined in <asm/sigcontext.h>,
+   and the 'struct pt_regs' defined in <asm/ptrace.h>
+   are quite different types.  */
+
+#  if defined __powerpc64__ || defined __powerpc64_elfv2__ /* 64-bit */
+#   define SIGSEGV_FAULT_STACKPOINTER  ((ucontext_t *) ucp)->uc_mcontext.gp_regs[1]
+#  else /* 32-bit */
+/* both should be equivalent */
+#   if 0
+#    define SIGSEGV_FAULT_STACKPOINTER  ((ucontext_t *) ucp)->uc_mcontext.regs->gpr[1]
+#   else
+#    define SIGSEGV_FAULT_STACKPOINTER  ((ucontext_t *) ucp)->uc_mcontext.uc_regs->gregs[1]
+#   endif
+#  endif
+
+# elif defined __riscv32__ || __riscv64__
+
+/* See glibc/sysdeps/unix/sysv/linux/riscv/sys/ucontext.h
+   and the definition of GET_STACK in
+   glibc/sysdeps/unix/sysv/linux/riscv/sigcontextinfo.h.
+   Note that the 'mcontext_t' defined in
+   glibc/sysdeps/unix/sysv/linux/riscv/sys/ucontext.h
+   and the 'struct sigcontext' defined in
+   glibc/sysdeps/unix/sysv/linux/riscv/bits/sigcontext.h
+   start with the same block of 32 general-purpose registers.  */
+
+#  define SIGSEGV_FAULT_STACKPOINTER  ((ucontext_t *) ucp)->uc_mcontext.__gregs[REG_SP]
+
+# elif defined __s390__ || defined __s390x__
+
+/* See glibc/sysdeps/unix/sysv/linux/s390/sys/ucontext.h
+   and the definition of GET_STACK in
+   glibc/sysdeps/unix/sysv/linux/s390/sigcontextinfo.h.
+   Note that the 'mcontext_t' defined in
+   glibc/sysdeps/unix/sysv/linux/s390/sys/ucontext.h
+   and the '_sigregs' type, indirect part of 'struct sigcontext', defined
+   in <asm/sigcontext.h>, are effectively the same.  */
+
+#  define SIGSEGV_FAULT_STACKPOINTER  ((ucontext_t *) ucp)->uc_mcontext.gregs[15]
+
+# elif defined __sh__
+
+/* See glibc/sysdeps/unix/sysv/linux/sh/sys/ucontext.h
+   and the definition of GET_STACK in
+   glibc/sysdeps/unix/sysv/linux/sh/sigcontextinfo.h.
+   Note that the 'mcontext_t' defined in
+   glibc/sysdeps/unix/sysv/linux/sh/sys/ucontext.h
+   and the 'struct sigcontext' defined in <asm/sigcontext.h>
+   are effectively the same.  */
+
+#  define SIGSEGV_FAULT_STACKPOINTER  ((ucontext_t *) ucp)->uc_mcontext.gregs[15]
+
+# elif defined __sparc__ || defined __sparc64__
+
+/* See glibc/sysdeps/unix/sysv/linux/sparc/sys/ucontext.h
+   and the definition of GET_STACK in
+   glibc/sysdeps/unix/sysv/linux/sparc/{sparc32,sparc64}/sigcontextinfo.h.
+   Note that the 'mcontext_t' defined in
+   glibc/sysdeps/unix/sysv/linux/sparc/sys/ucontext.h
+   and the 'struct sigcontext' defined in
+   glibc/sysdeps/unix/sysv/linux/sparc/bits/sigcontext.h
+   (see also <asm/sigcontext.h>)
+   are quite different types.  */
+
+#  if defined __sparc64__/* 64-bit */
+/* From linux-4.8.1/arch/sparc/kernel/signal_64.c, function setup_rt_frame, we
+   see that ucp is not an 'ucontext_t *' but rather a 'struct sigcontext *'
+   that happens to have the same value as sip (which is possible because a
+   'struct sigcontext' starts with 128 bytes room for the siginfo_t).  */
+#   define SIGSEGV_FAULT_STACKPOINTER  (((struct sigcontext *) ucp)->sigc_regs.u_regs[14] + 2047)
+#  else /* 32-bit */
+/* From linux-4.8.1/arch/sparc/kernel/signal_32.c, function setup_rt_frame,
+   and linux-4.8.1/arch/sparc/kernel/signal32.c, function setup_rt_frame32, we
+   see that ucp is a 'struct pt_regs *' or 'struct pt_regs32 *', respectively.
+   In userland, this is a 'struct sigcontext *'.  */
+#   define SIGSEGV_FAULT_STACKPOINTER  ((struct sigcontext *) ucp)->si_regs.u_regs[14]
+#  endif
+
+/* The sip->si_addr field is correct for a normal fault, but unusable in case
+   of a stack overflow. What I observe (when running
+   tests/test-sigsegv-catch-stackoverflow1, with a printf right at the beginning
+   of sigsegv_handler) is that sip->si_addr is near 0:
+     - in 64-bit mode: sip->si_addr = 0x000000000000030F, and gdb shows me that
+       the fault occurs in an instruction 'stx %o3,[%fp+0x30f]' and %fp is 0.
+       In fact, all registers %l0..%l7 and %i0..%i7 are 0.
+     - in 32-bit mode: sip->si_addr = 0xFFFFFA64, and gdb shows me that
+       the fault occurs in an instruction 'st %g2,[%fp-1436]' and %fp is 0.
+       In fact, all registers %l0..%l7 and %i0..%i7 are 0.
+   Apparently when the stack overflow occurred, some trap has tried to move the
+   contents of the registers %l0..%l7 and %i0..%i7 (a "window" in SPARC
+   terminology) to the stack, did not succeed in doing this, replaced all these
+   register values with 0, and resumed execution at the fault location. This
+   time, due to %fp = 0, a different fault was triggered. Now it is impossible
+   to determine the real (previous) fault address because, even if know the
+   faulting instruction, the previous register values have been lost.  */
+#  define BOGUS_FAULT_ADDRESS_UPON_STACK_OVERFLOW
+
+# else
+
+/* When adding support for other CPUs here:  */
+
+/* For SIGSEGV_FAULT_HANDLER_ARGLIST, see the definition of SIGCONTEXT in
+   glibc/sysdeps/unix/sysv/linux/<cpu>/sigcontextinfo.h.  */
+
+/* For SIGSEGV_FAULT_STACKPOINTER, see the definition of GET_STACK in
+   glibc/sysdeps/unix/sysv/linux/<cpu>/sigcontextinfo.h.  */
+
+# endif
+
+#endif
+
+#if defined __GNU__ /* Hurd */
+
+# define SIGSEGV_FAULT_HANDLER_ARGLIST  int sig, int code, struct sigcontext *scp
+# define SIGSEGV_FAULT_ADDRESS  (unsigned long) code
+# define SIGSEGV_FAULT_CONTEXT  scp
+
+# if defined __i386__
+
+/* scp points to a 'struct sigcontext' (defined in
+   glibc/sysdeps/mach/hurd/i386/bits/sigcontext.h).
+   The registers of this struct get pushed on the stack through
+   gnumach/i386/i386/locore.S:trapall.  */
+/* Both sc_esp and sc_uesp appear to have the same value.
+   It appears more reliable to use sc_uesp because it is labelled as
+   "old esp, if trapped from user".  */
+#  define SIGSEGV_FAULT_STACKPOINTER  scp->sc_uesp
+
+# endif
+
+#endif
+
+#if defined __FreeBSD_kernel__ || defined __FreeBSD__ || defined __DragonFly__ /* GNU/kFreeBSD, FreeBSD */
+
+# if defined __arm__ || defined __armhf__ || defined __arm64__
+
+#  define SIGSEGV_FAULT_HANDLER_ARGLIST  int sig, siginfo_t *sip, void *ucp
+#  define SIGSEGV_FAULT_ADDRESS  sip->si_addr
+#  define SIGSEGV_FAULT_CONTEXT  ((ucontext_t *) ucp)
+
+#  if defined __arm64__ /* 64-bit */
+
+/* See sys/arm64/include/ucontext.h.  */
+
+#   define SIGSEGV_FAULT_STACKPOINTER  ((ucontext_t *) ucp)->uc_mcontext.mc_gpregs.gp_sp
+
+#  elif defined __arm__ || defined __armhf__ /* 32-bit */
+
+/* See sys/arm/include/ucontext.h.  */
+
+#   define SIGSEGV_FAULT_STACKPOINTER  ((ucontext_t *) ucp)->uc_mcontext.__gregs[_REG_SP]
+
+#  endif
+
+# else
+
+/* On FreeBSD 12, both of these approaches work.  On FreeBSD derivatives, the
+   first one has more chances to work.  */
+#  if 1
+/* Use signal handlers without SA_SIGINFO.  */
+
+#   define SIGSEGV_FAULT_HANDLER_ARGLIST  int sig, int code, struct sigcontext *scp, void *addr
+#   define SIGSEGV_FAULT_ADDRESS  addr
+#   define SIGSEGV_FAULT_CONTEXT  scp
+
+/* See sys/x86/include/signal.h.  */
+
+#   if defined __x86_64__
+/* 64 bit registers */
+
+#    define SIGSEGV_FAULT_STACKPOINTER  scp->sc_rsp
+
+#   elif defined __i386__
+/* 32 bit registers */
+
+#    define SIGSEGV_FAULT_STACKPOINTER  scp->sc_esp
+
+#   endif
+
+#  else
+/* Use signal handlers with SA_SIGINFO.  */
+
+#   define SIGSEGV_FAULT_HANDLER_ARGLIST  int sig, siginfo_t *sip, void *scp
+#   define SIGSEGV_FAULT_ADDRESS  sip->si_addr
+#   define SIGSEGV_FAULT_CONTEXT  ((struct sigcontext *) scp)
+#   define SIGSEGV_FAULT_ADDRESS_FROM_SIGINFO
+
+/* See sys/x86/include/signal.h.  */
+
+#   if defined __x86_64__
+/* 64 bit registers */
+
+#    define SIGSEGV_FAULT_STACKPOINTER  ((struct sigcontext *) scp)->sc_rsp
+
+#   elif defined __i386__
+/* 32 bit registers */
+
+#    define SIGSEGV_FAULT_STACKPOINTER  ((struct sigcontext *) scp)->sc_esp
+
+#   endif
+
+#  endif
+
+# endif
+
+#endif
+
+#if defined __NetBSD__ /* NetBSD */
+
+# define SIGSEGV_FAULT_HANDLER_ARGLIST  int sig, siginfo_t *sip, void *ucp
+# define SIGSEGV_FAULT_ADDRESS  sip->si_addr
+# define SIGSEGV_FAULT_CONTEXT  ((ucontext_t *) ucp)
+# define SIGSEGV_FAULT_ADDRESS_FROM_SIGINFO
+
+/* _UC_MACHINE_SP is a platform independent macro.
+   Defined in <machine/mcontext.h>, see
+     http://cvsweb.netbsd.org/bsdweb.cgi/src/sys/arch/$arch/include/mcontext.h
+   Supported on alpha, amd64, i386, ia64, m68k, mips, powerpc, sparc since
+   NetBSD 2.0.
+   On i386, _UC_MACHINE_SP is the same as ->uc_mcontext.__gregs[_REG_UESP],
+   and apparently the same value as       ->uc_mcontext.__gregs[_REG_ESP]. */
+# ifdef _UC_MACHINE_SP
+#  define SIGSEGV_FAULT_STACKPOINTER  _UC_MACHINE_SP ((ucontext_t *) ucp)
+# endif
+
+#endif
+
+#if defined __OpenBSD__ /* OpenBSD */
+
+# define SIGSEGV_FAULT_HANDLER_ARGLIST  int sig, siginfo_t *sip, struct sigcontext *scp
+# define SIGSEGV_FAULT_ADDRESS  sip->si_addr
+# define SIGSEGV_FAULT_CONTEXT  scp
+# define SIGSEGV_FAULT_ADDRESS_FROM_SIGINFO
+
+# if defined __alpha__
+
+/* See the definition of 'struct sigcontext' in
+   openbsd-src/sys/arch/alpha/include/signal.h.  */
+
+#  define SIGSEGV_FAULT_STACKPOINTER  scp->sc_regs[30]
+
+# elif defined __arm__ || defined __armhf__
+
+/* See the definition of 'struct sigcontext' in
+   openbsd-src/sys/arch/arm/include/signal.h.  */
+
+#  define SIGSEGV_FAULT_STACKPOINTER  scp->sc_usr_sp
+
+# elif defined __hppa__ || defined __hppa64__
+
+/* See the definition of 'struct sigcontext' in
+   openbsd-src/sys/arch/hppa/include/signal.h
+   and
+   openbsd-src/sys/arch/hppa64/include/signal.h.  */
+
+#  define SIGSEGV_FAULT_STACKPOINTER  scp->sc_regs[30]
+
+# elif defined __x86_64__
+/* 64 bit registers */
+
+/* See the definition of 'struct sigcontext' in
+   openbsd-src/sys/arch/amd64/include/signal.h.  */
+
+#  define SIGSEGV_FAULT_STACKPOINTER  scp->sc_rsp
+
+# elif defined __i386__
+/* 32 bit registers */
+
+/* See the definition of 'struct sigcontext' in
+   openbsd-src/sys/arch/i386/include/signal.h.  */
+
+#  define SIGSEGV_FAULT_STACKPOINTER  scp->sc_esp
+
+# elif defined __m68k__
+
+/* See the definition of 'struct sigcontext' in
+   openbsd-src/sys/arch/m68k/include/signal.h.  */
+
+#  define SIGSEGV_FAULT_STACKPOINTER  scp->sc_sp
+
+# elif defined __m88k__
+
+/* See the definition of 'struct sigcontext' in
+   openbsd-src/sys/arch/m88k/include/signal.h
+   and the definition of 'struct reg' in
+   openbsd-src/sys/arch/m88k/include/reg.h.  */
+
+#  if OpenBSD >= 201211 /* OpenBSD version >= 5.2 */
+#   define SIGSEGV_FAULT_STACKPOINTER  scp->sc_regs[31]
+#  else
+#   define SIGSEGV_FAULT_STACKPOINTER  scp->sc_regs.r[31]
+#  endif
+
+# elif defined __mips__ || defined __mipsn32__ || defined __mips64__
+
+/* See the definition of 'struct sigcontext' in
+   openbsd-src/sys/arch/mips64/include/signal.h.  */
+
+#  define SIGSEGV_FAULT_STACKPOINTER  scp->sc_regs[29]
+
+# elif defined __powerpc__ || defined __powerpc64__
+
+/* See the definition of 'struct sigcontext' and 'struct trapframe' in
+   openbsd-src/sys/arch/powerpc/include/signal.h.  */
+
+#  define SIGSEGV_FAULT_STACKPOINTER  scp->sc_frame.fixreg[1]
+
+# elif defined __sh__
+
+/* See the definition of 'struct sigcontext' in
+   openbsd-src/sys/arch/sh/include/signal.h
+   and the definition of 'struct reg' in
+   openbsd-src/sys/arch/sh/include/reg.h.  */
+
+#  if OpenBSD >= 201211 /* OpenBSD version >= 5.2 */
+#   define SIGSEGV_FAULT_STACKPOINTER  scp->sc_reg[20-15]
+#  else
+#   define SIGSEGV_FAULT_STACKPOINTER  scp->sc_reg.r_r15
+#  endif
+
+# elif defined __sparc__ || defined __sparc64__
+
+/* See the definition of 'struct sigcontext' in
+   openbsd-src/sys/arch/sparc/include/signal.h
+   and
+   openbsd-src/sys/arch/sparc64/include/signal.h.  */
+
+#  define SIGSEGV_FAULT_STACKPOINTER  scp->sc_sp
+
+# elif defined __vax__
+
+/* See the definition of 'struct sigcontext' in
+   openbsd-src/sys/arch/vax/include/signal.h.  */
+
+#  define SIGSEGV_FAULT_STACKPOINTER  scp->sc_sp
+
+# endif
+
+#endif
+
+#if (defined __APPLE__ && defined __MACH__) /* macOS */
+
+# define SIGSEGV_FAULT_HANDLER_ARGLIST  int sig, siginfo_t *sip, void *ucp
+# define SIGSEGV_FAULT_ADDRESS  sip->si_addr
+# define SIGSEGV_FAULT_CONTEXT  ((ucontext_t *) ucp)
+# define SIGSEGV_FAULT_ADDRESS_FROM_SIGINFO
+
+# if defined __x86_64__
+
+/* See the definitions of
+     - 'ucontext_t' and 'struct __darwin_ucontext' in <sys/_types/_ucontext.h>,
+     - 'struct __darwin_mcontext64' in <i386/_mcontext.h>, and
+     - 'struct __darwin_x86_thread_state64' in <mach/i386/_structs.h>.  */
+#  define SIGSEGV_FAULT_STACKPOINTER  ((ucontext_t *) ucp)->uc_mcontext->__ss.__rsp
+
+# elif defined __i386__
+
+/* See the definitions of
+     - 'ucontext_t' and 'struct __darwin_ucontext' in <sys/_types/_ucontext.h>,
+     - 'struct __darwin_mcontext32' in <i386/_mcontext.h>, and
+     - 'struct __darwin_i386_thread_state' in <mach/i386/_structs.h>.  */
+#  define SIGSEGV_FAULT_STACKPOINTER  ((ucontext_t *) ucp)->uc_mcontext->__ss.__esp
+
+# elif defined __arm64__
+
+/* See the definitions of
+     - 'ucontext_t' and 'struct __darwin_ucontext' in <sys/_types/_ucontext.h>,
+     - 'struct __darwin_mcontext64' in <arm/_mcontext.h>, and
+     - 'struct __darwin_arm_thread_state64' in <mach/arm/_structs.h>.  */
+#  define SIGSEGV_FAULT_STACKPOINTER  ((ucontext_t *) ucp)->uc_mcontext->__ss.__sp
+
+# elif defined __powerpc__
+
+/* See the definitions of
+     - 'ucontext_t' and 'struct __darwin_ucontext' in <sys/_structs.h>,
+     - 'struct __darwin_mcontext' in <ppc/_structs.h>, and
+     - 'struct __darwin_ppc_thread_state' in <mach/ppc/_structs.h>.  */
+#  define SIGSEGV_FAULT_STACKPOINTER  ((ucontext_t *) ucp)->uc_mcontext->__ss.__r1
+
+# endif
+
+#endif
+
+#if defined _AIX /* AIX */
+
+# define SIGSEGV_FAULT_HANDLER_ARGLIST  int sig, siginfo_t *sip, void *ucp
+# define SIGSEGV_FAULT_ADDRESS  sip->si_addr
+# define SIGSEGV_FAULT_CONTEXT  ((ucontext_t *) ucp)
+# define SIGSEGV_FAULT_ADDRESS_FROM_SIGINFO
+
+# if defined __powerpc__ || defined __powerpc64__
+#  define SIGSEGV_FAULT_STACKPOINTER  ((ucontext_t *) ucp)->uc_mcontext.jmp_context.gpr[1]
+# endif
+
+#endif
+
+#if defined __sgi /* IRIX */
+
+# define SIGSEGV_FAULT_HANDLER_ARGLIST  int sig, int code, struct sigcontext *scp
+# define SIGSEGV_FAULT_ADDRESS  (unsigned long) scp->sc_badvaddr
+# define SIGSEGV_FAULT_CONTEXT  scp
+
+# if defined __mips__ || defined __mipsn32__ || defined __mips64__
+#  define SIGSEGV_FAULT_STACKPOINTER  scp->sc_regs[29]
+# endif
+
+#endif
+
+#if defined __sun /* Solaris */
+
+# define SIGSEGV_FAULT_HANDLER_ARGLIST  int sig, siginfo_t *sip, void *ucp
+# define SIGSEGV_FAULT_ADDRESS  sip->si_addr
+# define SIGSEGV_FAULT_CONTEXT  ((ucontext_t *) ucp)
+# define SIGSEGV_FAULT_ADDRESS_FROM_SIGINFO
+
+# if defined __x86_64__
+/* 64 bit registers */
+
+#  define SIGSEGV_FAULT_STACKPOINTER  ((ucontext_t *) ucp)->uc_mcontext.gregs[REG_RSP]
+
+# elif defined __i386__
+/* 32 bit registers */
+
+#  define SIGSEGV_FAULT_STACKPOINTER  ((ucontext_t *) ucp)->uc_mcontext.gregs[ESP]
+
+# elif defined __sparc__ || defined __sparc64__
+
+#  define SIGSEGV_FAULT_STACKPOINTER  ((ucontext_t *) ucp)->uc_mcontext.gregs[REG_O6]
+
+#  if SOLARIS11
+
+/* On Solaris 11.3/SPARC, both in 32-bit and 64-bit mode, when catching
+   stack overflow, the fault address is correct the first time, but is zero
+   or near zero the second time.
+   'truss tests/test-sigsegv-catch-stackoverflow1' shows it:
+
+   In 32-bit mode:
+
+    Incurred fault #6, FLTBOUNDS  %pc = 0x000116E8
+      siginfo: SIGSEGV SEGV_MAPERR addr=0xFFB00000
+    Received signal #11, SIGSEGV [caught]
+      siginfo: SIGSEGV SEGV_MAPERR addr=0xFFB00000
+   then
+    Incurred fault #6, FLTBOUNDS  %pc = 0x000116E8
+      siginfo: SIGSEGV SEGV_MAPERR addr=0x00000008
+    Received signal #11, SIGSEGV [caught]
+      siginfo: SIGSEGV SEGV_MAPERR addr=0x00000008
+
+   In 64-bit mode:
+
+    Incurred fault #6, FLTBOUNDS  %pc = 0x100001C58
+      siginfo: SIGSEGV SEGV_MAPERR addr=0xFFFFFFFF7FF00000
+    Received signal #11, SIGSEGV [caught]
+      siginfo: SIGSEGV SEGV_MAPERR addr=0xFFFFFFFF7FF00000
+   then
+    Incurred fault #6, FLTBOUNDS  %pc = 0x100001C58
+      siginfo: SIGSEGV SEGV_MAPERR addr=0x00000000
+    Received signal #11, SIGSEGV [caught]
+      siginfo: SIGSEGV SEGV_MAPERR addr=0x00000000
+ */
+#   define BOGUS_FAULT_ADDRESS_UPON_STACK_OVERFLOW
+
+#  endif
+
+# endif
+
+#endif
+
+#if defined __CYGWIN__ /* Cygwin */
+
+# define SIGSEGV_FAULT_HANDLER_ARGLIST  int sig, siginfo_t *sip, void *ucp
+# define SIGSEGV_FAULT_ADDRESS  sip->si_addr
+# define SIGSEGV_FAULT_CONTEXT  ((ucontext_t *) ucp)
+# define SIGSEGV_FAULT_ADDRESS_FROM_SIGINFO
+
+/* See the definition of 'ucontext_t' in <sys/ucontext.h> and
+   of 'struct __mcontext' in <cygwin/signal.h>.  */
+# if defined __x86_64__
+/* 64 bit registers */
+#  define SIGSEGV_FAULT_STACKPOINTER  ((ucontext_t *) ucp)->uc_mcontext.rsp
+# elif defined __i386__
+/* 32 bit registers */
+#  define SIGSEGV_FAULT_STACKPOINTER  ((ucontext_t *) ucp)->uc_mcontext.esp
+# endif
+
+#endif
+
+#if defined __HAIKU__ /* Haiku */
+
+# define SIGSEGV_FAULT_HANDLER_ARGLIST  int sig, siginfo_t *sip, void *ucp
+# define SIGSEGV_FAULT_ADDRESS  sip->si_addr
+# define SIGSEGV_FAULT_CONTEXT  ((ucontext_t *) ucp)
+# define SIGSEGV_FAULT_ADDRESS_FROM_SIGINFO
+
+# if defined __x86_64__
+/* 64 bit registers */
+
+/* See the definition of 'ucontext_t' in <signal.h> and
+   of 'struct vregs' in <arch/x86_64/signal.h>.  */
+
+#  define SIGSEGV_FAULT_STACKPOINTER  ((ucontext_t *) ucp)->uc_mcontext.rsp
+
+# elif defined __i386__
+/* 32 bit registers */
+
+/* See the definition of 'ucontext_t' in <signal.h> and
+   of 'struct vregs' in <arch/x86/signal.h>.  */
+
+#  define SIGSEGV_FAULT_STACKPOINTER  ((ucontext_t *) ucp)->uc_mcontext.esp
+
+# endif
+
+#endif
+
+/* ========================================================================== */
+
+/* List of signals that are sent when an invalid virtual memory address
+   is accessed, or when the stack overflows.  */
+#if defined __GNU__ \
+    || defined __FreeBSD_kernel__ || defined __FreeBSD__ || defined __DragonFly__ \
+    || defined __NetBSD__ || defined __OpenBSD__ \
+    || (defined __APPLE__ && defined __MACH__)
+# define SIGSEGV_FOR_ALL_SIGNALS(var,body) \
+    { int var; var = SIGSEGV; { body } var = SIGBUS; { body } }
+#else
+# define SIGSEGV_FOR_ALL_SIGNALS(var,body) \
+    { int var; var = SIGSEGV; { body } }
+#endif
+
+/* ========================================================================== */
+
+/* Determine the virtual memory area of a given address.  */
+#include "stackvma.h"
+
+/* ========================================================================== */
+
+/* On the average Unix platform, we define
+
+   HAVE_SIGSEGV_RECOVERY
+       if there is a fault-*.h include file which defines
+       SIGSEGV_FAULT_HANDLER_ARGLIST and SIGSEGV_FAULT_ADDRESS.
+
+   HAVE_STACK_OVERFLOW_RECOVERY
+       if HAVE_SIGALTSTACK is set and
+       at least two of the following are true:
+       A) There is a fault-*.h include file which defines
+          SIGSEGV_FAULT_HANDLER_ARGLIST and SIGSEGV_FAULT_ADDRESS.
+       B) There is a fault-*.h include file which defines
+          SIGSEGV_FAULT_HANDLER_ARGLIST and SIGSEGV_FAULT_STACKPOINTER.
+       C) There is a stackvma-*.c, other than stackvma-none.c, which
+          defines sigsegv_get_vma.
+
+   Why? Obviously, to catch stack overflow, we need an alternate signal
+   stack; this requires kernel support. But we also need to distinguish
+   (with a reasonable confidence) a stack overflow from a regular SIGSEGV.
+   If we have A) and B), we use the
+     Heuristic AB: If the fault address is near the stack pointer, it's a
+     stack overflow.
+   If we have A) and C), we use the
+     Heuristic AC: If the fault address is near and beyond the bottom of
+     the stack's virtual memory area, it's a stack overflow.
+   If we have B) and C), we use the
+     Heuristic BC: If the stack pointer is near the bottom of the stack's
+     virtual memory area, it's a stack overflow.
+     This heuristic comes in two flavours: On OSes which let the stack's
+     VMA grow continuously, we determine the bottom by use of getrlimit().
+     On OSes which preallocate the stack's VMA with its maximum size
+     (like BeOS), we use the stack's VMA directly.
+ */
+
+#if HAVE_SIGSEGV_RECOVERY \
+     && !(defined SIGSEGV_FAULT_HANDLER_ARGLIST && defined SIGSEGV_FAULT_ADDRESS)
+# error "You need to define SIGSEGV_FAULT_HANDLER_ARGLIST and SIGSEGV_FAULT_ADDRESS before you can define HAVE_SIGSEGV_RECOVERY."
+#endif
+#if !HAVE_SIGSEGV_RECOVERY \
+    && (defined SIGSEGV_FAULT_HANDLER_ARGLIST && defined SIGSEGV_FAULT_ADDRESS) \
+    && !(defined __FreeBSD__ && (defined __sparc__ || defined __sparc64__))
+# if __GNUC__ || (__clang_major__ >= 4)
+#  warning "You can define HAVE_SIGSEGV_RECOVERY on this platform."
+# else
+#  error "You can define HAVE_SIGSEGV_RECOVERY on this platform."
+# endif
+#endif
+
+#if HAVE_STACK_OVERFLOW_RECOVERY \
+    && !(defined SIGSEGV_FAULT_ADDRESS + defined SIGSEGV_FAULT_STACKPOINTER + HAVE_STACKVMA >= 2)
+# error "You need to define two of SIGSEGV_FAULT_ADDRESS, SIGSEGV_FAULT_STACKPOINTER, HAVE_STACKVMA, before you can define HAVE_STACK_OVERFLOW_RECOVERY."
+#endif
+#if !HAVE_STACK_OVERFLOW_RECOVERY \
+    && (defined SIGSEGV_FAULT_ADDRESS + defined SIGSEGV_FAULT_STACKPOINTER + HAVE_STACKVMA >= 2) \
+    && !(defined __FreeBSD__ && (defined __sparc__ || defined __sparc64__)) \
+    && !(defined __NetBSD__ && (defined __sparc__ || defined __sparc64__))
+# if __GNUC__ || (__clang_major__ >= 4)
+#  warning "You can define HAVE_STACK_OVERFLOW_RECOVERY on this platform."
+# else
+#  error "You can define HAVE_STACK_OVERFLOW_RECOVERY on this platform."
+# endif
+#endif
+
+/* ========================================================================== */
+
+#if HAVE_STACK_OVERFLOW_RECOVERY
+
+/* ======= Leaving a signal handler executing on the alternate stack ======= */
+
+/* Platform dependent:
+   Leaving a signal handler executing on the alternate stack.  */
+static void sigsegv_reset_onstack_flag (void);
+
+/* -------------------------- leave-sigaltstack.c -------------------------- */
+
+# if defined __GNU__ \
+     || defined __FreeBSD_kernel__ || defined __FreeBSD__ || defined __DragonFly__ \
+     || defined __NetBSD__ || defined __OpenBSD__
+
+static void
+sigsegv_reset_onstack_flag (void)
+{
+  stack_t ss;
+
+  if (sigaltstack (NULL, &ss) >= 0)
+    {
+      ss.ss_flags &= ~SS_ONSTACK;
+      sigaltstack (&ss, NULL);
+    }
+}
+
+/* --------------------------- leave-setcontext.c --------------------------- */
+
+# elif defined __sgi || defined __sun /* IRIX, Solaris */
+
+#  include <ucontext.h>
+
+static void
+sigsegv_reset_onstack_flag (void)
+{
+  ucontext_t uc;
+
+  if (getcontext (&uc) >= 0)
+    /* getcontext returns twice.  We are interested in the returned context
+       only the first time, i.e. when the SS_ONSTACK bit is set.  */
+    if (uc.uc_stack.ss_flags & SS_ONSTACK)
+      {
+        uc.uc_stack.ss_flags &= ~SS_ONSTACK;
+        /* Note that setcontext() does not refill uc.  Therefore if
+           setcontext() keeps SS_ONSTACK set in the kernel, either
+           setcontext() will return -1 or getcontext() will return a
+           second time, with the SS_ONSTACK bit being cleared.  */
+        setcontext (&uc);
+      }
+}
+
+/* ------------------------------ leave-nop.c ------------------------------ */
+
+# else
+
+static void
+sigsegv_reset_onstack_flag (void)
+{
+  /* Nothing to do. sigaltstack() simply looks at the stack pointer,
+     therefore SS_ONSTACK is not sticky.  */
+}
+
+# endif
+
+/* ========================================================================== */
+
+# if HAVE_STACKVMA
+
+/* Address of the last byte belonging to the stack vma.  */
+static uintptr_t stack_top = 0;
+
+/* Needs to be called once only.  */
+static void
+remember_stack_top (void *some_variable_on_stack)
+{
+  struct vma_struct vma;
+
+  if (sigsegv_get_vma ((uintptr_t) some_variable_on_stack, &vma) >= 0)
+    stack_top = vma.end - 1;
+}
+
+# endif /* HAVE_STACKVMA */
+
+static stackoverflow_handler_t stk_user_handler = (stackoverflow_handler_t)NULL;
+static uintptr_t stk_extra_stack;
+static size_t stk_extra_stack_size;
+
+#endif /* HAVE_STACK_OVERFLOW_RECOVERY */
+
+#if HAVE_SIGSEGV_RECOVERY
+
+/* User's SIGSEGV handler.  */
+static sigsegv_handler_t user_handler = (sigsegv_handler_t)NULL;
+
+#endif /* HAVE_SIGSEGV_RECOVERY */
+
+
+/* Our SIGSEGV handler, with OS dependent argument list.  */
+
+#if HAVE_SIGSEGV_RECOVERY
+
+static void
+sigsegv_handler (SIGSEGV_FAULT_HANDLER_ARGLIST)
+{
+  void *address = (void *) (SIGSEGV_FAULT_ADDRESS);
+
+# if HAVE_STACK_OVERFLOW_RECOVERY
+#  if !(HAVE_STACKVMA || defined SIGSEGV_FAULT_STACKPOINTER)
+#error "Insufficient heuristics for detecting a stack overflow.  Either define CFG_STACKVMA and HAVE_STACKVMA correctly, or define SIGSEGV_FAULT_STACKPOINTER correctly, or undefine HAVE_STACK_OVERFLOW_RECOVERY!"
+#  endif
+
+  /* Call user's handler.  */
+  if (user_handler && (*user_handler) (address, 0))
+    {
+      /* Handler successful.  */
+    }
+  else
+    {
+      /* Handler declined responsibility.  */
+
+      /* Did the user install a stack overflow handler?  */
+      if (stk_user_handler)
+        {
+          /* See whether it was a stack overflow. If so, longjump away.  */
+#  ifdef SIGSEGV_FAULT_STACKPOINTER
+          uintptr_t old_sp = (uintptr_t) (SIGSEGV_FAULT_STACKPOINTER);
+#   ifdef __ia64
+          uintptr_t old_bsp = (uintptr_t) (SIGSEGV_FAULT_BSP_POINTER);
+#   endif
+#  endif
+
+#  if HAVE_STACKVMA
+          /* Were we able to determine the stack top?  */
+          if (stack_top)
+            {
+              /* Determine stack bounds.  */
+              int saved_errno;
+              struct vma_struct vma;
+              int ret;
+
+              saved_errno = errno;
+              ret = sigsegv_get_vma (stack_top, &vma);
+              errno = saved_errno;
+              if (ret >= 0)
+                {
+#   ifndef BOGUS_FAULT_ADDRESS_UPON_STACK_OVERFLOW
+                  /* Heuristic AC: If the fault_address is nearer to the stack
+                     segment's [start,end] than to the previous segment, we
+                     consider it a stack overflow.
+                     In the case of IA-64, we know that the previous segment
+                     is the up-growing bsp segment, and either of the two
+                     stacks can overflow.  */
+                  uintptr_t addr = (uintptr_t) address;
+
+#    ifdef __ia64
+                  if (addr >= vma.prev_end && addr <= vma.end - 1)
+#    else
+#     if STACK_DIRECTION < 0
+                  if (addr >= vma.start
+                      ? (addr <= vma.end - 1)
+                      : vma.is_near_this (addr, &vma))
+#     else
+                  if (addr <= vma.end - 1
+                      ? (addr >= vma.start)
+                      : vma.is_near_this (addr, &vma))
+#     endif
+#    endif
+                    {
+#   else /* BOGUS_FAULT_ADDRESS_UPON_STACK_OVERFLOW */
+#    if HAVE_GETRLIMIT && defined RLIMIT_STACK
+                  /* Heuristic BC: If the stack size has reached its maximal size,
+                     and old_sp is near the low end, we consider it a stack
+                     overflow.  */
+                  struct rlimit rl;
+
+                  saved_errno = errno;
+                  ret = getrlimit (RLIMIT_STACK, &rl);
+                  errno = saved_errno;
+                  if (ret >= 0)
+                    {
+                      uintptr_t current_stack_size = vma.end - vma.start;
+                      uintptr_t max_stack_size = rl.rlim_cur;
+                      if (current_stack_size <= max_stack_size + 4096
+                          && max_stack_size <= current_stack_size + 4096
+#    else
+                    {
+                      if (1
+#    endif
+#    ifdef SIGSEGV_FAULT_STACKPOINTER
+                          /* Heuristic BC: If we know old_sp, and it is neither
+                             near the low end, nor in the alternate stack, then
+                             it's probably not a stack overflow.  */
+                          && ((old_sp >= stk_extra_stack
+                               && old_sp <= stk_extra_stack + stk_extra_stack_size)
+#     if STACK_DIRECTION < 0
+                              || (old_sp <= vma.start + 4096
+                                  && vma.start <= old_sp + 4096))
+#     else
+                              || (old_sp <= vma.end + 4096
+                                  && vma.end <= old_sp + 4096))
+#     endif
+#    endif
+                         )
+#   endif /* BOGUS_FAULT_ADDRESS_UPON_STACK_OVERFLOW */
+#  else /* !HAVE_STACKVMA */
+          /* Heuristic AB: If the fault address is near the stack pointer,
+             it's a stack overflow.  */
+          uintptr_t addr = (uintptr_t) address;
+
+          if ((addr <= old_sp + 4096 && old_sp <= addr + 4096)
+#   ifdef __ia64
+              || (addr <= old_bsp + 4096 && old_bsp <= addr + 4096)
+#   endif
+             )
+            {
+                {
+                    {
+#  endif /* !HAVE_STACKVMA */
+                        {
+#  ifdef SIGSEGV_FAULT_STACKPOINTER
+                          int emergency =
+                            (old_sp >= stk_extra_stack
+                             && old_sp <= stk_extra_stack + stk_extra_stack_size);
+                          stackoverflow_context_t context = (SIGSEGV_FAULT_CONTEXT);
+#  else
+                          int emergency = 0;
+                          stackoverflow_context_t context = (void *) 0;
+#  endif
+                          /* Call user's handler.  */
+                          (*stk_user_handler) (emergency, context);
+                        }
+                    }
+                }
+            }
+        }
+# endif /* HAVE_STACK_OVERFLOW_RECOVERY */
+
+      if (user_handler && (*user_handler) (address, 1))
+        {
+          /* Handler successful.  */
+        }
+      else
+        {
+          /* Handler declined responsibility for real.  */
+
+          /* Remove ourselves and dump core.  */
+          SIGSEGV_FOR_ALL_SIGNALS (signo, signal (signo, SIG_DFL);)
+        }
+
+# if HAVE_STACK_OVERFLOW_RECOVERY
+    }
+# endif /* HAVE_STACK_OVERFLOW_RECOVERY */
+}
+
+#elif HAVE_STACK_OVERFLOW_RECOVERY
+
+static void
+# ifdef SIGSEGV_FAULT_STACKPOINTER
+sigsegv_handler (SIGSEGV_FAULT_HANDLER_ARGLIST)
+# else
+sigsegv_handler (int sig)
+# endif
+{
+# if !((HAVE_GETRLIMIT && defined RLIMIT_STACK) || defined SIGSEGV_FAULT_STACKPOINTER)
+#  error "Insufficient heuristics for detecting a stack overflow.  Either define SIGSEGV_FAULT_STACKPOINTER correctly, or undefine HAVE_STACK_OVERFLOW_RECOVERY!"
+# endif
+
+  /* Did the user install a handler?  */
+  if (stk_user_handler)
+    {
+      /* See whether it was a stack overflow.  If so, longjump away.  */
+# ifdef SIGSEGV_FAULT_STACKPOINTER
+      uintptr_t old_sp = (uintptr_t) (SIGSEGV_FAULT_STACKPOINTER);
+# endif
+
+      /* Were we able to determine the stack top?  */
+      if (stack_top)
+        {
+          /* Determine stack bounds.  */
+          int saved_errno;
+          struct vma_struct vma;
+          int ret;
+
+          saved_errno = errno;
+          ret = sigsegv_get_vma (stack_top, &vma);
+          errno = saved_errno;
+          if (ret >= 0)
+            {
+# if HAVE_GETRLIMIT && defined RLIMIT_STACK
+              /* Heuristic BC: If the stack size has reached its maximal size,
+                 and old_sp is near the low end, we consider it a stack
+                 overflow.  */
+              struct rlimit rl;
+
+              saved_errno = errno;
+              ret = getrlimit (RLIMIT_STACK, &rl);
+              errno = saved_errno;
+              if (ret >= 0)
+                {
+                  uintptr_t current_stack_size = vma.end - vma.start;
+                  uintptr_t max_stack_size = rl.rlim_cur;
+                  if (current_stack_size <= max_stack_size + 4096
+                      && max_stack_size <= current_stack_size + 4096
+# else
+                {
+                  if (1
+# endif
+# ifdef SIGSEGV_FAULT_STACKPOINTER
+                      /* Heuristic BC: If we know old_sp, and it is neither
+                         near the low end, nor in the alternate stack, then
+                         it's probably not a stack overflow.  */
+                      && ((old_sp >= stk_extra_stack
+                           && old_sp <= stk_extra_stack + stk_extra_stack_size)
+#  if STACK_DIRECTION < 0
+                          || (old_sp <= vma.start + 4096
+                              && vma.start <= old_sp + 4096))
+#  else
+                          || (old_sp <= vma.end + 4096
+                              && vma.end <= old_sp + 4096))
+#  endif
+# endif
+                     )
+                    {
+# ifdef SIGSEGV_FAULT_STACKPOINTER
+                      int emergency =
+                        (old_sp >= stk_extra_stack
+                         && old_sp <= stk_extra_stack + stk_extra_stack_size);
+                      stackoverflow_context_t context = (SIGSEGV_FAULT_CONTEXT);
+# else
+                      int emergency = 0;
+                      stackoverflow_context_t context = (void *) 0;
+# endif
+                      /* Call user's handler.  */
+                      (*stk_user_handler)(emergency,context);
+                    }
+                }
+            }
+        }
+    }
+
+  /* Remove ourselves and dump core.  */
+  SIGSEGV_FOR_ALL_SIGNALS (signo, signal (signo, SIG_DFL);)
+}
+
+#endif
+
+
+#if HAVE_SIGSEGV_RECOVERY || HAVE_STACK_OVERFLOW_RECOVERY
+
+static void
+install_for (int sig)
+{
+  struct sigaction action;
+
+# ifdef SIGSEGV_FAULT_ADDRESS_FROM_SIGINFO
+  action.sa_sigaction = &sigsegv_handler;
+# else
+  action.sa_handler = (void (*) (int)) &sigsegv_handler;
+# endif
+  /* Block most signals while SIGSEGV is being handled.  */
+  /* Signals SIGKILL, SIGSTOP cannot be blocked.  */
+  /* Signals SIGCONT, SIGTSTP, SIGTTIN, SIGTTOU are not blocked because
+     dealing with these signals seems dangerous.  */
+  /* Signals SIGILL, SIGABRT, SIGFPE, SIGSEGV, SIGTRAP, SIGIOT, SIGEMT, SIGBUS,
+     SIGSYS, SIGSTKFLT are not blocked because these are synchronous signals,
+     which may require immediate intervention, otherwise the process may
+     starve.  */
+  sigemptyset (&action.sa_mask);
+# ifdef SIGHUP
+  sigaddset (&action.sa_mask,SIGHUP);
+# endif
+# ifdef SIGINT
+  sigaddset (&action.sa_mask,SIGINT);
+# endif
+# ifdef SIGQUIT
+  sigaddset (&action.sa_mask,SIGQUIT);
+# endif
+# ifdef SIGPIPE
+  sigaddset (&action.sa_mask,SIGPIPE);
+# endif
+# ifdef SIGALRM
+  sigaddset (&action.sa_mask,SIGALRM);
+# endif
+# ifdef SIGTERM
+  sigaddset (&action.sa_mask,SIGTERM);
+# endif
+# ifdef SIGUSR1
+  sigaddset (&action.sa_mask,SIGUSR1);
+# endif
+# ifdef SIGUSR2
+  sigaddset (&action.sa_mask,SIGUSR2);
+# endif
+# ifdef SIGCHLD
+  sigaddset (&action.sa_mask,SIGCHLD);
+# endif
+# ifdef SIGCLD
+  sigaddset (&action.sa_mask,SIGCLD);
+# endif
+# ifdef SIGURG
+  sigaddset (&action.sa_mask,SIGURG);
+# endif
+# ifdef SIGIO
+  sigaddset (&action.sa_mask,SIGIO);
+# endif
+# ifdef SIGPOLL
+  sigaddset (&action.sa_mask,SIGPOLL);
+# endif
+# ifdef SIGXCPU
+  sigaddset (&action.sa_mask,SIGXCPU);
+# endif
+# ifdef SIGXFSZ
+  sigaddset (&action.sa_mask,SIGXFSZ);
+# endif
+# ifdef SIGVTALRM
+  sigaddset (&action.sa_mask,SIGVTALRM);
+# endif
+# ifdef SIGPROF
+  sigaddset (&action.sa_mask,SIGPROF);
+# endif
+# ifdef SIGPWR
+  sigaddset (&action.sa_mask,SIGPWR);
+# endif
+# ifdef SIGLOST
+  sigaddset (&action.sa_mask,SIGLOST);
+# endif
+# ifdef SIGWINCH
+  sigaddset (&action.sa_mask,SIGWINCH);
+# endif
+  /* Note that sigaction() implicitly adds sig itself to action.sa_mask.  */
+  /* Ask the OS to provide a structure siginfo_t to the handler.  */
+# ifdef SIGSEGV_FAULT_ADDRESS_FROM_SIGINFO
+  action.sa_flags = SA_SIGINFO;
+# else
+  action.sa_flags = 0;
+# endif
+# if HAVE_STACK_OVERFLOW_RECOVERY && HAVE_SIGALTSTACK /* not BeOS */
+  /* Work around Linux 2.2.5 bug: If SA_ONSTACK is specified but sigaltstack()
+     has not been called, the kernel will busy loop, eating CPU time.  So
+     avoid setting SA_ONSTACK until the user has requested stack overflow
+     handling.  */
+  if (stk_user_handler)
+    action.sa_flags |= SA_ONSTACK;
+# endif
+  sigaction (sig, &action, (struct sigaction *) NULL);
+}
+
+#endif /* HAVE_SIGSEGV_RECOVERY || HAVE_STACK_OVERFLOW_RECOVERY */
+
+int
+sigsegv_install_handler (sigsegv_handler_t handler)
+{
+#if HAVE_SIGSEGV_RECOVERY
+  user_handler = handler;
+
+  SIGSEGV_FOR_ALL_SIGNALS (sig, install_for (sig);)
+
+  return 0;
+#else
+  return -1;
+#endif
+}
+
+void
+sigsegv_deinstall_handler (void)
+{
+#if HAVE_SIGSEGV_RECOVERY
+  user_handler = (sigsegv_handler_t)NULL;
+
+# if HAVE_STACK_OVERFLOW_RECOVERY
+  if (!stk_user_handler)
+# endif
+    {
+      SIGSEGV_FOR_ALL_SIGNALS (sig, signal (sig, SIG_DFL);)
+    }
+#endif
+}
+
+int
+sigsegv_leave_handler (void (*continuation) (void*, void*, void*),
+                       void* cont_arg1, void* cont_arg2, void* cont_arg3)
+{
+#if HAVE_STACK_OVERFLOW_RECOVERY
+  /*
+   * Reset the system's knowledge that we are executing on the alternate
+   * stack. If we didn't do that, siglongjmp would be needed instead of
+   * longjmp to leave the signal handler.
+   */
+  sigsegv_reset_onstack_flag ();
+#endif
+  (*continuation) (cont_arg1, cont_arg2, cont_arg3);
+  return 1;
+}
+
+int
+stackoverflow_install_handler (stackoverflow_handler_t handler,
+                               void *extra_stack, size_t extra_stack_size)
+{
+#if HAVE_STACK_OVERFLOW_RECOVERY
+# if HAVE_STACKVMA
+  if (!stack_top)
+    {
+      int dummy;
+      remember_stack_top (&dummy);
+      if (!stack_top)
+        return -1;
+    }
+# endif
+
+  stk_user_handler = handler;
+  stk_extra_stack = (uintptr_t) extra_stack;
+  stk_extra_stack_size = extra_stack_size;
+  {
+    stack_t ss;
+# if SIGALTSTACK_SS_REVERSED
+    ss.ss_sp = (char *) extra_stack + extra_stack_size - sizeof (void *);
+    ss.ss_size = extra_stack_size - sizeof (void *);
+# else
+    ss.ss_sp = extra_stack;
+    ss.ss_size = extra_stack_size;
+# endif
+    ss.ss_flags = 0; /* no SS_DISABLE */
+    if (sigaltstack (&ss, (stack_t*)0) < 0)
+      return -1;
+  }
+
+  /* Install the signal handlers with SA_ONSTACK.  */
+  SIGSEGV_FOR_ALL_SIGNALS (sig, install_for (sig);)
+  return 0;
+#else
+  return -1;
+#endif
+}
+
+void
+stackoverflow_deinstall_handler (void)
+{
+#if HAVE_STACK_OVERFLOW_RECOVERY
+  stk_user_handler = (stackoverflow_handler_t) NULL;
+
+# if HAVE_SIGSEGV_RECOVERY
+  if (user_handler)
+    {
+      /* Reinstall the signal handlers without SA_ONSTACK, to avoid Linux
+         bug.  */
+      SIGSEGV_FOR_ALL_SIGNALS (sig, install_for (sig);)
+    }
+  else
+# endif
+    {
+      SIGSEGV_FOR_ALL_SIGNALS (sig, signal (sig, SIG_DFL);)
+    }
+
+  {
+    stack_t ss;
+    ss.ss_flags = SS_DISABLE;
+    if (sigaltstack (&ss, (stack_t *) 0) < 0)
+      perror ("gnulib sigsegv (stackoverflow_deinstall_handler)");
+  }
+#endif
+}