New Language: Ada

From-SVN: r45955

1 files changed, 2027 insertions, 0 deletions

diff --git a/gcc/ada/init.c b/gcc/ada/init.c
new file mode 100644
index 00000000000..77d0d6f967e
--- /dev/null
+++ b/gcc/ada/init.c
@@ -0,0 +1,2027 @@
+/****************************************************************************
+ *                                                                          *
+ *                         GNAT COMPILER COMPONENTS                         *
+ *                                                                          *
+ *                                 I N I T                                  *
+ *                                                                          *
+ *                            $Revision: 1.1 $
+ *                                                                          *
+ *                          C Implementation File                           *
+ *                                                                          *
+ *          Copyright (C) 1992-2001 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- *
+ * ware  Foundation;  either version 2,  or (at your option) any later ver- *
+ * sion.  GNAT is distributed in the hope that it will be useful, but WITH- *
+ * OUT ANY WARRANTY;  without even the  implied warranty of MERCHANTABILITY *
+ * 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.                                                      *
+ *                                                                          *
+ * 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 *
+ * executable to be covered by the GNU General Public License. This except- *
+ * ion does not  however invalidate  any other reasons  why the  executable *
+ * 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). *
+ *                                                                          *
+ ****************************************************************************/
+
+/*  This unit contains initialization circuits that are system dependent. A
+    major part of the functionality involved involves stack overflow checking.
+    The GCC backend generates probe instructions to test for stack overflow.
+    For details on the exact approach used to generate these probes, see the
+    "Using and Porting GCC" manual, in particular the "Stack Checking" section
+    and the subsection "Specifying How Stack Checking is Done". The handlers
+    installed by this file are used to handle resulting signals that come
+    from these probes failing (i.e. touching protected pages) */
+
+/* The following include is here to meet the published VxWorks requirement
+   that the __vxworks header appear before any other include. */
+#ifdef __vxworks
+#include "vxWorks.h"
+#endif
+
+#ifdef IN_RTS
+#include "tconfig.h"
+#include "tsystem.h"
+#include <sys/stat.h>
+#else
+#include "config.h"
+#include "system.h"
+#endif
+
+#include "adaint.h"
+#include "raise.h"
+
+extern void __gnat_raise_program_error (const char *, int);
+
+/* Addresses of exception data blocks for predefined exceptions. */
+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 *,
+						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 
+   installed by a previous call to adainit */
+int  __gnat_handler_installed      = 0;
+
+/* 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_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.  */
+
+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;
+{
+  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. */
+
+/***********************************/
+/* __gnat_initialize (AIX version) */
+/***********************************/
+
+#if defined (_AIX)
+
+/* AiX doesn't have SA_NODEFER */
+
+#define SA_NODEFER 0
+
+#include <sys/time.h>
+
+/* AiX doesn't have nanosleep, but provides nsleep instead */
+
+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;
+  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 ()
+{
+}
+
+/****************************************/
+/* __gnat_initialize (Dec Unix version) */
+/****************************************/
+
+#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.  */
+
+#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 this was an explicit signal from a "kill", just resignal it.  */
+  if (SI_FROMUSER (sip))
+    {
+      signal (sig, SIG_DFL);
+      kill (getpid(), sig);
+    }
+
+  /* Otherwise, treat it as something we handle.  */
+  switch (sig)
+    {
+    case SIGSEGV:
+      /* If the problem was permissions, this is a constraint error.
+	 Likewise if the failing address isn't maximally aligned or if
+	 we've recursed.
+
+	 ??? Using a static variable here isn't task-safe, but it's
+	 much too hard to do anything else and we're just determining
+	 which exception to raise.  */
+      if (sip->si_code == SEGV_ACCERR
+	  || (((long) sip->si_addr) & 3) != 0
+	  || recurse)
+	{
+	  exception = &constraint_error;
+	  msg = "SIGSEGV";
+	}
+      else
+	{
+	  /* See if the page before the faulting page is accessable.  Do that
+	     by trying to access it.  We'd like to simply try to access
+	     4096 + the faulting address, but it's not guaranteed to be
+	     the actual address, just to be on the same page.  */
+	  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;
+
+  /* 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! */
+
+  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);
+    }
+
+  __gnat_handler_installed = 1;
+}
+
+void
+__gnat_initialize ()
+{
+}
+
+/* Routines called by 5amastop.adb.  */
+
+#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);
+}
+
+/***********************************/
+/* __gnat_initialize (HPUX version) */
+/***********************************/
+
+#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:
+      /* 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! Also setup an alternate
+     stack region for the handler execution so that stack overflows can be
+     handled properly, avoiding a SEGV generation from stack usage by the
+     handler itself. */
+
+  static char handler_stack [SIGSTKSZ];
+
+  stack_t stack;
+
+  stack.ss_sp    = handler_stack;
+  stack.ss_size  = SIGSTKSZ;
+  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);
+
+  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 (Linux version) */
+/*************************************/
+
+#elif defined (linux) && defined (i386) && !defined (__RT__)
+
+#include <signal.h>
+#include <asm/sigcontext.h>
+
+/* Linux with GNU libc does not define NULL in included header files */
+
+#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;
+  char *msg;
+  static int recurse = 0;
+
+  struct sigcontext *info
+    = (struct sigcontext *) (((char *) &sig) + sizeof (int));
+  /* Linux does not document how to get the machine state in a signal handler,
+     but in fact the necessary data is in a sigcontext_struct value that is
+     on the stack immediately above the signal number parameter, and the
+     above messing accesses this value on the stack. */
+
+  struct Machine_State *mstate;
+
+  switch (sig)
+    {
+    case SIGSEGV:
+      /* If the problem was permissions, this is a constraint error.
+       Likewise if the failing address isn't maximally aligned or if
+       we've recursed.
+
+       ??? Using a static variable here isn't task-safe, but it's
+       much too hard to do anything else and we're just determining
+       which exception to raise.  */
+      if (recurse)
+      {
+        exception = &constraint_error;
+        msg = "SIGSEGV";
+      }
+      else
+      {
+        /* Here we would like a discrimination test to see whether the
+           page before the faulting address is accessible. Unfortunately
+           Linux seems to have no way of giving us the faulting address.
+
+           In versions of a-init.c before 1.95, we had a test of the page
+           before the stack pointer using:
+
+            recurse++;
+             ((volatile char *)
+              ((long) info->esp_at_signal & - getpagesize ()))[getpagesize ()];
+
+           but that's wrong, since it tests the stack pointer location, and
+           the current stack probe code does not move the stack pointer
+           until all probes succeed.
+
+           For now we simply do not attempt any discrimination at all. Note
+           that this is quite acceptable, since a "real" SIGSEGV can only
+           occur as the result of an erroneous program */
+
+        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;
+
+  /* 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 ()
+{
+}
+
+/******************************************/
+/* __gnat_initialize (NT-mingw32 version) */
+/******************************************/
+
+#elif defined (__MINGW32__)
+#include <windows.h>
+
+static LONG __gnat_error_handler PARAMS ((PEXCEPTION_POINTERS));
+
+/* __gnat_initialize (mingw32).  */
+
+static LONG
+__gnat_error_handler (info)
+     PEXCEPTION_POINTERS info;
+{
+  static int recurse;
+  struct Exception_Data *exception;
+  char *msg;
+
+  switch (info->ExceptionRecord->ExceptionCode)
+    {
+    case EXCEPTION_ACCESS_VIOLATION:
+      /* If the failing address isn't maximally-aligned or if we've
+	 recursed, this is a program error.  */
+      if ((info->ExceptionRecord->ExceptionInformation[1] & 3) != 0
+	  || recurse)
+	{
+	  exception = &program_error;
+	  msg = "EXCEPTION_ACCESS_VIOLATION";
+	}
+      else
+	{
+	  /* See if the page before the faulting page is accessable.  Do that
+	     by trying to access it. */
+	  recurse++;
+	  * ((volatile char *) (info->ExceptionRecord->ExceptionInformation[1]
+				+ 4096));
+	  exception = &storage_error;
+	  msg = "stack overflow (or erroneous memory access)";
+	}
+      break;
+
+    case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
+      exception = &constraint_error;
+      msg = "EXCEPTION_ARRAY_BOUNDS_EXCEEDED";
+      break;
+
+    case EXCEPTION_DATATYPE_MISALIGNMENT:
+      exception = &constraint_error;
+      msg = "EXCEPTION_DATATYPE_MISALIGNMENT";
+      break;
+
+    case EXCEPTION_FLT_DENORMAL_OPERAND:
+      exception = &constraint_error;
+      msg = "EXCEPTION_FLT_DENORMAL_OPERAND";
+      break;
+
+    case EXCEPTION_FLT_DIVIDE_BY_ZERO:
+      exception = &constraint_error;
+      msg = "EXCEPTION_FLT_DENORMAL_OPERAND";
+      break;
+
+    case EXCEPTION_FLT_INVALID_OPERATION:
+      exception = &constraint_error;
+      msg = "EXCEPTION_FLT_INVALID_OPERATION";
+      break;
+
+    case EXCEPTION_FLT_OVERFLOW:
+      exception = &constraint_error;
+      msg = "EXCEPTION_FLT_OVERFLOW";
+      break;
+
+    case EXCEPTION_FLT_STACK_CHECK:
+      exception = &program_error;
+      msg = "EXCEPTION_FLT_STACK_CHECK";
+      break;
+
+    case EXCEPTION_FLT_UNDERFLOW:
+      exception = &constraint_error;
+      msg = "EXCEPTION_FLT_UNDERFLOW";
+      break;
+
+    case EXCEPTION_INT_DIVIDE_BY_ZERO:
+      exception = &constraint_error;
+      msg = "EXCEPTION_INT_DIVIDE_BY_ZERO";
+      break;
+
+    case EXCEPTION_INT_OVERFLOW:
+      exception = &constraint_error;
+      msg = "EXCEPTION_INT_OVERFLOW";
+      break;
+
+    case EXCEPTION_INVALID_DISPOSITION:
+      exception = &program_error;
+      msg = "EXCEPTION_INVALID_DISPOSITION";
+      break;
+
+    case EXCEPTION_NONCONTINUABLE_EXCEPTION:
+      exception = &program_error;
+      msg = "EXCEPTION_NONCONTINUABLE_EXCEPTION";
+      break;
+
+    case EXCEPTION_PRIV_INSTRUCTION:
+      exception = &program_error;
+      msg = "EXCEPTION_PRIV_INSTRUCTION";
+      break;
+
+    case EXCEPTION_SINGLE_STEP:
+      exception = &program_error;
+      msg = "EXCEPTION_SINGLE_STEP";
+      break;
+
+    case EXCEPTION_STACK_OVERFLOW:
+      exception = &storage_error;
+      msg = "EXCEPTION_STACK_OVERFLOW";
+      break;
+
+   default:
+      exception = &program_error;
+      msg = "unhandled signal";
+    }
+
+  recurse = 0;
+  Raise_From_Signal_Handler (exception, msg);
+}
+
+void
+__gnat_install_handler ()
+{
+  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) */
+/**************************************/
+
+#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;
+
+  /* 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 = 0;
+  (void) 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) */
+/**************************************/
+
+#elif defined (__Lynx__)
+
+void
+__gnat_initialize ()
+{
+   __gnat_init_float ();
+}
+
+/*********************************/
+/* __gnat_install_handler (Lynx) */
+/*********************************/
+
+void
+__gnat_install_handler ()
+{
+  __gnat_handler_installed = 1;
+}
+
+/****************************/
+/* __gnat_initialize (OS/2) */
+/****************************/
+
+#elif defined (__EMX__) /* OS/2 dependent initialization */
+
+void
+__gnat_initialize ()
+{
+}
+
+/*********************************/
+/* __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>
+
+#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; /* ??? storage_error ??? */
+	  msg = "SIGSEGV: (Autogrow for file failed)";
+	}
+      else if (code == EACCES)
+	{
+	  /* ??? Re-add smarts to further verify that we launched
+		 the stack into a guard page, not an attempt to
+		 write to .text or something */
+	  exception = &storage_error;
+	  msg = "SIGSEGV: (stack overflow or erroneous memory access)";
+	}
+      else
+	{
+	  /* Just in case the OS guys did it to us again.  Sometimes
+	     they fail to document all of the valid codes that are
+	     passed to signal handlers, just in case someone depends
+	     on knowing all the codes */
+	  exception = &program_error;
+	  msg = "SIGSEGV: (Undocumented reason)";
+	}
+      break;
+
+    case SIGBUS:
+      /* Map all bus errors to Program_Error.  */
+      exception = &program_error;
+      msg = "SIGBUS";
+      break;
+
+    case SIGFPE:
+      /* Map all fpe errors to Constraint_Error.  */
+      exception = &constraint_error;
+      msg = "SIGFPE";
+      break;
+
+    case SIGADAABORT:
+      if ((*Check_Abort_Status) ())
+	{
+	  exception = &_abort_signal;
+	  msg = "";
+	}
+      else
+	return;
+
+      break;
+
+    default:
+      /* Everything else is a Program_Error. */
+      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;
+
+  /* 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! */
+
+  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);
+
+  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) */
+/*************************************************/
+
+#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 this was an explicit signal from a "kill", just resignal it.  */
+  if (SI_FROMUSER (sip))
+    {
+      signal (sig, SIG_DFL);
+      kill (getpid(), sig);
+    }
+
+  /* Otherwise, treat it as something we handle.  */
+  switch (sig)
+    {
+    case SIGSEGV:
+      /* If the problem was permissions, this is a constraint error.
+	 Likewise if the failing address isn't maximally aligned or if
+	 we've recursed.
+
+	 ??? Using a static variable here isn't task-safe, but it's
+	 much too hard to do anything else and we're just determining
+	 which exception to raise.  */
+      if (sip->si_code == SEGV_ACCERR
+	  || (((long) sip->si_addr) & 3) != 0
+	  || recurse)
+	{
+	  exception = &constraint_error;
+	  msg = "SIGSEGV";
+	}
+      else
+	{
+	  /* See if the page before the faulting page is accessable.  Do that
+	     by trying to access it.  We'd like to simply try to access
+	     4096 + the faulting address, but it's not guaranteed to be
+	     the actual address, just to be on the same page.  */
+	  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;
+
+  /* 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 | SA_SIGINFO;
+  (void) sigemptyset (&act.sa_mask);
+
+  (void) sigaction (SIGABRT, &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 */
+
+#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 ()
+{
+}
+
+/***********************************/
+/* __gnat_initialize (VMS version) */
+/***********************************/
+
+#elif defined (VMS)
+
+/* The prehandler actually gets control first on a condition. It swaps the
+   stack pointer and calls the handler (__gnat_error_handler). */
+extern long __gnat_error_prehandler ();
+
+extern char *__gnat_error_prehandler_stack;   /* Alternate signal stack */
+
+/* Conditions that don't have an Ada exception counterpart must raise
+   Non_Ada_Error.  Since this is defined in s-auxdec, it should only be
+   referenced by user programs, not the compiler or tools. Hence the
+   #ifdef IN_RTS. */
+
+#ifdef IN_RTS
+#define Non_Ada_Error system__aux_dec__non_ada_error
+extern struct Exception_Data Non_Ada_Error;
+
+#define Coded_Exception system__vms_exception_table__coded_exception
+extern struct Exception_Data *Coded_Exception (int);
+#endif
+
+/* 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. */
+
+#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
+
+struct descriptor_s {unsigned short len, mbz; char *adr; };
+
+static long __gnat_error_handler PARAMS ((int *, void *));
+
+static 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; /* 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])
+  {
+
+    case CMA$_EXIT_THREAD:
+      return SS$_RESIGNAL;
+
+    case SS$_DEBUG: /* Gdb attach, resignal to merge activate gdbstub. */
+      return SS$_RESIGNAL;
+
+    case 1409786: /* Nickerson bug #33 ??? */
+      return SS$_RESIGNAL;
+
+    case 1381050: /* Nickerson bug #33 ??? */
+      return SS$_RESIGNAL;
+
+    case 11829410: /* Resignalled as Use_Error for CE10VRC */
+      return SS$_RESIGNAL;
+
+  }
+
+#ifdef IN_RTS
+  /* See if it's an imported exception. Mask off severity bits. */
+  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;
+      /* The full name really should be get sys$getmsg returns. ??? */
+      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; /* toplev.c handles for compiler */
+#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
+	/* User programs expect Non_Ada_Error to be raised, reference
+	   DEC Ada test CXCONDHAN. */
+	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 *) malloc (1025);
+
+  __gnat_error_prehandler_stack = &c[1024];
+
+  /* __gnat_error_prehandler is an assembly function.  */
+  SYS$SETEXV (1, __gnat_error_prehandler, 3, &prvhnd);
+  __gnat_handler_installed = 1;
+}
+
+void
+__gnat_initialize()
+{
+}
+
+/***************************************/
+/* __gnat_initialize (VXWorks version) */
+/***************************************/
+
+#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;
+{
+  /* Note that we should use something like Raise_From_Int_Handler here, but
+     for now Raise_From_Signal_Handler will do the job. ??? */
+
+  Raise_From_Signal_Handler (&storage_error, "stack overflow");
+}
+
+/* Used for stack-checking on VxWorks. Must be task-local in
+   tasking programs */
+
+void *__gnat_stack_limit = NULL;
+
+#ifndef __alpha_vxworks
+
+/* getpid is used by s-parint.adb, but is not defined by VxWorks, except
+   on Alpha VxWorks */
+
+extern long getpid PARAMS ((void));
+
+long
+getpid ()
+{
+  return taskIdSelf ();
+}
+#endif
+
+/* This is needed by the GNAT run time to handle Vxworks interrupts */
+int
+__gnat_inum_to_ivec (num)
+     int num;
+{
+  return INUM_TO_IVEC (num);
+}
+
+static void
+__gnat_error_handler (sig, code, sc)
+     int sig;
+     int code;
+     struct sigcontext *sc;
+{
+  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";
+      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;
+
+  /* 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! */
+
+  act.sa_handler = __gnat_error_handler;
+  act.sa_flags = SA_SIGINFO | SA_ONSTACK;
+  (void) sigemptyset (&act.sa_mask);
+
+  (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;
+}
+
+#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 ();
+
+#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
+}
+
+
+/***************************************/
+/* __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
+#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.  */
+
+typedef int ptr_type __attribute__ ((mode (pointer)));
+
+static void get_reg			PARAMS ((unsigned int, frame_state *,
+						 frame_state *));
+static void put_reg			PARAMS ((unsigned int, void *,
+						 frame_state *));
+static void copy_reg			PARAMS ((unsigned int, frame_state *,
+						 frame_state *));
+static inline void put_return_addr	PARAMS ((void *, frame_state *));
+static inline void *get_return_addr	PARAMS ((frame_state *,
+						 frame_state *));
+static frame_state *__frame_state_for_r	PARAMS ((void *, frame_state *));
+
+#ifdef INCOMING_REGNO
+static int in_reg_window		PARAMS ((unsigned int, frame_state *));
+#endif
+
+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;
+{
+  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 ();
+}
+
+/* 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;
+{
+  if (udata->saved[reg] == REG_SAVED_OFFSET)
+    *(word_type *) (udata->cfa + udata->reg_or_offset[reg])
+      = (word_type) (ptr_type) val;
+  else
+    abort ();
+}
+
+/* Copy the saved value for register REG from frame UDATA to frame
+   TARGET_UDATA.  Unlike the previous two functions, this can handle
+   registers that are not one word large.  */
+
+static void
+copy_reg (reg, udata, target_udata)
+     unsigned int reg;
+     frame_state *udate, *target_udata;
+{
+  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 ();
+}
+
+/* Overwrite the return address for frame UDATA with VAL.  */
+
+static inline void
+put_return_addr (val, udata)
+     void *val;
+     frame_state *udata;
+{
+  val = __builtin_frob_return_addr (val);
+  put_reg (udata->retaddr_column, val, udata);
+}
+
+#ifdef INCOMING_REGNO
+
+/* Is the saved value for register REG in frame UDATA stored in a register
+   window in the previous frame?  */
+
+static int
+in_reg_window (reg, udata)
+     unsigned int reg;
+     frame_state *udata;
+{
+  if (udata->saved[reg] != REG_SAVED_OFFSET)
+    return 0;
+
+#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;
+{
+  return __builtin_extract_return_addr (get_reg (udata->retaddr_column,
+						 udata, sub_udata));
+}
+
+/* Thread-safe version of __frame_state_for */
+
+static frame_state *
+__frame_state_for_r (void *pc_target, frame_state *state_in)
+     void *pc_target;
+     frame_state *state_in;
+{
+  frame_state *f;
+
+  (*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;
+{
+  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 this code for now since it doesn't work properly */
+#if 0
+  if (m->pc == m->pc_start)
+    return;
+
+  /* Copy the frame's saved register values into our register save slots.  */
+
+  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);
+      }
+#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;
+
+  /* Do any necessary initialization to access arbitrary stack frames.
+     On the SPARC, this means flushing the register windows.  */
+  __builtin_unwind_init ();
+
+  /* go up one frame */
+  __gnat_pop_frame (machine_state);
+}
+
+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
+
+  /* Emit the stub to adjust sp and jump to the handler.  */
+  retaddr = __builtin_eh_stub ();
+
+  /* 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);
+
+  /* Epilogue:  restore the handler frame's register values and return
+     to the stub.  */
+}
+
+__SIZE_TYPE__
+__gnat_machine_state_length ()
+{
+  return sizeof (struct machine_state);
+}
+
+void *
+__gnat_get_code_loc (m)
+     struct machine_state *m;
+{
+  return m->pc;
+}
+#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 ()
+{
+}
+
+/********************************************/
+/* __gnat_install_handler (default version) */
+/********************************************/
+
+void
+__gnat_install_handler ()
+{
+  __gnat_handler_installed = 1;
+}
+
+#endif
+
+
+/*********************/
+/* __gnat_init_float */
+/*********************/
+
+/* This routine is called as each process thread is created, for possible
+   initialization of the FP processor. This version is used under INTERIX,
+   WIN32 and could be used under OS/2 */
+
+#if defined (_WIN32) || defined (__INTERIX) || defined (__EMX__) \
+  || defined (__Lynx__)
+
+#define HAVE_GNAT_INIT_FLOAT
+
+void
+__gnat_init_float ()
+{
+#if defined (__i386__) || defined (i386)
+
+  /* This is used to properly initialize the FPU on an x86 for each
+     process thread. */
+
+  asm ("finit");
+
+#endif  /* 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 ()
+{
+}
+#endif