blob: 64624077cec19eddaec949f4f3d9847a6fefe27c [file] [log] [blame]
------------------------------------------------------------------------------
-- --
-- GNAT COMPILER COMPONENTS --
-- --
-- R E P I N F O --
-- --
-- S p e c --
-- --
-- Copyright (C) 1999-2022, 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. 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 COPYING3. If not, go to --
-- http://www.gnu.org/licenses for a complete copy of the license. --
-- --
-- GNAT was originally developed by the GNAT team at New York University. --
-- Extensive contributions were provided by Ada Core Technologies Inc. --
-- --
------------------------------------------------------------------------------
-- This package contains the routines to handle back annotation of the
-- tree to fill in representation information, and also the routines used
-- by -gnatR to output this information.
-- WARNING: There is a C version of this package. Any changes to this
-- source file must be properly reflected in the C header file repinfo.h
with Types; use Types;
with Uintp; use Uintp;
package Repinfo is
--------------------------------
-- Representation Information --
--------------------------------
-- The representation information of interest here is size and
-- component information for arrays and records. For primitive
-- types, the front end computes the Esize and RM_Size fields of
-- the corresponding entities as constant non-negative integers,
-- and the Uint values are stored directly in these fields.
-- For composite types, there are two cases:
-- 1. In some cases the front end knows the values statically,
-- for example in the case where representation clauses or
-- pragmas specify the values.
-- 2. The backend is responsible for layout of all types and objects
-- not laid out by the front end. This includes all dynamic values,
-- and also static values (e.g. record sizes) when not set by the
-- front end.
-----------------------------
-- Back Annotation by Gigi --
-----------------------------
-- The following interface is used by gigi
-- As part of the processing in gigi, the types are laid out and
-- appropriate values computed for the sizes and component positions
-- and sizes of records and arrays.
-- The back-annotation circuit in gigi is responsible for updating the
-- relevant fields in the tree to reflect these computations, as follows:
-- For E_Array_Type entities, the Component_Size field
-- For all record and array types and subtypes, the Esize and RM_Size
-- fields, which respectively contain the Object_Size and Value_Size
-- values for the type or subtype.
-- For E_Component and E_Discriminant entities, the Esize (size
-- of component) and Component_Bit_Offset fields. Note that gigi
-- does not generally back annotate Normalized_Position/First_Bit.
-- There are three cases to consider:
-- 1. The value is constant. In this case, the back annotation works
-- by simply storing the non-negative universal integer value in
-- the appropriate field corresponding to this constant size.
-- 2. The value depends on the discriminant values for the current
-- record. In this case, gigi back annotates the field with a
-- representation of the expression for computing the value in
-- terms of the discriminants. A negative Uint value is used to
-- represent the value of such an expression, as explained in
-- the following section.
-- 3. The value depends on variables other than discriminants of the
-- current record. In this case, gigi also back annotates the field
-- with a representation of the expression for computing the value
-- in terms of the variables represented symbolically.
-- Note: the extended back annotation for the dynamic case is needed only
-- for -gnatR3 output. Since it can be expensive to do this back annotation
-- (for discriminated records with many variable-length arrays), we only do
-- the full back annotation in -gnatR3 mode. In any other mode, the
-- back-end just sets the value to Uint_Minus_1, indicating that the value
-- of the attribute depends on discriminant information, but not giving
-- further details.
-- GCC expressions are represented with a Uint value that is negative.
-- See the body of this package for details on the representation used.
-- One other case in which gigi back annotates GCC expressions is in
-- the Present_Expr field of an N_Variant node. This expression which
-- will always depend on discriminants, and hence always be represented
-- as a negative Uint value, provides an expression which, when evaluated
-- with a given set of discriminant values, indicates whether the variant
-- is present for that set of values (result is True, i.e. non-zero) or
-- not present (result is False, i.e. zero). Again, the full annotation of
-- this field is done only in -gnatR3 mode, and in other modes, the value
-- is set to Uint_Minus_1.
subtype Node_Ref is Unegative;
-- Subtype used for negative Uint values used to represent nodes
subtype Node_Ref_Or_Val is Uint;
-- Subtype used for values that can be a Node_Ref (negative) or a value
-- (non-negative) or No_Uint.
type TCode is range 0 .. 27;
-- Type used on Ada side to represent DEFTREECODE values defined in
-- tree.def. Only a subset of these tree codes can actually appear.
-- The names are the names from tree.def in Ada casing.
-- name code description operands symbol
Cond_Expr : constant TCode := 1; -- conditional 3 ?<>
Plus_Expr : constant TCode := 2; -- addition 2 +
Minus_Expr : constant TCode := 3; -- subtraction 2 -
Mult_Expr : constant TCode := 4; -- multiplication 2 *
Trunc_Div_Expr : constant TCode := 5; -- truncating div 2 /t
Ceil_Div_Expr : constant TCode := 6; -- div rounding up 2 /c
Floor_Div_Expr : constant TCode := 7; -- div rounding down 2 /f
Trunc_Mod_Expr : constant TCode := 8; -- mod for trunc_div 2 modt
Ceil_Mod_Expr : constant TCode := 9; -- mod for ceil_div 2 modc
Floor_Mod_Expr : constant TCode := 10; -- mod for floor_div 2 modf
Exact_Div_Expr : constant TCode := 11; -- exact div 2 /e
Negate_Expr : constant TCode := 12; -- negation 1 -
Min_Expr : constant TCode := 13; -- minimum 2 min
Max_Expr : constant TCode := 14; -- maximum 2 max
Abs_Expr : constant TCode := 15; -- absolute value 1 abs
Truth_And_Expr : constant TCode := 16; -- boolean and 2 and
Truth_Or_Expr : constant TCode := 17; -- boolean or 2 or
Truth_Xor_Expr : constant TCode := 18; -- boolean xor 2 xor
Truth_Not_Expr : constant TCode := 19; -- boolean not 1 not
Lt_Expr : constant TCode := 20; -- comparison < 2 <
Le_Expr : constant TCode := 21; -- comparison <= 2 <=
Gt_Expr : constant TCode := 22; -- comparison > 2 >
Ge_Expr : constant TCode := 23; -- comparison >= 2 >=
Eq_Expr : constant TCode := 24; -- comparison = 2 ==
Ne_Expr : constant TCode := 25; -- comparison /= 2 !=
Bit_And_Expr : constant TCode := 26; -- bitwise and 2 &
-- The following entry is used to represent a discriminant value in
-- the tree. It has a special tree code that does not correspond
-- directly to a GCC node. The single operand is the index number
-- of the discriminant in the record (1 = first discriminant).
Discrim_Val : constant TCode := 0; -- discriminant value 1 #
-- The following entry is used to represent a value not known at
-- compile time in the tree, other than a discriminant value. It
-- has a special tree code that does not correspond directly to
-- a GCC node. The single operand is an arbitrary index number.
Dynamic_Val : constant TCode := 27; -- dynamic value 1 var
----------------------------
-- The JSON output format --
----------------------------
-- The representation information can be output to a file in the JSON
-- data interchange format specified by the ECMA-404 standard. In the
-- following description, the terminology is that of the JSON syntax
-- from the ECMA document and of the JSON grammar from www.json.org.
-- The output is an array of entities
-- An entity is an object whose members are pairs taken from:
-- "name" : string
-- "location" : string
-- "record" : array of components
-- "[parent_]*variant" : array of variants
-- "formal" : array of formal parameters
-- "mechanism" : string
-- "Size" : numerical expression
-- "Object_Size" : numerical expression
-- "Value_Size" : numerical expression
-- "Component_Size" : numerical expression
-- "Range" : array of numbers
-- "Small" : number
-- "Alignment" : number
-- "Convention" : string
-- "Linker_Section" : string
-- "Bit_Order" : string
-- "Scalar_Storage_Order" : string
-- "name" and "location" are present for every entity and come from the
-- declaration of the associated Ada entity. The value of "name" is the
-- fully qualified Ada name. The value of "location" is the expanded
-- chain of instantiation locations that contains the entity.
-- "record" is present for every record type and its value is the list of
-- components. "[parent_]*variant" is present only if the record type, or
-- one of its ancestors (parent, grand-parent, etc) if it's an extension,
-- has a variant part and its value is the list of variants.
-- "formal" is present for every subprogram and entry, and its value is
-- the list of formal parameters. "mechanism" is present for functions
-- only and its value is the return mechanim.
-- The other pairs may be present when the eponymous aspect/attribute is
-- defined for the Ada entity, and their value is set by the language.
-- A component is an object whose members are pairs taken from:
-- "name" : string
-- "discriminant" : number
-- "Position" : numerical expression
-- "First_Bit" : number
-- "Size" : numerical expression
-- "name" is present for every component and comes from the declaration
-- of the type; its value is the unqualified Ada name. "discriminant" is
-- present only if the component is a discriminant, and its value is the
-- ranking of the discriminant in the list of discriminants of the type,
-- i.e. an integer index ranging from 1 to the number of discriminants.
-- The other three pairs are present for every component and come from
-- the layout of the type; their value is the value of the eponymous
-- attribute set by the language.
-- A variant is an object whose members are pairs taken from:
-- "present" : numerical expression
-- "record" : array of components
-- "variant" : array of variants
-- "present" and "record" are present for every variant. The value of
-- "present" is a boolean expression that evaluates to true when the
-- components of the variant are contained in the record type and to
-- false when they are not. The value of "record" is the list of
-- components in the variant. "variant" is present only if the variant
-- itself has a variant part and its value is the list of (sub)variants.
-- A formal parameter is an object whose members are pairs taken from:
-- "name" : string
-- "mechanism" : string
-- The two pairs are present for every formal parameter. "name" comes
-- from the declaration of the parameter in the subprogram or entry
-- and its value is the unqualified Ada name. The value of "mechanism"
-- is the passing mechanism for the parameter set by the language.
-- A numerical expression is either a number or an object whose members
-- are pairs taken from:
-- "code" : string
-- "operands" : array of numerical expressions
-- The two pairs are present for every such object. The value of "code"
-- is a symbol taken from the table defining the TCode type above. The
-- number of elements of the value of "operands" is specified by the
-- operands column in the line associated with the symbol in the table.
-- As documented above, the full back annotation is only done in -gnatR3.
-- In the other cases, if the numerical expression is not a number, then
-- it is replaced with the "??" string.
------------------------
-- The gigi Interface --
------------------------
-- The following declarations are for use by gigi for back annotation
function Create_Node
(Expr : TCode;
Op1 : Node_Ref_Or_Val;
Op2 : Node_Ref_Or_Val := No_Uint;
Op3 : Node_Ref_Or_Val := No_Uint) return Node_Ref;
-- Creates a node using the tree code defined by Expr and from one to three
-- operands as required (unused operands set as shown to No_Uint) Note that
-- this call can be used to create a discriminant reference by using (Expr
-- => Discrim_Val, Op1 => discriminant_number).
function Create_Discrim_Ref (Discr : Entity_Id) return Node_Ref;
-- Creates a reference to the discriminant whose entity is Discr
--------------------------------------------------------
-- Front-End Interface for Dynamic Size/Offset Values --
--------------------------------------------------------
-- This interface is used by GNAT LLVM to deal with all dynamic size and
-- offset fields.
-- The interface here allows these created entities to be referenced
-- using negative Unit values, so that they can be stored in the
-- appropriate size and offset fields in the tree.
-- In the case of components, if the location of the component is static,
-- then all four fields (Component_Bit_Offset, Normalized_Position, Esize,
-- and Normalized_First_Bit) are set to appropriate values. In the case of
-- a nonstatic component location, Component_Bit_Offset is not used and
-- is left set to Unknown. Normalized_Position and Normalized_First_Bit
-- are set appropriately.
subtype SO_Ref is Uint;
-- Type used to represent a Uint value that represents a static or
-- dynamic size/offset value (non-negative if static, negative if
-- the size value is dynamic).
subtype Dynamic_SO_Ref is Uint;
-- Type used to represent a negative Uint value used to store
-- a dynamic size/offset value.
function Is_Dynamic_SO_Ref (U : SO_Ref) return Boolean;
pragma Inline (Is_Dynamic_SO_Ref);
-- Given a SO_Ref (Uint) value, returns True iff the SO_Ref value
-- represents a dynamic Size/Offset value (i.e. it is negative).
function Is_Static_SO_Ref (U : SO_Ref) return Boolean;
pragma Inline (Is_Static_SO_Ref);
-- Given a SO_Ref (Uint) value, returns True iff the SO_Ref value
-- represents a static Size/Offset value (i.e. it is non-negative).
function Create_Dynamic_SO_Ref (E : Entity_Id) return Dynamic_SO_Ref;
-- Given the Entity_Id for a constant (case 1), the Node_Id for an
-- expression (case 2), or the Entity_Id for a function (case 3),
-- this function returns a (negative) Uint value that can be used
-- to retrieve the entity or expression for later use.
function Get_Dynamic_SO_Entity (U : Dynamic_SO_Ref) return Entity_Id;
-- Retrieve the Node_Id or Entity_Id stored by a previous call to
-- Create_Dynamic_SO_Ref. The approach is that the front end makes
-- the necessary Create_Dynamic_SO_Ref calls to associate the node
-- and entity id values and the back end makes Get_Dynamic_SO_Ref
-- calls to retrieve them.
------------------------------
-- External tools Interface --
------------------------------
type Discrim_List is array (Pos range <>) of Uint;
-- Type used to represent list of discriminant values
function Rep_Value (Val : Node_Ref_Or_Val; D : Discrim_List) return Uint;
-- Given the contents of a First_Bit_Position or Esize field containing
-- a node reference (i.e. a negative Uint value) and D, the list of
-- discriminant values, returns the interpreted value of this field.
-- For convenience, Rep_Value will take a non-negative Uint value
-- as an argument value, and return it unmodified. A No_Uint value is
-- also returned unmodified.
------------------------
-- Compiler Interface --
------------------------
procedure List_Rep_Info (Bytes_Big_Endian : Boolean);
-- Procedure to list representation information. Bytes_Big_Endian is the
-- value from Ttypes (Repinfo cannot have a dependency on Ttypes).
--------------------------
-- Debugging Procedures --
--------------------------
procedure List_GCC_Expression (U : Node_Ref_Or_Val);
-- Prints out given expression in symbolic form. Constants are listed
-- in decimal numeric form, Discriminants are listed with a # followed
-- by the discriminant number, and operators are output in appropriate
-- symbolic form No_Uint displays as two question marks. The output is
-- on a single line but has no line return after it. This procedure is
-- useful only if operating in backend layout mode.
procedure lgx (U : Node_Ref_Or_Val);
-- In backend layout mode, this is like List_GCC_Expression, but
-- includes a line return at the end. If operating in front end
-- layout mode, then the name of the entity for the size (either
-- a function of a variable) is listed followed by a line return.
end Repinfo;