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