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