| ------------------------------------------------------------------------------ |
| -- -- |
| -- GNAT RUN-TIME COMPONENTS -- |
| -- -- |
| -- S Y S T E M . H I E _ B A C K _ E N D -- |
| -- -- |
| -- S p e c -- |
| -- -- |
| -- Copyright (C) 2001-2003 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 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. -- |
| -- Extensive contributions were provided by Ada Core Technologies Inc. -- |
| -- -- |
| ------------------------------------------------------------------------------ |
| |
| -- This package provides an interface used in HI-E mode to determine |
| -- whether or not the back end can handle certain constructs in a manner |
| -- that is consistent with certification requirements. |
| |
| -- The approach is to define entities which may or may not be present in |
| -- a HI-E configured library. If the entity is present then the compiler |
| -- operating in HI-E mode will allow the corresponding operation. If the |
| -- entity is not present, the corresponding construct will be flagged as |
| -- not permitted in High Integrity mode. |
| |
| -- The default version of this unit delivered with the HI-E compiler is |
| -- configured in a manner appropriate for the target, but it is possible |
| -- to reconfigure the run-time to change the settings as required. |
| |
| -- This unit is not used and never accessed by the compiler unless it is |
| -- operating in HI-E mode, so the settings are irrelevant. However, we |
| -- do include a standard version with all entities present in the standard |
| -- run-time for use when pragma No_Run_Time is specified. |
| |
| package System.HIE_Back_End is |
| |
| type Dummy is null record; |
| pragma Suppress_Initialization (Dummy); |
| -- This is the type used for the entities below. No properties of this |
| -- type are ever referenced, and in particular, the entities are defined |
| -- as variables, but their values are never referenced |
| |
| HIE_64_Bit_Divides : Dummy; |
| -- This entity controls whether the front end allows 64-bit integer |
| -- divide operations, including the case where division of 32-bit |
| -- fixed-point operands requires 64-bit arithmetic. This can safely |
| -- be set as High_Integrity on 64-bit machines which provide this |
| -- operation as a native instruction, but on most 32-bit machines |
| -- a run time call (e.g. to __divdi3 in gcclib) is required. If a |
| -- certifiable version of this routine is available, then setting |
| -- this entity to High_Integrity with a pragma will cause appropriate |
| -- calls to be generated, allowing 64-bit integer division operations. |
| |
| HIE_Long_Shifts : Dummy; |
| -- This entity controls whether the front end allows generation of |
| -- long shift instructions, i.e. shifts that operate on 64-bit values. |
| -- Such shifts are required for the implementation of fixed-point |
| -- types longer than 32 bits. This can safetly be set as High_Integrity |
| -- on 64-bit machines that provide this operation at the hardware level, |
| -- but on some 32-bit machines a run time call is required. If there |
| -- is a certifiable version available of the relevant run-time routines, |
| -- then setting this entity to High_Integrity with a pragma will cause |
| -- appropriate calls to be generated, allowing the declaration and use |
| -- of fixed-point types longer than 32 bits. |
| |
| HIE_Aggregates : Dummy; |
| -- In the general case, the use of aggregates may generate calls |
| -- to run-time routines in the C library, including memset, memcpy, |
| -- memmove, and bcopy. This entity can be set to High_Integrity with |
| -- a pragma if certifiable versions of all these routines are available, |
| -- in which case aggregates are permitted in HI-E mode. Otherwise the |
| -- HI-E compiler will reject any use of aggregates. |
| |
| HIE_Composite_Assignments : Dummy; |
| -- The assignment of composite objects other than small records and |
| -- arrays whose size is 64-bits or less and is set by an explicit |
| -- size clause may generate calls to memcpy, memmove, and bcopy. |
| -- If certifiable versions of all these routines are available, then |
| -- this entity may be set to High_Integrity using a pragma, in which |
| -- case such assignments are permitted. Otherwise the HI-E compiler |
| -- will reject any such composite assignments. |
| |
| end System.HIE_Back_End; |
