}
static void
-__gnat_error_handler
- (int sig, siginfo_t *sip, struct sigcontext *context)
+__gnat_error_handler (int sig, siginfo_t *sip, struct sigcontext *context)
{
struct Exception_Data *exception;
static int recurse = 0;
}
recurse = 0;
- Raise_From_Signal_Handler (exception, (char *) msg);
+ Raise_From_Signal_Handler (exception, (const char *) msg);
}
void
/* GNU/Linux Section */
/*********************/
-#elif defined (linux) && (defined (i386) || defined (__x86_64__) \
- || defined (__ia64__) || defined (__powerpc__))
+#elif defined (linux)
#include <signal.h>
{
mcontext_t *mcontext = &((ucontext_t *) ucontext)->uc_mcontext;
- /* On the i386 and x86-64 architectures, stack checking is performed by
+ /* On the i386 and x86-64 architectures, we specifically detect calls to
+ the null address and entirely fold the not-yet-fully-established frame
+ to prevent it from stopping the unwinding.
+
+ On the i386 and x86-64 architectures, stack checking is performed by
means of probes with moving stack pointer, that is to say the probed
address is always the value of the stack pointer. Upon hitting the
guard page, the stack pointer therefore points to an inaccessible
time this happens. */
#if defined (i386)
- unsigned long pattern = *(unsigned long *)mcontext->gregs[REG_EIP];
+ unsigned long *pc = (unsigned long *)mcontext->gregs[REG_EIP];
+ /* The call insn pushes the return address onto the stack. Pop it. */
+ if (pc == NULL)
+ {
+ mcontext->gregs[REG_EIP] = *(unsigned long *)mcontext->gregs[REG_ESP];
+ mcontext->gregs[REG_ESP] += 4;
+ }
/* The pattern is "orl $0x0,(%esp)" for a probe in 32-bit mode. */
- if (signo == SIGSEGV && pattern == 0x00240c83)
+ else if (signo == SIGSEGV && *pc == 0x00240c83)
mcontext->gregs[REG_ESP] += 4096 + 4 * sizeof (unsigned long);
#elif defined (__x86_64__)
- unsigned long pattern = *(unsigned long *)mcontext->gregs[REG_RIP];
+ unsigned long *pc = (unsigned long *)mcontext->gregs[REG_RIP];
+ /* The call insn pushes the return address onto the stack. Pop it. */
+ if (pc == NULL)
+ {
+ mcontext->gregs[REG_RIP] = *(unsigned long *)mcontext->gregs[REG_RSP];
+ mcontext->gregs[REG_RSP] += 8;
+ }
/* The pattern is "orq $0x0,(%rsp)" for a probe in 64-bit mode. */
- if (signo == SIGSEGV && (pattern & 0xffffffffff) == 0x00240c8348)
+ else if (signo == SIGSEGV && (*pc & 0xffffffffff) == 0x00240c8348)
mcontext->gregs[REG_RSP] += 4096 + 4 * sizeof (unsigned long);
#elif defined (__ia64__)
/* ??? The IA-64 unwinder doesn't compensate for signals. */
void *ucontext)
{
struct Exception_Data *exception;
- const char *msg;
static int recurse = 0;
+ const char *msg;
+
+ /* Adjusting is required for every fault context, so adjust for this one
+ now, before we possibly trigger a recursive fault below. */
+ __gnat_adjust_context_for_raise (sig, ucontext);
switch (sig)
{
exception = &program_error;
msg = "unhandled signal";
}
- recurse = 0;
-
- /* We adjust the interrupted context here (and not in the fallback
- unwinding routine) because recent versions of the Native POSIX
- Thread Library (NPTL) are compiled with unwind information, so
- the fallback routine is never executed for signal frames. */
- __gnat_adjust_context_for_raise (sig, ucontext);
+ recurse = 0;
Raise_From_Signal_Handler (exception, msg);
}
/* Likewise regarding how the "instruction pointer" register slot can
be identified in signal machine contexts. We have either "REG_PC"
or "PC" at hand, depending on the target CPU and Solaris version. */
-
#if !defined (REG_PC)
#define REG_PC PC
#endif
-static void __gnat_error_handler (int, siginfo_t *, ucontext_t *);
+static void __gnat_error_handler (int, siginfo_t *, void *);
+
+#define HAVE_GNAT_ADJUST_CONTEXT_FOR_RAISE
+
+void
+__gnat_adjust_context_for_raise (int signo ATTRIBUTE_UNUSED, void *ucontext)
+{
+ mcontext_t *mcontext = &((ucontext_t *) ucontext)->uc_mcontext;
+ unsigned long *pc = (unsigned long *)mcontext->gregs[REG_PC];
+
+ /* We specifically detect calls to the null address and entirely fold
+ the not-yet-fully-established frame to prevent it from stopping the
+ unwinding. */
+ if (pc == NULL)
+#if defined (__sparc)
+ /* The call insn moves the return address into %o7. Move it back. */
+ mcontext->gregs[REG_PC] = mcontext->gregs[REG_O7];
+#elif defined (i386)
+ {
+ /* The call insn pushes the return address onto the stack. Pop it. */
+ mcontext->gregs[REG_PC] = *(unsigned long *)mcontext->gregs[UESP];
+ mcontext->gregs[UESP] += 4;
+ }
+#elif defined (__x86_64__)
+ {
+ /* The call insn pushes the return address onto the stack. Pop it. */
+ mcontext->gregs[REG_PC] = *(unsigned long *)mcontext->gregs[REG_RSP];
+ mcontext->gregs[REG_RSP] += 8;
+ }
+#else
+#error architecture not supported on Solaris
+#endif
+}
static void
-__gnat_error_handler (int sig, siginfo_t *sip, ucontext_t *cx ATTRIBUTE_UNUSED)
+__gnat_error_handler (int sig, siginfo_t *sip, void *ucontext)
{
struct Exception_Data *exception;
static int recurse = 0;
const char *msg;
- /* If this was an explicit signal from a "kill", just resignal it. */
- if (SI_FROMUSER (sip))
- {
- signal (sig, SIG_DFL);
- kill (getpid(), sig);
- }
+ /* Adjusting is required for every fault context, so adjust for this one
+ now, before we possibly trigger a recursive fault below. */
+ __gnat_adjust_context_for_raise (sig, ucontext);
- /* Otherwise, treat it as something we handle. */
switch (sig)
{
case SIGSEGV:
much too hard to do anything else and we're just determining
which exception to raise. */
if (sip->si_code == SEGV_ACCERR
+ || (long) sip->si_addr == 0
|| (((long) sip->si_addr) & 3) != 0
|| recurse)
{
}
recurse = 0;
-
Raise_From_Signal_Handler (exception, msg);
}
msg = "SIGFPE";
break;
#ifdef VTHREADS
+#ifdef __VXWORKSMILS__
+ case SIGILL:
+ exception = &storage_error;
+ msg = "SIGILL: possible stack overflow";
+ break;
+ case SIGSEGV:
+ exception = &storage_error;
+ msg = "SIGSEGV";
+ break;
+ case SIGBUS:
+ exception = &program_error;
+ msg = "SIGBUS";
+ break;
+#else
case SIGILL:
exception = &constraint_error;
msg = "Floating point exception or SIGILL";
exception = &storage_error;
msg = "SIGBUS: possible stack overflow";
break;
+#endif
#elif (_WRS_VXWORKS_MAJOR == 6)
case SIGILL:
exception = &constraint_error;
#elif defined(__APPLE__)
#include <signal.h>
+#include <sys/syscall.h>
#include <mach/mach_vm.h>
#include <mach/mach_init.h>
#include <mach/vm_statistics.h>
static void __gnat_error_handler (int sig, siginfo_t * si, void * uc);
-/* Defined in xnu unix_signal.c */
+/* Defined in xnu unix_signal.c.
+ Tell the kernel to re-use alt stack when delivering a signal. */
#define UC_RESET_ALT_STACK 0x80000000
-extern int sigreturn (void *uc, int flavour);
/* Return true if ADDR is within a stack guard area. */
static int
msg = "erroneous memory access";
}
/* Reset the use of alt stack, so that the alt stack will be used
- for the next signal delivery. */
- sigreturn (NULL, UC_RESET_ALT_STACK);
+ for the next signal delivery.
+ The stack can't be used in case of stack checking. */
+ syscall (SYS_sigreturn, NULL, UC_RESET_ALT_STACK);
break;
case SIGFPE:
{
/* We used to compensate here for the raised from call vs raised from signal
exception discrepancy with the GCC ZCX scheme, but this now can be dealt
- with generically in the unwinder (see GCC PR other/26208). Only the VMS
- ports still do the compensation described in the few lines below.
+ with generically in the unwinder (see GCC PR other/26208). This however
+ requires the use of the _Unwind_GetIPInfo routine in raise-gcc.c, which
+ is predicated on the definition of HAVE_GETIPINFO at compile time. Only
+ the VMS ports still do the compensation described in the few lines below.
*** Call vs signal exception discrepancy with GCC ZCX scheme ***
OSDN Git Service
