File : exp_util.ads
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-2016, 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 procedure Build_Procedure_Form (N : Node_Id);
242 -- Create a procedure declaration which emulates the behavior of a function
243 -- that returns an array type, for C-compatible generation.
244
245 function Build_Runtime_Call (Loc : Source_Ptr; RE : RE_Id) return Node_Id;
246 -- Build an N_Procedure_Call_Statement calling the given runtime entity.
247 -- The call has no parameters. The first argument provides the location
248 -- information for the tree and for error messages. The call node is not
249 -- analyzed on return, the caller is responsible for analyzing it.
250
251 function Build_SS_Mark_Call
252 (Loc : Source_Ptr;
253 Mark : Entity_Id) return Node_Id;
254 -- Build a call to routine System.Secondary_Stack.Mark. Mark denotes the
255 -- entity of the secondary stack mark.
256
257 function Build_SS_Release_Call
258 (Loc : Source_Ptr;
259 Mark : Entity_Id) return Node_Id;
260 -- Build a call to routine System.Secondary_Stack.Release. Mark denotes the
261 -- entity of the secondary stack mark.
262
263 function Build_Task_Image_Decls
264 (Loc : Source_Ptr;
265 Id_Ref : Node_Id;
266 A_Type : Entity_Id;
267 In_Init_Proc : Boolean := False) return List_Id;
268 -- Build declaration for a variable that holds an identifying string to be
269 -- used as a task name. Id_Ref is an identifier if the task is a variable,
270 -- and a selected or indexed component if the task is component of an
271 -- object. If it is an indexed component, A_Type is the corresponding array
272 -- type. Its index types are used to build the string as an image of the
273 -- index values. For composite types, the result includes two declarations:
274 -- one for a generated function that computes the image without using
275 -- concatenation, and one for the variable that holds the result.
276 --
277 -- If In_Init_Proc is true, the call is part of the initialization of
278 -- a component of a composite type, and the enclosing initialization
279 -- procedure must be flagged as using the secondary stack. If In_Init_Proc
280 -- is false, the call is for a stand-alone object, and the generated
281 -- function itself must do its own cleanups.
282
283 procedure Check_Float_Op_Overflow (N : Node_Id);
284 -- Called where we could have a floating-point binary operator where we
285 -- must check for infinities if we are operating in Check_Float_Overflow
286 -- mode. Note that we don't need to worry about unary operator cases,
287 -- since for floating-point, abs, unary "-", and unary "+" can never
288 -- case overflow.
289
290 function Component_May_Be_Bit_Aligned (Comp : Entity_Id) return Boolean;
291 -- This function is in charge of detecting record components that may
292 -- cause trouble in the back end if an attempt is made to assign the
293 -- component. The back end can handle such assignments with no problem if
294 -- the components involved are small (64-bits or less) records or scalar
295 -- items (including bit-packed arrays represented with modular types) or
296 -- are both aligned on a byte boundary (starting on a byte boundary, and
297 -- occupying an integral number of bytes).
298 --
299 -- However, problems arise for records larger than 64 bits, or for arrays
300 -- (other than bit-packed arrays represented with a modular type) if the
301 -- component starts on a non-byte boundary, or does not occupy an integral
302 -- number of bytes (i.e. there are some bits possibly shared with fields
303 -- at the start or beginning of the component). The back end cannot handle
304 -- loading and storing such components in a single operation.
305 --
306 -- This function is used to detect the troublesome situation. it is
307 -- conservative in the sense that it produces True unless it knows for
308 -- sure that the component is safe (as outlined in the first paragraph
309 -- above). The code generation for record and array assignment checks for
310 -- trouble using this function, and if so the assignment is generated
311 -- component-wise, which the back end is required to handle correctly.
312 --
313 -- Note that in GNAT 3, the back end will reject such components anyway,
314 -- so the hard work in checking for this case is wasted in GNAT 3, but
315 -- it is harmless, so it is easier to do it in all cases, rather than
316 -- conditionalize it in GNAT 5 or beyond.
317
318 function Containing_Package_With_Ext_Axioms
319 (E : Entity_Id) return Entity_Id;
320 -- Returns the package entity with an external axiomatization containing E,
321 -- if any, or Empty if none.
322
323 procedure Convert_To_Actual_Subtype (Exp : Node_Id);
324 -- The Etype of an expression is the nominal type of the expression,
325 -- not the actual subtype. Often these are the same, but not always.
326 -- For example, a reference to a formal of unconstrained type has the
327 -- unconstrained type as its Etype, but the actual subtype is obtained by
328 -- applying the actual bounds. This routine is given an expression, Exp,
329 -- and (if necessary), replaces it using Rewrite, with a conversion to
330 -- the actual subtype, building the actual subtype if necessary. If the
331 -- expression is already of the requested type, then it is unchanged.
332
333 function Corresponding_Runtime_Package (Typ : Entity_Id) return RTU_Id;
334 -- Return the id of the runtime package that will provide support for
335 -- concurrent type Typ. Currently only protected types are supported,
336 -- and the returned value is one of the following:
337 -- System_Tasking_Protected_Objects
338 -- System_Tasking_Protected_Objects_Entries
339 -- System_Tasking_Protected_Objects_Single_Entry
340
341 function Current_Sem_Unit_Declarations return List_Id;
342 -- Return the place where it is fine to insert declarations for the
343 -- current semantic unit. If the unit is a package body, return the
344 -- visible declarations of the corresponding spec. For RCI stubs, this
345 -- is necessary because the point at which they are generated may not
346 -- be the earliest point at which they are used.
347
348 function Duplicate_Subexpr
349 (Exp : Node_Id;
350 Name_Req : Boolean := False;
351 Renaming_Req : Boolean := False) return Node_Id;
352 -- Given the node for a subexpression, this function makes a logical copy
353 -- of the subexpression, and returns it. This is intended for use when the
354 -- expansion of an expression needs to repeat part of it. For example,
355 -- replacing a**2 by a*a requires two references to a which may be a
356 -- complex subexpression. Duplicate_Subexpr guarantees not to duplicate
357 -- side effects. If necessary, it generates actions to save the expression
358 -- value in a temporary, inserting these actions into the tree using
359 -- Insert_Actions with Exp as the insertion location. The original
360 -- expression and the returned result then become references to this saved
361 -- value. Exp must be analyzed on entry. On return, Exp is analyzed, but
362 -- the caller is responsible for analyzing the returned copy after it is
363 -- attached to the tree.
364 --
365 -- The Name_Req flag is set to ensure that the result is suitable for use
366 -- in a context requiring a name (for example, the prefix of an attribute
367 -- reference) (can't this just be a qualification in Ada 2012???).
368 --
369 -- The Renaming_Req flag is set to produce an object renaming declaration
370 -- rather than an object declaration. This is valid only if the expression
371 -- Exp designates a renamable object. This is used for example in the case
372 -- of an unchecked deallocation, to make sure the object gets set to null.
373 --
374 -- Note that if there are any run time checks in Exp, these same checks
375 -- will be duplicated in the returned duplicated expression. The two
376 -- following functions allow this behavior to be modified.
377
378 function Duplicate_Subexpr_No_Checks
379 (Exp : Node_Id;
380 Name_Req : Boolean := False;
381 Renaming_Req : Boolean := False;
382 Related_Id : Entity_Id := Empty;
383 Is_Low_Bound : Boolean := False;
384 Is_High_Bound : Boolean := False) return Node_Id;
385 -- Identical in effect to Duplicate_Subexpr, except that Remove_Checks is
386 -- called on the result, so that the duplicated expression does not include
387 -- checks. This is appropriate for use when Exp, the original expression is
388 -- unconditionally elaborated before the duplicated expression, so that
389 -- there is no need to repeat any checks.
390 --
391 -- Related_Id denotes the entity of the context where Expr appears. Flags
392 -- Is_Low_Bound and Is_High_Bound specify whether the expression to check
393 -- is the low or the high bound of a range. These three optional arguments
394 -- signal Remove_Side_Effects to create an external symbol of the form
395 -- Chars (Related_Id)_FIRST/_LAST. For suggested use of these parameters
396 -- see the warning in the body of Sem_Ch3.Process_Range_Expr_In_Decl.
397
398 function Duplicate_Subexpr_Move_Checks
399 (Exp : Node_Id;
400 Name_Req : Boolean := False;
401 Renaming_Req : Boolean := False) return Node_Id;
402 -- Identical in effect to Duplicate_Subexpr, except that Remove_Checks is
403 -- called on Exp after the duplication is complete, so that the original
404 -- expression does not include checks. In this case the result returned
405 -- (the duplicated expression) will retain the original checks. This is
406 -- appropriate for use when the duplicated expression is sure to be
407 -- elaborated before the original expression Exp, so that there is no need
408 -- to repeat the checks.
409
410 procedure Ensure_Defined (Typ : Entity_Id; N : Node_Id);
411 -- This procedure ensures that type referenced by Typ is defined. For the
412 -- case of a type other than an Itype, nothing needs to be done, since
413 -- all such types have declaration nodes. For Itypes, an N_Itype_Reference
414 -- node is generated and inserted as an action on node N. This is typically
415 -- used to ensure that an Itype is properly defined outside a conditional
416 -- construct when it is referenced in more than one branch.
417
418 function Entry_Names_OK return Boolean;
419 -- Determine whether it is appropriate to dynamically allocate strings
420 -- which represent entry [family member] names. These strings are created
421 -- by the compiler and used by GDB.
422
423 procedure Evaluate_Name (Nam : Node_Id);
424 -- Remove all side effects from a name which appears as part of an object
425 -- renaming declaration. More comments are needed here that explain how
426 -- this differs from Force_Evaluation and Remove_Side_Effects ???
427
428 procedure Evolve_And_Then (Cond : in out Node_Id; Cond1 : Node_Id);
429 -- Rewrites Cond with the expression: Cond and then Cond1. If Cond is
430 -- Empty, then simply returns Cond1 (this allows the use of Empty to
431 -- initialize a series of checks evolved by this routine, with a final
432 -- result of Empty indicating that no checks were required). The Sloc field
433 -- of the constructed N_And_Then node is copied from Cond1.
434
435 procedure Evolve_Or_Else (Cond : in out Node_Id; Cond1 : Node_Id);
436 -- Rewrites Cond with the expression: Cond or else Cond1. If Cond is Empty,
437 -- then simply returns Cond1 (this allows the use of Empty to initialize a
438 -- series of checks evolved by this routine, with a final result of Empty
439 -- indicating that no checks were required). The Sloc field of the
440 -- constructed N_Or_Else node is copied from Cond1.
441
442 procedure Expand_Static_Predicates_In_Choices (N : Node_Id);
443 -- N is either a case alternative or a variant. The Discrete_Choices field
444 -- of N points to a list of choices. If any of these choices is the name
445 -- of a (statically) predicated subtype, then it is rewritten as the series
446 -- of choices that correspond to the values allowed for the subtype.
447
448 procedure Expand_Subtype_From_Expr
449 (N : Node_Id;
450 Unc_Type : Entity_Id;
451 Subtype_Indic : Node_Id;
452 Exp : Node_Id;
453 Related_Id : Entity_Id := Empty);
454 -- Build a constrained subtype from the initial value in object
455 -- declarations and/or allocations when the type is indefinite (including
456 -- class-wide). Set Related_Id to request an external name for the subtype
457 -- rather than an internal temporary.
458
459 function Finalize_Address (Typ : Entity_Id) return Entity_Id;
460 -- Locate TSS primitive Finalize_Address in type Typ. Return Empty if the
461 -- subprogram is not available.
462
463 function Find_Interface_ADT
464 (T : Entity_Id;
465 Iface : Entity_Id) return Elmt_Id;
466 -- Ada 2005 (AI-251): Given a type T implementing the interface Iface,
467 -- return the element of Access_Disp_Table containing the tag of the
468 -- interface.
469
470 function Find_Interface_Tag
471 (T : Entity_Id;
472 Iface : Entity_Id) return Entity_Id;
473 -- Ada 2005 (AI-251): Given a type T implementing the interface Iface,
474 -- return the record component containing the tag of Iface.
475
476 function Find_Prim_Op (T : Entity_Id; Name : Name_Id) return Entity_Id;
477 -- Find the first primitive operation of a tagged type T with name Name.
478 -- This function allows the use of a primitive operation which is not
479 -- directly visible. If T is a class wide type, then the reference is to an
480 -- operation of the corresponding root type. It is an error if no primitive
481 -- operation with the given name is found.
482
483 function Find_Prim_Op
484 (T : Entity_Id;
485 Name : TSS_Name_Type) return Entity_Id;
486 -- Find the first primitive operation of type T whose name has the form
487 -- indicated by the name parameter (i.e. is a type support subprogram
488 -- with the indicated suffix). This function allows use of a primitive
489 -- operation which is not directly visible. If T is a class wide type,
490 -- then the reference is to an operation of the corresponding root type.
491
492 function Find_Optional_Prim_Op
493 (T : Entity_Id; Name : Name_Id) return Entity_Id;
494 function Find_Optional_Prim_Op
495 (T : Entity_Id;
496 Name : TSS_Name_Type) return Entity_Id;
497 -- Same as Find_Prim_Op, except returns Empty if not found
498
499 function Find_Protection_Object (Scop : Entity_Id) return Entity_Id;
500 -- Traverse the scope stack starting from Scop and look for an entry, entry
501 -- family, or a subprogram that has a Protection_Object and return it. Must
502 -- always return a value since the context in which this routine is invoked
503 -- should always have a protection object.
504
505 function Find_Protection_Type (Conc_Typ : Entity_Id) return Entity_Id;
506 -- Given a protected type or its corresponding record, find the type of
507 -- field _object.
508
509 function Find_Hook_Context (N : Node_Id) return Node_Id;
510 -- Determine a suitable node on which to attach actions related to N that
511 -- need to be elaborated unconditionally. In general this is the topmost
512 -- expression of which N is a subexpression, which in turn may or may not
513 -- be evaluated, for example if N is the right operand of a short circuit
514 -- operator.
515
516 function Following_Address_Clause (D : Node_Id) return Node_Id;
517 -- D is the node for an object declaration. This function searches the
518 -- current declarative part to look for an address clause for the object
519 -- being declared, and returns the clause if one is found, returns
520 -- Empty otherwise.
521 --
522 -- Note: this function can be costly and must be invoked with special care.
523 -- Possibly we could introduce a flag at parse time indicating the presence
524 -- of an address clause to speed this up???
525 --
526 -- Note: currently this function does not scan the private part, that seems
527 -- like a potential bug ???
528
529 type Force_Evaluation_Mode is (Relaxed, Strict);
530
531 procedure Force_Evaluation
532 (Exp : Node_Id;
533 Name_Req : Boolean := False;
534 Related_Id : Entity_Id := Empty;
535 Is_Low_Bound : Boolean := False;
536 Is_High_Bound : Boolean := False;
537 Mode : Force_Evaluation_Mode := Relaxed);
538 -- Force the evaluation of the expression right away. Similar behavior
539 -- to Remove_Side_Effects when Variable_Ref is set to TRUE. That is to
540 -- say, it removes the side effects and captures the values of the
541 -- variables. Remove_Side_Effects guarantees that multiple evaluations
542 -- of the same expression won't generate multiple side effects, whereas
543 -- Force_Evaluation further guarantees that all evaluations will yield
544 -- the same result. If Mode is Relaxed then calls to this subprogram have
545 -- no effect if Exp is side-effect free; if Mode is Strict and Exp is not
546 -- a static expression then no side-effect check is performed on Exp and
547 -- temporaries are unconditionally generated.
548 --
549 -- Related_Id denotes the entity of the context where Expr appears. Flags
550 -- Is_Low_Bound and Is_High_Bound specify whether the expression to check
551 -- is the low or the high bound of a range. These three optional arguments
552 -- signal Remove_Side_Effects to create an external symbol of the form
553 -- Chars (Related_Id)_FIRST/_LAST. If Related_Id is set, then exactly one
554 -- of the Is_xxx_Bound flags must be set. For use of these parameters see
555 -- the warning in the body of Sem_Ch3.Process_Range_Expr_In_Decl.
556
557 function Fully_Qualified_Name_String
558 (E : Entity_Id;
559 Append_NUL : Boolean := True) return String_Id;
560 -- Generates the string literal corresponding to the fully qualified name
561 -- of entity E, in all upper case, with an ASCII.NUL appended at the end
562 -- of the name if Append_NUL is True.
563
564 procedure Generate_Poll_Call (N : Node_Id);
565 -- If polling is active, then a call to the Poll routine is built,
566 -- and then inserted before the given node N and analyzed.
567
568 procedure Get_Current_Value_Condition
569 (Var : Node_Id;
570 Op : out Node_Kind;
571 Val : out Node_Id);
572 -- This routine processes the Current_Value field of the variable Var. If
573 -- the Current_Value field is null or if it represents a known value, then
574 -- on return Cond is set to N_Empty, and Val is set to Empty.
575 --
576 -- The other case is when Current_Value points to an N_If_Statement or an
577 -- N_Elsif_Part or a N_Iteration_Scheme node (see description in Einfo for
578 -- exact details). In this case, Get_Current_Condition digs out the
579 -- condition, and then checks if the condition is known false, known true,
580 -- or not known at all. In the first two cases, Get_Current_Condition will
581 -- return with Op set to the appropriate conditional operator (inverted if
582 -- the condition is known false), and Val set to the constant value. If the
583 -- condition is not known, then Op and Val are set for the empty case
584 -- (N_Empty and Empty).
585 --
586 -- The check for whether the condition is true/false unknown depends
587 -- on the case:
588 --
589 -- For an IF, the condition is known true in the THEN part, known false
590 -- in any ELSIF or ELSE part, and not known outside the IF statement in
591 -- question.
592 --
593 -- For an ELSIF, the condition is known true in the ELSIF part, known
594 -- FALSE in any subsequent ELSIF, or ELSE part, and not known before the
595 -- ELSIF, or after the end of the IF statement.
596 --
597 -- The caller can use this result to determine the value (for the case of
598 -- N_Op_Eq), or to determine the result of some other test in other cases
599 -- (e.g. no access check required if N_Op_Ne Null).
600
601 function Get_Stream_Size (E : Entity_Id) return Uint;
602 -- Return the stream size value of the subtype E
603
604 function Has_Access_Constraint (E : Entity_Id) return Boolean;
605 -- Given object or type E, determine if a discriminant is of an access type
606
607 function Has_Annotate_Pragma_For_External_Axiomatization
608 (E : Entity_Id) return Boolean;
609 -- Returns whether E is a package entity, for which the initial list of
610 -- pragmas at the start of the package declaration contains
611 -- pragma Annotate (GNATprove, External_Axiomatization);
612
613 function Homonym_Number (Subp : Entity_Id) return Nat;
614 -- Here subp is the entity for a subprogram. This routine returns the
615 -- homonym number used to disambiguate overloaded subprograms in the same
616 -- scope (the number is used as part of constructed names to make sure that
617 -- they are unique). The number is the ordinal position on the Homonym
618 -- chain, counting only entries in the current scope. If an entity is not
619 -- overloaded, the returned number will be one.
620
621 function Inside_Init_Proc return Boolean;
622 -- Returns True if current scope is within an init proc
623
624 function In_Library_Level_Package_Body (Id : Entity_Id) return Boolean;
625 -- Given an arbitrary entity, determine whether it appears at the library
626 -- level of a package body.
627
628 function In_Unconditional_Context (Node : Node_Id) return Boolean;
629 -- Node is the node for a statement or a component of a statement. This
630 -- function determines if the statement appears in a context that is
631 -- unconditionally executed, i.e. it is not within a loop or a conditional
632 -- or a case statement etc.
633
634 function Is_All_Null_Statements (L : List_Id) return Boolean;
635 -- Return True if all the items of the list are N_Null_Statement nodes.
636 -- False otherwise. True for an empty list. It is an error to call this
637 -- routine with No_List as the argument.
638
639 function Is_Displacement_Of_Object_Or_Function_Result
640 (Obj_Id : Entity_Id) return Boolean;
641 -- Determine whether Obj_Id is a source entity that has been initialized by
642 -- either a controlled function call or the assignment of another source
643 -- object. In both cases the initialization expression is rewritten as a
644 -- class-wide conversion of Ada.Tags.Displace.
645
646 function Is_Finalizable_Transient
647 (Decl : Node_Id;
648 Rel_Node : Node_Id) return Boolean;
649 -- Determine whether declaration Decl denotes a controlled transient which
650 -- should be finalized. Rel_Node is the related context. Even though some
651 -- transients are controlled, they may act as renamings of other objects or
652 -- function calls.
653
654 function Is_Fully_Repped_Tagged_Type (T : Entity_Id) return Boolean;
655 -- Tests given type T, and returns True if T is a non-discriminated tagged
656 -- type which has a record representation clause that specifies the layout
657 -- of all the components, including recursively components in all parent
658 -- types. We exclude discriminated types for convenience, it is extremely
659 -- unlikely that the special processing associated with the use of this
660 -- routine is useful for the case of a discriminated type, and testing for
661 -- component overlap would be a pain.
662
663 function Is_Library_Level_Tagged_Type (Typ : Entity_Id) return Boolean;
664 -- Return True if Typ is a library level tagged type. Currently we use
665 -- this information to build statically allocated dispatch tables.
666
667 function Is_Non_BIP_Func_Call (Expr : Node_Id) return Boolean;
668 -- Determine whether node Expr denotes a non build-in-place function call
669
670 function Is_Object_Access_BIP_Func_Call
671 (Expr : Node_Id;
672 Obj_Id : Entity_Id) return Boolean;
673 -- Determine if Expr denotes a build-in-place function which stores its
674 -- result in the BIPaccess actual parameter whose prefix must match Obj_Id.
675
676 function Is_Possibly_Unaligned_Object (N : Node_Id) return Boolean;
677 -- Node N is an object reference. This function returns True if it is
678 -- possible that the object may not be aligned according to the normal
679 -- default alignment requirement for its type (e.g. if it appears in a
680 -- packed record, or as part of a component that has a component clause.)
681
682 function Is_Possibly_Unaligned_Slice (N : Node_Id) return Boolean;
683 -- Determine whether the node P is a slice of an array where the slice
684 -- result may cause alignment problems because it has an alignment that
685 -- is not compatible with the type. Return True if so.
686
687 function Is_Ref_To_Bit_Packed_Array (N : Node_Id) return Boolean;
688 -- Determine whether the node P is a reference to a bit packed array, i.e.
689 -- whether the designated object is a component of a bit packed array, or a
690 -- subcomponent of such a component. If so, then all subscripts in P are
691 -- evaluated with a call to Force_Evaluation, and True is returned.
692 -- Otherwise False is returned, and P is not affected.
693
694 function Is_Ref_To_Bit_Packed_Slice (N : Node_Id) return Boolean;
695 -- Determine whether the node P is a reference to a bit packed slice, i.e.
696 -- whether the designated object is bit packed slice or a component of a
697 -- bit packed slice. Return True if so.
698
699 function Is_Related_To_Func_Return (Id : Entity_Id) return Boolean;
700 -- Determine whether object Id is related to an expanded return statement.
701 -- The case concerned is "return Id.all;".
702
703 function Is_Renamed_Object (N : Node_Id) return Boolean;
704 -- Returns True if the node N is a renamed object. An expression is
705 -- considered to be a renamed object if either it is the Name of an object
706 -- renaming declaration, or is the prefix of a name which is a renamed
707 -- object. For example, in:
708 --
709 -- x : r renames a (1 .. 2) (1);
710 --
711 -- We consider that a (1 .. 2) is a renamed object since it is the prefix
712 -- of the name in the renaming declaration.
713
714 function Is_Secondary_Stack_BIP_Func_Call (Expr : Node_Id) return Boolean;
715 -- Determine whether Expr denotes a build-in-place function which returns
716 -- its result on the secondary stack.
717
718 function Is_Tag_To_Class_Wide_Conversion
719 (Obj_Id : Entity_Id) return Boolean;
720 -- Determine whether object Obj_Id is the result of a tag-to-class-wide
721 -- type conversion.
722
723 function Is_Untagged_Derivation (T : Entity_Id) return Boolean;
724 -- Returns true if type T is not tagged and is a derived type,
725 -- or is a private type whose completion is such a type.
726
727 function Is_Volatile_Reference (N : Node_Id) return Boolean;
728 -- Checks if the node N represents a volatile reference, which can be
729 -- either a direct reference to a variable treated as volatile, or an
730 -- indexed/selected component where the prefix is treated as volatile,
731 -- or has Volatile_Components set. A slice of a volatile variable is
732 -- also volatile.
733
734 procedure Kill_Dead_Code (N : Node_Id; Warn : Boolean := False);
735 -- N represents a node for a section of code that is known to be dead. Any
736 -- exception handler references and warning messages relating to this code
737 -- are removed. If Warn is True, a warning will be output at the start of N
738 -- indicating the deletion of the code. Note that the tree for the deleted
739 -- code is left intact so that e.g. cross-reference data is still valid.
740
741 procedure Kill_Dead_Code (L : List_Id; Warn : Boolean := False);
742 -- Like the above procedure, but applies to every element in the given
743 -- list. If Warn is True, a warning will be output at the start of N
744 -- indicating the deletion of the code.
745
746 function Known_Non_Negative (Opnd : Node_Id) return Boolean;
747 -- Given a node for a subexpression, determines if it represents a value
748 -- that cannot possibly be negative, and if so returns True. A value of
749 -- False means that it is not known if the value is positive or negative.
750
751 function Known_Non_Null (N : Node_Id) return Boolean;
752 -- Given a node N for a subexpression of an access type, determines if
753 -- this subexpression yields a value that is known at compile time to
754 -- be non-null and returns True if so. Returns False otherwise. It is
755 -- an error to call this function if N is not of an access type.
756
757 function Known_Null (N : Node_Id) return Boolean;
758 -- Given a node N for a subexpression of an access type, determines if this
759 -- subexpression yields a value that is known at compile time to be null
760 -- and returns True if so. Returns False otherwise. It is an error to call
761 -- this function if N is not of an access type.
762
763 function Make_Invariant_Call (Expr : Node_Id) return Node_Id;
764 -- Expr is an object of a type which Has_Invariants set (and which thus
765 -- also has an Invariant_Procedure set). If invariants are enabled, this
766 -- function returns a call to the Invariant procedure passing Expr as the
767 -- argument, and returns it unanalyzed. If invariants are not enabled,
768 -- returns a null statement.
769
770 function Make_Predicate_Call
771 (Typ : Entity_Id;
772 Expr : Node_Id;
773 Mem : Boolean := False) return Node_Id;
774 -- Typ is a type with Predicate_Function set. This routine builds a call to
775 -- this function passing Expr as the argument, and returns it unanalyzed.
776 -- If Mem is set True, this is the special call for the membership case,
777 -- and the function called is the Predicate_Function_M if present.
778
779 function Make_Predicate_Check
780 (Typ : Entity_Id;
781 Expr : Node_Id) return Node_Id;
782 -- Typ is a type with Predicate_Function set. This routine builds a Check
783 -- pragma whose first argument is Predicate, and the second argument is
784 -- a call to the predicate function of Typ with Expr as the argument. If
785 -- Predicate_Check is suppressed then a null statement is returned instead.
786
787 function Make_Subtype_From_Expr
788 (E : Node_Id;
789 Unc_Typ : Entity_Id;
790 Related_Id : Entity_Id := Empty) return Node_Id;
791 -- Returns a subtype indication corresponding to the actual type of an
792 -- expression E. Unc_Typ is an unconstrained array or record, or a class-
793 -- wide type. Set Related_Id to request an external name for the subtype
794 -- rather than an internal temporary.
795
796 function Matching_Standard_Type (Typ : Entity_Id) return Entity_Id;
797 -- Given a scalar subtype Typ, returns a matching type in standard that
798 -- has the same object size value. For example, a 16 bit signed type will
799 -- typically return Standard_Short_Integer. For fixed-point types, this
800 -- will return integer types of the corresponding size.
801
802 function May_Generate_Large_Temp (Typ : Entity_Id) return Boolean;
803 -- Determines if the given type, Typ, may require a large temporary of the
804 -- kind that causes back-end trouble if stack checking is enabled. The
805 -- result is True only the size of the type is known at compile time and
806 -- large, where large is defined heuristically by the body of this routine.
807 -- The purpose of this routine is to help avoid generating troublesome
808 -- temporaries that interfere with stack checking mechanism. Note that the
809 -- caller has to check whether stack checking is actually enabled in order
810 -- to guide the expansion (typically of a function call).
811
812 function Needs_Constant_Address
813 (Decl : Node_Id;
814 Typ : Entity_Id) return Boolean;
815 -- Check whether the expression in an address clause is restricted to
816 -- consist of constants, when the object has a nontrivial initialization
817 -- or is controlled.
818
819 function Needs_Finalization (T : Entity_Id) return Boolean;
820 -- True if type T is controlled, or has controlled subcomponents. Also
821 -- True if T is a class-wide type, because some type extension might add
822 -- controlled subcomponents, except that if pragma Restrictions
823 -- (No_Finalization) applies, this is False for class-wide types.
824
825 function Non_Limited_Designated_Type (T : Entity_Id) return Entity_Id;
826 -- An anonymous access type may designate a limited view. Check whether
827 -- non-limited view is available during expansion, to examine components
828 -- or other characteristics of the full type.
829
830 function OK_To_Do_Constant_Replacement (E : Entity_Id) return Boolean;
831 -- This function is used when testing whether or not to replace a reference
832 -- to entity E by a known constant value. Such replacement must be done
833 -- only in a scope known to be safe for such replacements. In particular,
834 -- if we are within a subprogram and the entity E is declared outside the
835 -- subprogram then we cannot do the replacement, since we do not attempt to
836 -- trace subprogram call flow. It is also unsafe to replace statically
837 -- allocated values (since they can be modified outside the scope), and we
838 -- also inhibit replacement of Volatile or aliased objects since their
839 -- address might be captured in a way we do not detect. A value of True is
840 -- returned only if the replacement is safe.
841
842 function Possible_Bit_Aligned_Component (N : Node_Id) return Boolean;
843 -- This function is used during processing the assignment of a record or
844 -- indexed component. The argument N is either the left hand or right hand
845 -- side of an assignment, and this function determines if there is a record
846 -- component reference where the record may be bit aligned in a manner that
847 -- causes trouble for the back end (see Component_May_Be_Bit_Aligned for
848 -- further details).
849
850 function Power_Of_Two (N : Node_Id) return Nat;
851 -- Determines if N is a known at compile time value which is of the form
852 -- 2**K, where K is in the range 1 .. M, where the Esize of N is 2**(M+1).
853 -- If so, returns the value K, otherwise returns zero. The caller checks
854 -- that N is of an integer type.
855
856 procedure Process_Statements_For_Controlled_Objects (N : Node_Id);
857 -- N is a node which contains a non-handled statement list. Inspect the
858 -- statements looking for declarations of controlled objects. If at least
859 -- one such object is found, wrap the statement list in a block.
860
861 function Remove_Init_Call
862 (Var : Entity_Id;
863 Rep_Clause : Node_Id) return Node_Id;
864 -- Look for init_proc call or aggregate initialization statements for
865 -- variable Var, either among declarations between that of Var and a
866 -- subsequent Rep_Clause applying to Var, or in the list of freeze actions
867 -- associated with Var, and if found, remove and return that call node.
868
869 procedure Remove_Side_Effects
870 (Exp : Node_Id;
871 Name_Req : Boolean := False;
872 Renaming_Req : Boolean := False;
873 Variable_Ref : Boolean := False;
874 Related_Id : Entity_Id := Empty;
875 Is_Low_Bound : Boolean := False;
876 Is_High_Bound : Boolean := False;
877 Check_Side_Effects : Boolean := True);
878 -- Given the node for a subexpression, this function replaces the node if
879 -- necessary by an equivalent subexpression that is guaranteed to be side
880 -- effect free. This is done by extracting any actions that could cause
881 -- side effects, and inserting them using Insert_Actions into the tree
882 -- to which Exp is attached. Exp must be analyzed and resolved before the
883 -- call and is analyzed and resolved on return. Name_Req may only be set to
884 -- True if Exp has the form of a name, and the effect is to guarantee that
885 -- any replacement maintains the form of name. If Renaming_Req is set to
886 -- True, the routine produces an object renaming reclaration capturing the
887 -- expression. If Variable_Ref is set to True, a variable is considered as
888 -- side effect (used in implementing Force_Evaluation). Note: after call to
889 -- Remove_Side_Effects, it is safe to call New_Copy_Tree to obtain a copy
890 -- of the resulting expression. If Check_Side_Effects is set to True then
891 -- no action is performed if Exp is known to be side-effect free.
892 --
893 -- Related_Id denotes the entity of the context where Expr appears. Flags
894 -- Is_Low_Bound and Is_High_Bound specify whether the expression to check
895 -- is the low or the high bound of a range. These three optional arguments
896 -- signal Remove_Side_Effects to create an external symbol of the form
897 -- Chars (Related_Id)_FIRST/_LAST. If Related_Id is set, then exactly one
898 -- of the Is_xxx_Bound flags must be set. For use of these parameters see
899 -- the warning in the body of Sem_Ch3.Process_Range_Expr_In_Decl.
900 --
901 -- The side effects are captured using one of the following methods:
902 --
903 -- 1) a constant initialized with the value of the subexpression
904 -- 2) a renaming of the subexpression
905 -- 3) a reference to the subexpression
906 --
907 -- For elementary types, methods 1) and 2) are used; for composite types,
908 -- methods 2) and 3) are used. The renaming (method 2) is used only when
909 -- the subexpression denotes a name, so that it can be elaborated by gigi
910 -- without evaluating the subexpression.
911 --
912 -- Historical note: the reference (method 3) used to be the common fallback
913 -- method but it gives rise to aliasing issues if the subexpression denotes
914 -- a name that is not aliased, since it is equivalent to taking the address
915 -- in this case. The renaming (method 2) used to be applied to any objects
916 -- in the RM sense, that is to say to the cases where a renaming is legal
917 -- in Ada. But for some of these cases, most notably functions calls, the
918 -- renaming cannot be elaborated without evaluating the subexpression, so
919 -- gigi would resort to method 1) or 3) under the hood for them.
920
921 function Represented_As_Scalar (T : Entity_Id) return Boolean;
922 -- Returns True iff the implementation of this type in code generation
923 -- terms is scalar. This is true for scalars in the Ada sense, and for
924 -- packed arrays which are represented by a scalar (modular) type.
925
926 function Requires_Cleanup_Actions
927 (N : Node_Id;
928 Lib_Level : Boolean) return Boolean;
929 -- Given a node N, determine whether its declarative and/or statement list
930 -- contains one of the following:
931 --
932 -- 1) controlled objects
933 -- 2) library-level tagged types
934 --
935 -- These cases require special actions on scope exit. The flag Lib_Level
936 -- is set True if the construct is at library level, and False otherwise.
937
938 function Safe_Unchecked_Type_Conversion (Exp : Node_Id) return Boolean;
939 -- Given the node for an N_Unchecked_Type_Conversion, return True if this
940 -- is an unchecked conversion that Gigi can handle directly. Otherwise
941 -- return False if it is one for which the front end must provide a
942 -- temporary. Note that the node need not be analyzed, and thus the Etype
943 -- field may not be set, but in that case it must be the case that the
944 -- Subtype_Mark field of the node is set/analyzed.
945
946 procedure Set_Current_Value_Condition (Cnode : Node_Id);
947 -- Cnode is N_If_Statement, N_Elsif_Part, or N_Iteration_Scheme (the latter
948 -- when a WHILE condition is present). This call checks whether Condition
949 -- (Cnode) has embedded expressions of a form that should result in setting
950 -- the Current_Value field of one or more entities, and if so sets these
951 -- fields to point to Cnode.
952
953 procedure Set_Elaboration_Flag (N : Node_Id; Spec_Id : Entity_Id);
954 -- N is the node for a subprogram or generic body, and Spec_Id is the
955 -- entity for the corresponding spec. If an elaboration entity is defined,
956 -- then this procedure generates an assignment statement to set it True,
957 -- immediately after the body is elaborated. However, no assignment is
958 -- generated in the case of library level procedures, since the setting of
959 -- the flag in this case is generated in the binder. We do that so that we
960 -- can detect cases where this is the only elaboration action that is
961 -- required.
962
963 procedure Set_Renamed_Subprogram (N : Node_Id; E : Entity_Id);
964 -- N is an node which is an entity name that represents the name of a
965 -- renamed subprogram. The node is rewritten to be an identifier that
966 -- refers directly to the renamed subprogram, given by entity E.
967
968 function Side_Effect_Free
969 (N : Node_Id;
970 Name_Req : Boolean := False;
971 Variable_Ref : Boolean := False) return Boolean;
972 -- Determines if the tree N represents an expression that is known not
973 -- to have side effects. If this function returns True, then for example
974 -- a call to Remove_Side_Effects has no effect.
975 --
976 -- Name_Req controls the handling of volatile variable references. If
977 -- Name_Req is False (the normal case), then volatile references are
978 -- considered to be side effects. If Name_Req is True, then volatility
979 -- of variables is ignored.
980 --
981 -- If Variable_Ref is True, then all variable references are considered to
982 -- be side effects (regardless of volatility or the setting of Name_Req).
983
984 function Side_Effect_Free
985 (L : List_Id;
986 Name_Req : Boolean := False;
987 Variable_Ref : Boolean := False) return Boolean;
988 -- Determines if all elements of the list L are side-effect free. Name_Req
989 -- and Variable_Ref are as described above.
990
991 procedure Silly_Boolean_Array_Not_Test (N : Node_Id; T : Entity_Id);
992 -- N is the node for a boolean array NOT operation, and T is the type of
993 -- the array. This routine deals with the silly case where the subtype of
994 -- the boolean array is False..False or True..True, where it is required
995 -- that a Constraint_Error exception be raised (RM 4.5.6(6)).
996
997 procedure Silly_Boolean_Array_Xor_Test (N : Node_Id; T : Entity_Id);
998 -- N is the node for a boolean array XOR operation, and T is the type of
999 -- the array. This routine deals with the silly case where the subtype of
1000 -- the boolean array is True..True, where a raise of a Constraint_Error
1001 -- exception is required (RM 4.5.6(6)).
1002
1003 function Target_Has_Fixed_Ops
1004 (Left_Typ : Entity_Id;
1005 Right_Typ : Entity_Id;
1006 Result_Typ : Entity_Id) return Boolean;
1007 -- Returns True if and only if the target machine has direct support
1008 -- for fixed-by-fixed multiplications and divisions for the given
1009 -- operand and result types. This is called in package Exp_Fixd to
1010 -- determine whether to expand such operations.
1011
1012 function Type_May_Have_Bit_Aligned_Components
1013 (Typ : Entity_Id) return Boolean;
1014 -- Determines if Typ is a composite type that has within it (looking down
1015 -- recursively at any subcomponents), a record type which has component
1016 -- that may be bit aligned (see Possible_Bit_Aligned_Component). The result
1017 -- is conservative, in that a result of False is decisive. A result of True
1018 -- means that such a component may or may not be present.
1019
1020 function Within_Case_Or_If_Expression (N : Node_Id) return Boolean;
1021 -- Determine whether arbitrary node N is within a case or an if expression
1022
1023 function Within_Internal_Subprogram return Boolean;
1024 -- Indicates that some expansion is taking place within the body of a
1025 -- predefined primitive operation. Some expansion activity (e.g. predicate
1026 -- checks) is disabled in such.
1027
1028 private
1029 pragma Inline (Duplicate_Subexpr);
1030 pragma Inline (Force_Evaluation);
1031 pragma Inline (Is_Library_Level_Tagged_Type);
1032 end Exp_Util;