1 ------------------------------------------------------------------------------
3 -- GNAT COMPILER COMPONENTS --
9 -- Copyright (C) 1992-2005, Free Software Foundation, Inc. --
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 2, 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 COPYING. If not, write --
19 -- to the Free Software Foundation, 51 Franklin Street, Fifth Floor, --
20 -- Boston, MA 02110-1301, USA. --
22 -- GNAT was originally developed by the GNAT team at New York University. --
23 -- Extensive contributions were provided by Ada Core Technologies Inc. --
25 ------------------------------------------------------------------------------
27 -- This package contains virtually all expansion mechanisms related to
31 with Atree
; use Atree
;
32 with Debug
; use Debug
;
33 with Einfo
; use Einfo
;
34 with Errout
; use Errout
;
35 with Exp_Ch9
; use Exp_Ch9
;
36 with Exp_Ch11
; use Exp_Ch11
;
37 with Exp_Dbug
; use Exp_Dbug
;
38 with Exp_Tss
; use Exp_Tss
;
39 with Exp_Util
; use Exp_Util
;
40 with Freeze
; use Freeze
;
41 with Hostparm
; use Hostparm
;
42 with Nlists
; use Nlists
;
43 with Nmake
; use Nmake
;
45 with Output
; use Output
;
46 with Restrict
; use Restrict
;
47 with Rident
; use Rident
;
48 with Rtsfind
; use Rtsfind
;
49 with Targparm
; use Targparm
;
50 with Sinfo
; use Sinfo
;
52 with Sem_Ch3
; use Sem_Ch3
;
53 with Sem_Ch7
; use Sem_Ch7
;
54 with Sem_Ch8
; use Sem_Ch8
;
55 with Sem_Res
; use Sem_Res
;
56 with Sem_Type
; use Sem_Type
;
57 with Sem_Util
; use Sem_Util
;
58 with Snames
; use Snames
;
59 with Stand
; use Stand
;
60 with Tbuild
; use Tbuild
;
61 with Uintp
; use Uintp
;
63 package body Exp_Ch7
is
65 --------------------------------
66 -- Transient Scope Management --
67 --------------------------------
69 -- A transient scope is created when temporary objects are created by the
70 -- compiler. These temporary objects are allocated on the secondary stack
71 -- and the transient scope is responsible for finalizing the object when
72 -- appropriate and reclaiming the memory at the right time. The temporary
73 -- objects are generally the objects allocated to store the result of a
74 -- function returning an unconstrained or a tagged value. Expressions
75 -- needing to be wrapped in a transient scope (functions calls returning
76 -- unconstrained or tagged values) may appear in 3 different contexts which
77 -- lead to 3 different kinds of transient scope expansion:
79 -- 1. In a simple statement (procedure call, assignment, ...). In
80 -- this case the instruction is wrapped into a transient block.
81 -- (See Wrap_Transient_Statement for details)
83 -- 2. In an expression of a control structure (test in a IF statement,
84 -- expression in a CASE statement, ...).
85 -- (See Wrap_Transient_Expression for details)
87 -- 3. In a expression of an object_declaration. No wrapping is possible
88 -- here, so the finalization actions, if any are done right after the
89 -- declaration and the secondary stack deallocation is done in the
90 -- proper enclosing scope (see Wrap_Transient_Declaration for details)
92 -- Note about function returning tagged types: It has been decided to
93 -- always allocate their result in the secondary stack while it is not
94 -- absolutely mandatory when the tagged type is constrained because the
95 -- caller knows the size of the returned object and thus could allocate the
96 -- result in the primary stack. But, allocating them always in the
97 -- secondary stack simplifies many implementation hassles:
99 -- - If it is dispatching function call, the computation of the size of
100 -- the result is possible but complex from the outside.
102 -- - If the returned type is controlled, the assignment of the returned
103 -- value to the anonymous object involves an Adjust, and we have no
104 -- easy way to access the anonymous object created by the back-end
106 -- - If the returned type is class-wide, this is an unconstrained type
109 -- Furthermore, the little loss in efficiency which is the result of this
110 -- decision is not such a big deal because function returning tagged types
111 -- are not very much used in real life as opposed to functions returning
112 -- access to a tagged type
114 --------------------------------------------------
115 -- Transient Blocks and Finalization Management --
116 --------------------------------------------------
118 function Find_Node_To_Be_Wrapped
(N
: Node_Id
) return Node_Id
;
119 -- N is a node wich may generate a transient scope. Loop over the
120 -- parent pointers of N until it find the appropriate node to
121 -- wrap. It it returns Empty, it means that no transient scope is
122 -- needed in this context.
131 Is_Protected_Subprogram
: Boolean;
132 Is_Task_Allocation_Block
: Boolean;
133 Is_Asynchronous_Call_Block
: Boolean) return Node_Id
;
134 -- Expand a the clean-up procedure for controlled and/or transient
135 -- block, and/or task master or task body, or blocks used to
136 -- implement task allocation or asynchronous entry calls, or
137 -- procedures used to implement protected procedures. Clean is the
138 -- entity for such a procedure. Mark is the entity for the secondary
139 -- stack mark, if empty only controlled block clean-up will be
140 -- performed. Flist is the entity for the local final list, if empty
141 -- only transient scope clean-up will be performed. The flags
142 -- Is_Task and Is_Master control the calls to the corresponding
143 -- finalization actions for a task body or for an entity that is a
146 procedure Set_Node_To_Be_Wrapped
(N
: Node_Id
);
147 -- Set the field Node_To_Be_Wrapped of the current scope
149 procedure Insert_Actions_In_Scope_Around
(N
: Node_Id
);
150 -- Insert the before-actions kept in the scope stack before N, and the
151 -- after after-actions, after N which must be a member of a list.
153 function Make_Transient_Block
155 Action
: Node_Id
) return Node_Id
;
156 -- Create a transient block whose name is Scope, which is also a
157 -- controlled block if Flist is not empty and whose only code is
158 -- Action (either a single statement or single declaration).
160 type Final_Primitives
is (Initialize_Case
, Adjust_Case
, Finalize_Case
);
161 -- This enumeration type is defined in order to ease sharing code for
162 -- building finalization procedures for composite types.
164 Name_Of
: constant array (Final_Primitives
) of Name_Id
:=
165 (Initialize_Case
=> Name_Initialize
,
166 Adjust_Case
=> Name_Adjust
,
167 Finalize_Case
=> Name_Finalize
);
169 Deep_Name_Of
: constant array (Final_Primitives
) of TSS_Name_Type
:=
170 (Initialize_Case
=> TSS_Deep_Initialize
,
171 Adjust_Case
=> TSS_Deep_Adjust
,
172 Finalize_Case
=> TSS_Deep_Finalize
);
174 procedure Build_Record_Deep_Procs
(Typ
: Entity_Id
);
175 -- Build the deep Initialize/Adjust/Finalize for a record Typ with
176 -- Has_Component_Component set and store them using the TSS mechanism.
178 procedure Build_Array_Deep_Procs
(Typ
: Entity_Id
);
179 -- Build the deep Initialize/Adjust/Finalize for a record Typ with
180 -- Has_Controlled_Component set and store them using the TSS mechanism.
182 function Make_Deep_Proc
183 (Prim
: Final_Primitives
;
185 Stmts
: List_Id
) return Node_Id
;
186 -- This function generates the tree for Deep_Initialize, Deep_Adjust
187 -- or Deep_Finalize procedures according to the first parameter,
188 -- these procedures operate on the type Typ. The Stmts parameter
189 -- gives the body of the procedure.
191 function Make_Deep_Array_Body
192 (Prim
: Final_Primitives
;
193 Typ
: Entity_Id
) return List_Id
;
194 -- This function generates the list of statements for implementing
195 -- Deep_Initialize, Deep_Adjust or Deep_Finalize procedures
196 -- according to the first parameter, these procedures operate on the
199 function Make_Deep_Record_Body
200 (Prim
: Final_Primitives
;
201 Typ
: Entity_Id
) return List_Id
;
202 -- This function generates the list of statements for implementing
203 -- Deep_Initialize, Deep_Adjust or Deep_Finalize procedures
204 -- according to the first parameter, these procedures operate on the
207 procedure Check_Visibly_Controlled
208 (Prim
: Final_Primitives
;
210 E
: in out Entity_Id
;
211 Cref
: in out Node_Id
);
212 -- The controlled operation declared for a derived type may not be
213 -- overriding, if the controlled operations of the parent type are
214 -- hidden, for example when the parent is a private type whose full
215 -- view is controlled. For other primitive operations we modify the
216 -- name of the operation to indicate that it is not overriding, but
217 -- this is not possible for Initialize, etc. because they have to be
218 -- retrievable by name. Before generating the proper call to one of
219 -- these operations we check whether Typ is known to be controlled at
220 -- the point of definition. If it is not then we must retrieve the
221 -- hidden operation of the parent and use it instead. This is one
222 -- case that might be solved more cleanly once Overriding pragmas or
223 -- declarations are in place.
225 function Convert_View
228 Ind
: Pos
:= 1) return Node_Id
;
229 -- Proc is one of the Initialize/Adjust/Finalize operations, and
230 -- Arg is the argument being passed to it. Ind indicates which
231 -- formal of procedure Proc we are trying to match. This function
232 -- will, if necessary, generate an conversion between the partial
233 -- and full view of Arg to match the type of the formal of Proc,
234 -- or force a conversion to the class-wide type in the case where
235 -- the operation is abstract.
237 -----------------------------
238 -- Finalization Management --
239 -----------------------------
241 -- This part describe how Initialization/Adjusment/Finalization procedures
242 -- are generated and called. Two cases must be considered, types that are
243 -- Controlled (Is_Controlled flag set) and composite types that contain
244 -- controlled components (Has_Controlled_Component flag set). In the first
245 -- case the procedures to call are the user-defined primitive operations
246 -- Initialize/Adjust/Finalize. In the second case, GNAT generates
247 -- Deep_Initialize, Deep_Adjust and Deep_Finalize that are in charge of
248 -- calling the former procedures on the controlled components.
250 -- For records with Has_Controlled_Component set, a hidden "controller"
251 -- component is inserted. This controller component contains its own
252 -- finalization list on which all controlled components are attached
253 -- creating an indirection on the upper-level Finalization list. This
254 -- technique facilitates the management of objects whose number of
255 -- controlled components changes during execution. This controller
256 -- component is itself controlled and is attached to the upper-level
257 -- finalization chain. Its adjust primitive is in charge of calling
258 -- adjust on the components and adusting the finalization pointer to
259 -- match their new location (see a-finali.adb).
261 -- It is not possible to use a similar technique for arrays that have
262 -- Has_Controlled_Component set. In this case, deep procedures are
263 -- generated that call initialize/adjust/finalize + attachment or
264 -- detachment on the finalization list for all component.
266 -- Initialize calls: they are generated for declarations or dynamic
267 -- allocations of Controlled objects with no initial value. They are
268 -- always followed by an attachment to the current Finalization
269 -- Chain. For the dynamic allocation case this the chain attached to
270 -- the scope of the access type definition otherwise, this is the chain
271 -- of the current scope.
273 -- Adjust Calls: They are generated on 2 occasions: (1) for
274 -- declarations or dynamic allocations of Controlled objects with an
275 -- initial value. (2) after an assignment. In the first case they are
276 -- followed by an attachment to the final chain, in the second case
279 -- Finalization Calls: They are generated on (1) scope exit, (2)
280 -- assignments, (3) unchecked deallocations. In case (3) they have to
281 -- be detached from the final chain, in case (2) they must not and in
282 -- case (1) this is not important since we are exiting the scope
286 -- - Type extensions will have a new record controller at each derivation
287 -- level containing controlled components.
288 -- - For types that are both Is_Controlled and Has_Controlled_Components,
289 -- the record controller and the object itself are handled separately.
290 -- It could seem simpler to attach the object at the end of its record
291 -- controller but this would not tackle view conversions properly.
292 -- - A classwide type can always potentially have controlled components
293 -- but the record controller of the corresponding actual type may not
294 -- be known at compile time so the dispatch table contains a special
295 -- field that allows to compute the offset of the record controller
296 -- dynamically. See s-finimp.Deep_Tag_Attach and a-tags.RC_Offset
298 -- Here is a simple example of the expansion of a controlled block :
302 -- Y : Controlled := Init;
308 -- Z : R := (C => X);
317 -- _L : System.FI.Finalizable_Ptr;
319 -- procedure _Clean is
322 -- System.FI.Finalize_List (_L);
330 -- Attach_To_Final_List (_L, Finalizable (X), 1);
331 -- at end: Abort_Undefer;
332 -- Y : Controlled := Init;
334 -- Attach_To_Final_List (_L, Finalizable (Y), 1);
337 -- _C : Record_Controller;
343 -- Deep_Initialize (W, _L, 1);
344 -- at end: Abort_Under;
345 -- Z : R := (C => X);
346 -- Deep_Adjust (Z, _L, 1);
350 -- Deep_Finalize (W, False);
351 -- <save W's final pointers>
353 -- <restore W's final pointers>
354 -- Deep_Adjust (W, _L, 0);
359 function Global_Flist_Ref
(Flist_Ref
: Node_Id
) return Boolean;
360 -- Return True if Flist_Ref refers to a global final list, either
361 -- the object GLobal_Final_List which is used to attach standalone
362 -- objects, or any of the list controllers associated with library
363 -- level access to controlled objects
365 procedure Clean_Simple_Protected_Objects
(N
: Node_Id
);
366 -- Protected objects without entries are not controlled types, and the
367 -- locks have to be released explicitly when such an object goes out
368 -- of scope. Traverse declarations in scope to determine whether such
369 -- objects are present.
371 ----------------------------
372 -- Build_Array_Deep_Procs --
373 ----------------------------
375 procedure Build_Array_Deep_Procs
(Typ
: Entity_Id
) is
379 Prim
=> Initialize_Case
,
381 Stmts
=> Make_Deep_Array_Body
(Initialize_Case
, Typ
)));
383 if not Is_Return_By_Reference_Type
(Typ
) then
388 Stmts
=> Make_Deep_Array_Body
(Adjust_Case
, Typ
)));
393 Prim
=> Finalize_Case
,
395 Stmts
=> Make_Deep_Array_Body
(Finalize_Case
, Typ
)));
396 end Build_Array_Deep_Procs
;
398 -----------------------------
399 -- Build_Controlling_Procs --
400 -----------------------------
402 procedure Build_Controlling_Procs
(Typ
: Entity_Id
) is
404 if Is_Array_Type
(Typ
) then
405 Build_Array_Deep_Procs
(Typ
);
407 else pragma Assert
(Is_Record_Type
(Typ
));
408 Build_Record_Deep_Procs
(Typ
);
410 end Build_Controlling_Procs
;
412 ----------------------
413 -- Build_Final_List --
414 ----------------------
416 procedure Build_Final_List
(N
: Node_Id
; Typ
: Entity_Id
) is
417 Loc
: constant Source_Ptr
:= Sloc
(N
);
421 Set_Associated_Final_Chain
(Typ
,
422 Make_Defining_Identifier
(Loc
,
423 New_External_Name
(Chars
(Typ
), 'L')));
426 Make_Object_Declaration
(Loc
,
427 Defining_Identifier
=>
428 Associated_Final_Chain
(Typ
),
431 (RTE
(RE_List_Controller
), Loc
));
433 -- The type may have been frozen already, and this is a late freezing
434 -- action, in which case the declaration must be elaborated at once.
435 -- If the call is for an allocator, the chain must also be created now,
436 -- because the freezing of the type does not build one. Otherwise, the
437 -- declaration is one of the freezing actions for a user-defined type.
440 or else (Nkind
(N
) = N_Allocator
441 and then Ekind
(Etype
(N
)) = E_Anonymous_Access_Type
)
443 Insert_Action
(N
, Decl
);
445 Append_Freeze_Action
(Typ
, Decl
);
447 end Build_Final_List
;
449 ---------------------
450 -- Build_Late_Proc --
451 ---------------------
453 procedure Build_Late_Proc
(Typ
: Entity_Id
; Nam
: Name_Id
) is
455 for Final_Prim
in Name_Of
'Range loop
456 if Name_Of
(Final_Prim
) = Nam
then
461 Stmts
=> Make_Deep_Record_Body
(Final_Prim
, Typ
)));
466 -----------------------------
467 -- Build_Record_Deep_Procs --
468 -----------------------------
470 procedure Build_Record_Deep_Procs
(Typ
: Entity_Id
) is
474 Prim
=> Initialize_Case
,
476 Stmts
=> Make_Deep_Record_Body
(Initialize_Case
, Typ
)));
478 if not Is_Return_By_Reference_Type
(Typ
) then
483 Stmts
=> Make_Deep_Record_Body
(Adjust_Case
, Typ
)));
488 Prim
=> Finalize_Case
,
490 Stmts
=> Make_Deep_Record_Body
(Finalize_Case
, Typ
)));
491 end Build_Record_Deep_Procs
;
497 function Cleanup_Array
500 Typ
: Entity_Id
) return List_Id
502 Loc
: constant Source_Ptr
:= Sloc
(N
);
503 Index_List
: constant List_Id
:= New_List
;
505 function Free_Component
return List_Id
;
506 -- Generate the code to finalize the task or protected subcomponents
507 -- of a single component of the array.
509 function Free_One_Dimension
(Dim
: Int
) return List_Id
;
510 -- Generate a loop over one dimension of the array
516 function Free_Component
return List_Id
is
517 Stmts
: List_Id
:= New_List
;
519 C_Typ
: constant Entity_Id
:= Component_Type
(Typ
);
522 -- Component type is known to contain tasks or protected objects
525 Make_Indexed_Component
(Loc
,
526 Prefix
=> Duplicate_Subexpr_No_Checks
(Obj
),
527 Expressions
=> Index_List
);
529 Set_Etype
(Tsk
, C_Typ
);
531 if Is_Task_Type
(C_Typ
) then
532 Append_To
(Stmts
, Cleanup_Task
(N
, Tsk
));
534 elsif Is_Simple_Protected_Type
(C_Typ
) then
535 Append_To
(Stmts
, Cleanup_Protected_Object
(N
, Tsk
));
537 elsif Is_Record_Type
(C_Typ
) then
538 Stmts
:= Cleanup_Record
(N
, Tsk
, C_Typ
);
540 elsif Is_Array_Type
(C_Typ
) then
541 Stmts
:= Cleanup_Array
(N
, Tsk
, C_Typ
);
547 ------------------------
548 -- Free_One_Dimension --
549 ------------------------
551 function Free_One_Dimension
(Dim
: Int
) return List_Id
is
555 if Dim
> Number_Dimensions
(Typ
) then
556 return Free_Component
;
558 -- Here we generate the required loop
562 Make_Defining_Identifier
(Loc
, New_Internal_Name
('J'));
564 Append
(New_Reference_To
(Index
, Loc
), Index_List
);
567 Make_Implicit_Loop_Statement
(N
,
570 Make_Iteration_Scheme
(Loc
,
571 Loop_Parameter_Specification
=>
572 Make_Loop_Parameter_Specification
(Loc
,
573 Defining_Identifier
=> Index
,
574 Discrete_Subtype_Definition
=>
575 Make_Attribute_Reference
(Loc
,
576 Prefix
=> Duplicate_Subexpr
(Obj
),
577 Attribute_Name
=> Name_Range
,
578 Expressions
=> New_List
(
579 Make_Integer_Literal
(Loc
, Dim
))))),
580 Statements
=> Free_One_Dimension
(Dim
+ 1)));
582 end Free_One_Dimension
;
584 -- Start of processing for Cleanup_Array
587 return Free_One_Dimension
(1);
594 function Cleanup_Record
597 Typ
: Entity_Id
) return List_Id
599 Loc
: constant Source_Ptr
:= Sloc
(N
);
602 Stmts
: constant List_Id
:= New_List
;
603 U_Typ
: constant Entity_Id
:= Underlying_Type
(Typ
);
606 if Has_Discriminants
(U_Typ
)
607 and then Nkind
(Parent
(U_Typ
)) = N_Full_Type_Declaration
609 Nkind
(Type_Definition
(Parent
(U_Typ
))) = N_Record_Definition
613 (Component_List
(Type_Definition
(Parent
(U_Typ
)))))
615 -- For now, do not attempt to free a component that may appear in
616 -- a variant, and instead issue a warning. Doing this "properly"
617 -- would require building a case statement and would be quite a
618 -- mess. Note that the RM only requires that free "work" for the
619 -- case of a task access value, so already we go way beyond this
620 -- in that we deal with the array case and non-discriminated
624 ("task/protected object in variant record will not be freed?", N
);
625 return New_List
(Make_Null_Statement
(Loc
));
628 Comp
:= First_Component
(Typ
);
630 while Present
(Comp
) loop
631 if Has_Task
(Etype
(Comp
))
632 or else Has_Simple_Protected_Object
(Etype
(Comp
))
635 Make_Selected_Component
(Loc
,
636 Prefix
=> Duplicate_Subexpr_No_Checks
(Obj
),
637 Selector_Name
=> New_Occurrence_Of
(Comp
, Loc
));
638 Set_Etype
(Tsk
, Etype
(Comp
));
640 if Is_Task_Type
(Etype
(Comp
)) then
641 Append_To
(Stmts
, Cleanup_Task
(N
, Tsk
));
643 elsif Is_Simple_Protected_Type
(Etype
(Comp
)) then
644 Append_To
(Stmts
, Cleanup_Protected_Object
(N
, Tsk
));
646 elsif Is_Record_Type
(Etype
(Comp
)) then
648 -- Recurse, by generating the prefix of the argument to
649 -- the eventual cleanup call.
652 (Stmts
, Cleanup_Record
(N
, Tsk
, Etype
(Comp
)));
654 elsif Is_Array_Type
(Etype
(Comp
)) then
656 (Stmts
, Cleanup_Array
(N
, Tsk
, Etype
(Comp
)));
660 Next_Component
(Comp
);
666 ------------------------------
667 -- Cleanup_Protected_Object --
668 ------------------------------
670 function Cleanup_Protected_Object
672 Ref
: Node_Id
) return Node_Id
674 Loc
: constant Source_Ptr
:= Sloc
(N
);
678 Make_Procedure_Call_Statement
(Loc
,
679 Name
=> New_Reference_To
(RTE
(RE_Finalize_Protection
), Loc
),
680 Parameter_Associations
=> New_List
(
681 Concurrent_Ref
(Ref
)));
682 end Cleanup_Protected_Object
;
684 ------------------------------------
685 -- Clean_Simple_Protected_Objects --
686 ------------------------------------
688 procedure Clean_Simple_Protected_Objects
(N
: Node_Id
) is
689 Stmts
: constant List_Id
:= Statements
(Handled_Statement_Sequence
(N
));
690 Stmt
: Node_Id
:= Last
(Stmts
);
694 E
:= First_Entity
(Current_Scope
);
695 while Present
(E
) loop
696 if (Ekind
(E
) = E_Variable
697 or else Ekind
(E
) = E_Constant
)
698 and then Has_Simple_Protected_Object
(Etype
(E
))
699 and then not Has_Task
(Etype
(E
))
700 and then Nkind
(Parent
(E
)) /= N_Object_Renaming_Declaration
703 Typ
: constant Entity_Id
:= Etype
(E
);
704 Ref
: constant Node_Id
:= New_Occurrence_Of
(E
, Sloc
(Stmt
));
707 if Is_Simple_Protected_Type
(Typ
) then
708 Append_To
(Stmts
, Cleanup_Protected_Object
(N
, Ref
));
710 elsif Has_Simple_Protected_Object
(Typ
) then
711 if Is_Record_Type
(Typ
) then
712 Append_List_To
(Stmts
, Cleanup_Record
(N
, Ref
, Typ
));
714 elsif Is_Array_Type
(Typ
) then
715 Append_List_To
(Stmts
, Cleanup_Array
(N
, Ref
, Typ
));
724 -- Analyze inserted cleanup statements
726 if Present
(Stmt
) then
729 while Present
(Stmt
) loop
734 end Clean_Simple_Protected_Objects
;
740 function Cleanup_Task
742 Ref
: Node_Id
) return Node_Id
744 Loc
: constant Source_Ptr
:= Sloc
(N
);
747 Make_Procedure_Call_Statement
(Loc
,
748 Name
=> New_Reference_To
(RTE
(RE_Free_Task
), Loc
),
749 Parameter_Associations
=>
750 New_List
(Concurrent_Ref
(Ref
)));
753 ---------------------------------
754 -- Has_Simple_Protected_Object --
755 ---------------------------------
757 function Has_Simple_Protected_Object
(T
: Entity_Id
) return Boolean is
761 if Is_Simple_Protected_Type
(T
) then
764 elsif Is_Array_Type
(T
) then
765 return Has_Simple_Protected_Object
(Component_Type
(T
));
767 elsif Is_Record_Type
(T
) then
768 Comp
:= First_Component
(T
);
770 while Present
(Comp
) loop
771 if Has_Simple_Protected_Object
(Etype
(Comp
)) then
775 Next_Component
(Comp
);
783 end Has_Simple_Protected_Object
;
785 ------------------------------
786 -- Is_Simple_Protected_Type --
787 ------------------------------
789 function Is_Simple_Protected_Type
(T
: Entity_Id
) return Boolean is
791 return Is_Protected_Type
(T
) and then not Has_Entries
(T
);
792 end Is_Simple_Protected_Type
;
794 ------------------------------
795 -- Check_Visibly_Controlled --
796 ------------------------------
798 procedure Check_Visibly_Controlled
799 (Prim
: Final_Primitives
;
801 E
: in out Entity_Id
;
802 Cref
: in out Node_Id
)
804 Parent_Type
: Entity_Id
;
808 if Is_Derived_Type
(Typ
)
809 and then Comes_From_Source
(E
)
810 and then not Is_Overriding_Operation
(E
)
812 -- We know that the explicit operation on the type does not override
813 -- the inherited operation of the parent, and that the derivation
814 -- is from a private type that is not visibly controlled.
816 Parent_Type
:= Etype
(Typ
);
817 Op
:= Find_Prim_Op
(Parent_Type
, Name_Of
(Prim
));
822 -- Wrap the object to be initialized into the proper
823 -- unchecked conversion, to be compatible with the operation
826 if Nkind
(Cref
) = N_Unchecked_Type_Conversion
then
827 Cref
:= Unchecked_Convert_To
(Parent_Type
, Expression
(Cref
));
829 Cref
:= Unchecked_Convert_To
(Parent_Type
, Cref
);
833 end Check_Visibly_Controlled
;
835 ---------------------
836 -- Controlled_Type --
837 ---------------------
839 function Controlled_Type
(T
: Entity_Id
) return Boolean is
841 function Has_Some_Controlled_Component
(Rec
: Entity_Id
) return Boolean;
842 -- If type is not frozen yet, check explicitly among its components,
843 -- because flag is not necessarily set.
845 -----------------------------------
846 -- Has_Some_Controlled_Component --
847 -----------------------------------
849 function Has_Some_Controlled_Component
850 (Rec
: Entity_Id
) return Boolean
855 if Has_Controlled_Component
(Rec
) then
858 elsif not Is_Frozen
(Rec
) then
859 if Is_Record_Type
(Rec
) then
860 Comp
:= First_Entity
(Rec
);
862 while Present
(Comp
) loop
863 if not Is_Type
(Comp
)
864 and then Controlled_Type
(Etype
(Comp
))
874 elsif Is_Array_Type
(Rec
) then
875 return Is_Controlled
(Component_Type
(Rec
));
878 return Has_Controlled_Component
(Rec
);
883 end Has_Some_Controlled_Component
;
885 -- Start of processing for Controlled_Type
888 -- Class-wide types must be treated as controlled because they may
889 -- contain an extension that has controlled components
891 -- We can skip this if finalization is not available
893 return (Is_Class_Wide_Type
(T
)
894 and then not In_Finalization_Root
(T
)
895 and then not Restriction_Active
(No_Finalization
))
896 or else Is_Controlled
(T
)
897 or else Has_Some_Controlled_Component
(T
)
898 or else (Is_Concurrent_Type
(T
)
899 and then Present
(Corresponding_Record_Type
(T
))
900 and then Controlled_Type
(Corresponding_Record_Type
(T
)));
903 --------------------------
904 -- Controller_Component --
905 --------------------------
907 function Controller_Component
(Typ
: Entity_Id
) return Entity_Id
is
908 T
: Entity_Id
:= Base_Type
(Typ
);
910 Comp_Scop
: Entity_Id
;
911 Res
: Entity_Id
:= Empty
;
912 Res_Scop
: Entity_Id
:= Empty
;
915 if Is_Class_Wide_Type
(T
) then
919 if Is_Private_Type
(T
) then
920 T
:= Underlying_Type
(T
);
923 -- Fetch the outermost controller
925 Comp
:= First_Entity
(T
);
926 while Present
(Comp
) loop
927 if Chars
(Comp
) = Name_uController
then
928 Comp_Scop
:= Scope
(Original_Record_Component
(Comp
));
930 -- If this controller is at the outermost level, no need to
931 -- look for another one
933 if Comp_Scop
= T
then
936 -- Otherwise record the outermost one and continue looking
938 elsif Res
= Empty
or else Is_Ancestor
(Res_Scop
, Comp_Scop
) then
940 Res_Scop
:= Comp_Scop
;
947 -- If we fall through the loop, there is no controller component
950 end Controller_Component
;
956 function Convert_View
959 Ind
: Pos
:= 1) return Node_Id
961 Fent
: Entity_Id
:= First_Entity
(Proc
);
966 for J
in 2 .. Ind
loop
970 Ftyp
:= Etype
(Fent
);
972 if Nkind
(Arg
) = N_Type_Conversion
973 or else Nkind
(Arg
) = N_Unchecked_Type_Conversion
975 Atyp
:= Entity
(Subtype_Mark
(Arg
));
980 if Is_Abstract
(Proc
) and then Is_Tagged_Type
(Ftyp
) then
981 return Unchecked_Convert_To
(Class_Wide_Type
(Ftyp
), Arg
);
984 and then Present
(Atyp
)
986 (Is_Private_Type
(Ftyp
) or else Is_Private_Type
(Atyp
))
988 Base_Type
(Underlying_Type
(Atyp
)) =
989 Base_Type
(Underlying_Type
(Ftyp
))
991 return Unchecked_Convert_To
(Ftyp
, Arg
);
993 -- If the argument is already a conversion, as generated by
994 -- Make_Init_Call, set the target type to the type of the formal
995 -- directly, to avoid spurious typing problems.
997 elsif (Nkind
(Arg
) = N_Unchecked_Type_Conversion
998 or else Nkind
(Arg
) = N_Type_Conversion
)
999 and then not Is_Class_Wide_Type
(Atyp
)
1001 Set_Subtype_Mark
(Arg
, New_Occurrence_Of
(Ftyp
, Sloc
(Arg
)));
1002 Set_Etype
(Arg
, Ftyp
);
1010 -------------------------------
1011 -- Establish_Transient_Scope --
1012 -------------------------------
1014 -- This procedure is called each time a transient block has to be inserted
1015 -- that is to say for each call to a function with unconstrained ot tagged
1016 -- result. It creates a new scope on the stack scope in order to enclose
1017 -- all transient variables generated
1019 procedure Establish_Transient_Scope
(N
: Node_Id
; Sec_Stack
: Boolean) is
1020 Loc
: constant Source_Ptr
:= Sloc
(N
);
1021 Wrap_Node
: Node_Id
;
1023 Sec_Stk
: constant Boolean :=
1024 Sec_Stack
and not Functions_Return_By_DSP_On_Target
;
1025 -- We never need a secondary stack if functions return by DSP
1028 -- Do not create a transient scope if we are already inside one
1030 for S
in reverse Scope_Stack
.First
.. Scope_Stack
.Last
loop
1032 if Scope_Stack
.Table
(S
).Is_Transient
then
1034 Set_Uses_Sec_Stack
(Scope_Stack
.Table
(S
).Entity
);
1039 -- If we have encountered Standard there are no enclosing
1040 -- transient scopes.
1042 elsif Scope_Stack
.Table
(S
).Entity
= Standard_Standard
then
1048 Wrap_Node
:= Find_Node_To_Be_Wrapped
(N
);
1050 -- Case of no wrap node, false alert, no transient scope needed
1052 if No
(Wrap_Node
) then
1055 -- If the node to wrap is an iteration_scheme, the expression is
1056 -- one of the bounds, and the expansion will make an explicit
1057 -- declaration for it (see Analyze_Iteration_Scheme, sem_ch5.adb),
1058 -- so do not apply any transformations here.
1060 elsif Nkind
(Wrap_Node
) = N_Iteration_Scheme
then
1064 New_Scope
(New_Internal_Entity
(E_Block
, Current_Scope
, Loc
, 'B'));
1065 Set_Scope_Is_Transient
;
1068 Set_Uses_Sec_Stack
(Current_Scope
);
1069 Check_Restriction
(No_Secondary_Stack
, N
);
1072 Set_Etype
(Current_Scope
, Standard_Void_Type
);
1073 Set_Node_To_Be_Wrapped
(Wrap_Node
);
1075 if Debug_Flag_W
then
1076 Write_Str
(" <Transient>");
1080 end Establish_Transient_Scope
;
1082 ----------------------------
1083 -- Expand_Cleanup_Actions --
1084 ----------------------------
1086 procedure Expand_Cleanup_Actions
(N
: Node_Id
) is
1088 S
: constant Entity_Id
:=
1090 Flist
: constant Entity_Id
:=
1091 Finalization_Chain_Entity
(S
);
1092 Is_Task
: constant Boolean :=
1093 (Nkind
(Original_Node
(N
)) = N_Task_Body
);
1094 Is_Master
: constant Boolean :=
1095 Nkind
(N
) /= N_Entry_Body
1096 and then Is_Task_Master
(N
);
1097 Is_Protected
: constant Boolean :=
1098 Nkind
(N
) = N_Subprogram_Body
1099 and then Is_Protected_Subprogram_Body
(N
);
1100 Is_Task_Allocation
: constant Boolean :=
1101 Nkind
(N
) = N_Block_Statement
1102 and then Is_Task_Allocation_Block
(N
);
1103 Is_Asynchronous_Call
: constant Boolean :=
1104 Nkind
(N
) = N_Block_Statement
1105 and then Is_Asynchronous_Call_Block
(N
);
1108 Mark
: Entity_Id
:= Empty
;
1109 New_Decls
: constant List_Id
:= New_List
;
1113 Chain
: Entity_Id
:= Empty
;
1119 -- Compute a location that is not directly in the user code in
1120 -- order to avoid to generate confusing debug info. A good
1121 -- approximation is the name of the outer user-defined scope
1124 S1
: Entity_Id
:= S
;
1127 while not Comes_From_Source
(S1
) and then S1
/= Standard_Standard
loop
1134 -- There are cleanup actions only if the secondary stack needs
1135 -- releasing or some finalizations are needed or in the context
1138 if Uses_Sec_Stack
(Current_Scope
)
1139 and then not Sec_Stack_Needed_For_Return
(Current_Scope
)
1143 and then not Is_Master
1144 and then not Is_Task
1145 and then not Is_Protected
1146 and then not Is_Task_Allocation
1147 and then not Is_Asynchronous_Call
1149 Clean_Simple_Protected_Objects
(N
);
1153 -- If the current scope is the subprogram body that is the rewriting
1154 -- of a task body, and the descriptors have not been delayed (due to
1155 -- some nested instantiations) do not generate redundant cleanup
1156 -- actions: the cleanup procedure already exists for this body.
1158 if Nkind
(N
) = N_Subprogram_Body
1159 and then Nkind
(Original_Node
(N
)) = N_Task_Body
1160 and then not Delay_Subprogram_Descriptors
(Corresponding_Spec
(N
))
1165 -- Set polling off, since we don't need to poll during cleanup
1166 -- actions, and indeed for the cleanup routine, which is executed
1167 -- with aborts deferred, we don't want polling.
1169 Old_Poll
:= Polling_Required
;
1170 Polling_Required
:= False;
1172 -- Make sure we have a declaration list, since we will add to it
1174 if No
(Declarations
(N
)) then
1175 Set_Declarations
(N
, New_List
);
1178 -- The task activation call has already been built for task
1179 -- allocation blocks.
1181 if not Is_Task_Allocation
then
1182 Build_Task_Activation_Call
(N
);
1186 Establish_Task_Master
(N
);
1189 -- If secondary stack is in use, expand:
1190 -- _Mxx : constant Mark_Id := SS_Mark;
1192 -- Suppress calls to SS_Mark and SS_Release if Java_VM,
1193 -- since we never use the secondary stack on the JVM.
1195 if Uses_Sec_Stack
(Current_Scope
)
1196 and then not Sec_Stack_Needed_For_Return
(Current_Scope
)
1197 and then not Java_VM
1199 Mark
:= Make_Defining_Identifier
(Loc
, New_Internal_Name
('M'));
1200 Append_To
(New_Decls
,
1201 Make_Object_Declaration
(Loc
,
1202 Defining_Identifier
=> Mark
,
1203 Object_Definition
=> New_Reference_To
(RTE
(RE_Mark_Id
), Loc
),
1205 Make_Function_Call
(Loc
,
1206 Name
=> New_Reference_To
(RTE
(RE_SS_Mark
), Loc
))));
1208 Set_Uses_Sec_Stack
(Current_Scope
, False);
1211 -- If finalization list is present then expand:
1212 -- Local_Final_List : System.FI.Finalizable_Ptr;
1214 if Present
(Flist
) then
1215 Append_To
(New_Decls
,
1216 Make_Object_Declaration
(Loc
,
1217 Defining_Identifier
=> Flist
,
1218 Object_Definition
=>
1219 New_Reference_To
(RTE
(RE_Finalizable_Ptr
), Loc
)));
1222 -- Clean-up procedure definition
1224 Clean
:= Make_Defining_Identifier
(Loc
, Name_uClean
);
1225 Set_Suppress_Elaboration_Warnings
(Clean
);
1226 Append_To
(New_Decls
,
1227 Make_Clean
(N
, Clean
, Mark
, Flist
,
1232 Is_Asynchronous_Call
));
1234 -- If exception handlers are present, wrap the Sequence of
1235 -- statements in a block because it is not possible to get
1236 -- exception handlers and an AT END call in the same scope.
1238 if Present
(Exception_Handlers
(Handled_Statement_Sequence
(N
))) then
1240 -- Preserve end label to provide proper cross-reference information
1242 End_Lab
:= End_Label
(Handled_Statement_Sequence
(N
));
1244 Make_Block_Statement
(Loc
,
1245 Handled_Statement_Sequence
=> Handled_Statement_Sequence
(N
));
1246 Set_Handled_Statement_Sequence
(N
,
1247 Make_Handled_Sequence_Of_Statements
(Loc
, New_List
(Blok
)));
1248 Set_End_Label
(Handled_Statement_Sequence
(N
), End_Lab
);
1251 -- Otherwise we do not wrap
1258 -- Don't move the _chain Activation_Chain declaration in task
1259 -- allocation blocks. Task allocation blocks use this object
1260 -- in their cleanup handlers, and gigi complains if it is declared
1261 -- in the sequence of statements of the scope that declares the
1264 if Is_Task_Allocation
then
1265 Chain
:= Activation_Chain_Entity
(N
);
1266 Decl
:= First
(Declarations
(N
));
1268 while Nkind
(Decl
) /= N_Object_Declaration
1269 or else Defining_Identifier
(Decl
) /= Chain
1272 pragma Assert
(Present
(Decl
));
1276 Prepend_To
(New_Decls
, Decl
);
1279 -- Now we move the declarations into the Sequence of statements
1280 -- in order to get them protected by the AT END call. It may seem
1281 -- weird to put declarations in the sequence of statement but in
1282 -- fact nothing forbids that at the tree level. We also set the
1283 -- First_Real_Statement field so that we remember where the real
1284 -- statements (i.e. original statements) begin. Note that if we
1285 -- wrapped the statements, the first real statement is inside the
1286 -- inner block. If the First_Real_Statement is already set (as is
1287 -- the case for subprogram bodies that are expansions of task bodies)
1288 -- then do not reset it, because its declarative part would migrate
1289 -- to the statement part.
1292 if No
(First_Real_Statement
(Handled_Statement_Sequence
(N
))) then
1293 Set_First_Real_Statement
(Handled_Statement_Sequence
(N
),
1294 First
(Statements
(Handled_Statement_Sequence
(N
))));
1298 Set_First_Real_Statement
(Handled_Statement_Sequence
(N
), Blok
);
1301 Append_List_To
(Declarations
(N
),
1302 Statements
(Handled_Statement_Sequence
(N
)));
1303 Set_Statements
(Handled_Statement_Sequence
(N
), Declarations
(N
));
1305 -- We need to reset the Sloc of the handled statement sequence to
1306 -- properly reflect the new initial "statement" in the sequence.
1309 (Handled_Statement_Sequence
(N
), Sloc
(First
(Declarations
(N
))));
1311 -- The declarations of the _Clean procedure and finalization chain
1312 -- replace the old declarations that have been moved inward
1314 Set_Declarations
(N
, New_Decls
);
1315 Analyze_Declarations
(New_Decls
);
1317 -- The At_End call is attached to the sequence of statements
1323 -- If the construct is a protected subprogram, then the call to
1324 -- the corresponding unprotected program appears in a block which
1325 -- is the last statement in the body, and it is this block that
1326 -- must be covered by the At_End handler.
1328 if Is_Protected
then
1329 HSS
:= Handled_Statement_Sequence
1330 (Last
(Statements
(Handled_Statement_Sequence
(N
))));
1332 HSS
:= Handled_Statement_Sequence
(N
);
1335 Set_At_End_Proc
(HSS
, New_Occurrence_Of
(Clean
, Loc
));
1336 Expand_At_End_Handler
(HSS
, Empty
);
1339 -- Restore saved polling mode
1341 Polling_Required
:= Old_Poll
;
1342 end Expand_Cleanup_Actions
;
1344 -------------------------------
1345 -- Expand_Ctrl_Function_Call --
1346 -------------------------------
1348 procedure Expand_Ctrl_Function_Call
(N
: Node_Id
) is
1349 Loc
: constant Source_Ptr
:= Sloc
(N
);
1350 Rtype
: constant Entity_Id
:= Etype
(N
);
1351 Utype
: constant Entity_Id
:= Underlying_Type
(Rtype
);
1354 Action2
: Node_Id
:= Empty
;
1356 Attach_Level
: Uint
:= Uint_1
;
1357 Len_Ref
: Node_Id
:= Empty
;
1359 function Last_Array_Component
1361 Typ
: Entity_Id
) return Node_Id
;
1362 -- Creates a reference to the last component of the array object
1363 -- designated by Ref whose type is Typ.
1365 --------------------------
1366 -- Last_Array_Component --
1367 --------------------------
1369 function Last_Array_Component
1371 Typ
: Entity_Id
) return Node_Id
1373 Index_List
: constant List_Id
:= New_List
;
1376 for N
in 1 .. Number_Dimensions
(Typ
) loop
1377 Append_To
(Index_List
,
1378 Make_Attribute_Reference
(Loc
,
1379 Prefix
=> Duplicate_Subexpr_No_Checks
(Ref
),
1380 Attribute_Name
=> Name_Last
,
1381 Expressions
=> New_List
(
1382 Make_Integer_Literal
(Loc
, N
))));
1386 Make_Indexed_Component
(Loc
,
1387 Prefix
=> Duplicate_Subexpr
(Ref
),
1388 Expressions
=> Index_List
);
1389 end Last_Array_Component
;
1391 -- Start of processing for Expand_Ctrl_Function_Call
1394 -- Optimization, if the returned value (which is on the sec-stack)
1395 -- is returned again, no need to copy/readjust/finalize, we can just
1396 -- pass the value thru (see Expand_N_Return_Statement), and thus no
1397 -- attachment is needed
1399 if Nkind
(Parent
(N
)) = N_Return_Statement
then
1403 -- Resolution is now finished, make sure we don't start analysis again
1404 -- because of the duplication
1407 Ref
:= Duplicate_Subexpr_No_Checks
(N
);
1409 -- Now we can generate the Attach Call, note that this value is
1410 -- always in the (secondary) stack and thus is attached to a singly
1411 -- linked final list:
1413 -- Resx := F (X)'reference;
1414 -- Attach_To_Final_List (_Lx, Resx.all, 1);
1416 -- or when there are controlled components
1418 -- Attach_To_Final_List (_Lx, Resx._controller, 1);
1420 -- or when it is both is_controlled and has_controlled_components
1422 -- Attach_To_Final_List (_Lx, Resx._controller, 1);
1423 -- Attach_To_Final_List (_Lx, Resx, 1);
1425 -- or if it is an array with is_controlled (and has_controlled)
1427 -- Attach_To_Final_List (_Lx, Resx (Resx'last), 3);
1428 -- An attach level of 3 means that a whole array is to be
1429 -- attached to the finalization list (including the controlled
1432 -- or if it is an array with has_controlled components but not
1435 -- Attach_To_Final_List (_Lx, Resx (Resx'last)._controller, 3);
1437 if Has_Controlled_Component
(Rtype
) then
1439 T1
: Entity_Id
:= Rtype
;
1440 T2
: Entity_Id
:= Utype
;
1443 if Is_Array_Type
(T2
) then
1445 Make_Attribute_Reference
(Loc
,
1447 Duplicate_Subexpr_Move_Checks
1448 (Unchecked_Convert_To
(T2
, Ref
)),
1449 Attribute_Name
=> Name_Length
);
1452 while Is_Array_Type
(T2
) loop
1454 Ref
:= Unchecked_Convert_To
(T2
, Ref
);
1457 Ref
:= Last_Array_Component
(Ref
, T2
);
1458 Attach_Level
:= Uint_3
;
1459 T1
:= Component_Type
(T2
);
1460 T2
:= Underlying_Type
(T1
);
1463 -- If the type has controlled components, go to the controller
1464 -- except in the case of arrays of controlled objects since in
1465 -- this case objects and their components are already chained
1466 -- and the head of the chain is the last array element.
1468 if Is_Array_Type
(Rtype
) and then Is_Controlled
(T2
) then
1471 elsif Has_Controlled_Component
(T2
) then
1473 Ref
:= Unchecked_Convert_To
(T2
, Ref
);
1477 Make_Selected_Component
(Loc
,
1479 Selector_Name
=> Make_Identifier
(Loc
, Name_uController
));
1483 -- Here we know that 'Ref' has a controller so we may as well
1484 -- attach it directly
1489 Flist_Ref
=> Find_Final_List
(Current_Scope
),
1490 With_Attach
=> Make_Integer_Literal
(Loc
, Attach_Level
));
1492 -- If it is also Is_Controlled we need to attach the global object
1494 if Is_Controlled
(Rtype
) then
1497 Obj_Ref
=> Duplicate_Subexpr_No_Checks
(N
),
1498 Flist_Ref
=> Find_Final_List
(Current_Scope
),
1499 With_Attach
=> Make_Integer_Literal
(Loc
, Attach_Level
));
1503 -- Here, we have a controlled type that does not seem to have
1504 -- controlled components but it could be a class wide type whose
1505 -- further derivations have controlled components. So we don't know
1506 -- if the object itself needs to be attached or if it
1507 -- has a record controller. We need to call a runtime function
1508 -- (Deep_Tag_Attach) which knows what to do thanks to the
1509 -- RC_Offset in the dispatch table.
1512 Make_Procedure_Call_Statement
(Loc
,
1513 Name
=> New_Reference_To
(RTE
(RE_Deep_Tag_Attach
), Loc
),
1514 Parameter_Associations
=> New_List
(
1515 Find_Final_List
(Current_Scope
),
1517 Make_Attribute_Reference
(Loc
,
1519 Attribute_Name
=> Name_Address
),
1521 Make_Integer_Literal
(Loc
, Attach_Level
)));
1524 if Present
(Len_Ref
) then
1526 Make_Implicit_If_Statement
(N
,
1527 Condition
=> Make_Op_Gt
(Loc
,
1528 Left_Opnd
=> Len_Ref
,
1529 Right_Opnd
=> Make_Integer_Literal
(Loc
, 0)),
1530 Then_Statements
=> New_List
(Action
));
1533 Insert_Action
(N
, Action
);
1534 if Present
(Action2
) then
1535 Insert_Action
(N
, Action2
);
1537 end Expand_Ctrl_Function_Call
;
1539 ---------------------------
1540 -- Expand_N_Package_Body --
1541 ---------------------------
1543 -- Add call to Activate_Tasks if body is an activator (actual
1544 -- processing is in chapter 9).
1546 -- Generate subprogram descriptor for elaboration routine
1548 -- ENcode entity names in package body
1550 procedure Expand_N_Package_Body
(N
: Node_Id
) is
1551 Ent
: constant Entity_Id
:= Corresponding_Spec
(N
);
1554 -- This is done only for non-generic packages
1556 if Ekind
(Ent
) = E_Package
then
1557 New_Scope
(Corresponding_Spec
(N
));
1558 Build_Task_Activation_Call
(N
);
1562 Set_Elaboration_Flag
(N
, Corresponding_Spec
(N
));
1563 Set_In_Package_Body
(Ent
, False);
1565 -- Set to encode entity names in package body before gigi is called
1567 Qualify_Entity_Names
(N
);
1568 end Expand_N_Package_Body
;
1570 ----------------------------------
1571 -- Expand_N_Package_Declaration --
1572 ----------------------------------
1574 -- Add call to Activate_Tasks if there are tasks declared and the
1575 -- package has no body. Note that in Ada83, this may result in
1576 -- premature activation of some tasks, given that we cannot tell
1577 -- whether a body will eventually appear.
1579 procedure Expand_N_Package_Declaration
(N
: Node_Id
) is
1581 if Nkind
(Parent
(N
)) = N_Compilation_Unit
1582 and then not Body_Required
(Parent
(N
))
1583 and then not Unit_Requires_Body
(Defining_Entity
(N
))
1584 and then Present
(Activation_Chain_Entity
(N
))
1586 New_Scope
(Defining_Entity
(N
));
1587 Build_Task_Activation_Call
(N
);
1591 -- Note: it is not necessary to worry about generating a subprogram
1592 -- descriptor, since the only way to get exception handlers into a
1593 -- package spec is to include instantiations, and that would cause
1594 -- generation of subprogram descriptors to be delayed in any case.
1596 -- Set to encode entity names in package spec before gigi is called
1598 Qualify_Entity_Names
(N
);
1599 end Expand_N_Package_Declaration
;
1601 ---------------------
1602 -- Find_Final_List --
1603 ---------------------
1605 function Find_Final_List
1607 Ref
: Node_Id
:= Empty
) return Node_Id
1609 Loc
: constant Source_Ptr
:= Sloc
(Ref
);
1615 -- Case of an internal component. The Final list is the record
1616 -- controller of the enclosing record
1618 if Present
(Ref
) then
1622 when N_Unchecked_Type_Conversion | N_Type_Conversion
=>
1623 R
:= Expression
(R
);
1625 when N_Indexed_Component | N_Explicit_Dereference
=>
1628 when N_Selected_Component
=>
1632 when N_Identifier
=>
1636 raise Program_Error
;
1641 Make_Selected_Component
(Loc
,
1643 Make_Selected_Component
(Loc
,
1645 Selector_Name
=> Make_Identifier
(Loc
, Name_uController
)),
1646 Selector_Name
=> Make_Identifier
(Loc
, Name_F
));
1648 -- Case of a dynamically allocated object. The final list is the
1649 -- corresponding list controller (The next entity in the scope of
1650 -- the access type with the right type). If the type comes from a
1651 -- With_Type clause, no controller was created, and we use the
1652 -- global chain instead.
1654 elsif Is_Access_Type
(E
) then
1655 if not From_With_Type
(E
) then
1657 Make_Selected_Component
(Loc
,
1660 (Associated_Final_Chain
(Base_Type
(E
)), Loc
),
1661 Selector_Name
=> Make_Identifier
(Loc
, Name_F
));
1663 return New_Reference_To
(RTE
(RE_Global_Final_List
), Sloc
(E
));
1667 if Is_Dynamic_Scope
(E
) then
1670 S
:= Enclosing_Dynamic_Scope
(E
);
1673 -- When the finalization chain entity is 'Error', it means that
1674 -- there should not be any chain at that level and that the
1675 -- enclosing one should be used
1677 -- This is a nasty kludge, see ??? note in exp_ch11
1679 while Finalization_Chain_Entity
(S
) = Error
loop
1680 S
:= Enclosing_Dynamic_Scope
(S
);
1683 if S
= Standard_Standard
then
1684 return New_Reference_To
(RTE
(RE_Global_Final_List
), Sloc
(E
));
1686 if No
(Finalization_Chain_Entity
(S
)) then
1688 Id
:= Make_Defining_Identifier
(Sloc
(S
),
1689 New_Internal_Name
('F'));
1690 Set_Finalization_Chain_Entity
(S
, Id
);
1692 -- Set momentarily some semantics attributes to allow normal
1693 -- analysis of expansions containing references to this chain.
1694 -- Will be fully decorated during the expansion of the scope
1697 Set_Ekind
(Id
, E_Variable
);
1698 Set_Etype
(Id
, RTE
(RE_Finalizable_Ptr
));
1701 return New_Reference_To
(Finalization_Chain_Entity
(S
), Sloc
(E
));
1704 end Find_Final_List
;
1706 -----------------------------
1707 -- Find_Node_To_Be_Wrapped --
1708 -----------------------------
1710 function Find_Node_To_Be_Wrapped
(N
: Node_Id
) return Node_Id
is
1712 The_Parent
: Node_Id
;
1718 pragma Assert
(P
/= Empty
);
1719 The_Parent
:= Parent
(P
);
1721 case Nkind
(The_Parent
) is
1723 -- Simple statement can be wrapped
1728 -- Usually assignments are good candidate for wrapping
1729 -- except when they have been generated as part of a
1730 -- controlled aggregate where the wrapping should take
1731 -- place more globally.
1733 when N_Assignment_Statement
=>
1734 if No_Ctrl_Actions
(The_Parent
) then
1740 -- An entry call statement is a special case if it occurs in
1741 -- the context of a Timed_Entry_Call. In this case we wrap
1742 -- the entire timed entry call.
1744 when N_Entry_Call_Statement |
1745 N_Procedure_Call_Statement
=>
1746 if Nkind
(Parent
(The_Parent
)) = N_Entry_Call_Alternative
1748 (Nkind
(Parent
(Parent
(The_Parent
)))
1749 = N_Timed_Entry_Call
1751 Nkind
(Parent
(Parent
(The_Parent
)))
1752 = N_Conditional_Entry_Call
)
1754 return Parent
(Parent
(The_Parent
));
1759 -- Object declarations are also a boundary for the transient scope
1760 -- even if they are not really wrapped
1761 -- (see Wrap_Transient_Declaration)
1763 when N_Object_Declaration |
1764 N_Object_Renaming_Declaration |
1765 N_Subtype_Declaration
=>
1768 -- The expression itself is to be wrapped if its parent is a
1769 -- compound statement or any other statement where the expression
1770 -- is known to be scalar
1772 when N_Accept_Alternative |
1773 N_Attribute_Definition_Clause |
1776 N_Delay_Alternative |
1777 N_Delay_Until_Statement |
1778 N_Delay_Relative_Statement |
1779 N_Discriminant_Association |
1781 N_Entry_Body_Formal_Part |
1784 N_Iteration_Scheme |
1785 N_Terminate_Alternative
=>
1788 when N_Attribute_Reference
=>
1790 if Is_Procedure_Attribute_Name
1791 (Attribute_Name
(The_Parent
))
1796 -- If the expression is within the iteration scheme of a loop,
1797 -- we must create a declaration for it, followed by an assignment
1798 -- in order to have a usable statement to wrap.
1800 when N_Loop_Parameter_Specification
=>
1801 return Parent
(The_Parent
);
1803 -- The following nodes contains "dummy calls" which don't
1804 -- need to be wrapped.
1806 when N_Parameter_Specification |
1807 N_Discriminant_Specification |
1808 N_Component_Declaration
=>
1811 -- The return statement is not to be wrapped when the function
1812 -- itself needs wrapping at the outer-level
1814 when N_Return_Statement
=>
1815 if Requires_Transient_Scope
(Return_Type
(The_Parent
)) then
1821 -- If we leave a scope without having been able to find a node to
1822 -- wrap, something is going wrong but this can happen in error
1823 -- situation that are not detected yet (such as a dynamic string
1824 -- in a pragma export)
1826 when N_Subprogram_Body |
1827 N_Package_Declaration |
1829 N_Block_Statement
=>
1832 -- otherwise continue the search
1838 end Find_Node_To_Be_Wrapped
;
1840 ----------------------
1841 -- Global_Flist_Ref --
1842 ----------------------
1844 function Global_Flist_Ref
(Flist_Ref
: Node_Id
) return Boolean is
1848 -- Look for the Global_Final_List
1850 if Is_Entity_Name
(Flist_Ref
) then
1851 Flist
:= Entity
(Flist_Ref
);
1853 -- Look for the final list associated with an access to controlled
1855 elsif Nkind
(Flist_Ref
) = N_Selected_Component
1856 and then Is_Entity_Name
(Prefix
(Flist_Ref
))
1858 Flist
:= Entity
(Prefix
(Flist_Ref
));
1863 return Present
(Flist
)
1864 and then Present
(Scope
(Flist
))
1865 and then Enclosing_Dynamic_Scope
(Flist
) = Standard_Standard
;
1866 end Global_Flist_Ref
;
1868 ----------------------------------
1869 -- Has_New_Controlled_Component --
1870 ----------------------------------
1872 function Has_New_Controlled_Component
(E
: Entity_Id
) return Boolean is
1876 if not Is_Tagged_Type
(E
) then
1877 return Has_Controlled_Component
(E
);
1878 elsif not Is_Derived_Type
(E
) then
1879 return Has_Controlled_Component
(E
);
1882 Comp
:= First_Component
(E
);
1883 while Present
(Comp
) loop
1885 if Chars
(Comp
) = Name_uParent
then
1888 elsif Scope
(Original_Record_Component
(Comp
)) = E
1889 and then Controlled_Type
(Etype
(Comp
))
1894 Next_Component
(Comp
);
1898 end Has_New_Controlled_Component
;
1900 --------------------------
1901 -- In_Finalization_Root --
1902 --------------------------
1904 -- It would seem simpler to test Scope (RTE (RE_Root_Controlled)) but
1905 -- the purpose of this function is to avoid a circular call to Rtsfind
1906 -- which would been caused by such a test.
1908 function In_Finalization_Root
(E
: Entity_Id
) return Boolean is
1909 S
: constant Entity_Id
:= Scope
(E
);
1912 return Chars
(Scope
(S
)) = Name_System
1913 and then Chars
(S
) = Name_Finalization_Root
1914 and then Scope
(Scope
(S
)) = Standard_Standard
;
1915 end In_Finalization_Root
;
1917 ------------------------------------
1918 -- Insert_Actions_In_Scope_Around --
1919 ------------------------------------
1921 procedure Insert_Actions_In_Scope_Around
(N
: Node_Id
) is
1922 SE
: Scope_Stack_Entry
renames Scope_Stack
.Table
(Scope_Stack
.Last
);
1926 -- If the node to be wrapped is the triggering alternative of an
1927 -- asynchronous select, it is not part of a statement list. The
1928 -- actions must be inserted before the Select itself, which is
1929 -- part of some list of statements.
1931 if Nkind
(Parent
(Node_To_Be_Wrapped
)) = N_Triggering_Alternative
then
1932 Target
:= Parent
(Parent
(Node_To_Be_Wrapped
));
1937 if Present
(SE
.Actions_To_Be_Wrapped_Before
) then
1938 Insert_List_Before
(Target
, SE
.Actions_To_Be_Wrapped_Before
);
1939 SE
.Actions_To_Be_Wrapped_Before
:= No_List
;
1942 if Present
(SE
.Actions_To_Be_Wrapped_After
) then
1943 Insert_List_After
(Target
, SE
.Actions_To_Be_Wrapped_After
);
1944 SE
.Actions_To_Be_Wrapped_After
:= No_List
;
1946 end Insert_Actions_In_Scope_Around
;
1948 -----------------------
1949 -- Make_Adjust_Call --
1950 -----------------------
1952 function Make_Adjust_Call
1955 Flist_Ref
: Node_Id
;
1956 With_Attach
: Node_Id
) return List_Id
1958 Loc
: constant Source_Ptr
:= Sloc
(Ref
);
1959 Res
: constant List_Id
:= New_List
;
1962 Cref
: Node_Id
:= Ref
;
1964 Attach
: Node_Id
:= With_Attach
;
1967 if Is_Class_Wide_Type
(Typ
) then
1968 Utyp
:= Underlying_Type
(Base_Type
(Root_Type
(Typ
)));
1970 Utyp
:= Underlying_Type
(Base_Type
(Typ
));
1973 Set_Assignment_OK
(Cref
);
1975 -- Deal with non-tagged derivation of private views
1977 if Is_Untagged_Derivation
(Typ
) then
1978 Utyp
:= Underlying_Type
(Root_Type
(Base_Type
(Typ
)));
1979 Cref
:= Unchecked_Convert_To
(Utyp
, Cref
);
1980 Set_Assignment_OK
(Cref
);
1981 -- To prevent problems with UC see 1.156 RH ???
1984 -- If the underlying_type is a subtype, we are dealing with
1985 -- the completion of a private type. We need to access
1986 -- the base type and generate a conversion to it.
1988 if Utyp
/= Base_Type
(Utyp
) then
1989 pragma Assert
(Is_Private_Type
(Typ
));
1990 Utyp
:= Base_Type
(Utyp
);
1991 Cref
:= Unchecked_Convert_To
(Utyp
, Cref
);
1994 -- If the object is unanalyzed, set its expected type for use
1995 -- in Convert_View in case an additional conversion is needed.
1997 if No
(Etype
(Cref
))
1998 and then Nkind
(Cref
) /= N_Unchecked_Type_Conversion
2000 Set_Etype
(Cref
, Typ
);
2003 -- We do not need to attach to one of the Global Final Lists
2004 -- the objects whose type is Finalize_Storage_Only
2006 if Finalize_Storage_Only
(Typ
)
2007 and then (Global_Flist_Ref
(Flist_Ref
)
2008 or else Entity
(Constant_Value
(RTE
(RE_Garbage_Collected
)))
2011 Attach
:= Make_Integer_Literal
(Loc
, 0);
2015 -- Deep_Adjust (Flist_Ref, Ref, With_Attach);
2017 if Has_Controlled_Component
(Utyp
)
2018 or else Is_Class_Wide_Type
(Typ
)
2020 if Is_Tagged_Type
(Utyp
) then
2021 Proc
:= Find_Prim_Op
(Utyp
, TSS_Deep_Adjust
);
2024 Proc
:= TSS
(Utyp
, TSS_Deep_Adjust
);
2027 Cref
:= Convert_View
(Proc
, Cref
, 2);
2030 Make_Procedure_Call_Statement
(Loc
,
2031 Name
=> New_Reference_To
(Proc
, Loc
),
2032 Parameter_Associations
=>
2033 New_List
(Flist_Ref
, Cref
, Attach
)));
2036 -- if With_Attach then
2037 -- Attach_To_Final_List (Ref, Flist_Ref);
2041 else -- Is_Controlled (Utyp)
2043 Proc
:= Find_Prim_Op
(Utyp
, Name_Of
(Adjust_Case
));
2044 Cref
:= Convert_View
(Proc
, Cref
);
2045 Cref2
:= New_Copy_Tree
(Cref
);
2048 Make_Procedure_Call_Statement
(Loc
,
2049 Name
=> New_Reference_To
(Proc
, Loc
),
2050 Parameter_Associations
=> New_List
(Cref2
)));
2052 Append_To
(Res
, Make_Attach_Call
(Cref
, Flist_Ref
, Attach
));
2056 end Make_Adjust_Call
;
2058 ----------------------
2059 -- Make_Attach_Call --
2060 ----------------------
2063 -- System.FI.Attach_To_Final_List (Flist, Ref, Nb_Link)
2065 function Make_Attach_Call
2067 Flist_Ref
: Node_Id
;
2068 With_Attach
: Node_Id
) return Node_Id
2070 Loc
: constant Source_Ptr
:= Sloc
(Obj_Ref
);
2073 -- Optimization: If the number of links is statically '0', don't
2074 -- call the attach_proc.
2076 if Nkind
(With_Attach
) = N_Integer_Literal
2077 and then Intval
(With_Attach
) = Uint_0
2079 return Make_Null_Statement
(Loc
);
2083 Make_Procedure_Call_Statement
(Loc
,
2084 Name
=> New_Reference_To
(RTE
(RE_Attach_To_Final_List
), Loc
),
2085 Parameter_Associations
=> New_List
(
2087 OK_Convert_To
(RTE
(RE_Finalizable
), Obj_Ref
),
2089 end Make_Attach_Call
;
2101 Is_Master
: Boolean;
2102 Is_Protected_Subprogram
: Boolean;
2103 Is_Task_Allocation_Block
: Boolean;
2104 Is_Asynchronous_Call_Block
: Boolean) return Node_Id
2106 Loc
: constant Source_Ptr
:= Sloc
(Clean
);
2107 Stmt
: constant List_Id
:= New_List
;
2113 Param_Type
: Entity_Id
;
2114 Pid
: Entity_Id
:= Empty
;
2115 Cancel_Param
: Entity_Id
;
2119 if Restricted_Profile
then
2121 (Stmt
, Build_Runtime_Call
(Loc
, RE_Complete_Restricted_Task
));
2123 Append_To
(Stmt
, Build_Runtime_Call
(Loc
, RE_Complete_Task
));
2126 elsif Is_Master
then
2127 if Restriction_Active
(No_Task_Hierarchy
) = False then
2128 Append_To
(Stmt
, Build_Runtime_Call
(Loc
, RE_Complete_Master
));
2131 elsif Is_Protected_Subprogram
then
2133 -- Add statements to the cleanup handler of the (ordinary)
2134 -- subprogram expanded to implement a protected subprogram,
2135 -- unlocking the protected object parameter and undeferring abort.
2136 -- If this is a protected procedure, and the object contains
2137 -- entries, this also calls the entry service routine.
2139 -- NOTE: This cleanup handler references _object, a parameter
2140 -- to the procedure.
2142 -- Find the _object parameter representing the protected object
2144 Spec
:= Parent
(Corresponding_Spec
(N
));
2146 Param
:= First
(Parameter_Specifications
(Spec
));
2148 Param_Type
:= Etype
(Parameter_Type
(Param
));
2150 if Ekind
(Param_Type
) = E_Record_Type
then
2151 Pid
:= Corresponding_Concurrent_Type
(Param_Type
);
2154 exit when not Present
(Param
) or else Present
(Pid
);
2158 pragma Assert
(Present
(Param
));
2160 -- If the associated protected object declares entries,
2161 -- a protected procedure has to service entry queues.
2162 -- In this case, add
2164 -- Service_Entries (_object._object'Access);
2166 -- _object is the record used to implement the protected object.
2167 -- It is a parameter to the protected subprogram.
2169 if Nkind
(Specification
(N
)) = N_Procedure_Specification
2170 and then Has_Entries
(Pid
)
2173 or else Restriction_Active
(No_Entry_Queue
) = False
2174 or else Number_Entries
(Pid
) > 1
2176 Name
:= New_Reference_To
(RTE
(RE_Service_Entries
), Loc
);
2178 Name
:= New_Reference_To
(RTE
(RE_Service_Entry
), Loc
);
2182 Make_Procedure_Call_Statement
(Loc
,
2184 Parameter_Associations
=> New_List
(
2185 Make_Attribute_Reference
(Loc
,
2187 Make_Selected_Component
(Loc
,
2188 Prefix
=> New_Reference_To
(
2189 Defining_Identifier
(Param
), Loc
),
2191 Make_Identifier
(Loc
, Name_uObject
)),
2192 Attribute_Name
=> Name_Unchecked_Access
))));
2195 -- Unlock (_object._object'Access);
2197 -- object is the record used to implement the protected object.
2198 -- It is a parameter to the protected subprogram.
2200 -- If the protected object is controlled (i.e it has entries or
2201 -- needs finalization for interrupt handling), call
2202 -- Unlock_Entries, except if the protected object follows the
2203 -- ravenscar profile, in which case call Unlock_Entry, otherwise
2204 -- call the simplified version, Unlock.
2206 if Has_Entries
(Pid
)
2207 or else Has_Interrupt_Handler
(Pid
)
2208 or else (Has_Attach_Handler
(Pid
)
2209 and then not Restricted_Profile
)
2210 or else (Ada_Version
>= Ada_05
2211 and then Present
(Interface_List
(Parent
(Pid
))))
2214 or else Restriction_Active
(No_Entry_Queue
) = False
2215 or else Number_Entries
(Pid
) > 1
2217 Name
:= New_Reference_To
(RTE
(RE_Unlock_Entries
), Loc
);
2219 Name
:= New_Reference_To
(RTE
(RE_Unlock_Entry
), Loc
);
2223 Name
:= New_Reference_To
(RTE
(RE_Unlock
), Loc
);
2227 Make_Procedure_Call_Statement
(Loc
,
2229 Parameter_Associations
=> New_List
(
2230 Make_Attribute_Reference
(Loc
,
2232 Make_Selected_Component
(Loc
,
2234 New_Reference_To
(Defining_Identifier
(Param
), Loc
),
2236 Make_Identifier
(Loc
, Name_uObject
)),
2237 Attribute_Name
=> Name_Unchecked_Access
))));
2240 if Abort_Allowed
then
2245 Make_Procedure_Call_Statement
(Loc
,
2248 RTE
(RE_Abort_Undefer
), Loc
),
2249 Parameter_Associations
=> Empty_List
));
2252 elsif Is_Task_Allocation_Block
then
2254 -- Add a call to Expunge_Unactivated_Tasks to the cleanup
2255 -- handler of a block created for the dynamic allocation of
2258 -- Expunge_Unactivated_Tasks (_chain);
2260 -- where _chain is the list of tasks created by the allocator
2261 -- but not yet activated. This list will be empty unless
2262 -- the block completes abnormally.
2264 -- This only applies to dynamically allocated tasks;
2265 -- other unactivated tasks are completed by Complete_Task or
2268 -- NOTE: This cleanup handler references _chain, a local
2272 Make_Procedure_Call_Statement
(Loc
,
2275 RTE
(RE_Expunge_Unactivated_Tasks
), Loc
),
2276 Parameter_Associations
=> New_List
(
2277 New_Reference_To
(Activation_Chain_Entity
(N
), Loc
))));
2279 elsif Is_Asynchronous_Call_Block
then
2281 -- Add a call to attempt to cancel the asynchronous entry call
2282 -- whenever the block containing the abortable part is exited.
2284 -- NOTE: This cleanup handler references C, a local object
2286 -- Get the argument to the Cancel procedure
2287 Cancel_Param
:= Entry_Cancel_Parameter
(Entity
(Identifier
(N
)));
2289 -- If it is of type Communication_Block, this must be a
2290 -- protected entry call.
2292 if Is_RTE
(Etype
(Cancel_Param
), RE_Communication_Block
) then
2296 -- if Enqueued (Cancel_Parameter) then
2298 Make_Implicit_If_Statement
(Clean
,
2299 Condition
=> Make_Function_Call
(Loc
,
2300 Name
=> New_Reference_To
(
2301 RTE
(RE_Enqueued
), Loc
),
2302 Parameter_Associations
=> New_List
(
2303 New_Reference_To
(Cancel_Param
, Loc
))),
2304 Then_Statements
=> New_List
(
2306 -- Cancel_Protected_Entry_Call (Cancel_Param);
2308 Make_Procedure_Call_Statement
(Loc
,
2309 Name
=> New_Reference_To
(
2310 RTE
(RE_Cancel_Protected_Entry_Call
), Loc
),
2311 Parameter_Associations
=> New_List
(
2312 New_Reference_To
(Cancel_Param
, Loc
))))));
2314 -- Asynchronous delay
2316 elsif Is_RTE
(Etype
(Cancel_Param
), RE_Delay_Block
) then
2318 Make_Procedure_Call_Statement
(Loc
,
2319 Name
=> New_Reference_To
(RTE
(RE_Cancel_Async_Delay
), Loc
),
2320 Parameter_Associations
=> New_List
(
2321 Make_Attribute_Reference
(Loc
,
2322 Prefix
=> New_Reference_To
(Cancel_Param
, Loc
),
2323 Attribute_Name
=> Name_Unchecked_Access
))));
2328 -- Append call to Cancel_Task_Entry_Call (C);
2331 Make_Procedure_Call_Statement
(Loc
,
2332 Name
=> New_Reference_To
(
2333 RTE
(RE_Cancel_Task_Entry_Call
),
2335 Parameter_Associations
=> New_List
(
2336 New_Reference_To
(Cancel_Param
, Loc
))));
2341 if Present
(Flist
) then
2343 Make_Procedure_Call_Statement
(Loc
,
2344 Name
=> New_Reference_To
(RTE
(RE_Finalize_List
), Loc
),
2345 Parameter_Associations
=> New_List
(
2346 New_Reference_To
(Flist
, Loc
))));
2349 if Present
(Mark
) then
2351 Make_Procedure_Call_Statement
(Loc
,
2352 Name
=> New_Reference_To
(RTE
(RE_SS_Release
), Loc
),
2353 Parameter_Associations
=> New_List
(
2354 New_Reference_To
(Mark
, Loc
))));
2358 Make_Subprogram_Body
(Loc
,
2360 Make_Procedure_Specification
(Loc
,
2361 Defining_Unit_Name
=> Clean
),
2363 Declarations
=> New_List
,
2365 Handled_Statement_Sequence
=>
2366 Make_Handled_Sequence_Of_Statements
(Loc
,
2367 Statements
=> Stmt
));
2369 if Present
(Flist
) or else Is_Task
or else Is_Master
then
2370 Wrap_Cleanup_Procedure
(Sbody
);
2373 -- We do not want debug information for _Clean routines,
2374 -- since it just confuses the debugging operation unless
2375 -- we are debugging generated code.
2377 if not Debug_Generated_Code
then
2378 Set_Debug_Info_Off
(Clean
, True);
2384 --------------------------
2385 -- Make_Deep_Array_Body --
2386 --------------------------
2388 -- Array components are initialized and adjusted in the normal order
2389 -- and finalized in the reverse order. Exceptions are handled and
2390 -- Program_Error is re-raise in the Adjust and Finalize case
2391 -- (RM 7.6.1(12)). Generate the following code :
2393 -- procedure Deep_<P> -- with <P> being Initialize or Adjust or Finalize
2394 -- (L : in out Finalizable_Ptr;
2398 -- for J1 in Typ'First (1) .. Typ'Last (1) loop
2399 -- ^ reverse ^ -- in the finalization case
2401 -- for J2 in Typ'First (n) .. Typ'Last (n) loop
2402 -- Make_<P>_Call (Typ, V (J1, .. , Jn), L, V);
2406 -- exception -- not in the
2407 -- when others => raise Program_Error; -- Initialize case
2410 function Make_Deep_Array_Body
2411 (Prim
: Final_Primitives
;
2412 Typ
: Entity_Id
) return List_Id
2414 Loc
: constant Source_Ptr
:= Sloc
(Typ
);
2416 Index_List
: constant List_Id
:= New_List
;
2417 -- Stores the list of references to the indexes (one per dimension)
2419 function One_Component
return List_Id
;
2420 -- Create one statement to initialize/adjust/finalize one array
2421 -- component, designated by a full set of indices.
2423 function One_Dimension
(N
: Int
) return List_Id
;
2424 -- Create loop to deal with one dimension of the array. The single
2425 -- statement in the body of the loop initializes the inner dimensions if
2426 -- any, or else a single component.
2432 function One_Component
return List_Id
is
2433 Comp_Typ
: constant Entity_Id
:= Component_Type
(Typ
);
2434 Comp_Ref
: constant Node_Id
:=
2435 Make_Indexed_Component
(Loc
,
2436 Prefix
=> Make_Identifier
(Loc
, Name_V
),
2437 Expressions
=> Index_List
);
2440 -- Set the etype of the component Reference, which is used to
2441 -- determine whether a conversion to a parent type is needed.
2443 Set_Etype
(Comp_Ref
, Comp_Typ
);
2446 when Initialize_Case
=>
2447 return Make_Init_Call
(Comp_Ref
, Comp_Typ
,
2448 Make_Identifier
(Loc
, Name_L
),
2449 Make_Identifier
(Loc
, Name_B
));
2452 return Make_Adjust_Call
(Comp_Ref
, Comp_Typ
,
2453 Make_Identifier
(Loc
, Name_L
),
2454 Make_Identifier
(Loc
, Name_B
));
2456 when Finalize_Case
=>
2457 return Make_Final_Call
(Comp_Ref
, Comp_Typ
,
2458 Make_Identifier
(Loc
, Name_B
));
2466 function One_Dimension
(N
: Int
) return List_Id
is
2470 if N
> Number_Dimensions
(Typ
) then
2471 return One_Component
;
2475 Make_Defining_Identifier
(Loc
, New_External_Name
('J', N
));
2477 Append_To
(Index_List
, New_Reference_To
(Index
, Loc
));
2480 Make_Implicit_Loop_Statement
(Typ
,
2481 Identifier
=> Empty
,
2483 Make_Iteration_Scheme
(Loc
,
2484 Loop_Parameter_Specification
=>
2485 Make_Loop_Parameter_Specification
(Loc
,
2486 Defining_Identifier
=> Index
,
2487 Discrete_Subtype_Definition
=>
2488 Make_Attribute_Reference
(Loc
,
2489 Prefix
=> Make_Identifier
(Loc
, Name_V
),
2490 Attribute_Name
=> Name_Range
,
2491 Expressions
=> New_List
(
2492 Make_Integer_Literal
(Loc
, N
))),
2493 Reverse_Present
=> Prim
= Finalize_Case
)),
2494 Statements
=> One_Dimension
(N
+ 1)));
2498 -- Start of processing for Make_Deep_Array_Body
2501 return One_Dimension
(1);
2502 end Make_Deep_Array_Body
;
2504 --------------------
2505 -- Make_Deep_Proc --
2506 --------------------
2509 -- procedure DEEP_<prim>
2510 -- (L : IN OUT Finalizable_Ptr; -- not for Finalize
2511 -- V : IN OUT <typ>;
2512 -- B : IN Short_Short_Integer) is
2515 -- exception -- Finalize and Adjust Cases only
2516 -- raise Program_Error; -- idem
2519 function Make_Deep_Proc
2520 (Prim
: Final_Primitives
;
2522 Stmts
: List_Id
) return Entity_Id
2524 Loc
: constant Source_Ptr
:= Sloc
(Typ
);
2526 Proc_Name
: Entity_Id
;
2527 Handler
: List_Id
:= No_List
;
2531 if Prim
= Finalize_Case
then
2532 Formals
:= New_List
;
2533 Type_B
:= Standard_Boolean
;
2536 Formals
:= New_List
(
2537 Make_Parameter_Specification
(Loc
,
2538 Defining_Identifier
=> Make_Defining_Identifier
(Loc
, Name_L
),
2540 Out_Present
=> True,
2542 New_Reference_To
(RTE
(RE_Finalizable_Ptr
), Loc
)));
2543 Type_B
:= Standard_Short_Short_Integer
;
2547 Make_Parameter_Specification
(Loc
,
2548 Defining_Identifier
=> Make_Defining_Identifier
(Loc
, Name_V
),
2550 Out_Present
=> True,
2551 Parameter_Type
=> New_Reference_To
(Typ
, Loc
)));
2554 Make_Parameter_Specification
(Loc
,
2555 Defining_Identifier
=> Make_Defining_Identifier
(Loc
, Name_B
),
2556 Parameter_Type
=> New_Reference_To
(Type_B
, Loc
)));
2558 if Prim
= Finalize_Case
or else Prim
= Adjust_Case
then
2559 Handler
:= New_List
(
2560 Make_Exception_Handler
(Loc
,
2561 Exception_Choices
=> New_List
(Make_Others_Choice
(Loc
)),
2562 Statements
=> New_List
(
2563 Make_Raise_Program_Error
(Loc
,
2564 Reason
=> PE_Finalize_Raised_Exception
))));
2568 Make_Defining_Identifier
(Loc
,
2569 Chars
=> Make_TSS_Name
(Typ
, Deep_Name_Of
(Prim
)));
2572 Make_Subprogram_Body
(Loc
,
2574 Make_Procedure_Specification
(Loc
,
2575 Defining_Unit_Name
=> Proc_Name
,
2576 Parameter_Specifications
=> Formals
),
2578 Declarations
=> Empty_List
,
2579 Handled_Statement_Sequence
=>
2580 Make_Handled_Sequence_Of_Statements
(Loc
,
2581 Statements
=> Stmts
,
2582 Exception_Handlers
=> Handler
)));
2587 ---------------------------
2588 -- Make_Deep_Record_Body --
2589 ---------------------------
2591 -- The Deep procedures call the appropriate Controlling proc on the
2592 -- the controller component. In the init case, it also attach the
2593 -- controller to the current finalization list.
2595 function Make_Deep_Record_Body
2596 (Prim
: Final_Primitives
;
2597 Typ
: Entity_Id
) return List_Id
2599 Loc
: constant Source_Ptr
:= Sloc
(Typ
);
2600 Controller_Typ
: Entity_Id
;
2601 Obj_Ref
: constant Node_Id
:= Make_Identifier
(Loc
, Name_V
);
2602 Controller_Ref
: constant Node_Id
:=
2603 Make_Selected_Component
(Loc
,
2606 Make_Identifier
(Loc
, Name_uController
));
2607 Res
: constant List_Id
:= New_List
;
2610 if Is_Return_By_Reference_Type
(Typ
) then
2611 Controller_Typ
:= RTE
(RE_Limited_Record_Controller
);
2613 Controller_Typ
:= RTE
(RE_Record_Controller
);
2617 when Initialize_Case
=>
2618 Append_List_To
(Res
,
2620 Ref
=> Controller_Ref
,
2621 Typ
=> Controller_Typ
,
2622 Flist_Ref
=> Make_Identifier
(Loc
, Name_L
),
2623 With_Attach
=> Make_Identifier
(Loc
, Name_B
)));
2625 -- When the type is also a controlled type by itself,
2626 -- Initialize it and attach it to the finalization chain
2628 if Is_Controlled
(Typ
) then
2630 Make_Procedure_Call_Statement
(Loc
,
2631 Name
=> New_Reference_To
(
2632 Find_Prim_Op
(Typ
, Name_Of
(Prim
)), Loc
),
2633 Parameter_Associations
=>
2634 New_List
(New_Copy_Tree
(Obj_Ref
))));
2636 Append_To
(Res
, Make_Attach_Call
(
2637 Obj_Ref
=> New_Copy_Tree
(Obj_Ref
),
2638 Flist_Ref
=> Make_Identifier
(Loc
, Name_L
),
2639 With_Attach
=> Make_Identifier
(Loc
, Name_B
)));
2643 Append_List_To
(Res
,
2644 Make_Adjust_Call
(Controller_Ref
, Controller_Typ
,
2645 Make_Identifier
(Loc
, Name_L
),
2646 Make_Identifier
(Loc
, Name_B
)));
2648 -- When the type is also a controlled type by itself,
2649 -- Adjust it it and attach it to the finalization chain
2651 if Is_Controlled
(Typ
) then
2653 Make_Procedure_Call_Statement
(Loc
,
2654 Name
=> New_Reference_To
(
2655 Find_Prim_Op
(Typ
, Name_Of
(Prim
)), Loc
),
2656 Parameter_Associations
=>
2657 New_List
(New_Copy_Tree
(Obj_Ref
))));
2659 Append_To
(Res
, Make_Attach_Call
(
2660 Obj_Ref
=> New_Copy_Tree
(Obj_Ref
),
2661 Flist_Ref
=> Make_Identifier
(Loc
, Name_L
),
2662 With_Attach
=> Make_Identifier
(Loc
, Name_B
)));
2665 when Finalize_Case
=>
2666 if Is_Controlled
(Typ
) then
2668 Make_Implicit_If_Statement
(Obj_Ref
,
2669 Condition
=> Make_Identifier
(Loc
, Name_B
),
2670 Then_Statements
=> New_List
(
2671 Make_Procedure_Call_Statement
(Loc
,
2672 Name
=> New_Reference_To
(RTE
(RE_Finalize_One
), Loc
),
2673 Parameter_Associations
=> New_List
(
2674 OK_Convert_To
(RTE
(RE_Finalizable
),
2675 New_Copy_Tree
(Obj_Ref
))))),
2677 Else_Statements
=> New_List
(
2678 Make_Procedure_Call_Statement
(Loc
,
2679 Name
=> New_Reference_To
(
2680 Find_Prim_Op
(Typ
, Name_Of
(Prim
)), Loc
),
2681 Parameter_Associations
=>
2682 New_List
(New_Copy_Tree
(Obj_Ref
))))));
2685 Append_List_To
(Res
,
2686 Make_Final_Call
(Controller_Ref
, Controller_Typ
,
2687 Make_Identifier
(Loc
, Name_B
)));
2690 end Make_Deep_Record_Body
;
2692 ----------------------
2693 -- Make_Final_Call --
2694 ----------------------
2696 function Make_Final_Call
2699 With_Detach
: Node_Id
) return List_Id
2701 Loc
: constant Source_Ptr
:= Sloc
(Ref
);
2702 Res
: constant List_Id
:= New_List
;
2709 if Is_Class_Wide_Type
(Typ
) then
2710 Utyp
:= Root_Type
(Typ
);
2713 elsif Is_Concurrent_Type
(Typ
) then
2714 Utyp
:= Corresponding_Record_Type
(Typ
);
2715 Cref
:= Convert_Concurrent
(Ref
, Typ
);
2717 elsif Is_Private_Type
(Typ
)
2718 and then Present
(Full_View
(Typ
))
2719 and then Is_Concurrent_Type
(Full_View
(Typ
))
2721 Utyp
:= Corresponding_Record_Type
(Full_View
(Typ
));
2722 Cref
:= Convert_Concurrent
(Ref
, Full_View
(Typ
));
2728 Utyp
:= Underlying_Type
(Base_Type
(Utyp
));
2729 Set_Assignment_OK
(Cref
);
2731 -- Deal with non-tagged derivation of private views
2733 if Is_Untagged_Derivation
(Typ
) then
2734 Utyp
:= Underlying_Type
(Root_Type
(Base_Type
(Typ
)));
2735 Cref
:= Unchecked_Convert_To
(Utyp
, Cref
);
2736 Set_Assignment_OK
(Cref
);
2737 -- To prevent problems with UC see 1.156 RH ???
2740 -- If the underlying_type is a subtype, we are dealing with
2741 -- the completion of a private type. We need to access
2742 -- the base type and generate a conversion to it.
2744 if Utyp
/= Base_Type
(Utyp
) then
2745 pragma Assert
(Is_Private_Type
(Typ
));
2746 Utyp
:= Base_Type
(Utyp
);
2747 Cref
:= Unchecked_Convert_To
(Utyp
, Cref
);
2751 -- Deep_Finalize (Ref, With_Detach);
2753 if Has_Controlled_Component
(Utyp
)
2754 or else Is_Class_Wide_Type
(Typ
)
2756 if Is_Tagged_Type
(Utyp
) then
2757 Proc
:= Find_Prim_Op
(Utyp
, TSS_Deep_Finalize
);
2759 Proc
:= TSS
(Utyp
, TSS_Deep_Finalize
);
2762 Cref
:= Convert_View
(Proc
, Cref
);
2765 Make_Procedure_Call_Statement
(Loc
,
2766 Name
=> New_Reference_To
(Proc
, Loc
),
2767 Parameter_Associations
=>
2768 New_List
(Cref
, With_Detach
)));
2771 -- if With_Detach then
2772 -- Finalize_One (Ref);
2778 Proc
:= Find_Prim_Op
(Utyp
, Name_Of
(Finalize_Case
));
2780 if Chars
(With_Detach
) = Chars
(Standard_True
) then
2782 Make_Procedure_Call_Statement
(Loc
,
2783 Name
=> New_Reference_To
(RTE
(RE_Finalize_One
), Loc
),
2784 Parameter_Associations
=> New_List
(
2785 OK_Convert_To
(RTE
(RE_Finalizable
), Cref
))));
2787 elsif Chars
(With_Detach
) = Chars
(Standard_False
) then
2789 Make_Procedure_Call_Statement
(Loc
,
2790 Name
=> New_Reference_To
(Proc
, Loc
),
2791 Parameter_Associations
=>
2792 New_List
(Convert_View
(Proc
, Cref
))));
2795 Cref2
:= New_Copy_Tree
(Cref
);
2797 Make_Implicit_If_Statement
(Ref
,
2798 Condition
=> With_Detach
,
2799 Then_Statements
=> New_List
(
2800 Make_Procedure_Call_Statement
(Loc
,
2801 Name
=> New_Reference_To
(RTE
(RE_Finalize_One
), Loc
),
2802 Parameter_Associations
=> New_List
(
2803 OK_Convert_To
(RTE
(RE_Finalizable
), Cref
)))),
2805 Else_Statements
=> New_List
(
2806 Make_Procedure_Call_Statement
(Loc
,
2807 Name
=> New_Reference_To
(Proc
, Loc
),
2808 Parameter_Associations
=>
2809 New_List
(Convert_View
(Proc
, Cref2
))))));
2814 end Make_Final_Call
;
2816 --------------------
2817 -- Make_Init_Call --
2818 --------------------
2820 function Make_Init_Call
2823 Flist_Ref
: Node_Id
;
2824 With_Attach
: Node_Id
) return List_Id
2826 Loc
: constant Source_Ptr
:= Sloc
(Ref
);
2828 Res
: constant List_Id
:= New_List
;
2833 Attach
: Node_Id
:= With_Attach
;
2836 if Is_Concurrent_Type
(Typ
) then
2838 Utyp
:= Corresponding_Record_Type
(Typ
);
2839 Cref
:= Convert_Concurrent
(Ref
, Typ
);
2841 elsif Is_Private_Type
(Typ
)
2842 and then Present
(Full_View
(Typ
))
2843 and then Is_Concurrent_Type
(Underlying_Type
(Typ
))
2846 Utyp
:= Corresponding_Record_Type
(Underlying_Type
(Typ
));
2847 Cref
:= Convert_Concurrent
(Ref
, Underlying_Type
(Typ
));
2855 Utyp
:= Underlying_Type
(Base_Type
(Utyp
));
2857 Set_Assignment_OK
(Cref
);
2859 -- Deal with non-tagged derivation of private views
2861 if Is_Untagged_Derivation
(Typ
)
2862 and then not Is_Conc
2864 Utyp
:= Underlying_Type
(Root_Type
(Base_Type
(Typ
)));
2865 Cref
:= Unchecked_Convert_To
(Utyp
, Cref
);
2866 Set_Assignment_OK
(Cref
);
2867 -- To prevent problems with UC see 1.156 RH ???
2870 -- If the underlying_type is a subtype, we are dealing with
2871 -- the completion of a private type. We need to access
2872 -- the base type and generate a conversion to it.
2874 if Utyp
/= Base_Type
(Utyp
) then
2875 pragma Assert
(Is_Private_Type
(Typ
));
2876 Utyp
:= Base_Type
(Utyp
);
2877 Cref
:= Unchecked_Convert_To
(Utyp
, Cref
);
2880 -- We do not need to attach to one of the Global Final Lists
2881 -- the objects whose type is Finalize_Storage_Only
2883 if Finalize_Storage_Only
(Typ
)
2884 and then (Global_Flist_Ref
(Flist_Ref
)
2885 or else Entity
(Constant_Value
(RTE
(RE_Garbage_Collected
)))
2888 Attach
:= Make_Integer_Literal
(Loc
, 0);
2892 -- Deep_Initialize (Ref, Flist_Ref);
2894 if Has_Controlled_Component
(Utyp
) then
2895 Proc
:= TSS
(Utyp
, Deep_Name_Of
(Initialize_Case
));
2897 Cref
:= Convert_View
(Proc
, Cref
, 2);
2900 Make_Procedure_Call_Statement
(Loc
,
2901 Name
=> New_Reference_To
(Proc
, Loc
),
2902 Parameter_Associations
=> New_List
(
2908 -- Attach_To_Final_List (Ref, Flist_Ref);
2909 -- Initialize (Ref);
2911 else -- Is_Controlled (Utyp)
2912 Proc
:= Find_Prim_Op
(Utyp
, Name_Of
(Initialize_Case
));
2913 Check_Visibly_Controlled
(Initialize_Case
, Typ
, Proc
, Cref
);
2915 Cref
:= Convert_View
(Proc
, Cref
);
2916 Cref2
:= New_Copy_Tree
(Cref
);
2919 Make_Procedure_Call_Statement
(Loc
,
2920 Name
=> New_Reference_To
(Proc
, Loc
),
2921 Parameter_Associations
=> New_List
(Cref2
)));
2924 Make_Attach_Call
(Cref
, Flist_Ref
, Attach
));
2930 --------------------------
2931 -- Make_Transient_Block --
2932 --------------------------
2934 -- If finalization is involved, this function just wraps the instruction
2935 -- into a block whose name is the transient block entity, and then
2936 -- Expand_Cleanup_Actions (called on the expansion of the handled
2937 -- sequence of statements will do the necessary expansions for
2940 function Make_Transient_Block
2942 Action
: Node_Id
) return Node_Id
2944 Flist
: constant Entity_Id
:= Finalization_Chain_Entity
(Current_Scope
);
2945 Decls
: constant List_Id
:= New_List
;
2946 Par
: constant Node_Id
:= Parent
(Action
);
2947 Instrs
: constant List_Id
:= New_List
(Action
);
2951 -- Case where only secondary stack use is involved
2953 if Uses_Sec_Stack
(Current_Scope
)
2955 and then Nkind
(Action
) /= N_Return_Statement
2956 and then Nkind
(Par
) /= N_Exception_Handler
2963 S
:= Scope
(Current_Scope
);
2967 -- At the outer level, no need to release the sec stack
2969 if S
= Standard_Standard
then
2970 Set_Uses_Sec_Stack
(Current_Scope
, False);
2973 -- In a function, only release the sec stack if the
2974 -- function does not return on the sec stack otherwise
2975 -- the result may be lost. The caller is responsible for
2978 elsif K
= E_Function
then
2979 Set_Uses_Sec_Stack
(Current_Scope
, False);
2981 if not Requires_Transient_Scope
(Etype
(S
)) then
2982 if not Functions_Return_By_DSP_On_Target
then
2983 Set_Uses_Sec_Stack
(S
, True);
2984 Check_Restriction
(No_Secondary_Stack
, Action
);
2990 -- In a loop or entry we should install a block encompassing
2991 -- all the construct. For now just release right away.
2993 elsif K
= E_Loop
or else K
= E_Entry
then
2996 -- In a procedure or a block, we release on exit of the
2997 -- procedure or block. ??? memory leak can be created by
3000 elsif K
= E_Procedure
3003 if not Functions_Return_By_DSP_On_Target
then
3004 Set_Uses_Sec_Stack
(S
, True);
3005 Check_Restriction
(No_Secondary_Stack
, Action
);
3008 Set_Uses_Sec_Stack
(Current_Scope
, False);
3018 -- Insert actions stuck in the transient scopes as well as all
3019 -- freezing nodes needed by those actions
3021 Insert_Actions_In_Scope_Around
(Action
);
3024 Last_Inserted
: Node_Id
:= Prev
(Action
);
3027 if Present
(Last_Inserted
) then
3028 Freeze_All
(First_Entity
(Current_Scope
), Last_Inserted
);
3033 Make_Block_Statement
(Loc
,
3034 Identifier
=> New_Reference_To
(Current_Scope
, Loc
),
3035 Declarations
=> Decls
,
3036 Handled_Statement_Sequence
=>
3037 Make_Handled_Sequence_Of_Statements
(Loc
, Statements
=> Instrs
),
3038 Has_Created_Identifier
=> True);
3040 -- When the transient scope was established, we pushed the entry for
3041 -- the transient scope onto the scope stack, so that the scope was
3042 -- active for the installation of finalizable entities etc. Now we
3043 -- must remove this entry, since we have constructed a proper block.
3048 end Make_Transient_Block
;
3050 ------------------------
3051 -- Node_To_Be_Wrapped --
3052 ------------------------
3054 function Node_To_Be_Wrapped
return Node_Id
is
3056 return Scope_Stack
.Table
(Scope_Stack
.Last
).Node_To_Be_Wrapped
;
3057 end Node_To_Be_Wrapped
;
3059 ----------------------------
3060 -- Set_Node_To_Be_Wrapped --
3061 ----------------------------
3063 procedure Set_Node_To_Be_Wrapped
(N
: Node_Id
) is
3065 Scope_Stack
.Table
(Scope_Stack
.Last
).Node_To_Be_Wrapped
:= N
;
3066 end Set_Node_To_Be_Wrapped
;
3068 ----------------------------------
3069 -- Store_After_Actions_In_Scope --
3070 ----------------------------------
3072 procedure Store_After_Actions_In_Scope
(L
: List_Id
) is
3073 SE
: Scope_Stack_Entry
renames Scope_Stack
.Table
(Scope_Stack
.Last
);
3076 if Present
(SE
.Actions_To_Be_Wrapped_After
) then
3077 Insert_List_Before_And_Analyze
(
3078 First
(SE
.Actions_To_Be_Wrapped_After
), L
);
3081 SE
.Actions_To_Be_Wrapped_After
:= L
;
3083 if Is_List_Member
(SE
.Node_To_Be_Wrapped
) then
3084 Set_Parent
(L
, Parent
(SE
.Node_To_Be_Wrapped
));
3086 Set_Parent
(L
, SE
.Node_To_Be_Wrapped
);
3091 end Store_After_Actions_In_Scope
;
3093 -----------------------------------
3094 -- Store_Before_Actions_In_Scope --
3095 -----------------------------------
3097 procedure Store_Before_Actions_In_Scope
(L
: List_Id
) is
3098 SE
: Scope_Stack_Entry
renames Scope_Stack
.Table
(Scope_Stack
.Last
);
3101 if Present
(SE
.Actions_To_Be_Wrapped_Before
) then
3102 Insert_List_After_And_Analyze
(
3103 Last
(SE
.Actions_To_Be_Wrapped_Before
), L
);
3106 SE
.Actions_To_Be_Wrapped_Before
:= L
;
3108 if Is_List_Member
(SE
.Node_To_Be_Wrapped
) then
3109 Set_Parent
(L
, Parent
(SE
.Node_To_Be_Wrapped
));
3111 Set_Parent
(L
, SE
.Node_To_Be_Wrapped
);
3116 end Store_Before_Actions_In_Scope
;
3118 --------------------------------
3119 -- Wrap_Transient_Declaration --
3120 --------------------------------
3122 -- If a transient scope has been established during the processing of the
3123 -- Expression of an Object_Declaration, it is not possible to wrap the
3124 -- declaration into a transient block as usual case, otherwise the object
3125 -- would be itself declared in the wrong scope. Therefore, all entities (if
3126 -- any) defined in the transient block are moved to the proper enclosing
3127 -- scope, furthermore, if they are controlled variables they are finalized
3128 -- right after the declaration. The finalization list of the transient
3129 -- scope is defined as a renaming of the enclosing one so during their
3130 -- initialization they will be attached to the proper finalization
3131 -- list. For instance, the following declaration :
3133 -- X : Typ := F (G (A), G (B));
3135 -- (where G(A) and G(B) return controlled values, expanded as _v1 and _v2)
3136 -- is expanded into :
3138 -- _local_final_list_1 : Finalizable_Ptr;
3139 -- X : Typ := [ complex Expression-Action ];
3140 -- Finalize_One(_v1);
3141 -- Finalize_One (_v2);
3143 procedure Wrap_Transient_Declaration
(N
: Node_Id
) is
3145 LC
: Entity_Id
:= Empty
;
3147 Loc
: constant Source_Ptr
:= Sloc
(N
);
3148 Enclosing_S
: Entity_Id
;
3150 Next_N
: constant Node_Id
:= Next
(N
);
3154 Enclosing_S
:= Scope
(S
);
3156 -- Insert Actions kept in the Scope stack
3158 Insert_Actions_In_Scope_Around
(N
);
3160 -- If the declaration is consuming some secondary stack, mark the
3161 -- Enclosing scope appropriately.
3163 Uses_SS
:= Uses_Sec_Stack
(S
);
3166 -- Create a List controller and rename the final list to be its
3167 -- internal final pointer:
3168 -- Lxxx : Simple_List_Controller;
3169 -- Fxxx : Finalizable_Ptr renames Lxxx.F;
3171 if Present
(Finalization_Chain_Entity
(S
)) then
3172 LC
:= Make_Defining_Identifier
(Loc
, New_Internal_Name
('L'));
3175 Make_Object_Declaration
(Loc
,
3176 Defining_Identifier
=> LC
,
3177 Object_Definition
=>
3178 New_Reference_To
(RTE
(RE_Simple_List_Controller
), Loc
)),
3180 Make_Object_Renaming_Declaration
(Loc
,
3181 Defining_Identifier
=> Finalization_Chain_Entity
(S
),
3182 Subtype_Mark
=> New_Reference_To
(RTE
(RE_Finalizable_Ptr
), Loc
),
3184 Make_Selected_Component
(Loc
,
3185 Prefix
=> New_Reference_To
(LC
, Loc
),
3186 Selector_Name
=> Make_Identifier
(Loc
, Name_F
))));
3188 -- Put the declaration at the beginning of the declaration part
3189 -- to make sure it will be before all other actions that have been
3190 -- inserted before N.
3192 Insert_List_Before_And_Analyze
(First
(List_Containing
(N
)), Nodes
);
3194 -- Generate the Finalization calls by finalizing the list
3195 -- controller right away. It will be re-finalized on scope
3196 -- exit but it doesn't matter. It cannot be done when the
3197 -- call initializes a renaming object though because in this
3198 -- case, the object becomes a pointer to the temporary and thus
3199 -- increases its life span.
3201 if Nkind
(N
) = N_Object_Renaming_Declaration
3202 and then Controlled_Type
(Etype
(Defining_Identifier
(N
)))
3209 Ref
=> New_Reference_To
(LC
, Loc
),
3211 With_Detach
=> New_Reference_To
(Standard_False
, Loc
));
3212 if Present
(Next_N
) then
3213 Insert_List_Before_And_Analyze
(Next_N
, Nodes
);
3215 Append_List_To
(List_Containing
(N
), Nodes
);
3220 -- Put the local entities back in the enclosing scope, and set the
3221 -- Is_Public flag appropriately.
3223 Transfer_Entities
(S
, Enclosing_S
);
3225 -- Mark the enclosing dynamic scope so that the sec stack will be
3226 -- released upon its exit unless this is a function that returns on
3227 -- the sec stack in which case this will be done by the caller.
3230 S
:= Enclosing_Dynamic_Scope
(S
);
3232 if Ekind
(S
) = E_Function
3233 and then Requires_Transient_Scope
(Etype
(S
))
3237 Set_Uses_Sec_Stack
(S
);
3238 Check_Restriction
(No_Secondary_Stack
, N
);
3241 end Wrap_Transient_Declaration
;
3243 -------------------------------
3244 -- Wrap_Transient_Expression --
3245 -------------------------------
3247 -- Insert actions before <Expression>:
3249 -- (lines marked with <CTRL> are expanded only in presence of Controlled
3250 -- objects needing finalization)
3254 -- _M : constant Mark_Id := SS_Mark;
3255 -- Local_Final_List : System.FI.Finalizable_Ptr; <CTRL>
3257 -- procedure _Clean is
3260 -- System.FI.Finalize_List (Local_Final_List); <CTRL>
3266 -- _E := <Expression>;
3271 -- then expression is replaced by _E
3273 procedure Wrap_Transient_Expression
(N
: Node_Id
) is
3274 Loc
: constant Source_Ptr
:= Sloc
(N
);
3275 E
: constant Entity_Id
:=
3276 Make_Defining_Identifier
(Loc
, New_Internal_Name
('E'));
3277 Etyp
: constant Entity_Id
:= Etype
(N
);
3280 Insert_Actions
(N
, New_List
(
3281 Make_Object_Declaration
(Loc
,
3282 Defining_Identifier
=> E
,
3283 Object_Definition
=> New_Reference_To
(Etyp
, Loc
)),
3285 Make_Transient_Block
(Loc
,
3287 Make_Assignment_Statement
(Loc
,
3288 Name
=> New_Reference_To
(E
, Loc
),
3289 Expression
=> Relocate_Node
(N
)))));
3291 Rewrite
(N
, New_Reference_To
(E
, Loc
));
3292 Analyze_And_Resolve
(N
, Etyp
);
3293 end Wrap_Transient_Expression
;
3295 ------------------------------
3296 -- Wrap_Transient_Statement --
3297 ------------------------------
3299 -- Transform <Instruction> into
3301 -- (lines marked with <CTRL> are expanded only in presence of Controlled
3302 -- objects needing finalization)
3305 -- _M : Mark_Id := SS_Mark;
3306 -- Local_Final_List : System.FI.Finalizable_Ptr ; <CTRL>
3308 -- procedure _Clean is
3311 -- System.FI.Finalize_List (Local_Final_List); <CTRL>
3322 procedure Wrap_Transient_Statement
(N
: Node_Id
) is
3323 Loc
: constant Source_Ptr
:= Sloc
(N
);
3324 New_Statement
: constant Node_Id
:= Relocate_Node
(N
);
3327 Rewrite
(N
, Make_Transient_Block
(Loc
, New_Statement
));
3329 -- With the scope stack back to normal, we can call analyze on the
3330 -- resulting block. At this point, the transient scope is being
3331 -- treated like a perfectly normal scope, so there is nothing
3332 -- special about it.
3334 -- Note: Wrap_Transient_Statement is called with the node already
3335 -- analyzed (i.e. Analyzed (N) is True). This is important, since
3336 -- otherwise we would get a recursive processing of the node when
3337 -- we do this Analyze call.
3340 end Wrap_Transient_Statement
;