| blob | e45930d573221d543faac9fdca7ae3408b93091f |
1 ------------------------------------------------------------------------------
2 -- --
3 -- GNAT COMPILER COMPONENTS --
4 -- --
5 -- E X P _ U T I L --
6 -- --
7 -- S p e c --
8 -- --
9 -- Copyright (C) 1992-2003 Free Software Foundation, Inc. --
10 -- --
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 2, 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 COPYING. If not, write --
19 -- to the Free Software Foundation, 59 Temple Place - Suite 330, Boston, --
20 -- MA 02111-1307, USA. --
21 -- --
22 -- GNAT was originally developed by the GNAT team at New York University. --
23 -- Extensive contributions were provided by Ada Core Technologies Inc. --
24 -- --
25 ------------------------------------------------------------------------------
27 -- Package containing utility procedures used throughout the expander
36 -----------------------------------------------
37 -- Handling of Actions Associated with Nodes --
38 -----------------------------------------------
40 -- The evaluation of certain expression nodes involves the elaboration
41 -- of associated types and other declarations, and the execution of
42 -- statement sequences. Expansion routines generating such actions must
43 -- find an appropriate place in the tree to hang the actions so that
44 -- they will be evaluated at the appropriate point.
46 -- Some cases are simple:
48 -- For an expression occurring in a simple statement that is in a list
49 -- of statements, the actions are simply inserted into the list before
50 -- the associated statement.
52 -- For an expression occurring in a declaration (declarations always
53 -- appear in lists), the actions are similarly inserted into the list
54 -- just before the associated declaration.
56 -- The following special cases arise:
58 -- For actions associated with the right operand of a short circuit
59 -- form, the actions are first stored in the short circuit form node
60 -- in the Actions field. The expansion of these forms subsequently
61 -- expands the short circuit forms into if statements which can then
62 -- be moved as described above.
64 -- For actions appearing in the Condition expression of a while loop,
65 -- or an elsif clause, the actions are similarly temporarily stored in
66 -- in the node (N_Elsif_Part or N_Iteration_Scheme) associated with
67 -- the expression using the Condition_Actions field. Subsequently, the
68 -- expansion of these nodes rewrites the control structures involved to
69 -- reposition the actions in normal statement sequence.
71 -- For actions appearing in the then or else expression of a conditional
72 -- expression, these actions are similarly placed in the node, using the
73 -- Then_Actions or Else_Actions field as appropriate. Once again the
74 -- expansion of the N_Conditional_Expression node rewrites the node so
75 -- that the actions can be normally positioned.
77 -- Basically what we do is to climb up to the tree looking for the
78 -- proper insertion point, as described by one of the above cases,
79 -- and then insert the appropriate action or actions.
81 -- Note if more than one insert call is made specifying the same
82 -- Assoc_Node, then the actions are elaborated in the order of the
83 -- calls, and this guarantee is preserved for the special cases above.
85 procedure Insert_Action
88 -- Insert the action Ins_Action at the appropriate point as described
89 -- above. The action is analyzed using the default checks after it is
90 -- inserted. Assoc_Node is the node with which the action is associated.
92 procedure Insert_Action
96 -- Insert the action Ins_Action at the appropriate point as described
97 -- above. The action is analyzed using the default checks as modified
98 -- by the given Suppress argument after it is inserted. Assoc_Node is
99 -- the node with which the action is associated.
101 procedure Insert_Actions
104 -- Insert the list of action Ins_Actions at the appropriate point as
105 -- described above. The actions are analyzed using the default checks
106 -- after they are inserted. Assoc_Node is the node with which the actions
107 -- are associated. Ins_Actions may be No_List, in which case the call has
108 -- no effect.
110 procedure Insert_Actions
114 -- Insert the list of action Ins_Actions at the appropriate point as
115 -- described above. The actions are analyzed using the default checks
116 -- as modified by the given Suppress argument after they are inserted.
117 -- Assoc_Node is the node with which the actions are associated.
118 -- Ins_Actions may be No_List, in which case the call has no effect.
120 procedure Insert_Actions_After
123 -- Assoc_Node must be a node in a list. Same as Insert_Actions but
124 -- actions will be inserted after N in a manner that is compatible with
125 -- the transient scope mechanism. This procedure must be used instead
126 -- of Insert_List_After if Assoc_Node may be in a transient scope.
127 --
128 -- Implementation limitation: Assoc_Node must be a statement. We can
129 -- generalize to expressions if there is a need but this is tricky to
130 -- implement because of short-ciruits (among other things).???
133 -- This procedure inserts and analyzes the node N as an action at the
134 -- library level for the current unit (i.e. it is attached to the
135 -- Actions field of the N_Compilation_Aux node for the main unit).
138 -- Similar, but inserts a list of actions.
140 -----------------------
141 -- Other Subprograms --
142 -----------------------
145 -- The node N is an expression whose root-type is Boolean, and which
146 -- represents a boolean value used as a condition (i.e. a True/False
147 -- value). This routine handles the case of C and Fortran convention
148 -- boolean types, which have zero/non-zero semantics rather than the
149 -- normal 0/1 semantics, and also the case of an enumeration rep
150 -- clause that specifies a non-standard representation. On return,
151 -- node N always has the type Standard.Boolean, with a value that
152 -- is a standard Boolean values of 0/1 for False/True. This procedure
153 -- is used in two situations. First, the processing for a condition
154 -- field always calls Adjust_Condition, so that the boolean value
155 -- presented to the backend is a standard value. Second, for the
156 -- code for boolean operations such as AND, Adjust_Condition is
157 -- called on both operands, and then the operation is done in the
158 -- domain of Standard_Boolean, then Adjust_Result_Type is called
159 -- on the result to possibly reset the original type. This procedure
160 -- also takes care of validity checking if Validity_Checks = Tests.
163 -- The processing of boolean operations like AND uses the procedure
164 -- Adjust_Condition so that it can operate on Standard.Boolean, which
165 -- is the only boolean type on which the backend needs to be able to
166 -- implement such operators. This means that the result is also of
167 -- type Standard.Boolean. In general the type must be reset back to
168 -- the original type to get proper semantics, and that is the purpose
169 -- of this procedure. N is the node (of type Standard.Boolean), and
170 -- T is the desired type. As an optimization, this procedure leaves
171 -- the type as Standard.Boolean in contexts where this is permissible
172 -- (in particular for Condition fields, and for operands of other
173 -- logical operations higher up the tree). The call to this procedure
174 -- is completely ignored if the argument N is not of type Boolean.
177 -- Add a new freeze action for the given type. The freeze action is
178 -- attached to the freeze node for the type. Actions will be elaborated
179 -- in the order in which they are added. Note that the added node is not
180 -- analyzed. The analyze call is found in Sem_Ch13.Expand_N_Freeze_Entity.
183 -- Adds the given list of freeze actions (declarations or statements)
184 -- for the given type. The freeze actions are attached to the freeze
185 -- node for the type. Actions will be elaborated in the order in which
186 -- they are added, and the actions within the list will be elaborated in
187 -- list order. Note that the added nodes are not analyzed. The analyze
188 -- call is found in Sem_Ch13.Expand_N_Freeze_Entity.
191 -- Build an N_Procedure_Call_Statement calling the given runtime entity.
192 -- The call has no parameters. The first argument provides the location
193 -- information for the tree and for error messages. The call node is not
194 -- analyzed on return, the caller is responsible for analyzing it.
196 function Build_Task_Image_Decls
201 -- Build declaration for a variable that holds an identifying string
202 -- to be used as a task name. Id_Ref is an identifier if the task is
203 -- a variable, and a selected or indexed component if the task is a
204 -- component of an object. If it is an indexed component, A_Type is
205 -- the corresponding array type. Its index types are used to build the
206 -- string as an image of the index values. For composite types, the
207 -- result includes two declarations: one for a generated function that
208 -- computes the image without using concatenation, and one for the
209 -- variable that holds the result.
212 -- The Etype of an expression is the nominal type of the expression,
213 -- not the actual subtype. Often these are the same, but not always.
214 -- For example, a reference to a formal of unconstrained type has the
215 -- unconstrained type as its Etype, but the actual subtype is obtained
216 -- by applying the actual bounds. This routine is given an expression,
217 -- Exp, and (if necessary), replaces it using Rewrite, with a conversion
218 -- to the actual subtype, building the actual subtype if necessary. If
219 -- the expression is already of the requested type, then it is unchanged.
222 -- Return the a place where it is fine to insert declarations for the
223 -- current semantic unit. If the unit is a package body, return the
224 -- visible declarations of the corresponding spec. For RCI stubs, this
225 -- is necessary because the point at which they are generated may not
226 -- be the earliest point at which they are used.
228 function Duplicate_Subexpr
232 -- Given the node for a subexpression, this function makes a logical
233 -- copy of the subexpression, and returns it. This is intended for use
234 -- when the expansion of an expression needs to repeat part of it. For
235 -- example, replacing a**2 by a*a requires two references to a which
236 -- may be a complex subexpression. Duplicate_Subexpression guarantees
237 -- not to duplicate side effects. If necessary, it generates actions
238 -- to save the expression value in a temporary, inserting these actions
239 -- into the tree using Insert_Actions with Exp as the insertion location.
240 -- The original expression and the returned result then become references
241 -- to this saved value. Exp must be analyzed on entry. On return, Exp
242 -- is analyzed, but the caller is responsible for analyzing the returned
243 -- copy after it is attached to the tree. The Name_Req flag is set to
244 -- ensure that the result is suitable for use in a context requiring a
245 -- name (e.g. the prefix of an attribute reference).
246 --
247 -- Note that if there are any run time checks in Exp, these same checks
248 -- will be duplicated in the returned duplicated expression. The two
249 -- following functions allow this behavior to be modified.
251 function Duplicate_Subexpr_No_Checks
255 -- Identical in effect to Duplicate_Subexpr, except that Remove_Checks
256 -- is called on the result, so that the duplicated expression does not
257 -- include checks. This is appropriate for use when Exp, the original
258 -- expression is unconditionally elaborated before the duplicated
259 -- expression, so that there is no need to repeat any checks.
261 function Duplicate_Subexpr_Move_Checks
265 -- Identical in effect to Duplicate_Subexpr, except that Remove_Checks
266 -- is called on Exp after the duplication is complete, so that the
267 -- original expression does not include checks. In this case the result
268 -- returned (the duplicated expression) will retain the original checks.
269 -- This is appropriate for use when the duplicated expression is sure
270 -- to be elaborated before the original expression Exp, so that there
271 -- is no need to repeat the checks.
274 -- This procedure ensures that type referenced by Typ is defined. For the
275 -- case of a type other than an Itype, nothing needs to be done, since
276 -- all such types have declaration nodes. For Itypes, an N_Itype_Reference
277 -- node is generated and inserted at the given node N. This is typically
278 -- used to ensure that an Itype is properly defined outside a conditional
279 -- construct when it is referenced in more than one branch.
282 -- Rewrites Cond with the expression: Cond and then Cond1. If Cond is
283 -- Empty, then simply returns Cond1 (this allows the use of Empty to
284 -- initialize a series of checks evolved by this routine, with a final
285 -- result of Empty indicating that no checks were required). The Sloc
286 -- field of the constructed N_And_Then node is copied from Cond1.
289 -- Rewrites Cond with the expression: Cond or else Cond1. If Cond is
290 -- Empty, then simply returns Cond1 (this allows the use of Empty to
291 -- initialize a series of checks evolved by this routine, with a final
292 -- result of Empty indicating that no checks were required). The Sloc
293 -- field of the constructed N_And_Then node is copied from Cond1.
295 procedure Expand_Subtype_From_Expr
300 -- Build a constrained subtype from the initial value in object
301 -- declarations and/or allocations when the type is indefinite (including
302 -- class-wide).
305 -- Find the first primitive operation of type T whose name is 'Name'.
306 -- This function allows the use of a primitive operation which is not
307 -- directly visible. If T is a class wide type, then the reference is
308 -- to an operation of the corresponding root type.
310 function Find_Prim_Op
313 -- Find the first primitive operation of type T whose name has the form
314 -- indicated by the name parameter (i.e. is a type support subprogram
315 -- with the indicated suffix). This function allows use of a primitive
316 -- operation which is not directly visible. If T is a class wide type,
317 -- then the reference is to an operation of the corresponding root type.
319 procedure Force_Evaluation
322 -- Force the evaluation of the expression right away. Similar behavior
323 -- to Remove_Side_Effects when Variable_Ref is set to TRUE. That is to
324 -- say, it removes the side-effects and capture the values of the
325 -- variables. Remove_Side_effects guarantees that multiple evaluations
326 -- of the same expression won't generate multiple side effects, whereas
327 -- Force_Evaluation further guarantees that all evaluations will yield
328 -- the same result.
331 -- If polling is active, then a call to the Poll routine is built,
332 -- and then inserted before the given node N and analyzed.
334 procedure Get_Current_Value_Condition
338 -- This routine processes the Current_Value field of the variable Var.
339 -- If the Current_Value field is null or if it represents a known value,
340 -- then on return Cond is set to N_Empty, and Val is set to Empty.
341 --
342 -- The other case is when Current_Value points to an N_If_Statement
343 -- or an N_Elsif_Part (while statement). Such a setting only occurs
344 -- if the condition of an IF or ELSIF is of the form X op Y, where X
345 -- is the variable in question, Y is a compile-time known value, and
346 -- op is one of the six possible relational operators.
347 --
348 -- In this case, Get_Current_Condition digs out the condition, and
349 -- then checks if the condition is known false, known true, or not
350 -- known at all. In the first two cases, Get_Current_Condition will
351 -- return with Op set to the appropriate conditional operator (inverted
352 -- if the condition is known false), and Val set to the constant value.
353 -- If the condition is not known, then Cond and Val are set for the
354 -- empty case (N_Empty and Empty).
355 --
356 -- The check for whether the condition is true/false unknown depends
357 -- on the case:
358 --
359 -- For an IF, the condition is known true in the THEN part, known
360 -- false in any ELSIF or ELSE part, and not known outside the IF
361 -- statement in question.
362 --
363 -- For an ELSIF, the condition is known true in the ELSIF part,
364 -- known FALSE in any subsequent ELSIF, or ELSE part, and not
365 -- known before the ELSIF, or after the end of the IF statement.
366 --
367 -- The caller can use this result to determine the value (for the
368 -- case of N_Op_Eq), or to determine the result of some other test
369 -- in other cases (e.g. no access check required if N_Op_Ne Null).
372 -- Here subp is the entity for a subprogram. This routine returns the
373 -- homonym number used to disambiguate overloaded subprograms in the
374 -- same scope (the number is used as part of constructed names to make
375 -- sure that they are unique). The number is the ordinal position on
376 -- the Homonym chain, counting only entries in the curren scope. If
377 -- an entity is not overloaded, the returned number will be one.
380 -- Returns True if current scope is within an init proc
383 -- Node is the node for a statement or a component of a statement.
384 -- This function deteermines if the statement appears in a context
385 -- that is unconditionally executed, i.e. it is not within a loop
386 -- or a conditional or a case statement etc.
389 -- Return True if all the items of the list are N_Null_Statement
390 -- nodes. False otherwise. True for an empty list. It is an error
391 -- to call this routine with No_List as the argument.
394 -- Determine whether the node P is a reference to a bit packed
395 -- array, i.e. whether the designated object is a component of
396 -- a bit packed array, or a subcomponent of such a component.
397 -- If so, then all subscripts in P are evaluated with a call
398 -- to Force_Evaluation, and True is returned. Otherwise False
399 -- is returned, and P is not affected.
402 -- Determine whether the node P is a reference to a bit packed
403 -- slice, i.e. whether the designated object is bit packed slice
404 -- or a component of a bit packed slice. Return True if so.
407 -- Determine whether the node P is a slice of an array where the slice
408 -- result may cause alignment problems because it has an alignment that
409 -- is not compatible with the type. Return True if so.
412 -- Node P is an object reference. This function returns True if it
413 -- is possible that the object may not be aligned according to the
414 -- normal default alignment requirement for its type (e.g. if it
415 -- appears in a packed record, or as part of a component that has
416 -- a component clause.
419 -- Returns True if the node N is a renamed object. An expression
420 -- is considered to be a renamed object if either it is the Name
421 -- of an object renaming declaration, or is the prefix of a name
422 -- which is a renamed object. For example, in:
423 --
424 -- x : r renames a (1 .. 2) (1);
425 --
426 -- We consider that a (1 .. 2) is a renamed object since it is the
427 -- prefix of the name in the renaming declaration.
430 -- Returns true if type T is not tagged and is a derived type,
431 -- or is a private type whose completion is such a type.
434 -- N represents a node for a section of code that is known to be
435 -- dead. The node is deleted, and any exception handler references
436 -- and warning messages relating to this code are removed.
439 -- Like the above procedure, but applies to every element in the given
440 -- list. Each of the entries is removed from the list before killing it.
443 -- Given a node for a subexpression, determines if it represents a value
444 -- that cannot possibly be negative, and if so returns True. A value of
445 -- False means that it is not known if the value is positive or negative.
448 -- Given a node N for a subexpression of an access type, determines if
449 -- this subexpression yields a value that is known at compile time to
450 -- be non-null and returns True if so. Returns False otherwise. It is
451 -- an error to call this function if N is not of an access type.
453 function Make_Subtype_From_Expr
457 -- Returns a subtype indication corresponding to the actual type of an
458 -- expression E. Unc_Typ is an unconstrained array or record, or
459 -- a classwide type.
462 -- Determines if the given type, Typ, may require a large temporary
463 -- of the type that causes trouble if stack checking is enabled. The
464 -- result is True only if stack checking is enabled and the size of
465 -- the type is known at compile time and large, where large is defined
466 -- hueristically by the body of this routine. The purpose of this
467 -- routine is to help avoid generating troublesome temporaries that
468 -- intefere with the stack checking mechanism.
470 procedure Remove_Side_Effects
474 -- Given the node for a subexpression, this function replaces the node
475 -- if necessary by an equivalent subexpression that is guaranteed to be
476 -- side effect free. This is done by extracting any actions that could
477 -- cause side effects, and inserting them using Insert_Actions into the
478 -- tree to which Exp is attached. Exp must be analayzed and resolved
479 -- before the call and is analyzed and resolved on return. The Name_Req
480 -- may only be set to True if Exp has the form of a name, and the
481 -- effect is to guarantee that any replacement maintains the form of a
482 -- name. If Variable_Ref is set to TRUE, a variable is considered as a
483 -- side effect (used in implementing Force_Evaluation). Note: after a
484 -- call to Remove_Side_Effects, it is safe to use a call to
485 -- New_Copy_Tree to obtain a copy of the resulting expression.
488 -- Given the node for an N_Unchecked_Type_Conversion, return True
489 -- if this is an unchecked conversion that Gigi can handle directly.
490 -- Otherwise return False if it is one for which the front end must
491 -- provide a temporary. Note that the node need not be analyzed, and
492 -- thus the Etype field may not be set, but in that case it must be
493 -- the case that the Subtype_Mark field of the node is set/analyzed.
496 -- N is the node for a subprogram or generic body, and Spec_Id
497 -- is the entity for the corresponding spec. If an elaboration
498 -- entity is defined, then this procedure generates an assignment
499 -- statement to set it True, immediately after the body is elaborated.
500 -- However, no assignment is generated in the case of library level
501 -- procedures, since the setting of the flag in this case is generated
502 -- in the binder. We do that so that we can detect cases where this is
503 -- the only elaboration action that is required.
505 function Target_Has_Fixed_Ops
510 -- Returns True if and only if the target machine has direct support
511 -- for fixed-by-fixed multiplications and divisions for the given
512 -- operand and result types. This is called in package Exp_Fixd to
513 -- determine whether to expand such operations.
516 -- Given an N_Subprogram_Body node, this procedure adds an Abort_Defer
517 -- call at the start of the statement sequence, and an Abort_Undefer call
518 -- at the end of the statement sequence. All cleanup routines (i.e. those
519 -- that are called from "at end" handlers) must defer abort on entry and
520 -- undefer abort on exit. Note that it is assumed that the code for the
521 -- procedure does not contain any return statements which would allow the
522 -- flow of control to escape doing the undefer call.
524 private