2001-10-02 10:30:19 -04:00
|
|
|
------------------------------------------------------------------------------
|
|
|
|
|
-- --
|
|
|
|
|
-- GNAT RUN-TIME COMPONENTS --
|
|
|
|
|
-- --
|
|
|
|
|
-- S Y S T E M . E X C E P T I O N S --
|
|
|
|
|
-- --
|
|
|
|
|
-- S p e c --
|
|
|
|
|
-- --
|
|
|
|
|
-- Copyright (C) 1992-2000 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 other files instantiate generics from this --
|
|
|
|
|
-- unit, or you link this unit with other files to produce an executable, --
|
|
|
|
|
-- this unit does not by itself cause the resulting executable to be --
|
|
|
|
|
-- covered by the GNU General Public License. This exception 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. --
|
2002-10-23 03:33:35 -04:00
|
|
|
-- Extensive contributions were provided by Ada Core Technologies Inc. --
|
2001-10-02 10:30:19 -04:00
|
|
|
-- --
|
|
|
|
|
------------------------------------------------------------------------------
|
|
|
|
|
|
|
|
|
|
-- This package contains definitions used for zero cost exception handling.
|
|
|
|
|
-- See unit Ada.Exceptions for further details. Note that the reason that
|
|
|
|
|
-- we separate out these definitions is to avoid problems with recursion
|
|
|
|
|
-- in rtsfind. They must be in a unit which does not require any exception
|
|
|
|
|
-- table generation of any kind.
|
|
|
|
|
|
|
|
|
|
with Ada.Exceptions;
|
|
|
|
|
|
|
|
|
|
with System;
|
|
|
|
|
with System.Standard_Library;
|
|
|
|
|
|
|
|
|
|
with Unchecked_Conversion;
|
|
|
|
|
|
|
|
|
|
package System.Exceptions is
|
|
|
|
|
|
|
|
|
|
package SSL renames System.Standard_Library;
|
|
|
|
|
package AEX renames Ada.Exceptions;
|
|
|
|
|
|
|
|
|
|
-- The following section defines data structures used for zero cost
|
|
|
|
|
-- exception handling if System.Parameters.Zero_Cost_Exceptions is
|
|
|
|
|
-- set true (i.e. zero cost exceptions are implemented on this target).
|
|
|
|
|
|
|
|
|
|
-- The approach is to build tables that describe the PC ranges that
|
|
|
|
|
-- are covered by various exception frames. When an exception occurs,
|
|
|
|
|
-- these tables are searched to determine the address of the applicable
|
|
|
|
|
-- handler for the current exception.
|
|
|
|
|
|
|
|
|
|
subtype Handler_Loc is System.Address;
|
|
|
|
|
-- Code location representing entry address of a handler. Values of
|
|
|
|
|
-- this type are created using the N_Handler_Loc node, and then
|
|
|
|
|
-- passed to the Enter_Handler procedure to enter a handler.
|
|
|
|
|
|
|
|
|
|
subtype Code_Loc is System.Address;
|
|
|
|
|
-- Code location used in building exception tables and for call
|
|
|
|
|
-- addresses when propagating an exception (also traceback table)
|
|
|
|
|
-- Values of this type are created by using Label'Address or
|
|
|
|
|
-- extracted from machine states using Get_Code_Loc.
|
|
|
|
|
|
|
|
|
|
--------------------
|
|
|
|
|
-- Handler_Record --
|
|
|
|
|
--------------------
|
|
|
|
|
|
|
|
|
|
-- A Handler record is built for each choice for each exception handler
|
|
|
|
|
-- in a frame.
|
|
|
|
|
|
|
|
|
|
function To_Exception_Id is
|
|
|
|
|
new Unchecked_Conversion (SSL.Exception_Data_Ptr, AEX.Exception_Id);
|
|
|
|
|
|
|
|
|
|
Others_Dummy_Exception : aliased SSL.Exception_Data;
|
|
|
|
|
Others_Id : constant AEX.Exception_Id :=
|
|
|
|
|
To_Exception_Id (Others_Dummy_Exception'Access);
|
|
|
|
|
-- Dummy exception used to signal others exception
|
|
|
|
|
|
|
|
|
|
All_Others_Dummy_Exception : aliased SSL.Exception_Data;
|
|
|
|
|
All_Others_Id : constant AEX.Exception_Id :=
|
|
|
|
|
To_Exception_Id (All_Others_Dummy_Exception'Access);
|
|
|
|
|
-- Dummy exception used to signal all others exception (including
|
|
|
|
|
-- exceptions not normally handled by others, e.g. Abort_Signal)
|
|
|
|
|
|
|
|
|
|
type Handler_Record is record
|
|
|
|
|
Lo : Code_Loc;
|
|
|
|
|
Hi : Code_Loc;
|
|
|
|
|
-- Range of PC values of code covered by this handler record. The
|
|
|
|
|
-- handler covers all code addresses that are greater than the Lo
|
|
|
|
|
-- value, and less than or equal to the Hi value.
|
|
|
|
|
|
|
|
|
|
Id : AEX.Exception_Id;
|
|
|
|
|
-- Id of exception being handled, or one of the above special values
|
|
|
|
|
|
|
|
|
|
Handler : Handler_Loc;
|
|
|
|
|
-- Address of label at start of handler
|
|
|
|
|
end record;
|
|
|
|
|
|
|
|
|
|
type Handler_Record_Ptr is access all Handler_Record;
|
|
|
|
|
type Handler_Record_List is array (Natural range <>) of Handler_Record_Ptr;
|
|
|
|
|
|
|
|
|
|
---------------------------
|
|
|
|
|
-- Subprogram_Descriptor --
|
|
|
|
|
---------------------------
|
|
|
|
|
|
|
|
|
|
-- A Subprogram_Descriptor is built for each subprogram through which
|
|
|
|
|
-- exceptions may propagate, this includes all Ada subprograms,
|
|
|
|
|
-- and also all foreign language imported subprograms.
|
|
|
|
|
|
|
|
|
|
subtype Subprogram_Info_Type is System.Address;
|
|
|
|
|
-- This type is used to represent a value that is used to unwind stack
|
|
|
|
|
-- frames. It references target dependent data that provides sufficient
|
|
|
|
|
-- information (e.g. about the location of the return point, use of a
|
|
|
|
|
-- frame pointer, save-over-call registers etc) to unwind the machine
|
|
|
|
|
-- state to the caller. For some targets, this is simply a pointer to
|
|
|
|
|
-- the entry point of the procedure (and the routine to pop the machine
|
|
|
|
|
-- state disassembles the code at the entry point to obtain the required
|
|
|
|
|
-- information). On other targets, it is a pointer to data created by the
|
|
|
|
|
-- backend or assembler to represent the required information.
|
|
|
|
|
|
|
|
|
|
No_Info : constant Subprogram_Info_Type := System.Null_Address;
|
|
|
|
|
-- This is a special value used to indicate that it is not possible
|
|
|
|
|
-- to pop past this frame. This is used at the outer level (e.g. for
|
|
|
|
|
-- package elaboration procedures or the main procedure), and for any
|
|
|
|
|
-- other foreign language procedure for which propagation is known
|
|
|
|
|
-- to be impossible. An exception is considered unhandled if an
|
|
|
|
|
-- attempt is made to pop a frame whose Subprogram_Info_Type value
|
|
|
|
|
-- is set to No_Info.
|
|
|
|
|
|
|
|
|
|
type Subprogram_Descriptor (Num_Handlers : Natural) is record
|
|
|
|
|
Code : Code_Loc;
|
|
|
|
|
-- This is a code location used to determine which procedure we are
|
|
|
|
|
-- in. Most usually it is simply the entry address for the procedure.
|
|
|
|
|
-- hA given address is considered to be within the procedure referenced
|
|
|
|
|
-- by a Subprogram_Descriptor record if this is the descriptor for
|
|
|
|
|
-- which the Code value is as large as possible without exceeding
|
|
|
|
|
-- the given value.
|
|
|
|
|
|
|
|
|
|
Subprogram_Info : Subprogram_Info_Type;
|
|
|
|
|
-- This is a pointer to a target dependent data item that provides
|
|
|
|
|
-- sufficient information for unwinding the stack frame of this
|
|
|
|
|
-- procedure. A value of No_Info (zero) means that we are the
|
|
|
|
|
-- outer level procedure.
|
|
|
|
|
|
|
|
|
|
Handler_Records : Handler_Record_List (1 .. Num_Handlers);
|
|
|
|
|
-- List of pointers to Handler_Records for this procedure. The array
|
|
|
|
|
-- is sorted inside out, i.e. entries for inner frames appear before
|
|
|
|
|
-- entries for outer handlers. This ensures that a serial search
|
|
|
|
|
-- finds the innermost applicable handler
|
|
|
|
|
end record;
|
|
|
|
|
|
|
|
|
|
subtype Subprogram_Descriptor_0 is Subprogram_Descriptor (0);
|
|
|
|
|
subtype Subprogram_Descriptor_1 is Subprogram_Descriptor (1);
|
|
|
|
|
subtype Subprogram_Descriptor_2 is Subprogram_Descriptor (2);
|
|
|
|
|
subtype Subprogram_Descriptor_3 is Subprogram_Descriptor (3);
|
|
|
|
|
-- Predeclare commonly used subtypes for buildingt he tables
|
|
|
|
|
|
|
|
|
|
type Subprogram_Descriptor_Ptr is access all Subprogram_Descriptor;
|
|
|
|
|
|
|
|
|
|
type Subprogram_Descriptor_List
|
|
|
|
|
is array (Natural range <>) of Subprogram_Descriptor_Ptr;
|
|
|
|
|
|
|
|
|
|
type Subprogram_Descriptors_Record (Count : Natural) is record
|
|
|
|
|
SDesc : Subprogram_Descriptor_List (1 .. Count);
|
|
|
|
|
end record;
|
|
|
|
|
|
|
|
|
|
type Subprogram_Descriptors_Ptr is
|
|
|
|
|
access all Subprogram_Descriptors_Record;
|
|
|
|
|
|
|
|
|
|
--------------------------
|
|
|
|
|
-- Unit Exception_Table --
|
|
|
|
|
--------------------------
|
|
|
|
|
|
|
|
|
|
-- If a unit contains at least one subprogram, then a library level
|
|
|
|
|
-- declaration of the form:
|
|
|
|
|
|
|
|
|
|
-- Tnn : aliased constant Subprogram_Descriptors :=
|
|
|
|
|
-- (Count => n,
|
|
|
|
|
-- SDesc =>
|
|
|
|
|
-- (SD1'Unrestricted_Access,
|
|
|
|
|
-- SD2'Unrestricted_Access,
|
|
|
|
|
-- ...
|
|
|
|
|
-- SDn'Unrestricted_Access));
|
|
|
|
|
-- pragma Export (Ada, Tnn, "__gnat_unit_name__SDP");
|
|
|
|
|
|
|
|
|
|
-- is generated where the initializing expression is an array aggregate
|
|
|
|
|
-- whose elements are pointers to the generated subprogram descriptors
|
|
|
|
|
-- for the units.
|
|
|
|
|
|
|
|
|
|
-- Note: the ALI file contains the designation UX in each unit entry
|
|
|
|
|
-- if a unit exception table is generated.
|
|
|
|
|
|
|
|
|
|
-- The binder generates a list of addresses of pointers to these tables.
|
|
|
|
|
|
|
|
|
|
end System.Exceptions;
|
