gcc/ada/init.c

   1 /****************************************************************************
   2  *                                                                          *
   3  *                         GNAT COMPILER COMPONENTS                         *
   4  *                                                                          *
   5  *                                 I N I T                                  *
   6  *                                                                          *
   7  *                                                                          *
   8  *                          C Implementation File                           *
   9  *                                                                          *
  10  *          Copyright (C) 1992-2003 Free Software Foundation, Inc.          *
  11  *                                                                          *
  12  * GNAT is free software;  you can  redistribute it  and/or modify it under *
  13  * terms of the  GNU General Public License as published  by the Free Soft- *
  14  * ware  Foundation;  either version 2,  or (at your option) any later ver- *
  15  * sion.  GNAT is distributed in the hope that it will be useful, but WITH- *
  16  * OUT ANY WARRANTY;  without even the  implied warranty of MERCHANTABILITY *
  17  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License *
  18  * for  more details.  You should have  received  a copy of the GNU General *
  19  * Public License  distributed with GNAT;  see file COPYING.  If not, write *
  20  * to  the Free Software Foundation,  59 Temple Place - Suite 330,  Boston, *
  21  * MA 02111-1307, USA.                                                      *
  22  *                                                                          *
  23  * As a  special  exception,  if you  link  this file  with other  files to *
  24  * produce an executable,  this file does not by itself cause the resulting *
  25  * executable to be covered by the GNU General Public License. This except- *
  26  * ion does not  however invalidate  any other reasons  why the  executable *
  27  * file might be covered by the  GNU Public License.                        *
  28  *                                                                          *
  29  * GNAT was originally developed  by the GNAT team at  New York University. *
  30  * Extensive contributions were provided by Ada Core Technologies Inc.      *
  31  *                                                                          *
  32  ****************************************************************************/
  33
  34 /*  This unit contains initialization circuits that are system dependent. A
  35     major part of the functionality involved involves stack overflow checking.
  36     The GCC backend generates probe instructions to test for stack overflow.
  37     For details on the exact approach used to generate these probes, see the
  38     "Using and Porting GCC" manual, in particular the "Stack Checking" section
  39     and the subsection "Specifying How Stack Checking is Done". The handlers
  40     installed by this file are used to handle resulting signals that come
  41     from these probes failing (i.e. touching protected pages) */
  42
  43 /* The following include is here to meet the published VxWorks requirement
  44    that the __vxworks header appear before any other include. */
  45 #ifdef __vxworks
  46 #include "vxWorks.h"
  47 #endif
  48
  49 #ifdef IN_RTS
  50 #include "tconfig.h"
  51 #include "tsystem.h"
  52 #include <sys/stat.h>
  53
  54 /* We don't have libiberty, so us malloc.  */
  55 #define xmalloc(S) malloc (S)
  56 #else
  57 #include "config.h"
  58 #include "system.h"
  59 #endif
  60
  61 #include "adaint.h"
  62 #include "raise.h"
  63
  64 extern void __gnat_raise_program_error (const char *, int);
  65
  66 /* Addresses of exception data blocks for predefined exceptions. */
  67 extern struct Exception_Data constraint_error;
  68 extern struct Exception_Data numeric_error;
  69 extern struct Exception_Data program_error;
  70 extern struct Exception_Data storage_error;
  71 extern struct Exception_Data tasking_error;
  72 extern struct Exception_Data _abort_signal;
  73
  74 #define Lock_Task system__soft_links__lock_task
  75 extern void (*Lock_Task) PARAMS ((void));
  76
  77 #define Unlock_Task system__soft_links__unlock_task
  78 extern void (*Unlock_Task) PARAMS ((void));
  79
  80 #define Get_Machine_State_Addr \
  81                       system__soft_links__get_machine_state_addr
  82 extern struct Machine_State *(*Get_Machine_State_Addr) PARAMS ((void));
  83
  84 #define Check_Abort_Status     \
  85                       system__soft_links__check_abort_status
  86 extern int    (*Check_Abort_Status) PARAMS ((void));
  87
  88 #define Raise_From_Signal_Handler \
  89                       ada__exceptions__raise_from_signal_handler
  90 extern void   Raise_From_Signal_Handler PARAMS ((struct Exception_Data *,
  91                                                 const char *));
  92
  93 #define Propagate_Signal_Exception \
  94                       __gnat_propagate_sig_exc
  95 extern void   Propagate_Signal_Exception
  96         PARAMS ((struct Machine_State *, struct Exception_Data *, const char *));
  97
  98 /* Copies of global values computed by the binder */
  99 int   __gl_main_priority            = -1;
 100 int   __gl_time_slice_val           = -1;
 101 char  __gl_wc_encoding              = 'n';
 102 char  __gl_locking_policy           = ' ';
 103 char  __gl_queuing_policy           = ' ';
 104 char *__gl_restrictions             = 0;
 105 char  __gl_task_dispatching_policy  = ' ';
 106 int   __gl_unreserve_all_interrupts = 0;
 107 int   __gl_exception_tracebacks     = 0;
 108 int   __gl_zero_cost_exceptions     = 0;
 109
 110 /* Indication of whether synchronous signal handler has already been
 111    installed by a previous call to adainit */
 112 int  __gnat_handler_installed      = 0;
 113
 114 /* HAVE_GNAT_INIT_FLOAT must be set on every targets where a __gnat_init_float
 115    is defined. If this is not set them a void implementation will be defined
 116    at the end of this unit. */
 117 #undef HAVE_GNAT_INIT_FLOAT
 118
 119 /**********************/
 120 /* __gnat_set_globals */
 121 /**********************/
 122
 123 /* This routine is called from the binder generated main program.  It copies
 124    the values for global quantities computed by the binder into the following
 125    global locations. The reason that we go through this copy, rather than just
 126    define the global locations in the binder generated file, is that they are
 127    referenced from the runtime, which may be in a shared library, and the
 128    binder file is not in the shared library. Global references across library
 129    boundaries like this are not handled correctly in all systems.  */
 130
 131 void
 132 __gnat_set_globals (main_priority, time_slice_val, wc_encoding, locking_policy,
 133                     queuing_policy, task_dispatching_policy, restrictions,
 134                     unreserve_all_interrupts, exception_tracebacks,
 135                     zero_cost_exceptions)
 136      int main_priority;
 137      int time_slice_val;
 138      char wc_encoding;
 139      char locking_policy, queuing_policy, task_dispatching_policy;
 140      char *restrictions;
 141      int unreserve_all_interrupts, exception_tracebacks, zero_cost_exceptions;
 142 {
 143   static int already_called = 0;
 144
 145   /* If this procedure has been already called once, check that the
 146      arguments in this call are consistent with the ones in the previous
 147      calls. Otherwise, raise a Program_Error exception.
 148
 149      We do not check for consistency of the wide character encoding
 150      method. This default affects only Wide_Text_IO where no explicit
 151      coding method is given, and there is no particular reason to let
 152      this default be affected by the source representation of a library
 153      in any case.
 154
 155      The value of main_priority is meaningful only when we are invoked
 156      from the main program elaboration routine of an Ada application.
 157      Checking the consistency of this parameter should therefore not be
 158      done. Since it is assured that the main program elaboration will
 159      always invoke this procedure before any library elaboration
 160      routine, only the value of main_priority during the first call
 161      should be taken into account and all the subsequent ones should be
 162      ignored. Note that the case where the main program is not written
 163      in Ada is also properly handled, since the default value will then
 164      be used for this parameter.
 165
 166      For identical reasons, the consistency of time_slice_val should not
 167      be checked. */
 168
 169   if (already_called)
 170     {
 171       if (__gl_locking_policy              != locking_policy
 172           || __gl_queuing_policy           != queuing_policy
 173           || __gl_task_dispatching_policy  != task_dispatching_policy
 174           || __gl_unreserve_all_interrupts != unreserve_all_interrupts
 175           || __gl_exception_tracebacks     != exception_tracebacks
 176           || __gl_zero_cost_exceptions     != zero_cost_exceptions)
 177         __gnat_raise_program_error (__FILE__, __LINE__);
 178
 179       return;
 180     }
 181   already_called = 1;
 182
 183   __gl_main_priority            = main_priority;
 184   __gl_time_slice_val           = time_slice_val;
 185   __gl_wc_encoding              = wc_encoding;
 186   __gl_locking_policy           = locking_policy;
 187   __gl_queuing_policy           = queuing_policy;
 188   __gl_restrictions             = restrictions;
 189   __gl_task_dispatching_policy  = task_dispatching_policy;
 190   __gl_unreserve_all_interrupts = unreserve_all_interrupts;
 191   __gl_exception_tracebacks     = exception_tracebacks;
 192
 193   /* ??? __gl_zero_cost_exceptions is new in 3.15 and is referenced from
 194      a-except.adb, which is also part of the compiler sources. Since the
 195      compiler is built with an older release of GNAT, the call generated by
 196      the old binder to this function does not provide any value for the
 197      corresponding argument, so the global has to be initialized in some
 198      reasonable other way. This could be removed as soon as the next major
 199      release is out.  */
 200
 201 #ifdef IN_RTS
 202   __gl_zero_cost_exceptions = zero_cost_exceptions;
 203 #else
 204   __gl_zero_cost_exceptions = 0;
 205   /* We never build the compiler to run in ZCX mode currently anyway.  */
 206 #endif
 207 }
 208
 209 /*********************/
 210 /* __gnat_initialize */
 211 /*********************/
 212
 213 /* __gnat_initialize is called at the start of execution of an Ada program
 214    (the call is generated by the binder). The standard routine does nothing
 215    at all; the intention is that this be replaced by system specific
 216    code where initialization is required. */
 217
 218 /***********************************/
 219 /* __gnat_initialize (AIX version) */
 220 /***********************************/
 221
 222 #if defined (_AIX)
 223
 224 /* AiX doesn't have SA_NODEFER */
 225
 226 #define SA_NODEFER 0
 227
 228 #include <sys/time.h>
 229
 230 /* AiX doesn't have nanosleep, but provides nsleep instead */
 231
 232 extern int nanosleep PARAMS ((struct timestruc_t *, struct timestruc_t *));
 233 static void __gnat_error_handler PARAMS ((int));
 234
 235 int
 236 nanosleep (Rqtp, Rmtp)
 237      struct timestruc_t *Rqtp, *Rmtp;
 238 {
 239   return nsleep (Rqtp, Rmtp);
 240 }
 241
 242 #include <signal.h>
 243
 244 static void
 245 __gnat_error_handler (sig)
 246      int sig;
 247 {
 248   struct Exception_Data *exception;
 249   const char *msg;
 250
 251   switch (sig)
 252     {
 253     case SIGSEGV:
 254       /* FIXME: we need to detect the case of a *real* SIGSEGV */
 255       exception = &storage_error;
 256       msg = "stack overflow or erroneous memory access";
 257       break;
 258
 259     case SIGBUS:
 260       exception = &constraint_error;
 261       msg = "SIGBUS";
 262       break;
 263
 264     case SIGFPE:
 265       exception = &constraint_error;
 266       msg = "SIGFPE";
 267       break;
 268
 269     default:
 270       exception = &program_error;
 271       msg = "unhandled signal";
 272     }
 273
 274   Raise_From_Signal_Handler (exception, msg);
 275 }
 276
 277 void
 278 __gnat_install_handler ()
 279 {
 280   struct sigaction act;
 281
 282   /* Set up signal handler to map synchronous signals to appropriate
 283      exceptions.  Make sure that the handler isn't interrupted by another
 284      signal that might cause a scheduling event! */
 285
 286   act.sa_handler = __gnat_error_handler;
 287   act.sa_flags = SA_NODEFER | SA_RESTART;
 288   (void) sigemptyset (&act.sa_mask);
 289
 290   (void) sigaction (SIGABRT, &act, NULL);
 291   (void) sigaction (SIGFPE,  &act, NULL);
 292   (void) sigaction (SIGILL,  &act, NULL);
 293   (void) sigaction (SIGSEGV, &act, NULL);
 294   (void) sigaction (SIGBUS,  &act, NULL);
 295   __gnat_handler_installed = 1;
 296 }
 297
 298 void
 299 __gnat_initialize ()
 300 {
 301 }
 302
 303 /****************************************/
 304 /* __gnat_initialize (Dec Unix version) */
 305 /****************************************/
 306
 307 #elif defined(__alpha__) && defined(__osf__) && ! defined(__alpha_vxworks)
 308
 309 /* Note: it seems that __osf__ is defined for the Alpha VXWorks case. Not
 310    clear that this is reasonable, but in any case we have to be sure to
 311    exclude this case in the above test.  */
 312
 313 #include <signal.h>
 314 #include <sys/siginfo.h>
 315
 316 static void __gnat_error_handler PARAMS ((int, siginfo_t *,
 317                                           struct sigcontext *));
 318 extern char *__gnat_get_code_loc PARAMS ((struct sigcontext *));
 319 extern void __gnat_enter_handler PARAMS ((struct sigcontext *, char *));
 320 extern size_t __gnat_machine_state_length PARAMS ((void));
 321
 322 extern long exc_lookup_gp PARAMS ((char *));
 323 extern void exc_resume PARAMS ((struct sigcontext *));
 324
 325 static void
 326 __gnat_error_handler (sig, sip, context)
 327      int sig;
 328      siginfo_t *sip;
 329      struct sigcontext *context;
 330 {
 331   struct Exception_Data *exception;
 332   static int recurse = 0;
 333   struct sigcontext *mstate;
 334   const char *msg;
 335
 336   /* If this was an explicit signal from a "kill", just resignal it.  */
 337   if (SI_FROMUSER (sip))
 338     {
 339       signal (sig, SIG_DFL);
 340       kill (getpid(), sig);
 341     }
 342
 343   /* Otherwise, treat it as something we handle.  */
 344   switch (sig)
 345     {
 346     case SIGSEGV:
 347       /* If the problem was permissions, this is a constraint error.
 348          Likewise if the failing address isn't maximally aligned or if
 349          we've recursed.
 350
 351          ??? Using a static variable here isn't task-safe, but it's
 352          much too hard to do anything else and we're just determining
 353          which exception to raise.  */
 354       if (sip->si_code == SEGV_ACCERR
 355           || (((long) sip->si_addr) & 3) != 0
 356           || recurse)
 357         {
 358           exception = &constraint_error;
 359           msg = "SIGSEGV";
 360         }
 361       else
 362         {
 363           /* See if the page before the faulting page is accessible.  Do that
 364              by trying to access it.  We'd like to simply try to access
 365              4096 + the faulting address, but it's not guaranteed to be
 366              the actual address, just to be on the same page.  */
 367           recurse++;
 368           ((volatile char *)
 369            ((long) sip->si_addr & - getpagesize ()))[getpagesize ()];
 370           msg = "stack overflow (or erroneous memory access)";
 371           exception = &storage_error;
 372         }
 373       break;
 374
 375     case SIGBUS:
 376       exception = &program_error;
 377       msg = "SIGBUS";
 378       break;
 379
 380     case SIGFPE:
 381       exception = &constraint_error;
 382       msg = "SIGFPE";
 383       break;
 384
 385     default:
 386       exception = &program_error;
 387       msg = "unhandled signal";
 388     }
 389
 390   recurse = 0;
 391   mstate = (struct sigcontext *) (*Get_Machine_State_Addr) ();
 392   if (mstate != 0)
 393     *mstate = *context;
 394
 395   Raise_From_Signal_Handler (exception, (char *) msg);
 396 }
 397
 398 void
 399 __gnat_install_handler ()
 400 {
 401   struct sigaction act;
 402
 403   /* Setup signal handler to map synchronous signals to appropriate
 404      exceptions. Make sure that the handler isn't interrupted by another
 405      signal that might cause a scheduling event! */
 406
 407   act.sa_handler = (void (*) PARAMS ((int))) __gnat_error_handler;
 408   act.sa_flags = SA_ONSTACK | SA_RESTART | SA_NODEFER | SA_SIGINFO;
 409   (void) sigemptyset (&act.sa_mask);
 410
 411   (void) sigaction (SIGABRT, &act, NULL);
 412   (void) sigaction (SIGFPE,  &act, NULL);
 413   (void) sigaction (SIGILL,  &act, NULL);
 414   (void) sigaction (SIGSEGV, &act, NULL);
 415   (void) sigaction (SIGBUS,  &act, NULL);
 416
 417   __gnat_handler_installed = 1;
 418 }
 419
 420 void
 421 __gnat_initialize ()
 422 {
 423 }
 424
 425 /* Routines called by 5amastop.adb.  */
 426
 427 #define SC_GP 29
 428
 429 char *
 430 __gnat_get_code_loc (context)
 431      struct sigcontext *context;
 432 {
 433   return (char *) context->sc_pc;
 434 }
 435
 436 void
 437 __gnat_enter_handler (context, pc)
 438      struct sigcontext *context;
 439      char *pc;
 440 {
 441   context->sc_pc = (long) pc;
 442   context->sc_regs[SC_GP] = exc_lookup_gp (pc);
 443   exc_resume (context);
 444 }
 445
 446 size_t
 447 __gnat_machine_state_length ()
 448 {
 449   return sizeof (struct sigcontext);
 450 }
 451
 452 /***********************************/
 453 /* __gnat_initialize (HPUX version) */
 454 /***********************************/
 455
 456 #elif defined (hpux)
 457
 458 #include <signal.h>
 459
 460 static void __gnat_error_handler PARAMS ((int));
 461
 462 static void
 463 __gnat_error_handler (sig)
 464      int sig;
 465 {
 466   struct Exception_Data *exception;
 467   char *msg;
 468
 469   switch (sig)
 470     {
 471     case SIGSEGV:
 472       /* FIXME: we need to detect the case of a *real* SIGSEGV */
 473       exception = &storage_error;
 474       msg = "stack overflow or erroneous memory access";
 475       break;
 476
 477     case SIGBUS:
 478       exception = &constraint_error;
 479       msg = "SIGBUS";
 480       break;
 481
 482     case SIGFPE:
 483       exception = &constraint_error;
 484       msg = "SIGFPE";
 485       break;
 486
 487     default:
 488       exception = &program_error;
 489       msg = "unhandled signal";
 490     }
 491
 492   Raise_From_Signal_Handler (exception, msg);
 493 }
 494
 495 void
 496 __gnat_install_handler ()
 497 {
 498   struct sigaction act;
 499
 500   /* Set up signal handler to map synchronous signals to appropriate
 501      exceptions.  Make sure that the handler isn't interrupted by another
 502      signal that might cause a scheduling event! Also setup an alternate
 503      stack region for the handler execution so that stack overflows can be
 504      handled properly, avoiding a SEGV generation from stack usage by the
 505      handler itself. */
 506
 507   static char handler_stack[SIGSTKSZ*2];
 508   /* SIGSTKSZ appeared to be "short" for the needs in some contexts
 509      (e.g. experiments with GCC ZCX exceptions).  */
 510
 511   stack_t stack;
 512
 513   stack.ss_sp    = handler_stack;
 514   stack.ss_size  = sizeof (handler_stack);
 515   stack.ss_flags = 0;
 516
 517   (void) sigaltstack (&stack, NULL);
 518
 519   act.sa_handler = __gnat_error_handler;
 520   act.sa_flags = SA_NODEFER | SA_RESTART | SA_ONSTACK;
 521   (void) sigemptyset (&act.sa_mask);
 522
 523   (void) sigaction (SIGABRT, &act, NULL);
 524   (void) sigaction (SIGFPE,  &act, NULL);
 525   (void) sigaction (SIGILL,  &act, NULL);
 526   (void) sigaction (SIGSEGV, &act, NULL);
 527   (void) sigaction (SIGBUS,  &act, NULL);
 528
 529   __gnat_handler_installed = 1;
 530 }
 531
 532 void
 533 __gnat_initialize ()
 534 {
 535 }
 536
 537 /*************************************/
 538 /* __gnat_initialize (GNU/Linux version) */
 539 /*************************************/
 540
 541 #elif defined (linux) && defined (i386) && !defined (__RT__)
 542
 543 #include <signal.h>
 544 #include <asm/sigcontext.h>
 545
 546 /* GNU/Linux, which uses glibc, does not define NULL in included
 547    header files */
 548
 549 #if !defined (NULL)
 550 #define NULL ((void *) 0)
 551 #endif
 552
 553 struct Machine_State
 554 {
 555   unsigned long eip;
 556   unsigned long ebx;
 557   unsigned long esp;
 558   unsigned long ebp;
 559   unsigned long esi;
 560   unsigned long edi;
 561 };
 562
 563 static void __gnat_error_handler PARAMS ((int));
 564
 565 static void
 566 __gnat_error_handler (sig)
 567      int sig;
 568 {
 569   struct Exception_Data *exception;
 570   const char *msg;
 571   static int recurse = 0;
 572
 573   struct sigcontext *info
 574     = (struct sigcontext *) (((char *) &sig) + sizeof (int));
 575
 576   /* The Linux kernel does not document how to get the machine state in a
 577      signal handler, but in fact the necessary data is in a sigcontext_struct
 578      value that is on the stack immediately above the signal number
 579      parameter, and the above messing accesses this value on the stack. */
 580
 581   struct Machine_State *mstate;
 582
 583   switch (sig)
 584     {
 585     case SIGSEGV:
 586       /* If the problem was permissions, this is a constraint error.
 587        Likewise if the failing address isn't maximally aligned or if
 588        we've recursed.
 589
 590        ??? Using a static variable here isn't task-safe, but it's
 591        much too hard to do anything else and we're just determining
 592        which exception to raise.  */
 593       if (recurse)
 594       {
 595         exception = &constraint_error;
 596         msg = "SIGSEGV";
 597       }
 598       else
 599       {
 600         /* Here we would like a discrimination test to see whether the
 601            page before the faulting address is accessible. Unfortunately
 602            Linux seems to have no way of giving us the faulting address.
 603
 604            In versions of a-init.c before 1.95, we had a test of the page
 605            before the stack pointer using:
 606
 607             recurse++;
 608              ((volatile char *)
 609               ((long) info->esp_at_signal & - getpagesize ()))[getpagesize ()];
 610
 611            but that's wrong, since it tests the stack pointer location, and
 612            the current stack probe code does not move the stack pointer
 613            until all probes succeed.
 614
 615            For now we simply do not attempt any discrimination at all. Note
 616            that this is quite acceptable, since a "real" SIGSEGV can only
 617            occur as the result of an erroneous program */
 618
 619         msg = "stack overflow (or erroneous memory access)";
 620         exception = &storage_error;
 621       }
 622       break;
 623
 624     case SIGBUS:
 625       exception = &constraint_error;
 626       msg = "SIGBUS";
 627       break;
 628
 629     case SIGFPE:
 630       exception = &constraint_error;
 631       msg = "SIGFPE";
 632       break;
 633
 634     default:
 635       exception = &program_error;
 636       msg = "unhandled signal";
 637     }
 638
 639   mstate = (*Get_Machine_State_Addr)();
 640   if (mstate)
 641     {
 642       mstate->eip = info->eip;
 643       mstate->ebx = info->ebx;
 644       mstate->esp = info->esp_at_signal;
 645       mstate->ebp = info->ebp;
 646       mstate->esi = info->esi;
 647       mstate->edi = info->edi;
 648     }
 649
 650   recurse = 0;
 651   Raise_From_Signal_Handler (exception, msg);
 652 }
 653
 654 void
 655 __gnat_install_handler ()
 656 {
 657   struct sigaction act;
 658
 659   /* Set up signal handler to map synchronous signals to appropriate
 660      exceptions.  Make sure that the handler isn't interrupted by another
 661      signal that might cause a scheduling event! */
 662
 663   act.sa_handler = __gnat_error_handler;
 664   act.sa_flags = SA_NODEFER | SA_RESTART;
 665   (void) sigemptyset (&act.sa_mask);
 666
 667   (void) sigaction (SIGABRT, &act, NULL);
 668   (void) sigaction (SIGFPE,  &act, NULL);
 669   (void) sigaction (SIGILL,  &act, NULL);
 670   (void) sigaction (SIGSEGV, &act, NULL);
 671   (void) sigaction (SIGBUS,  &act, NULL);
 672
 673   __gnat_handler_installed = 1;
 674 }
 675
 676 void
 677 __gnat_initialize ()
 678 {
 679 }
 680
 681 /******************************************/
 682 /* __gnat_initialize (NT-mingw32 version) */
 683 /******************************************/
 684
 685 #elif defined (__MINGW32__)
 686 #include <windows.h>
 687
 688 static LONG __gnat_error_handler PARAMS ((PEXCEPTION_POINTERS));
 689
 690 /* __gnat_initialize (mingw32).  */
 691
 692 static LONG
 693 __gnat_error_handler (info)
 694      PEXCEPTION_POINTERS info;
 695 {
 696   static int recurse;
 697   struct Exception_Data *exception;
 698   char *msg;
 699
 700   switch (info->ExceptionRecord->ExceptionCode)
 701     {
 702     case EXCEPTION_ACCESS_VIOLATION:
 703       /* If the failing address isn't maximally-aligned or if we've
 704          recursed, this is a program error.  */
 705       if ((info->ExceptionRecord->ExceptionInformation[1] & 3) != 0
 706           || recurse)
 707         {
 708           exception = &program_error;
 709           msg = "EXCEPTION_ACCESS_VIOLATION";
 710         }
 711       else
 712         {
 713           /* See if the page before the faulting page is accessible.  Do that
 714              by trying to access it. */
 715           recurse++;
 716           * ((volatile char *) (info->ExceptionRecord->ExceptionInformation[1]
 717                                 + 4096));
 718           exception = &storage_error;
 719           msg = "stack overflow (or erroneous memory access)";
 720         }
 721       break;
 722
 723     case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
 724       exception = &constraint_error;
 725       msg = "EXCEPTION_ARRAY_BOUNDS_EXCEEDED";
 726       break;
 727
 728     case EXCEPTION_DATATYPE_MISALIGNMENT:
 729       exception = &constraint_error;
 730       msg = "EXCEPTION_DATATYPE_MISALIGNMENT";
 731       break;
 732
 733     case EXCEPTION_FLT_DENORMAL_OPERAND:
 734       exception = &constraint_error;
 735       msg = "EXCEPTION_FLT_DENORMAL_OPERAND";
 736       break;
 737
 738     case EXCEPTION_FLT_DIVIDE_BY_ZERO:
 739       exception = &constraint_error;
 740       msg = "EXCEPTION_FLT_DENORMAL_OPERAND";
 741       break;
 742
 743     case EXCEPTION_FLT_INVALID_OPERATION:
 744       exception = &constraint_error;
 745       msg = "EXCEPTION_FLT_INVALID_OPERATION";
 746       break;
 747
 748     case EXCEPTION_FLT_OVERFLOW:
 749       exception = &constraint_error;
 750       msg = "EXCEPTION_FLT_OVERFLOW";
 751       break;
 752
 753     case EXCEPTION_FLT_STACK_CHECK:
 754       exception = &program_error;
 755       msg = "EXCEPTION_FLT_STACK_CHECK";
 756       break;
 757
 758     case EXCEPTION_FLT_UNDERFLOW:
 759       exception = &constraint_error;
 760       msg = "EXCEPTION_FLT_UNDERFLOW";
 761       break;
 762
 763     case EXCEPTION_INT_DIVIDE_BY_ZERO:
 764       exception = &constraint_error;
 765       msg = "EXCEPTION_INT_DIVIDE_BY_ZERO";
 766       break;
 767
 768     case EXCEPTION_INT_OVERFLOW:
 769       exception = &constraint_error;
 770       msg = "EXCEPTION_INT_OVERFLOW";
 771       break;
 772
 773     case EXCEPTION_INVALID_DISPOSITION:
 774       exception = &program_error;
 775       msg = "EXCEPTION_INVALID_DISPOSITION";
 776       break;
 777
 778     case EXCEPTION_NONCONTINUABLE_EXCEPTION:
 779       exception = &program_error;
 780       msg = "EXCEPTION_NONCONTINUABLE_EXCEPTION";
 781       break;
 782
 783     case EXCEPTION_PRIV_INSTRUCTION:
 784       exception = &program_error;
 785       msg = "EXCEPTION_PRIV_INSTRUCTION";
 786       break;
 787
 788     case EXCEPTION_SINGLE_STEP:
 789       exception = &program_error;
 790       msg = "EXCEPTION_SINGLE_STEP";
 791       break;
 792
 793     case EXCEPTION_STACK_OVERFLOW:
 794       exception = &storage_error;
 795       msg = "EXCEPTION_STACK_OVERFLOW";
 796       break;
 797
 798    default:
 799       exception = &program_error;
 800       msg = "unhandled signal";
 801     }
 802
 803   recurse = 0;
 804   Raise_From_Signal_Handler (exception, msg);
 805 }
 806
 807 void
 808 __gnat_install_handler ()
 809 {
 810   SetUnhandledExceptionFilter (__gnat_error_handler);
 811   __gnat_handler_installed = 1;
 812 }
 813
 814 void
 815 __gnat_initialize ()
 816 {
 817
 818    /* Initialize floating-point coprocessor. This call is needed because
 819       the MS libraries default to 64-bit precision instead of 80-bit
 820       precision, and we require the full precision for proper operation,
 821       given that we have set Max_Digits etc with this in mind */
 822
 823    __gnat_init_float ();
 824
 825    /* initialize a lock for a process handle list - see a-adaint.c for the
 826       implementation of __gnat_portable_no_block_spawn, __gnat_portable_wait */
 827    __gnat_plist_init();
 828 }
 829
 830 /**************************************/
 831 /* __gnat_initialize (Interix version) */
 832 /**************************************/
 833
 834 #elif defined (__INTERIX)
 835
 836 #include <signal.h>
 837
 838 static void __gnat_error_handler PARAMS ((int));
 839
 840 static void
 841 __gnat_error_handler (sig)
 842      int sig;
 843 {
 844   struct Exception_Data *exception;
 845   char *msg;
 846
 847   switch (sig)
 848     {
 849     case SIGSEGV:
 850       exception = &storage_error;
 851       msg = "stack overflow or erroneous memory access";
 852       break;
 853
 854     case SIGBUS:
 855       exception = &constraint_error;
 856       msg = "SIGBUS";
 857       break;
 858
 859     case SIGFPE:
 860       exception = &constraint_error;
 861       msg = "SIGFPE";
 862       break;
 863
 864     default:
 865       exception = &program_error;
 866       msg = "unhandled signal";
 867     }
 868
 869   Raise_From_Signal_Handler (exception, msg);
 870 }
 871
 872 void
 873 __gnat_install_handler ()
 874 {
 875   struct sigaction act;
 876
 877   /* Set up signal handler to map synchronous signals to appropriate
 878      exceptions.  Make sure that the handler isn't interrupted by another
 879      signal that might cause a scheduling event! */
 880
 881   act.sa_handler = __gnat_error_handler;
 882   act.sa_flags = 0;
 883   (void) sigemptyset (&act.sa_mask);
 884
 885   /* Handlers for signals besides SIGSEGV cause c974013 to hang */
 886 /*  (void) sigaction (SIGILL,  &act, NULL); */
 887 /*  (void) sigaction (SIGABRT, &act, NULL); */
 888 /*  (void) sigaction (SIGFPE,  &act, NULL); */
 889 /*  (void) sigaction (SIGBUS,  &act, NULL); */
 890
 891   (void) sigaction (SIGSEGV, &act, NULL);
 892
 893   __gnat_handler_installed = 1;
 894 }
 895
 896 void
 897 __gnat_initialize ()
 898 {
 899    __gnat_init_float ();
 900 }
 901
 902 /**************************************/
 903 /* __gnat_initialize (LynxOS version) */
 904 /**************************************/
 905
 906 #elif defined (__Lynx__)
 907
 908 void
 909 __gnat_initialize ()
 910 {
 911    __gnat_init_float ();
 912 }
 913
 914 /*********************************/
 915 /* __gnat_install_handler (Lynx) */
 916 /*********************************/
 917
 918 void
 919 __gnat_install_handler ()
 920 {
 921   __gnat_handler_installed = 1;
 922 }
 923
 924 /****************************/
 925 /* __gnat_initialize (OS/2) */
 926 /****************************/
 927
 928 #elif defined (__EMX__) /* OS/2 dependent initialization */
 929
 930 void
 931 __gnat_initialize ()
 932 {
 933 }
 934
 935 /*********************************/
 936 /* __gnat_install_handler (OS/2) */
 937 /*********************************/
 938
 939 void
 940 __gnat_install_handler ()
 941 {
 942   __gnat_handler_installed = 1;
 943 }
 944
 945 /***********************************/
 946 /* __gnat_initialize (SGI version) */
 947 /***********************************/
 948
 949 #elif defined (sgi)
 950
 951 #include <signal.h>
 952 #include <siginfo.h>
 953
 954 #ifndef NULL
 955 #define NULL 0
 956 #endif
 957
 958 #define SIGADAABORT 48
 959 #define SIGNAL_STACK_SIZE 4096
 960 #define SIGNAL_STACK_ALIGNMENT 64
 961
 962 struct Machine_State
 963 {
 964   sigcontext_t context;
 965 };
 966
 967 static void __gnat_error_handler PARAMS ((int, int, sigcontext_t *));
 968
 969 static void
 970 __gnat_error_handler (sig, code, sc)
 971      int sig;
 972      int code;
 973      sigcontext_t *sc;
 974 {
 975   struct Machine_State  *mstate;
 976   struct Exception_Data *exception;
 977   char *msg;
 978
 979   int i;
 980
 981   switch (sig)
 982     {
 983     case SIGSEGV:
 984       if (code == EFAULT)
 985         {
 986           exception = &program_error;
 987           msg = "SIGSEGV: (Invalid virtual address)";
 988         }
 989       else if (code == ENXIO)
 990         {
 991           exception = &program_error;
 992           msg = "SIGSEGV: (Read beyond mapped object)";
 993         }
 994       else if (code == ENOSPC)
 995         {
 996           exception = &program_error; /* ??? storage_error ??? */
 997           msg = "SIGSEGV: (Autogrow for file failed)";
 998         }
 999       else if (code == EACCES)
1000         {
1001           /* ??? Re-add smarts to further verify that we launched
1002                  the stack into a guard page, not an attempt to
1003                  write to .text or something */
1004           exception = &storage_error;
1005           msg = "SIGSEGV: (stack overflow or erroneous memory access)";
1006         }
1007       else
1008         {
1009           /* Just in case the OS guys did it to us again.  Sometimes
1010              they fail to document all of the valid codes that are
1011              passed to signal handlers, just in case someone depends
1012              on knowing all the codes */
1013           exception = &program_error;
1014           msg = "SIGSEGV: (Undocumented reason)";
1015         }
1016       break;
1017
1018     case SIGBUS:
1019       /* Map all bus errors to Program_Error.  */
1020       exception = &program_error;
1021       msg = "SIGBUS";
1022       break;
1023
1024     case SIGFPE:
1025       /* Map all fpe errors to Constraint_Error.  */
1026       exception = &constraint_error;
1027       msg = "SIGFPE";
1028       break;
1029
1030     case SIGADAABORT:
1031       if ((*Check_Abort_Status) ())
1032         {
1033           exception = &_abort_signal;
1034           msg = "";
1035         }
1036       else
1037         return;
1038
1039       break;
1040
1041     default:
1042       /* Everything else is a Program_Error. */
1043       exception = &program_error;
1044       msg = "unhandled signal";
1045     }
1046
1047   mstate = (*Get_Machine_State_Addr)();
1048   if (mstate != 0)
1049     memcpy ((void *) mstate, (const void *) sc, sizeof (sigcontext_t));
1050
1051   Raise_From_Signal_Handler (exception, msg);
1052
1053 }
1054
1055 void
1056 __gnat_install_handler ()
1057 {
1058   stack_t ss;
1059   struct sigaction act;
1060
1061   /* Setup signal handler to map synchronous signals to appropriate
1062      exceptions.  Make sure that the handler isn't interrupted by another
1063      signal that might cause a scheduling event! */
1064
1065   act.sa_handler = __gnat_error_handler;
1066   act.sa_flags = SA_NODEFER + SA_RESTART;
1067   (void) sigfillset (&act.sa_mask);
1068   (void) sigemptyset (&act.sa_mask);
1069
1070   (void) sigaction (SIGABRT, &act, NULL);
1071   (void) sigaction (SIGFPE,  &act, NULL);
1072   (void) sigaction (SIGILL,  &act, NULL);
1073   (void) sigaction (SIGSEGV, &act, NULL);
1074   (void) sigaction (SIGBUS,  &act, NULL);
1075   (void) sigaction (SIGADAABORT,  &act, NULL);
1076   __gnat_handler_installed = 1;
1077 }
1078
1079 void
1080 __gnat_initialize ()
1081 {
1082 }
1083
1084 /*************************************************/
1085 /* __gnat_initialize (Solaris and SunOS version) */
1086 /*************************************************/
1087
1088 #elif defined (sun) && defined (__SVR4) && !defined (__vxworks)
1089
1090 #include <signal.h>
1091 #include <siginfo.h>
1092
1093 static void __gnat_error_handler PARAMS ((int, siginfo_t *));
1094
1095 static void
1096 __gnat_error_handler (sig, sip)
1097      int sig;
1098      siginfo_t *sip;
1099 {
1100   struct Exception_Data *exception;
1101   static int recurse = 0;
1102   const char *msg;
1103
1104   /* If this was an explicit signal from a "kill", just resignal it.  */
1105   if (SI_FROMUSER (sip))
1106     {
1107       signal (sig, SIG_DFL);
1108       kill (getpid(), sig);
1109     }
1110
1111   /* Otherwise, treat it as something we handle.  */
1112   switch (sig)
1113     {
1114     case SIGSEGV:
1115       /* If the problem was permissions, this is a constraint error.
1116          Likewise if the failing address isn't maximally aligned or if
1117          we've recursed.
1118
1119          ??? Using a static variable here isn't task-safe, but it's
1120          much too hard to do anything else and we're just determining
1121          which exception to raise.  */
1122       if (sip->si_code == SEGV_ACCERR
1123           || (((long) sip->si_addr) & 3) != 0
1124           || recurse)
1125         {
1126           exception = &constraint_error;
1127           msg = "SIGSEGV";
1128         }
1129       else
1130         {
1131           /* See if the page before the faulting page is accessible.  Do that
1132              by trying to access it.  We'd like to simply try to access
1133              4096 + the faulting address, but it's not guaranteed to be
1134              the actual address, just to be on the same page.  */
1135           recurse++;
1136           ((volatile char *)
1137            ((long) sip->si_addr & - getpagesize ()))[getpagesize ()];
1138           exception = &storage_error;
1139           msg = "stack overflow (or erroneous memory access)";
1140         }
1141       break;
1142
1143     case SIGBUS:
1144       exception = &program_error;
1145       msg = "SIGBUS";
1146       break;
1147
1148     case SIGFPE:
1149       exception = &constraint_error;
1150       msg = "SIGFPE";
1151       break;
1152
1153     default:
1154       exception = &program_error;
1155       msg = "unhandled signal";
1156     }
1157
1158   recurse = 0;
1159
1160   Raise_From_Signal_Handler (exception, msg);
1161 }
1162
1163 void
1164 __gnat_install_handler ()
1165 {
1166   struct sigaction act;
1167
1168   /* Set up signal handler to map synchronous signals to appropriate
1169      exceptions.  Make sure that the handler isn't interrupted by another
1170      signal that might cause a scheduling event! */
1171
1172   act.sa_handler = __gnat_error_handler;
1173   act.sa_flags = SA_NODEFER | SA_RESTART | SA_SIGINFO;
1174   (void) sigemptyset (&act.sa_mask);
1175
1176   (void) sigaction (SIGABRT, &act, NULL);
1177   (void) sigaction (SIGFPE,  &act, NULL);
1178   (void) sigaction (SIGSEGV, &act, NULL);
1179   (void) sigaction (SIGBUS,  &act, NULL);
1180
1181   __gnat_handler_installed = 1;
1182 }
1183
1184 void
1185 __gnat_initialize ()
1186 {
1187 }
1188
1189 /***********************************/
1190 /* __gnat_initialize (SNI version) */
1191 /***********************************/
1192
1193 #elif defined (__sni__)
1194
1195 /* SNI needs special defines and includes */
1196
1197 #define _XOPEN_SOURCE
1198 #define _POSIX_SOURCE
1199 #include <signal.h>
1200
1201 extern size_t __gnat_getpagesize PARAMS ((void));
1202 static void __gnat_error_handler PARAMS ((int));
1203
1204 /* The run time needs this function which is a #define in SNI */
1205
1206 size_t
1207 __gnat_getpagesize ()
1208 {
1209   return getpagesize ();
1210 }
1211
1212 static void
1213 __gnat_error_handler (sig)
1214      int sig;
1215 {
1216   struct Exception_Data *exception;
1217   char *msg;
1218
1219   switch (sig)
1220     {
1221     case SIGSEGV:
1222       /* FIXME: we need to detect the case of a *real* SIGSEGV */
1223       exception = &storage_error;
1224       msg = "stack overflow or erroneous memory access";
1225       break;
1226
1227     case SIGBUS:
1228       exception = &constraint_error;
1229       msg = "SIGBUS";
1230       break;
1231
1232     case SIGFPE:
1233       exception = &constraint_error;
1234       msg = "SIGFPE";
1235       break;
1236
1237     default:
1238       exception = &program_error;
1239       msg = "unhandled signal";
1240     }
1241
1242   Raise_From_Signal_Handler (exception, msg);
1243 }
1244
1245 void
1246 __gnat_install_handler ()
1247 {
1248   struct sigaction act;
1249
1250   /* Set up signal handler to map synchronous signals to appropriate
1251      exceptions.  Make sure that the handler isn't interrupted by another
1252      signal that might cause a scheduling event! */
1253
1254   act.sa_handler = __gnat_error_handler;
1255   act.sa_flags = SA_NODEFER | SA_RESTART;
1256   (void) sigemptyset (&act.sa_mask);
1257
1258   (void) sigaction (SIGABRT, &act, NULL);
1259   (void) sigaction (SIGFPE,  &act, NULL);
1260   (void) sigaction (SIGILL,  &act, NULL);
1261   (void) sigaction (SIGSEGV, &act, NULL);
1262   (void) sigaction (SIGBUS,  &act, NULL);
1263
1264   __gnat_handler_installed = 1;
1265 }
1266
1267 void
1268 __gnat_initialize ()
1269 {
1270 }
1271
1272 /***********************************/
1273 /* __gnat_initialize (VMS version) */
1274 /***********************************/
1275
1276 #elif defined (VMS)
1277
1278 /* The prehandler actually gets control first on a condition. It swaps the
1279    stack pointer and calls the handler (__gnat_error_handler). */
1280 extern long __gnat_error_prehandler ();
1281
1282 extern char *__gnat_error_prehandler_stack;   /* Alternate signal stack */
1283
1284 /* Conditions that don't have an Ada exception counterpart must raise
1285    Non_Ada_Error.  Since this is defined in s-auxdec, it should only be
1286    referenced by user programs, not the compiler or tools. Hence the
1287    #ifdef IN_RTS. */
1288
1289 #ifdef IN_RTS
1290 #define Non_Ada_Error system__aux_dec__non_ada_error
1291 extern struct Exception_Data Non_Ada_Error;
1292
1293 #define Coded_Exception system__vms_exception_table__coded_exception
1294 extern struct Exception_Data *Coded_Exception (int);
1295 #endif
1296
1297 /* Define macro symbols for the VMS conditions that become Ada exceptions.
1298    Most of these are also defined in the header file ssdef.h which has not
1299    yet been converted to be recoginized by Gnu C. Some, which couldn't be
1300    located, are assigned names based on the DEC test suite tests which
1301    raise them. */
1302
1303 #define SS$_ACCVIO            12
1304 #define SS$_DEBUG           1132
1305 #define SS$_INTDIV          1156
1306 #define SS$_HPARITH         1284
1307 #define SS$_STKOVF          1364
1308 #define SS$_RESIGNAL        2328
1309 #define MTH$_FLOOVEMAT   1475268       /* Some ACVC_21 CXA tests */
1310 #define SS$_CE24VRU      3253636       /* Write to unopened file */
1311 #define SS$_C980VTE      3246436       /* AST requests time slice */
1312 #define CMA$_EXIT_THREAD 4227492
1313 #define CMA$_EXCCOPLOS   4228108
1314 #define CMA$_ALERTED     4227460
1315
1316 struct descriptor_s {unsigned short len, mbz; char *adr; };
1317
1318 long __gnat_error_handler PARAMS ((int *, void *));
1319
1320 long
1321 __gnat_error_handler (sigargs, mechargs)
1322      int *sigargs;
1323      void *mechargs;
1324 {
1325   struct Exception_Data *exception = 0;
1326   char *msg = "";
1327   char message[256];
1328   long prvhnd;
1329   struct descriptor_s msgdesc;
1330   int msg_flag = 0x000f; /* 1 bit for each of the four message parts */
1331   unsigned short outlen;
1332   char curr_icb[544];
1333   long curr_invo_handle;
1334   long *mstate;
1335
1336   /* Resignaled conditions aren't effected by by pragma Import_Exception */
1337
1338   switch (sigargs[1])
1339   {
1340
1341     case CMA$_EXIT_THREAD:
1342       return SS$_RESIGNAL;
1343
1344     case SS$_DEBUG: /* Gdb attach, resignal to merge activate gdbstub. */
1345       return SS$_RESIGNAL;
1346
1347     case 1409786: /* Nickerson bug #33 ??? */
1348       return SS$_RESIGNAL;
1349
1350     case 1381050: /* Nickerson bug #33 ??? */
1351       return SS$_RESIGNAL;
1352
1353     case 11829410: /* Resignalled as Use_Error for CE10VRC */
1354       return SS$_RESIGNAL;
1355
1356   }
1357
1358 #ifdef IN_RTS
1359   /* See if it's an imported exception. Mask off severity bits. */
1360   exception = Coded_Exception (sigargs[1] & 0xfffffff8);
1361   if (exception)
1362     {
1363       msgdesc.len = 256;
1364       msgdesc.mbz = 0;
1365       msgdesc.adr = message;
1366       SYS$GETMSG (sigargs[1], &outlen, &msgdesc, msg_flag, 0);
1367       message[outlen] = 0;
1368       msg = message;
1369
1370       exception->Name_Length = 19;
1371       /* The full name really should be get sys$getmsg returns. ??? */
1372       exception->Full_Name = "IMPORTED_EXCEPTION";
1373       exception->Import_Code = sigargs[1] & 0xfffffff8;
1374     }
1375 #endif
1376
1377   if (exception == 0)
1378     switch (sigargs[1])
1379       {
1380       case SS$_ACCVIO:
1381         if (sigargs[3] == 0)
1382           {
1383             exception = &constraint_error;
1384             msg = "access zero";
1385           }
1386         else
1387           {
1388             exception = &storage_error;
1389             msg = "stack overflow (or erroneous memory access)";
1390           }
1391         break;
1392
1393       case SS$_STKOVF:
1394         exception = &storage_error;
1395         msg = "stack overflow";
1396         break;
1397
1398       case SS$_INTDIV:
1399         exception = &constraint_error;
1400         msg = "division by zero";
1401         break;
1402
1403       case SS$_HPARITH:
1404 #ifndef IN_RTS
1405         return SS$_RESIGNAL; /* toplev.c handles for compiler */
1406 #else
1407         {
1408           exception = &constraint_error;
1409           msg = "arithmetic error";
1410         }
1411 #endif
1412         break;
1413
1414       case MTH$_FLOOVEMAT:
1415         exception = &constraint_error;
1416         msg = "floating overflow in math library";
1417         break;
1418
1419       case SS$_CE24VRU:
1420         exception = &constraint_error;
1421         msg = "";
1422         break;
1423
1424       case SS$_C980VTE:
1425         exception = &program_error;
1426         msg = "";
1427         break;
1428
1429       default:
1430 #ifndef IN_RTS
1431         exception = &program_error;
1432 #else
1433         /* User programs expect Non_Ada_Error to be raised, reference
1434            DEC Ada test CXCONDHAN. */
1435         exception = &Non_Ada_Error;
1436 #endif
1437         msgdesc.len = 256;
1438         msgdesc.mbz = 0;
1439         msgdesc.adr = message;
1440         SYS$GETMSG (sigargs[1], &outlen, &msgdesc, msg_flag, 0);
1441         message[outlen] = 0;
1442         msg = message;
1443         break;
1444       }
1445
1446   mstate = (long *) (*Get_Machine_State_Addr) ();
1447   if (mstate != 0)
1448     {
1449       LIB$GET_CURR_INVO_CONTEXT (&curr_icb);
1450       LIB$GET_PREV_INVO_CONTEXT (&curr_icb);
1451       LIB$GET_PREV_INVO_CONTEXT (&curr_icb);
1452       curr_invo_handle = LIB$GET_INVO_HANDLE (&curr_icb);
1453       *mstate = curr_invo_handle;
1454     }
1455   Raise_From_Signal_Handler (exception, msg);
1456 }
1457
1458 void
1459 __gnat_install_handler ()
1460 {
1461   long prvhnd;
1462   char *c;
1463
1464   c = (char *) xmalloc (2049);
1465
1466   __gnat_error_prehandler_stack = &c[2048];
1467
1468   /* __gnat_error_prehandler is an assembly function.  */
1469   SYS$SETEXV (1, __gnat_error_prehandler, 3, &prvhnd);
1470   __gnat_handler_installed = 1;
1471 }
1472
1473 void
1474 __gnat_initialize()
1475 {
1476 }
1477
1478 /***************************************/
1479 /* __gnat_initialize (VXWorks version) */
1480 /***************************************/
1481
1482 #elif defined(__vxworks)
1483
1484 #include <signal.h>
1485 #include <taskLib.h>
1486 #include <intLib.h>
1487 #include <iv.h>
1488
1489 static void __gnat_init_handler PARAMS ((int));
1490 extern int __gnat_inum_to_ivec PARAMS ((int));
1491 static void __gnat_error_handler PARAMS ((int, int, struct sigcontext *));
1492
1493 static void
1494 __gnat_int_handler (interr)
1495       int interr;
1496 {
1497   /* Note that we should use something like Raise_From_Int_Handler here, but
1498      for now Raise_From_Signal_Handler will do the job. ??? */
1499
1500   Raise_From_Signal_Handler (&storage_error, "stack overflow");
1501 }
1502
1503 /* Used for stack-checking on VxWorks. Must be task-local in
1504    tasking programs */
1505
1506 void *__gnat_stack_limit = NULL;
1507
1508 #ifndef __alpha_vxworks
1509
1510 /* getpid is used by s-parint.adb, but is not defined by VxWorks, except
1511    on Alpha VxWorks */
1512
1513 extern long getpid PARAMS ((void));
1514
1515 long
1516 getpid ()
1517 {
1518   return taskIdSelf ();
1519 }
1520 #endif
1521
1522 /* This is needed by the GNAT run time to handle Vxworks interrupts */
1523 int
1524 __gnat_inum_to_ivec (num)
1525      int num;
1526 {
1527   return INUM_TO_IVEC (num);
1528 }
1529
1530 static void
1531 __gnat_error_handler (sig, code, sc)
1532      int sig;
1533      int code;
1534      struct sigcontext *sc;
1535 {
1536   struct Exception_Data *exception;
1537   sigset_t mask;
1538   int result;
1539   char *msg;
1540
1541   /* VxWorks will always mask out the signal during the signal handler and
1542      will reenable it on a longjmp.  GNAT does not generate a longjmp to
1543      return from a signal handler so the signal will still be masked unless
1544      we unmask it. */
1545   (void) sigprocmask (SIG_SETMASK, NULL, &mask);
1546   sigdelset (&mask, sig);
1547   (void) sigprocmask (SIG_SETMASK, &mask, NULL);
1548
1549   /* VxWorks will suspend the task when it gets a hardware exception.  We
1550      take the liberty of resuming the task for the application. */
1551   if (taskIsSuspended (taskIdSelf ()) != 0)
1552     (void) taskResume (taskIdSelf ());
1553
1554   switch (sig)
1555     {
1556     case SIGFPE:
1557       exception = &constraint_error;
1558       msg = "SIGFPE";
1559       break;
1560     case SIGILL:
1561       exception = &constraint_error;
1562       msg = "SIGILL";
1563       break;
1564     case SIGSEGV:
1565       exception = &program_error;
1566       msg = "SIGSEGV";
1567       break;
1568     case SIGBUS:
1569       exception = &program_error;
1570       msg = "SIGBUS";
1571       break;
1572     default:
1573       exception = &program_error;
1574       msg = "unhandled signal";
1575     }
1576
1577   Raise_From_Signal_Handler (exception, msg);
1578 }
1579
1580 void
1581 __gnat_install_handler ()
1582 {
1583   struct sigaction act;
1584
1585   /* Setup signal handler to map synchronous signals to appropriate
1586      exceptions.  Make sure that the handler isn't interrupted by another
1587      signal that might cause a scheduling event! */
1588
1589   act.sa_handler = __gnat_error_handler;
1590   act.sa_flags = SA_SIGINFO | SA_ONSTACK;
1591   (void) sigemptyset (&act.sa_mask);
1592
1593   (void) sigaction (SIGFPE,  &act, NULL);
1594   (void) sigaction (SIGILL,  &act, NULL);
1595   (void) sigaction (SIGSEGV, &act, NULL);
1596   (void) sigaction (SIGBUS,  &act, NULL);
1597
1598   __gnat_handler_installed = 1;
1599 }
1600
1601 #define HAVE_GNAT_INIT_FLOAT
1602
1603 void
1604 __gnat_init_float ()
1605 {
1606 #if defined (_ARCH_PPC) && !defined (_SOFT_FLOAT)
1607   /* Disable overflow/underflow exceptions on the PPC processor, this is needed
1608       to get correct Ada semantic */
1609   asm ("mtfsb0 25");
1610   asm ("mtfsb0 26");
1611 #endif
1612 }
1613
1614 void
1615 __gnat_initialize ()
1616 {
1617   TASK_DESC pTaskDesc;
1618
1619   if (taskInfoGet (taskIdSelf (), &pTaskDesc) != OK)
1620     printErr ("Cannot get task info");
1621
1622   __gnat_stack_limit = (void *) pTaskDesc.td_pStackLimit;
1623
1624   __gnat_init_float ();
1625
1626 #ifdef __mips_vxworks
1627 #if 0
1628   /* For now remove this handler, since it is causing interferences with gdb */
1629
1630   /* Connect the overflow trap directly to the __gnat_int_handler routine
1631    as it is not converted to a signal by VxWorks. */
1632
1633   intConnect (INUM_TO_IVEC (IV_TRAP_VEC), &__gnat_int_handler, IV_TRAP_VEC);
1634 #endif
1635 #endif
1636 }
1637
1638 #else
1639
1640 /* For all other versions of GNAT, the initialize routine and handler
1641    installation do nothing */
1642
1643 /***************************************/
1644 /* __gnat_initialize (default version) */
1645 /***************************************/
1646
1647 void
1648 __gnat_initialize ()
1649 {
1650 }
1651
1652 /********************************************/
1653 /* __gnat_install_handler (default version) */
1654 /********************************************/
1655
1656 void
1657 __gnat_install_handler ()
1658 {
1659   __gnat_handler_installed = 1;
1660 }
1661
1662 #endif
1663
1664 /*********************/
1665 /* __gnat_init_float */
1666 /*********************/
1667
1668 /* This routine is called as each process thread is created, for possible
1669    initialization of the FP processor. This version is used under INTERIX,
1670    WIN32 and could be used under OS/2 */
1671
1672 #if defined (_WIN32) || defined (__INTERIX) || defined (__EMX__) \
1673   || defined (__Lynx__)
1674
1675 #define HAVE_GNAT_INIT_FLOAT
1676
1677 void
1678 __gnat_init_float ()
1679 {
1680 #if defined (__i386__) || defined (i386)
1681
1682   /* This is used to properly initialize the FPU on an x86 for each
1683      process thread. */
1684
1685   asm ("finit");
1686
1687 #endif  /* Defined __i386__ */
1688 }
1689 #endif
1690
1691 #ifndef HAVE_GNAT_INIT_FLOAT
1692
1693 /* All targets without a specific __gnat_init_float will use an empty one */
1694 void
1695 __gnat_init_float ()
1696 {
1697 }
1698 #endif