* *
* I N I T *
* *
- * $Revision: 1.1 $
- * *
* C Implementation File *
* *
- * Copyright (C) 1992-2001 Free Software Foundation, Inc. *
+ * Copyright (C) 1992-2005, Free Software Foundation, Inc. *
* *
* GNAT is free software; you can redistribute it and/or modify it under *
* terms of the GNU General Public License as published by the Free Soft- *
* file might be covered by the GNU Public License. *
* *
* GNAT was originally developed by the GNAT team at New York University. *
- * It is now maintained by Ada Core Technologies Inc (http://www.gnat.com). *
+ * Extensive contributions were provided by Ada Core Technologies Inc. *
* *
****************************************************************************/
installed by this file are used to handle resulting signals that come
from these probes failing (i.e. touching protected pages) */
+/* This file should be kept synchronized with 2sinit.ads, 2sinit.adb, and
+ 5zinit.adb. All these files implement the required functionality for
+ different targets. */
+
/* The following include is here to meet the published VxWorks requirement
that the __vxworks header appear before any other include. */
#ifdef __vxworks
#include "tconfig.h"
#include "tsystem.h"
#include <sys/stat.h>
+
+/* We don't have libiberty, so us malloc. */
+#define xmalloc(S) malloc (S)
#else
#include "config.h"
#include "system.h"
extern struct Exception_Data _abort_signal;
#define Lock_Task system__soft_links__lock_task
-extern void (*Lock_Task) PARAMS ((void));
+extern void (*Lock_Task) (void);
#define Unlock_Task system__soft_links__unlock_task
-extern void (*Unlock_Task) PARAMS ((void));
+extern void (*Unlock_Task) (void);
#define Get_Machine_State_Addr \
system__soft_links__get_machine_state_addr
-extern struct Machine_State *(*Get_Machine_State_Addr) PARAMS ((void));
+extern struct Machine_State *(*Get_Machine_State_Addr) (void);
#define Check_Abort_Status \
system__soft_links__check_abort_status
-extern int (*Check_Abort_Status) PARAMS ((void));
+extern int (*Check_Abort_Status) (void);
#define Raise_From_Signal_Handler \
ada__exceptions__raise_from_signal_handler
-extern void Raise_From_Signal_Handler PARAMS ((struct Exception_Data *,
- char *));
+extern void Raise_From_Signal_Handler (struct Exception_Data *, const char *);
#define Propagate_Signal_Exception \
__gnat_propagate_sig_exc
-extern void Propagate_Signal_Exception
- PARAMS ((struct Machine_State *, struct Exception_Data *, char *));
-
+extern void Propagate_Signal_Exception (struct Machine_State *,
+ struct Exception_Data *,
+ const char *);
/* Copies of global values computed by the binder */
-int __gl_main_priority = -1;
-int __gl_time_slice_val = -1;
-char __gl_wc_encoding = 'n';
-char __gl_locking_policy = ' ';
-char __gl_queuing_policy = ' ';
-char __gl_task_dispatching_policy = ' ';
-int __gl_unreserve_all_interrupts = 0;
-int __gl_exception_tracebacks = 0;
-
-/* Indication of whether synchronous signal handler has already been
+int __gl_main_priority = -1;
+int __gl_time_slice_val = -1;
+char __gl_wc_encoding = 'n';
+char __gl_locking_policy = ' ';
+char __gl_queuing_policy = ' ';
+char __gl_task_dispatching_policy = ' ';
+char *__gl_restrictions = 0;
+char *__gl_interrupt_states = 0;
+int __gl_num_interrupt_states = 0;
+int __gl_unreserve_all_interrupts = 0;
+int __gl_exception_tracebacks = 0;
+int __gl_zero_cost_exceptions = 0;
+int __gl_detect_blocking = 0;
+
+/* Indication of whether synchronous signal handler has already been
installed by a previous call to adainit */
int __gnat_handler_installed = 0;
at the end of this unit. */
#undef HAVE_GNAT_INIT_FLOAT
+/******************************/
+/* __gnat_get_interrupt_state */
+/******************************/
+
+char __gnat_get_interrupt_state (int);
+
+/* This routine is called from the runtime as needed to determine the state
+ of an interrupt, as set by an Interrupt_State pragma appearing anywhere
+ in the current partition. The input argument is the interrupt number,
+ and the result is one of the following:
+
+ 'n' this interrupt not set by any Interrupt_State pragma
+ 'u' Interrupt_State pragma set state to User
+ 'r' Interrupt_State pragma set state to Runtime
+ 's' Interrupt_State pragma set state to System */
+
+char
+__gnat_get_interrupt_state (int intrup)
+{
+ if (intrup >= __gl_num_interrupt_states)
+ return 'n';
+ else
+ return __gl_interrupt_states [intrup];
+}
+
/**********************/
/* __gnat_set_globals */
/**********************/
binder file is not in the shared library. Global references across library
boundaries like this are not handled correctly in all systems. */
+/* For detailed description of the parameters to this routine, see the
+ section titled Run-Time Globals in package Bindgen (bindgen.adb) */
+
void
-__gnat_set_globals (main_priority, time_slice_val, wc_encoding, locking_policy,
- queuing_policy, task_dispatching_policy, adafinal_ptr,
- unreserve_all_interrupts, exception_tracebacks)
- int main_priority;
- int time_slice_val;
- int wc_encoding;
- int locking_policy, queuing_policy, task_dispatching_policy;
- void (*adafinal_ptr) PARAMS ((void)) ATTRIBUTE_UNUSED;
- int unreserve_all_interrupts, exception_tracebacks;
+__gnat_set_globals (int main_priority,
+ int time_slice_val,
+ char wc_encoding,
+ char locking_policy,
+ char queuing_policy,
+ char task_dispatching_policy,
+ char *restrictions,
+ char *interrupt_states,
+ int num_interrupt_states,
+ int unreserve_all_interrupts,
+ int exception_tracebacks,
+ int zero_cost_exceptions,
+ int detect_blocking)
{
static int already_called = 0;
method. This default affects only Wide_Text_IO where no explicit
coding method is given, and there is no particular reason to let
this default be affected by the source representation of a library
- in any case.
+ in any case.
+
+ We do not check either for the consistency of exception tracebacks,
+ because exception tracebacks are not normally set in Stand-Alone
+ libraries. If a library or the main program set the exception
+ tracebacks, then they are never reset afterwards (see below).
The value of main_priority is meaningful only when we are invoked
from the main program elaboration routine of an Ada application.
if (already_called)
{
- if (__gl_locking_policy != locking_policy ||
- __gl_queuing_policy != queuing_policy ||
- __gl_task_dispatching_policy != task_dispatching_policy ||
- __gl_unreserve_all_interrupts != unreserve_all_interrupts ||
- __gl_exception_tracebacks != exception_tracebacks)
- {
- __gnat_raise_program_error (__FILE__, __LINE__);
- }
+ if (__gl_locking_policy != locking_policy
+ || __gl_queuing_policy != queuing_policy
+ || __gl_task_dispatching_policy != task_dispatching_policy
+ || __gl_unreserve_all_interrupts != unreserve_all_interrupts
+ || __gl_zero_cost_exceptions != zero_cost_exceptions)
+ __gnat_raise_program_error (__FILE__, __LINE__);
+
+ /* If either a library or the main program set the exception traceback
+ flag, it is never reset later */
+
+ if (exception_tracebacks != 0)
+ __gl_exception_tracebacks = exception_tracebacks;
+
return;
}
already_called = 1;
__gl_wc_encoding = wc_encoding;
__gl_locking_policy = locking_policy;
__gl_queuing_policy = queuing_policy;
+ __gl_restrictions = restrictions;
+ __gl_interrupt_states = interrupt_states;
+ __gl_num_interrupt_states = num_interrupt_states;
__gl_task_dispatching_policy = task_dispatching_policy;
__gl_unreserve_all_interrupts = unreserve_all_interrupts;
__gl_exception_tracebacks = exception_tracebacks;
+ __gl_detect_blocking = detect_blocking;
+
+ /* ??? __gl_zero_cost_exceptions is new in 3.15 and is referenced from
+ a-except.adb, which is also part of the compiler sources. Since the
+ compiler is built with an older release of GNAT, the call generated by
+ the old binder to this function does not provide any value for the
+ corresponding argument, so the global has to be initialized in some
+ reasonable other way. This could be removed as soon as the next major
+ release is out. */
+
+#ifdef IN_RTS
+ __gl_zero_cost_exceptions = zero_cost_exceptions;
+#else
+ __gl_zero_cost_exceptions = 0;
+ /* We never build the compiler to run in ZCX mode currently anyway. */
+#endif
}
/*********************/
at all; the intention is that this be replaced by system specific
code where initialization is required. */
+/* Notes on the Zero Cost Exceptions scheme and its impact on the signal
+ handlers implemented below :
+
+ What we call Zero Cost Exceptions is implemented using the GCC eh
+ circuitry, even if the underlying implementation is setjmp/longjmp
+ based. In any case ...
+
+ The GCC unwinder expects to be dealing with call return addresses, since
+ this is the "nominal" case of what we retrieve while unwinding a regular
+ call chain. To evaluate if a handler applies at some point in this chain,
+ the propagation engine needs to determine what region the corresponding
+ call instruction pertains to. The return address may not be attached to the
+ same region as the call, so the unwinder unconditionally substracts "some"
+ amount to the return addresses it gets to search the region tables. The
+ exact amount is computed to ensure that the resulting address is inside the
+ call instruction, and is thus target dependant (think about delay slots for
+ instance).
+
+ When we raise an exception from a signal handler, e.g. to transform a
+ SIGSEGV into Storage_Error, things need to appear as if the signal handler
+ had been "called" by the instruction which triggered the signal, so that
+ exception handlers that apply there are considered. What the unwinder will
+ retrieve as the return address from the signal handler is what it will find
+ as the faulting instruction address in the corresponding signal context
+ pushed by the kernel. Leaving this address untouched may loose, because if
+ the triggering instruction happens to be the very first of a region, the
+ later adjustments performed by the unwinder would yield an address outside
+ that region. We need to compensate for those adjustments at some point,
+ which we currently do in the GCC unwinding fallback macro.
+
+ The thread at http://gcc.gnu.org/ml/gcc-patches/2004-05/msg00343.html
+ describes a couple of issues with our current approach. Basically: on some
+ targets the adjustment to apply depends on the triggering signal, which is
+ not easily accessible from the macro, and we actually do not tackle this as
+ of today. Besides, other languages, e.g. Java, deal with this by performing
+ the adjustment in the signal handler before the raise, so our adjustments
+ may break those front-ends.
+
+ To have it all right, we should either find a way to deal with the signal
+ variants from the macro and convert Java on all targets (ugh), or remove
+ our macro adjustments and update our signal handlers a-la-java way. The
+ latter option appears the simplest, although some targets have their share
+ of subtleties to account for. See for instance the syscall(SYS_sigaction)
+ story in libjava/include/i386-signal.h. */
+
/***********************************/
-/* __gnat_initialize (AIX version) */
+/* __gnat_initialize (AIX Version) */
/***********************************/
#if defined (_AIX)
-/* AiX doesn't have SA_NODEFER */
+#include <signal.h>
+#include <sys/time.h>
+/* Some versions of AIX don't define SA_NODEFER. */
+
+#ifndef SA_NODEFER
#define SA_NODEFER 0
+#endif /* SA_NODEFER */
-#include <sys/time.h>
+/* Versions of AIX before 4.3 don't have nanosleep but provide
+ nsleep instead. */
-/* AiX doesn't have nanosleep, but provides nsleep instead */
+#ifndef _AIXVERSION_430
-extern int nanosleep PARAMS ((struct timestruc_t *, struct timestruc_t *));
-static void __gnat_error_handler PARAMS ((int));
+extern int nanosleep (struct timestruc_t *, struct timestruc_t *);
int
-nanosleep (Rqtp, Rmtp)
- struct timestruc_t *Rqtp, *Rmtp;
+nanosleep (struct timestruc_t *Rqtp, struct timestruc_t *Rmtp)
{
return nsleep (Rqtp, Rmtp);
}
-#include <signal.h>
+#endif /* _AIXVERSION_430 */
+
+static void __gnat_error_handler (int);
static void
-__gnat_error_handler (sig)
- int sig;
+__gnat_error_handler (int sig)
{
struct Exception_Data *exception;
- char *msg;
+ const char *msg;
switch (sig)
{
}
void
-__gnat_install_handler ()
+__gnat_install_handler (void)
{
struct sigaction act;
act.sa_handler = __gnat_error_handler;
act.sa_flags = SA_NODEFER | SA_RESTART;
- (void) sigemptyset (&act.sa_mask);
-
- (void) sigaction (SIGABRT, &act, NULL);
- (void) sigaction (SIGFPE, &act, NULL);
+ sigemptyset (&act.sa_mask);
+
+ /* Do not install handlers if interrupt state is "System" */
+ if (__gnat_get_interrupt_state (SIGABRT) != 's')
+ sigaction (SIGABRT, &act, NULL);
+ if (__gnat_get_interrupt_state (SIGFPE) != 's')
+ sigaction (SIGFPE, &act, NULL);
+ if (__gnat_get_interrupt_state (SIGILL) != 's')
+ sigaction (SIGILL, &act, NULL);
+ if (__gnat_get_interrupt_state (SIGSEGV) != 's')
+ sigaction (SIGSEGV, &act, NULL);
+ if (__gnat_get_interrupt_state (SIGBUS) != 's')
+ sigaction (SIGBUS, &act, NULL);
- if (__gl_unreserve_all_interrupts == 0)
- {
- (void) sigaction (SIGILL, &act, NULL);
- (void) sigaction (SIGSEGV, &act, NULL);
- (void) sigaction (SIGBUS, &act, NULL);
- }
__gnat_handler_installed = 1;
}
void
-__gnat_initialize ()
+__gnat_initialize (void *eh ATTRIBUTE_UNUSED)
+{
+}
+
+/***************************************/
+/* __gnat_initialize (RTEMS version) */
+/***************************************/
+
+#elif defined(__rtems__)
+
+extern void __gnat_install_handler (void);
+
+/* For RTEMS, each bsp will provide a custom __gnat_install_handler (). */
+
+void
+__gnat_initialize (void *eh ATTRIBUTE_UNUSED)
{
+ __gnat_install_handler ();
}
/****************************************/
-/* __gnat_initialize (Dec Unix version) */
+/* __gnat_initialize (Dec Unix Version) */
/****************************************/
#elif defined(__alpha__) && defined(__osf__) && ! defined(__alpha_vxworks)
#include <signal.h>
#include <sys/siginfo.h>
-static void __gnat_error_handler PARAMS ((int, siginfo_t *,
- struct sigcontext *));
-extern char *__gnat_get_code_loc PARAMS ((struct sigcontext *));
-extern void __gnat_enter_handler PARAMS ((struct sigcontext *, char *));
-extern size_t __gnat_machine_state_length PARAMS ((void));
+static void __gnat_error_handler (int, siginfo_t *, struct sigcontext *);
+extern char *__gnat_get_code_loc (struct sigcontext *);
+extern void __gnat_enter_handler (struct sigcontext *, char *);
+extern size_t __gnat_machine_state_length (void);
-extern long exc_lookup_gp PARAMS ((char *));
-extern void exc_resume PARAMS ((struct sigcontext *));
+extern long exc_lookup_gp (char *);
+extern void exc_resume (struct sigcontext *);
static void
-__gnat_error_handler (sig, sip, context)
- 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;
}
else
{
- /* See if the page before the faulting page is accessable. Do that
+ /* See if the page before the faulting page is accessible. Do that
by trying to access it. We'd like to simply try to access
4096 + the faulting address, but it's not guaranteed to be
the actual address, just to be on the same page. */
}
void
-__gnat_install_handler ()
+__gnat_install_handler (void)
{
struct sigaction act;
exceptions. Make sure that the handler isn't interrupted by another
signal that might cause a scheduling event! */
- act.sa_handler = (void (*) PARAMS ((int))) __gnat_error_handler;
- act.sa_flags = SA_ONSTACK | SA_RESTART | SA_NODEFER | SA_SIGINFO;
- (void) sigemptyset (&act.sa_mask);
-
- (void) sigaction (SIGABRT, &act, NULL);
- (void) sigaction (SIGFPE, &act, NULL);
-
- if (__gl_unreserve_all_interrupts == 0)
- {
- (void) sigaction (SIGILL, &act, NULL);
- (void) sigaction (SIGSEGV, &act, NULL);
- (void) sigaction (SIGBUS, &act, NULL);
- }
+ act.sa_handler = (void (*) (int)) __gnat_error_handler;
+ act.sa_flags = SA_RESTART | SA_NODEFER | SA_SIGINFO;
+ sigemptyset (&act.sa_mask);
+
+ /* Do not install handlers if interrupt state is "System" */
+ if (__gnat_get_interrupt_state (SIGABRT) != 's')
+ sigaction (SIGABRT, &act, NULL);
+ if (__gnat_get_interrupt_state (SIGFPE) != 's')
+ sigaction (SIGFPE, &act, NULL);
+ if (__gnat_get_interrupt_state (SIGILL) != 's')
+ sigaction (SIGILL, &act, NULL);
+ if (__gnat_get_interrupt_state (SIGSEGV) != 's')
+ sigaction (SIGSEGV, &act, NULL);
+ if (__gnat_get_interrupt_state (SIGBUS) != 's')
+ sigaction (SIGBUS, &act, NULL);
__gnat_handler_installed = 1;
}
void
-__gnat_initialize ()
+__gnat_initialize (void *eh ATTRIBUTE_UNUSED)
{
}
-/* Routines called by 5amastop.adb. */
+/* Routines called by s-mastop-tru64.adb. */
#define SC_GP 29
char *
-__gnat_get_code_loc (context)
- struct sigcontext *context;
+__gnat_get_code_loc (struct sigcontext *context)
{
return (char *) context->sc_pc;
}
void
-__gnat_enter_handler (context, pc)
- struct sigcontext *context;
- char *pc;
+__gnat_enter_handler (struct sigcontext *context, char *pc)
{
context->sc_pc = (long) pc;
context->sc_regs[SC_GP] = exc_lookup_gp (pc);
}
size_t
-__gnat_machine_state_length ()
+__gnat_machine_state_length (void)
{
return sizeof (struct sigcontext);
}
-/***********************************/
-/* __gnat_initialize (HPUX version) */
-/***********************************/
+/************************************/
+/* __gnat_initialize (HPUX Version) */
+/************************************/
-#elif defined (hpux)
+#elif defined (__hpux__)
#include <signal.h>
+#include <sys/ucontext.h>
+
+static void
+__gnat_error_handler (int sig, siginfo_t *siginfo, void *ucontext);
+
+/* __gnat_adjust_context_for_raise - see comments along with the default
+ version later in this file. */
+
+#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;
-static void __gnat_error_handler PARAMS ((int));
+ if (UseWideRegs (mcontext))
+ mcontext->ss_wide.ss_32.ss_pcoq_head_lo ++;
+ else
+ mcontext->ss_narrow.ss_pcoq_head ++;
+}
static void
-__gnat_error_handler (sig)
- int sig;
+__gnat_error_handler (int sig, siginfo_t *siginfo, void *ucontext)
{
struct Exception_Data *exception;
char *msg;
msg = "unhandled signal";
}
+ __gnat_adjust_context_for_raise (sig, ucontext);
+
Raise_From_Signal_Handler (exception, msg);
}
void
-__gnat_install_handler ()
+__gnat_install_handler (void)
{
struct sigaction act;
handled properly, avoiding a SEGV generation from stack usage by the
handler itself. */
- static char handler_stack [SIGSTKSZ];
+ static char handler_stack[SIGSTKSZ*2];
+ /* SIGSTKSZ appeared to be "short" for the needs in some contexts
+ (e.g. experiments with GCC ZCX exceptions). */
stack_t stack;
stack.ss_sp = handler_stack;
- stack.ss_size = SIGSTKSZ;
+ stack.ss_size = sizeof (handler_stack);
stack.ss_flags = 0;
- (void) sigaltstack (&stack, NULL);
+ sigaltstack (&stack, NULL);
- act.sa_handler = __gnat_error_handler;
- act.sa_flags = SA_NODEFER | SA_RESTART | SA_ONSTACK;
- (void) sigemptyset (&act.sa_mask);
+ act.sa_sigaction = __gnat_error_handler;
+ act.sa_flags = SA_NODEFER | SA_RESTART | SA_ONSTACK | SA_SIGINFO;
+ sigemptyset (&act.sa_mask);
- (void) sigaction (SIGABRT, &act, NULL);
- (void) sigaction (SIGFPE, &act, NULL);
+ /* Do not install handlers if interrupt state is "System" */
+ if (__gnat_get_interrupt_state (SIGABRT) != 's')
+ sigaction (SIGABRT, &act, NULL);
+ if (__gnat_get_interrupt_state (SIGFPE) != 's')
+ sigaction (SIGFPE, &act, NULL);
+ if (__gnat_get_interrupt_state (SIGILL) != 's')
+ sigaction (SIGILL, &act, NULL);
+ if (__gnat_get_interrupt_state (SIGSEGV) != 's')
+ sigaction (SIGSEGV, &act, NULL);
+ if (__gnat_get_interrupt_state (SIGBUS) != 's')
+ sigaction (SIGBUS, &act, NULL);
- if (__gl_unreserve_all_interrupts == 0)
- {
- (void) sigaction (SIGILL, &act, NULL);
- (void) sigaction (SIGSEGV, &act, NULL);
- (void) sigaction (SIGBUS, &act, NULL);
- }
__gnat_handler_installed = 1;
}
void
-__gnat_initialize ()
+__gnat_initialize (void *eh ATTRIBUTE_UNUSED)
{
}
-
-/*************************************/
-/* __gnat_initialize (Linux version) */
-/*************************************/
+/*****************************************/
+/* __gnat_initialize (GNU/Linux Version) */
+/*****************************************/
#elif defined (linux) && defined (i386) && !defined (__RT__)
#include <signal.h>
#include <asm/sigcontext.h>
-/* Linux with GNU libc does not define NULL in included header files */
+/* GNU/Linux, which uses glibc, does not define NULL in included
+ header files */
#if !defined (NULL)
#define NULL ((void *) 0)
unsigned long edi;
};
-static void __gnat_error_handler PARAMS ((int));
+static void __gnat_error_handler (int);
static void
-__gnat_error_handler (sig)
- int sig;
+__gnat_error_handler (int sig)
{
struct Exception_Data *exception;
- char *msg;
+ const char *msg;
static int recurse = 0;
struct sigcontext *info
= (struct sigcontext *) (((char *) &sig) + sizeof (int));
- /* Linux does not document how to get the machine state in a signal handler,
- but in fact the necessary data is in a sigcontext_struct value that is
- on the stack immediately above the signal number parameter, and the
- above messing accesses this value on the stack. */
+
+ /* The Linux kernel does not document how to get the machine state in a
+ signal handler, but in fact the necessary data is in a sigcontext_struct
+ value that is on the stack immediately above the signal number
+ parameter, and the above messing accesses this value on the stack. */
struct Machine_State *mstate;
msg = "unhandled signal";
}
- mstate = (*Get_Machine_State_Addr)();
+ mstate = (*Get_Machine_State_Addr) ();
if (mstate)
{
mstate->eip = info->eip;
}
void
-__gnat_install_handler ()
+__gnat_install_handler (void)
{
struct sigaction act;
act.sa_handler = __gnat_error_handler;
act.sa_flags = SA_NODEFER | SA_RESTART;
- (void) sigemptyset (&act.sa_mask);
-
- (void) sigaction (SIGABRT, &act, NULL);
- (void) sigaction (SIGFPE, &act, NULL);
+ sigemptyset (&act.sa_mask);
+
+ /* Do not install handlers if interrupt state is "System" */
+ if (__gnat_get_interrupt_state (SIGABRT) != 's')
+ sigaction (SIGABRT, &act, NULL);
+ if (__gnat_get_interrupt_state (SIGFPE) != 's')
+ sigaction (SIGFPE, &act, NULL);
+ if (__gnat_get_interrupt_state (SIGILL) != 's')
+ sigaction (SIGILL, &act, NULL);
+ if (__gnat_get_interrupt_state (SIGSEGV) != 's')
+ sigaction (SIGSEGV, &act, NULL);
+ if (__gnat_get_interrupt_state (SIGBUS) != 's')
+ sigaction (SIGBUS, &act, NULL);
- if (__gl_unreserve_all_interrupts == 0)
- {
- (void) sigaction (SIGILL, &act, NULL);
- (void) sigaction (SIGSEGV, &act, NULL);
- (void) sigaction (SIGBUS, &act, NULL);
- }
__gnat_handler_installed = 1;
}
void
-__gnat_initialize ()
+__gnat_initialize (void *eh ATTRIBUTE_UNUSED)
{
}
/******************************************/
-/* __gnat_initialize (NT-mingw32 version) */
+/* __gnat_initialize (NT-mingw32 Version) */
/******************************************/
#elif defined (__MINGW32__)
#include <windows.h>
-static LONG __gnat_error_handler PARAMS ((PEXCEPTION_POINTERS));
-
-/* __gnat_initialize (mingw32). */
-
-static LONG
-__gnat_error_handler (info)
- PEXCEPTION_POINTERS info;
-{
- static int recurse;
- struct Exception_Data *exception;
- char *msg;
-
- switch (info->ExceptionRecord->ExceptionCode)
- {
- case EXCEPTION_ACCESS_VIOLATION:
- /* If the failing address isn't maximally-aligned or if we've
- recursed, this is a program error. */
- if ((info->ExceptionRecord->ExceptionInformation[1] & 3) != 0
- || recurse)
- {
- exception = &program_error;
- msg = "EXCEPTION_ACCESS_VIOLATION";
- }
- else
- {
- /* See if the page before the faulting page is accessable. Do that
- by trying to access it. */
- recurse++;
- * ((volatile char *) (info->ExceptionRecord->ExceptionInformation[1]
- + 4096));
- exception = &storage_error;
- msg = "stack overflow (or erroneous memory access)";
- }
- break;
-
- case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
- exception = &constraint_error;
- msg = "EXCEPTION_ARRAY_BOUNDS_EXCEEDED";
- break;
-
- case EXCEPTION_DATATYPE_MISALIGNMENT:
- exception = &constraint_error;
- msg = "EXCEPTION_DATATYPE_MISALIGNMENT";
- break;
-
- case EXCEPTION_FLT_DENORMAL_OPERAND:
- exception = &constraint_error;
- msg = "EXCEPTION_FLT_DENORMAL_OPERAND";
- break;
-
- case EXCEPTION_FLT_DIVIDE_BY_ZERO:
- exception = &constraint_error;
- msg = "EXCEPTION_FLT_DENORMAL_OPERAND";
- break;
-
- case EXCEPTION_FLT_INVALID_OPERATION:
- exception = &constraint_error;
- msg = "EXCEPTION_FLT_INVALID_OPERATION";
- break;
-
- case EXCEPTION_FLT_OVERFLOW:
- exception = &constraint_error;
- msg = "EXCEPTION_FLT_OVERFLOW";
- break;
-
- case EXCEPTION_FLT_STACK_CHECK:
- exception = &program_error;
- msg = "EXCEPTION_FLT_STACK_CHECK";
- break;
-
- case EXCEPTION_FLT_UNDERFLOW:
- exception = &constraint_error;
- msg = "EXCEPTION_FLT_UNDERFLOW";
- break;
-
- case EXCEPTION_INT_DIVIDE_BY_ZERO:
- exception = &constraint_error;
- msg = "EXCEPTION_INT_DIVIDE_BY_ZERO";
- break;
-
- case EXCEPTION_INT_OVERFLOW:
- exception = &constraint_error;
- msg = "EXCEPTION_INT_OVERFLOW";
- break;
-
- case EXCEPTION_INVALID_DISPOSITION:
- exception = &program_error;
- msg = "EXCEPTION_INVALID_DISPOSITION";
- break;
-
- case EXCEPTION_NONCONTINUABLE_EXCEPTION:
- exception = &program_error;
- msg = "EXCEPTION_NONCONTINUABLE_EXCEPTION";
- break;
-
- case EXCEPTION_PRIV_INSTRUCTION:
- exception = &program_error;
- msg = "EXCEPTION_PRIV_INSTRUCTION";
- break;
-
- case EXCEPTION_SINGLE_STEP:
- exception = &program_error;
- msg = "EXCEPTION_SINGLE_STEP";
- break;
-
- case EXCEPTION_STACK_OVERFLOW:
- exception = &storage_error;
- msg = "EXCEPTION_STACK_OVERFLOW";
- break;
-
- default:
- exception = &program_error;
- msg = "unhandled signal";
- }
-
- recurse = 0;
- Raise_From_Signal_Handler (exception, msg);
-}
-
void
-__gnat_install_handler ()
+__gnat_install_handler (void)
{
- SetUnhandledExceptionFilter (__gnat_error_handler);
- __gnat_handler_installed = 1;
}
void
-__gnat_initialize ()
+__gnat_initialize (void *eh ATTRIBUTE_UNUSED)
{
-
/* Initialize floating-point coprocessor. This call is needed because
the MS libraries default to 64-bit precision instead of 80-bit
precision, and we require the full precision for proper operation,
given that we have set Max_Digits etc with this in mind */
-
__gnat_init_float ();
- /* initialize a lock for a process handle list - see a-adaint.c for the
+ /* Initialize a lock for a process handle list - see a-adaint.c for the
implementation of __gnat_portable_no_block_spawn, __gnat_portable_wait */
__gnat_plist_init();
+
+ /* Note that we do not activate this for the compiler itself to avoid a
+ bootstrap path problem. Older version of gnatbind will generate a call
+ to __gnat_initialize() without argument. Therefore we cannot use eh in
+ this case. It will be possible to remove the following #ifdef at some
+ point. */
+#ifdef IN_RTS
+ /* Install the Structured Exception handler. */
+ if (eh)
+ __gnat_install_SEH_handler (eh);
+#endif
}
-/**************************************/
-/* __gnat_initialize (Interix version) */
-/**************************************/
+/***************************************/
+/* __gnat_initialize (Interix Version) */
+/***************************************/
#elif defined (__INTERIX)
#include <signal.h>
-static void __gnat_error_handler PARAMS ((int));
+static void __gnat_error_handler (int);
static void
-__gnat_error_handler (sig)
- int sig;
+__gnat_error_handler (int sig)
{
struct Exception_Data *exception;
char *msg;
}
void
-__gnat_install_handler ()
+__gnat_install_handler (void)
{
struct sigaction act;
act.sa_handler = __gnat_error_handler;
act.sa_flags = 0;
- (void) sigemptyset (&act.sa_mask);
+ sigemptyset (&act.sa_mask);
/* Handlers for signals besides SIGSEGV cause c974013 to hang */
-/* (void) sigaction (SIGILL, &act, NULL); */
-/* (void) sigaction (SIGABRT, &act, NULL); */
-/* (void) sigaction (SIGFPE, &act, NULL); */
-/* (void) sigaction (SIGBUS, &act, NULL); */
- if (__gl_unreserve_all_interrupts == 0)
- {
- (void) sigaction (SIGSEGV, &act, NULL);
- }
+/* sigaction (SIGILL, &act, NULL); */
+/* sigaction (SIGABRT, &act, NULL); */
+/* sigaction (SIGFPE, &act, NULL); */
+/* sigaction (SIGBUS, &act, NULL); */
+
+ /* Do not install handlers if interrupt state is "System" */
+ if (__gnat_get_interrupt_state (SIGSEGV) != 's')
+ sigaction (SIGSEGV, &act, NULL);
+
__gnat_handler_installed = 1;
}
void
-__gnat_initialize ()
+__gnat_initialize (void *eh ATTRIBUTE_UNUSED)
{
__gnat_init_float ();
}
/**************************************/
-/* __gnat_initialize (LynxOS version) */
+/* __gnat_initialize (LynxOS Version) */
/**************************************/
#elif defined (__Lynx__)
void
-__gnat_initialize ()
+__gnat_initialize (void *eh ATTRIBUTE_UNUSED)
{
__gnat_init_float ();
}
/*********************************/
void
-__gnat_install_handler ()
+__gnat_install_handler (void)
{
__gnat_handler_installed = 1;
}
#elif defined (__EMX__) /* OS/2 dependent initialization */
void
-__gnat_initialize ()
+__gnat_initialize (void *eh ATTRIBUTE_UNUSED)
{
}
/*********************************/
void
-__gnat_install_handler ()
+__gnat_install_handler (void)
{
__gnat_handler_installed = 1;
}
/***********************************/
-/* __gnat_initialize (SGI version) */
+/* __gnat_initialize (SGI Version) */
/***********************************/
#elif defined (sgi)
sigcontext_t context;
};
-static void __gnat_error_handler PARAMS ((int, int, sigcontext_t *));
+static void __gnat_error_handler (int, int, sigcontext_t *);
+
+/* We are not setting the SA_SIGINFO bit in the sigaction flags when
+ connecting that handler, with the effects described in the sigaction
+ man page:
+
+ SA_SIGINFO [...]
+ If cleared and the signal is caught, the first argument is
+ also the signal number but the second argument is the signal
+ code identifying the cause of the signal. The third argument
+ points to a sigcontext_t structure containing the receiving
+ process's context when the signal was delivered.
+*/
static void
-__gnat_error_handler (sig, code, sc)
- int sig;
- int code;
- sigcontext_t *sc;
+__gnat_error_handler (int sig, int code, sigcontext_t *sc)
{
struct Machine_State *mstate;
struct Exception_Data *exception;
- char *msg;
-
- int i;
+ const char *msg;
switch (sig)
{
exception = &program_error; /* ??? storage_error ??? */
msg = "SIGSEGV: (Autogrow for file failed)";
}
- else if (code == EACCES)
+ else if (code == EACCES || code == EEXIST)
{
+ /* ??? We handle stack overflows here, some of which do trigger
+ SIGSEGV + EEXIST on Irix 6.5 although EEXIST is not part of
+ the documented valid codes for SEGV in the signal(5) man
+ page. */
+
/* ??? Re-add smarts to further verify that we launched
the stack into a guard page, not an attempt to
write to .text or something */
msg = "unhandled signal";
}
- mstate = (*Get_Machine_State_Addr)();
+ mstate = (*Get_Machine_State_Addr) ();
if (mstate != 0)
memcpy ((void *) mstate, (const void *) sc, sizeof (sigcontext_t));
Raise_From_Signal_Handler (exception, msg);
-
}
void
-__gnat_install_handler ()
+__gnat_install_handler (void)
{
- stack_t ss;
struct sigaction act;
/* Setup signal handler to map synchronous signals to appropriate
act.sa_handler = __gnat_error_handler;
act.sa_flags = SA_NODEFER + SA_RESTART;
- (void) sigfillset (&act.sa_mask);
- (void) sigemptyset (&act.sa_mask);
-
- (void) sigaction (SIGABRT, &act, NULL);
- (void) sigaction (SIGFPE, &act, NULL);
+ sigfillset (&act.sa_mask);
+ sigemptyset (&act.sa_mask);
+
+ /* Do not install handlers if interrupt state is "System" */
+ if (__gnat_get_interrupt_state (SIGABRT) != 's')
+ sigaction (SIGABRT, &act, NULL);
+ if (__gnat_get_interrupt_state (SIGFPE) != 's')
+ sigaction (SIGFPE, &act, NULL);
+ if (__gnat_get_interrupt_state (SIGILL) != 's')
+ sigaction (SIGILL, &act, NULL);
+ if (__gnat_get_interrupt_state (SIGSEGV) != 's')
+ sigaction (SIGSEGV, &act, NULL);
+ if (__gnat_get_interrupt_state (SIGBUS) != 's')
+ sigaction (SIGBUS, &act, NULL);
+ if (__gnat_get_interrupt_state (SIGADAABORT) != 's')
+ sigaction (SIGADAABORT, &act, NULL);
- if (__gl_unreserve_all_interrupts == 0)
- {
- (void) sigaction (SIGILL, &act, NULL);
- (void) sigaction (SIGSEGV, &act, NULL);
- (void) sigaction (SIGBUS, &act, NULL);
- }
- (void) sigaction (SIGADAABORT, &act, NULL);
__gnat_handler_installed = 1;
}
void
-__gnat_initialize ()
+__gnat_initialize (void *eh ATTRIBUTE_UNUSED)
{
}
/*************************************************/
-/* __gnat_initialize (Solaris and SunOS version) */
+/* __gnat_initialize (Solaris and SunOS Version) */
/*************************************************/
#elif defined (sun) && defined (__SVR4) && !defined (__vxworks)
#include <signal.h>
#include <siginfo.h>
-static void __gnat_error_handler PARAMS ((int, siginfo_t *));
+static void __gnat_error_handler (int, siginfo_t *);
static void
-__gnat_error_handler (sig, sip)
- int sig;
- siginfo_t *sip;
+__gnat_error_handler (int sig, siginfo_t *sip)
{
struct Exception_Data *exception;
static int recurse = 0;
- char *msg;
+ const char *msg;
/* If this was an explicit signal from a "kill", just resignal it. */
if (SI_FROMUSER (sip))
}
else
{
- /* See if the page before the faulting page is accessable. Do that
+ /* See if the page before the faulting page is accessible. Do that
by trying to access it. We'd like to simply try to access
4096 + the faulting address, but it's not guaranteed to be
the actual address, just to be on the same page. */
}
void
-__gnat_install_handler ()
+__gnat_install_handler (void)
{
struct sigaction act;
act.sa_handler = __gnat_error_handler;
act.sa_flags = SA_NODEFER | SA_RESTART | SA_SIGINFO;
- (void) sigemptyset (&act.sa_mask);
-
- (void) sigaction (SIGABRT, &act, NULL);
+ sigemptyset (&act.sa_mask);
+
+ /* Do not install handlers if interrupt state is "System" */
+ if (__gnat_get_interrupt_state (SIGABRT) != 's')
+ sigaction (SIGABRT, &act, NULL);
+ if (__gnat_get_interrupt_state (SIGFPE) != 's')
+ sigaction (SIGFPE, &act, NULL);
+ if (__gnat_get_interrupt_state (SIGSEGV) != 's')
+ sigaction (SIGSEGV, &act, NULL);
+ if (__gnat_get_interrupt_state (SIGBUS) != 's')
+ sigaction (SIGBUS, &act, NULL);
- if (__gl_unreserve_all_interrupts == 0)
- {
- (void) sigaction (SIGFPE, &act, NULL);
- (void) sigaction (SIGSEGV, &act, NULL);
- (void) sigaction (SIGBUS, &act, NULL);
- }
__gnat_handler_installed = 1;
}
void
-__gnat_initialize ()
+__gnat_initialize (void *eh ATTRIBUTE_UNUSED)
{
}
/***********************************/
-/* __gnat_initialize (SNI version) */
+/* __gnat_initialize (VMS Version) */
/***********************************/
-#elif defined (__sni__)
+#elif defined (VMS)
-/* SNI needs special defines and includes */
+#ifdef __IA64
+#define lib_get_curr_invo_context LIB$I64_GET_CURR_INVO_CONTEXT
+#define lib_get_prev_invo_context LIB$I64_GET_PREV_INVO_CONTEXT
+#define lib_get_invo_handle LIB$I64_GET_INVO_HANDLE
+#else
+#define lib_get_curr_invo_context LIB$GET_CURR_INVO_CONTEXT
+#define lib_get_prev_invo_context LIB$GET_PREV_INVO_CONTEXT
+#define lib_get_invo_handle LIB$GET_INVO_HANDLE
+#endif
-#define _XOPEN_SOURCE
-#define _POSIX_SOURCE
-#include <signal.h>
+#if defined (IN_RTS) && !defined (__IA64)
-extern size_t __gnat_getpagesize PARAMS ((void));
-static void __gnat_error_handler PARAMS ((int));
+/* The prehandler actually gets control first on a condition. It swaps the
+ stack pointer and calls the handler (__gnat_error_handler). */
+extern long __gnat_error_prehandler (void);
-/* The run time needs this function which is a #define in SNI */
+extern char *__gnat_error_prehandler_stack; /* Alternate signal stack */
+#endif
-size_t
-__gnat_getpagesize ()
-{
- return getpagesize ();
-}
+/* Conditions that don't have an Ada exception counterpart must raise
+ Non_Ada_Error. Since this is defined in s-auxdec, it should only be
+ referenced by user programs, not the compiler or tools. Hence the
+ #ifdef IN_RTS. */
-static void
-__gnat_error_handler (sig)
- int sig;
-{
- struct Exception_Data *exception;
- char *msg;
+#ifdef IN_RTS
+#define Non_Ada_Error system__aux_dec__non_ada_error
+extern struct Exception_Data Non_Ada_Error;
- switch (sig)
- {
- case SIGSEGV:
- /* FIXME: we need to detect the case of a *real* SIGSEGV */
- exception = &storage_error;
- msg = "stack overflow or erroneous memory access";
- break;
+#define Coded_Exception system__vms_exception_table__coded_exception
+extern struct Exception_Data *Coded_Exception (Exception_Code);
- case SIGBUS:
- exception = &constraint_error;
- msg = "SIGBUS";
- break;
+#define Base_Code_In system__vms_exception_table__base_code_in
+extern Exception_Code Base_Code_In (Exception_Code);
+#endif
- case SIGFPE:
- exception = &constraint_error;
- msg = "SIGFPE";
- break;
+/* Define macro symbols for the VMS conditions that become Ada exceptions.
+ Most of these are also defined in the header file ssdef.h which has not
+ yet been converted to be recognized by Gnu C. Some, which couldn't be
+ located, are assigned names based on the DEC test suite tests which
+ raise them. */
- default:
- exception = &program_error;
- msg = "unhandled signal";
- }
+#define SS$_ACCVIO 12
+#define SS$_DEBUG 1132
+#define SS$_INTDIV 1156
+#define SS$_HPARITH 1284
+#define SS$_STKOVF 1364
+#define SS$_RESIGNAL 2328
+#define MTH$_FLOOVEMAT 1475268 /* Some ACVC_21 CXA tests */
+#define SS$_CE24VRU 3253636 /* Write to unopened file */
+#define SS$_C980VTE 3246436 /* AST requests time slice */
+#define CMA$_EXIT_THREAD 4227492
+#define CMA$_EXCCOPLOS 4228108
+#define CMA$_ALERTED 4227460
- Raise_From_Signal_Handler (exception, msg);
-}
+struct descriptor_s {unsigned short len, mbz; char *adr; };
-void
-__gnat_install_handler ()
-{
- struct sigaction act;
+long __gnat_error_handler (int *, void *);
- /* Set up signal handler to map synchronous signals to appropriate
- exceptions. Make sure that the handler isn't interrupted by another
- signal that might cause a scheduling event! */
+/* To deal with VMS conditions and their mapping to Ada exceptions,
+ the __gnat_error_handler routine below is installed as an exception
+ vector having precedence over DEC frame handlers. Some conditions
+ still need to be handled by such handlers, however, in which case
+ __gnat_error_handler needs to return SS$_RESIGNAL. Consider for
+ instance the use of a third party library compiled with DECAda and
+ performing its own exception handling internally.
- act.sa_handler = __gnat_error_handler;
- act.sa_flags = SA_NODEFER | SA_RESTART;
- (void) sigemptyset (&act.sa_mask);
+ To allow some user-level flexibility, which conditions should be
+ resignaled is controlled by a predicate function, provided with the
+ condition value and returning a boolean indication stating whether
+ this condition should be resignaled or not.
- (void) sigaction (SIGABRT, &act, NULL);
- (void) sigaction (SIGFPE, &act, NULL);
+ That predicate function is called indirectly, via a function pointer,
+ by __gnat_error_handler, and changing that pointer is allowed to the
+ the user code by way of the __gnat_set_resignal_predicate interface.
- if (__gl_unreserve_all_interrupts == 0)
- {
- (void) sigaction (SIGILL, &act, NULL);
- (void) sigaction (SIGSEGV, &act, NULL);
- (void) sigaction (SIGBUS, &act, NULL);
- }
- __gnat_handler_installed = 1;
-}
+ The user level function may then implement what it likes, including
+ for instance the maintenance of a dynamic data structure if the set
+ of to be resignalled conditions has to change over the program's
+ lifetime.
-void
-__gnat_initialize ()
-{
-}
+ ??? This is not a perfect solution to deal with the possible
+ interactions between the GNAT and the DECAda exception handling
+ models and better (more general) schemes are studied. This is so
+ just provided as a convenient workaround in the meantime, and
+ should be use with caution since the implementation has been kept
+ very simple. */
-/***********************************/
-/* __gnat_initialize (VMS version) */
-/***********************************/
+typedef int
+resignal_predicate (int code);
-#elif defined (VMS)
+/* Default GNAT predicate for resignaling conditions. */
-/* The prehandler actually gets control first on a condition. It swaps the
- stack pointer and calls the handler (__gnat_error_handler). */
-extern long __gnat_error_prehandler ();
-
-extern char *__gnat_error_prehandler_stack; /* Alternate signal stack */
-
-/* Conditions that don't have an Ada exception counterpart must raise
- Non_Ada_Error. Since this is defined in s-auxdec, it should only be
- referenced by user programs, not the compiler or tools. Hence the
- #ifdef IN_RTS. */
-
-#ifdef IN_RTS
-#define Non_Ada_Error system__aux_dec__non_ada_error
-extern struct Exception_Data Non_Ada_Error;
-
-#define Coded_Exception system__vms_exception_table__coded_exception
-extern struct Exception_Data *Coded_Exception (int);
-#endif
+static int
+__gnat_default_resignal_p (int code)
+{
+ return
+ code == CMA$_EXIT_THREAD
+ || code == SS$_DEBUG /* Gdb attach, resignal to merge activate gdbstub. */
+ || code == 1409786 /* Nickerson bug #33 ??? */
+ || code == 1381050 /* Nickerson bug #33 ??? */
+ || code == 20480426 /* RDB-E-STREAM_EOF */
+ || code == 11829410 /* Resignalled as Use_Error for CE10VRC */
+ ;
+}
-/* Define macro symbols for the VMS conditions that become Ada exceptions.
- Most of these are also defined in the header file ssdef.h which has not
- yet been converted to be recoginized by Gnu C. Some, which couldn't be
- located, are assigned names based on the DEC test suite tests which
- raise them. */
+/* Static pointer to predicate that the __gnat_error_handler exception
+ vector invokes to determine if it should resignal a condition. */
-#define SS$_ACCVIO 12
-#define SS$_DEBUG 1132
-#define SS$_INTDIV 1156
-#define SS$_HPARITH 1284
-#define SS$_STKOVF 1364
-#define SS$_RESIGNAL 2328
-#define MTH$_FLOOVEMAT 1475268 /* Some ACVC_21 CXA tests */
-#define SS$_CE24VRU 3253636 /* Write to unopened file */
-#define SS$_C980VTE 3246436 /* AST requests time slice */
-#define CMA$_EXIT_THREAD 4227492
-#define CMA$_EXCCOPLOS 4228108
-#define CMA$_ALERTED 4227460
+static resignal_predicate * __gnat_resignal_p = __gnat_default_resignal_p;
-struct descriptor_s {unsigned short len, mbz; char *adr; };
+/* User interface to change the predicate pointer to PREDICATE. Reset to
+ the default if PREDICATE is null. */
-static long __gnat_error_handler PARAMS ((int *, void *));
+void
+__gnat_set_resignal_predicate (resignal_predicate * predicate)
+{
+ if (predicate == 0)
+ __gnat_resignal_p = __gnat_default_resignal_p;
+ else
+ __gnat_resignal_p = predicate;
+}
-static long
-__gnat_error_handler (sigargs, mechargs)
- int *sigargs;
- void *mechargs;
+long
+__gnat_error_handler (int *sigargs, void *mechargs)
{
struct Exception_Data *exception = 0;
+ Exception_Code base_code;
+
char *msg = "";
- char message [256];
+ char message[256];
long prvhnd;
struct descriptor_s msgdesc;
int msg_flag = 0x000f; /* 1 bit for each of the four message parts */
unsigned short outlen;
- char curr_icb [544];
+ char curr_icb[544];
long curr_invo_handle;
long *mstate;
- /* Resignaled condtions aren't effected by by pragma Import_Exception */
-
- switch (sigargs[1])
- {
-
- case CMA$_EXIT_THREAD:
- return SS$_RESIGNAL;
-
- case SS$_DEBUG: /* Gdb attach, resignal to merge activate gdbstub. */
- return SS$_RESIGNAL;
-
- case 1409786: /* Nickerson bug #33 ??? */
- return SS$_RESIGNAL;
-
- case 1381050: /* Nickerson bug #33 ??? */
- return SS$_RESIGNAL;
-
- case 11829410: /* Resignalled as Use_Error for CE10VRC */
- return SS$_RESIGNAL;
-
- }
+ /* Check for conditions to resignal which aren't effected by pragma
+ Import_Exception. */
+ if (__gnat_resignal_p (sigargs [1]))
+ return SS$_RESIGNAL;
#ifdef IN_RTS
- /* See if it's an imported exception. Mask off severity bits. */
- exception = Coded_Exception (sigargs [1] & 0xfffffff8);
+ /* See if it's an imported exception. Beware that registered exceptions
+ are bound to their base code, with the severity bits masked off. */
+ base_code = Base_Code_In ((Exception_Code) sigargs [1]);
+ exception = Coded_Exception (base_code);
+
if (exception)
{
msgdesc.len = 256;
msgdesc.mbz = 0;
msgdesc.adr = message;
SYS$GETMSG (sigargs[1], &outlen, &msgdesc, msg_flag, 0);
- message [outlen] = 0;
+ message[outlen] = 0;
msg = message;
exception->Name_Length = 19;
/* The full name really should be get sys$getmsg returns. ??? */
exception->Full_Name = "IMPORTED_EXCEPTION";
- exception->Import_Code = sigargs [1] & 0xfffffff8;
+ exception->Import_Code = base_code;
}
#endif
msgdesc.mbz = 0;
msgdesc.adr = message;
SYS$GETMSG (sigargs[1], &outlen, &msgdesc, msg_flag, 0);
- message [outlen] = 0;
+ message[outlen] = 0;
msg = message;
break;
}
mstate = (long *) (*Get_Machine_State_Addr) ();
if (mstate != 0)
{
- LIB$GET_CURR_INVO_CONTEXT (&curr_icb);
- LIB$GET_PREV_INVO_CONTEXT (&curr_icb);
- LIB$GET_PREV_INVO_CONTEXT (&curr_icb);
- curr_invo_handle = LIB$GET_INVO_HANDLE (&curr_icb);
+ lib_get_curr_invo_context (&curr_icb);
+ lib_get_prev_invo_context (&curr_icb);
+ lib_get_prev_invo_context (&curr_icb);
+ curr_invo_handle = lib_get_invo_handle (&curr_icb);
*mstate = curr_invo_handle;
}
Raise_From_Signal_Handler (exception, msg);
}
void
-__gnat_install_handler ()
+__gnat_install_handler (void)
{
long prvhnd;
+#if defined (IN_RTS) && !defined (__IA64)
char *c;
- c = (char *) malloc (1025);
+ c = (char *) xmalloc (2049);
- __gnat_error_prehandler_stack = &c[1024];
+ __gnat_error_prehandler_stack = &c[2048];
/* __gnat_error_prehandler is an assembly function. */
SYS$SETEXV (1, __gnat_error_prehandler, 3, &prvhnd);
+#else
+ SYS$SETEXV (1, __gnat_error_handler, 3, &prvhnd);
+#endif
__gnat_handler_installed = 1;
}
void
-__gnat_initialize()
+__gnat_initialize(void *eh ATTRIBUTE_UNUSED)
{
}
-/***************************************/
-/* __gnat_initialize (VXWorks version) */
-/***************************************/
+/*************************************************/
+/* __gnat_initialize (FreeBSD version) */
+/*************************************************/
-#elif defined(__vxworks)
+#elif defined (__FreeBSD__)
#include <signal.h>
-#include <taskLib.h>
-#include <intLib.h>
-#include <iv.h>
+#include <unistd.h>
-static void __gnat_init_handler PARAMS ((int));
-extern int __gnat_inum_to_ivec PARAMS ((int));
-static void __gnat_error_handler PARAMS ((int, int, struct sigcontext *));
+static void __gnat_error_handler (int, int, struct sigcontext *);
static void
-__gnat_int_handler (interr)
- int interr;
-{
- /* Note that we should use something like Raise_From_Int_Handler here, but
- for now Raise_From_Signal_Handler will do the job. ??? */
-
- Raise_From_Signal_Handler (&storage_error, "stack overflow");
-}
-
-/* Used for stack-checking on VxWorks. Must be task-local in
- tasking programs */
-
-void *__gnat_stack_limit = NULL;
-
-#ifndef __alpha_vxworks
-
-/* getpid is used by s-parint.adb, but is not defined by VxWorks, except
- on Alpha VxWorks */
-
-extern long getpid PARAMS ((void));
-
-long
-getpid ()
-{
- return taskIdSelf ();
-}
-#endif
-
-/* This is needed by the GNAT run time to handle Vxworks interrupts */
-int
-__gnat_inum_to_ivec (num)
- int num;
-{
- return INUM_TO_IVEC (num);
-}
-
-static void
-__gnat_error_handler (sig, code, sc)
- int sig;
- int code;
- struct sigcontext *sc;
+__gnat_error_handler (int sig, int code __attribute__ ((unused)),
+ struct sigcontext *sc __attribute__ ((unused)))
{
struct Exception_Data *exception;
- sigset_t mask;
- int result;
- char *msg;
-
- /* VxWorks will always mask out the signal during the signal handler and
- will reenable it on a longjmp. GNAT does not generate a longjmp to
- return from a signal handler so the signal will still be masked unless
- we unmask it. */
- (void) sigprocmask (SIG_SETMASK, NULL, &mask);
- sigdelset (&mask, sig);
- (void) sigprocmask (SIG_SETMASK, &mask, NULL);
-
- /* VxWorks will suspend the task when it gets a hardware exception. We
- take the liberty of resuming the task for the application. */
- if (taskIsSuspended (taskIdSelf ()) != 0)
- (void) taskResume (taskIdSelf ());
+ const char *msg;
switch (sig)
{
exception = &constraint_error;
msg = "SIGFPE";
break;
+
case SIGILL:
exception = &constraint_error;
msg = "SIGILL";
break;
+
case SIGSEGV:
- exception = &program_error;
- msg = "SIGSEGV";
+ exception = &storage_error;
+ msg = "stack overflow or erroneous memory access";
break;
+
case SIGBUS:
- exception = &program_error;
+ exception = &constraint_error;
msg = "SIGBUS";
break;
+
default:
exception = &program_error;
msg = "unhandled signal";
{
struct sigaction act;
- /* Setup signal handler to map synchronous signals to appropriate
+ /* Set up signal handler to map synchronous signals to appropriate
exceptions. Make sure that the handler isn't interrupted by another
signal that might cause a scheduling event! */
act.sa_handler = __gnat_error_handler;
- act.sa_flags = SA_SIGINFO | SA_ONSTACK;
+ act.sa_flags = SA_NODEFER | SA_RESTART;
(void) sigemptyset (&act.sa_mask);
+ (void) sigaction (SIGILL, &act, NULL);
(void) sigaction (SIGFPE, &act, NULL);
-
- if (__gl_unreserve_all_interrupts == 0)
- {
- (void) sigaction (SIGILL, &act, NULL);
- (void) sigaction (SIGSEGV, &act, NULL);
- (void) sigaction (SIGBUS, &act, NULL);
- }
- __gnat_handler_installed = 1;
+ (void) sigaction (SIGSEGV, &act, NULL);
+ (void) sigaction (SIGBUS, &act, NULL);
}
-#define HAVE_GNAT_INIT_FLOAT
-
void
-__gnat_init_float ()
+__gnat_initialize (void *eh ATTRIBUTE_UNUSED)
{
-#if defined (_ARCH_PPC) && !defined (_SOFT_FLOAT)
- /* Disable overflow/underflow exceptions on the PPC processor, this is needed
- to get correct Ada semantic */
- asm ("mtfsb0 25");
- asm ("mtfsb0 26");
-#endif
-}
+ __gnat_install_handler ();
-void
-__gnat_initialize ()
-{
- TASK_DESC pTaskDesc;
-
- if (taskInfoGet (taskIdSelf (), &pTaskDesc) != OK)
- printErr ("Cannot get task info");
-
- __gnat_stack_limit = (void *) pTaskDesc.td_pStackLimit;
-
- __gnat_init_float ();
-
-#ifdef __mips_vxworks
-#if 0
- /* For now remove this handler, since it is causing interferences with gdb */
-
- /* Connect the overflow trap directly to the __gnat_int_handler routine
- as it is not converted to a signal by VxWorks. */
-
- intConnect (INUM_TO_IVEC (IV_TRAP_VEC), &__gnat_int_handler, IV_TRAP_VEC);
-#endif
-#endif
+ /* XXX - Initialize floating-point coprocessor. This call is
+ needed because FreeBSD defaults to 64-bit precision instead
+ of 80-bit precision? We require the full precision for
+ proper operation, given that we have set Max_Digits etc
+ with this in mind */
+ __gnat_init_float ();
}
-
/***************************************/
-/* __gnat_initialize (default version) */
+/* __gnat_initialize (VXWorks Version) */
/***************************************/
-/* Get the stack unwinding mechanism when available and when compiling
- a-init.c for the run time. Except in the case of a restricted run-time,
- such as RT-Linux modules (__RT__ is defined). */
+#elif defined(__vxworks)
-#elif defined (IN_RTS) && !defined (__RT__)
+#include <signal.h>
+#include <taskLib.h>
+#include <intLib.h>
+#include <iv.h>
-/* If we have a definition of INCOMING_RETURN_ADDR_RTX, assume that
- the rest of the DWARF 2 frame unwind support is also provided. */
-#if !defined (DWARF2_UNWIND_INFO) && defined (INCOMING_RETURN_ADDR_RTX)
-#define DWARF2_UNWIND_INFO 1
+#ifdef VTHREADS
+#include "private/vThreadsP.h"
#endif
-#ifdef DWARF2_UNWIND_INFO
-#include "frame.h"
+extern int __gnat_inum_to_ivec (int);
+static void __gnat_error_handler (int, int, struct sigcontext *);
+void __gnat_map_signal (int);
-struct machine_state
-{
- frame_state f1, f2, f3;
- frame_state *udata, *udata_start, *sub_udata;
- void *pc, *pc_start, *new_pc;
-};
-
-typedef int word_type __attribute__ ((mode (__word__)));
-
-/* This type is used in get_reg and put_reg to deal with ABIs where a void*
- is smaller than a word, such as the Irix 6 n32 ABI. We cast twice to
- avoid a warning about casting between int and pointer of different
- sizes. */
-
-typedef int ptr_type __attribute__ ((mode (pointer)));
-
-static void get_reg PARAMS ((unsigned int, frame_state *,
- frame_state *));
-static void put_reg PARAMS ((unsigned int, void *,
- frame_state *));
-static void copy_reg PARAMS ((unsigned int, frame_state *,
- frame_state *));
-static inline void put_return_addr PARAMS ((void *, frame_state *));
-static inline void *get_return_addr PARAMS ((frame_state *,
- frame_state *));
-static frame_state *__frame_state_for_r PARAMS ((void *, frame_state *));
-
-#ifdef INCOMING_REGNO
-static int in_reg_window PARAMS ((unsigned int, frame_state *));
-#endif
+#ifndef __alpha_vxworks
-extern void __gnat_pop_frame PARAMS ((struct machine_state *));
-extern void __gnat_set_machine_state PARAMS ((struct machine_state *));
-extern void __gnat_enter_handler PARAMS ((struct machine_state *,
- void *));
-extern __SIZE_TYPE__ __gnat_machine_state_length PARAMS ((void));
-extern void *__gnat_get_code_loc PARAMS ((struct machine_state *));
+/* getpid is used by s-parint.adb, but is not defined by VxWorks, except
+ on Alpha VxWorks */
-/* Get the value of register REG as saved in UDATA, where SUB_UDATA is a
- frame called by UDATA or 0. */
+extern long getpid (void);
-static void *
-get_reg (reg, udata, sub_udata)
- unsigned int reg;
- frame_state *udata, *sub_udata;
+long
+getpid (void)
{
- if (udata->saved[reg] == REG_SAVED_OFFSET)
- return
- (void *) (ptr_type) *(word_type *) (udata->cfa
- + udata->reg_or_offset[reg]);
- else if (udata->saved[reg] == REG_SAVED_REG && sub_udata)
- return get_reg (udata->reg_or_offset[reg], sub_udata, 0);
- else
- abort ();
+ return taskIdSelf ();
}
+#endif
-/* Overwrite the saved value for register REG in frame UDATA with VAL. */
-
-static void
-put_reg (reg, val, udata)
- unsigned int reg;
- void *val;
- frame_state *udate;
+/* This is needed by the GNAT run time to handle Vxworks interrupts */
+int
+__gnat_inum_to_ivec (int num)
{
- if (udata->saved[reg] == REG_SAVED_OFFSET)
- *(word_type *) (udata->cfa + udata->reg_or_offset[reg])
- = (word_type) (ptr_type) val;
- else
- abort ();
+ return INUM_TO_IVEC (num);
}
-/* Copy the saved value for register REG from frame UDATA to frame
- TARGET_UDATA. Unlike the previous two functions, this can handle
- registers that are not one word large. */
-
-static void
-copy_reg (reg, udata, target_udata)
- unsigned int reg;
- frame_state *udate, *target_udata;
+/* VxWorks expects the field excCnt to be zeroed when a signal is handled.
+ The VxWorks version of longjmp does this; gcc's builtin_longjmp does not */
+void
+__gnat_clear_exception_count (void)
{
- if (udata->saved[reg] == REG_SAVED_OFFSET
- && target_udata->saved[reg] == REG_SAVED_OFFSET)
- memcpy (target_udata->cfa + target_udata->reg_or_offset[reg],
- udata->cfa + udata->reg_or_offset[reg],
- __builtin_dwarf_reg_size (reg));
- else
- abort ();
-}
+#ifdef VTHREADS
+ WIND_TCB *currentTask = (WIND_TCB *) taskIdSelf();
-/* Overwrite the return address for frame UDATA with VAL. */
-
-static inline void
-put_return_addr (val, udata)
- void *val;
- frame_state *udata;
-{
- val = __builtin_frob_return_addr (val);
- put_reg (udata->retaddr_column, val, udata);
+ currentTask->vThreads.excCnt = 0;
+#endif
}
-#ifdef INCOMING_REGNO
-
-/* Is the saved value for register REG in frame UDATA stored in a register
- window in the previous frame? */
-
-static int
-in_reg_window (reg, udata)
- unsigned int reg;
- frame_state *udata;
+/* Exported to 5zintman.adb in order to handle different signal
+ to exception mappings in different VxWorks versions */
+void
+__gnat_map_signal (int sig)
{
- if (udata->saved[reg] != REG_SAVED_OFFSET)
- return 0;
+ struct Exception_Data *exception;
+ char *msg;
-#ifdef STACK_GROWS_DOWNWARD
- return udata->reg_or_offset[reg] > 0;
+ switch (sig)
+ {
+ case SIGFPE:
+ exception = &constraint_error;
+ msg = "SIGFPE";
+ break;
+#ifdef VTHREADS
+ case SIGILL:
+ exception = &constraint_error;
+ msg = "Floating point exception or SIGILL";
+ break;
+ case SIGSEGV:
+ exception = &storage_error;
+ msg = "SIGSEGV: possible stack overflow";
+ break;
+ case SIGBUS:
+ exception = &storage_error;
+ msg = "SIGBUS: possible stack overflow";
+ break;
#else
- return udata->reg_or_offset[reg] < 0;
+ case SIGILL:
+ exception = &constraint_error;
+ msg = "SIGILL";
+ break;
+ case SIGSEGV:
+ exception = &program_error;
+ msg = "SIGSEGV";
+ break;
+ case SIGBUS:
+ exception = &program_error;
+ msg = "SIGBUS";
+ break;
#endif
-}
-#endif /* INCOMING_REGNO */
+ default:
+ exception = &program_error;
+ msg = "unhandled signal";
+ }
-/* Retrieve the return address for frame UDATA, where SUB_UDATA is a
- frame called by UDATA or 0. */
+ __gnat_clear_exception_count ();
+ Raise_From_Signal_Handler (exception, msg);
+}
-static inline void *
-get_return_addr (udata, sub_udata)
- frame_state *udate, *sub_udata;
+static void
+__gnat_error_handler (int sig, int code, struct sigcontext *sc)
{
- return __builtin_extract_return_addr (get_reg (udata->retaddr_column,
- udata, sub_udata));
-}
+ sigset_t mask;
+ int result;
-/* Thread-safe version of __frame_state_for */
+ /* VxWorks will always mask out the signal during the signal handler and
+ will reenable it on a longjmp. GNAT does not generate a longjmp to
+ return from a signal handler so the signal will still be masked unless
+ we unmask it. */
+ sigprocmask (SIG_SETMASK, NULL, &mask);
+ sigdelset (&mask, sig);
+ sigprocmask (SIG_SETMASK, &mask, NULL);
-static frame_state *
-__frame_state_for_r (void *pc_target, frame_state *state_in)
- void *pc_target;
- frame_state *state_in;
-{
- frame_state *f;
+ __gnat_map_signal (sig);
- (*Lock_Task) ();
- f = __frame_state_for (pc_target, state_in);
- (*Unlock_Task) ();
- return f;
}
-/* Given the current frame UDATA and its return address PC, return the
- information about the calling frame in CALLER_UDATA. */
-
void
-__gnat_pop_frame (m)
- struct machine_state *m;
+__gnat_install_handler (void)
{
- frame_state *p;
+ struct sigaction act;
- int i;
+ /* Setup signal handler to map synchronous signals to appropriate
+ exceptions. Make sure that the handler isn't interrupted by another
+ signal that might cause a scheduling event! */
- m->pc = m->new_pc;
- p = m->udata;
- if (! __frame_state_for_r (m->pc, m->sub_udata))
- {
- m->new_pc = 0;
- return;
- }
+ act.sa_handler = __gnat_error_handler;
+ act.sa_flags = SA_SIGINFO | SA_ONSTACK;
+ sigemptyset (&act.sa_mask);
- /* Now go back to our caller's stack frame. If our caller's CFA register
- was saved in our stack frame, restore it; otherwise, assume the CFA
- register is SP and restore it to our CFA value. */
- if (m->udata->saved[m->sub_udata->cfa_reg])
- m->sub_udata->cfa = get_reg (m->sub_udata->cfa_reg, m->udata, 0);
- else
- m->sub_udata->cfa = m->udata->cfa;
- m->sub_udata->cfa += m->sub_udata->cfa_offset;
+ /* For VxWorks, install all signal handlers, since pragma Interrupt_State
+ applies to vectored hardware interrupts, not signals */
+ sigaction (SIGFPE, &act, NULL);
+ sigaction (SIGILL, &act, NULL);
+ sigaction (SIGSEGV, &act, NULL);
+ sigaction (SIGBUS, &act, NULL);
- m->udata = m->sub_udata;
- m->sub_udata = p;
- m->new_pc = get_return_addr (m->udata, m->sub_udata) - 1;
+ __gnat_handler_installed = 1;
+}
- return;
+#define HAVE_GNAT_INIT_FLOAT
-/* ??? disable this code for now since it doesn't work properly */
-#if 0
- if (m->pc == m->pc_start)
- return;
+void
+__gnat_init_float (void)
+{
+ /* Disable overflow/underflow exceptions on the PPC processor, this is needed
+ to get correct Ada semantics. Note that for AE653 vThreads, the HW
+ overflow settings are an OS configuration issue. The instructions
+ below have no effect */
+#if defined (_ARCH_PPC) && !defined (_SOFT_FLOAT) && !defined (VTHREADS)
+ asm ("mtfsb0 25");
+ asm ("mtfsb0 26");
+#endif
- /* Copy the frame's saved register values into our register save slots. */
+ /* Similarly for sparc64. Achieved by masking bits in the Trap Enable Mask
+ field of the Floating-point Status Register (see the Sparc Architecture
+ Manual Version 9, p 48). */
+#if defined (sparc64)
- for (i = 0; i < FIRST_PSEUDO_REGISTER; ++i)
- if (i != m->udata->retaddr_column && m->udata->saved[i])
- {
-#ifdef INCOMING_REGNO
- /* If you modify the saved value of the return address
- register on the SPARC, you modify the return address for
- your caller's frame. Don't do that here, as it will
- confuse get_return_addr. */
- if (in_reg_window (i, m->udata)
- && m->udata->saved[m->udata->retaddr_column] == REG_SAVED_REG
- && m->udata->reg_or_offset[m->udata->retaddr_column] == i)
- continue;
-#endif
- copy_reg (i, m->udata, m->udata_start);
- }
+#define FSR_TEM_NVM (1 << 27) /* Invalid operand */
+#define FSR_TEM_OFM (1 << 26) /* Overflow */
+#define FSR_TEM_UFM (1 << 25) /* Underflow */
+#define FSR_TEM_DZM (1 << 24) /* Division by Zero */
+#define FSR_TEM_NXM (1 << 23) /* Inexact result */
+ {
+ unsigned int fsr;
+
+ __asm__("st %%fsr, %0" : "=m" (fsr));
+ fsr &= ~(FSR_TEM_OFM | FSR_TEM_UFM);
+ __asm__("ld %0, %%fsr" : : "m" (fsr));
+ }
#endif
}
void
-__gnat_set_machine_state (machine_state)
- struct machine_state *machine_state;
+__gnat_initialize (void *eh ATTRIBUTE_UNUSED)
{
- frame_state sub_udata;
-
- /* Start at our stack frame. */
-label:
- machine_state->udata = &machine_state->f1;
- machine_state->sub_udata = &machine_state->f2;
- machine_state->udata_start = &machine_state->f3;
-
- if (! __frame_state_for_r (&&label, machine_state->udata))
- return;
-
- /* We need to get the value from the CFA register. At this point in
- compiling libgnat.a we don't know whether or not we will use the frame
- pointer register for the CFA, so we check our unwind info. */
- if (machine_state->udata->cfa_reg == __builtin_dwarf_fp_regnum ())
- machine_state->udata->cfa = __builtin_fp ();
- else
- machine_state->udata->cfa = __builtin_sp ();
- machine_state->udata->cfa += machine_state->udata->cfa_offset;
+ __gnat_init_float ();
- memcpy (machine_state->udata_start, machine_state->udata,
- sizeof (frame_state));
- machine_state->new_pc =
- machine_state->pc_start =
- machine_state->pc = &&label;
+ /* On targets where we might be using the ZCX scheme, we need to register
+ the frame tables.
+
+ For applications loaded as a set of "modules", the crtstuff objects
+ linked in (crtbegin/end) are tailored to provide this service a-la C++
+ constructor fashion, typically triggered by the VxWorks loader. This is
+ achieved by way of a special variable declaration in the crt object, the
+ name of which has been deduced by analyzing the output of the "munching"
+ step documented for C++. The de-registration is handled symetrically,
+ a-la C++ destructor fashion and typically triggered by the dynamic
+ unloader. Note that since the tables shall be registered against a
+ common datastructure, libgcc should be one of the modules (vs beeing
+ partially linked against all the others at build time) and shall be
+ loaded first.
+
+ For applications linked with the kernel, the scheme above would lead to
+ duplicated symbols because the VxWorks kernel build "munches" by default.
+ To prevent those conflicts, we link against crtbegin/endS objects that
+ don't include the special variable and directly call the appropriate
+ function here. We'll never unload that, so there is no de-registration to
+ worry about.
+
+ For whole applications loaded as a single module, we may use one scheme
+ or the other, except for the mixed Ada/C++ case in which the first scheme
+ would fail for the same reason as in the linked-with-kernel situation.
+
+ We can differentiate by looking at the __module_has_ctors value provided
+ by each class of crt objects. As of today, selecting the crt set with the
+ ctors/dtors capabilities (first scheme above) is triggered by adding
+ "-dynamic" to the gcc *link* command line options. Selecting the other
+ set of crt objects is achieved by "-static" instead.
+
+ This is a first approach, tightly synchronized with a number of GCC
+ configuration and crtstuff changes. We need to ensure that those changes
+ are there to activate this circuitry. */
+
+#if (__GNUC__ >= 3) && (defined (_ARCH_PPC) || defined (__ppc))
+ {
+ /* The scheme described above is only useful for the actual ZCX case, and
+ we don't want any reference to the crt provided symbols otherwise. We
+ may not link with any of the crt objects in the non-ZCX case, e.g. from
+ documented procedures instructing the use of -nostdlib, and references
+ to the ctors symbols here would just remain unsatisfied.
+
+ We have no way to avoid those references in the right conditions in this
+ C module, because we have nothing like a IN_ZCX_RTS macro. This aspect
+ is then deferred to an Ada routine, which can do that based on a test
+ against a constant System flag value. */
+
+ extern void __gnat_vxw_setup_for_eh (void);
+ __gnat_vxw_setup_for_eh ();
+ }
+#endif
+}
- /* Do any necessary initialization to access arbitrary stack frames.
- On the SPARC, this means flushing the register windows. */
- __builtin_unwind_init ();
+/********************************/
+/* __gnat_initialize for NetBSD */
+/********************************/
- /* go up one frame */
- __gnat_pop_frame (machine_state);
-}
+#elif defined(__NetBSD__)
-void
-__gnat_enter_handler (m, handler)
- struct machine_state *m;
- void *handler;
-{
- void *retaddr;
-
-#ifdef INCOMING_REGNO
- /* we need to update the saved return address register from
- the last frame we unwind, or the handler frame will have the wrong
- return address. */
- if (m->udata->saved[m->udata->retaddr_column] == REG_SAVED_REG)
- {
- int i = m->udata->reg_or_offset[m->udata->retaddr_column];
- if (in_reg_window (i, m->udata))
- copy_reg (i, m->udata, m->udata_start);
- }
-#endif
+#include <signal.h>
+#include <unistd.h>
- /* Emit the stub to adjust sp and jump to the handler. */
- retaddr = __builtin_eh_stub ();
+static void
+__gnat_error_handler (int sig)
+{
+ struct Exception_Data *exception;
+ const char *msg;
- /* And then set our return address to point to the stub. */
- if (m->udata_start->saved[m->udata_start->retaddr_column] ==
- REG_SAVED_OFFSET)
- put_return_addr (retaddr, m->udata_start);
- else
- __builtin_set_return_addr_reg (retaddr);
-
- /* Set up the registers we use to communicate with the stub.
- We check STACK_GROWS_DOWNWARD so the stub can use adjust_stack. */
- __builtin_set_eh_regs
- (handler,
-#ifdef STACK_GROWS_DOWNWARD
- m->udata->cfa - m->udata_start->cfa
-#else
- m->udata_start->cfa - m->udata->cfa
-#endif
- + m->udata->args_size);
+ switch(sig)
+ {
+ case SIGFPE:
+ exception = &constraint_error;
+ msg = "SIGFPE";
+ break;
+ case SIGILL:
+ exception = &constraint_error;
+ msg = "SIGILL";
+ break;
+ case SIGSEGV:
+ exception = &storage_error;
+ msg = "stack overflow or erroneous memory access";
+ break;
+ case SIGBUS:
+ exception = &constraint_error;
+ msg = "SIGBUS";
+ break;
+ default:
+ exception = &program_error;
+ msg = "unhandled signal";
+ }
- /* Epilogue: restore the handler frame's register values and return
- to the stub. */
+ Raise_From_Signal_Handler(exception, msg);
}
-__SIZE_TYPE__
-__gnat_machine_state_length ()
+void
+__gnat_install_handler(void)
{
- return sizeof (struct machine_state);
+ struct sigaction act;
+
+ act.sa_handler = __gnat_error_handler;
+ act.sa_flags = SA_NODEFER | SA_RESTART;
+ sigemptyset (&act.sa_mask);
+
+ /* Do not install handlers if interrupt state is "System" */
+ if (__gnat_get_interrupt_state (SIGFPE) != 's')
+ sigaction (SIGFPE, &act, NULL);
+ if (__gnat_get_interrupt_state (SIGILL) != 's')
+ sigaction (SIGILL, &act, NULL);
+ if (__gnat_get_interrupt_state (SIGSEGV) != 's')
+ sigaction (SIGSEGV, &act, NULL);
+ if (__gnat_get_interrupt_state (SIGBUS) != 's')
+ sigaction (SIGBUS, &act, NULL);
+
+ __gnat_handler_installed = 1;
}
-void *
-__gnat_get_code_loc (m)
- struct machine_state *m;
+void
+__gnat_initialize (void *eh ATTRIBUTE_UNUSED)
{
- return m->pc;
+ __gnat_install_handler ();
+ __gnat_init_float ();
}
-#endif /* DWARF2_UNWIND_INFO */
#else
installation do nothing */
/***************************************/
-/* __gnat_initialize (default version) */
+/* __gnat_initialize (Default Version) */
/***************************************/
void
-__gnat_initialize ()
+__gnat_initialize (void *eh ATTRIBUTE_UNUSED)
{
}
/********************************************/
-/* __gnat_install_handler (default version) */
+/* __gnat_install_handler (Default Version) */
/********************************************/
void
-__gnat_install_handler ()
+__gnat_install_handler (void)
{
__gnat_handler_installed = 1;
}
#endif
-
/*********************/
/* __gnat_init_float */
/*********************/
WIN32 and could be used under OS/2 */
#if defined (_WIN32) || defined (__INTERIX) || defined (__EMX__) \
- || defined (__Lynx__)
+ || defined (__Lynx__) || defined(__NetBSD__) || defined(__FreeBSD__)
#define HAVE_GNAT_INIT_FLOAT
void
-__gnat_init_float ()
+__gnat_init_float (void)
{
#if defined (__i386__) || defined (i386)
}
#endif
-
#ifndef HAVE_GNAT_INIT_FLOAT
/* All targets without a specific __gnat_init_float will use an empty one */
void
-__gnat_init_float ()
+__gnat_init_float (void)
{
}
#endif
+
+/***********************************/
+/* __gnat_adjust_context_for_raise */
+/***********************************/
+
+#ifndef HAVE_GNAT_ADJUST_CONTEXT_FOR_RAISE
+
+/* All targets without a specific version will use an empty one */
+
+/* UCONTEXT is a pointer to a context structure received by a signal handler
+ about to propagate an exception. Adjust it to compensate the fact that the
+ generic unwinder thinks the corresponding PC is a call return address. */
+
+void
+__gnat_adjust_context_for_raise (int signo ATTRIBUTE_UNUSED,
+ void *ucontext ATTRIBUTE_UNUSED)
+{
+ /* The point is that the interrupted context PC typically is the address
+ that we should search an EH region for, which is different from the call
+ return address case. The target independant part of the GCC unwinder
+ don't differentiate the two situations, so we compensate here for the
+ adjustments it will blindly make.
+
+ signo is passed because on some targets for some signals the PC in
+ context points to the instruction after the faulting one, in which case
+ the unwinder adjustment is still desired. */
+
+ /* On a number of targets, we have arranged for the adjustment to be
+ performed by the MD_FALLBACK_FRAME_STATE circuitry, so we don't provide a
+ specific instance of this routine. The MD_FALLBACK doesn't have access
+ to the signal number, though, so the compensation is systematic there and
+ might be wrong in some cases. */
+
+ /* Having the compensation wrong leads to potential failures. A very
+ typical case is what happens when there is no compensation and a signal
+ triggers for the first instruction in a region : the unwinder adjustment
+ has it search in the wrong EH region. */
+}
+
+#endif
OSDN Git Service
