Subversion Repositories openrisc

------------------------------------------------------------------------------

--                                                                          --

--                         GNAT COMPILER COMPONENTS                         --

--                                                                          --

--                                E I N F O                                 --

--                                                                          --

--                                 S p e c                                  --

--                                                                          --

--          Copyright (C) 1992-2012, 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 3,  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.                                     --

--                                                                          --

-- As a special exception under Section 7 of GPL version 3, you are granted --

-- additional permissions described in the GCC Runtime Library Exception,   --

-- version 3.1, as published by the Free Software Foundation.               --

--                                                                          --

-- You should have received a copy of the GNU General Public License and    --

-- a copy of the GCC Runtime Library Exception along with this program;     --

-- see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see    --

-- <http://www.gnu.org/licenses/>.                                          --

--                                                                          --

-- GNAT was originally developed  by the GNAT team at  New York University. --

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

--                                                                          --

------------------------------------------------------------------------------

with Namet;  use Namet;

with Snames; use Snames;

with Types;  use Types;

with Uintp;  use Uintp;

with Urealp; use Urealp;

package Einfo is

--  This package defines the annotations to the abstract syntax tree that

--  are needed to support semantic processing of an Ada compilation.

--  Note that after editing this spec and the corresponding body it is

--  required to run ceinfo to check the consistentcy of spec and body.

--  See ceinfo.adb for more information about the checks made.

--  These annotations are for the most part attributes of declared entities,

--  and they correspond to conventional symbol table information. Other

--  attributes include sets of meanings for overloaded names, possible

--  types for overloaded expressions, flags to indicate deferred constants,

--  incomplete types, etc. These attributes are stored in available fields

--  in tree nodes (i.e. fields not used by the parser, as defined by the

--  Sinfo package specification), and accessed by means of a set of

--  subprograms which define an abstract interface.

--  There are two kinds of semantic information

--    First, the tree nodes with the following Nkind values:

--      N_Defining_Identifier

--      N_Defining_Character_Literal

--      N_Defining_Operator_Symbol

--    are called Entities, and constitute the information that would often

--    be stored separately in a symbol table. These nodes are all extended

--    to provide extra space, and contain fields which depend on the entity

--    kind, as defined by the contents of the Ekind field. The use of the

--    Ekind field, and the associated fields in the entity, are defined

--    in this package, as are the access functions to these fields.

--    Second, in some cases semantic information is stored directly in other

--    kinds of nodes, e.g. the Etype field, used to indicate the type of an

--    expression. The access functions to these fields are defined in the

--    Sinfo package, but their full documentation is to be found in

--    the Einfo package specification.

--  Declaration processing places information in the nodes of their defining

--  identifiers. Name resolution places in all other occurrences of an

--  identifier a pointer to the corresponding defining occurrence.

--------------------------------

-- The XEINFO Utility Program --

--------------------------------

--  XEINFO is a utility program which automatically produces a C header file,

--  einfo.h from the spec and body of package Einfo. It reads the input

--  files einfo.ads and einfo.adb and produces the output file einfo.h.

--  XEINFO is run automatically by the build scripts when you do a full

--  bootstrap.

--  In order for this utility program to operate correctly, the form of the

--  einfo.ads and einfo.adb files must meet certain requirements and be laid

--  out in a specific manner.

--  The general form of einfo.ads is as follows:

--     type declaration for type Entity_Kind

--     subtype declarations declaring subranges of Entity_Kind

--     subtype declarations declaring synonyms for some standard types

--     function specs for attributes

--     procedure specs

--     pragma Inline declarations

--  This order must be observed. There are no restrictions on the procedures,

--  since the C header file only includes functions (Gigi is not allowed to

--  modify the generated tree). However, functions are required to have headers

--  that fit on a single line.

--  XEINFO reads and processes the function specs and the pragma Inlines. For

--  functions that are declared as inlined, XEINFO reads the corresponding body

--  from einfo.adb, and processes it into C code. This results in some strict

--  restrictions on which functions can be inlined:

--     The function spec must be on a single line

--     There can only be a single statement, contained on a single line,

--     not counting any pragma Assert statements.

--     This single statement must either be a function call with simple,

--     single token arguments, or it must be a membership test of the form

--     a in b, where a and b are single tokens.

--  For functions that are not inlined, there is no restriction on the body,

--  and XEINFO generates a direct reference in the C header file which allows

--  the C code in Gigi to directly call the corresponding Ada body.

----------------------------------

-- Handling of Type'Size Values --

----------------------------------

--  The Ada 95 RM contains some rather peculiar (to us!) rules on the value

--  of type'Size (see RM 13.3(55)). We have found that attempting to use

--  these RM Size values generally, and in particular for determining the

--  default size of objects, creates chaos, and major incompatibilities in

--  existing code.

--  We proceed as follows, for discrete and fixed-point subtypes, we have

--  two separate sizes for each subtype:

--    The Object_Size, which is used for determining the default size of

--    objects and components. This size value can be referred to using the

--    Object_Size attribute. The phrase "is used" here means that it is

--    the basis of the determination of the size. The backend is free to

--    pad this up if necessary for efficiency, e.g. an 8-bit stand-alone

--    character might be stored in 32 bits on a machine with no efficient

--    byte access instructions such as the Alpha.

--    The default rules for the value of Object_Size for fixed-point and

--    discrete types are as follows:

--       The Object_Size for base subtypes reflect the natural hardware

--       size in bits (see Ttypes and Cstand for integer types). For

--       enumeration and fixed-point base subtypes have 8. 16. 32 or 64

--       bits for this size, depending on the range of values to be stored.

--       The Object_Size of a subtype is the same as the Object_Size of

--       the subtype from which it is obtained.

--       The Object_Size of a derived base type is copied from the parent

--       base type, and the Object_Size of a derived first subtype is copied

--       from the parent first subtype.

--    The Value_Size which is the number of bits required to store a value

--    of the type. This size can be referred to using the Value_Size

--    attribute. This value is used to determine how tightly to pack

--    records or arrays with components of this type, and also affects

--    the semantics of unchecked conversion (unchecked conversions where

--    the Value_Size values differ generate a warning, and are potentially

--    target dependent).

--    The default rule for the value of Value_Size are as follows:

--       The Value_Size for a base subtype is the minimum number of bits

--       required to store all values of the type (including the sign bit

--       only if negative values are possible).

--       If a subtype statically matches the first subtype, then it has

--       by default the same Value_Size as the first subtype. This is a

--       consequence of RM 13.1(14) ("if two subtypes statically match,

--       then their subtype-specific aspects are the same".)

--       All other subtypes have a Value_Size corresponding to the minimum

--       number of bits required to store all values of the subtype. For

--       dynamic bounds, it is assumed that the value can range down or up

--       to the corresponding bound of the ancestor

--    The RM defined attribute Size corresponds to the Value_Size attribute

--    The Size attribute may be defined for a first-named subtype. This sets

--    the Value_Size of the first-named subtype to the given value, and the

--    Object_Size of this first-named subtype to the given value padded up

--    to an appropriate boundary. It is a consequence of the default rules

--    above that this Object_Size will apply to all further subtypes. On the

--    other hand, Value_Size is affected only for the first subtype, any

--    dynamic subtypes obtained from it directly, and any statically matching

--    subtypes. The Value_Size of any other static subtypes is not affected.

--    Value_Size and Object_Size may be explicitly set for any subtype using

--    an attribute definition clause. Note that the use of these attributes

--    can cause the RM 13.1(14) rule to be violated. If two access types

--    reference aliased objects whose subtypes have differing Object_Size

--    values as a result of explicit attribute definition clauses, then it

--    is erroneous to convert from one access subtype to the other.

--    At the implementation level, Esize stores the Object_Size and the

--    RM_Size field stores the Value_Size (and hence the value of the

--    Size attribute, which, as noted above, is equivalent to Value_Size).

--  To get a feel for the difference, consider the following examples (note

--  that in each case the base is short_short_integer with a size of 8):

--                                            Object_Size     Value_Size

--     type x1 is range 0..5;                      8               3

--     type x2 is range 0..5;

--     for x2'size use 12;                        16              12

--     subtype x3 is x2 range 0 .. 3;             16               2

--     subtype x4 is x2'base range 0 .. 10;        8               4

--     subtype x5 is x2 range 0 .. dynamic;       16              (7)

--     subtype x6 is x2'base range 0 .. dynamic;   8              (7)

--  Note: the entries marked (7) are not actually specified by the Ada 95 RM,

--  but it seems in the spirit of the RM rules to allocate the minimum number

--  of bits known to be large enough to hold the given range of values.

--  So far, so good, but GNAT has to obey the RM rules, so the question is

--  under what conditions must the RM Size be used. The following is a list

--  of the occasions on which the RM Size must be used:

--    Component size for packed arrays or records

--    Value of the attribute Size for a type

--    Warning about sizes not matching for unchecked conversion

--  The RM_Size field keeps track of the RM Size as needed in these

--  three situations.

--  For elementary types other than discrete and fixed-point types, the

--  Object_Size and Value_Size are the same (and equivalent to the RM

--  attribute Size). Only Size may be specified for such types.

--  For composite types, Object_Size and Value_Size are computed from their

--  respective value for the type of each element as well as the layout.

--  All size attributes are stored as Uint values. Negative values are used to

--  reference GCC expressions for the case of non-static sizes, as explained

--  in Repinfo.

--------------------------------------

-- Delayed Freezing and Elaboration --

--------------------------------------

--  The flag Has_Delayed_Freeze indicates that an entity carries an explicit

--  freeze node, which appears later in the expanded tree.

--  a) The flag is used by the front-end to trigger expansion actions which

--  include the generation of that freeze node. Typically this happens at the

--  end of the current compilation unit, or before the first subprogram body is

--  encountered in the current unit. See files freeze and exp_ch13 for details

--  on the actions triggered by a freeze node, which include the construction

--  of initialization procedures and dispatch tables.

--  b) The presence of a freeze node on an entity is used by the backend to

--  defer elaboration of the entity until its freeze node is seen. In the

--  absence of an explicit freeze node, an entity is frozen (and elaborated)

--  at the point of declaration.

--  For object declarations, the flag is set when an address clause for the

--  object is encountered. Legality checks on the address expression only take

--  place at the freeze point of the object.

--  Most types have an explicit freeze node, because they cannot be elaborated

--  until all representation and operational items that apply to them have been

--  analyzed. Private types and incomplete types have the flag set as well, as

--  do task and protected types.

--  Implicit base types created for type derivations, as well as classwide

--  types created for all tagged types, have the flag set.

--  If a subprogram has an access parameter whose designated type is incomplete

--  the subprogram has the flag set.

-----------------------

-- Entity Attributes --

-----------------------

--  This section contains a complete list of the attributes that are defined

--  on entities. Some attributes apply to all entities, others only to certain

--  kinds of entities. In the latter case the attribute should only be set or

--  accessed if the Ekind field indicates an appropriate entity.

--  There are two kinds of attributes that apply to entities, stored and

--  synthesized. Stored attributes correspond to a field or flag in the entity

--  itself. Such attributes are identified in the table below by giving the

--  field or flag in the attribute that is used to hold the attribute value.

--  Synthesized attributes are not stored directly, but are rather computed as

--  needed from other attributes, or from information in the tree. These are

--  marked "synthesized" in the table below. The stored attributes have both

--  access functions and set procedures to set the corresponding values, while

--  synthesized attributes have only access functions.

--  Note: in the case of Node, Uint, or Elist fields, there are cases where

--  the same physical field is used for different purposes in different

--  entities, so these access functions should only be referenced for the

--  class of entities in which they are defined as being present. Flags are

--  not overlapped in this way, but nevertheless as a matter of style and

--  abstraction (which may or may not be checked by assertions in the body),

--  this restriction should be observed for flag fields as well.

--  Note: certain of the attributes on types apply only to base types, and

--  are so noted by the notation [base type only]. These are cases where the

--  attribute of any subtype is the same as the attribute of the base type.

--  The attribute can be referenced on a subtype (and automatically retrieves

--  the value from the base type). However, it is an error to try to set the

--  attribute on other than the base type, and if assertions are enabled,

--  an attempt to set the attribute on a subtype will raise an assert error.

--  Other attributes are noted as applying to the [implementation base type

--  only].  These are representation attributes which must always apply to a

--  full non-private type, and where the attributes are always on the full

--  type.  The attribute can be referenced on a subtype (and automatically

--  retries the value from the implementation base type). However, it is an

--  error to try to set the attribute on other than the implementation base

--  type, and if assertions are enabled, an attempt to set the attribute on a

--  subtype will raise an assert error.

--    Accept_Address (Elist21)

--       Present in entries. If an accept has a statement sequence, then an

--       address variable is created, which is used to hold the address of the

--       parameters, as passed by the runtime. Accept_Address holds an element

--       list which represents a stack of entities for these address variables.

--       The current entry is the top of the stack, which is the last element

--       on the list. A stack is required to handle the case of nested select

--       statements referencing the same entry.

--    Access_Disp_Table (Elist16) [implementation base type only]

--       Present in E_Record_Type and E_Record_Subtype entities. Set in tagged

--       types to point to their dispatch tables. The first two entities are

--       associated with the primary dispatch table: 1) primary dispatch table

--       with user-defined primitives 2) primary dispatch table with predefined

--       primitives. For each interface type covered by the tagged type we also

--       have: 3) secondary dispatch table with thunks of primitives covering

--       user-defined interface primitives, 4) secondary dispatch table with

--       thunks of predefined primitives, 5) secondary dispatch table with user

--       defined primitives, and 6) secondary dispatch table with predefined

--       primitives. The last entity of this list is an access type declaration

--       used to expand dispatching calls through the primary dispatch table.

--       For a non-tagged record, contains No_Elist.

--    Actual_Subtype (Node17)

--       Present in variables, constants, and formal parameters. This is the

--       subtype imposed by the value of the object, as opposed to its nominal

--       subtype, which is imposed by the declaration. The actual subtype

--       differs from the nominal one when the latter is indefinite (as in the

--       case of an unconstrained formal parameter, or a variable declared

--       with an unconstrained type and an initial value). The nominal subtype

--       is the Etype entry for the entity. The Actual_Subtype field is set

--       only if the actual subtype differs from the nominal subtype. If the

--       actual and nominal subtypes are the same, then the Actual_Subtype

--       field is Empty, and Etype indicates both types.

--

--       For objects, the Actual_Subtype is set only if this is a discriminated

--       type. For arrays, the bounds of the expression are obtained and the

--       Etype of the object is directly the constrained subtype. This is

--       rather irregular, and the semantic checks that depend on the nominal

--       subtype being unconstrained use flag Is_Constr_Subt_For_U_Nominal(qv).

--    Address_Clause (synthesized)

--       Applies to entries, objects and subprograms. Set if an address clause

--       is present which references the object or subprogram and points to

--       the N_Attribute_Definition_Clause node. Empty if no Address clause.

--       The expression in the address clause is always a constant that is

--       defined before the entity to which the address clause applies.

--       Note: Gigi references this field in E_Task_Type entities???

--    Address_Taken (Flag104)

--       Present in all entities. Set if the Address or Unrestricted_Access

--       attribute is applied directly to the entity, i.e. the entity is the

--       entity of the prefix of the attribute reference. Also set if the

--       entity is the second argument of an Asm_Input or Asm_Output attribute,

--       as the construct may entail taking its address. Used by Gigi to make

--       sure that the address can be meaningfully taken, and also in the case

--       of subprograms to control output of certain warnings.

--    Aft_Value (synthesized)

--       Applies to fixed and decimal types. Computes a universal integer

--       that holds value of the Aft attribute for the type.

--    Alias (Node18)

--       Present in overloadable entities (literals, subprograms, entries) and

--       subprograms that cover a primitive operation of an abstract interface

--       (that is, subprograms with the Interface_Alias attribute). In case of

--       overloaded entities it points to the parent subprogram of a derived

--       subprogram. In case of abstract interface subprograms it points to the

--       subprogram that covers the abstract interface primitive. Also used for

--       a subprogram renaming, where it points to the renamed subprogram. For

--       an inherited operation (of a type extension) that is overridden in a

--       private part, the Alias is the overriding operation. In this fashion a

--       call from outside the package ends up executing the new body even if

--       non-dispatching, and a call from inside calls the overriding operation

--       because it hides the implicit one. Alias is always empty for entries.

--    Alignment (Uint14)

--       Present in entities for types and also in constants, variables

--       (including exceptions where it refers to the static data allocated for

--       an exception), loop parameters, and formal parameters. This indicates

--       the desired alignment for a type, or the actual alignment for an

--       object. A value of zero (Uint_0) indicates that the alignment has not

--       been set yet. The alignment can be set by an explicit alignment

--       clause, or set by the front-end in package Layout, or set by the

--       back-end as part of the back end back-annotation process. The

--       alignment field is also present in E_Exception entities, but there it

--       is used only by the back-end for back annotation.

--    Alignment_Clause (synthesized)

--       Applies to all entities for types and objects. If an alignment

--       attribute definition clause is present for the entity, then this

--       function returns the N_Attribute_Definition clause that specifies the

--       alignment. If no alignment clause applies to the type, then the call

--       to this function returns Empty. Note that the call can return a

--       non-Empty value even if Has_Alignment_Clause is not set (happens with

--       subtype and derived type declarations). Note also that a record

--       definition clause with an (obsolescent) mod clause is converted

--       into an attribute definition clause for this purpose.

--    Associated_Formal_Package (Node12)

--       Present in packages that are the actuals of formal_packages. Points

--       to the entity in the declaration for the formal package.

--    Associated_Node_For_Itype (Node8)

--       Present in all type and subtype entities. Set non-Empty only for

--       Itypes. Set to point to the associated node for the Itype, i.e.

--       the node whose elaboration generated the Itype. This is used for

--       copying trees, to determine whether or not to copy an Itype, and

--       also for accessibility checks on anonymous access types. This

--       node is typically an object declaration, component declaration,

--       type or subtype declaration. For an access discriminant in a type

--       declaration, the associated_node_for_itype is the discriminant

--       specification. For an access parameter it is the enclosing subprogram

--       declaration.

--

--       Itypes have no explicit declaration, and therefore are not attached to

--       the tree: their Parent field is always empty. The Associated_Node_For_

--       Itype is the only way to determine the construct that leads to the

--       creation of a given itype entity.

--    Associated_Storage_Pool (Node22) [root type only]

--       Present in simple and general access type entities. References the

--       storage pool to be used for the corresponding collection. A value of

--       Empty means that the default pool is to be used. This is present

--       only in the root type, since derived types must have the same pool

--       as the parent type.

--    Barrier_Function (Node12)

--       Present in protected entries and entry families. This is the

--       subprogram declaration for the body of the function that returns

--       the value of the entry barrier.

--    Base_Type (synthesized)

--       Applies to all type and subtype entities. Returns the base type of a

--       type or subtype. The base type of a type is the type itself. The base

--       type of a subtype is the type that it constrains (which is always

--       a type entity, not some other subtype). Note that in the case of a

--       subtype of a private type, it is possible for the base type attribute

--       to return a private type, even if the subtype to which it applies is

--       non-private. See also Implementation_Base_Type. Note: it is allowed to

--       apply Base_Type to other than a type, in which case it simply returns

--       the entity unchanged.

--    Block_Node (Node11)

--       Present in block entities. Points to the identifier in the

--       Block_Statement itself. Used when retrieving the block construct

--       for finalization purposes, The block entity has an implicit label

--       declaration in the enclosing declarative part, and has otherwise

--       no direct connection in the tree with the block statement. The

--       link is to the identifier (which is an occurrence of the entity)

--       and not to the block_statement itself, because the statement may

--       be rewritten, e.g. in the process of removing dead code.

--    Body_Entity (Node19)

--       Present in package and generic package entities, points to the

--       corresponding package body entity if one is present.

--    Body_Needed_For_SAL (Flag40)

--       Present in package and subprogram entities that are compilation

--       units. Indicates that the source for the body must be included

--       when the unit is part of a standalone library.

--    C_Pass_By_Copy (Flag125) [implementation base type only]

--       Present in record types. Set if a pragma Convention for the record

--       type specifies convention C_Pass_By_Copy. This convention name is

--       treated as identical in all respects to convention C, except that

--       if it is specified for a record type, then the C_Pass_By_Copy flag

--       is set, and if a foreign convention subprogram has a formal of the

--       corresponding type, then the parameter passing mechanism will be

--       set to By_Copy (unless specifically overridden by an Import or

--       Export pragma).

--    Can_Never_Be_Null (Flag38)

--       This flag is present in all entities, but can only be set in an object

--       which can never have a null value. This is set True for constant

--       access values initialized to a non-null value. This is also True for

--       all access parameters in Ada 83 and Ada 95 modes, and for access

--       parameters that explicitly exclude null in Ada 2005.

--

--       This is used to avoid unnecessary resetting of the Is_Known_Non_Null

--       flag for such entities. In Ada 2005 mode, this is also used when

--       determining subtype conformance of subprogram profiles to ensure

--       that two formals have the same null-exclusion status.

--

--       ??? This is also set on some access types, eg the Etype of the

--       anonymous access type of a controlling formal.

--    Can_Use_Internal_Rep (Flag229) [base type only]

--       Present in Access_Subprogram_Kind nodes. This flag is set by the

--       front end and used by the back end. False means that the back end

--       must represent the type in the same way as Convention-C types (and

--       other foreign-convention types). On many targets, this means that

--       the back end will use dynamically generated trampolines for nested

--       subprograms. True means that the back end can represent the type in

--       some internal way. On the aforementioned targets, this means that the

--       back end will not use dynamically generated trampolines. This flag

--       must be False if Has_Foreign_Convention is True; otherwise, the front

--       end is free to set the policy.

--

--       Setting this False in all cases corresponds to the traditional back

--       end strategy, where all access-to-subprogram types are represented the

--       same way, independent of the Convention. See also

--       Always_Compatible_Rep in Targparm.

--

--       Efficiency note: On targets that use dynamically generated

--       trampolines, False generally favors efficiency of top-level

--       subprograms, whereas True generally favors efficiency of nested

--       ones. On other targets, this flag has little or no effect on

--       efficiency. The front end should take this into account. In

--       particular, pragma Favor_Top_Level gives a hint that the flag should

--       be False.

--

--       Note: We considered using Convention-C for this purpose, but we need

--       this separate flag, because Convention-C implies that for

--       P'[Unrestricted_]Access, P also have convention C. Sometimes we want

--       to have Can_Use_Internal_Rep False for an access type, but allow P to

--       have convention Ada.

--    Chars (Name1)

--       Present in all entities. This field contains an entry into the names

--       table that has the character string of the identifier, character

--       literal or operator symbol. See Namet for further details. Note that

--       throughout the processing of the front end, this name is the simple

--       unqualified name. However, just before gigi is called, a call is made

--       to Qualify_All_Entity_Names. This causes entity names to be qualified

--       using the encoding described in exp_dbug.ads, and from that point on

--       (including post gigi steps such as cross-reference generation), the

--       entities will contain the encoded qualified names.

--    Checks_May_Be_Suppressed (Flag31)

--       Present in all entities. Set if a pragma Suppress or Unsuppress

--       mentions the entity specifically in the second argument. If this

--       flag is set the Global_Entity_Suppress and Local_Entity_Suppress

--       tables must be consulted to determine if there actually is an active

--       Suppress or Unsuppress pragma that applies to the entity.

--    Class_Wide_Type (Node9)

--       Present in all type entities. For a tagged type or subtype, returns

--       the corresponding implicitly declared class-wide type. For a

--       class-wide type, returns itself. Set to Empty for non-tagged types.

--    Cloned_Subtype (Node16)

--       Present in E_Record_Subtype and E_Class_Wide_Subtype entities.

--       Each such entity can either have a Discriminant_Constraint, in

--       which case it represents a distinct type from the base type (and

--       will have a list of components and discrimants in the list headed by

--       First_Entity) or else no such constraint, in which case it will be a

--       copy of the base type.

--

--       o  Each element of the list in First_Entity is copied from the base

--          type; in that case, this field is Empty.

--

--       o  The list in First_Entity is shared with the base type; in that

--          case, this field points to that entity.

--

--       A record or classwide subtype may also be a copy of some other

--       subtype and share the entities in the First_Entity with that subtype.

--       In that case, this field points to that subtype.

--

--       For E_Class_Wide_Subtype, the presence of Equivalent_Type overrides

--       this field. Note that this field ONLY appears in subtype entries, not

--       in type entries, it is not present, and it is an error to reference

--       Cloned_Subtype in an E_Record_Type or E_Class_Wide_Type entity.

--    Comes_From_Source

--       This flag appears on all nodes, including entities, and indicates

--       that the node was created by the scanner or parser from the original

--       source. Thus for entities, it indicates that the entity is defined

--       in the original source program.

--    Component_Alignment (special field) [base type only]

--       Present in array and record entities. Contains a value of type

--       Component_Alignment_Kind indicating the alignment of components.

--       Set to Calign_Default normally, but can be overridden by use of

--       the Component_Alignment pragma. Note: this field is currently

--       stored in a non-standard way, see body for details.

--    Component_Bit_Offset (Uint11)

--       Present in record components (E_Component, E_Discriminant) if a

--       component clause applies to the component. First bit position of

--       given component, computed from the first bit and position values

--       given in the component clause. A value of No_Uint means that the

--       value is not yet known. The value can be set by the appearance of

--       an explicit component clause in a record representation clause,

--       or it can be set by the front-end in package Layout, or it can be

--       set by the backend. By the time backend processing is completed,

--       this field is always set. A negative value is used to represent

--       a value which is not known at compile time, and must be computed

--       at run-time (this happens if fields of a record have variable

--       lengths). See package Layout for details of these values.

--

--       Note: Component_Bit_Offset is redundant with respect to the fields

--       Normalized_First_Bit and Normalized_Position, and could in principle

--       be eliminated, but it is convenient in several situations, including

--       use in Gigi, to have this redundant field.

--    Component_Clause (Node13)

--       Present in record components and discriminants. If a record

--       representation clause is present for the corresponding record type a

--       that specifies a position for the component, then the Component_Clause

--       field of the E_Component entity points to the N_Component_Clause node.

--       Set to Empty if no record representation clause was present, or if

--       there was no specification for this component.

--    Component_Size (Uint22) [implementation base type only]

--       Present in array types. It contains the component size value for

--       the array. A value of No_Uint means that the value is not yet set.

--       The value can be set by the use of a component size clause, or

--       by the front end in package Layout, or by the backend. A negative

--       value is used to represent a value which is not known at compile

--       time, and must be computed at run-time (this happens if the type

--       of the component has a variable length size). See package Layout

--       for details of these values.

--    Component_Type (Node20) [implementation base type only]

--       Present in array types and string types. References component type.

--    Corresponding_Concurrent_Type (Node18)

--       Present in record types that are constructed by the expander to

--       represent task and protected types (Is_Concurrent_Record_Type flag

--       set True). Points to the entity for the corresponding task type or

--       protected type.

--    Corresponding_Discriminant (Node19)

--       Present in discriminants of a derived type, when the discriminant is

--       used to constrain a discriminant of the parent type. Points to the

--       corresponding discriminant in the parent type. Otherwise it is Empty.

--    Corresponding_Equality (Node13)

--       Present in function entities for implicit inequality operators.

--       Denotes the explicit or derived equality operation that creates

--       the implicit inequality. Note that this field is not present in

--       other function entities, only in implicit inequality routines,

--       where Comes_From_Source is always False.

--    Corresponding_Protected_Entry (Node18)

--       Present in subprogram bodies. Set for subprogram bodies that implement

--       a protected type entry to point to the entity for the entry.

--    Corresponding_Record_Type (Node18)

--       Present in protected and task types and subtypes. References the

--       entity for the corresponding record type constructed by the expander

--       (see Exp_Ch9). This type is used to represent values of the task type.

--    Corresponding_Remote_Type (Node22)

--       Present in record types that describe the fat pointer structure for

--       Remote_Access_To_Subprogram types. References the original access

--       type.

--    CR_Discriminant (Node23)

--       Present in discriminants of concurrent types. Denotes the homologous

--       discriminant of the corresponding record type. The CR_Discriminant is

--       created at the same time as the discriminal, and used to replace

--       occurrences of the discriminant within the type declaration.

--    Current_Use_Clause (Node27)

--       Present in packages and in types. For packages, denotes the use

--       package clause currently in scope that makes the package use_visible.

--       For types, it denotes the use_type clause that makes the operators of

--       the type visible. Used for more precise warning messages on redundant

--       use clauses.

--    Current_Value (Node9)

--       Present in all object entities. Set in E_Variable, E_Constant, formal

--       parameters and E_Loop_Parameter entities if we have trackable current

--       values. Set non-Empty if the (constant) current value of the variable

--       is known, This value is valid only for references from the same

--       sequential scope as the entity. The sequential scope of an entity

--       includes the immediate scope and any contained scopes that are package

--       specs, package bodies, blocks (at any nesting level) or statement

--       sequences in IF or loop statements.

--

--       Another related use of this field is to record information about the

--       value obtained from an IF or WHILE statement condition. If the IF or

--       ELSIF or WHILE condition has the form "NOT {,NOT] OBJ RELOP VAL ",

--       or OBJ [AND [THEN]] expr, where OBJ refers to an entity with a

--       Current_Value field, RELOP is one of the six relational operators, and

--       VAL is a compile-time known value then the Current_Value field of OBJ

--       points to the N_If_Statement, N_Elsif_Part, or N_Iteration_Scheme node

--       of the relevant construct, and the Condition field of this can be

--       consulted to give information about the value of OBJ. For more details

--       on this usage, see the procedure Exp_Util.Get_Current_Value_Condition.

--    Debug_Info_Off (Flag166)

--       Present in all entities. Set if a pragma Suppress_Debug_Info applies

--       to the entity, or if internal processing in the compiler determines

--       that suppression of debug information is desirable. Note that this

--       flag is only for use by the front end as part of the processing for

--       determining if Needs_Debug_Info should be set. The back end should

--       always test Needs_Debug_Info, it should never test Debug_Info_Off.

--    Debug_Renaming_Link (Node25)

--       Used to link the variable associated with a debug renaming declaration

--       to the renamed entity. See Exp_Dbug.Debug_Renaming_Declaration for

--       details of the use of this field.

--    Declaration_Node (synthesized)

--       Applies to all entities. Returns the tree node for the construct that

--       declared the entity. Normally this is just the Parent of the entity.

--       One exception arises with child units, where the parent of the entity

--       is a selected component/defining program unit name. Another exception

--       is that if the entity is an incomplete type that has been completed,

--       then we obtain the declaration node denoted by the full type, i.e. the

--       full type declaration node. Also note that for subprograms, this

--       returns the {function,procedure}_specification, not the subprogram_

--       declaration.

--    Default_Aspect_Component_Value (Node19)

--       Present in array types. Holds the static value specified in a

--       default_component_value aspect specification for the array type.

--    Default_Aspect_Value (Node19)

--       Present in scalar types. Holds the static value specified in a

--       default_value aspect specification for the type.

--    Default_Expr_Function (Node21)

--       Present in parameters. It holds the entity of the parameterless

--       function that is built to evaluate the default expression if it is

--       more complex than a simple identifier or literal. For the latter

--       simple cases or if there is no default value, this field is Empty.

--    Default_Expressions_Processed (Flag108)

--       A flag in subprograms (functions, operators, procedures) and in

--       entries and entry families used to indicate that default expressions

--       have been processed and to avoid multiple calls to process the

--       default expressions (see Freeze.Process_Default_Expressions), which

--       would not only waste time, but also generate false error messages.

--    Default_Value (Node20)

--       Present in formal parameters. Points to the node representing the

--       expression for the default value for the parameter. Empty if the

--       parameter has no default value (which is always the case for OUT

--       and IN OUT parameters in the absence of errors).

--    Delay_Cleanups (Flag114)

--       Present in entities that have finalization lists (subprograms

--       blocks, and tasks). Set if there are pending generic body

--       instantiations for the corresponding entity. If this flag is

--       set, then generation of cleanup actions for the corresponding

--       entity must be delayed, since the insertion of the generic body

--       may affect cleanup generation (see Inline for further details).

--    Delay_Subprogram_Descriptors (Flag50)

--       Present in entities for which exception subprogram descriptors

--       are generated (subprograms, package declarations and package

--       bodies). Present if there are pending generic body instantiations

--       for the corresponding entity. If this flag is set, then generation

--       of the subprogram descriptor for the corresponding enities must

--       be delayed, since the insertion of the generic body may add entries

--       to the list of handlers.

--

--       Note: for subprograms, Delay_Subprogram_Descriptors is set if and

--       only if Delay_Cleanups is set. But Delay_Cleanups can be set for a

--       a block (in which case Delay_Subprogram_Descriptors is set for the

--       containing subprogram). In addition Delay_Subprogram_Descriptors is

--       set for a library level package declaration or body which contains

--       delayed instantiations (in this case the descriptor refers to the

--       enclosing elaboration procedure).

--    Delta_Value (Ureal18)

--       Present in fixed and decimal types. Points to a universal real

--       that holds value of delta for the type, as given in the declaration

--       or as inherited by a subtype or derived type.

--    Dependent_Instances (Elist8)

--       Present in packages that are instances. Holds list of instances

--       of inner generics. Used to place freeze nodes for those instances

--       after that of the current one, i.e. after the corresponding generic

--       bodies.

--    Depends_On_Private (Flag14)

--       Present in all type entities. Set if the type is private or if it

--       depends on a private type.

--    Designated_Type (synthesized)

--       Applies to access types. Returns the designated type. Differs

--       from Directly_Designated_Type in that if the access type refers

--       to an incomplete type, and the full type is available, then this

--       full type is returned instead of the incomplete type.

--    Digits_Value (Uint17)

--       Present in floating point types and subtypes and decimal types and

--       subtypes. Contains the Digits value specified in the declaration.

--    Direct_Primitive_Operations (Elist10)

--       Present in tagged types and subtypes (including synchronized types),

--       in tagged private types and in tagged incomplete types. Element list

--       of entities for primitive operations of the tagged type. Not present

--       in untagged types. In order to follow the C++ ABI, entities of

--       primitives that come from source must be stored in this list in the

--       order of their occurrence in the sources. For incomplete types the

--       list is always empty.

--    Directly_Designated_Type (Node20)

--       Present in access types. This field points to the type that is

--       directly designated by the access type. In the case of an access

--       type to an incomplete type, this field references the incomplete

--       type. Directly_Designated_Type is typically used in implementing the

--       static semantics of the language; in implementing dynamic semantics,

--       we typically want the full view of the designated type. The function

--       Designated_Type obtains this full type in the case of access to an

--       incomplete type.

--    Discard_Names (Flag88)

--       Present in types and exception entities. Set if pragma Discard_Names

--       applies to the entity. It is also set for declarative regions and