* *
* I N I T *
* *
- * $Revision$
- * *
* C Implementation File *
* *
- * Copyright (C) 1992-2001 Free Software Foundation, Inc. *
+ * Copyright (C) 1992-2004 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 *,
- const 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 *, const 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 adjustements 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;
const char *msg;
}
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)
+{
+}
+
+/***************************************/
+/* __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)
{
+ __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;
}
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)
{
}
#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)
#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;
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);
-
- (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)
{
}
-
-/*************************************/
-/* __gnat_initialize (GNU/Linux version) */
-/*************************************/
+/*****************************************/
+/* __gnat_initialize (GNU/Linux Version) */
+/*****************************************/
#elif defined (linux) && defined (i386) && !defined (__RT__)
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;
const char *msg;
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)
{
}
/******************************************/
-/* __gnat_initialize (NT-mingw32 version) */
+/* __gnat_initialize (NT-mingw32 Version) */
/******************************************/
#elif defined (__MINGW32__)
#include <windows.h>
-static LONG __gnat_error_handler PARAMS ((PEXCEPTION_POINTERS));
+static LONG WINAPI __gnat_error_handler (PEXCEPTION_POINTERS);
/* __gnat_initialize (mingw32). */
-static LONG
-__gnat_error_handler (info)
- PEXCEPTION_POINTERS info;
+static LONG WINAPI
+__gnat_error_handler (PEXCEPTION_POINTERS info)
{
static int recurse;
struct Exception_Data *exception;
- char *msg;
+ const char *msg;
switch (info->ExceptionRecord->ExceptionCode)
{
recurse = 0;
Raise_From_Signal_Handler (exception, msg);
+ return 0; /* This is never reached, avoid compiler warning */
}
void
-__gnat_install_handler ()
+__gnat_install_handler (void)
{
SetUnhandledExceptionFilter (__gnat_error_handler);
__gnat_handler_installed = 1;
}
void
-__gnat_initialize ()
+__gnat_initialize (void)
{
/* Initialize floating-point coprocessor. This call is needed because
__gnat_plist_init();
}
-/**************************************/
-/* __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)
{
__gnat_init_float ();
}
/**************************************/
-/* __gnat_initialize (LynxOS version) */
+/* __gnat_initialize (LynxOS Version) */
/**************************************/
#elif defined (__Lynx__)
void
-__gnat_initialize ()
+__gnat_initialize (void)
{
__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)
{
}
/*********************************/
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);
+ 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 (void)
{
}
/*************************************************/
-/* __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))
}
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)
{
}
/***********************************/
-/* __gnat_initialize (SNI version) */
+/* __gnat_initialize (VMS Version) */
/***********************************/
-#elif defined (__sni__)
-
-/* SNI needs special defines and includes */
-
-#define _XOPEN_SOURCE
-#define _POSIX_SOURCE
-#include <signal.h>
-
-extern size_t __gnat_getpagesize PARAMS ((void));
-static void __gnat_error_handler PARAMS ((int));
-
-/* The run time needs this function which is a #define in SNI */
-
-size_t
-__gnat_getpagesize ()
-{
- return getpagesize ();
-}
-
-static void
-__gnat_error_handler (sig)
- int sig;
-{
- struct Exception_Data *exception;
- char *msg;
-
- 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;
-
- case SIGBUS:
- exception = &constraint_error;
- msg = "SIGBUS";
- break;
-
- case SIGFPE:
- exception = &constraint_error;
- msg = "SIGFPE";
- break;
-
- default:
- exception = &program_error;
- msg = "unhandled signal";
- }
-
- Raise_From_Signal_Handler (exception, msg);
-}
-
-void
-__gnat_install_handler ()
-{
- struct sigaction act;
-
- /* 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_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 ()
-{
-}
+#elif defined (VMS)
-/***********************************/
-/* __gnat_initialize (VMS version) */
-/***********************************/
+#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
-#elif defined (VMS)
+#if defined (IN_RTS) && !defined (__IA64)
/* 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 long __gnat_error_prehandler (void);
extern char *__gnat_error_prehandler_stack; /* Alternate signal stack */
+#endif
/* 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
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);
#endif
/* Define macro symbols for the VMS conditions that become Ada exceptions.
struct descriptor_s {unsigned short len, mbz; char *adr; };
-static long __gnat_error_handler PARAMS ((int *, void *));
+long __gnat_error_handler (int *, void *);
-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;
case 1381050: /* Nickerson bug #33 ??? */
return SS$_RESIGNAL;
+ case 20480426: /* RDB-E-STREAM_EOF */
+ return SS$_RESIGNAL;
+
case 11829410: /* Resignalled as Use_Error for CE10VRC */
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)
{
}
-/***************************************/
-/* __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>
-
-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_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);
-}
+#include <unistd.h>
static void
__gnat_error_handler (sig, code, sc)
struct sigcontext *sc;
{
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 ());
-
switch (sig)
{
case SIGFPE:
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 ()
-{
-#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_init_float ();
void
__gnat_initialize ()
{
- TASK_DESC pTaskDesc;
-
- if (taskInfoGet (taskIdSelf (), &pTaskDesc) != OK)
- printErr ("Cannot get task info");
+ __gnat_install_handler ();
- __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 (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
-#endif
-
-#ifdef DWARF2_UNWIND_INFO
-#include "frame.h"
+#elif defined(__vxworks)
-struct machine_state
-{
- frame_state f1, f2, f3;
- frame_state *udata, *udata_start, *sub_udata;
- void *pc, *pc_start, *new_pc;
-};
+#include <signal.h>
+#include <taskLib.h>
+#include <intLib.h>
+#include <iv.h>
-typedef int word_type __attribute__ ((mode (__word__)));
+extern int __gnat_inum_to_ivec (int);
+static void __gnat_error_handler (int, int, struct sigcontext *);
+void __gnat_map_signal (int);
-/* 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. */
+#ifndef __alpha_vxworks
-typedef int ptr_type __attribute__ ((mode (pointer)));
+/* getpid is used by s-parint.adb, but is not defined by VxWorks, except
+ on Alpha VxWorks */
-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 *));
+extern long getpid (void);
-#ifdef INCOMING_REGNO
-static int in_reg_window PARAMS ((unsigned int, frame_state *));
+long
+getpid (void)
+{
+ return taskIdSelf ();
+}
#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 *));
-
-/* 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);
}
-/* 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;
+/* 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)
- *(word_type *) (udata->cfa + udata->reg_or_offset[reg])
- = (word_type) (ptr_type) val;
- else
- abort ();
-}
+ struct Exception_Data *exception;
+ char *msg;
-/* 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. */
+ switch (sig)
+ {
+ case SIGFPE:
+ exception = &constraint_error;
+ msg = "SIGFPE";
+ break;
+ case SIGILL:
+ exception = &constraint_error;
+ msg = "SIGILL";
+ break;
+ case SIGSEGV:
+ exception = &program_error;
+ msg = "SIGSEGV";
+ break;
+ case SIGBUS:
+#ifdef VTHREADS
+ exception = &storage_error;
+ msg = "SIGBUS: possible stack overflow";
+#else
+ exception = &program_error;
+ msg = "SIGBUS";
+#endif
+ break;
+ default:
+ exception = &program_error;
+ msg = "unhandled signal";
+ }
-static void
-copy_reg (reg, udata, target_udata)
- unsigned int reg;
- frame_state *udate, *target_udata;
-{
- 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 ();
+ Raise_From_Signal_Handler (exception, msg);
}
-/* Overwrite the return address for frame UDATA with VAL. */
-
-static inline void
-put_return_addr (val, udata)
- void *val;
- frame_state *udata;
+static void
+__gnat_error_handler (int sig, int code, struct sigcontext *sc)
{
- val = __builtin_frob_return_addr (val);
- put_reg (udata->retaddr_column, val, udata);
-}
+ sigset_t mask;
+ int result;
-#ifdef INCOMING_REGNO
+ /* 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);
-/* Is the saved value for register REG in frame UDATA stored in a register
- window in the previous frame? */
+ /* 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)
+ taskResume (taskIdSelf ());
-static int
-in_reg_window (reg, udata)
- unsigned int reg;
- frame_state *udata;
-{
- if (udata->saved[reg] != REG_SAVED_OFFSET)
- return 0;
+ __gnat_map_signal (sig);
-#ifdef STACK_GROWS_DOWNWARD
- return udata->reg_or_offset[reg] > 0;
-#else
- return udata->reg_or_offset[reg] < 0;
-#endif
}
-#endif /* INCOMING_REGNO */
-
-/* Retrieve the return address for frame UDATA, where SUB_UDATA is a
- frame called by UDATA or 0. */
-static inline void *
-get_return_addr (udata, sub_udata)
- frame_state *udate, *sub_udata;
+void
+__gnat_install_handler (void)
{
- return __builtin_extract_return_addr (get_reg (udata->retaddr_column,
- udata, sub_udata));
-}
+ 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! */
-/* Thread-safe version of __frame_state_for */
+ act.sa_handler = __gnat_error_handler;
+ act.sa_flags = SA_SIGINFO | SA_ONSTACK;
+ sigemptyset (&act.sa_mask);
-static frame_state *
-__frame_state_for_r (void *pc_target, frame_state *state_in)
- void *pc_target;
- frame_state *state_in;
-{
- frame_state *f;
+ /* 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);
- (*Lock_Task) ();
- f = __frame_state_for (pc_target, state_in);
- (*Unlock_Task) ();
- return f;
+ __gnat_handler_installed = 1;
}
-/* Given the current frame UDATA and its return address PC, return the
- information about the calling frame in CALLER_UDATA. */
+#define HAVE_GNAT_INIT_FLOAT
void
-__gnat_pop_frame (m)
- struct machine_state *m;
+__gnat_init_float (void)
{
- frame_state *p;
-
- int i;
-
- m->pc = m->new_pc;
- p = m->udata;
- if (! __frame_state_for_r (m->pc, m->sub_udata))
- {
- m->new_pc = 0;
- return;
- }
-
- /* 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;
-
- m->udata = m->sub_udata;
- m->sub_udata = p;
- m->new_pc = get_return_addr (m->udata, m->sub_udata) - 1;
-
- return;
+ /* Disable overflow/underflow exceptions on the PPC processor, this is needed
+ to get correct Ada semantic. */
+#if defined (_ARCH_PPC) && !defined (_SOFT_FLOAT)
+ 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;
+ /* Similarily 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;
+__gnat_initialize (void)
{
- 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/endS) are tailored to provide this service a-la C++
+ static 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 call 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/end 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
+ static ctors/dtors capabilities (first scheme above) is triggered by
+ adding "-static" to the gcc *link* command line options. Without this,
+ the other set of crt objects is fetched.
+
+ 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 DWARF2_UNWIND_INFO && defined (_ARCH_PPC)
+ {
+ extern const int __module_has_ctors;
+ extern void __do_global_ctors ();
+
+ if (! __module_has_ctors)
+ __do_global_ctors ();
+ }
+#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)
{
- 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)
{
}
/********************************************/
-/* __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
OSDN Git Service
