-- --
-- S p e c --
-- --
--- --
--- Copyright (C) 1992-2002 Free Software Foundation, Inc. --
+-- Copyright (C) 1992-2013, 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- --
+-- 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 COPYING. If not, write --
--- to the Free Software Foundation, 59 Temple Place - Suite 330, Boston, --
--- MA 02111-1307, USA. --
+-- 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. --
--- It is now maintained by Ada Core Technologies Inc (http://www.gnat.com). --
+-- Extensive contributions were provided by Ada Core Technologies Inc. --
-- --
------------------------------------------------------------------------------
-- Package containing utility procedures used throughout the expander
-with Snames; use Snames;
+with Exp_Tss; use Exp_Tss;
+with Namet; use Namet;
with Rtsfind; use Rtsfind;
+with Sinfo; use Sinfo;
with Types; use Types;
+with Uintp; use Uintp;
package Exp_Util is
-- For actions appearing in the then or else expression of a conditional
-- expression, these actions are similarly placed in the node, using the
-- Then_Actions or Else_Actions field as appropriate. Once again the
- -- expansion of the N_Conditional_Expression node rewrites the node so
- -- that the actions can be normally positioned.
+ -- expansion of the N_If_Expression node rewrites the node so that the
+ -- actions can be positioned normally.
+
+ -- For actions coming from expansion of the expression in an expression
+ -- with actions node, the action is appended to the list of actions.
-- Basically what we do is to climb up to the tree looking for the
-- proper insertion point, as described by one of the above cases,
-- Assoc_Node is the node with which the actions are associated.
-- Ins_Actions may be No_List, in which case the call has no effect.
+ procedure Insert_Action_After
+ (Assoc_Node : Node_Id;
+ Ins_Action : Node_Id);
+ -- Assoc_Node must be a node in a list. Same as Insert_Action but the
+ -- action will be inserted after N in a manner that is compatible with
+ -- the transient scope mechanism.
+
procedure Insert_Actions_After
(Assoc_Node : Node_Id;
Ins_Actions : List_Id);
--
-- Implementation limitation: Assoc_Node must be a statement. We can
-- generalize to expressions if there is a need but this is tricky to
- -- implement because of short-ciruits (among other things).???
+ -- implement because of short-circuits (among other things).???
procedure Insert_Library_Level_Action (N : Node_Id);
-- This procedure inserts and analyzes the node N as an action at the
-- Actions field of the N_Compilation_Aux node for the main unit).
procedure Insert_Library_Level_Actions (L : List_Id);
- -- Similar, but inserts a list of actions.
+ -- Similar, but inserts a list of actions
-----------------------
-- Other Subprograms --
-----------------------
+ procedure Activate_Atomic_Synchronization (N : Node_Id);
+ -- N is a node for which atomic synchronization may be required (it is
+ -- either an identifier, expanded name, or selected/indexed component or
+ -- an explicit dereference). The caller has checked the basic conditions
+ -- (atomic variable appearing and Atomic_Sync not disabled). This function
+ -- checks if atomic synchronization is required and if so sets the flag
+ -- and if appropriate generates a warning (in -gnatw.n mode).
+
procedure Adjust_Condition (N : Node_Id);
-- The node N is an expression whose root-type is Boolean, and which
-- represents a boolean value used as a condition (i.e. a True/False
-- value). This routine handles the case of C and Fortran convention
- -- boolean types, which have zero/non-zero semantics rather than the
- -- normal 0/1 semantics, and also the case of an enumeration rep
- -- clause that specifies a non-standard representation. On return,
- -- node N always has the type Standard.Boolean, with a value that
- -- is a standard Boolean values of 0/1 for False/True. This procedure
- -- is used in two situations. First, the processing for a condition
- -- field always calls Adjust_Condition, so that the boolean value
- -- presented to the backend is a standard value. Second, for the
- -- code for boolean operations such as AND, Adjust_Condition is
- -- called on both operands, and then the operation is done in the
- -- domain of Standard_Boolean, then Adjust_Result_Type is called
- -- on the result to possibly reset the original type. This procedure
+ -- boolean types, which have zero/non-zero semantics rather than the normal
+ -- 0/1 semantics, and also the case of an enumeration rep clause that
+ -- specifies a non-standard representation. On return, node N always has
+ -- the type Standard.Boolean, with a value that is a standard Boolean
+ -- values of 0/1 for False/True. This procedure is used in two situations.
+ -- First, the processing for a condition field always calls
+ -- Adjust_Condition, so that the boolean value presented to the backend is
+ -- a standard value. Second, for the code for boolean operations such as
+ -- AND, Adjust_Condition is called on both operands, and then the operation
+ -- is done in the domain of Standard_Boolean, then Adjust_Result_Type is
+ -- called on the result to possibly reset the original type. This procedure
-- also takes care of validity checking if Validity_Checks = Tests.
procedure Adjust_Result_Type (N : Node_Id; T : Entity_Id);
-- The processing of boolean operations like AND uses the procedure
- -- Adjust_Condition so that it can operate on Standard.Boolean, which
- -- is the only boolean type on which the backend needs to be able to
- -- implement such operators. This means that the result is also of
- -- type Standard.Boolean. In general the type must be reset back to
- -- the original type to get proper semantics, and that is the purpose
- -- of this procedure. N is the node (of type Standard.Boolean), and
- -- T is the desired type. As an optimization, this procedure leaves
- -- the type as Standard.Boolean in contexts where this is permissible
- -- (in particular for Condition fields, and for operands of other
- -- logical operations higher up the tree). The call to this procedure
- -- is completely ignored if the argument N is not of type Boolean.
+ -- Adjust_Condition so that it can operate on Standard.Boolean, which is
+ -- the only boolean type on which the backend needs to be able to implement
+ -- such operators. This means that the result is also of type
+ -- Standard.Boolean. In general the type must be reset back to the original
+ -- type to get proper semantics, and that is the purpose of this procedure.
+ -- N is the node (of type Standard.Boolean), and T is the desired type. As
+ -- an optimization, this procedure leaves the type as Standard.Boolean in
+ -- contexts where this is permissible (in particular for Condition fields,
+ -- and for operands of other logical operations higher up the tree). The
+ -- call to this procedure is completely ignored if the argument N is not of
+ -- type Boolean.
procedure Append_Freeze_Action (T : Entity_Id; N : Node_Id);
-- Add a new freeze action for the given type. The freeze action is
- -- attached to the freeze node for the type. Actions will be elaborated
- -- in the order in which they are added. Note that the added node is not
- -- analyzed. The analyze call is found in Sem_Ch13.Expand_N_Freeze_Entity.
+ -- attached to the freeze node for the type. Actions will be elaborated in
+ -- the order in which they are added. Note that the added node is not
+ -- analyzed. The analyze call is found in Exp_Ch13.Expand_N_Freeze_Entity.
procedure Append_Freeze_Actions (T : Entity_Id; L : List_Id);
- -- Adds the given list of freeze actions (declarations or statements)
- -- for the given type. The freeze actions are attached to the freeze
- -- node for the type. Actions will be elaborated in the order in which
- -- they are added, and the actions within the list will be elaborated in
- -- list order. Note that the added nodes are not analyzed. The analyze
- -- call is found in Sem_Ch13.Expand_N_Freeze_Entity.
+ -- Adds the given list of freeze actions (declarations or statements) for
+ -- the given type. The freeze actions are attached to the freeze node for
+ -- the type. Actions will be elaborated in the order in which they are
+ -- added, and the actions within the list will be elaborated in list order.
+ -- Note that the added nodes are not analyzed. The analyze call is found in
+ -- Exp_Ch13.Expand_N_Freeze_Entity.
+
+ procedure Build_Allocate_Deallocate_Proc
+ (N : Node_Id;
+ Is_Allocate : Boolean);
+ -- Create a custom Allocate/Deallocate to be associated with an allocation
+ -- or deallocation:
+ --
+ -- 1) controlled objects
+ -- 2) class-wide objects
+ -- 3) any kind of object on a subpool
+ --
+ -- N must be an allocator or the declaration of a temporary variable which
+ -- represents the expression of the original allocator node, otherwise N
+ -- must be a free statement. If flag Is_Allocate is set, the generated
+ -- routine is allocate, deallocate otherwise.
function Build_Runtime_Call (Loc : Source_Ptr; RE : RE_Id) return Node_Id;
-- Build an N_Procedure_Call_Statement calling the given runtime entity.
-- analyzed on return, the caller is responsible for analyzing it.
function Build_Task_Image_Decls
- (Loc : Source_Ptr;
- Id_Ref : Node_Id;
- A_Type : Entity_Id)
- return List_Id;
- -- Build declaration for a variable that holds an identifying string
- -- to be used as a task name. Id_Ref is an identifier if the task is
- -- a variable, and a selected or indexed component if the task is a
- -- component of an object. If it is an indexed component, A_Type is
- -- the corresponding array type. Its index types are used to build the
- -- string as an image of the index values. For composite types, the
- -- result includes two declarations: one for a generated function that
- -- computes the image without using concatenation, and one for the
- -- variable that holds the result.
+ (Loc : Source_Ptr;
+ Id_Ref : Node_Id;
+ A_Type : Entity_Id;
+ In_Init_Proc : Boolean := False) return List_Id;
+ -- Build declaration for a variable that holds an identifying string to be
+ -- used as a task name. Id_Ref is an identifier if the task is a variable,
+ -- and a selected or indexed component if the task is component of an
+ -- object. If it is an indexed component, A_Type is the corresponding array
+ -- type. Its index types are used to build the string as an image of the
+ -- index values. For composite types, the result includes two declarations:
+ -- one for a generated function that computes the image without using
+ -- concatenation, and one for the variable that holds the result.
+ --
+ -- If In_Init_Proc is true, the call is part of the initialization of
+ -- a component of a composite type, and the enclosing initialization
+ -- procedure must be flagged as using the secondary stack. If In_Init_Proc
+ -- is false, the call is for a stand-alone object, and the generated
+ -- function itself must do its own cleanups.
+
+ function Component_May_Be_Bit_Aligned (Comp : Entity_Id) return Boolean;
+ -- This function is in charge of detecting record components that may
+ -- cause trouble in the back end if an attempt is made to assign the
+ -- component. The back end can handle such assignments with no problem if
+ -- the components involved are small (64-bits or less) records or scalar
+ -- items (including bit-packed arrays represented with modular types) or
+ -- are both aligned on a byte boundary (starting on a byte boundary, and
+ -- occupying an integral number of bytes).
+ --
+ -- However, problems arise for records larger than 64 bits, or for arrays
+ -- (other than bit-packed arrays represented with a modular type) if the
+ -- component starts on a non-byte boundary, or does not occupy an integral
+ -- number of bytes (i.e. there are some bits possibly shared with fields
+ -- at the start or beginning of the component). The back end cannot handle
+ -- loading and storing such components in a single operation.
+ --
+ -- This function is used to detect the troublesome situation. it is
+ -- conservative in the sense that it produces True unless it knows for
+ -- sure that the component is safe (as outlined in the first paragraph
+ -- above). The code generation for record and array assignment checks for
+ -- trouble using this function, and if so the assignment is generated
+ -- component-wise, which the back end is required to handle correctly.
+ --
+ -- Note that in GNAT 3, the back end will reject such components anyway,
+ -- so the hard work in checking for this case is wasted in GNAT 3, but
+ -- it is harmless, so it is easier to do it in all cases, rather than
+ -- conditionalize it in GNAT 5 or beyond.
procedure Convert_To_Actual_Subtype (Exp : Node_Id);
-- The Etype of an expression is the nominal type of the expression,
-- not the actual subtype. Often these are the same, but not always.
-- For example, a reference to a formal of unconstrained type has the
- -- unconstrained type as its Etype, but the actual subtype is obtained
- -- by applying the actual bounds. This routine is given an expression,
- -- Exp, and (if necessary), replaces it using Rewrite, with a conversion
- -- to the actual subtype, building the actual subtype if necessary. If
- -- the expression is already of the requested type, then it is unchanged.
+ -- unconstrained type as its Etype, but the actual subtype is obtained by
+ -- applying the actual bounds. This routine is given an expression, Exp,
+ -- and (if necessary), replaces it using Rewrite, with a conversion to
+ -- the actual subtype, building the actual subtype if necessary. If the
+ -- expression is already of the requested type, then it is unchanged.
+
+ function Corresponding_Runtime_Package (Typ : Entity_Id) return RTU_Id;
+ -- Return the id of the runtime package that will provide support for
+ -- concurrent type Typ. Currently only protected types are supported,
+ -- and the returned value is one of the following:
+ -- System_Tasking_Protected_Objects
+ -- System_Tasking_Protected_Objects_Entries
+ -- System_Tasking_Protected_Objects_Single_Entry
function Current_Sem_Unit_Declarations return List_Id;
- -- Return the a place where it is fine to insert declarations for the
+ -- Return the place where it is fine to insert declarations for the
-- current semantic unit. If the unit is a package body, return the
-- visible declarations of the corresponding spec. For RCI stubs, this
-- is necessary because the point at which they are generated may not
function Duplicate_Subexpr
(Exp : Node_Id;
- Name_Req : Boolean := False)
- return Node_Id;
- -- Given the node for a subexpression, this function makes a logical
- -- copy of the subexpression, and returns it. This is intended for use
- -- when the expansion of an expression needs to repeat part of it. For
- -- example, replacing a**2 by a*a requires two references to a which
- -- may be a complex subexpression. Duplicate_Subexpression guarantees
- -- not to duplicate side effects. If necessary, it generates actions
- -- to save the expression value in a temporary, inserting these actions
- -- into the tree using Insert_Actions with Exp as the insertion location.
- -- The original expression and the returned result then become references
- -- to this saved value. Exp must be analyzed on entry. On return, Exp
- -- is analyzed, but the caller is responsible for analyzing the returned
- -- copy after it is attached to the tree. The Name_Req flag is set to
- -- ensure that the result is suitable for use in a context requiring a
- -- name (e.g. the prefix of an attribute reference).
+ Name_Req : Boolean := False) return Node_Id;
+ -- Given the node for a subexpression, this function makes a logical copy
+ -- of the subexpression, and returns it. This is intended for use when the
+ -- expansion of an expression needs to repeat part of it. For example,
+ -- replacing a**2 by a*a requires two references to a which may be a
+ -- complex subexpression. Duplicate_Subexpr guarantees not to duplicate
+ -- side effects. If necessary, it generates actions to save the expression
+ -- value in a temporary, inserting these actions into the tree using
+ -- Insert_Actions with Exp as the insertion location. The original
+ -- expression and the returned result then become references to this saved
+ -- value. Exp must be analyzed on entry. On return, Exp is analyzed, but
+ -- the caller is responsible for analyzing the returned copy after it is
+ -- attached to the tree. The Name_Req flag is set to ensure that the result
+ -- is suitable for use in a context requiring name (e.g. the prefix of an
+ -- attribute reference).
--
-- Note that if there are any run time checks in Exp, these same checks
-- will be duplicated in the returned duplicated expression. The two
function Duplicate_Subexpr_No_Checks
(Exp : Node_Id;
- Name_Req : Boolean := False)
- return Node_Id;
+ Name_Req : Boolean := False) return Node_Id;
-- Identical in effect to Duplicate_Subexpr, except that Remove_Checks
-- is called on the result, so that the duplicated expression does not
-- include checks. This is appropriate for use when Exp, the original
function Duplicate_Subexpr_Move_Checks
(Exp : Node_Id;
- Name_Req : Boolean := False)
- return Node_Id;
- -- Identical in effect to Duplicate_Subexpr, except that Remove_Checks
- -- is called on Exp after the duplication is complete, so that the
- -- original expression does not include checks. In this case the result
- -- returned (the duplicated expression) will retain the original checks.
- -- This is appropriate for use when the duplicated expression is sure
- -- to be elaborated before the original expression Exp, so that there
- -- is no need to repeat the checks.
+ Name_Req : Boolean := False) return Node_Id;
+ -- Identical in effect to Duplicate_Subexpr, except that Remove_Checks is
+ -- called on Exp after the duplication is complete, so that the original
+ -- expression does not include checks. In this case the result returned
+ -- (the duplicated expression) will retain the original checks. This is
+ -- appropriate for use when the duplicated expression is sure to be
+ -- elaborated before the original expression Exp, so that there is no need
+ -- to repeat the checks.
procedure Ensure_Defined (Typ : Entity_Id; N : Node_Id);
-- This procedure ensures that type referenced by Typ is defined. For the
-- used to ensure that an Itype is properly defined outside a conditional
-- construct when it is referenced in more than one branch.
+ function Entry_Names_OK return Boolean;
+ -- Determine whether it is appropriate to dynamically allocate strings
+ -- which represent entry [family member] names. These strings are created
+ -- by the compiler and used by GDB.
+
+ procedure Evaluate_Name (Nam : Node_Id);
+ -- Remove the all side effects from a name which appears as part of an
+ -- object renaming declaration. More comments are needed here that explain
+ -- how this differs from Force_Evaluation and Remove_Side_Effects ???
+
procedure Evolve_And_Then (Cond : in out Node_Id; Cond1 : Node_Id);
-- Rewrites Cond with the expression: Cond and then Cond1. If Cond is
-- Empty, then simply returns Cond1 (this allows the use of Empty to
-- initialize a series of checks evolved by this routine, with a final
- -- result of Empty indicating that no checks were required). The Sloc
- -- field of the constructed N_And_Then node is copied from Cond1.
+ -- result of Empty indicating that no checks were required). The Sloc field
+ -- of the constructed N_And_Then node is copied from Cond1.
procedure Evolve_Or_Else (Cond : in out Node_Id; Cond1 : Node_Id);
- -- Rewrites Cond with the expression: Cond or else Cond1. If Cond is
- -- Empty, then simply returns Cond1 (this allows the use of Empty to
- -- initialize a series of checks evolved by this routine, with a final
- -- result of Empty indicating that no checks were required). The Sloc
- -- field of the constructed N_And_Then node is copied from Cond1.
+ -- Rewrites Cond with the expression: Cond or else Cond1. If Cond is Empty,
+ -- then simply returns Cond1 (this allows the use of Empty to initialize a
+ -- series of checks evolved by this routine, with a final result of Empty
+ -- indicating that no checks were required). The Sloc field of the
+ -- constructed N_Or_Else node is copied from Cond1.
procedure Expand_Subtype_From_Expr
(N : Node_Id;
-- declarations and/or allocations when the type is indefinite (including
-- class-wide).
+ function Find_Interface_ADT
+ (T : Entity_Id;
+ Iface : Entity_Id) return Elmt_Id;
+ -- Ada 2005 (AI-251): Given a type T implementing the interface Iface,
+ -- return the element of Access_Disp_Table containing the tag of the
+ -- interface.
+
+ function Find_Interface_Tag
+ (T : Entity_Id;
+ Iface : Entity_Id) return Entity_Id;
+ -- Ada 2005 (AI-251): Given a type T implementing the interface Iface,
+ -- return the record component containing the tag of Iface.
+
function Find_Prim_Op (T : Entity_Id; Name : Name_Id) return Entity_Id;
-- Find the first primitive operation of type T whose name is 'Name'.
- -- this function allows the use of a primitive operation which is not
- -- directly visible
+ -- This function allows the use of a primitive operation which is not
+ -- directly visible. If T is a class wide type, then the reference is
+ -- to an operation of the corresponding root type. Raises Program_Error
+ -- exception if no primitive operation is found. This is normally an
+ -- internal error, but in some cases is an expected consequence of
+ -- illegalities elsewhere.
+
+ function Find_Prim_Op
+ (T : Entity_Id;
+ Name : TSS_Name_Type) return Entity_Id;
+ -- Find the first primitive operation of type T whose name has the form
+ -- indicated by the name parameter (i.e. is a type support subprogram
+ -- with the indicated suffix). This function allows use of a primitive
+ -- operation which is not directly visible. If T is a class wide type,
+ -- then the reference is to an operation of the corresponding root type.
+ -- Raises Program_Error exception if no primitive operation is found.
+ -- This is normally an internal error, but in some cases is an expected
+ -- consequence of illegalities elsewhere.
+
+ function Find_Protection_Object (Scop : Entity_Id) return Entity_Id;
+ -- Traverse the scope stack starting from Scop and look for an entry,
+ -- entry family, or a subprogram that has a Protection_Object and return
+ -- it. Raises Program_Error if no such entity is found since the context
+ -- in which this routine is invoked should always have a protection
+ -- object.
+
+ function Find_Protection_Type (Conc_Typ : Entity_Id) return Entity_Id;
+ -- Given a protected type or its corresponding record, find the type of
+ -- field _object.
procedure Force_Evaluation
(Exp : Node_Id;
Name_Req : Boolean := False);
-- Force the evaluation of the expression right away. Similar behavior
-- to Remove_Side_Effects when Variable_Ref is set to TRUE. That is to
- -- say, it removes the side-effects and capture the values of the
- -- variables. Remove_Side_effects guarantees that multiple evaluations
+ -- say, it removes the side-effects and captures the values of the
+ -- variables. Remove_Side_Effects guarantees that multiple evaluations
-- of the same expression won't generate multiple side effects, whereas
-- Force_Evaluation further guarantees that all evaluations will yield
-- the same result.
+ function Fully_Qualified_Name_String (E : Entity_Id) return String_Id;
+ -- Generates the string literal corresponding to the fully qualified name
+ -- of entity E, in all upper case, with an ASCII.NUL appended at the end
+ -- of the name.
+
procedure Generate_Poll_Call (N : Node_Id);
-- If polling is active, then a call to the Poll routine is built,
-- and then inserted before the given node N and analyzed.
+ procedure Get_Current_Value_Condition
+ (Var : Node_Id;
+ Op : out Node_Kind;
+ Val : out Node_Id);
+ -- This routine processes the Current_Value field of the variable Var. If
+ -- the Current_Value field is null or if it represents a known value, then
+ -- on return Cond is set to N_Empty, and Val is set to Empty.
+ --
+ -- The other case is when Current_Value points to an N_If_Statement or an
+ -- N_Elsif_Part or a N_Iteration_Scheme node (see description in Einfo for
+ -- exact details). In this case, Get_Current_Condition digs out the
+ -- condition, and then checks if the condition is known false, known true,
+ -- or not known at all. In the first two cases, Get_Current_Condition will
+ -- return with Op set to the appropriate conditional operator (inverted if
+ -- the condition is known false), and Val set to the constant value. If the
+ -- condition is not known, then Op and Val are set for the empty case
+ -- (N_Empty and Empty).
+ --
+ -- The check for whether the condition is true/false unknown depends
+ -- on the case:
+ --
+ -- For an IF, the condition is known true in the THEN part, known false
+ -- in any ELSIF or ELSE part, and not known outside the IF statement in
+ -- question.
+ --
+ -- For an ELSIF, the condition is known true in the ELSIF part, known
+ -- FALSE in any subsequent ELSIF, or ELSE part, and not known before the
+ -- ELSIF, or after the end of the IF statement.
+ --
+ -- The caller can use this result to determine the value (for the case of
+ -- N_Op_Eq), or to determine the result of some other test in other cases
+ -- (e.g. no access check required if N_Op_Ne Null).
+
+ function Get_Stream_Size (E : Entity_Id) return Uint;
+ -- Return the stream size value of the subtype E
+
+ function Has_Access_Constraint (E : Entity_Id) return Boolean;
+ -- Given object or type E, determine if a discriminant is of an access type
+
+ function Has_Following_Address_Clause (D : Node_Id) return Boolean;
+ -- D is the node for an object declaration. This function searches the
+ -- current declarative part to look for an address clause for the object
+ -- being declared, and returns True if one is found.
+
function Homonym_Number (Subp : Entity_Id) return Nat;
-- Here subp is the entity for a subprogram. This routine returns the
- -- homonym number used to disambiguate overloaded subprograms in the
- -- same scope (the number is used as part of constructed names to make
- -- sure that they are unique). The number is the ordinal position on
- -- the Homonym chain, counting only entries in the curren scope. If
- -- an entity is not overloaded, the returned number will be one.
+ -- homonym number used to disambiguate overloaded subprograms in the same
+ -- scope (the number is used as part of constructed names to make sure that
+ -- they are unique). The number is the ordinal position on the Homonym
+ -- chain, counting only entries in the current scope. If an entity is not
+ -- overloaded, the returned number will be one.
function Inside_Init_Proc return Boolean;
- -- Returns True if current scope is within an Init_Proc
+ -- Returns True if current scope is within an init proc
+
+ function In_Library_Level_Package_Body (Id : Entity_Id) return Boolean;
+ -- Given an arbitrary entity, determine whether it appears at the library
+ -- level of a package body.
function In_Unconditional_Context (Node : Node_Id) return Boolean;
- -- Node is the node for a statement or a component of a statement.
- -- This function deteermines if the statement appears in a context
- -- that is unconditionally executed, i.e. it is not within a loop
- -- or a conditional or a case statement etc.
-
- function Is_Ref_To_Bit_Packed_Array (P : Node_Id) return Boolean;
- -- Determine whether the node P is a reference to a bit packed
- -- array, i.e. whether the designated object is a component of
- -- a bit packed array, or a subcomponent of such a component.
- -- If so, then all subscripts in P are evaluated with a call
- -- to Force_Evaluation, and True is returned. Otherwise False
- -- is returned, and P is not affected.
-
- function Is_Ref_To_Bit_Packed_Slice (P : Node_Id) return Boolean;
- -- Determine whether the node P is a reference to a bit packed
- -- slice, i.e. whether the designated object is bit packed slice
- -- or a component of a bit packed slice. Return True if so.
+ -- Node is the node for a statement or a component of a statement. This
+ -- function determines if the statement appears in a context that is
+ -- unconditionally executed, i.e. it is not within a loop or a conditional
+ -- or a case statement etc.
+
+ function Is_All_Null_Statements (L : List_Id) return Boolean;
+ -- Return True if all the items of the list are N_Null_Statement nodes.
+ -- False otherwise. True for an empty list. It is an error to call this
+ -- routine with No_List as the argument.
+
+ function Is_Displacement_Of_Object_Or_Function_Result
+ (Obj_Id : Entity_Id) return Boolean;
+ -- Determine whether Obj_Id is a source entity that has been initialized by
+ -- either a controlled function call or the assignment of another source
+ -- object. In both cases the initialization expression is rewritten as a
+ -- class-wide conversion of Ada.Tags.Displace.
+
+ function Is_Finalizable_Transient
+ (Decl : Node_Id;
+ Rel_Node : Node_Id) return Boolean;
+ -- Determine whether declaration Decl denotes a controlled transient which
+ -- should be finalized. Rel_Node is the related context. Even though some
+ -- transient are controlled, they may act as renamings of other objects or
+ -- function calls.
+
+ function Is_Fully_Repped_Tagged_Type (T : Entity_Id) return Boolean;
+ -- Tests given type T, and returns True if T is a non-discriminated tagged
+ -- type which has a record representation clause that specifies the layout
+ -- of all the components, including recursively components in all parent
+ -- types. We exclude discriminated types for convenience, it is extremely
+ -- unlikely that the special processing associated with the use of this
+ -- routine is useful for the case of a discriminated type, and testing for
+ -- component overlap would be a pain.
+
+ function Is_Library_Level_Tagged_Type (Typ : Entity_Id) return Boolean;
+ -- Return True if Typ is a library level tagged type. Currently we use
+ -- this information to build statically allocated dispatch tables.
+
+ function Is_Non_BIP_Func_Call (Expr : Node_Id) return Boolean;
+ -- Determine whether node Expr denotes a non build-in-place function call
+
+ function Is_Possibly_Unaligned_Object (N : Node_Id) return Boolean;
+ -- Node N is an object reference. This function returns True if it is
+ -- possible that the object may not be aligned according to the normal
+ -- default alignment requirement for its type (e.g. if it appears in a
+ -- packed record, or as part of a component that has a component clause.)
+
+ function Is_Possibly_Unaligned_Slice (N : Node_Id) return Boolean;
+ -- Determine whether the node P is a slice of an array where the slice
+ -- result may cause alignment problems because it has an alignment that
+ -- is not compatible with the type. Return True if so.
+
+ function Is_Ref_To_Bit_Packed_Array (N : Node_Id) return Boolean;
+ -- Determine whether the node P is a reference to a bit packed array, i.e.
+ -- whether the designated object is a component of a bit packed array, or a
+ -- subcomponent of such a component. If so, then all subscripts in P are
+ -- evaluated with a call to Force_Evaluation, and True is returned.
+ -- Otherwise False is returned, and P is not affected.
+
+ function Is_Ref_To_Bit_Packed_Slice (N : Node_Id) return Boolean;
+ -- Determine whether the node P is a reference to a bit packed slice, i.e.
+ -- whether the designated object is bit packed slice or a component of a
+ -- bit packed slice. Return True if so.
+
+ function Is_Related_To_Func_Return (Id : Entity_Id) return Boolean;
+ -- Determine whether object Id is related to an expanded return statement.
+ -- The case concerned is "return Id.all;".
function Is_Renamed_Object (N : Node_Id) return Boolean;
- -- Returns True if the node N is a renamed object. An expression
- -- is considered to be a renamed object if either it is the Name
- -- of an object renaming declaration, or is the prefix of a name
- -- which is a renamed object. For example, in:
+ -- Returns True if the node N is a renamed object. An expression is
+ -- considered to be a renamed object if either it is the Name of an object
+ -- renaming declaration, or is the prefix of a name which is a renamed
+ -- object. For example, in:
--
-- x : r renames a (1 .. 2) (1);
--
- -- We consider that a (1 .. 2) is a renamed object since it is the
- -- prefix of the name in the renaming declaration.
+ -- We consider that a (1 .. 2) is a renamed object since it is the prefix
+ -- of the name in the renaming declaration.
+
+ function Is_Secondary_Stack_BIP_Func_Call (Expr : Node_Id) return Boolean;
+ -- Determine whether Expr denotes a build-in-place function which returns
+ -- its result on the secondary stack.
+
+ function Is_Tag_To_Class_Wide_Conversion
+ (Obj_Id : Entity_Id) return Boolean;
+ -- Determine whether object Obj_Id is the result of a tag-to-class-wide
+ -- type conversion.
function Is_Untagged_Derivation (T : Entity_Id) return Boolean;
-- Returns true if type T is not tagged and is a derived type,
-- or is a private type whose completion is such a type.
- procedure Kill_Dead_Code (N : Node_Id);
- -- N represents a node for a section of code that is known to be
- -- dead. The node is deleted, and any exception handler references
- -- and warning messages relating to this code are removed.
-
- procedure Kill_Dead_Code (L : List_Id);
+ function Is_Volatile_Reference (N : Node_Id) return Boolean;
+ -- Checks if the node N represents a volatile reference, which can be
+ -- either a direct reference to a variable treated as volatile, or an
+ -- indexed/selected component where the prefix is treated as volatile,
+ -- or has Volatile_Components set. A slice of a volatile variable is
+ -- also volatile.
+
+ function Is_VM_By_Copy_Actual (N : Node_Id) return Boolean;
+ -- Returns True if we are compiling on VM targets and N is a node that
+ -- requires pass-by-copy in these targets.
+
+ procedure Kill_Dead_Code (N : Node_Id; Warn : Boolean := False);
+ -- N represents a node for a section of code that is known to be dead. Any
+ -- exception handler references and warning messages relating to this code
+ -- are removed. If Warn is True, a warning will be output at the start of N
+ -- indicating the deletion of the code. Note that the tree for the deleted
+ -- code is left intact so that e.g. cross-reference data is still valid.
+
+ procedure Kill_Dead_Code (L : List_Id; Warn : Boolean := False);
-- Like the above procedure, but applies to every element in the given
- -- list. Each of the entries is removed from the list before killing it.
+ -- list. If Warn is True, a warning will be output at the start of N
+ -- indicating the deletion of the code.
function Known_Non_Negative (Opnd : Node_Id) return Boolean;
-- Given a node for a subexpression, determines if it represents a value
-- that cannot possibly be negative, and if so returns True. A value of
-- False means that it is not known if the value is positive or negative.
+ function Known_Non_Null (N : Node_Id) return Boolean;
+ -- Given a node N for a subexpression of an access type, determines if
+ -- this subexpression yields a value that is known at compile time to
+ -- be non-null and returns True if so. Returns False otherwise. It is
+ -- an error to call this function if N is not of an access type.
+
+ function Known_Null (N : Node_Id) return Boolean;
+ -- Given a node N for a subexpression of an access type, determines if this
+ -- subexpression yields a value that is known at compile time to be null
+ -- and returns True if so. Returns False otherwise. It is an error to call
+ -- this function if N is not of an access type.
+
+ function Make_Invariant_Call (Expr : Node_Id) return Node_Id;
+ -- Expr is an object of a type which Has_Invariants set (and which thus
+ -- also has an Invariant_Procedure set). If invariants are enabled, this
+ -- function returns a call to the Invariant procedure passing Expr as the
+ -- argument, and returns it unanalyzed. If invariants are not enabled,
+ -- returns a null statement.
+
+ function Make_Predicate_Call
+ (Typ : Entity_Id;
+ Expr : Node_Id;
+ Mem : Boolean := False) return Node_Id;
+ -- Typ is a type with Predicate_Function set. This routine builds a call to
+ -- this function passing Expr as the argument, and returns it unanalyzed.
+ -- If Mem is set True, this is the special call for the membership case,
+ -- and the function called is the Predicate_Function_M if present.
+
+ function Make_Predicate_Check
+ (Typ : Entity_Id;
+ Expr : Node_Id) return Node_Id;
+ -- Typ is a type with Predicate_Function set. This routine builds a Check
+ -- pragma whose first argument is Predicate, and the second argument is a
+ -- call to the this predicate function with Expr as the argument.
+
function Make_Subtype_From_Expr
(E : Node_Id;
- Unc_Typ : Entity_Id)
- return Node_Id;
+ Unc_Typ : Entity_Id) return Node_Id;
-- Returns a subtype indication corresponding to the actual type of an
-- expression E. Unc_Typ is an unconstrained array or record, or
-- a classwide type.
function May_Generate_Large_Temp (Typ : Entity_Id) return Boolean;
- -- Determines if the given type, Typ, may require a large temporary
- -- of the type that causes trouble if stack checking is enabled. The
- -- result is True only if stack checking is enabled and the size of
- -- the type is known at compile time and large, where large is defined
- -- hueristically by the body of this routine. The purpose of this
- -- routine is to help avoid generating troublesome temporaries that
- -- intefere with the stack checking mechanism.
+ -- Determines if the given type, Typ, may require a large temporary of the
+ -- kind that causes back-end trouble if stack checking is enabled. The
+ -- result is True only the size of the type is known at compile time and
+ -- large, where large is defined heuristically by the body of this routine.
+ -- The purpose of this routine is to help avoid generating troublesome
+ -- temporaries that interfere with stack checking mechanism. Note that the
+ -- caller has to check whether stack checking is actually enabled in order
+ -- to guide the expansion (typically of a function call).
+
+ function Needs_Constant_Address
+ (Decl : Node_Id;
+ Typ : Entity_Id) return Boolean;
+ -- Check whether the expression in an address clause is restricted to
+ -- consist of constants, when the object has a non-trivial initialization
+ -- or is controlled.
+
+ function Needs_Finalization (T : Entity_Id) return Boolean;
+ -- True if type T is controlled, or has controlled subcomponents. Also
+ -- True if T is a class-wide type, because some type extension might add
+ -- controlled subcomponents, except that if pragma Restrictions
+ -- (No_Finalization) applies, this is False for class-wide types.
+
+ function Non_Limited_Designated_Type (T : Entity_Id) return Entity_Id;
+ -- An anonymous access type may designate a limited view. Check whether
+ -- non-limited view is available during expansion, to examine components
+ -- or other characteristics of the full type.
+
+ function OK_To_Do_Constant_Replacement (E : Entity_Id) return Boolean;
+ -- This function is used when testing whether or not to replace a reference
+ -- to entity E by a known constant value. Such replacement must be done
+ -- only in a scope known to be safe for such replacements. In particular,
+ -- if we are within a subprogram and the entity E is declared outside the
+ -- subprogram then we cannot do the replacement, since we do not attempt to
+ -- trace subprogram call flow. It is also unsafe to replace statically
+ -- allocated values (since they can be modified outside the scope), and we
+ -- also inhibit replacement of Volatile or aliased objects since their
+ -- address might be captured in a way we do not detect. A value of True is
+ -- returned only if the replacement is safe.
+
+ function Possible_Bit_Aligned_Component (N : Node_Id) return Boolean;
+ -- This function is used during processing the assignment of a record or
+ -- indexed component. The argument N is either the left hand or right hand
+ -- side of an assignment, and this function determines if there is a record
+ -- component reference where the record may be bit aligned in a manner that
+ -- causes trouble for the back end (see Component_May_Be_Bit_Aligned for
+ -- further details).
+
+ procedure Process_Statements_For_Controlled_Objects (N : Node_Id);
+ -- N is a node which contains a non-handled statement list. Inspect the
+ -- statements looking for declarations of controlled objects. If at least
+ -- one such object is found, wrap the statement list in a block.
+
+ function Remove_Init_Call
+ (Var : Entity_Id;
+ Rep_Clause : Node_Id) return Node_Id;
+ -- Look for init_proc call or aggregate initialization statements for
+ -- variable Var, either among declarations between that of Var and a
+ -- subsequent Rep_Clause applying to Var, or in the list of freeze actions
+ -- associated with Var, and if found, remove and return that call node.
procedure Remove_Side_Effects
(Exp : Node_Id;
Name_Req : Boolean := False;
Variable_Ref : Boolean := False);
- -- Given the node for a subexpression, this function replaces the node
- -- if necessary by an equivalent subexpression that is guaranteed to be
- -- side effect free. This is done by extracting any actions that could
- -- cause side effects, and inserting them using Insert_Actions into the
- -- tree to which Exp is attached. Exp must be analayzed and resolved
- -- before the call and is analyzed and resolved on return. The Name_Req
- -- may only be set to True if Exp has the form of a name, and the
- -- effect is to guarantee that any replacement maintains the form of a
- -- name. If Variable_Ref is set to TRUE, a variable is considered as a
- -- side effect (used in implementing Force_Evaluation). Note: after a
- -- call to Remove_Side_Effects, it is safe to use a call to
- -- New_Copy_Tree to obtain a copy of the resulting expression.
+ -- Given the node for a subexpression, this function replaces the node if
+ -- necessary by an equivalent subexpression that is guaranteed to be side
+ -- effect free. This is done by extracting any actions that could cause
+ -- side effects, and inserting them using Insert_Actions into the tree to
+ -- which Exp is attached. Exp must be analyzed and resolved before the call
+ -- and is analyzed and resolved on return. The Name_Req may only be set to
+ -- True if Exp has the form of a name, and the effect is to guarantee that
+ -- any replacement maintains the form of name. If Variable_Ref is set to
+ -- TRUE, a variable is considered as side effect (used in implementing
+ -- Force_Evaluation). Note: after call to Remove_Side_Effects, it is safe
+ -- to call New_Copy_Tree to obtain a copy of the resulting expression.
+
+ function Represented_As_Scalar (T : Entity_Id) return Boolean;
+ -- Returns True iff the implementation of this type in code generation
+ -- terms is scalar. This is true for scalars in the Ada sense, and for
+ -- packed arrays which are represented by a scalar (modular) type.
+
+ function Requires_Cleanup_Actions
+ (N : Node_Id;
+ Lib_Level : Boolean) return Boolean;
+ -- Given a node N, determine whether its declarative and/or statement list
+ -- contains one of the following:
+ --
+ -- 1) controlled objects
+ -- 2) library-level tagged types
+ --
+ -- These cases require special actions on scope exit. The flag Lib_Level
+ -- is set True if the construct is at library level, and False otherwise.
function Safe_Unchecked_Type_Conversion (Exp : Node_Id) return Boolean;
- -- Given the node for an N_Unchecked_Type_Conversion, return True
- -- if this is an unchecked conversion that Gigi can handle directly.
- -- Otherwise return False if it is one for which the front end must
- -- provide a temporary. Note that the node need not be analyzed, and
- -- thus the Etype field may not be set, but in that case it must be
- -- the case that the Subtype_Mark field of the node is set/analyzed.
+ -- Given the node for an N_Unchecked_Type_Conversion, return True if this
+ -- is an unchecked conversion that Gigi can handle directly. Otherwise
+ -- return False if it is one for which the front end must provide a
+ -- temporary. Note that the node need not be analyzed, and thus the Etype
+ -- field may not be set, but in that case it must be the case that the
+ -- Subtype_Mark field of the node is set/analyzed.
+
+ procedure Set_Current_Value_Condition (Cnode : Node_Id);
+ -- Cnode is N_If_Statement, N_Elsif_Part, or N_Iteration_Scheme (the latter
+ -- when a WHILE condition is present). This call checks whether Condition
+ -- (Cnode) has embedded expressions of a form that should result in setting
+ -- the Current_Value field of one or more entities, and if so sets these
+ -- fields to point to Cnode.
procedure Set_Elaboration_Flag (N : Node_Id; Spec_Id : Entity_Id);
- -- N is the node for a subprogram or generic body, and Spec_Id
- -- is the entity for the corresponding spec. If an elaboration
- -- entity is defined, then this procedure generates an assignment
- -- statement to set it True, immediately after the body is elaborated.
- -- However, no assignment is generated in the case of library level
- -- procedures, since the setting of the flag in this case is generated
- -- in the binder. We do that so that we can detect cases where this is
- -- the only elaboration action that is required.
+ -- N is the node for a subprogram or generic body, and Spec_Id is the
+ -- entity for the corresponding spec. If an elaboration entity is defined,
+ -- then this procedure generates an assignment statement to set it True,
+ -- immediately after the body is elaborated. However, no assignment is
+ -- generated in the case of library level procedures, since the setting of
+ -- the flag in this case is generated in the binder. We do that so that we
+ -- can detect cases where this is the only elaboration action that is
+ -- required.
+
+ procedure Set_Renamed_Subprogram (N : Node_Id; E : Entity_Id);
+ -- N is an node which is an entity name that represents the name of a
+ -- renamed subprogram. The node is rewritten to be an identifier that
+ -- refers directly to the renamed subprogram, given by entity E.
+
+ procedure Silly_Boolean_Array_Not_Test (N : Node_Id; T : Entity_Id);
+ -- N is the node for a boolean array NOT operation, and T is the type of
+ -- the array. This routine deals with the silly case where the subtype of
+ -- the boolean array is False..False or True..True, where it is required
+ -- that a Constraint_Error exception be raised (RM 4.5.6(6)).
+
+ procedure Silly_Boolean_Array_Xor_Test (N : Node_Id; T : Entity_Id);
+ -- N is the node for a boolean array XOR operation, and T is the type of
+ -- the array. This routine deals with the silly case where the subtype of
+ -- the boolean array is True..True, where a raise of a Constraint_Error
+ -- exception is required (RM 4.5.6(6)).
function Target_Has_Fixed_Ops
(Left_Typ : Entity_Id;
Right_Typ : Entity_Id;
- Result_Typ : Entity_Id)
- return Boolean;
+ Result_Typ : Entity_Id) return Boolean;
-- Returns True if and only if the target machine has direct support
-- for fixed-by-fixed multiplications and divisions for the given
-- operand and result types. This is called in package Exp_Fixd to
-- determine whether to expand such operations.
+ function Type_May_Have_Bit_Aligned_Components
+ (Typ : Entity_Id) return Boolean;
+ -- Determines if Typ is a composite type that has within it (looking down
+ -- recursively at any subcomponents), a record type which has component
+ -- that may be bit aligned (see Possible_Bit_Aligned_Component). The result
+ -- is conservative, in that a result of False is decisive. A result of True
+ -- means that such a component may or may not be present.
+
+ function Within_Case_Or_If_Expression (N : Node_Id) return Boolean;
+ -- Determine whether arbitrary node N is within a case or an if expression
+
procedure Wrap_Cleanup_Procedure (N : Node_Id);
- -- Given an N_Subprogram_Body node, this procedure adds an Abort_Defer
- -- call at the start of the statement sequence, and an Abort_Undefer call
- -- at the end of the statement sequence. All cleanup routines (i.e. those
- -- that are called from "at end" handlers) must defer abort on entry and
- -- undefer abort on exit. Note that it is assumed that the code for the
- -- procedure does not contain any return statements which would allow the
- -- flow of control to escape doing the undefer call.
+ -- Given an N_Subprogram_Body node, this procedure adds an Abort_Defer call
+ -- at the start of the statement sequence, and an Abort_Undefer call at the
+ -- end of the statement sequence. All cleanup routines (i.e. those that are
+ -- called from "at end" handlers) must defer abort on entry and undefer
+ -- abort on exit. Note that it is assumed that the code for the procedure
+ -- does not contain any return statements which would allow the flow of
+ -- control to escape doing the undefer call.
private
- pragma Inline (Force_Evaluation);
pragma Inline (Duplicate_Subexpr);
-
+ pragma Inline (Force_Evaluation);
+ pragma Inline (Is_Library_Level_Tagged_Type);
end Exp_Util;
OSDN Git Service
