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