Subversion Repositories scarts

/****************************************************************************

 *                                                                          *

 *                         GNAT COMPILER COMPONENTS                         *

 *                                                                          *

 *                                 I N I T                                  *

 *                                                                          *

 *                          C Implementation File                           *

 *                                                                          *

 *          Copyright (C) 1992-2005, 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,  51  Franklin  Street,  Fifth  Floor, *

 * Boston, MA 02110-1301, USA.                                              *

 *                                                                          *

 * As a  special  exception,  if you  link  this file  with other  files to *

 * produce an executable,  this file does not by itself cause the resulting *

 * 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. *

 * Extensive contributions were provided by Ada Core Technologies Inc.      *

 *                                                                          *

 ****************************************************************************/

/*  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) */

/* This file should be kept synchronized with 2sinit.ads, 2sinit.adb,

   s-init-ae653-cert.adb and s-init-xi-sparc.adb. All these files implement

   the required functionality for different targets. */

/* The following include is here to meet the published VxWorks requirement

   that the __vxworks header appear before any other include. */

#ifdef __vxworks

#include "vxWorks.h"

#endif

#ifdef IN_RTS

#include "tconfig.h"

#include "tsystem.h"

#include <sys/stat.h>

/* We don't have libiberty, so us malloc.  */

#define xmalloc(S) malloc (S)

#else

#include "config.h"

#include "system.h"

#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) (void);

#define Unlock_Task system__soft_links__unlock_task

extern void (*Unlock_Task) (void);

#define Check_Abort_Status     \

                      system__soft_links__check_abort_status

extern int (*Check_Abort_Status) (void);

#define Raise_From_Signal_Handler \

                      ada__exceptions__raise_from_signal_handler

extern void Raise_From_Signal_Handler (struct Exception_Data *, const char *);

/* Copies of global values computed by the binder */

int   __gl_main_priority            = -1;

int   __gl_time_slice_val           = -1;

char  __gl_wc_encoding              = 'n';

char  __gl_locking_policy           = ' ';

char  __gl_queuing_policy           = ' ';

char  __gl_task_dispatching_policy  = ' ';

char *__gl_restrictions             = 0;

char *__gl_interrupt_states         = 0;

int   __gl_num_interrupt_states     = 0;

int   __gl_unreserve_all_interrupts = 0;

int   __gl_exception_tracebacks     = 0;

int   __gl_zero_cost_exceptions     = 0;

int   __gl_detect_blocking          = 0;

/* Indication of whether synchronous signal handler has already been

   installed by a previous call to adainit */

int  __gnat_handler_installed      = 0;

#ifndef IN_RTS

int __gnat_inside_elab_final_code = 0;

/* ??? This variable is obsolete since 2001-08-29 but is kept to allow

   bootstrap from old GNAT versions (< 3.15). */

#endif

/* HAVE_GNAT_INIT_FLOAT must be set on every targets where a __gnat_init_float

   is defined. If this is not set them a void implementation will be defined

   at the end of this unit. */

#undef HAVE_GNAT_INIT_FLOAT

/******************************/

/* __gnat_get_interrupt_state */

/******************************/

char __gnat_get_interrupt_state (int);

/* This routine is called from the runtime as needed to determine the state

   of an interrupt, as set by an Interrupt_State pragma appearing anywhere

   in the current partition. The input argument is the interrupt number,

   and the result is one of the following:

       'n'   this interrupt not set by any Interrupt_State pragma

       'u'   Interrupt_State pragma set state to User

       'r'   Interrupt_State pragma set state to Runtime

       's'   Interrupt_State pragma set state to System */

char

__gnat_get_interrupt_state (int intrup)

{

  if (intrup >= __gl_num_interrupt_states)

    return 'n';

  else

    return __gl_interrupt_states [intrup];

}

/**********************/

/* __gnat_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.  */

/* For detailed description of the parameters to this routine, see the

   section titled Run-Time Globals in package Bindgen (bindgen.adb) */

void

__gnat_set_globals (int main_priority,

                    int time_slice_val,

                    char wc_encoding,

                    char locking_policy,

                    char queuing_policy,

                    char task_dispatching_policy,

                    char *restrictions,

                    char *interrupt_states,

                    int num_interrupt_states,

                    int unreserve_all_interrupts,

                    int exception_tracebacks,

                    int zero_cost_exceptions,

                    int detect_blocking)

{

  static int already_called = 0;

  /* 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.

     We do not check either for the consistency of exception tracebacks,

     because exception tracebacks are not normally set in Stand-Alone

     libraries. If a library or the main program set the exception

     tracebacks, then they are never reset afterwards (see below).

     The value of main_priority is meaningful only when we are invoked

     from the main program elaboration routine of an Ada application.

     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_zero_cost_exceptions     != zero_cost_exceptions)

        __gnat_raise_program_error (__FILE__, __LINE__);

      /* If either a library or the main program set the exception traceback

         flag, it is never reset later */

      if (exception_tracebacks != 0)

         __gl_exception_tracebacks = exception_tracebacks;

      return;

    }

  already_called = 1;

  __gl_main_priority            = main_priority;

  __gl_time_slice_val           = time_slice_val;

  __gl_wc_encoding              = wc_encoding;

  __gl_locking_policy           = locking_policy;

  __gl_queuing_policy           = queuing_policy;

  __gl_restrictions             = restrictions;

  __gl_interrupt_states         = interrupt_states;

  __gl_num_interrupt_states     = num_interrupt_states;

  __gl_task_dispatching_policy  = task_dispatching_policy;

  __gl_unreserve_all_interrupts = unreserve_all_interrupts;

  __gl_exception_tracebacks     = exception_tracebacks;

  __gl_detect_blocking          = detect_blocking;

  /* ??? __gl_zero_cost_exceptions is new in 3.15 and is referenced from

     a-except.adb, which is also part of the compiler sources. Since the

     compiler is built with an older release of GNAT, the call generated by

     the old binder to this function does not provide any value for the

     corresponding argument, so the global has to be initialized in some

     reasonable other way. This could be removed as soon as the next major

     release is out.  */

#ifdef IN_RTS

  __gl_zero_cost_exceptions = zero_cost_exceptions;

#else

  __gl_zero_cost_exceptions = 0;

  /* We never build the compiler to run in ZCX mode currently anyway.  */

#endif

}

/* Notes on the Zero Cost Exceptions scheme and its impact on the signal

   handlers implemented below :

   What we call Zero Cost Exceptions is implemented using the GCC eh

   circuitry, even if the underlying implementation is setjmp/longjmp

   based. In any case ...

   The GCC unwinder expects to be dealing with call return addresses, since

   this is the "nominal" case of what we retrieve while unwinding a regular

   call chain. To evaluate if a handler applies at some point in this chain,

   the propagation engine needs to determine what region the corresponding

   call instruction pertains to. The return address may not be attached to the

   same region as the call, so the unwinder unconditionally subtracts "some"

   amount to the return addresses it gets to search the region tables. The

   exact amount is computed to ensure that the resulting address is inside the

   call instruction, and is thus target dependent (think about delay slots for

   instance).

   When we raise an exception from a signal handler, e.g. to transform a

   SIGSEGV into Storage_Error, things need to appear as if the signal handler

   had been "called" by the instruction which triggered the signal, so that

   exception handlers that apply there are considered. What the unwinder will

   retrieve as the return address from the signal handler is what it will find

   as the faulting instruction address in the corresponding signal context

   pushed by the kernel. Leaving this address untouched may loose, because if

   the triggering instruction happens to be the very first of a region, the

   later adjustments performed by the unwinder would yield an address outside

   that region. We need to compensate for those adjustments at some point,

   which we currently do in the GCC unwinding fallback macro.

   The thread at http://gcc.gnu.org/ml/gcc-patches/2004-05/msg00343.html

   describes a couple of issues with our current approach. Basically: on some

   targets the adjustment to apply depends on the triggering signal, which is

   not easily accessible from the macro, and we actually do not tackle this as

   of today. Besides, other languages, e.g. Java, deal with this by performing

   the adjustment in the signal handler before the raise, so our adjustments

   may break those front-ends.

   To have it all right, we should either find a way to deal with the signal

   variants from the macro and convert Java on all targets (ugh), or remove

   our macro adjustments and update our signal handlers a-la-java way.  The

   latter option appears the simplest, although some targets have their share

   of subtleties to account for.  See for instance the syscall(SYS_sigaction)

   story in libjava/include/i386-signal.h.  */

/***************/

/* AIX Section */

/***************/

#if defined (_AIX)

#include <signal.h>

#include <sys/time.h>

/* Some versions of AIX don't define SA_NODEFER. */

#ifndef SA_NODEFER

#define SA_NODEFER 0

#endif /* SA_NODEFER */

/* Versions of AIX before 4.3 don't have nanosleep but provide

   nsleep instead. */

#ifndef _AIXVERSION_430

extern int nanosleep (struct timestruc_t *, struct timestruc_t *);

int

nanosleep (struct timestruc_t *Rqtp, struct timestruc_t *Rmtp)

{

  return nsleep (Rqtp, Rmtp);

}

#endif /* _AIXVERSION_430 */

static void __gnat_error_handler (int);

static void

__gnat_error_handler (int sig)

{

  struct Exception_Data *exception;

  const 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 (void)

{

  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;

  sigemptyset (&act.sa_mask);

  /* Do not install handlers if interrupt state is "System" */

  if (__gnat_get_interrupt_state (SIGABRT) != 's')

    sigaction (SIGABRT, &act, NULL);

  if (__gnat_get_interrupt_state (SIGFPE) != 's')

    sigaction (SIGFPE,  &act, NULL);

  if (__gnat_get_interrupt_state (SIGILL) != 's')

    sigaction (SIGILL,  &act, NULL);

  if (__gnat_get_interrupt_state (SIGSEGV) != 's')

    sigaction (SIGSEGV, &act, NULL);

  if (__gnat_get_interrupt_state (SIGBUS) != 's')

    sigaction (SIGBUS,  &act, NULL);

  __gnat_handler_installed = 1;

}

/*****************/

/* Tru64 section */

/*****************/

#elif defined(__alpha__) && defined(__osf__)

#include <signal.h>

#include <sys/siginfo.h>

static void __gnat_error_handler (int, siginfo_t *, struct sigcontext *);

extern char *__gnat_get_code_loc (struct sigcontext *);

extern void __gnat_set_code_loc (struct sigcontext *, char *);

extern size_t __gnat_machine_state_length (void);

static void

__gnat_error_handler

  (int sig, siginfo_t *sip, struct sigcontext *context ATTRIBUTE_UNUSED)

{

  struct Exception_Data *exception;

  static int recurse = 0;

  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 accessible.  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;

  Raise_From_Signal_Handler (exception, (char *) msg);

}

void

__gnat_install_handler (void)

{

  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 (*) (int)) __gnat_error_handler;

  act.sa_flags = SA_RESTART | SA_NODEFER | SA_SIGINFO;

  sigemptyset (&act.sa_mask);

  /* Do not install handlers if interrupt state is "System" */

  if (__gnat_get_interrupt_state (SIGABRT) != 's')

    sigaction (SIGABRT, &act, NULL);

  if (__gnat_get_interrupt_state (SIGFPE) != 's')

    sigaction (SIGFPE,  &act, NULL);

  if (__gnat_get_interrupt_state (SIGILL) != 's')

    sigaction (SIGILL,  &act, NULL);

  if (__gnat_get_interrupt_state (SIGSEGV) != 's')

    sigaction (SIGSEGV, &act, NULL);

  if (__gnat_get_interrupt_state (SIGBUS) != 's')

    sigaction (SIGBUS,  &act, NULL);

  __gnat_handler_installed = 1;

}

/* Routines called by s-mastop-tru64.adb.  */

#define SC_GP 29

char *

__gnat_get_code_loc (struct sigcontext *context)

{

  return (char *) context->sc_pc;

}

void

__gnat_set_code_loc (struct sigcontext *context, char *pc)

{

  context->sc_pc = (long) pc;

}

size_t

__gnat_machine_state_length (void)

{

  return sizeof (struct sigcontext);

}

/********************/

/* PA HP-UX section */

/********************/

#elif defined (__hppa__) && defined (__hpux__)

#include <signal.h>

#include <sys/ucontext.h>

static void

__gnat_error_handler (int sig, siginfo_t *siginfo, void *ucontext);

/* __gnat_adjust_context_for_raise - see comments along with the default

   version later in this file.  */

#define HAVE_GNAT_ADJUST_CONTEXT_FOR_RAISE

void

__gnat_adjust_context_for_raise (int signo ATTRIBUTE_UNUSED, void *ucontext)

{

  mcontext_t *mcontext = &((ucontext_t *) ucontext)->uc_mcontext;

  if (UseWideRegs (mcontext))

    mcontext->ss_wide.ss_32.ss_pcoq_head_lo ++;

  else

    mcontext->ss_narrow.ss_pcoq_head ++;

}

static void

__gnat_error_handler

  (int sig, siginfo_t *siginfo ATTRIBUTE_UNUSED, void *ucontext)

{

  struct Exception_Data *exception;

  const 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";

    }

  __gnat_adjust_context_for_raise (sig, ucontext);

  Raise_From_Signal_Handler (exception, msg);

}

void

__gnat_install_handler (void)

{

  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*2];

  /* SIGSTKSZ appeared to be "short" for the needs in some contexts

     (e.g. experiments with GCC ZCX exceptions).  */

  stack_t stack;

  stack.ss_sp    = handler_stack;

  stack.ss_size  = sizeof (handler_stack);

  stack.ss_flags = 0;

  sigaltstack (&stack, NULL);

  act.sa_sigaction = __gnat_error_handler;

  act.sa_flags = SA_NODEFER | SA_RESTART | SA_ONSTACK | SA_SIGINFO;

  sigemptyset (&act.sa_mask);

  /* Do not install handlers if interrupt state is "System" */

  if (__gnat_get_interrupt_state (SIGABRT) != 's')

    sigaction (SIGABRT, &act, NULL);

  if (__gnat_get_interrupt_state (SIGFPE) != 's')

    sigaction (SIGFPE,  &act, NULL);

  if (__gnat_get_interrupt_state (SIGILL) != 's')

    sigaction (SIGILL,  &act, NULL);

  if (__gnat_get_interrupt_state (SIGSEGV) != 's')

    sigaction (SIGSEGV, &act, NULL);

  if (__gnat_get_interrupt_state (SIGBUS) != 's')

    sigaction (SIGBUS,  &act, NULL);

  __gnat_handler_installed = 1;

}

/*********************/

/* GNU/Linux Section */

/*********************/

#elif defined (linux) && (defined (i386) || defined (__x86_64__) \

                          || defined (__ia64__))

#include <signal.h>

#define __USE_GNU 1 /* required to get REG_EIP/RIP from glibc's ucontext.h */

#include <sys/ucontext.h>

/* GNU/Linux, which uses glibc, does not define NULL in included

   header files */

#if !defined (NULL)

#define NULL ((void *) 0)

#endif

static void __gnat_error_handler (int, siginfo_t *siginfo, void *ucontext);

/* __gnat_adjust_context_for_raise - see comments along with the default

   version later in this file.  */

#define HAVE_GNAT_ADJUST_CONTEXT_FOR_RAISE

void

__gnat_adjust_context_for_raise (int signo ATTRIBUTE_UNUSED, void *ucontext)

{

  mcontext_t *mcontext = &((ucontext_t *) ucontext)->uc_mcontext;

#if defined (i386)

  mcontext->gregs[REG_EIP]++;

#elif defined (__x86_64__)

  mcontext->gregs[REG_RIP]++;

#elif defined (__ia64__)

  mcontext->sc_ip++;

#endif

}

static void

__gnat_error_handler (int sig,

                      siginfo_t *siginfo ATTRIBUTE_UNUSED,

                      void *ucontext)

{

  struct Exception_Data *exception;

  const char *msg;

  static int recurse = 0;

  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";

    }

  recurse = 0;

  /* We adjust the interrupted context here (and not in the

     MD_FALLBACK_FRAME_STATE_FOR macro) because recent versions of the Native

     POSIX Thread Library (NPTL) are compiled with DWARF 2 unwind information,

     and hence the later macro is never executed for signal frames. */

  __gnat_adjust_context_for_raise (sig, ucontext);

  Raise_From_Signal_Handler (exception, msg);

}

void

__gnat_install_handler (void)

{

  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_sigaction = __gnat_error_handler;

  act.sa_flags = SA_NODEFER | SA_RESTART | SA_SIGINFO;

  sigemptyset (&act.sa_mask);

  /* Do not install handlers if interrupt state is "System" */