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