1 ------------------------------------------------------------------------------
3 -- GNAT COMPILER COMPONENTS --
9 -- Copyright (C) 1992-2019, 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. ???Declarations do not always
56 -- appear in lists; in particular, a library unit declaration does not
57 -- appear in a list, and Insert_Action will crash in that case.
59 -- The following special cases arise:
61 -- For actions associated with the right operand of a short circuit
62 -- form, the actions are first stored in the short circuit form node
63 -- in the Actions field. The expansion of these forms subsequently
64 -- expands the short circuit forms into if statements which can then
65 -- be moved as described above.
67 -- For actions appearing in the Condition expression of a while loop,
68 -- or an elsif clause, the actions are similarly temporarily stored in
69 -- in the node (N_Elsif_Part or N_Iteration_Scheme) associated with
70 -- the expression using the Condition_Actions field. Subsequently, the
71 -- expansion of these nodes rewrites the control structures involved to
72 -- reposition the actions in normal statement sequence.
74 -- For actions appearing in the then or else expression of a conditional
75 -- expression, these actions are similarly placed in the node, using the
76 -- Then_Actions or Else_Actions field as appropriate. Once again the
77 -- expansion of the N_If_Expression node rewrites the node so that the
78 -- actions can be positioned normally.
80 -- For actions coming from expansion of the expression in an expression
81 -- with actions node, the action is appended to the list of actions.
83 -- Basically what we do is to climb up to the tree looking for the
84 -- proper insertion point, as described by one of the above cases,
85 -- and then insert the appropriate action or actions.
87 -- Note if more than one insert call is made specifying the same
88 -- Assoc_Node, then the actions are elaborated in the order of the
89 -- calls, and this guarantee is preserved for the special cases above.
91 procedure Insert_Action
92 (Assoc_Node
: Node_Id
;
94 Spec_Expr_OK
: Boolean := False);
95 -- Insert the action Ins_Action at the appropriate point as described
96 -- above. The action is analyzed using the default checks after it is
97 -- inserted. Assoc_Node is the node with which the action is associated.
98 -- When flag Spec_Expr_OK is set, insertions triggered in the context of
99 -- spec expressions are honored, even though they contradict "Handling
100 -- of Default and Per-Object Expressions".
102 procedure Insert_Action
103 (Assoc_Node
: Node_Id
;
104 Ins_Action
: Node_Id
;
106 Spec_Expr_OK
: Boolean := False);
107 -- Insert the action Ins_Action at the appropriate point as described
108 -- above. The action is analyzed using the default checks as modified
109 -- by the given Suppress argument after it is inserted. Assoc_Node is
110 -- the node with which the action is associated. When flag Spec_Expr_OK
111 -- is set, insertions triggered in the context of spec expressions are
112 -- honored, even though they contradict "Handling of Default and Per-
113 -- Object Expressions".
115 procedure Insert_Actions
116 (Assoc_Node
: Node_Id
;
117 Ins_Actions
: List_Id
;
118 Spec_Expr_OK
: Boolean := False);
119 -- Insert the list of action Ins_Actions at the appropriate point as
120 -- described above. The actions are analyzed using the default checks
121 -- after they are inserted. Assoc_Node is the node with which the actions
122 -- are associated. Ins_Actions may be No_List, in which case the call has
123 -- no effect. When flag Spec_Expr_OK is set, insertions triggered in the
124 -- context of spec expressions are honored, even though they contradict
125 -- "Handling of Default and Per-Object Expressions".
127 procedure Insert_Actions
128 (Assoc_Node
: Node_Id
;
129 Ins_Actions
: List_Id
;
131 Spec_Expr_OK
: Boolean := False);
132 -- Insert the list of action Ins_Actions at the appropriate point as
133 -- described above. The actions are analyzed using the default checks
134 -- as modified by the given Suppress argument after they are inserted.
135 -- Assoc_Node is the node with which the actions are associated. List
136 -- Ins_Actions may be No_List, in which case the call has no effect.
137 -- When flag Spec_Expr_OK is set, insertions triggered in the context of
138 -- spec expressions are honored, even though they contradict "Handling
139 -- of Default and Per-Object Expressions".
141 procedure Insert_Action_After
142 (Assoc_Node
: Node_Id
;
143 Ins_Action
: Node_Id
);
144 -- Assoc_Node must be a node in a list. Same as Insert_Action but the
145 -- action will be inserted after N in a manner that is compatible with
146 -- the transient scope mechanism.
148 -- Note: If several successive calls to Insert_Action_After are made for
149 -- the same node, they will each in turn be inserted just after the node.
150 -- This means they will end up being executed in reverse order. Use the
151 -- call to Insert_Actions_After to insert a list of actions to be executed
152 -- in the sequence in which they are given in the list.
154 procedure Insert_Actions_After
155 (Assoc_Node
: Node_Id
;
156 Ins_Actions
: List_Id
);
157 -- Assoc_Node must be a node in a list. Same as Insert_Actions but
158 -- actions will be inserted after N in a manner that is compatible with
159 -- the transient scope mechanism. This procedure must be used instead
160 -- of Insert_List_After if Assoc_Node may be in a transient scope.
162 -- Implementation limitation: Assoc_Node must be a statement. We can
163 -- generalize to expressions if there is a need but this is tricky to
164 -- implement because of short-circuits (among other things).???
166 procedure Insert_Declaration
(N
: Node_Id
; Decl
: Node_Id
);
167 -- N must be a subexpression (Nkind in N_Subexpr). This is similar to
168 -- Insert_Action (N, Decl), but inserts Decl outside the expression in
169 -- which N appears. This is called Insert_Declaration because the intended
170 -- use is for declarations that have no associated code. We can't go
171 -- moving other kinds of things out of the current expression, since they
172 -- could be executed conditionally (e.g. right operand of short circuit,
173 -- or THEN/ELSE of if expression). This is currently used only in
174 -- Modify_Tree_For_C mode, where it is needed because in C we have no
175 -- way of having declarations within an expression (a really annoying
178 procedure Insert_Library_Level_Action
(N
: Node_Id
);
179 -- This procedure inserts and analyzes the node N as an action at the
180 -- library level for the current unit (i.e. it is attached to the
181 -- Actions field of the N_Compilation_Aux node for the main unit).
183 procedure Insert_Library_Level_Actions
(L
: List_Id
);
184 -- Similar, but inserts a list of actions
186 -----------------------
187 -- Other Subprograms --
188 -----------------------
190 procedure Activate_Atomic_Synchronization
(N
: Node_Id
);
191 -- N is a node for which atomic synchronization may be required (it is
192 -- either an identifier, expanded name, or selected/indexed component or
193 -- an explicit dereference). The caller has checked the basic conditions
194 -- (atomic variable appearing and Atomic_Sync not disabled). This function
195 -- checks if atomic synchronization is required and if so sets the flag
196 -- and if appropriate generates a warning (in -gnatw.n mode).
198 procedure Adjust_Condition
(N
: Node_Id
);
199 -- The node N is an expression whose root-type is Boolean, and which
200 -- represents a boolean value used as a condition (i.e. a True/False
201 -- value). This routine handles the case of C and Fortran convention
202 -- boolean types, which have zero/non-zero semantics rather than the normal
203 -- 0/1 semantics, and also the case of an enumeration rep clause that
204 -- specifies a non-standard representation. On return, node N always has
205 -- the type Standard.Boolean, with a value that is a standard Boolean
206 -- values of 0/1 for False/True. This procedure is used in two situations.
207 -- First, the processing for a condition field always calls
208 -- Adjust_Condition, so that the boolean value presented to the backend is
209 -- a standard value. Second, for the code for boolean operations such as
210 -- AND, Adjust_Condition is called on both operands, and then the operation
211 -- is done in the domain of Standard_Boolean, then Adjust_Result_Type is
212 -- called on the result to possibly reset the original type. This procedure
213 -- also takes care of validity checking if Validity_Checks = Tests.
215 procedure Adjust_Result_Type
(N
: Node_Id
; T
: Entity_Id
);
216 -- The processing of boolean operations like AND uses the procedure
217 -- Adjust_Condition so that it can operate on Standard.Boolean, which is
218 -- the only boolean type on which the backend needs to be able to implement
219 -- such operators. This means that the result is also of type
220 -- Standard.Boolean. In general the type must be reset back to the original
221 -- type to get proper semantics, and that is the purpose of this procedure.
222 -- N is the node (of type Standard.Boolean), and T is the desired type. As
223 -- an optimization, this procedure leaves the type as Standard.Boolean in
224 -- contexts where this is permissible (in particular for Condition fields,
225 -- and for operands of other logical operations higher up the tree). The
226 -- call to this procedure is completely ignored if the argument N is not of
229 procedure Append_Freeze_Action
(T
: Entity_Id
; N
: Node_Id
);
230 -- Add a new freeze action for the given type. The freeze action is
231 -- attached to the freeze node for the type. Actions will be elaborated in
232 -- the order in which they are added. Note that the added node is not
233 -- analyzed. The analyze call is found in Exp_Ch13.Expand_N_Freeze_Entity.
235 procedure Append_Freeze_Actions
(T
: Entity_Id
; L
: List_Id
);
236 -- Adds the given list of freeze actions (declarations or statements) for
237 -- the given type. The freeze actions are attached to the freeze node for
238 -- the type. Actions will be elaborated in the order in which they are
239 -- added, and the actions within the list will be elaborated in list order.
240 -- Note that the added nodes are not analyzed. The analyze call is found in
241 -- Exp_Ch13.Expand_N_Freeze_Entity.
243 procedure Build_Allocate_Deallocate_Proc
245 Is_Allocate
: Boolean);
246 -- Create a custom Allocate/Deallocate to be associated with an allocation
249 -- 1) controlled objects
250 -- 2) class-wide objects
251 -- 3) any kind of object on a subpool
253 -- N must be an allocator or the declaration of a temporary variable which
254 -- represents the expression of the original allocator node, otherwise N
255 -- must be a free statement. If flag Is_Allocate is set, the generated
256 -- routine is allocate, deallocate otherwise.
258 function Build_Abort_Undefer_Block
261 Context
: Node_Id
) return Node_Id
;
262 -- Wrap statements Stmts in a block where the AT END handler contains a
263 -- call to Abort_Undefer_Direct. Context is the node which prompted the
264 -- inlining of the abort undefer routine. Note that this routine does
265 -- not install a call to Abort_Defer.
267 procedure Build_Class_Wide_Expression
270 Par_Subp
: Entity_Id
;
271 Adjust_Sloc
: Boolean;
272 Needs_Wrapper
: out Boolean);
273 -- Build the expression for an inherited class-wide condition. Prag is
274 -- the pragma constructed from the corresponding aspect of the parent
275 -- subprogram, and Subp is the overriding operation, and Par_Subp is
276 -- the overridden operation that has the condition. Adjust_Sloc is True
277 -- when the sloc of nodes traversed should be adjusted for the inherited
278 -- pragma. The routine is also called to check whether an inherited
279 -- operation that is not overridden but has inherited conditions needs
280 -- a wrapper, because the inherited condition includes calls to other
281 -- primitives that have been overridden. In that case the first argument
282 -- is the expression of the original class-wide aspect. In SPARK_Mode, such
283 -- operation which are just inherited but have modified pre/postconditions
285 -- If there are calls to overridden operations in the condition, and the
286 -- pragma applies to an inherited operation, a wrapper must be built for
287 -- it to capture the new inherited condition. The flag Needs_Wrapper is
288 -- set in that case so that the wrapper can be built, when the controlling
291 function Build_DIC_Call
294 Typ
: Entity_Id
) return Node_Id
;
295 -- Build a call to the DIC procedure of type Typ with Obj_Id as the actual
298 procedure Build_DIC_Procedure_Body
300 For_Freeze
: Boolean := False);
301 -- Create the body of the procedure which verifies the assertion expression
302 -- of pragma Default_Initial_Condition at run time. Flag For_Freeze should
303 -- be set when the body is constructed as part of the freezing actions for
306 procedure Build_DIC_Procedure_Declaration
(Typ
: Entity_Id
);
307 -- Create the declaration of the procedure which verifies the assertion
308 -- expression of pragma Default_Initial_Condition at run time.
310 procedure Build_Invariant_Procedure_Body
312 Partial_Invariant
: Boolean := False);
313 -- Create the body of the procedure which verifies the invariants of type
314 -- Typ at runtime. Flag Partial_Invariant should be set when Typ denotes a
315 -- private type, otherwise it is assumed that Typ denotes the full view of
318 procedure Build_Invariant_Procedure_Declaration
320 Partial_Invariant
: Boolean := False);
321 -- Create the declaration of the procedure which verifies the invariants of
322 -- type Typ at runtime. Flag Partial_Invariant should be set when building
323 -- the invariant procedure for a private type.
325 procedure Build_Procedure_Form
(N
: Node_Id
);
326 -- Create a procedure declaration which emulates the behavior of a function
327 -- that returns an array type, for C-compatible generation.
329 function Build_Runtime_Call
(Loc
: Source_Ptr
; RE
: RE_Id
) return Node_Id
;
330 -- Build an N_Procedure_Call_Statement calling the given runtime entity.
331 -- The call has no parameters. The first argument provides the location
332 -- information for the tree and for error messages. The call node is not
333 -- analyzed on return, the caller is responsible for analyzing it.
335 function Build_SS_Mark_Call
337 Mark
: Entity_Id
) return Node_Id
;
338 -- Build a call to routine System.Secondary_Stack.Mark. Mark denotes the
339 -- entity of the secondary stack mark.
341 function Build_SS_Release_Call
343 Mark
: Entity_Id
) return Node_Id
;
344 -- Build a call to routine System.Secondary_Stack.Release. Mark denotes the
345 -- entity of the secondary stack mark.
347 function Build_Task_Image_Decls
351 In_Init_Proc
: Boolean := False) return List_Id
;
352 -- Build declaration for a variable that holds an identifying string to be
353 -- used as a task name. Id_Ref is an identifier if the task is a variable,
354 -- and a selected or indexed component if the task is component of an
355 -- object. If it is an indexed component, A_Type is the corresponding array
356 -- type. Its index types are used to build the string as an image of the
357 -- index values. For composite types, the result includes two declarations:
358 -- one for a generated function that computes the image without using
359 -- concatenation, and one for the variable that holds the result.
361 -- If In_Init_Proc is true, the call is part of the initialization of
362 -- a component of a composite type, and the enclosing initialization
363 -- procedure must be flagged as using the secondary stack. If In_Init_Proc
364 -- is false, the call is for a stand-alone object, and the generated
365 -- function itself must do its own cleanups.
367 procedure Build_Transient_Object_Statements
369 Fin_Call
: out Node_Id
;
370 Hook_Assign
: out Node_Id
;
371 Hook_Clear
: out Node_Id
;
372 Hook_Decl
: out Node_Id
;
373 Ptr_Decl
: out Node_Id
;
374 Finalize_Obj
: Boolean := True);
375 -- Subsidiary to the processing of transient objects in transient scopes,
376 -- if expressions, case expressions, expression_with_action nodes, array
377 -- aggregates, and record aggregates. Obj_Decl denotes the declaration of
378 -- the transient object. Generate the following nodes:
380 -- * Fin_Call - the call to [Deep_]Finalize which cleans up the transient
381 -- object if flag Finalize_Obj is set to True, or finalizes the hook when
382 -- the flag is False.
384 -- * Hook_Assign - the assignment statement which captures a reference to
385 -- the transient object in the hook.
387 -- * Hook_Clear - the assignment statement which resets the hook to null
389 -- * Hook_Decl - the declaration of the hook object
391 -- * Ptr_Decl - the full type declaration of the hook type
393 -- These nodes are inserted in specific places depending on the context by
394 -- the various Process_Transient_xxx routines.
396 procedure Check_Float_Op_Overflow
(N
: Node_Id
);
397 -- Called where we could have a floating-point binary operator where we
398 -- must check for infinities if we are operating in Check_Float_Overflow
399 -- mode. Note that we don't need to worry about unary operator cases,
400 -- since for floating-point, abs, unary "-", and unary "+" can never
403 function Component_May_Be_Bit_Aligned
(Comp
: Entity_Id
) return Boolean;
404 -- This function is in charge of detecting record components that may
405 -- cause trouble in the back end if an attempt is made to assign the
406 -- component. The back end can handle such assignments with no problem if
407 -- the components involved are small (64-bits or less) records or scalar
408 -- items (including bit-packed arrays represented with modular types) or
409 -- are both aligned on a byte boundary (starting on a byte boundary, and
410 -- occupying an integral number of bytes).
412 -- However, problems arise for records larger than 64 bits, or for arrays
413 -- (other than bit-packed arrays represented with a modular type) if the
414 -- component starts on a non-byte boundary, or does not occupy an integral
415 -- number of bytes (i.e. there are some bits possibly shared with fields
416 -- at the start or beginning of the component). The back end cannot handle
417 -- loading and storing such components in a single operation.
419 -- This function is used to detect the troublesome situation. it is
420 -- conservative in the sense that it produces True unless it knows for
421 -- sure that the component is safe (as outlined in the first paragraph
422 -- above). The code generation for record and array assignment checks for
423 -- trouble using this function, and if so the assignment is generated
424 -- component-wise, which the back end is required to handle correctly.
426 -- Note that in GNAT 3, the back end will reject such components anyway,
427 -- so the hard work in checking for this case is wasted in GNAT 3, but
428 -- it is harmless, so it is easier to do it in all cases, rather than
429 -- conditionalize it in GNAT 5 or beyond.
431 function Containing_Package_With_Ext_Axioms
432 (E
: Entity_Id
) return Entity_Id
;
433 -- Returns the package entity with an external axiomatization containing E,
434 -- if any, or Empty if none.
436 procedure Convert_To_Actual_Subtype
(Exp
: Node_Id
);
437 -- The Etype of an expression is the nominal type of the expression,
438 -- not the actual subtype. Often these are the same, but not always.
439 -- For example, a reference to a formal of unconstrained type has the
440 -- unconstrained type as its Etype, but the actual subtype is obtained by
441 -- applying the actual bounds. This routine is given an expression, Exp,
442 -- and (if necessary), replaces it using Rewrite, with a conversion to
443 -- the actual subtype, building the actual subtype if necessary. If the
444 -- expression is already of the requested type, then it is unchanged.
446 function Corresponding_Runtime_Package
(Typ
: Entity_Id
) return RTU_Id
;
447 -- Return the id of the runtime package that will provide support for
448 -- concurrent type Typ. Currently only protected types are supported,
449 -- and the returned value is one of the following:
450 -- System_Tasking_Protected_Objects
451 -- System_Tasking_Protected_Objects_Entries
452 -- System_Tasking_Protected_Objects_Single_Entry
454 function Current_Sem_Unit_Declarations
return List_Id
;
455 -- Return the place where it is fine to insert declarations for the
456 -- current semantic unit. If the unit is a package body, return the
457 -- visible declarations of the corresponding spec. For RCI stubs, this
458 -- is necessary because the point at which they are generated may not
459 -- be the earliest point at which they are used.
461 function Duplicate_Subexpr
463 Name_Req
: Boolean := False;
464 Renaming_Req
: Boolean := False) return Node_Id
;
465 -- Given the node for a subexpression, this function makes a logical copy
466 -- of the subexpression, and returns it. This is intended for use when the
467 -- expansion of an expression needs to repeat part of it. For example,
468 -- replacing a**2 by a*a requires two references to a which may be a
469 -- complex subexpression. Duplicate_Subexpr guarantees not to duplicate
470 -- side effects. If necessary, it generates actions to save the expression
471 -- value in a temporary, inserting these actions into the tree using
472 -- Insert_Actions with Exp as the insertion location. The original
473 -- expression and the returned result then become references to this saved
474 -- value. Exp must be analyzed on entry. On return, Exp is analyzed, but
475 -- the caller is responsible for analyzing the returned copy after it is
476 -- attached to the tree.
478 -- The Name_Req flag is set to ensure that the result is suitable for use
479 -- in a context requiring a name (for example, the prefix of an attribute
480 -- reference) (can't this just be a qualification in Ada 2012???).
482 -- The Renaming_Req flag is set to produce an object renaming declaration
483 -- rather than an object declaration. This is valid only if the expression
484 -- Exp designates a renamable object. This is used for example in the case
485 -- of an unchecked deallocation, to make sure the object gets set to null.
487 -- Note that if there are any run time checks in Exp, these same checks
488 -- will be duplicated in the returned duplicated expression. The two
489 -- following functions allow this behavior to be modified.
491 function Duplicate_Subexpr_No_Checks
493 Name_Req
: Boolean := False;
494 Renaming_Req
: Boolean := False;
495 Related_Id
: Entity_Id
:= Empty
;
496 Is_Low_Bound
: Boolean := False;
497 Is_High_Bound
: Boolean := False) return Node_Id
;
498 -- Identical in effect to Duplicate_Subexpr, except that Remove_Checks is
499 -- called on the result, so that the duplicated expression does not include
500 -- checks. This is appropriate for use when Exp, the original expression is
501 -- unconditionally elaborated before the duplicated expression, so that
502 -- there is no need to repeat any checks.
504 -- Related_Id denotes the entity of the context where Expr appears. Flags
505 -- Is_Low_Bound and Is_High_Bound specify whether the expression to check
506 -- is the low or the high bound of a range. These three optional arguments
507 -- signal Remove_Side_Effects to create an external symbol of the form
508 -- Chars (Related_Id)_FIRST/_LAST. For suggested use of these parameters
509 -- see the warning in the body of Sem_Ch3.Process_Range_Expr_In_Decl.
511 function Duplicate_Subexpr_Move_Checks
513 Name_Req
: Boolean := False;
514 Renaming_Req
: Boolean := False) return Node_Id
;
515 -- Identical in effect to Duplicate_Subexpr, except that Remove_Checks is
516 -- called on Exp after the duplication is complete, so that the original
517 -- expression does not include checks. In this case the result returned
518 -- (the duplicated expression) will retain the original checks. This is
519 -- appropriate for use when the duplicated expression is sure to be
520 -- elaborated before the original expression Exp, so that there is no need
521 -- to repeat the checks.
523 function Enclosing_Init_Proc
return Entity_Id
;
524 -- Obtain the entity of the type initialization procedure which encloses
525 -- the current scope. Return Empty if no such procedure exists.
527 procedure Ensure_Defined
(Typ
: Entity_Id
; N
: Node_Id
);
528 -- This procedure ensures that type referenced by Typ is defined. For the
529 -- case of a type other than an Itype, nothing needs to be done, since
530 -- all such types have declaration nodes. For Itypes, an N_Itype_Reference
531 -- node is generated and inserted as an action on node N. This is typically
532 -- used to ensure that an Itype is properly defined outside a conditional
533 -- construct when it is referenced in more than one branch.
535 function Entry_Names_OK
return Boolean;
536 -- Determine whether it is appropriate to dynamically allocate strings
537 -- which represent entry [family member] names. These strings are created
538 -- by the compiler and used by GDB.
540 procedure Evaluate_Name
(Nam
: Node_Id
);
541 -- Remove all side effects from a name which appears as part of an object
542 -- renaming declaration. Similarly to Force_Evaluation, it removes the
543 -- side effects and captures the values of the variables, except for the
544 -- variable being renamed. Hence this differs from Force_Evaluation and
545 -- Remove_Side_Effects (but it calls Force_Evaluation on subexpressions
546 -- whose value needs to be fixed).
548 procedure Evolve_And_Then
(Cond
: in out Node_Id
; Cond1
: Node_Id
);
549 -- Rewrites Cond with the expression: Cond and then Cond1. If Cond is
550 -- Empty, then simply returns Cond1 (this allows the use of Empty to
551 -- initialize a series of checks evolved by this routine, with a final
552 -- result of Empty indicating that no checks were required). The Sloc field
553 -- of the constructed N_And_Then node is copied from Cond1.
555 procedure Evolve_Or_Else
(Cond
: in out Node_Id
; Cond1
: Node_Id
);
556 -- Rewrites Cond with the expression: Cond or else Cond1. If Cond is Empty,
557 -- then simply returns Cond1 (this allows the use of Empty to initialize a
558 -- series of checks evolved by this routine, with a final result of Empty
559 -- indicating that no checks were required). The Sloc field of the
560 -- constructed N_Or_Else node is copied from Cond1.
562 function Exceptions_OK
return Boolean;
563 -- Determine whether exceptions are allowed to be caught, propagated, or
566 procedure Expand_Static_Predicates_In_Choices
(N
: Node_Id
);
567 -- N is either a case alternative or a variant. The Discrete_Choices field
568 -- of N points to a list of choices. If any of these choices is the name
569 -- of a (statically) predicated subtype, then it is rewritten as the series
570 -- of choices that correspond to the values allowed for the subtype.
572 procedure Expand_Subtype_From_Expr
574 Unc_Type
: Entity_Id
;
575 Subtype_Indic
: Node_Id
;
577 Related_Id
: Entity_Id
:= Empty
);
578 -- Build a constrained subtype from the initial value in object
579 -- declarations and/or allocations when the type is indefinite (including
580 -- class-wide). Set Related_Id to request an external name for the subtype
581 -- rather than an internal temporary.
583 function Expression_Contains_Primitives_Calls_Of
585 Typ
: Entity_Id
) return Boolean;
586 -- Return True if the expression Expr contains a nondispatching call to a
587 -- function which is a primitive of the tagged type Typ.
589 function Finalize_Address
(Typ
: Entity_Id
) return Entity_Id
;
590 -- Locate TSS primitive Finalize_Address in type Typ. Return Empty if the
591 -- subprogram is not available.
593 function Find_Interface_ADT
595 Iface
: Entity_Id
) return Elmt_Id
;
596 -- Ada 2005 (AI-251): Given a type T implementing the interface Iface,
597 -- return the element of Access_Disp_Table containing the tag of the
600 function Find_Interface_Tag
602 Iface
: Entity_Id
) return Entity_Id
;
603 -- Ada 2005 (AI-251): Given a type T and an interface Iface, return the
604 -- record component containing the tag of Iface if T implements Iface or
605 -- Empty if it does not.
607 function Find_Prim_Op
(T
: Entity_Id
; Name
: Name_Id
) return Entity_Id
;
608 -- Find the first primitive operation of a tagged type T with name Name.
609 -- This function allows the use of a primitive operation which is not
610 -- directly visible. If T is a class wide type, then the reference is to an
611 -- operation of the corresponding root type. It is an error if no primitive
612 -- operation with the given name is found.
614 function Find_Prim_Op
616 Name
: TSS_Name_Type
) return Entity_Id
;
617 -- Same as Find_Prim_Op above, except we're searching for an op that has
618 -- the form indicated by Name (i.e. is a type support subprogram with the
619 -- indicated suffix).
621 function Find_Optional_Prim_Op
622 (T
: Entity_Id
; Name
: Name_Id
) return Entity_Id
;
623 function Find_Optional_Prim_Op
625 Name
: TSS_Name_Type
) return Entity_Id
;
626 -- Same as Find_Prim_Op, except returns Empty if not found
628 function Find_Protection_Object
(Scop
: Entity_Id
) return Entity_Id
;
629 -- Traverse the scope stack starting from Scop and look for an entry, entry
630 -- family, or a subprogram that has a Protection_Object and return it. Must
631 -- always return a value since the context in which this routine is invoked
632 -- should always have a protection object.
634 function Find_Protection_Type
(Conc_Typ
: Entity_Id
) return Entity_Id
;
635 -- Given a protected type or its corresponding record, find the type of
638 function Find_Hook_Context
(N
: Node_Id
) return Node_Id
;
639 -- Determine a suitable node on which to attach actions related to N that
640 -- need to be elaborated unconditionally. In general this is the topmost
641 -- expression of which N is a subexpression, which in turn may or may not
642 -- be evaluated, for example if N is the right operand of a short circuit
645 function Following_Address_Clause
(D
: Node_Id
) return Node_Id
;
646 -- D is the node for an object declaration. This function searches the
647 -- current declarative part to look for an address clause for the object
648 -- being declared, and returns the clause if one is found, returns
651 -- Note: this function can be costly and must be invoked with special care.
652 -- Possibly we could introduce a flag at parse time indicating the presence
653 -- of an address clause to speed this up???
655 -- Note: currently this function does not scan the private part, that seems
656 -- like a potential bug ???
658 type Force_Evaluation_Mode
is (Relaxed
, Strict
);
660 procedure Force_Evaluation
662 Name_Req
: Boolean := False;
663 Related_Id
: Entity_Id
:= Empty
;
664 Is_Low_Bound
: Boolean := False;
665 Is_High_Bound
: Boolean := False;
666 Mode
: Force_Evaluation_Mode
:= Relaxed
);
667 -- Force the evaluation of the expression right away. Similar behavior
668 -- to Remove_Side_Effects when Variable_Ref is set to TRUE. That is to
669 -- say, it removes the side effects and captures the values of the
670 -- variables. Remove_Side_Effects guarantees that multiple evaluations
671 -- of the same expression won't generate multiple side effects, whereas
672 -- Force_Evaluation further guarantees that all evaluations will yield
673 -- the same result. If Mode is Relaxed then calls to this subprogram have
674 -- no effect if Exp is side-effect free; if Mode is Strict and Exp is not
675 -- a static expression then no side-effect check is performed on Exp and
676 -- temporaries are unconditionally generated.
678 -- Related_Id denotes the entity of the context where Expr appears. Flags
679 -- Is_Low_Bound and Is_High_Bound specify whether the expression to check
680 -- is the low or the high bound of a range. These three optional arguments
681 -- signal Remove_Side_Effects to create an external symbol of the form
682 -- Chars (Related_Id)_FIRST/_LAST. If Related_Id is set, then exactly one
683 -- of the Is_xxx_Bound flags must be set. For use of these parameters see
684 -- the warning in the body of Sem_Ch3.Process_Range_Expr_In_Decl.
686 function Fully_Qualified_Name_String
688 Append_NUL
: Boolean := True) return String_Id
;
689 -- Generates the string literal corresponding to the fully qualified name
690 -- of entity E, in all upper case, with an ASCII.NUL appended at the end
691 -- of the name if Append_NUL is True.
693 procedure Generate_Poll_Call
(N
: Node_Id
);
694 -- If polling is active, then a call to the Poll routine is built,
695 -- and then inserted before the given node N and analyzed.
697 procedure Get_Current_Value_Condition
701 -- This routine processes the Current_Value field of the variable Var. If
702 -- the Current_Value field is null or if it represents a known value, then
703 -- on return Cond is set to N_Empty, and Val is set to Empty.
705 -- The other case is when Current_Value points to an N_If_Statement or an
706 -- N_Elsif_Part or a N_Iteration_Scheme node (see description in Einfo for
707 -- exact details). In this case, Get_Current_Condition digs out the
708 -- condition, and then checks if the condition is known false, known true,
709 -- or not known at all. In the first two cases, Get_Current_Condition will
710 -- return with Op set to the appropriate conditional operator (inverted if
711 -- the condition is known false), and Val set to the constant value. If the
712 -- condition is not known, then Op and Val are set for the empty case
713 -- (N_Empty and Empty).
715 -- The check for whether the condition is true/false unknown depends
718 -- For an IF, the condition is known true in the THEN part, known false
719 -- in any ELSIF or ELSE part, and not known outside the IF statement in
722 -- For an ELSIF, the condition is known true in the ELSIF part, known
723 -- FALSE in any subsequent ELSIF, or ELSE part, and not known before the
724 -- ELSIF, or after the end of the IF statement.
726 -- The caller can use this result to determine the value (for the case of
727 -- N_Op_Eq), or to determine the result of some other test in other cases
728 -- (e.g. no access check required if N_Op_Ne Null).
730 function Get_Stream_Size
(E
: Entity_Id
) return Uint
;
731 -- Return the stream size value of the subtype E
733 function Has_Access_Constraint
(E
: Entity_Id
) return Boolean;
734 -- Given object or type E, determine if a discriminant is of an access type
736 function Has_Annotate_Pragma_For_External_Axiomatization
737 (E
: Entity_Id
) return Boolean;
738 -- Returns whether E is a package entity, for which the initial list of
739 -- pragmas at the start of the package declaration contains
740 -- pragma Annotate (GNATprove, External_Axiomatization);
742 function Homonym_Number
(Subp
: Entity_Id
) return Nat
;
743 -- Here subp is the entity for a subprogram. This routine returns the
744 -- homonym number used to disambiguate overloaded subprograms in the same
745 -- scope (the number is used as part of constructed names to make sure that
746 -- they are unique). The number is the ordinal position on the Homonym
747 -- chain, counting only entries in the current scope. If an entity is not
748 -- overloaded, the returned number will be one.
750 function Inside_Init_Proc
return Boolean;
751 -- Returns True if current scope is within an init proc
753 function In_Library_Level_Package_Body
(Id
: Entity_Id
) return Boolean;
754 -- Given an arbitrary entity, determine whether it appears at the library
755 -- level of a package body.
757 function In_Unconditional_Context
(Node
: Node_Id
) return Boolean;
758 -- Node is the node for a statement or a component of a statement. This
759 -- function determines if the statement appears in a context that is
760 -- unconditionally executed, i.e. it is not within a loop or a conditional
761 -- or a case statement etc.
763 function Is_All_Null_Statements
(L
: List_Id
) return Boolean;
764 -- Return True if all the items of the list are N_Null_Statement nodes.
765 -- False otherwise. True for an empty list. It is an error to call this
766 -- routine with No_List as the argument.
768 function Is_Displacement_Of_Object_Or_Function_Result
769 (Obj_Id
: Entity_Id
) return Boolean;
770 -- Determine whether Obj_Id is a source entity that has been initialized by
771 -- either a controlled function call or the assignment of another source
772 -- object. In both cases the initialization expression is rewritten as a
773 -- class-wide conversion of Ada.Tags.Displace.
775 function Is_Finalizable_Transient
777 Rel_Node
: Node_Id
) return Boolean;
778 -- Determine whether declaration Decl denotes a controlled transient which
779 -- should be finalized. Rel_Node is the related context. Even though some
780 -- transients are controlled, they may act as renamings of other objects or
783 function Is_Fully_Repped_Tagged_Type
(T
: Entity_Id
) return Boolean;
784 -- Tests given type T, and returns True if T is a non-discriminated tagged
785 -- type which has a record representation clause that specifies the layout
786 -- of all the components, including recursively components in all parent
787 -- types. We exclude discriminated types for convenience, it is extremely
788 -- unlikely that the special processing associated with the use of this
789 -- routine is useful for the case of a discriminated type, and testing for
790 -- component overlap would be a pain.
792 function Is_Library_Level_Tagged_Type
(Typ
: Entity_Id
) return Boolean;
793 -- Return True if Typ is a library level tagged type. Currently we use
794 -- this information to build statically allocated dispatch tables.
796 function Is_Non_BIP_Func_Call
(Expr
: Node_Id
) return Boolean;
797 -- Determine whether node Expr denotes a non build-in-place function call
799 function Is_Possibly_Unaligned_Object
(N
: Node_Id
) return Boolean;
800 -- Node N is an object reference. This function returns True if it is
801 -- possible that the object may not be aligned according to the normal
802 -- default alignment requirement for its type (e.g. if it appears in a
803 -- packed record, or as part of a component that has a component clause.)
805 function Is_Possibly_Unaligned_Slice
(N
: Node_Id
) return Boolean;
806 -- Determine whether the node P is a slice of an array where the slice
807 -- result may cause alignment problems because it has an alignment that
808 -- is not compatible with the type. Return True if so.
810 function Is_Ref_To_Bit_Packed_Array
(N
: Node_Id
) return Boolean;
811 -- Determine whether the node P is a reference to a bit packed array, i.e.
812 -- whether the designated object is a component of a bit packed array, or a
813 -- subcomponent of such a component. If so, then all subscripts in P are
814 -- evaluated with a call to Force_Evaluation, and True is returned.
815 -- Otherwise False is returned, and P is not affected.
817 function Is_Ref_To_Bit_Packed_Slice
(N
: Node_Id
) return Boolean;
818 -- Determine whether the node P is a reference to a bit packed slice, i.e.
819 -- whether the designated object is bit packed slice or a component of a
820 -- bit packed slice. Return True if so.
822 function Is_Related_To_Func_Return
(Id
: Entity_Id
) return Boolean;
823 -- Determine whether object Id is related to an expanded return statement.
824 -- The case concerned is "return Id.all;".
826 function Is_Renamed_Object
(N
: Node_Id
) return Boolean;
827 -- Returns True if the node N is a renamed object. An expression is
828 -- considered to be a renamed object if either it is the Name of an object
829 -- renaming declaration, or is the prefix of a name which is a renamed
830 -- object. For example, in:
832 -- x : r renames a (1 .. 2) (1);
834 -- We consider that a (1 .. 2) is a renamed object since it is the prefix
835 -- of the name in the renaming declaration.
837 function Is_Secondary_Stack_BIP_Func_Call
(Expr
: Node_Id
) return Boolean;
838 -- Determine whether Expr denotes a build-in-place function which returns
839 -- its result on the secondary stack.
841 function Is_Tag_To_Class_Wide_Conversion
842 (Obj_Id
: Entity_Id
) return Boolean;
843 -- Determine whether object Obj_Id is the result of a tag-to-class-wide
846 function Is_Untagged_Derivation
(T
: Entity_Id
) return Boolean;
847 -- Returns true if type T is not tagged and is a derived type,
848 -- or is a private type whose completion is such a type.
850 function Is_Untagged_Private_Derivation
851 (Priv_Typ
: Entity_Id
;
852 Full_Typ
: Entity_Id
) return Boolean;
853 -- Determine whether private type Priv_Typ and its full view Full_Typ
854 -- represent an untagged derivation from a private parent.
856 function Is_Volatile_Reference
(N
: Node_Id
) return Boolean;
857 -- Checks if the node N represents a volatile reference, which can be
858 -- either a direct reference to a variable treated as volatile, or an
859 -- indexed/selected component where the prefix is treated as volatile,
860 -- or has Volatile_Components set. A slice of a volatile variable is
863 procedure Kill_Dead_Code
(N
: Node_Id
; Warn
: Boolean := False);
864 -- N represents a node for a section of code that is known to be dead. Any
865 -- exception handler references and warning messages relating to this code
866 -- are removed. If Warn is True, a warning will be output at the start of N
867 -- indicating the deletion of the code. Note that the tree for the deleted
868 -- code is left intact so that e.g. cross-reference data is still valid.
870 procedure Kill_Dead_Code
(L
: List_Id
; Warn
: Boolean := False);
871 -- Like the above procedure, but applies to every element in the given
872 -- list. If Warn is True, a warning will be output at the start of N
873 -- indicating the deletion of the code.
875 function Known_Non_Negative
(Opnd
: Node_Id
) return Boolean;
876 -- Given a node for a subexpression, determines if it represents a value
877 -- that cannot possibly be negative, and if so returns True. A value of
878 -- False means that it is not known if the value is positive or negative.
880 function Make_Invariant_Call
(Expr
: Node_Id
) return Node_Id
;
881 -- Generate a call to the Invariant_Procedure associated with the type of
882 -- expression Expr. Expr is passed as an actual parameter in the call.
884 function Make_Predicate_Call
887 Mem
: Boolean := False) return Node_Id
;
888 -- Typ is a type with Predicate_Function set. This routine builds a call to
889 -- this function passing Expr as the argument, and returns it unanalyzed.
890 -- If Mem is set True, this is the special call for the membership case,
891 -- and the function called is the Predicate_Function_M if present.
893 function Make_Predicate_Check
895 Expr
: Node_Id
) return Node_Id
;
896 -- Typ is a type with Predicate_Function set. This routine builds a Check
897 -- pragma whose first argument is Predicate, and the second argument is
898 -- a call to the predicate function of Typ with Expr as the argument. If
899 -- Predicate_Check is suppressed then a null statement is returned instead.
901 function Make_Subtype_From_Expr
904 Related_Id
: Entity_Id
:= Empty
) return Node_Id
;
905 -- Returns a subtype indication corresponding to the actual type of an
906 -- expression E. Unc_Typ is an unconstrained array or record, or a class-
907 -- wide type. Set Related_Id to request an external name for the subtype
908 -- rather than an internal temporary.
910 procedure Map_Types
(Parent_Type
: Entity_Id
; Derived_Type
: Entity_Id
);
911 -- Establish the following mapping between the attributes of tagged parent
912 -- type Parent_Type and tagged derived type Derived_Type.
914 -- * Map each discriminant of Parent_Type to ether the corresponding
915 -- discriminant of Derived_Type or come constraint.
917 -- * Map each primitive operation of Parent_Type to the corresponding
918 -- primitive of Derived_Type.
920 -- The mapping Parent_Type -> Derived_Type is also added to the table in
921 -- order to prevent subsequent attempts of the same mapping.
923 function Matching_Standard_Type
(Typ
: Entity_Id
) return Entity_Id
;
924 -- Given a scalar subtype Typ, returns a matching type in standard that
925 -- has the same object size value. For example, a 16 bit signed type will
926 -- typically return Standard_Short_Integer. For fixed-point types, this
927 -- will return integer types of the corresponding size.
929 function May_Generate_Large_Temp
(Typ
: Entity_Id
) return Boolean;
930 -- Determines if the given type, Typ, may require a large temporary of the
931 -- kind that causes back-end trouble if stack checking is enabled. The
932 -- result is True only the size of the type is known at compile time and
933 -- large, where large is defined heuristically by the body of this routine.
934 -- The purpose of this routine is to help avoid generating troublesome
935 -- temporaries that interfere with stack checking mechanism. Note that the
936 -- caller has to check whether stack checking is actually enabled in order
937 -- to guide the expansion (typically of a function call).
939 function Needs_Conditional_Null_Excluding_Check
940 (Typ
: Entity_Id
) return Boolean;
941 -- Check if a type meets certain properties that require it to have a
942 -- conditional null-excluding check within its Init_Proc.
944 function Needs_Constant_Address
946 Typ
: Entity_Id
) return Boolean;
947 -- Check whether the expression in an address clause is restricted to
948 -- consist of constants, when the object has a nontrivial initialization
951 function Needs_Finalization
(Typ
: Entity_Id
) return Boolean;
952 -- Determine whether type Typ is controlled and this requires finalization
955 function Non_Limited_Designated_Type
(T
: Entity_Id
) return Entity_Id
;
956 -- An anonymous access type may designate a limited view. Check whether
957 -- non-limited view is available during expansion, to examine components
958 -- or other characteristics of the full type.
960 function OK_To_Do_Constant_Replacement
(E
: Entity_Id
) return Boolean;
961 -- This function is used when testing whether or not to replace a reference
962 -- to entity E by a known constant value. Such replacement must be done
963 -- only in a scope known to be safe for such replacements. In particular,
964 -- if we are within a subprogram and the entity E is declared outside the
965 -- subprogram then we cannot do the replacement, since we do not attempt to
966 -- trace subprogram call flow. It is also unsafe to replace statically
967 -- allocated values (since they can be modified outside the scope), and we
968 -- also inhibit replacement of Volatile or aliased objects since their
969 -- address might be captured in a way we do not detect. A value of True is
970 -- returned only if the replacement is safe.
972 function Possible_Bit_Aligned_Component
(N
: Node_Id
) return Boolean;
973 -- This function is used during processing the assignment of a record or
974 -- indexed component. The argument N is either the left hand or right hand
975 -- side of an assignment, and this function determines if there is a record
976 -- component reference where the record may be bit aligned in a manner that
977 -- causes trouble for the back end (see Component_May_Be_Bit_Aligned for
980 function Power_Of_Two
(N
: Node_Id
) return Nat
;
981 -- Determines if N is a known at compile time value which is of the form
982 -- 2**K, where K is in the range 1 .. M, where the Esize of N is 2**(M+1).
983 -- If so, returns the value K, otherwise returns zero. The caller checks
984 -- that N is of an integer type.
986 procedure Process_Statements_For_Controlled_Objects
(N
: Node_Id
);
987 -- N is a node which contains a non-handled statement list. Inspect the
988 -- statements looking for declarations of controlled objects. If at least
989 -- one such object is found, wrap the statement list in a block.
991 function Remove_Init_Call
993 Rep_Clause
: Node_Id
) return Node_Id
;
994 -- Look for init_proc call or aggregate initialization statements for
995 -- variable Var, either among declarations between that of Var and a
996 -- subsequent Rep_Clause applying to Var, or in the list of freeze actions
997 -- associated with Var, and if found, remove and return that call node.
999 procedure Remove_Side_Effects
1001 Name_Req
: Boolean := False;
1002 Renaming_Req
: Boolean := False;
1003 Variable_Ref
: Boolean := False;
1004 Related_Id
: Entity_Id
:= Empty
;
1005 Is_Low_Bound
: Boolean := False;
1006 Is_High_Bound
: Boolean := False;
1007 Check_Side_Effects
: Boolean := True);
1008 -- Given the node for a subexpression, this function replaces the node if
1009 -- necessary by an equivalent subexpression that is guaranteed to be side
1010 -- effect free. This is done by extracting any actions that could cause
1011 -- side effects, and inserting them using Insert_Actions into the tree
1012 -- to which Exp is attached. Exp must be analyzed and resolved before the
1013 -- call and is analyzed and resolved on return. Name_Req may only be set to
1014 -- True if Exp has the form of a name, and the effect is to guarantee that
1015 -- any replacement maintains the form of name. If Renaming_Req is set to
1016 -- True, the routine produces an object renaming reclaration capturing the
1017 -- expression. If Variable_Ref is set to True, a variable is considered as
1018 -- side effect (used in implementing Force_Evaluation). Note: after call to
1019 -- Remove_Side_Effects, it is safe to call New_Copy_Tree to obtain a copy
1020 -- of the resulting expression. If Check_Side_Effects is set to True then
1021 -- no action is performed if Exp is known to be side-effect free.
1023 -- Related_Id denotes the entity of the context where Expr appears. Flags
1024 -- Is_Low_Bound and Is_High_Bound specify whether the expression to check
1025 -- is the low or the high bound of a range. These three optional arguments
1026 -- signal Remove_Side_Effects to create an external symbol of the form
1027 -- Chars (Related_Id)_FIRST/_LAST. If Related_Id is set, then exactly one
1028 -- of the Is_xxx_Bound flags must be set. For use of these parameters see
1029 -- the warning in the body of Sem_Ch3.Process_Range_Expr_In_Decl.
1031 -- The side effects are captured using one of the following methods:
1033 -- 1) a constant initialized with the value of the subexpression
1034 -- 2) a renaming of the subexpression
1035 -- 3) a reference to the subexpression
1037 -- For elementary types, methods 1) and 2) are used; for composite types,
1038 -- methods 2) and 3) are used. The renaming (method 2) is used only when
1039 -- the subexpression denotes a name, so that it can be elaborated by gigi
1040 -- without evaluating the subexpression.
1042 -- Historical note: the reference (method 3) used to be the common fallback
1043 -- method but it gives rise to aliasing issues if the subexpression denotes
1044 -- a name that is not aliased, since it is equivalent to taking the address
1045 -- in this case. The renaming (method 2) used to be applied to any objects
1046 -- in the RM sense, that is to say to the cases where a renaming is legal
1047 -- in Ada. But for some of these cases, most notably functions calls, the
1048 -- renaming cannot be elaborated without evaluating the subexpression, so
1049 -- gigi would resort to method 1) or 3) under the hood for them.
1051 procedure Replace_References
1053 Par_Typ
: Entity_Id
;
1054 Deriv_Typ
: Entity_Id
;
1055 Par_Obj
: Entity_Id
:= Empty
;
1056 Deriv_Obj
: Entity_Id
:= Empty
);
1057 -- Expr denotes an arbitrary expression. Par_Typ is a tagged parent type
1058 -- in a type hierarchy. Deriv_Typ is a tagged type derived from Par_Typ
1059 -- with optional ancestors in between. Par_Obj is a formal parameter
1060 -- which emulates the current instance of Par_Typ. Deriv_Obj is a formal
1061 -- parameter which emulates the current instance of Deriv_Typ. Perform the
1062 -- following substitutions in Expr:
1064 -- * Replace a reference to Par_Obj with a reference to Deriv_Obj
1066 -- * Replace a reference to a discriminant of Par_Typ with a suitable
1067 -- value from the point of view of Deriv_Typ.
1069 -- * Replace a call to an overridden primitive of Par_Typ with a call to
1070 -- an overriding primitive of Deriv_Typ.
1072 -- * Replace a call to an inherited primitive of Par_Type with a call to
1073 -- the internally-generated inherited primitive of Deriv_Typ.
1075 procedure Replace_Type_References
1078 Obj_Id
: Entity_Id
);
1079 -- Substitute all references of the current instance of type Typ with
1080 -- references to formal parameter Obj_Id within expression Expr.
1082 function Represented_As_Scalar
(T
: Entity_Id
) return Boolean;
1083 -- Returns True iff the implementation of this type in code generation
1084 -- terms is scalar. This is true for scalars in the Ada sense, and for
1085 -- packed arrays which are represented by a scalar (modular) type.
1087 function Requires_Cleanup_Actions
1089 Lib_Level
: Boolean) return Boolean;
1090 -- Given a node N, determine whether its declarative and/or statement list
1091 -- contains one of the following:
1093 -- 1) controlled objects
1094 -- 2) library-level tagged types
1096 -- These cases require special actions on scope exit. The flag Lib_Level
1097 -- is set True if the construct is at library level, and False otherwise.
1099 function Safe_Unchecked_Type_Conversion
(Exp
: Node_Id
) return Boolean;
1100 -- Given the node for an N_Unchecked_Type_Conversion, return True if this
1101 -- is an unchecked conversion that Gigi can handle directly. Otherwise
1102 -- return False if it is one for which the front end must provide a
1103 -- temporary. Note that the node need not be analyzed, and thus the Etype
1104 -- field may not be set, but in that case it must be the case that the
1105 -- Subtype_Mark field of the node is set/analyzed.
1107 procedure Set_Current_Value_Condition
(Cnode
: Node_Id
);
1108 -- Cnode is N_If_Statement, N_Elsif_Part, or N_Iteration_Scheme (the latter
1109 -- when a WHILE condition is present). This call checks whether Condition
1110 -- (Cnode) has embedded expressions of a form that should result in setting
1111 -- the Current_Value field of one or more entities, and if so sets these
1112 -- fields to point to Cnode.
1114 procedure Set_Elaboration_Flag
(N
: Node_Id
; Spec_Id
: Entity_Id
);
1115 -- N is the node for a subprogram or generic body, and Spec_Id is the
1116 -- entity for the corresponding spec. If an elaboration entity is defined,
1117 -- then this procedure generates an assignment statement to set it True,
1118 -- immediately after the body is elaborated. However, no assignment is
1119 -- generated in the case of library level procedures, since the setting of
1120 -- the flag in this case is generated in the binder. We do that so that we
1121 -- can detect cases where this is the only elaboration action that is
1124 procedure Set_Renamed_Subprogram
(N
: Node_Id
; E
: Entity_Id
);
1125 -- N is an node which is an entity name that represents the name of a
1126 -- renamed subprogram. The node is rewritten to be an identifier that
1127 -- refers directly to the renamed subprogram, given by entity E.
1129 function Side_Effect_Free
1131 Name_Req
: Boolean := False;
1132 Variable_Ref
: Boolean := False) return Boolean;
1133 -- Determines if the tree N represents an expression that is known not
1134 -- to have side effects. If this function returns True, then for example
1135 -- a call to Remove_Side_Effects has no effect.
1137 -- Name_Req controls the handling of volatile variable references. If
1138 -- Name_Req is False (the normal case), then volatile references are
1139 -- considered to be side effects. If Name_Req is True, then volatility
1140 -- of variables is ignored.
1142 -- If Variable_Ref is True, then all variable references are considered to
1143 -- be side effects (regardless of volatility or the setting of Name_Req).
1145 function Side_Effect_Free
1147 Name_Req
: Boolean := False;
1148 Variable_Ref
: Boolean := False) return Boolean;
1149 -- Determines if all elements of the list L are side-effect free. Name_Req
1150 -- and Variable_Ref are as described above.
1152 procedure Silly_Boolean_Array_Not_Test
(N
: Node_Id
; T
: Entity_Id
);
1153 -- N is the node for a boolean array NOT operation, and T is the type of
1154 -- the array. This routine deals with the silly case where the subtype of
1155 -- the boolean array is False..False or True..True, where it is required
1156 -- that a Constraint_Error exception be raised (RM 4.5.6(6)).
1158 procedure Silly_Boolean_Array_Xor_Test
1162 -- N is the node for a boolean array XOR operation, T is the type of the
1163 -- array, and R is a copy of the right operand of N, required to prevent
1164 -- scope anomalies when unnesting is in effect. This routine deals with
1165 -- the admitedly silly case where the subtype of the boolean array is
1166 -- True..True, where a raise of a Constraint_Error exception is required
1167 -- (RM 4.5.6(6)) and ACATS-tested.
1169 function Target_Has_Fixed_Ops
1170 (Left_Typ
: Entity_Id
;
1171 Right_Typ
: Entity_Id
;
1172 Result_Typ
: Entity_Id
) return Boolean;
1173 -- Returns True if and only if the target machine has direct support
1174 -- for fixed-by-fixed multiplications and divisions for the given
1175 -- operand and result types. This is called in package Exp_Fixd to
1176 -- determine whether to expand such operations.
1178 function Type_May_Have_Bit_Aligned_Components
1179 (Typ
: Entity_Id
) return Boolean;
1180 -- Determines if Typ is a composite type that has within it (looking down
1181 -- recursively at any subcomponents), a record type which has component
1182 -- that may be bit aligned (see Possible_Bit_Aligned_Component). The result
1183 -- is conservative, in that a result of False is decisive. A result of True
1184 -- means that such a component may or may not be present.
1186 procedure Update_Primitives_Mapping
1187 (Inher_Id
: Entity_Id
;
1188 Subp_Id
: Entity_Id
);
1189 -- Map primitive operations of the parent type to the corresponding
1190 -- operations of the descendant. Note that the descendant type may not be
1191 -- frozen yet, so we cannot use the dispatch table directly. This is called
1192 -- when elaborating a contract for a subprogram, and when freezing a type
1193 -- extension to verify legality rules on inherited conditions.
1195 function Within_Case_Or_If_Expression
(N
: Node_Id
) return Boolean;
1196 -- Determine whether arbitrary node N is within a case or an if expression
1198 function Within_Internal_Subprogram
return Boolean;
1199 -- Indicates that some expansion is taking place within the body of a
1200 -- predefined primitive operation. Some expansion activity (e.g. predicate
1201 -- checks) is disabled in such. Because we want to detect invalid uses
1202 -- of function calls within predicates (which lead to infinite recursion)
1203 -- predicate functions themselves are not considered internal here.
1206 pragma Inline
(Duplicate_Subexpr
);
1207 pragma Inline
(Force_Evaluation
);
1208 pragma Inline
(Is_Library_Level_Tagged_Type
);