1 ------------------------------------------------------------------------------
3 -- GNAT COMPILER COMPONENTS --
9 -- Copyright (C) 1992-2011, Free Software Foundation, Inc. --
11 -- GNAT is free software; you can redistribute it and/or modify it under --
12 -- terms of the GNU General Public License as published by the Free Soft- --
13 -- ware Foundation; either version 3, or (at your option) any later ver- --
14 -- sion. GNAT is distributed in the hope that it will be useful, but WITH- --
15 -- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY --
16 -- or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License --
17 -- for more details. You should have received a copy of the GNU General --
18 -- Public License distributed with GNAT; see file COPYING3. If not, go to --
19 -- http://www.gnu.org/licenses for a complete copy of the license. --
21 -- GNAT was originally developed by the GNAT team at New York University. --
22 -- Extensive contributions were provided by Ada Core Technologies Inc. --
24 ------------------------------------------------------------------------------
26 -- Package containing utility procedures used throughout the expander
28 with Exp_Tss; use Exp_Tss;
29 with Namet; use Namet;
30 with Rtsfind; use Rtsfind;
31 with Sinfo; use Sinfo;
32 with Types; use Types;
33 with Uintp; use Uintp;
37 -----------------------------------------------
38 -- Handling of Actions Associated with Nodes --
39 -----------------------------------------------
41 -- The evaluation of certain expression nodes involves the elaboration
42 -- of associated types and other declarations, and the execution of
43 -- statement sequences. Expansion routines generating such actions must
44 -- find an appropriate place in the tree to hang the actions so that
45 -- they will be evaluated at the appropriate point.
47 -- Some cases are simple:
49 -- For an expression occurring in a simple statement that is in a list
50 -- of statements, the actions are simply inserted into the list before
51 -- the associated statement.
53 -- For an expression occurring in a declaration (declarations always
54 -- appear in lists), the actions are similarly inserted into the list
55 -- just before the associated declaration.
57 -- The following special cases arise:
59 -- For actions associated with the right operand of a short circuit
60 -- form, the actions are first stored in the short circuit form node
61 -- in the Actions field. The expansion of these forms subsequently
62 -- expands the short circuit forms into if statements which can then
63 -- be moved as described above.
65 -- For actions appearing in the Condition expression of a while loop,
66 -- or an elsif clause, the actions are similarly temporarily stored in
67 -- in the node (N_Elsif_Part or N_Iteration_Scheme) associated with
68 -- the expression using the Condition_Actions field. Subsequently, the
69 -- expansion of these nodes rewrites the control structures involved to
70 -- reposition the actions in normal statement sequence.
72 -- For actions appearing in the then or else expression of a conditional
73 -- expression, these actions are similarly placed in the node, using the
74 -- Then_Actions or Else_Actions field as appropriate. Once again the
75 -- expansion of the N_Conditional_Expression node rewrites the node so
76 -- that the actions can be normally positioned.
78 -- Basically what we do is to climb up to the tree looking for the
79 -- proper insertion point, as described by one of the above cases,
80 -- and then insert the appropriate action or actions.
82 -- Note if more than one insert call is made specifying the same
83 -- Assoc_Node, then the actions are elaborated in the order of the
84 -- calls, and this guarantee is preserved for the special cases above.
86 procedure Insert_Action
87 (Assoc_Node : Node_Id;
88 Ins_Action : Node_Id);
89 -- Insert the action Ins_Action at the appropriate point as described
90 -- above. The action is analyzed using the default checks after it is
91 -- inserted. Assoc_Node is the node with which the action is associated.
93 procedure Insert_Action
94 (Assoc_Node : Node_Id;
97 -- Insert the action Ins_Action at the appropriate point as described
98 -- above. The action is analyzed using the default checks as modified
99 -- by the given Suppress argument after it is inserted. Assoc_Node is
100 -- the node with which the action is associated.
102 procedure Insert_Actions
103 (Assoc_Node : Node_Id;
104 Ins_Actions : List_Id);
105 -- Insert the list of action Ins_Actions at the appropriate point as
106 -- described above. The actions are analyzed using the default checks
107 -- after they are inserted. Assoc_Node is the node with which the actions
108 -- are associated. Ins_Actions may be No_List, in which case the call has
111 procedure Insert_Actions
112 (Assoc_Node : Node_Id;
113 Ins_Actions : List_Id;
114 Suppress : Check_Id);
115 -- Insert the list of action Ins_Actions at the appropriate point as
116 -- described above. The actions are analyzed using the default checks
117 -- as modified by the given Suppress argument after they are inserted.
118 -- Assoc_Node is the node with which the actions are associated.
119 -- Ins_Actions may be No_List, in which case the call has no effect.
121 procedure Insert_Action_After
122 (Assoc_Node : Node_Id;
123 Ins_Action : Node_Id);
124 -- Assoc_Node must be a node in a list. Same as Insert_Action but the
125 -- action will be inserted after N in a manner that is compatible with
126 -- the transient scope mechanism.
128 procedure Insert_Actions_After
129 (Assoc_Node : Node_Id;
130 Ins_Actions : List_Id);
131 -- Assoc_Node must be a node in a list. Same as Insert_Actions but
132 -- actions will be inserted after N in a manner that is compatible with
133 -- the transient scope mechanism. This procedure must be used instead
134 -- of Insert_List_After if Assoc_Node may be in a transient scope.
136 -- Implementation limitation: Assoc_Node must be a statement. We can
137 -- generalize to expressions if there is a need but this is tricky to
138 -- implement because of short-circuits (among other things).???
140 procedure Insert_Library_Level_Action (N : Node_Id);
141 -- This procedure inserts and analyzes the node N as an action at the
142 -- library level for the current unit (i.e. it is attached to the
143 -- Actions field of the N_Compilation_Aux node for the main unit).
145 procedure Insert_Library_Level_Actions (L : List_Id);
146 -- Similar, but inserts a list of actions
148 -----------------------
149 -- Other Subprograms --
150 -----------------------
152 procedure Adjust_Condition (N : Node_Id);
153 -- The node N is an expression whose root-type is Boolean, and which
154 -- represents a boolean value used as a condition (i.e. a True/False
155 -- value). This routine handles the case of C and Fortran convention
156 -- boolean types, which have zero/non-zero semantics rather than the normal
157 -- 0/1 semantics, and also the case of an enumeration rep clause that
158 -- specifies a non-standard representation. On return, node N always has
159 -- the type Standard.Boolean, with a value that is a standard Boolean
160 -- values of 0/1 for False/True. This procedure is used in two situations.
161 -- First, the processing for a condition field always calls
162 -- Adjust_Condition, so that the boolean value presented to the backend is
163 -- a standard value. Second, for the code for boolean operations such as
164 -- AND, Adjust_Condition is called on both operands, and then the operation
165 -- is done in the domain of Standard_Boolean, then Adjust_Result_Type is
166 -- called on the result to possibly reset the original type. This procedure
167 -- also takes care of validity checking if Validity_Checks = Tests.
169 procedure Adjust_Result_Type (N : Node_Id; T : Entity_Id);
170 -- The processing of boolean operations like AND uses the procedure
171 -- Adjust_Condition so that it can operate on Standard.Boolean, which is
172 -- the only boolean type on which the backend needs to be able to implement
173 -- such operators. This means that the result is also of type
174 -- Standard.Boolean. In general the type must be reset back to the original
175 -- type to get proper semantics, and that is the purpose of this procedure.
176 -- N is the node (of type Standard.Boolean), and T is the desired type. As
177 -- an optimization, this procedure leaves the type as Standard.Boolean in
178 -- contexts where this is permissible (in particular for Condition fields,
179 -- and for operands of other logical operations higher up the tree). The
180 -- call to this procedure is completely ignored if the argument N is not of
183 procedure Append_Freeze_Action (T : Entity_Id; N : Node_Id);
184 -- Add a new freeze action for the given type. The freeze action is
185 -- attached to the freeze node for the type. Actions will be elaborated in
186 -- the order in which they are added. Note that the added node is not
187 -- analyzed. The analyze call is found in Exp_Ch13.Expand_N_Freeze_Entity.
189 procedure Append_Freeze_Actions (T : Entity_Id; L : List_Id);
190 -- Adds the given list of freeze actions (declarations or statements) for
191 -- the given type. The freeze actions are attached to the freeze node for
192 -- the type. Actions will be elaborated in the order in which they are
193 -- added, and the actions within the list will be elaborated in list order.
194 -- Note that the added nodes are not analyzed. The analyze call is found in
195 -- Exp_Ch13.Expand_N_Freeze_Entity.
197 procedure Build_Allocate_Deallocate_Proc
199 Is_Allocate : Boolean);
200 -- Create a custom Allocate/Deallocate to be associated with an allocation
201 -- or deallocation of a controlled or class-wide object. In the case of
202 -- allocation, N is the declaration of the temporary variable which
203 -- represents the expression of the original allocator node, otherwise N
204 -- must be a free statement. If flag Is_Allocate is set, the generated
205 -- routine is allocate, deallocate otherwise. The generated routine is:
207 -- F : constant Boolean := -- CW case
208 -- Ada.Tags.Needs_Finalization (<Expr>'Tag); -- CW case
210 -- procedure Allocate / Deallocate
211 -- (P : Storage_Pool;
212 -- A : [out] Address; -- out is present for Allocate
213 -- S : Storage_Count;
214 -- L : Storage_Count)
217 -- Allocate / Deallocate
218 -- (<Ptr_Typ collection>, A, S, L, [Needs_Header => F]);
221 function Build_Runtime_Call (Loc : Source_Ptr; RE : RE_Id) return Node_Id;
222 -- Build an N_Procedure_Call_Statement calling the given runtime entity.
223 -- The call has no parameters. The first argument provides the location
224 -- information for the tree and for error messages. The call node is not
225 -- analyzed on return, the caller is responsible for analyzing it.
227 function Build_Task_Image_Decls
231 In_Init_Proc : Boolean := False) return List_Id;
232 -- Build declaration for a variable that holds an identifying string to be
233 -- used as a task name. Id_Ref is an identifier if the task is a variable,
234 -- and a selected or indexed component if the task is component of an
235 -- object. If it is an indexed component, A_Type is the corresponding array
236 -- type. Its index types are used to build the string as an image of the
237 -- index values. For composite types, the result includes two declarations:
238 -- one for a generated function that computes the image without using
239 -- concatenation, and one for the variable that holds the result.
241 -- If In_Init_Proc is true, the call is part of the initialization of
242 -- a component of a composite type, and the enclosing initialization
243 -- procedure must be flagged as using the secondary stack. If In_Init_Proc
244 -- is false, the call is for a stand-alone object, and the generated
245 -- function itself must do its own cleanups.
247 function Component_May_Be_Bit_Aligned (Comp : Entity_Id) return Boolean;
248 -- This function is in charge of detecting record components that may
249 -- cause trouble in the back end if an attempt is made to assign the
250 -- component. The back end can handle such assignments with no problem if
251 -- the components involved are small (64-bits or less) records or scalar
252 -- items (including bit-packed arrays represented with modular types) or
253 -- are both aligned on a byte boundary (starting on a byte boundary, and
254 -- occupying an integral number of bytes).
256 -- However, problems arise for records larger than 64 bits, or for arrays
257 -- (other than bit-packed arrays represented with a modular type) if the
258 -- component starts on a non-byte boundary, or does not occupy an integral
259 -- number of bytes (i.e. there are some bits possibly shared with fields
260 -- at the start or beginning of the component). The back end cannot handle
261 -- loading and storing such components in a single operation.
263 -- This function is used to detect the troublesome situation. it is
264 -- conservative in the sense that it produces True unless it knows for
265 -- sure that the component is safe (as outlined in the first paragraph
266 -- above). The code generation for record and array assignment checks for
267 -- trouble using this function, and if so the assignment is generated
268 -- component-wise, which the back end is required to handle correctly.
270 -- Note that in GNAT 3, the back end will reject such components anyway,
271 -- so the hard work in checking for this case is wasted in GNAT 3, but
272 -- it is harmless, so it is easier to do it in all cases, rather than
273 -- conditionalize it in GNAT 5 or beyond.
275 procedure Convert_To_Actual_Subtype (Exp : Node_Id);
276 -- The Etype of an expression is the nominal type of the expression,
277 -- not the actual subtype. Often these are the same, but not always.
278 -- For example, a reference to a formal of unconstrained type has the
279 -- unconstrained type as its Etype, but the actual subtype is obtained by
280 -- applying the actual bounds. This routine is given an expression, Exp,
281 -- and (if necessary), replaces it using Rewrite, with a conversion to
282 -- the actual subtype, building the actual subtype if necessary. If the
283 -- expression is already of the requested type, then it is unchanged.
285 function Corresponding_Runtime_Package (Typ : Entity_Id) return RTU_Id;
286 -- Return the id of the runtime package that will provide support for
287 -- concurrent type Typ. Currently only protected types are supported,
288 -- and the returned value is one of the following:
289 -- System_Tasking_Protected_Objects
290 -- System_Tasking_Protected_Objects_Entries
291 -- System_Tasking_Protected_Objects_Single_Entry
293 function Current_Sem_Unit_Declarations return List_Id;
294 -- Return the place where it is fine to insert declarations for the
295 -- current semantic unit. If the unit is a package body, return the
296 -- visible declarations of the corresponding spec. For RCI stubs, this
297 -- is necessary because the point at which they are generated may not
298 -- be the earliest point at which they are used.
300 function Duplicate_Subexpr
302 Name_Req : Boolean := False) return Node_Id;
303 -- Given the node for a subexpression, this function makes a logical copy
304 -- of the subexpression, and returns it. This is intended for use when the
305 -- expansion of an expression needs to repeat part of it. For example,
306 -- replacing a**2 by a*a requires two references to a which may be a
307 -- complex subexpression. Duplicate_Subexpr guarantees not to duplicate
308 -- side effects. If necessary, it generates actions to save the expression
309 -- value in a temporary, inserting these actions into the tree using
310 -- Insert_Actions with Exp as the insertion location. The original
311 -- expression and the returned result then become references to this saved
312 -- value. Exp must be analyzed on entry. On return, Exp is analyzed, but
313 -- the caller is responsible for analyzing the returned copy after it is
314 -- attached to the tree. The Name_Req flag is set to ensure that the result
315 -- is suitable for use in a context requiring name (e.g. the prefix of an
316 -- attribute reference).
318 -- Note that if there are any run time checks in Exp, these same checks
319 -- will be duplicated in the returned duplicated expression. The two
320 -- following functions allow this behavior to be modified.
322 function Duplicate_Subexpr_No_Checks
324 Name_Req : Boolean := False) return Node_Id;
325 -- Identical in effect to Duplicate_Subexpr, except that Remove_Checks
326 -- is called on the result, so that the duplicated expression does not
327 -- include checks. This is appropriate for use when Exp, the original
328 -- expression is unconditionally elaborated before the duplicated
329 -- expression, so that there is no need to repeat any checks.
331 function Duplicate_Subexpr_Move_Checks
333 Name_Req : Boolean := False) return Node_Id;
334 -- Identical in effect to Duplicate_Subexpr, except that Remove_Checks is
335 -- called on Exp after the duplication is complete, so that the original
336 -- expression does not include checks. In this case the result returned
337 -- (the duplicated expression) will retain the original checks. This is
338 -- appropriate for use when the duplicated expression is sure to be
339 -- elaborated before the original expression Exp, so that there is no need
340 -- to repeat the checks.
342 procedure Ensure_Defined (Typ : Entity_Id; N : Node_Id);
343 -- This procedure ensures that type referenced by Typ is defined. For the
344 -- case of a type other than an Itype, nothing needs to be done, since
345 -- all such types have declaration nodes. For Itypes, an N_Itype_Reference
346 -- node is generated and inserted at the given node N. This is typically
347 -- used to ensure that an Itype is properly defined outside a conditional
348 -- construct when it is referenced in more than one branch.
350 function Entry_Names_OK return Boolean;
351 -- Determine whether it is appropriate to dynamically allocate strings
352 -- which represent entry [family member] names. These strings are created
353 -- by the compiler and used by GDB.
355 procedure Evolve_And_Then (Cond : in out Node_Id; Cond1 : Node_Id);
356 -- Rewrites Cond with the expression: Cond and then Cond1. If Cond is
357 -- Empty, then simply returns Cond1 (this allows the use of Empty to
358 -- initialize a series of checks evolved by this routine, with a final
359 -- result of Empty indicating that no checks were required). The Sloc field
360 -- of the constructed N_And_Then node is copied from Cond1.
362 procedure Evolve_Or_Else (Cond : in out Node_Id; Cond1 : Node_Id);
363 -- Rewrites Cond with the expression: Cond or else Cond1. If Cond is Empty,
364 -- then simply returns Cond1 (this allows the use of Empty to initialize a
365 -- series of checks evolved by this routine, with a final result of Empty
366 -- indicating that no checks were required). The Sloc field of the
367 -- constructed N_Or_Else node is copied from Cond1.
369 procedure Expand_Subtype_From_Expr
371 Unc_Type : Entity_Id;
372 Subtype_Indic : Node_Id;
374 -- Build a constrained subtype from the initial value in object
375 -- declarations and/or allocations when the type is indefinite (including
378 function Find_Init_Call
380 Rep_Clause : Node_Id) return Node_Id;
381 -- Look for init_proc call for variable Var, either among declarations
382 -- between that of Var and a subsequent Rep_Clause applying to Var, or
383 -- in the list of freeze actions associated with Var, and if found, return
386 function Find_Interface_ADT
388 Iface : Entity_Id) return Elmt_Id;
389 -- Ada 2005 (AI-251): Given a type T implementing the interface Iface,
390 -- return the element of Access_Disp_Table containing the tag of the
393 function Find_Interface_Tag
395 Iface : Entity_Id) return Entity_Id;
396 -- Ada 2005 (AI-251): Given a type T implementing the interface Iface,
397 -- return the record component containing the tag of Iface.
399 function Find_Prim_Op (T : Entity_Id; Name : Name_Id) return Entity_Id;
400 -- Find the first primitive operation of type T whose name is 'Name'.
401 -- This function allows the use of a primitive operation which is not
402 -- directly visible. If T is a class wide type, then the reference is
403 -- to an operation of the corresponding root type. Raises Program_Error
404 -- exception if no primitive operation is found. This is normally an
405 -- internal error, but in some cases is an expected consequence of
406 -- illegalities elsewhere.
408 function Find_Prim_Op
410 Name : TSS_Name_Type) return Entity_Id;
411 -- Find the first primitive operation of type T whose name has the form
412 -- indicated by the name parameter (i.e. is a type support subprogram
413 -- with the indicated suffix). This function allows use of a primitive
414 -- operation which is not directly visible. If T is a class wide type,
415 -- then the reference is to an operation of the corresponding root type.
416 -- Raises Program_Error exception if no primitive operation is found.
417 -- This is normally an internal error, but in some cases is an expected
418 -- consequence of illegalities elsewhere.
420 function Find_Protection_Object (Scop : Entity_Id) return Entity_Id;
421 -- Traverse the scope stack starting from Scop and look for an entry,
422 -- entry family, or a subprogram that has a Protection_Object and return
423 -- it. Raises Program_Error if no such entity is found since the context
424 -- in which this routine is invoked should always have a protection
427 function Find_Protection_Type (Conc_Typ : Entity_Id) return Entity_Id;
428 -- Given a protected type or its corresponding record, find the type of
431 procedure Force_Evaluation
433 Name_Req : Boolean := False);
434 -- Force the evaluation of the expression right away. Similar behavior
435 -- to Remove_Side_Effects when Variable_Ref is set to TRUE. That is to
436 -- say, it removes the side-effects and captures the values of the
437 -- variables. Remove_Side_Effects guarantees that multiple evaluations
438 -- of the same expression won't generate multiple side effects, whereas
439 -- Force_Evaluation further guarantees that all evaluations will yield
442 function Fully_Qualified_Name_String (E : Entity_Id) return String_Id;
443 -- Generates the string literal corresponding to the fully qualified name
444 -- of entity E with an ASCII.NUL appended at the end of the name.
446 procedure Generate_Poll_Call (N : Node_Id);
447 -- If polling is active, then a call to the Poll routine is built,
448 -- and then inserted before the given node N and analyzed.
450 procedure Get_Current_Value_Condition
454 -- This routine processes the Current_Value field of the variable Var. If
455 -- the Current_Value field is null or if it represents a known value, then
456 -- on return Cond is set to N_Empty, and Val is set to Empty.
458 -- The other case is when Current_Value points to an N_If_Statement or an
459 -- N_Elsif_Part or a N_Iteration_Scheme node (see description in Einfo for
460 -- exact details). In this case, Get_Current_Condition digs out the
461 -- condition, and then checks if the condition is known false, known true,
462 -- or not known at all. In the first two cases, Get_Current_Condition will
463 -- return with Op set to the appropriate conditional operator (inverted if
464 -- the condition is known false), and Val set to the constant value. If the
465 -- condition is not known, then Op and Val are set for the empty case
466 -- (N_Empty and Empty).
468 -- The check for whether the condition is true/false unknown depends
471 -- For an IF, the condition is known true in the THEN part, known false
472 -- in any ELSIF or ELSE part, and not known outside the IF statement in
475 -- For an ELSIF, the condition is known true in the ELSIF part, known
476 -- FALSE in any subsequent ELSIF, or ELSE part, and not known before the
477 -- ELSIF, or after the end of the IF statement.
479 -- The caller can use this result to determine the value (for the case of
480 -- N_Op_Eq), or to determine the result of some other test in other cases
481 -- (e.g. no access check required if N_Op_Ne Null).
483 function Get_Stream_Size (E : Entity_Id) return Uint;
484 -- Return the stream size value of the subtype E
486 function Has_Access_Constraint (E : Entity_Id) return Boolean;
487 -- Given object or type E, determine if a discriminant is of an access type
489 function Has_Following_Address_Clause (D : Node_Id) return Boolean;
490 -- D is the node for an object declaration. This function searches the
491 -- current declarative part to look for an address clause for the object
492 -- being declared, and returns True if one is found.
494 function Homonym_Number (Subp : Entity_Id) return Nat;
495 -- Here subp is the entity for a subprogram. This routine returns the
496 -- homonym number used to disambiguate overloaded subprograms in the same
497 -- scope (the number is used as part of constructed names to make sure that
498 -- they are unique). The number is the ordinal position on the Homonym
499 -- chain, counting only entries in the current scope. If an entity is not
500 -- overloaded, the returned number will be one.
502 function Inside_Init_Proc return Boolean;
503 -- Returns True if current scope is within an init proc
505 function In_Library_Level_Package_Body (Id : Entity_Id) return Boolean;
506 -- Given an arbitrary entity, determine whether it appears at the library
507 -- level of a package body.
509 function In_Unconditional_Context (Node : Node_Id) return Boolean;
510 -- Node is the node for a statement or a component of a statement. This
511 -- function determines if the statement appears in a context that is
512 -- unconditionally executed, i.e. it is not within a loop or a conditional
513 -- or a case statement etc.
515 function Is_All_Null_Statements (L : List_Id) return Boolean;
516 -- Return True if all the items of the list are N_Null_Statement nodes.
517 -- False otherwise. True for an empty list. It is an error to call this
518 -- routine with No_List as the argument.
520 function Is_Finalizable_Transient
522 Rel_Node : Node_Id) return Boolean;
523 -- Determine whether declaration Decl denotes a controlled transient which
524 -- should be finalized. Rel_Node is the related context. Even though some
525 -- transient are controlled, they may act as renamings of other objects or
528 function Is_Fully_Repped_Tagged_Type (T : Entity_Id) return Boolean;
529 -- Tests given type T, and returns True if T is a non-discriminated tagged
530 -- type which has a record representation clause that specifies the layout
531 -- of all the components, including recursively components in all parent
532 -- types. We exclude discriminated types for convenience, it is extremely
533 -- unlikely that the special processing associated with the use of this
534 -- routine is useful for the case of a discriminated type, and testing for
535 -- component overlap would be a pain.
537 function Is_Library_Level_Tagged_Type (Typ : Entity_Id) return Boolean;
538 -- Return True if Typ is a library level tagged type. Currently we use
539 -- this information to build statically allocated dispatch tables.
541 function Is_Null_Access_BIP_Func_Call (Expr : Node_Id) return Boolean;
542 -- Determine whether node Expr denotes a build-in-place function call with
543 -- a value of "null" for extra formal BIPaccess.
545 function Is_Non_BIP_Func_Call (Expr : Node_Id) return Boolean;
546 -- Determine whether node Expr denotes a non build-in-place function call
548 function Is_Ref_To_Bit_Packed_Array (N : Node_Id) return Boolean;
549 -- Determine whether the node P is a reference to a bit packed array, i.e.
550 -- whether the designated object is a component of a bit packed array, or a
551 -- subcomponent of such a component. If so, then all subscripts in P are
552 -- evaluated with a call to Force_Evaluation, and True is returned.
553 -- Otherwise False is returned, and P is not affected.
555 function Is_Ref_To_Bit_Packed_Slice (N : Node_Id) return Boolean;
556 -- Determine whether the node P is a reference to a bit packed slice, i.e.
557 -- whether the designated object is bit packed slice or a component of a
558 -- bit packed slice. Return True if so.
560 function Is_Related_To_Func_Return (Id : Entity_Id) return Boolean;
561 -- Determine whether object Id is related to an expanded return statement.
562 -- The case concerned is "return Id.all;".
564 function Is_Possibly_Unaligned_Slice (N : Node_Id) return Boolean;
565 -- Determine whether the node P is a slice of an array where the slice
566 -- result may cause alignment problems because it has an alignment that
567 -- is not compatible with the type. Return True if so.
569 function Is_Possibly_Unaligned_Object (N : Node_Id) return Boolean;
570 -- Node N is an object reference. This function returns True if it is
571 -- possible that the object may not be aligned according to the normal
572 -- default alignment requirement for its type (e.g. if it appears in a
573 -- packed record, or as part of a component that has a component clause.)
575 function Is_Renamed_Object (N : Node_Id) return Boolean;
576 -- Returns True if the node N is a renamed object. An expression is
577 -- considered to be a renamed object if either it is the Name of an object
578 -- renaming declaration, or is the prefix of a name which is a renamed
579 -- object. For example, in:
581 -- x : r renames a (1 .. 2) (1);
583 -- We consider that a (1 .. 2) is a renamed object since it is the prefix
584 -- of the name in the renaming declaration.
586 function Is_Tag_To_CW_Conversion (Obj_Id : Entity_Id) return Boolean;
587 -- Determine whether object Obj_Id is the result of a tag-to-class-wide
590 function Is_Untagged_Derivation (T : Entity_Id) return Boolean;
591 -- Returns true if type T is not tagged and is a derived type,
592 -- or is a private type whose completion is such a type.
594 function Is_Volatile_Reference (N : Node_Id) return Boolean;
595 -- Checks if the node N represents a volatile reference, which can be
596 -- either a direct reference to a variable treated as volatile, or an
597 -- indexed/selected component where the prefix is treated as volatile,
598 -- or has Volatile_Components set. A slice of a volatile variable is
601 function Is_VM_By_Copy_Actual (N : Node_Id) return Boolean;
602 -- Returns True if we are compiling on VM targets and N is a node that
603 -- requires pass-by-copy in these targets.
605 procedure Kill_Dead_Code (N : Node_Id; Warn : Boolean := False);
606 -- N represents a node for a section of code that is known to be dead. Any
607 -- exception handler references and warning messages relating to this code
608 -- are removed. If Warn is True, a warning will be output at the start of N
609 -- indicating the deletion of the code. Note that the tree for the deleted
610 -- code is left intact so that e.g. cross-reference data is still valid.
612 procedure Kill_Dead_Code (L : List_Id; Warn : Boolean := False);
613 -- Like the above procedure, but applies to every element in the given
614 -- list. If Warn is True, a warning will be output at the start of N
615 -- indicating the deletion of the code.
617 function Known_Non_Negative (Opnd : Node_Id) return Boolean;
618 -- Given a node for a subexpression, determines if it represents a value
619 -- that cannot possibly be negative, and if so returns True. A value of
620 -- False means that it is not known if the value is positive or negative.
622 function Known_Non_Null (N : Node_Id) return Boolean;
623 -- Given a node N for a subexpression of an access type, determines if
624 -- this subexpression yields a value that is known at compile time to
625 -- be non-null and returns True if so. Returns False otherwise. It is
626 -- an error to call this function if N is not of an access type.
628 function Known_Null (N : Node_Id) return Boolean;
629 -- Given a node N for a subexpression of an access type, determines if this
630 -- subexpression yields a value that is known at compile time to be null
631 -- and returns True if so. Returns False otherwise. It is an error to call
632 -- this function if N is not of an access type.
634 function Make_Invariant_Call (Expr : Node_Id) return Node_Id;
635 -- Expr is an object of a type which Has_Invariants set (and which thus
636 -- also has an Invariant_Procedure set). If invariants are enabled, this
637 -- function returns a call to the Invariant procedure passing Expr as the
638 -- argument, and returns it unanalyzed. If invariants are not enabled,
639 -- returns a null statement.
641 function Make_Predicate_Call
643 Expr : Node_Id) return Node_Id;
644 -- Typ is a type with Predicate_Function set. This routine builds a call to
645 -- this function passing Expr as the argument, and returns it unanalyzed.
647 function Make_Predicate_Check
649 Expr : Node_Id) return Node_Id;
650 -- Typ is a type with Predicate_Function set. This routine builds a Check
651 -- pragma whose first argument is Predicate, and the second argument is a
652 -- call to the this predicate function with Expr as the argument.
654 function Make_Subtype_From_Expr
656 Unc_Typ : Entity_Id) return Node_Id;
657 -- Returns a subtype indication corresponding to the actual type of an
658 -- expression E. Unc_Typ is an unconstrained array or record, or
661 function May_Generate_Large_Temp (Typ : Entity_Id) return Boolean;
662 -- Determines if the given type, Typ, may require a large temporary of the
663 -- kind that causes back-end trouble if stack checking is enabled. The
664 -- result is True only the size of the type is known at compile time and
665 -- large, where large is defined heuristically by the body of this routine.
666 -- The purpose of this routine is to help avoid generating troublesome
667 -- temporaries that interfere with stack checking mechanism. Note that the
668 -- caller has to check whether stack checking is actually enabled in order
669 -- to guide the expansion (typically of a function call).
671 function Needs_Constant_Address
673 Typ : Entity_Id) return Boolean;
674 -- Check whether the expression in an address clause is restricted to
675 -- consist of constants, when the object has a non-trivial initialization
678 function Needs_Finalization (T : Entity_Id) return Boolean;
679 -- True if type T is controlled, or has controlled subcomponents. Also
680 -- True if T is a class-wide type, because some type extension might add
681 -- controlled subcomponents, except that if pragma Restrictions
682 -- (No_Finalization) applies, this is False for class-wide types.
684 function Non_Limited_Designated_Type (T : Entity_Id) return Entity_Id;
685 -- An anonymous access type may designate a limited view. Check whether
686 -- non-limited view is available during expansion, to examine components
687 -- or other characteristics of the full type.
689 function OK_To_Do_Constant_Replacement (E : Entity_Id) return Boolean;
690 -- This function is used when testing whether or not to replace a reference
691 -- to entity E by a known constant value. Such replacement must be done
692 -- only in a scope known to be safe for such replacements. In particular,
693 -- if we are within a subprogram and the entity E is declared outside the
694 -- subprogram then we cannot do the replacement, since we do not attempt to
695 -- trace subprogram call flow. It is also unsafe to replace statically
696 -- allocated values (since they can be modified outside the scope), and we
697 -- also inhibit replacement of Volatile or aliased objects since their
698 -- address might be captured in a way we do not detect. A value of True is
699 -- returned only if the replacement is safe.
701 function Possible_Bit_Aligned_Component (N : Node_Id) return Boolean;
702 -- This function is used during processing the assignment of a record or
703 -- indexed component. The argument N is either the left hand or right hand
704 -- side of an assignment, and this function determines if there is a record
705 -- component reference where the record may be bit aligned in a manner that
706 -- causes trouble for the back end (see Component_May_Be_Bit_Aligned for
709 procedure Process_Statements_For_Controlled_Objects (N : Node_Id);
710 -- N is a node which contains a non-handled statement list. Inspect the
711 -- statements looking for declarations of controlled objects. If at least
712 -- one such object is found, wrap the statement list in a block.
714 procedure Remove_Side_Effects
716 Name_Req : Boolean := False;
717 Variable_Ref : Boolean := False);
718 -- Given the node for a subexpression, this function replaces the node if
719 -- necessary by an equivalent subexpression that is guaranteed to be side
720 -- effect free. This is done by extracting any actions that could cause
721 -- side effects, and inserting them using Insert_Actions into the tree to
722 -- which Exp is attached. Exp must be analyzed and resolved before the call
723 -- and is analyzed and resolved on return. The Name_Req may only be set to
724 -- True if Exp has the form of a name, and the effect is to guarantee that
725 -- any replacement maintains the form of name. If Variable_Ref is set to
726 -- TRUE, a variable is considered as side effect (used in implementing
727 -- Force_Evaluation). Note: after call to Remove_Side_Effects, it is safe
728 -- to call New_Copy_Tree to obtain a copy of the resulting expression.
730 function Represented_As_Scalar (T : Entity_Id) return Boolean;
731 -- Returns True iff the implementation of this type in code generation
732 -- terms is scalar. This is true for scalars in the Ada sense, and for
733 -- packed arrays which are represented by a scalar (modular) type.
735 function Requires_Cleanup_Actions (N : Node_Id) return Boolean;
736 -- Given a node N, determine whether its declarative and/or statement list
737 -- contains one of the following:
739 -- 1) controlled objects
740 -- 2) library-level tagged types
742 -- The above cases require special actions on scope exit.
744 function Safe_Unchecked_Type_Conversion (Exp : Node_Id) return Boolean;
745 -- Given the node for an N_Unchecked_Type_Conversion, return True if this
746 -- is an unchecked conversion that Gigi can handle directly. Otherwise
747 -- return False if it is one for which the front end must provide a
748 -- temporary. Note that the node need not be analyzed, and thus the Etype
749 -- field may not be set, but in that case it must be the case that the
750 -- Subtype_Mark field of the node is set/analyzed.
752 procedure Set_Current_Value_Condition (Cnode : Node_Id);
753 -- Cnode is N_If_Statement, N_Elsif_Part, or N_Iteration_Scheme (the latter
754 -- when a WHILE condition is present). This call checks whether Condition
755 -- (Cnode) has embedded expressions of a form that should result in setting
756 -- the Current_Value field of one or more entities, and if so sets these
757 -- fields to point to Cnode.
759 procedure Set_Elaboration_Flag (N : Node_Id; Spec_Id : Entity_Id);
760 -- N is the node for a subprogram or generic body, and Spec_Id is the
761 -- entity for the corresponding spec. If an elaboration entity is defined,
762 -- then this procedure generates an assignment statement to set it True,
763 -- immediately after the body is elaborated. However, no assignment is
764 -- generated in the case of library level procedures, since the setting of
765 -- the flag in this case is generated in the binder. We do that so that we
766 -- can detect cases where this is the only elaboration action that is
769 procedure Set_Renamed_Subprogram (N : Node_Id; E : Entity_Id);
770 -- N is an node which is an entity name that represents the name of a
771 -- renamed subprogram. The node is rewritten to be an identifier that
772 -- refers directly to the renamed subprogram, given by entity E.
774 procedure Silly_Boolean_Array_Not_Test (N : Node_Id; T : Entity_Id);
775 -- N is the node for a boolean array NOT operation, and T is the type of
776 -- the array. This routine deals with the silly case where the subtype of
777 -- the boolean array is False..False or True..True, where it is required
778 -- that a Constraint_Error exception be raised (RM 4.5.6(6)).
780 procedure Silly_Boolean_Array_Xor_Test (N : Node_Id; T : Entity_Id);
781 -- N is the node for a boolean array XOR operation, and T is the type of
782 -- the array. This routine deals with the silly case where the subtype of
783 -- the boolean array is True..True, where a raise of a Constraint_Error
784 -- exception is required (RM 4.5.6(6)).
786 function Target_Has_Fixed_Ops
787 (Left_Typ : Entity_Id;
788 Right_Typ : Entity_Id;
789 Result_Typ : Entity_Id) return Boolean;
790 -- Returns True if and only if the target machine has direct support
791 -- for fixed-by-fixed multiplications and divisions for the given
792 -- operand and result types. This is called in package Exp_Fixd to
793 -- determine whether to expand such operations.
795 function Type_May_Have_Bit_Aligned_Components
796 (Typ : Entity_Id) return Boolean;
797 -- Determines if Typ is a composite type that has within it (looking down
798 -- recursively at any subcomponents), a record type which has component
799 -- that may be bit aligned (see Possible_Bit_Aligned_Component). The result
800 -- is conservative, in that a result of False is decisive. A result of True
801 -- means that such a component may or may not be present.
803 procedure Wrap_Cleanup_Procedure (N : Node_Id);
804 -- Given an N_Subprogram_Body node, this procedure adds an Abort_Defer call
805 -- at the start of the statement sequence, and an Abort_Undefer call at the
806 -- end of the statement sequence. All cleanup routines (i.e. those that are
807 -- called from "at end" handlers) must defer abort on entry and undefer
808 -- abort on exit. Note that it is assumed that the code for the procedure
809 -- does not contain any return statements which would allow the flow of
810 -- control to escape doing the undefer call.
813 pragma Inline (Duplicate_Subexpr);
814 pragma Inline (Force_Evaluation);
815 pragma Inline (Is_Library_Level_Tagged_Type);