X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Fada%2Fexp_util.ads;h=67982c2c96884aff283a1dc442f8459df79328ff;hb=53fc0f2949929d2361f57599cb39c761d6150f01;hp=da3b1335b7d311542f7d2dc2031581203846af33;hpb=ba40b4affc67004522f70a179d3667fbedf60167;p=pf3gnuchains%2Fgcc-fork.git diff --git a/gcc/ada/exp_util.ads b/gcc/ada/exp_util.ads index da3b1335b7d..67982c2c968 100644 --- a/gcc/ada/exp_util.ads +++ b/gcc/ada/exp_util.ads @@ -6,18 +6,17 @@ -- -- -- S p e c -- -- -- --- Copyright (C) 1992-2005 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. -- -- Extensive contributions were provided by Ada Core Technologies Inc. -- @@ -27,9 +26,11 @@ -- Package containing utility procedures used throughout the expander 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 @@ -71,8 +72,11 @@ 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, @@ -117,6 +121,13 @@ package Exp_Util is -- 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); @@ -135,57 +146,79 @@ package Exp_Util is -- 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. @@ -194,62 +227,73 @@ package Exp_Util is -- 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). + -- 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. + -- 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. + -- 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's harmless, so it is easier to do it in - -- all cases, rather than conditionalize it in GNAT 5 or beyond. + -- 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 @@ -258,20 +302,20 @@ package Exp_Util is 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_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 a - -- name (e.g. the prefix of an attribute reference). + -- 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 @@ -289,13 +333,13 @@ package Exp_Util is 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. + -- 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 @@ -305,19 +349,29 @@ package Exp_Util is -- 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_Or_Else 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; @@ -328,11 +382,27 @@ package Exp_Util is -- 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. If T is a class wide type, then the reference is - -- to an operation of the corresponding root type. + -- 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; @@ -342,18 +412,37 @@ package Exp_Util is -- 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 + -- 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. @@ -362,109 +451,176 @@ package Exp_Util is (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 (while statement). Such a setting only occurs - -- if the condition of an IF or ELSIF is of the form X op Y, where X - -- is the variable in question, Y is a compile-time known value, and - -- op is one of the six possible relational operators. + -- 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. -- - -- 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 Cond and Val are set for the - -- empty case (N_Empty and 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 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. + -- 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). + -- 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 + 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. + -- 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_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. + -- 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_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_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_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_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 @@ -477,6 +633,35 @@ package Exp_Util is -- 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; @@ -485,54 +670,140 @@ package Exp_Util is -- 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 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). + -- 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 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 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 call 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; @@ -545,23 +816,26 @@ package Exp_Util is 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 a - -- 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. + -- 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;