* *
* I N I T *
* *
- * $Revision: 1.2 $
- * *
* C Implementation File *
* *
- * Copyright (C) 1992-2001 Free Software Foundation, Inc. *
+ * Copyright (C) 1992-2006, 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- *
* 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 distributed with GNAT; see file COPYING. If not, write *
- * to the Free Software Foundation, 59 Temple Place - Suite 330, Boston, *
- * MA 02111-1307, USA. *
+ * to the Free Software Foundation, 51 Franklin Street, Fifth Floor, *
+ * Boston, MA 02110-1301, USA. *
* *
* As a special exception, if you link this file with other files to *
* produce an executable, this file does not by itself cause the resulting *
* 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,
+ s-init-ae653-cert.adb and s-init-xi-sparc.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 void __gnat_raise_program_error (const char *, int);
-/* Addresses of exception data blocks for predefined exceptions. */
+/* Addresses of exception data blocks for predefined exceptions. Tasking_Error
+ is not used in this unit, and the abort signal is only used on IRIX. */
extern struct Exception_Data constraint_error;
extern struct Exception_Data numeric_error;
extern struct Exception_Data program_error;
extern struct Exception_Data storage_error;
-extern struct Exception_Data tasking_error;
-extern struct Exception_Data _abort_signal;
-
-#define Lock_Task system__soft_links__lock_task
-extern void (*Lock_Task) PARAMS ((void));
-
-#define Unlock_Task system__soft_links__unlock_task
-extern void (*Unlock_Task) PARAMS ((void));
-
-#define Get_Machine_State_Addr \
- system__soft_links__get_machine_state_addr
-extern struct Machine_State *(*Get_Machine_State_Addr) PARAMS ((void));
-
-#define Check_Abort_Status \
- system__soft_links__check_abort_status
-extern int (*Check_Abort_Status) PARAMS ((void));
+/* For the Cert run time we use the regular raise exception routine because
+ Raise_From_Signal_Handler is not available. */
+#ifdef CERT
+#define Raise_From_Signal_Handler \
+ __gnat_raise_exception
+extern void Raise_From_Signal_Handler (struct Exception_Data *, const char *);
+#else
#define Raise_From_Signal_Handler \
ada__exceptions__raise_from_signal_handler
-extern void Raise_From_Signal_Handler PARAMS ((struct Exception_Data *,
- char *));
-
-#define Propagate_Signal_Exception \
- __gnat_propagate_sig_exc
-extern void Propagate_Signal_Exception
- PARAMS ((struct Machine_State *, struct Exception_Data *, 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
+extern void Raise_From_Signal_Handler (struct Exception_Data *, const char *);
+#endif
+
+/* 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 = ' ';
+char *__gl_priority_specific_dispatching = 0;
+int __gl_num_specific_dispatching = 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;
+int __gl_default_stack_size = -1;
+
+/* Indication of whether synchronous signal handler has already been
installed by a previous call to adainit */
int __gnat_handler_installed = 0;
+#ifndef IN_RTS
+int __gnat_inside_elab_final_code = 0;
+/* ??? This variable is obsolete since 2001-08-29 but is kept to allow
+ bootstrap from old GNAT versions (< 3.15). */
+#endif
+
/* HAVE_GNAT_INIT_FLOAT must be set on every targets where a __gnat_init_float
is defined. If this is not set them a void implementation will be defined
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_get_specific_dispatching */
+/***********************************/
+
+char __gnat_get_specific_dispatching (int);
+
+/* This routine is called from the run time as needed to determine the
+ priority specific dispatching policy, as set by a
+ Priority_Specific_Dispatching pragma appearing anywhere in the current
+ partition. The input argument is the priority number, and the result is
+ the upper case first character of the policy name, e.g. 'F' for
+ FIFO_Within_Priorities. A space ' ' is returned if no
+ Priority_Specific_Dispatching pragma is used in the partition. */
+
+char
+__gnat_get_specific_dispatching (int priority)
+{
+ if (__gl_num_specific_dispatching == 0)
+ return ' ';
+ else if (priority >= __gl_num_specific_dispatching)
+ return 'F';
+ else
+ return __gl_priority_specific_dispatching [priority];
+}
+
+#ifndef IN_RTS
+
/**********************/
/* __gnat_set_globals */
/**********************/
-/* This routine is called from the binder generated main program. It copies
- the values for global quantities computed by the binder into the following
- global locations. The reason that we go through this copy, rather than just
- define the global locations in the binder generated file, is that they are
- referenced from the runtime, which may be in a shared library, and the
- binder file is not in the shared library. Global references across library
- boundaries like this are not handled correctly in all systems. */
+/* This routine is kept for boostrapping purposes, since the binder generated
+ file now sets the __gl_* variables directly. */
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 ()
{
- static int already_called = 0;
-
- /* If this procedure has been already called once, check that the
- arguments in this call are consistent with the ones in the previous
- calls. Otherwise, raise a Program_Error exception.
-
- We do not check for consistency of the wide character encoding
- 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.
-
- The value of main_priority is meaningful only when we are invoked
- from the main program elaboration routine of an Ada application.
- Checking the consistency of this parameter should therefore not be
- done. Since it is assured that the main program elaboration will
- always invoke this procedure before any library elaboration
- routine, only the value of main_priority during the first call
- should be taken into account and all the subsequent ones should be
- ignored. Note that the case where the main program is not written
- in Ada is also properly handled, since the default value will then
- be used for this parameter.
-
- For identical reasons, the consistency of time_slice_val should not
- be checked. */
-
- 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__);
- }
- return;
- }
- already_called = 1;
-
- __gl_main_priority = main_priority;
- __gl_time_slice_val = time_slice_val;
- __gl_wc_encoding = wc_encoding;
- __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_initialize */
-/*********************/
-
-/* __gnat_initialize is called at the start of execution of an Ada program
- (the call is generated by the binder). The standard routine does nothing
- at all; the intention is that this be replaced by system specific
- code where initialization is required. */
+#endif
-/***********************************/
-/* __gnat_initialize (AIX version) */
-/***********************************/
+/* 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 subtracts "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 dependent (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 used to 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 the fallback based compensation approach.
+ First, on some targets the adjustment to apply depends on the triggering
+ signal, which is not easily accessible from the macro. Besides, other
+ languages, e.g. Java, deal with this by performing the adjustment in the
+ signal handler before the raise, so fallback adjustments just break those
+ front-ends.
+
+ We now follow the Java way for most targets, via adjust_context_for_raise
+ below. */
+
+/***************/
+/* AIX Section */
+/***************/
#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 (Dec Unix version) */
-/****************************************/
+/*****************/
+/* Tru64 section */
+/*****************/
-#elif defined(__alpha__) && defined(__osf__) && ! defined(__alpha_vxworks)
-
-/* Note: it seems that __osf__ is defined for the Alpha VXWorks case. Not
- clear that this is reasonable, but in any case we have to be sure to
- exclude this case in the above test. */
+#elif defined(__alpha__) && defined(__osf__)
#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));
-
-extern long exc_lookup_gp PARAMS ((char *));
-extern void exc_resume PARAMS ((struct sigcontext *));
+static void __gnat_error_handler (int, siginfo_t *, struct sigcontext *);
+extern char *__gnat_get_code_loc (struct sigcontext *);
+extern void __gnat_set_code_loc (struct sigcontext *, char *);
+extern size_t __gnat_machine_state_length (void);
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 ATTRIBUTE_UNUSED)
{
struct Exception_Data *exception;
static int recurse = 0;
- struct sigcontext *mstate;
const char *msg;
/* If this was an explicit signal from a "kill", just resignal it. */
}
recurse = 0;
- mstate = (struct sigcontext *) (*Get_Machine_State_Addr) ();
- if (mstate != 0)
- *mstate = *context;
-
Raise_From_Signal_Handler (exception, (char *) msg);
}
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 ()
-{
-}
-
-/* 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_set_code_loc (struct sigcontext *context, char *pc)
{
context->sc_pc = (long) pc;
- context->sc_regs[SC_GP] = exc_lookup_gp (pc);
- exc_resume (context);
}
+
size_t
-__gnat_machine_state_length ()
+__gnat_machine_state_length (void)
{
return sizeof (struct sigcontext);
}
-/***********************************/
-/* __gnat_initialize (HPUX version) */
-/***********************************/
+/********************/
+/* PA HP-UX section */
+/********************/
-#elif defined (hpux)
+#elif defined (__hppa__) && 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 ATTRIBUTE_UNUSED, void *ucontext)
{
struct Exception_Data *exception;
- char *msg;
+ const char *msg;
switch (sig)
{
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 (GNU/Linux version) */
-/*************************************/
+/*********************/
+/* GNU/Linux Section */
+/*********************/
-#elif defined (linux) && defined (i386) && !defined (__RT__)
+#elif defined (linux) && (defined (i386) || defined (__x86_64__) \
+ || defined (__ia64__))
#include <signal.h>
-#include <asm/sigcontext.h>
+
+#define __USE_GNU 1 /* required to get REG_EIP/RIP from glibc's ucontext.h */
+#include <sys/ucontext.h>
/* GNU/Linux, which uses glibc, does not define NULL in included
header files */
#define NULL ((void *) 0)
#endif
-struct Machine_State
+#if defined (MaRTE)
+
+/* MaRTE OS provides its own version of sigaction, sigfillset, and
+ sigemptyset (overriding these symbol names). We want to make sure that
+ the versions provided by the underlying C library are used here (these
+ versions are renamed by MaRTE to linux_sigaction, fake_linux_sigfillset,
+ and fake_linux_sigemptyset, respectively). The MaRTE library will not
+ always be present (it will not be linked if no tasking constructs are
+ used), so we use the weak symbol mechanism to point always to the symbols
+ defined within the C library. */
+
+#pragma weak linux_sigaction
+int linux_sigaction (int signum, const struct sigaction *act,
+ struct sigaction *oldact) {
+ return sigaction (signum, act, oldact);
+}
+#define sigaction(signum, act, oldact) linux_sigaction (signum, act, oldact)
+
+#pragma weak fake_linux_sigfillset
+void fake_linux_sigfillset (sigset_t *set) {
+ sigfillset (set);
+}
+#define sigfillset(set) fake_linux_sigfillset (set)
+
+#pragma weak fake_linux_sigemptyset
+void fake_linux_sigemptyset (sigset_t *set) {
+ sigemptyset (set);
+}
+#define sigemptyset(set) fake_linux_sigemptyset (set)
+
+#endif
+
+static void __gnat_error_handler (int, 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)
{
- unsigned long eip;
- unsigned long ebx;
- unsigned long esp;
- unsigned long ebp;
- unsigned long esi;
- unsigned long edi;
-};
+ mcontext_t *mcontext = &((ucontext_t *) ucontext)->uc_mcontext;
-static void __gnat_error_handler PARAMS ((int));
+#if defined (i386)
+ mcontext->gregs[REG_EIP]++;
+#elif defined (__x86_64__)
+ mcontext->gregs[REG_RIP]++;
+#elif defined (__ia64__)
+ mcontext->sc_ip++;
+#endif
+}
static void
-__gnat_error_handler (sig)
- int sig;
+__gnat_error_handler (int sig,
+ siginfo_t *siginfo ATTRIBUTE_UNUSED,
+ void *ucontext)
{
struct Exception_Data *exception;
- char *msg;
+ const char *msg;
static int recurse = 0;
- struct sigcontext *info
- = (struct sigcontext *) (((char *) &sig) + sizeof (int));
-
- /* 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;
-
switch (sig)
{
case SIGSEGV:
exception = &program_error;
msg = "unhandled signal";
}
+ recurse = 0;
- mstate = (*Get_Machine_State_Addr)();
- if (mstate)
- {
- mstate->eip = info->eip;
- mstate->ebx = info->ebx;
- mstate->esp = info->esp_at_signal;
- mstate->ebp = info->ebp;
- mstate->esi = info->esi;
- mstate->edi = info->edi;
- }
+ /* We adjust the interrupted context here (and not in the
+ MD_FALLBACK_FRAME_STATE_FOR macro) because recent versions of the Native
+ POSIX Thread Library (NPTL) are compiled with DWARF 2 unwind information,
+ and hence the later macro is never executed for signal frames. */
+
+ __gnat_adjust_context_for_raise (sig, ucontext);
- recurse = 0;
Raise_From_Signal_Handler (exception, msg);
}
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 = __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);
-
- 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 (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 accessible. 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);
-}
+ act.sa_sigaction = __gnat_error_handler;
+ act.sa_flags = SA_NODEFER | SA_RESTART | 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);
-void
-__gnat_install_handler ()
-{
- SetUnhandledExceptionFilter (__gnat_error_handler);
__gnat_handler_installed = 1;
}
-void
-__gnat_initialize ()
-{
-
- /* 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
- implementation of __gnat_portable_no_block_spawn, __gnat_portable_wait */
- __gnat_plist_init();
-}
-
-/**************************************/
-/* __gnat_initialize (Interix version) */
-/**************************************/
+/*******************/
+/* Interix Section */
+/*******************/
#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;
+ 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 = 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);
- }
- __gnat_handler_installed = 1;
-}
-
-void
-__gnat_initialize ()
-{
- __gnat_init_float ();
-}
-
-/**************************************/
-/* __gnat_initialize (LynxOS version) */
-/**************************************/
+/* sigaction (SIGILL, &act, NULL); */
+/* sigaction (SIGABRT, &act, NULL); */
+/* sigaction (SIGFPE, &act, NULL); */
+/* sigaction (SIGBUS, &act, NULL); */
-#elif defined (__Lynx__)
+ /* Do not install handlers if interrupt state is "System" */
+ if (__gnat_get_interrupt_state (SIGSEGV) != 's')
+ sigaction (SIGSEGV, &act, NULL);
-void
-__gnat_initialize ()
-{
- __gnat_init_float ();
-}
-
-/*********************************/
-/* __gnat_install_handler (Lynx) */
-/*********************************/
-
-void
-__gnat_install_handler ()
-{
__gnat_handler_installed = 1;
}
-/****************************/
-/* __gnat_initialize (OS/2) */
-/****************************/
+/****************/
+/* IRIX Section */
+/****************/
-#elif defined (__EMX__) /* OS/2 dependent initialization */
-
-void
-__gnat_initialize ()
-{
-}
+#elif defined (sgi)
-/*********************************/
-/* __gnat_install_handler (OS/2) */
-/*********************************/
-
-void
-__gnat_install_handler ()
-{
- __gnat_handler_installed = 1;
-}
-
-/***********************************/
-/* __gnat_initialize (SGI version) */
-/***********************************/
-
-#elif defined (sgi)
-
-#include <signal.h>
-#include <siginfo.h>
+#include <signal.h>
+#include <siginfo.h>
#ifndef NULL
#define NULL 0
#define SIGNAL_STACK_SIZE 4096
#define SIGNAL_STACK_ALIGNMENT 64
-struct Machine_State
-{
- sigcontext_t context;
-};
+#define Check_Abort_Status \
+ system__soft_links__check_abort_status
+extern int (*Check_Abort_Status) (void);
+
+extern struct Exception_Data _abort_signal;
-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 ATTRIBUTE_UNUSED)
{
- 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)();
- 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);
+ 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);
- (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);
- }
- (void) sigaction (SIGADAABORT, &act, NULL);
__gnat_handler_installed = 1;
}
-void
-__gnat_initialize ()
-{
-}
-
-/*************************************************/
-/* __gnat_initialize (Solaris and SunOS version) */
-/*************************************************/
+/*******************/
+/* Solaris Section */
+/*******************/
#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))
}
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 (SNI version) */
-/***********************************/
-
-#elif defined (__sni__)
-
-/* SNI needs special defines and includes */
+/***************/
+/* VMS Section */
+/***************/
-#define _XOPEN_SOURCE
-#define _POSIX_SOURCE
-#include <signal.h>
-
-extern size_t __gnat_getpagesize PARAMS ((void));
-static void __gnat_error_handler PARAMS ((int));
+#elif defined (VMS)
-/* The run time needs this function which is a #define in SNI */
+long __gnat_error_handler (int *, void *);
-size_t
-__gnat_getpagesize ()
-{
- return getpagesize ();
-}
+#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
-static void
-__gnat_error_handler (sig)
- int sig;
-{
- struct Exception_Data *exception;
- char *msg;
+#if defined (IN_RTS) && !defined (__IA64)
- 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;
+/* 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);
- case SIGBUS:
- exception = &constraint_error;
- msg = "SIGBUS";
- break;
+extern char *__gnat_error_prehandler_stack; /* Alternate signal stack */
+#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. */
- default:
- exception = &program_error;
- msg = "unhandled signal";
- }
+/* Defining these as macros, as opposed to external addresses, allows
+ them to be used in a case statement (below */
+#define SS$_ACCVIO 12
+#define SS$_HPARITH 1284
+#define SS$_STKOVF 1364
+#define SS$_RESIGNAL 2328
- Raise_From_Signal_Handler (exception, msg);
-}
+/* These codes are in standard message libraries */
+extern int CMA$_EXIT_THREAD;
+extern int SS$_DEBUG;
+extern int SS$_INTDIV;
+extern int LIB$_KEYNOTFOU;
+extern int LIB$_ACTIMAGE;
+extern int MTH$_FLOOVEMAT; /* Some ACVC_21 CXA tests */
+
+/* These codes are non standard, which is to say the author is
+ not sure if they are defined in the standard message libraries
+ so keep them as macros for now. */
+#define RDB$_STREAM_EOF 20480426
+#define FDL$_UNPRIKW 11829410
+
+struct cond_except {
+ const int *cond;
+ const struct Exception_Data *except;
+};
-void
-__gnat_install_handler ()
-{
- struct sigaction act;
+struct descriptor_s {unsigned short len, mbz; __char_ptr32 adr; };
- /* 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! */
+/* 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. */
- act.sa_handler = __gnat_error_handler;
- act.sa_flags = SA_NODEFER | SA_RESTART;
- (void) sigemptyset (&act.sa_mask);
+#ifdef IN_RTS
- (void) sigaction (SIGABRT, &act, NULL);
- (void) sigaction (SIGFPE, &act, NULL);
+#define Status_Error ada__io_exceptions__status_error
+extern struct Exception_Data Status_Error;
- 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;
-}
+#define Mode_Error ada__io_exceptions__mode_error
+extern struct Exception_Data Mode_Error;
-void
-__gnat_initialize ()
-{
-}
+#define Name_Error ada__io_exceptions__name_error
+extern struct Exception_Data Name_Error;
-/***********************************/
-/* __gnat_initialize (VMS version) */
-/***********************************/
+#define Use_Error ada__io_exceptions__use_error
+extern struct Exception_Data Use_Error;
-#elif defined (VMS)
+#define Device_Error ada__io_exceptions__device_error
+extern struct Exception_Data Device_Error;
-/* 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 ();
+#define End_Error ada__io_exceptions__end_error
+extern struct Exception_Data End_Error;
-extern char *__gnat_error_prehandler_stack; /* Alternate signal stack */
+#define Data_Error ada__io_exceptions__data_error
+extern struct Exception_Data Data_Error;
-/* 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. */
+#define Layout_Error ada__io_exceptions__layout_error
+extern struct Exception_Data Layout_Error;
-#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);
+extern struct Exception_Data *Coded_Exception (Exception_Code);
+
+#define Base_Code_In system__vms_exception_table__base_code_in
+extern Exception_Code Base_Code_In (Exception_Code);
+
+/* DEC Ada exceptions are not defined in a header file, so they
+ must be declared as external addresses */
+
+extern int ADA$_PROGRAM_ERROR;
+extern int ADA$_LOCK_ERROR;
+extern int ADA$_EXISTENCE_ERROR;
+extern int ADA$_KEY_ERROR;
+extern int ADA$_KEYSIZERR;
+extern int ADA$_STAOVF;
+extern int ADA$_CONSTRAINT_ERRO;
+extern int ADA$_IOSYSFAILED;
+extern int ADA$_LAYOUT_ERROR;
+extern int ADA$_STORAGE_ERROR;
+extern int ADA$_DATA_ERROR;
+extern int ADA$_DEVICE_ERROR;
+extern int ADA$_END_ERROR;
+extern int ADA$_MODE_ERROR;
+extern int ADA$_NAME_ERROR;
+extern int ADA$_STATUS_ERROR;
+extern int ADA$_NOT_OPEN;
+extern int ADA$_ALREADY_OPEN;
+extern int ADA$_USE_ERROR;
+extern int ADA$_UNSUPPORTED;
+extern int ADA$_FAC_MODE_MISMAT;
+extern int ADA$_ORG_MISMATCH;
+extern int ADA$_RFM_MISMATCH;
+extern int ADA$_RAT_MISMATCH;
+extern int ADA$_MRS_MISMATCH;
+extern int ADA$_MRN_MISMATCH;
+extern int ADA$_KEY_MISMATCH;
+extern int ADA$_MAXLINEXC;
+extern int ADA$_LINEXCMRS;
+
+/* DEC Ada specific conditions */
+static const struct cond_except dec_ada_cond_except_table [] = {
+ {&ADA$_PROGRAM_ERROR, &program_error},
+ {&ADA$_USE_ERROR, &Use_Error},
+ {&ADA$_KEYSIZERR, &program_error},
+ {&ADA$_STAOVF, &storage_error},
+ {&ADA$_CONSTRAINT_ERRO, &constraint_error},
+ {&ADA$_IOSYSFAILED, &Device_Error},
+ {&ADA$_LAYOUT_ERROR, &Layout_Error},
+ {&ADA$_STORAGE_ERROR, &storage_error},
+ {&ADA$_DATA_ERROR, &Data_Error},
+ {&ADA$_DEVICE_ERROR, &Device_Error},
+ {&ADA$_END_ERROR, &End_Error},
+ {&ADA$_MODE_ERROR, &Mode_Error},
+ {&ADA$_NAME_ERROR, &Name_Error},
+ {&ADA$_STATUS_ERROR, &Status_Error},
+ {&ADA$_NOT_OPEN, &Use_Error},
+ {&ADA$_ALREADY_OPEN, &Use_Error},
+ {&ADA$_USE_ERROR, &Use_Error},
+ {&ADA$_UNSUPPORTED, &Use_Error},
+ {&ADA$_FAC_MODE_MISMAT, &Use_Error},
+ {&ADA$_ORG_MISMATCH, &Use_Error},
+ {&ADA$_RFM_MISMATCH, &Use_Error},
+ {&ADA$_RAT_MISMATCH, &Use_Error},
+ {&ADA$_MRS_MISMATCH, &Use_Error},
+ {&ADA$_MRN_MISMATCH, &Use_Error},
+ {&ADA$_KEY_MISMATCH, &Use_Error},
+ {&ADA$_MAXLINEXC, &constraint_error},
+ {&ADA$_LINEXCMRS, &constraint_error},
+ {0, 0}
+};
+
+#if 0
+ /* Already handled by a pragma Import_Exception
+ in Aux_IO_Exceptions */
+ {&ADA$_LOCK_ERROR, &Lock_Error},
+ {&ADA$_EXISTENCE_ERROR, &Existence_Error},
+ {&ADA$_KEY_ERROR, &Key_Error},
#endif
-/* 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. */
+#endif /* IN_RTS */
-#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
+/* Non DEC Ada specific conditions. We could probably also put
+ SS$_HPARITH here and possibly SS$_ACCVIO, SS$_STKOVF. */
+static const struct cond_except cond_except_table [] = {
+ {&MTH$_FLOOVEMAT, &constraint_error},
+ {&SS$_INTDIV, &constraint_error},
+ {0, 0}
+};
-struct descriptor_s {unsigned short len, mbz; char *adr; };
+/* 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 it's own exception handling internally.
+
+ 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.
+
+ 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.
+
+ 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.
+
+ ??? 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. */
+
+typedef int
+resignal_predicate (int code);
+
+const int *cond_resignal_table [] = {
+ &CMA$_EXIT_THREAD,
+ &SS$_DEBUG,
+ &LIB$_KEYNOTFOU,
+ &LIB$_ACTIMAGE,
+ (int *) RDB$_STREAM_EOF,
+ (int *) FDL$_UNPRIKW,
+ 0
+};
-static long __gnat_error_handler PARAMS ((int *, void *));
+const int facility_resignal_table [] = {
+ 0x1380000, /* RDB */
+ 0x2220000, /* SQL */
+ 0
+};
-static long
-__gnat_error_handler (sigargs, mechargs)
- int *sigargs;
- void *mechargs;
+/* Default GNAT predicate for resignaling conditions. */
+
+static int
+__gnat_default_resignal_p (int code)
{
- struct Exception_Data *exception = 0;
- char *msg = "";
- 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];
- long curr_invo_handle;
- long *mstate;
-
- /* Resignaled condtions aren't effected by by pragma Import_Exception */
-
- switch (sigargs[1])
- {
+ int i, iexcept;
+
+ for (i = 0; facility_resignal_table [i]; i++)
+ if ((code & 0xfff0000) == facility_resignal_table [i])
+ return 1;
- case CMA$_EXIT_THREAD:
- return SS$_RESIGNAL;
+ for (i = 0, iexcept = 0;
+ cond_resignal_table [i] &&
+ !(iexcept = LIB$MATCH_COND (&code, &cond_resignal_table [i]));
+ i++);
- case SS$_DEBUG: /* Gdb attach, resignal to merge activate gdbstub. */
- return SS$_RESIGNAL;
+ return iexcept;
+}
- case 1409786: /* Nickerson bug #33 ??? */
- return SS$_RESIGNAL;
+/* Static pointer to predicate that the __gnat_error_handler exception
+ vector invokes to determine if it should resignal a condition. */
- case 1381050: /* Nickerson bug #33 ??? */
- return SS$_RESIGNAL;
+static resignal_predicate * __gnat_resignal_p = __gnat_default_resignal_p;
- case 11829410: /* Resignalled as Use_Error for CE10VRC */
- return SS$_RESIGNAL;
+/* User interface to change the predicate pointer to PREDICATE. Reset to
+ the default if PREDICATE is null. */
- }
+void
+__gnat_set_resignal_predicate (resignal_predicate * predicate)
+{
+ if (predicate == 0)
+ __gnat_resignal_p = __gnat_default_resignal_p;
+ else
+ __gnat_resignal_p = predicate;
+}
+
+/* Should match System.Parameters.Default_Exception_Msg_Max_Length */
+#define Default_Exception_Msg_Max_Length 512
+
+/* Action routine for SYS$PUTMSG. There may be
+ multiple conditions, each with text to be appended to
+ MESSAGE and separated by line termination. */
+
+static int
+copy_msg (msgdesc, message)
+ struct descriptor_s *msgdesc;
+ char *message;
+{
+ int len = strlen (message);
+ int copy_len;
+
+ /* Check for buffer overflow and skip */
+ if (len > 0 && len <= Default_Exception_Msg_Max_Length - 3)
+ {
+ strcat (message, "\r\n");
+ len += 2;
+ }
+
+ /* Check for buffer overflow and truncate if necessary */
+ copy_len = (len + msgdesc->len <= Default_Exception_Msg_Max_Length - 1 ?
+ msgdesc->len :
+ Default_Exception_Msg_Max_Length - 1 - len);
+ strncpy (&message [len], msgdesc->adr, copy_len);
+ message [len + copy_len] = 0;
+
+ return 0;
+}
+
+long
+__gnat_handle_vms_condition (int *sigargs, void *mechargs)
+{
+ struct Exception_Data *exception = 0;
+ Exception_Code base_code;
+ struct descriptor_s gnat_facility = {4,0,"GNAT"};
+ char message [Default_Exception_Msg_Max_Length];
+
+ const char *msg = "";
+
+ /* 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 [0] = 0;
+
+ /* Subtract PC & PSL fields which messes with PUTMSG */
+ sigargs [0] -= 2;
+ SYS$PUTMSG (sigargs, copy_msg, &gnat_facility, message);
+ sigargs [0] += 2;
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
msg = "stack overflow";
break;
- case SS$_INTDIV:
- exception = &constraint_error;
- msg = "division by zero";
- break;
-
case SS$_HPARITH:
#ifndef IN_RTS
return SS$_RESIGNAL; /* toplev.c handles for compiler */
#endif
break;
- case MTH$_FLOOVEMAT:
- exception = &constraint_error;
- msg = "floating overflow in math library";
- break;
-
- case SS$_CE24VRU:
- exception = &constraint_error;
- msg = "";
- break;
-
- case SS$_C980VTE:
- exception = &program_error;
- msg = "";
- break;
-
default:
-#ifndef IN_RTS
- exception = &program_error;
+#ifdef IN_RTS
+ {
+ int i;
+
+ /* Scan the DEC Ada exception condition table for a match and fetch
+ the associated GNAT exception pointer */
+ for (i = 0;
+ dec_ada_cond_except_table [i].cond &&
+ !LIB$MATCH_COND (&sigargs [1],
+ &dec_ada_cond_except_table [i].cond);
+ i++);
+ exception = (struct Exception_Data *)
+ dec_ada_cond_except_table [i].except;
+
+ if (!exception)
+ {
+ /* Scan the VMS standard condition table for a match and fetch
+ the associated GNAT exception pointer */
+ for (i = 0;
+ cond_except_table [i].cond &&
+ !LIB$MATCH_COND (&sigargs [1], &cond_except_table [i].cond);
+ i++);
+ exception =(struct Exception_Data *) cond_except_table [i].except;
+
+ if (!exception)
+ /* User programs expect Non_Ada_Error to be raised, reference
+ DEC Ada test CXCONDHAN. */
+ exception = &Non_Ada_Error;
+ }
+ }
#else
- /* User programs expect Non_Ada_Error to be raised, reference
- DEC Ada test CXCONDHAN. */
- exception = &Non_Ada_Error;
+ exception = &program_error;
#endif
- msgdesc.len = 256;
- msgdesc.mbz = 0;
- msgdesc.adr = message;
- SYS$GETMSG (sigargs[1], &outlen, &msgdesc, msg_flag, 0);
- message [outlen] = 0;
+ message [0] = 0;
+ /* Subtract PC & PSL fields which messes with PUTMSG */
+ sigargs [0] -= 2;
+ SYS$PUTMSG (sigargs, copy_msg, &gnat_facility, message);
+ sigargs [0] += 2;
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);
- *mstate = curr_invo_handle;
- }
- Raise_From_Signal_Handler (exception, msg);
+ __gnat_adjust_context_for_raise (0, (void *)mechargs);
+ Raise_From_Signal_Handler (exception, msg);
+}
+
+long
+__gnat_error_handler (int *sigargs, void *mechargs)
+{
+ return __gnat_handle_vms_condition (sigargs, mechargs);
}
void
-__gnat_install_handler ()
+__gnat_install_handler (void)
{
- long prvhnd;
- char *c;
+ long prvhnd ATTRIBUTE_UNUSED;
+
+#if !defined (IN_RTS)
+ SYS$SETEXV (1, __gnat_error_handler, 3, &prvhnd);
+#endif
- c = (char *) malloc (1025);
+ /* On alpha-vms, we avoid the global vector annoyance thanks to frame based
+ handlers to turn conditions into exceptions since GCC 3.4. The global
+ vector is still required for earlier GCC versions. We're resorting to
+ the __gnat_error_prehandler assembly function in this case. */
- __gnat_error_prehandler_stack = &c[1024];
+#if defined (IN_RTS) && defined (__alpha__)
+ if ((__GNUC__ * 10 + __GNUC_MINOR__) < 34)
+ {
+ char * c = (char *) xmalloc (2049);
+
+ __gnat_error_prehandler_stack = &c[2048];
+ SYS$SETEXV (1, __gnat_error_prehandler, 3, &prvhnd);
+ }
+#endif
- /* __gnat_error_prehandler is an assembly function. */
- SYS$SETEXV (1, __gnat_error_prehandler, 3, &prvhnd);
__gnat_handler_installed = 1;
}
+/* __gnat_adjust_context_for_raise for alpha - see comments along with the
+ default version later in this file. */
+
+#if defined (IN_RTS) && defined (__alpha__)
+
+#include <vms/chfctxdef.h>
+#include <vms/chfdef.h>
+
+#define HAVE_GNAT_ADJUST_CONTEXT_FOR_RAISE
+
void
-__gnat_initialize()
+__gnat_adjust_context_for_raise (int signo ATTRIBUTE_UNUSED, void *ucontext)
{
+ /* Add one to the address of the instruction signaling the condition,
+ located in the sigargs array. */
+
+ CHF$MECH_ARRAY * mechargs = (CHF$MECH_ARRAY *) ucontext;
+ CHF$SIGNAL_ARRAY * sigargs
+ = (CHF$SIGNAL_ARRAY *) mechargs->chf$q_mch_sig_addr;
+
+ int vcount = sigargs->chf$is_sig_args;
+ int * pc_slot = & (&sigargs->chf$l_sig_name)[vcount-2];
+
+ (*pc_slot) ++;
}
-/***************************************/
-/* __gnat_initialize (VXWorks version) */
-/***************************************/
+#endif
-#elif defined(__vxworks)
+/* __gnat_adjust_context_for_raise for ia64. */
-#include <signal.h>
-#include <taskLib.h>
-#include <intLib.h>
-#include <iv.h>
+#if defined (IN_RTS) && defined (__IA64)
-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 *));
+#include <vms/chfctxdef.h>
+#include <vms/chfdef.h>
-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. ??? */
+#define HAVE_GNAT_ADJUST_CONTEXT_FOR_RAISE
- Raise_From_Signal_Handler (&storage_error, "stack overflow");
-}
+typedef unsigned long long u64;
-/* Used for stack-checking on VxWorks. Must be task-local in
- tasking programs */
+void
+__gnat_adjust_context_for_raise (int signo ATTRIBUTE_UNUSED, void *ucontext)
+{
+ /* Add one to the address of the instruction signaling the condition,
+ located in the 64bits sigargs array. */
-void *__gnat_stack_limit = NULL;
+ CHF$MECH_ARRAY * mechargs = (CHF$MECH_ARRAY *) ucontext;
-#ifndef __alpha_vxworks
+ CHF64$SIGNAL_ARRAY *chfsig64
+ = (CHF64$SIGNAL_ARRAY *) mechargs->chf$ph_mch_sig64_addr;
-/* getpid is used by s-parint.adb, but is not defined by VxWorks, except
- on Alpha VxWorks */
+ u64 * post_sigarray
+ = (u64 *)chfsig64 + 1 + chfsig64->chf64$l_sig_args;
-extern long getpid PARAMS ((void));
+ u64 * ih_pc_loc = post_sigarray - 2;
-long
-getpid ()
-{
- return taskIdSelf ();
+ (*ih_pc_loc) ++;
}
+
#endif
-/* This is needed by the GNAT run time to handle Vxworks interrupts */
-int
-__gnat_inum_to_ivec (num)
- int num;
+/*******************/
+/* FreeBSD Section */
+/*******************/
+
+#elif defined (__FreeBSD__)
+
+#include <signal.h>
+#include <sys/ucontext.h>
+#include <unistd.h>
+
+static void __gnat_error_handler (int, siginfo_t *, ucontext_t *);
+void __gnat_adjust_context_for_raise (int, void*);
+
+/* __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)
{
- return INUM_TO_IVEC (num);
+ mcontext_t *mcontext = &((ucontext_t *) ucontext)->uc_mcontext;
+ mcontext->mc_eip++;
}
static void
-__gnat_error_handler (sig, code, sc)
- int sig;
- int code;
- struct sigcontext *sc;
+__gnat_error_handler (int sig, siginfo_t *info __attribute__ ((unused)),
+ ucontext_t *ucontext)
{
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";
}
+ __gnat_adjust_context_for_raise (sig, ucontext);
Raise_From_Signal_Handler (exception, msg);
}
{
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 | SA_SIGINFO;
(void) sigemptyset (&act.sa_mask);
+ (void) sigaction (SIGILL, &act, NULL);
(void) sigaction (SIGFPE, &act, NULL);
+ (void) sigaction (SIGSEGV, &act, NULL);
+ (void) 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;
}
-#define HAVE_GNAT_INIT_FLOAT
-
-void
-__gnat_init_float ()
-{
-#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
-}
-
-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 ();
+/*******************/
+/* VxWorks Section */
+/*******************/
-#ifdef __mips_vxworks
-#if 0
- /* For now remove this handler, since it is causing interferences with gdb */
+#elif defined(__vxworks)
- /* Connect the overflow trap directly to the __gnat_int_handler routine
- as it is not converted to a signal by VxWorks. */
+#include <signal.h>
+#include <taskLib.h>
- intConnect (INUM_TO_IVEC (IV_TRAP_VEC), &__gnat_int_handler, IV_TRAP_VEC);
-#endif
+#ifndef __RTP__
+#include <intLib.h>
+#include <iv.h>
#endif
-}
-
-
-/***************************************/
-/* __gnat_initialize (default 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 (IN_RTS) && !defined (__RT__)
-
-/* 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"
-
-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. */
+static void __gnat_error_handler (int, int, struct sigcontext *);
+void __gnat_map_signal (int);
-typedef int ptr_type __attribute__ ((mode (pointer)));
+#ifndef __RTP__
-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 *));
+/* Directly vectored Interrupt routines are not supported when using RTPs */
-#ifdef INCOMING_REGNO
-static int in_reg_window PARAMS ((unsigned int, frame_state *));
-#endif
-
-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 *));
+extern int __gnat_inum_to_ivec (int);
-/* Get the value of register REG as saved in UDATA, where SUB_UDATA is a
- frame called by UDATA or 0. */
-
-static void *
-get_reg (reg, udata, sub_udata)
- unsigned int reg;
- frame_state *udata, *sub_udata;
+/* 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)
- 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 INUM_TO_IVEC (num);
}
+#endif
-/* Overwrite the saved value for register REG in frame UDATA with VAL. */
+#if !defined(__alpha_vxworks) && (_WRS_VXWORKS_MAJOR != 6) && !defined(__RTP__)
-static void
-put_reg (reg, val, udata)
- unsigned int reg;
- void *val;
- frame_state *udate;
-{
- if (udata->saved[reg] == REG_SAVED_OFFSET)
- *(word_type *) (udata->cfa + udata->reg_or_offset[reg])
- = (word_type) (ptr_type) val;
- else
- abort ();
-}
+/* getpid is used by s-parint.adb, but is not defined by VxWorks, except
+ on Alpha VxWorks and VxWorks 6.x (including RTPs). */
-/* 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. */
+extern long getpid (void);
-static void
-copy_reg (reg, udata, target_udata)
- unsigned int reg;
- frame_state *udate, *target_udata;
+long
+getpid (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 ();
+ return taskIdSelf ();
}
+#endif
-/* Overwrite the return address for frame UDATA with VAL. */
-
-static inline void
-put_return_addr (val, udata)
- void *val;
- frame_state *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)
{
- val = __builtin_frob_return_addr (val);
- put_reg (udata->retaddr_column, val, udata);
-}
+#ifdef VTHREADS
+ WIND_TCB *currentTask = (WIND_TCB *) taskIdSelf();
-#ifdef INCOMING_REGNO
-
-/* Is the saved value for register REG in frame UDATA stored in a register
- window in the previous frame? */
+ currentTask->vThreads.excCnt = 0;
+#endif
+}
-static int
-in_reg_window (reg, udata)
- unsigned int reg;
- frame_state *udata;
+/* Exported to s-intman-vxworks.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;
+ const 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;
+
+ /* 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! */
- int i;
+ act.sa_handler = __gnat_error_handler;
+ act.sa_flags = SA_SIGINFO | SA_ONSTACK;
+ sigemptyset (&act.sa_mask);
- m->pc = m->new_pc;
- p = m->udata;
- if (! __frame_state_for_r (m->pc, m->sub_udata))
- {
- m->new_pc = 0;
- return;
- }
+ /* 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);
- /* 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;
+ __gnat_handler_installed = 1;
+}
- m->udata = m->sub_udata;
- m->sub_udata = p;
- m->new_pc = get_return_addr (m->udata, m->sub_udata) - 1;
+#define HAVE_GNAT_INIT_FLOAT
- 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
-/* ??? disable this code for now since it doesn't work properly */
-#if 0
- if (m->pc == m->pc_start)
- return;
+ /* 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)
- /* Copy the frame's saved register values into our register save slots. */
+#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;
- 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);
- }
+ __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;
-{
- 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;
-
- memcpy (machine_state->udata_start, machine_state->udata,
- sizeof (frame_state));
- machine_state->new_pc =
- machine_state->pc_start =
- machine_state->pc = &&label;
+/******************/
+/* NetBSD Section */
+/******************/
- /* Do any necessary initialization to access arbitrary stack frames.
- On the SPARC, this means flushing the register windows. */
- __builtin_unwind_init ();
+#elif defined(__NetBSD__)
- /* go up one frame */
- __gnat_pop_frame (machine_state);
-}
+#include <signal.h>
+#include <unistd.h>
-void
-__gnat_enter_handler (m, handler)
- struct machine_state *m;
- void *handler;
+static void
+__gnat_error_handler (int sig)
{
- 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
-
- /* Emit the stub to adjust sp and jump to the handler. */
- retaddr = __builtin_eh_stub ();
+ 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;
-void *
-__gnat_get_code_loc (m)
- struct machine_state *m;
-{
- return m->pc;
+ 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;
}
-#endif /* DWARF2_UNWIND_INFO */
#else
-/* For all other versions of GNAT, the initialize routine and handler
- installation do nothing */
-
-/***************************************/
-/* __gnat_initialize (default version) */
-/***************************************/
-
-void
-__gnat_initialize ()
-{
-}
+/* For all other versions of GNAT, the handler does nothing */
-/********************************************/
-/* __gnat_install_handler (default version) */
-/********************************************/
+/*******************/
+/* Default Section */
+/*******************/
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 independent 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