#ifdef __vxworks
#include "vxWorks.h"
#endif
#ifdef IN_RTS
#include "tconfig.h"
#include "tsystem.h"
#include <sys/stat.h>
#define xmalloc(S) malloc (S)
#else
#include "config.h"
#include "system.h"
#endif
#include "adaint.h"
#include "raise.h"
extern void __gnat_raise_program_error (const char *, int);
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));
#define Raise_From_Signal_Handler \
ada__exceptions__raise_from_signal_handler
extern void Raise_From_Signal_Handler PARAMS ((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 *));
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_restrictions = 0;
char __gl_task_dispatching_policy = ' ';
int __gl_unreserve_all_interrupts = 0;
int __gl_exception_tracebacks = 0;
int __gl_zero_cost_exceptions = 0;
int __gnat_handler_installed = 0;
#undef HAVE_GNAT_INIT_FLOAT
void
__gnat_set_globals (main_priority, time_slice_val, wc_encoding, locking_policy,
queuing_policy, task_dispatching_policy, restrictions,
unreserve_all_interrupts, exception_tracebacks,
zero_cost_exceptions)
int main_priority;
int time_slice_val;
char wc_encoding;
char locking_policy, queuing_policy, task_dispatching_policy;
char *restrictions;
int unreserve_all_interrupts, exception_tracebacks, zero_cost_exceptions;
{
static int already_called = 0;
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
|| __gl_zero_cost_exceptions != zero_cost_exceptions)
__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_restrictions = restrictions;
__gl_task_dispatching_policy = task_dispatching_policy;
__gl_unreserve_all_interrupts = unreserve_all_interrupts;
__gl_exception_tracebacks = exception_tracebacks;
#ifdef IN_RTS
__gl_zero_cost_exceptions = zero_cost_exceptions;
#else
__gl_zero_cost_exceptions = 0;
#endif
}
#if defined (_AIX)
#define SA_NODEFER 0
#include <sys/time.h>
extern int nanosleep PARAMS ((struct timestruc_t *, struct timestruc_t *));
static void __gnat_error_handler PARAMS ((int));
int
nanosleep (Rqtp, Rmtp)
struct timestruc_t *Rqtp, *Rmtp;
{
return nsleep (Rqtp, Rmtp);
}
#include <signal.h>
static void
__gnat_error_handler (sig)
int sig;
{
struct Exception_Data *exception;
const char *msg;
switch (sig)
{
case 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;
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);
(void) sigaction (SIGILL, &act, NULL);
(void) sigaction (SIGSEGV, &act, NULL);
(void) sigaction (SIGBUS, &act, NULL);
__gnat_handler_installed = 1;
}
void
__gnat_initialize ()
{
}
#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));
extern long exc_lookup_gp PARAMS ((char *));
extern void exc_resume PARAMS ((struct sigcontext *));
static void
__gnat_error_handler (sig, sip, context)
int sig;
siginfo_t *sip;
struct sigcontext *context;
{
struct Exception_Data *exception;
static int recurse = 0;
struct sigcontext *mstate;
const char *msg;
if (SI_FROMUSER (sip))
{
signal (sig, SIG_DFL);
kill (getpid(), sig);
}
switch (sig)
{
case SIGSEGV:
if (sip->si_code == SEGV_ACCERR
|| (((long) sip->si_addr) & 3) != 0
|| recurse)
{
exception = &constraint_error;
msg = "SIGSEGV";
}
else
{
recurse++;
((volatile char *)
((long) sip->si_addr & - getpagesize ()))[getpagesize ()];
msg = "stack overflow (or erroneous memory access)";
exception = &storage_error;
}
break;
case SIGBUS:
exception = &program_error;
msg = "SIGBUS";
break;
case SIGFPE:
exception = &constraint_error;
msg = "SIGFPE";
break;
default:
exception = &program_error;
msg = "unhandled signal";
}
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 ()
{
struct sigaction act;
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);
(void) sigaction (SIGILL, &act, NULL);
(void) sigaction (SIGSEGV, &act, NULL);
(void) sigaction (SIGBUS, &act, NULL);
__gnat_handler_installed = 1;
}
void
__gnat_initialize ()
{
}
#define SC_GP 29
char *
__gnat_get_code_loc (context)
struct sigcontext *context;
{
return (char *) context->sc_pc;
}
void
__gnat_enter_handler (context, pc)
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 ()
{
return sizeof (struct sigcontext);
}
#elif defined (hpux)
#include <signal.h>
static void __gnat_error_handler PARAMS ((int));
static void
__gnat_error_handler (sig)
int sig;
{
struct Exception_Data *exception;
char *msg;
switch (sig)
{
case 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;
static char handler_stack[SIGSTKSZ*2];
stack_t stack;
stack.ss_sp = handler_stack;
stack.ss_size = sizeof (handler_stack);
stack.ss_flags = 0;
(void) 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);
(void) sigaction (SIGILL, &act, NULL);
(void) sigaction (SIGSEGV, &act, NULL);
(void) sigaction (SIGBUS, &act, NULL);
__gnat_handler_installed = 1;
}
void
__gnat_initialize ()
{
}
#elif defined (linux) && defined (i386) && !defined (__RT__)
#include <signal.h>
#include <asm/sigcontext.h>
#if !defined (NULL)
#define NULL ((void *) 0)
#endif
struct Machine_State
{
unsigned long eip;
unsigned long ebx;
unsigned long esp;
unsigned long ebp;
unsigned long esi;
unsigned long edi;
};
static void __gnat_error_handler PARAMS ((int));
static void
__gnat_error_handler (sig)
int sig;
{
struct Exception_Data *exception;
const char *msg;
static int recurse = 0;
struct sigcontext *info
= (struct sigcontext *) (((char *) &sig) + sizeof (int));
struct Machine_State *mstate;
switch (sig)
{
case SIGSEGV:
if (recurse)
{
exception = &constraint_error;
msg = "SIGSEGV";
}
else
{
msg = "stack overflow (or erroneous memory access)";
exception = &storage_error;
}
break;
case SIGBUS:
exception = &constraint_error;
msg = "SIGBUS";
break;
case SIGFPE:
exception = &constraint_error;
msg = "SIGFPE";
break;
default:
exception = &program_error;
msg = "unhandled signal";
}
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;
}
recurse = 0;
Raise_From_Signal_Handler (exception, msg);
}
void
__gnat_install_handler ()
{
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);
(void) sigaction (SIGILL, &act, NULL);
(void) sigaction (SIGSEGV, &act, NULL);
(void) sigaction (SIGBUS, &act, NULL);
__gnat_handler_installed = 1;
}
void
__gnat_initialize ()
{
}
#elif defined (__MINGW32__)
#include <windows.h>
static LONG __gnat_error_handler PARAMS ((PEXCEPTION_POINTERS));
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 ((info->ExceptionRecord->ExceptionInformation[1] & 3) != 0
|| recurse)
{
exception = &program_error;
msg = "EXCEPTION_ACCESS_VIOLATION";
}
else
{
recurse++;
* ((volatile char *) (info->ExceptionRecord->ExceptionInformation[1]
+ 4096));
exception = &storage_error;
msg = "stack overflow (or erroneous memory access)";
}
break;
case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
exception = &constraint_error;
msg = "EXCEPTION_ARRAY_BOUNDS_EXCEEDED";
break;
case EXCEPTION_DATATYPE_MISALIGNMENT:
exception = &constraint_error;
msg = "EXCEPTION_DATATYPE_MISALIGNMENT";
break;
case EXCEPTION_FLT_DENORMAL_OPERAND:
exception = &constraint_error;
msg = "EXCEPTION_FLT_DENORMAL_OPERAND";
break;
case EXCEPTION_FLT_DIVIDE_BY_ZERO:
exception = &constraint_error;
msg = "EXCEPTION_FLT_DENORMAL_OPERAND";
break;
case EXCEPTION_FLT_INVALID_OPERATION:
exception = &constraint_error;
msg = "EXCEPTION_FLT_INVALID_OPERATION";
break;
case EXCEPTION_FLT_OVERFLOW:
exception = &constraint_error;
msg = "EXCEPTION_FLT_OVERFLOW";
break;
case EXCEPTION_FLT_STACK_CHECK:
exception = &program_error;
msg = "EXCEPTION_FLT_STACK_CHECK";
break;
case EXCEPTION_FLT_UNDERFLOW:
exception = &constraint_error;
msg = "EXCEPTION_FLT_UNDERFLOW";
break;
case EXCEPTION_INT_DIVIDE_BY_ZERO:
exception = &constraint_error;
msg = "EXCEPTION_INT_DIVIDE_BY_ZERO";
break;
case EXCEPTION_INT_OVERFLOW:
exception = &constraint_error;
msg = "EXCEPTION_INT_OVERFLOW";
break;
case EXCEPTION_INVALID_DISPOSITION:
exception = &program_error;
msg = "EXCEPTION_INVALID_DISPOSITION";
break;
case EXCEPTION_NONCONTINUABLE_EXCEPTION:
exception = &program_error;
msg = "EXCEPTION_NONCONTINUABLE_EXCEPTION";
break;
case EXCEPTION_PRIV_INSTRUCTION:
exception = &program_error;
msg = "EXCEPTION_PRIV_INSTRUCTION";
break;
case EXCEPTION_SINGLE_STEP:
exception = &program_error;
msg = "EXCEPTION_SINGLE_STEP";
break;
case EXCEPTION_STACK_OVERFLOW:
exception = &storage_error;
msg = "EXCEPTION_STACK_OVERFLOW";
break;
default:
exception = &program_error;
msg = "unhandled signal";
}
recurse = 0;
Raise_From_Signal_Handler (exception, msg);
}
void
__gnat_install_handler ()
{
SetUnhandledExceptionFilter (__gnat_error_handler);
__gnat_handler_installed = 1;
}
void
__gnat_initialize ()
{
__gnat_init_float ();
__gnat_plist_init();
}
#elif defined (__INTERIX)
#include <signal.h>
static void __gnat_error_handler PARAMS ((int));
static void
__gnat_error_handler (sig)
int sig;
{
struct Exception_Data *exception;
char *msg;
switch (sig)
{
case 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;
act.sa_handler = __gnat_error_handler;
act.sa_flags = 0;
(void) sigemptyset (&act.sa_mask);
(void) sigaction (SIGSEGV, &act, NULL);
__gnat_handler_installed = 1;
}
void
__gnat_initialize ()
{
__gnat_init_float ();
}
#elif defined (__Lynx__)
void
__gnat_initialize ()
{
__gnat_init_float ();
}
void
__gnat_install_handler ()
{
__gnat_handler_installed = 1;
}
#elif defined (__EMX__)
void
__gnat_initialize ()
{
}
void
__gnat_install_handler ()
{
__gnat_handler_installed = 1;
}
#elif defined (sgi)
#include <signal.h>
#include <siginfo.h>
#ifndef NULL
#define NULL 0
#endif
#define SIGADAABORT 48
#define SIGNAL_STACK_SIZE 4096
#define SIGNAL_STACK_ALIGNMENT 64
struct Machine_State
{
sigcontext_t context;
};
static void __gnat_error_handler PARAMS ((int, int, sigcontext_t *));
static void
__gnat_error_handler (sig, code, sc)
int sig;
int code;
sigcontext_t *sc;
{
struct Machine_State *mstate;
struct Exception_Data *exception;
char *msg;
int i;
switch (sig)
{
case SIGSEGV:
if (code == EFAULT)
{
exception = &program_error;
msg = "SIGSEGV: (Invalid virtual address)";
}
else if (code == ENXIO)
{
exception = &program_error;
msg = "SIGSEGV: (Read beyond mapped object)";
}
else if (code == ENOSPC)
{
exception = &program_error;
msg = "SIGSEGV: (Autogrow for file failed)";
}
else if (code == EACCES)
{
exception = &storage_error;
msg = "SIGSEGV: (stack overflow or erroneous memory access)";
}
else
{
exception = &program_error;
msg = "SIGSEGV: (Undocumented reason)";
}
break;
case SIGBUS:
exception = &program_error;
msg = "SIGBUS";
break;
case SIGFPE:
exception = &constraint_error;
msg = "SIGFPE";
break;
case SIGADAABORT:
if ((*Check_Abort_Status) ())
{
exception = &_abort_signal;
msg = "";
}
else
return;
break;
default:
exception = &program_error;
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 ()
{
stack_t ss;
struct sigaction act;
act.sa_handler = __gnat_error_handler;
act.sa_flags = SA_NODEFER + SA_RESTART;
(void) sigfillset (&act.sa_mask);
(void) sigemptyset (&act.sa_mask);
(void) sigaction (SIGABRT, &act, NULL);
(void) sigaction (SIGFPE, &act, NULL);
(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 ()
{
}
#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 (sig, sip)
int sig;
siginfo_t *sip;
{
struct Exception_Data *exception;
static int recurse = 0;
char *msg;
if (SI_FROMUSER (sip))
{
signal (sig, SIG_DFL);
kill (getpid(), sig);
}
switch (sig)
{
case SIGSEGV:
if (sip->si_code == SEGV_ACCERR
|| (((long) sip->si_addr) & 3) != 0
|| recurse)
{
exception = &constraint_error;
msg = "SIGSEGV";
}
else
{
recurse++;
((volatile char *)
((long) sip->si_addr & - getpagesize ()))[getpagesize ()];
exception = &storage_error;
msg = "stack overflow (or erroneous memory access)";
}
break;
case SIGBUS:
exception = &program_error;
msg = "SIGBUS";
break;
case SIGFPE:
exception = &constraint_error;
msg = "SIGFPE";
break;
default:
exception = &program_error;
msg = "unhandled signal";
}
recurse = 0;
Raise_From_Signal_Handler (exception, msg);
}
void
__gnat_install_handler ()
{
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);
(void) sigaction (SIGFPE, &act, NULL);
(void) sigaction (SIGSEGV, &act, NULL);
(void) sigaction (SIGBUS, &act, NULL);
__gnat_handler_installed = 1;
}
void
__gnat_initialize ()
{
}
#elif defined (__sni__)
#define _XOPEN_SOURCE
#define _POSIX_SOURCE
#include <signal.h>
extern size_t __gnat_getpagesize PARAMS ((void));
static void __gnat_error_handler PARAMS ((int));
size_t
__gnat_getpagesize ()
{
return getpagesize ();
}
static void
__gnat_error_handler (sig)
int sig;
{
struct Exception_Data *exception;
char *msg;
switch (sig)
{
case 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;
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);
(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)
extern long __gnat_error_prehandler ();
extern char *__gnat_error_prehandler_stack;
#ifdef IN_RTS
#define Non_Ada_Error system__aux_dec__non_ada_error
extern struct Exception_Data Non_Ada_Error;
#define Coded_Exception system__vms_exception_table__coded_exception
extern struct Exception_Data *Coded_Exception (int);
#endif
#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
#define SS$_CE24VRU 3253636
#define SS$_C980VTE 3246436
#define CMA$_EXIT_THREAD 4227492
#define CMA$_EXCCOPLOS 4228108
#define CMA$_ALERTED 4227460
struct descriptor_s {unsigned short len, mbz; char *adr; };
long __gnat_error_handler PARAMS ((int *, void *));
long
__gnat_error_handler (sigargs, mechargs)
int *sigargs;
void *mechargs;
{
struct Exception_Data *exception = 0;
char *msg = "";
char message[256];
long prvhnd;
struct descriptor_s msgdesc;
int msg_flag = 0x000f;
unsigned short outlen;
char curr_icb[544];
long curr_invo_handle;
long *mstate;
switch (sigargs[1])
{
case CMA$_EXIT_THREAD:
return SS$_RESIGNAL;
case SS$_DEBUG:
return SS$_RESIGNAL;
case 1409786:
return SS$_RESIGNAL;
case 1381050:
return SS$_RESIGNAL;
case 11829410:
return SS$_RESIGNAL;
}
#ifdef IN_RTS
exception = Coded_Exception (sigargs[1] & 0xfffffff8);
if (exception)
{
msgdesc.len = 256;
msgdesc.mbz = 0;
msgdesc.adr = message;
SYS$GETMSG (sigargs[1], &outlen, &msgdesc, msg_flag, 0);
message[outlen] = 0;
msg = message;
exception->Name_Length = 19;
exception->Full_Name = "IMPORTED_EXCEPTION";
exception->Import_Code = sigargs[1] & 0xfffffff8;
}
#endif
if (exception == 0)
switch (sigargs[1])
{
case SS$_ACCVIO:
if (sigargs[3] == 0)
{
exception = &constraint_error;
msg = "access zero";
}
else
{
exception = &storage_error;
msg = "stack overflow (or erroneous memory access)";
}
break;
case SS$_STKOVF:
exception = &storage_error;
msg = "stack overflow";
break;
case SS$_INTDIV:
exception = &constraint_error;
msg = "division by zero";
break;
case SS$_HPARITH:
#ifndef IN_RTS
return SS$_RESIGNAL;
#else
{
exception = &constraint_error;
msg = "arithmetic error";
}
#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;
#else
exception = &Non_Ada_Error;
#endif
msgdesc.len = 256;
msgdesc.mbz = 0;
msgdesc.adr = message;
SYS$GETMSG (sigargs[1], &outlen, &msgdesc, msg_flag, 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);
*mstate = curr_invo_handle;
}
Raise_From_Signal_Handler (exception, msg);
}
void
__gnat_install_handler ()
{
long prvhnd;
char *c;
c = (char *) xmalloc (2049);
__gnat_error_prehandler_stack = &c[2048];
SYS$SETEXV (1, __gnat_error_prehandler, 3, &prvhnd);
__gnat_handler_installed = 1;
}
void
__gnat_initialize()
{
}
#elif defined(__vxworks)
#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;
{
Raise_From_Signal_Handler (&storage_error, "stack overflow");
}
void *__gnat_stack_limit = NULL;
#ifndef __alpha_vxworks
extern long getpid PARAMS ((void));
long
getpid ()
{
return taskIdSelf ();
}
#endif
int
__gnat_inum_to_ivec (num)
int num;
{
return INUM_TO_IVEC (num);
}
static void
__gnat_error_handler (sig, code, sc)
int sig;
int code;
struct sigcontext *sc;
{
struct Exception_Data *exception;
sigset_t mask;
int result;
char *msg;
(void) sigprocmask (SIG_SETMASK, NULL, &mask);
sigdelset (&mask, sig);
(void) sigprocmask (SIG_SETMASK, &mask, NULL);
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";
break;
case SIGBUS:
exception = &program_error;
msg = "SIGBUS";
break;
default:
exception = &program_error;
msg = "unhandled signal";
}
Raise_From_Signal_Handler (exception, msg);
}
void
__gnat_install_handler ()
{
struct sigaction act;
act.sa_handler = __gnat_error_handler;
act.sa_flags = SA_SIGINFO | SA_ONSTACK;
(void) sigemptyset (&act.sa_mask);
(void) sigaction (SIGFPE, &act, NULL);
(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)
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 ();
#ifdef __mips_vxworks
#if 0
intConnect (INUM_TO_IVEC (IV_TRAP_VEC), &__gnat_int_handler, IV_TRAP_VEC);
#endif
#endif
}
#elif defined(__rtems__)
extern void __gnat_install_handler ();
void
__gnat_initialize ()
{
__gnat_install_handler ();
}
#else
void
__gnat_initialize ()
{
}
void
__gnat_install_handler ()
{
__gnat_handler_installed = 1;
}
#endif
#if defined (_WIN32) || defined (__INTERIX) || defined (__EMX__) \
|| defined (__Lynx__)
#define HAVE_GNAT_INIT_FLOAT
void
__gnat_init_float ()
{
#if defined (__i386__) || defined (i386)
asm ("finit");
#endif
}
#endif
#ifndef HAVE_GNAT_INIT_FLOAT
void
__gnat_init_float ()
{
}
#endif