From f385ad6639380eb6dfa8b8eb4a5ba65dd12db744 Mon Sep 17 00:00:00 2001
From: Khem Raj <raj.khem@gmail.com>
Date: Fri, 25 Mar 2022 13:43:19 -0700
Subject: [PATCH] mcontext is not a standard layout so glibc and musl differ

This is already applied to libsigsegv upstream, hopefully next version
of grep will update its internal copy and we can drop this patch

Upstream-Status: Backport [https://git.savannah.gnu.org/gitweb/?p=libsigsegv.git;a=commitdiff;h=a6ff69873110c0a8ba6f7fd90532dbc11224828c]

Signed-off-by: Khem Raj <raj.khem@gmail.com>
---
 lib/sigsegv.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/lib/sigsegv.c b/lib/sigsegv.c
index 998c827..b6f4841 100644
--- a/lib/sigsegv.c
+++ b/lib/sigsegv.c
@@ -219,8 +219,8 @@ int libsigsegv_version = LIBSIGSEGV_VERSION;
 #   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]
+#   if ! defined __GLIBC__
+#    define SIGSEGV_FAULT_STACKPOINTER  ((ucontext_t *) ucp)->uc_regs->gregs[1]
 #   else
 #    define SIGSEGV_FAULT_STACKPOINTER  ((ucontext_t *) ucp)->uc_mcontext.uc_regs->gregs[1]
 #   endif
-- 
2.35.1

