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, 59 Temple Place - Suite 330, Boston, --
20 -- MA 02111-1307, 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 nown 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));
1564 -- Generate a subprogram descriptor for the elaboration routine of
1565 -- a package body if the package body has no pending instantiations
1566 -- and it has generated at least one exception handler
1568 if Present (Handler_Records (Body_Entity (Ent)))
1569 and then Is_Compilation_Unit (Ent)
1570 and then not Delay_Subprogram_Descriptors (Body_Entity (Ent))
1572 Generate_Subprogram_Descriptor_For_Package
1573 (N, Body_Entity (Ent));
1576 Set_In_Package_Body (Ent, False);
1578 -- Set to encode entity names in package body before gigi is called
1580 Qualify_Entity_Names (N);
1581 end Expand_N_Package_Body;
1583 ----------------------------------
1584 -- Expand_N_Package_Declaration --
1585 ----------------------------------
1587 -- Add call to Activate_Tasks if there are tasks declared and the
1588 -- package has no body. Note that in Ada83, this may result in
1589 -- premature activation of some tasks, given that we cannot tell
1590 -- whether a body will eventually appear.
1592 procedure Expand_N_Package_Declaration (N : Node_Id) is
1594 if Nkind (Parent (N)) = N_Compilation_Unit
1595 and then not Body_Required (Parent (N))
1596 and then not Unit_Requires_Body (Defining_Entity (N))
1597 and then Present (Activation_Chain_Entity (N))
1599 New_Scope (Defining_Entity (N));
1600 Build_Task_Activation_Call (N);
1604 -- Note: it is not necessary to worry about generating a subprogram
1605 -- descriptor, since the only way to get exception handlers into a
1606 -- package spec is to include instantiations, and that would cause
1607 -- generation of subprogram descriptors to be delayed in any case.
1609 -- Set to encode entity names in package spec before gigi is called
1611 Qualify_Entity_Names (N);
1612 end Expand_N_Package_Declaration;
1614 ---------------------
1615 -- Find_Final_List --
1616 ---------------------
1618 function Find_Final_List
1620 Ref : Node_Id := Empty) return Node_Id
1622 Loc : constant Source_Ptr := Sloc (Ref);
1628 -- Case of an internal component. The Final list is the record
1629 -- controller of the enclosing record
1631 if Present (Ref) then
1635 when N_Unchecked_Type_Conversion | N_Type_Conversion =>
1636 R := Expression (R);
1638 when N_Indexed_Component | N_Explicit_Dereference =>
1641 when N_Selected_Component =>
1645 when N_Identifier =>
1649 raise Program_Error;
1654 Make_Selected_Component (Loc,
1656 Make_Selected_Component (Loc,
1658 Selector_Name => Make_Identifier (Loc, Name_uController)),
1659 Selector_Name => Make_Identifier (Loc, Name_F));
1661 -- Case of a dynamically allocated object. The final list is the
1662 -- corresponding list controller (The next entity in the scope of
1663 -- the access type with the right type). If the type comes from a
1664 -- With_Type clause, no controller was created, and we use the
1665 -- global chain instead.
1667 elsif Is_Access_Type (E) then
1668 if not From_With_Type (E) then
1670 Make_Selected_Component (Loc,
1673 (Associated_Final_Chain (Base_Type (E)), Loc),
1674 Selector_Name => Make_Identifier (Loc, Name_F));
1676 return New_Reference_To (RTE (RE_Global_Final_List), Sloc (E));
1680 if Is_Dynamic_Scope (E) then
1683 S := Enclosing_Dynamic_Scope (E);
1686 -- When the finalization chain entity is 'Error', it means that
1687 -- there should not be any chain at that level and that the
1688 -- enclosing one should be used
1690 -- This is a nasty kludge, see ??? note in exp_ch11
1692 while Finalization_Chain_Entity (S) = Error loop
1693 S := Enclosing_Dynamic_Scope (S);
1696 if S = Standard_Standard then
1697 return New_Reference_To (RTE (RE_Global_Final_List), Sloc (E));
1699 if No (Finalization_Chain_Entity (S)) then
1701 Id := Make_Defining_Identifier (Sloc (S),
1702 New_Internal_Name ('F'));
1703 Set_Finalization_Chain_Entity (S, Id);
1705 -- Set momentarily some semantics attributes to allow normal
1706 -- analysis of expansions containing references to this chain.
1707 -- Will be fully decorated during the expansion of the scope
1710 Set_Ekind (Id, E_Variable);
1711 Set_Etype (Id, RTE (RE_Finalizable_Ptr));
1714 return New_Reference_To (Finalization_Chain_Entity (S), Sloc (E));
1717 end Find_Final_List;
1719 -----------------------------
1720 -- Find_Node_To_Be_Wrapped --
1721 -----------------------------
1723 function Find_Node_To_Be_Wrapped (N : Node_Id) return Node_Id is
1725 The_Parent : Node_Id;
1731 pragma Assert (P /= Empty);
1732 The_Parent := Parent (P);
1734 case Nkind (The_Parent) is
1736 -- Simple statement can be wrapped
1741 -- Usually assignments are good candidate for wrapping
1742 -- except when they have been generated as part of a
1743 -- controlled aggregate where the wrapping should take
1744 -- place more globally.
1746 when N_Assignment_Statement =>
1747 if No_Ctrl_Actions (The_Parent) then
1753 -- An entry call statement is a special case if it occurs in
1754 -- the context of a Timed_Entry_Call. In this case we wrap
1755 -- the entire timed entry call.
1757 when N_Entry_Call_Statement |
1758 N_Procedure_Call_Statement =>
1759 if Nkind (Parent (The_Parent)) = N_Entry_Call_Alternative
1761 Nkind (Parent (Parent (The_Parent))) = N_Timed_Entry_Call
1763 return Parent (Parent (The_Parent));
1768 -- Object declarations are also a boundary for the transient scope
1769 -- even if they are not really wrapped
1770 -- (see Wrap_Transient_Declaration)
1772 when N_Object_Declaration |
1773 N_Object_Renaming_Declaration |
1774 N_Subtype_Declaration =>
1777 -- The expression itself is to be wrapped if its parent is a
1778 -- compound statement or any other statement where the expression
1779 -- is known to be scalar
1781 when N_Accept_Alternative |
1782 N_Attribute_Definition_Clause |
1785 N_Delay_Alternative |
1786 N_Delay_Until_Statement |
1787 N_Delay_Relative_Statement |
1788 N_Discriminant_Association |
1790 N_Entry_Body_Formal_Part |
1793 N_Iteration_Scheme |
1794 N_Terminate_Alternative =>
1797 when N_Attribute_Reference =>
1799 if Is_Procedure_Attribute_Name
1800 (Attribute_Name (The_Parent))
1805 -- If the expression is within the iteration scheme of a loop,
1806 -- we must create a declaration for it, followed by an assignment
1807 -- in order to have a usable statement to wrap.
1809 when N_Loop_Parameter_Specification =>
1810 return Parent (The_Parent);
1812 -- The following nodes contains "dummy calls" which don't
1813 -- need to be wrapped.
1815 when N_Parameter_Specification |
1816 N_Discriminant_Specification |
1817 N_Component_Declaration =>
1820 -- The return statement is not to be wrapped when the function
1821 -- itself needs wrapping at the outer-level
1823 when N_Return_Statement =>
1824 if Requires_Transient_Scope (Return_Type (The_Parent)) then
1830 -- If we leave a scope without having been able to find a node to
1831 -- wrap, something is going wrong but this can happen in error
1832 -- situation that are not detected yet (such as a dynamic string
1833 -- in a pragma export)
1835 when N_Subprogram_Body |
1836 N_Package_Declaration |
1838 N_Block_Statement =>
1841 -- otherwise continue the search
1847 end Find_Node_To_Be_Wrapped;
1849 ----------------------
1850 -- Global_Flist_Ref --
1851 ----------------------
1853 function Global_Flist_Ref (Flist_Ref : Node_Id) return Boolean is
1857 -- Look for the Global_Final_List
1859 if Is_Entity_Name (Flist_Ref) then
1860 Flist := Entity (Flist_Ref);
1862 -- Look for the final list associated with an access to controlled
1864 elsif Nkind (Flist_Ref) = N_Selected_Component
1865 and then Is_Entity_Name (Prefix (Flist_Ref))
1867 Flist := Entity (Prefix (Flist_Ref));
1872 return Present (Flist)
1873 and then Present (Scope (Flist))
1874 and then Enclosing_Dynamic_Scope (Flist) = Standard_Standard;
1875 end Global_Flist_Ref;
1877 ----------------------------------
1878 -- Has_New_Controlled_Component --
1879 ----------------------------------
1881 function Has_New_Controlled_Component (E : Entity_Id) return Boolean is
1885 if not Is_Tagged_Type (E) then
1886 return Has_Controlled_Component (E);
1887 elsif not Is_Derived_Type (E) then
1888 return Has_Controlled_Component (E);
1891 Comp := First_Component (E);
1892 while Present (Comp) loop
1894 if Chars (Comp) = Name_uParent then
1897 elsif Scope (Original_Record_Component (Comp)) = E
1898 and then Controlled_Type (Etype (Comp))
1903 Next_Component (Comp);
1907 end Has_New_Controlled_Component;
1909 --------------------------
1910 -- In_Finalization_Root --
1911 --------------------------
1913 -- It would seem simpler to test Scope (RTE (RE_Root_Controlled)) but
1914 -- the purpose of this function is to avoid a circular call to Rtsfind
1915 -- which would been caused by such a test.
1917 function In_Finalization_Root (E : Entity_Id) return Boolean is
1918 S : constant Entity_Id := Scope (E);
1921 return Chars (Scope (S)) = Name_System
1922 and then Chars (S) = Name_Finalization_Root
1923 and then Scope (Scope (S)) = Standard_Standard;
1924 end In_Finalization_Root;
1926 ------------------------------------
1927 -- Insert_Actions_In_Scope_Around --
1928 ------------------------------------
1930 procedure Insert_Actions_In_Scope_Around (N : Node_Id) is
1931 SE : Scope_Stack_Entry renames Scope_Stack.Table (Scope_Stack.Last);
1935 -- If the node to be wrapped is the triggering alternative of an
1936 -- asynchronous select, it is not part of a statement list. The
1937 -- actions must be inserted before the Select itself, which is
1938 -- part of some list of statements.
1940 if Nkind (Parent (Node_To_Be_Wrapped)) = N_Triggering_Alternative then
1941 Target := Parent (Parent (Node_To_Be_Wrapped));
1946 if Present (SE.Actions_To_Be_Wrapped_Before) then
1947 Insert_List_Before (Target, SE.Actions_To_Be_Wrapped_Before);
1948 SE.Actions_To_Be_Wrapped_Before := No_List;
1951 if Present (SE.Actions_To_Be_Wrapped_After) then
1952 Insert_List_After (Target, SE.Actions_To_Be_Wrapped_After);
1953 SE.Actions_To_Be_Wrapped_After := No_List;
1955 end Insert_Actions_In_Scope_Around;
1957 -----------------------
1958 -- Make_Adjust_Call --
1959 -----------------------
1961 function Make_Adjust_Call
1964 Flist_Ref : Node_Id;
1965 With_Attach : Node_Id) return List_Id
1967 Loc : constant Source_Ptr := Sloc (Ref);
1968 Res : constant List_Id := New_List;
1971 Cref : Node_Id := Ref;
1973 Attach : Node_Id := With_Attach;
1976 if Is_Class_Wide_Type (Typ) then
1977 Utyp := Underlying_Type (Base_Type (Root_Type (Typ)));
1979 Utyp := Underlying_Type (Base_Type (Typ));
1982 Set_Assignment_OK (Cref);
1984 -- Deal with non-tagged derivation of private views
1986 if Is_Untagged_Derivation (Typ) then
1987 Utyp := Underlying_Type (Root_Type (Base_Type (Typ)));
1988 Cref := Unchecked_Convert_To (Utyp, Cref);
1989 Set_Assignment_OK (Cref);
1990 -- To prevent problems with UC see 1.156 RH ???
1993 -- If the underlying_type is a subtype, we are dealing with
1994 -- the completion of a private type. We need to access
1995 -- the base type and generate a conversion to it.
1997 if Utyp /= Base_Type (Utyp) then
1998 pragma Assert (Is_Private_Type (Typ));
1999 Utyp := Base_Type (Utyp);
2000 Cref := Unchecked_Convert_To (Utyp, Cref);
2003 -- If the object is unanalyzed, set its expected type for use
2004 -- in Convert_View in case an additional conversion is needed.
2006 if No (Etype (Cref))
2007 and then Nkind (Cref) /= N_Unchecked_Type_Conversion
2009 Set_Etype (Cref, Typ);
2012 -- We do not need to attach to one of the Global Final Lists
2013 -- the objects whose type is Finalize_Storage_Only
2015 if Finalize_Storage_Only (Typ)
2016 and then (Global_Flist_Ref (Flist_Ref)
2017 or else Entity (Constant_Value (RTE (RE_Garbage_Collected)))
2020 Attach := Make_Integer_Literal (Loc, 0);
2024 -- Deep_Adjust (Flist_Ref, Ref, With_Attach);
2026 if Has_Controlled_Component (Utyp)
2027 or else Is_Class_Wide_Type (Typ)
2029 if Is_Tagged_Type (Utyp) then
2030 Proc := Find_Prim_Op (Utyp, TSS_Deep_Adjust);
2033 Proc := TSS (Utyp, TSS_Deep_Adjust);
2036 Cref := Convert_View (Proc, Cref, 2);
2039 Make_Procedure_Call_Statement (Loc,
2040 Name => New_Reference_To (Proc, Loc),
2041 Parameter_Associations =>
2042 New_List (Flist_Ref, Cref, Attach)));
2045 -- if With_Attach then
2046 -- Attach_To_Final_List (Ref, Flist_Ref);
2050 else -- Is_Controlled (Utyp)
2052 Proc := Find_Prim_Op (Utyp, Name_Of (Adjust_Case));
2053 Cref := Convert_View (Proc, Cref);
2054 Cref2 := New_Copy_Tree (Cref);
2057 Make_Procedure_Call_Statement (Loc,
2058 Name => New_Reference_To (Proc, Loc),
2059 Parameter_Associations => New_List (Cref2)));
2061 Append_To (Res, Make_Attach_Call (Cref, Flist_Ref, Attach));
2065 end Make_Adjust_Call;
2067 ----------------------
2068 -- Make_Attach_Call --
2069 ----------------------
2072 -- System.FI.Attach_To_Final_List (Flist, Ref, Nb_Link)
2074 function Make_Attach_Call
2076 Flist_Ref : Node_Id;
2077 With_Attach : Node_Id) return Node_Id
2079 Loc : constant Source_Ptr := Sloc (Obj_Ref);
2082 -- Optimization: If the number of links is statically '0', don't
2083 -- call the attach_proc.
2085 if Nkind (With_Attach) = N_Integer_Literal
2086 and then Intval (With_Attach) = Uint_0
2088 return Make_Null_Statement (Loc);
2092 Make_Procedure_Call_Statement (Loc,
2093 Name => New_Reference_To (RTE (RE_Attach_To_Final_List), Loc),
2094 Parameter_Associations => New_List (
2096 OK_Convert_To (RTE (RE_Finalizable), Obj_Ref),
2098 end Make_Attach_Call;
2110 Is_Master : Boolean;
2111 Is_Protected_Subprogram : Boolean;
2112 Is_Task_Allocation_Block : Boolean;
2113 Is_Asynchronous_Call_Block : Boolean) return Node_Id
2115 Loc : constant Source_Ptr := Sloc (Clean);
2116 Stmt : constant List_Id := New_List;
2122 Param_Type : Entity_Id;
2123 Pid : Entity_Id := Empty;
2124 Cancel_Param : Entity_Id;
2128 if Restricted_Profile then
2130 (Stmt, Build_Runtime_Call (Loc, RE_Complete_Restricted_Task));
2132 Append_To (Stmt, Build_Runtime_Call (Loc, RE_Complete_Task));
2135 elsif Is_Master then
2136 if Restriction_Active (No_Task_Hierarchy) = False then
2137 Append_To (Stmt, Build_Runtime_Call (Loc, RE_Complete_Master));
2140 elsif Is_Protected_Subprogram then
2142 -- Add statements to the cleanup handler of the (ordinary)
2143 -- subprogram expanded to implement a protected subprogram,
2144 -- unlocking the protected object parameter and undeferring abort.
2145 -- If this is a protected procedure, and the object contains
2146 -- entries, this also calls the entry service routine.
2148 -- NOTE: This cleanup handler references _object, a parameter
2149 -- to the procedure.
2151 -- Find the _object parameter representing the protected object
2153 Spec := Parent (Corresponding_Spec (N));
2155 Param := First (Parameter_Specifications (Spec));
2157 Param_Type := Etype (Parameter_Type (Param));
2159 if Ekind (Param_Type) = E_Record_Type then
2160 Pid := Corresponding_Concurrent_Type (Param_Type);
2163 exit when not Present (Param) or else Present (Pid);
2167 pragma Assert (Present (Param));
2169 -- If the associated protected object declares entries,
2170 -- a protected procedure has to service entry queues.
2171 -- In this case, add
2173 -- Service_Entries (_object._object'Access);
2175 -- _object is the record used to implement the protected object.
2176 -- It is a parameter to the protected subprogram.
2178 if Nkind (Specification (N)) = N_Procedure_Specification
2179 and then Has_Entries (Pid)
2182 or else Restriction_Active (No_Entry_Queue) = False
2183 or else Number_Entries (Pid) > 1
2185 Name := New_Reference_To (RTE (RE_Service_Entries), Loc);
2187 Name := New_Reference_To (RTE (RE_Service_Entry), Loc);
2191 Make_Procedure_Call_Statement (Loc,
2193 Parameter_Associations => New_List (
2194 Make_Attribute_Reference (Loc,
2196 Make_Selected_Component (Loc,
2197 Prefix => New_Reference_To (
2198 Defining_Identifier (Param), Loc),
2200 Make_Identifier (Loc, Name_uObject)),
2201 Attribute_Name => Name_Unchecked_Access))));
2204 -- Unlock (_object._object'Access);
2206 -- object is the record used to implement the protected object.
2207 -- It is a parameter to the protected subprogram.
2209 -- If the protected object is controlled (i.e it has entries or
2210 -- needs finalization for interrupt handling), call
2211 -- Unlock_Entries, except if the protected object follows the
2212 -- ravenscar profile, in which case call Unlock_Entry, otherwise
2213 -- call the simplified version, Unlock.
2215 if Has_Entries (Pid)
2216 or else Has_Interrupt_Handler (Pid)
2217 or else (Has_Attach_Handler (Pid)
2218 and then not Restricted_Profile)
2221 or else Restriction_Active (No_Entry_Queue) = False
2222 or else Number_Entries (Pid) > 1
2224 Name := New_Reference_To (RTE (RE_Unlock_Entries), Loc);
2226 Name := New_Reference_To (RTE (RE_Unlock_Entry), Loc);
2230 Name := New_Reference_To (RTE (RE_Unlock), Loc);
2234 Make_Procedure_Call_Statement (Loc,
2236 Parameter_Associations => New_List (
2237 Make_Attribute_Reference (Loc,
2239 Make_Selected_Component (Loc,
2241 New_Reference_To (Defining_Identifier (Param), Loc),
2243 Make_Identifier (Loc, Name_uObject)),
2244 Attribute_Name => Name_Unchecked_Access))));
2247 if Abort_Allowed then
2252 Make_Procedure_Call_Statement (Loc,
2255 RTE (RE_Abort_Undefer), Loc),
2256 Parameter_Associations => Empty_List));
2259 elsif Is_Task_Allocation_Block then
2261 -- Add a call to Expunge_Unactivated_Tasks to the cleanup
2262 -- handler of a block created for the dynamic allocation of
2265 -- Expunge_Unactivated_Tasks (_chain);
2267 -- where _chain is the list of tasks created by the allocator
2268 -- but not yet activated. This list will be empty unless
2269 -- the block completes abnormally.
2271 -- This only applies to dynamically allocated tasks;
2272 -- other unactivated tasks are completed by Complete_Task or
2275 -- NOTE: This cleanup handler references _chain, a local
2279 Make_Procedure_Call_Statement (Loc,
2282 RTE (RE_Expunge_Unactivated_Tasks), Loc),
2283 Parameter_Associations => New_List (
2284 New_Reference_To (Activation_Chain_Entity (N), Loc))));
2286 elsif Is_Asynchronous_Call_Block then
2288 -- Add a call to attempt to cancel the asynchronous entry call
2289 -- whenever the block containing the abortable part is exited.
2291 -- NOTE: This cleanup handler references C, a local object
2293 -- Get the argument to the Cancel procedure
2294 Cancel_Param := Entry_Cancel_Parameter (Entity (Identifier (N)));
2296 -- If it is of type Communication_Block, this must be a
2297 -- protected entry call.
2299 if Is_RTE (Etype (Cancel_Param), RE_Communication_Block) then
2303 -- if Enqueued (Cancel_Parameter) then
2305 Make_Implicit_If_Statement (Clean,
2306 Condition => Make_Function_Call (Loc,
2307 Name => New_Reference_To (
2308 RTE (RE_Enqueued), Loc),
2309 Parameter_Associations => New_List (
2310 New_Reference_To (Cancel_Param, Loc))),
2311 Then_Statements => New_List (
2313 -- Cancel_Protected_Entry_Call (Cancel_Param);
2315 Make_Procedure_Call_Statement (Loc,
2316 Name => New_Reference_To (
2317 RTE (RE_Cancel_Protected_Entry_Call), Loc),
2318 Parameter_Associations => New_List (
2319 New_Reference_To (Cancel_Param, Loc))))));
2321 -- Asynchronous delay
2323 elsif Is_RTE (Etype (Cancel_Param), RE_Delay_Block) then
2325 Make_Procedure_Call_Statement (Loc,
2326 Name => New_Reference_To (RTE (RE_Cancel_Async_Delay), Loc),
2327 Parameter_Associations => New_List (
2328 Make_Attribute_Reference (Loc,
2329 Prefix => New_Reference_To (Cancel_Param, Loc),
2330 Attribute_Name => Name_Unchecked_Access))));
2335 -- Append call to Cancel_Task_Entry_Call (C);
2338 Make_Procedure_Call_Statement (Loc,
2339 Name => New_Reference_To (
2340 RTE (RE_Cancel_Task_Entry_Call),
2342 Parameter_Associations => New_List (
2343 New_Reference_To (Cancel_Param, Loc))));
2348 if Present (Flist) then
2350 Make_Procedure_Call_Statement (Loc,
2351 Name => New_Reference_To (RTE (RE_Finalize_List), Loc),
2352 Parameter_Associations => New_List (
2353 New_Reference_To (Flist, Loc))));
2356 if Present (Mark) then
2358 Make_Procedure_Call_Statement (Loc,
2359 Name => New_Reference_To (RTE (RE_SS_Release), Loc),
2360 Parameter_Associations => New_List (
2361 New_Reference_To (Mark, Loc))));
2365 Make_Subprogram_Body (Loc,
2367 Make_Procedure_Specification (Loc,
2368 Defining_Unit_Name => Clean),
2370 Declarations => New_List,
2372 Handled_Statement_Sequence =>
2373 Make_Handled_Sequence_Of_Statements (Loc,
2374 Statements => Stmt));
2376 if Present (Flist) or else Is_Task or else Is_Master then
2377 Wrap_Cleanup_Procedure (Sbody);
2380 -- We do not want debug information for _Clean routines,
2381 -- since it just confuses the debugging operation unless
2382 -- we are debugging generated code.
2384 if not Debug_Generated_Code then
2385 Set_Debug_Info_Off (Clean, True);
2391 --------------------------
2392 -- Make_Deep_Array_Body --
2393 --------------------------
2395 -- Array components are initialized and adjusted in the normal order
2396 -- and finalized in the reverse order. Exceptions are handled and
2397 -- Program_Error is re-raise in the Adjust and Finalize case
2398 -- (RM 7.6.1(12)). Generate the following code :
2400 -- procedure Deep_<P> -- with <P> being Initialize or Adjust or Finalize
2401 -- (L : in out Finalizable_Ptr;
2405 -- for J1 in Typ'First (1) .. Typ'Last (1) loop
2406 -- ^ reverse ^ -- in the finalization case
2408 -- for J2 in Typ'First (n) .. Typ'Last (n) loop
2409 -- Make_<P>_Call (Typ, V (J1, .. , Jn), L, V);
2413 -- exception -- not in the
2414 -- when others => raise Program_Error; -- Initialize case
2417 function Make_Deep_Array_Body
2418 (Prim : Final_Primitives;
2419 Typ : Entity_Id) return List_Id
2421 Loc : constant Source_Ptr := Sloc (Typ);
2423 Index_List : constant List_Id := New_List;
2424 -- Stores the list of references to the indexes (one per dimension)
2426 function One_Component return List_Id;
2427 -- Create one statement to initialize/adjust/finalize one array
2428 -- component, designated by a full set of indices.
2430 function One_Dimension (N : Int) return List_Id;
2431 -- Create loop to deal with one dimension of the array. The single
2432 -- statement in the body of the loop initializes the inner dimensions if
2433 -- any, or else a single component.
2439 function One_Component return List_Id is
2440 Comp_Typ : constant Entity_Id := Component_Type (Typ);
2441 Comp_Ref : constant Node_Id :=
2442 Make_Indexed_Component (Loc,
2443 Prefix => Make_Identifier (Loc, Name_V),
2444 Expressions => Index_List);
2447 -- Set the etype of the component Reference, which is used to
2448 -- determine whether a conversion to a parent type is needed.
2450 Set_Etype (Comp_Ref, Comp_Typ);
2453 when Initialize_Case =>
2454 return Make_Init_Call (Comp_Ref, Comp_Typ,
2455 Make_Identifier (Loc, Name_L),
2456 Make_Identifier (Loc, Name_B));
2459 return Make_Adjust_Call (Comp_Ref, Comp_Typ,
2460 Make_Identifier (Loc, Name_L),
2461 Make_Identifier (Loc, Name_B));
2463 when Finalize_Case =>
2464 return Make_Final_Call (Comp_Ref, Comp_Typ,
2465 Make_Identifier (Loc, Name_B));
2473 function One_Dimension (N : Int) return List_Id is
2477 if N > Number_Dimensions (Typ) then
2478 return One_Component;
2482 Make_Defining_Identifier (Loc, New_External_Name ('J', N));
2484 Append_To (Index_List, New_Reference_To (Index, Loc));
2487 Make_Implicit_Loop_Statement (Typ,
2488 Identifier => Empty,
2490 Make_Iteration_Scheme (Loc,
2491 Loop_Parameter_Specification =>
2492 Make_Loop_Parameter_Specification (Loc,
2493 Defining_Identifier => Index,
2494 Discrete_Subtype_Definition =>
2495 Make_Attribute_Reference (Loc,
2496 Prefix => Make_Identifier (Loc, Name_V),
2497 Attribute_Name => Name_Range,
2498 Expressions => New_List (
2499 Make_Integer_Literal (Loc, N))),
2500 Reverse_Present => Prim = Finalize_Case)),
2501 Statements => One_Dimension (N + 1)));
2505 -- Start of processing for Make_Deep_Array_Body
2508 return One_Dimension (1);
2509 end Make_Deep_Array_Body;
2511 --------------------
2512 -- Make_Deep_Proc --
2513 --------------------
2516 -- procedure DEEP_<prim>
2517 -- (L : IN OUT Finalizable_Ptr; -- not for Finalize
2518 -- V : IN OUT <typ>;
2519 -- B : IN Short_Short_Integer) is
2522 -- exception -- Finalize and Adjust Cases only
2523 -- raise Program_Error; -- idem
2526 function Make_Deep_Proc
2527 (Prim : Final_Primitives;
2529 Stmts : List_Id) return Entity_Id
2531 Loc : constant Source_Ptr := Sloc (Typ);
2533 Proc_Name : Entity_Id;
2534 Handler : List_Id := No_List;
2538 if Prim = Finalize_Case then
2539 Formals := New_List;
2540 Type_B := Standard_Boolean;
2543 Formals := New_List (
2544 Make_Parameter_Specification (Loc,
2545 Defining_Identifier => Make_Defining_Identifier (Loc, Name_L),
2547 Out_Present => True,
2549 New_Reference_To (RTE (RE_Finalizable_Ptr), Loc)));
2550 Type_B := Standard_Short_Short_Integer;
2554 Make_Parameter_Specification (Loc,
2555 Defining_Identifier => Make_Defining_Identifier (Loc, Name_V),
2557 Out_Present => True,
2558 Parameter_Type => New_Reference_To (Typ, Loc)));
2561 Make_Parameter_Specification (Loc,
2562 Defining_Identifier => Make_Defining_Identifier (Loc, Name_B),
2563 Parameter_Type => New_Reference_To (Type_B, Loc)));
2565 if Prim = Finalize_Case or else Prim = Adjust_Case then
2566 Handler := New_List (
2567 Make_Exception_Handler (Loc,
2568 Exception_Choices => New_List (Make_Others_Choice (Loc)),
2569 Statements => New_List (
2570 Make_Raise_Program_Error (Loc,
2571 Reason => PE_Finalize_Raised_Exception))));
2575 Make_Defining_Identifier (Loc,
2576 Chars => Make_TSS_Name (Typ, Deep_Name_Of (Prim)));
2579 Make_Subprogram_Body (Loc,
2581 Make_Procedure_Specification (Loc,
2582 Defining_Unit_Name => Proc_Name,
2583 Parameter_Specifications => Formals),
2585 Declarations => Empty_List,
2586 Handled_Statement_Sequence =>
2587 Make_Handled_Sequence_Of_Statements (Loc,
2588 Statements => Stmts,
2589 Exception_Handlers => Handler)));
2594 ---------------------------
2595 -- Make_Deep_Record_Body --
2596 ---------------------------
2598 -- The Deep procedures call the appropriate Controlling proc on the
2599 -- the controller component. In the init case, it also attach the
2600 -- controller to the current finalization list.
2602 function Make_Deep_Record_Body
2603 (Prim : Final_Primitives;
2604 Typ : Entity_Id) return List_Id
2606 Loc : constant Source_Ptr := Sloc (Typ);
2607 Controller_Typ : Entity_Id;
2608 Obj_Ref : constant Node_Id := Make_Identifier (Loc, Name_V);
2609 Controller_Ref : constant Node_Id :=
2610 Make_Selected_Component (Loc,
2613 Make_Identifier (Loc, Name_uController));
2614 Res : constant List_Id := New_List;
2617 if Is_Return_By_Reference_Type (Typ) then
2618 Controller_Typ := RTE (RE_Limited_Record_Controller);
2620 Controller_Typ := RTE (RE_Record_Controller);
2624 when Initialize_Case =>
2625 Append_List_To (Res,
2627 Ref => Controller_Ref,
2628 Typ => Controller_Typ,
2629 Flist_Ref => Make_Identifier (Loc, Name_L),
2630 With_Attach => Make_Identifier (Loc, Name_B)));
2632 -- When the type is also a controlled type by itself,
2633 -- Initialize it and attach it to the finalization chain
2635 if Is_Controlled (Typ) then
2637 Make_Procedure_Call_Statement (Loc,
2638 Name => New_Reference_To (
2639 Find_Prim_Op (Typ, Name_Of (Prim)), Loc),
2640 Parameter_Associations =>
2641 New_List (New_Copy_Tree (Obj_Ref))));
2643 Append_To (Res, Make_Attach_Call (
2644 Obj_Ref => New_Copy_Tree (Obj_Ref),
2645 Flist_Ref => Make_Identifier (Loc, Name_L),
2646 With_Attach => Make_Identifier (Loc, Name_B)));
2650 Append_List_To (Res,
2651 Make_Adjust_Call (Controller_Ref, Controller_Typ,
2652 Make_Identifier (Loc, Name_L),
2653 Make_Identifier (Loc, Name_B)));
2655 -- When the type is also a controlled type by itself,
2656 -- Adjust it it and attach it to the finalization chain
2658 if Is_Controlled (Typ) then
2660 Make_Procedure_Call_Statement (Loc,
2661 Name => New_Reference_To (
2662 Find_Prim_Op (Typ, Name_Of (Prim)), Loc),
2663 Parameter_Associations =>
2664 New_List (New_Copy_Tree (Obj_Ref))));
2666 Append_To (Res, Make_Attach_Call (
2667 Obj_Ref => New_Copy_Tree (Obj_Ref),
2668 Flist_Ref => Make_Identifier (Loc, Name_L),
2669 With_Attach => Make_Identifier (Loc, Name_B)));
2672 when Finalize_Case =>
2673 if Is_Controlled (Typ) then
2675 Make_Implicit_If_Statement (Obj_Ref,
2676 Condition => Make_Identifier (Loc, Name_B),
2677 Then_Statements => New_List (
2678 Make_Procedure_Call_Statement (Loc,
2679 Name => New_Reference_To (RTE (RE_Finalize_One), Loc),
2680 Parameter_Associations => New_List (
2681 OK_Convert_To (RTE (RE_Finalizable),
2682 New_Copy_Tree (Obj_Ref))))),
2684 Else_Statements => New_List (
2685 Make_Procedure_Call_Statement (Loc,
2686 Name => New_Reference_To (
2687 Find_Prim_Op (Typ, Name_Of (Prim)), Loc),
2688 Parameter_Associations =>
2689 New_List (New_Copy_Tree (Obj_Ref))))));
2692 Append_List_To (Res,
2693 Make_Final_Call (Controller_Ref, Controller_Typ,
2694 Make_Identifier (Loc, Name_B)));
2697 end Make_Deep_Record_Body;
2699 ----------------------
2700 -- Make_Final_Call --
2701 ----------------------
2703 function Make_Final_Call
2706 With_Detach : Node_Id) return List_Id
2708 Loc : constant Source_Ptr := Sloc (Ref);
2709 Res : constant List_Id := New_List;
2716 if Is_Class_Wide_Type (Typ) then
2717 Utyp := Root_Type (Typ);
2720 elsif Is_Concurrent_Type (Typ) then
2721 Utyp := Corresponding_Record_Type (Typ);
2722 Cref := Convert_Concurrent (Ref, Typ);
2724 elsif Is_Private_Type (Typ)
2725 and then Present (Full_View (Typ))
2726 and then Is_Concurrent_Type (Full_View (Typ))
2728 Utyp := Corresponding_Record_Type (Full_View (Typ));
2729 Cref := Convert_Concurrent (Ref, Full_View (Typ));
2735 Utyp := Underlying_Type (Base_Type (Utyp));
2736 Set_Assignment_OK (Cref);
2738 -- Deal with non-tagged derivation of private views
2740 if Is_Untagged_Derivation (Typ) then
2741 Utyp := Underlying_Type (Root_Type (Base_Type (Typ)));
2742 Cref := Unchecked_Convert_To (Utyp, Cref);
2743 Set_Assignment_OK (Cref);
2744 -- To prevent problems with UC see 1.156 RH ???
2747 -- If the underlying_type is a subtype, we are dealing with
2748 -- the completion of a private type. We need to access
2749 -- the base type and generate a conversion to it.
2751 if Utyp /= Base_Type (Utyp) then
2752 pragma Assert (Is_Private_Type (Typ));
2753 Utyp := Base_Type (Utyp);
2754 Cref := Unchecked_Convert_To (Utyp, Cref);
2758 -- Deep_Finalize (Ref, With_Detach);
2760 if Has_Controlled_Component (Utyp)
2761 or else Is_Class_Wide_Type (Typ)
2763 if Is_Tagged_Type (Utyp) then
2764 Proc := Find_Prim_Op (Utyp, TSS_Deep_Finalize);
2766 Proc := TSS (Utyp, TSS_Deep_Finalize);
2769 Cref := Convert_View (Proc, Cref);
2772 Make_Procedure_Call_Statement (Loc,
2773 Name => New_Reference_To (Proc, Loc),
2774 Parameter_Associations =>
2775 New_List (Cref, With_Detach)));
2778 -- if With_Detach then
2779 -- Finalize_One (Ref);
2785 Proc := Find_Prim_Op (Utyp, Name_Of (Finalize_Case));
2787 if Chars (With_Detach) = Chars (Standard_True) then
2789 Make_Procedure_Call_Statement (Loc,
2790 Name => New_Reference_To (RTE (RE_Finalize_One), Loc),
2791 Parameter_Associations => New_List (
2792 OK_Convert_To (RTE (RE_Finalizable), Cref))));
2794 elsif Chars (With_Detach) = Chars (Standard_False) then
2796 Make_Procedure_Call_Statement (Loc,
2797 Name => New_Reference_To (Proc, Loc),
2798 Parameter_Associations =>
2799 New_List (Convert_View (Proc, Cref))));
2802 Cref2 := New_Copy_Tree (Cref);
2804 Make_Implicit_If_Statement (Ref,
2805 Condition => With_Detach,
2806 Then_Statements => New_List (
2807 Make_Procedure_Call_Statement (Loc,
2808 Name => New_Reference_To (RTE (RE_Finalize_One), Loc),
2809 Parameter_Associations => New_List (
2810 OK_Convert_To (RTE (RE_Finalizable), Cref)))),
2812 Else_Statements => New_List (
2813 Make_Procedure_Call_Statement (Loc,
2814 Name => New_Reference_To (Proc, Loc),
2815 Parameter_Associations =>
2816 New_List (Convert_View (Proc, Cref2))))));
2821 end Make_Final_Call;
2823 --------------------
2824 -- Make_Init_Call --
2825 --------------------
2827 function Make_Init_Call
2830 Flist_Ref : Node_Id;
2831 With_Attach : Node_Id) return List_Id
2833 Loc : constant Source_Ptr := Sloc (Ref);
2835 Res : constant List_Id := New_List;
2840 Attach : Node_Id := With_Attach;
2843 if Is_Concurrent_Type (Typ) then
2845 Utyp := Corresponding_Record_Type (Typ);
2846 Cref := Convert_Concurrent (Ref, Typ);
2848 elsif Is_Private_Type (Typ)
2849 and then Present (Full_View (Typ))
2850 and then Is_Concurrent_Type (Underlying_Type (Typ))
2853 Utyp := Corresponding_Record_Type (Underlying_Type (Typ));
2854 Cref := Convert_Concurrent (Ref, Underlying_Type (Typ));
2862 Utyp := Underlying_Type (Base_Type (Utyp));
2864 Set_Assignment_OK (Cref);
2866 -- Deal with non-tagged derivation of private views
2868 if Is_Untagged_Derivation (Typ)
2869 and then not Is_Conc
2871 Utyp := Underlying_Type (Root_Type (Base_Type (Typ)));
2872 Cref := Unchecked_Convert_To (Utyp, Cref);
2873 Set_Assignment_OK (Cref);
2874 -- To prevent problems with UC see 1.156 RH ???
2877 -- If the underlying_type is a subtype, we are dealing with
2878 -- the completion of a private type. We need to access
2879 -- the base type and generate a conversion to it.
2881 if Utyp /= Base_Type (Utyp) then
2882 pragma Assert (Is_Private_Type (Typ));
2883 Utyp := Base_Type (Utyp);
2884 Cref := Unchecked_Convert_To (Utyp, Cref);
2887 -- We do not need to attach to one of the Global Final Lists
2888 -- the objects whose type is Finalize_Storage_Only
2890 if Finalize_Storage_Only (Typ)
2891 and then (Global_Flist_Ref (Flist_Ref)
2892 or else Entity (Constant_Value (RTE (RE_Garbage_Collected)))
2895 Attach := Make_Integer_Literal (Loc, 0);
2899 -- Deep_Initialize (Ref, Flist_Ref);
2901 if Has_Controlled_Component (Utyp) then
2902 Proc := TSS (Utyp, Deep_Name_Of (Initialize_Case));
2904 Cref := Convert_View (Proc, Cref, 2);
2907 Make_Procedure_Call_Statement (Loc,
2908 Name => New_Reference_To (Proc, Loc),
2909 Parameter_Associations => New_List (
2915 -- Attach_To_Final_List (Ref, Flist_Ref);
2916 -- Initialize (Ref);
2918 else -- Is_Controlled (Utyp)
2919 Proc := Find_Prim_Op (Utyp, Name_Of (Initialize_Case));
2920 Check_Visibly_Controlled (Initialize_Case, Typ, Proc, Cref);
2922 Cref := Convert_View (Proc, Cref);
2923 Cref2 := New_Copy_Tree (Cref);
2926 Make_Procedure_Call_Statement (Loc,
2927 Name => New_Reference_To (Proc, Loc),
2928 Parameter_Associations => New_List (Cref2)));
2931 Make_Attach_Call (Cref, Flist_Ref, Attach));
2937 --------------------------
2938 -- Make_Transient_Block --
2939 --------------------------
2941 -- If finalization is involved, this function just wraps the instruction
2942 -- into a block whose name is the transient block entity, and then
2943 -- Expand_Cleanup_Actions (called on the expansion of the handled
2944 -- sequence of statements will do the necessary expansions for
2947 function Make_Transient_Block
2949 Action : Node_Id) return Node_Id
2951 Flist : constant Entity_Id := Finalization_Chain_Entity (Current_Scope);
2952 Decls : constant List_Id := New_List;
2953 Par : constant Node_Id := Parent (Action);
2954 Instrs : constant List_Id := New_List (Action);
2958 -- Case where only secondary stack use is involved
2960 if Uses_Sec_Stack (Current_Scope)
2962 and then Nkind (Action) /= N_Return_Statement
2963 and then Nkind (Par) /= N_Exception_Handler
2970 S := Scope (Current_Scope);
2974 -- At the outer level, no need to release the sec stack
2976 if S = Standard_Standard then
2977 Set_Uses_Sec_Stack (Current_Scope, False);
2980 -- In a function, only release the sec stack if the
2981 -- function does not return on the sec stack otherwise
2982 -- the result may be lost. The caller is responsible for
2985 elsif K = E_Function then
2986 Set_Uses_Sec_Stack (Current_Scope, False);
2988 if not Requires_Transient_Scope (Etype (S)) then
2989 if not Functions_Return_By_DSP_On_Target then
2990 Set_Uses_Sec_Stack (S, True);
2991 Check_Restriction (No_Secondary_Stack, Action);
2997 -- In a loop or entry we should install a block encompassing
2998 -- all the construct. For now just release right away.
3000 elsif K = E_Loop or else K = E_Entry then
3003 -- In a procedure or a block, we release on exit of the
3004 -- procedure or block. ??? memory leak can be created by
3007 elsif K = E_Procedure
3010 if not Functions_Return_By_DSP_On_Target then
3011 Set_Uses_Sec_Stack (S, True);
3012 Check_Restriction (No_Secondary_Stack, Action);
3015 Set_Uses_Sec_Stack (Current_Scope, False);
3025 -- Insert actions stuck in the transient scopes as well as all
3026 -- freezing nodes needed by those actions
3028 Insert_Actions_In_Scope_Around (Action);
3031 Last_Inserted : Node_Id := Prev (Action);
3034 if Present (Last_Inserted) then
3035 Freeze_All (First_Entity (Current_Scope), Last_Inserted);
3040 Make_Block_Statement (Loc,
3041 Identifier => New_Reference_To (Current_Scope, Loc),
3042 Declarations => Decls,
3043 Handled_Statement_Sequence =>
3044 Make_Handled_Sequence_Of_Statements (Loc, Statements => Instrs),
3045 Has_Created_Identifier => True);
3047 -- When the transient scope was established, we pushed the entry for
3048 -- the transient scope onto the scope stack, so that the scope was
3049 -- active for the installation of finalizable entities etc. Now we
3050 -- must remove this entry, since we have constructed a proper block.
3055 end Make_Transient_Block;
3057 ------------------------
3058 -- Node_To_Be_Wrapped --
3059 ------------------------
3061 function Node_To_Be_Wrapped return Node_Id is
3063 return Scope_Stack.Table (Scope_Stack.Last).Node_To_Be_Wrapped;
3064 end Node_To_Be_Wrapped;
3066 ----------------------------
3067 -- Set_Node_To_Be_Wrapped --
3068 ----------------------------
3070 procedure Set_Node_To_Be_Wrapped (N : Node_Id) is
3072 Scope_Stack.Table (Scope_Stack.Last).Node_To_Be_Wrapped := N;
3073 end Set_Node_To_Be_Wrapped;
3075 ----------------------------------
3076 -- Store_After_Actions_In_Scope --
3077 ----------------------------------
3079 procedure Store_After_Actions_In_Scope (L : List_Id) is
3080 SE : Scope_Stack_Entry renames Scope_Stack.Table (Scope_Stack.Last);
3083 if Present (SE.Actions_To_Be_Wrapped_After) then
3084 Insert_List_Before_And_Analyze (
3085 First (SE.Actions_To_Be_Wrapped_After), L);
3088 SE.Actions_To_Be_Wrapped_After := L;
3090 if Is_List_Member (SE.Node_To_Be_Wrapped) then
3091 Set_Parent (L, Parent (SE.Node_To_Be_Wrapped));
3093 Set_Parent (L, SE.Node_To_Be_Wrapped);
3098 end Store_After_Actions_In_Scope;
3100 -----------------------------------
3101 -- Store_Before_Actions_In_Scope --
3102 -----------------------------------
3104 procedure Store_Before_Actions_In_Scope (L : List_Id) is
3105 SE : Scope_Stack_Entry renames Scope_Stack.Table (Scope_Stack.Last);
3108 if Present (SE.Actions_To_Be_Wrapped_Before) then
3109 Insert_List_After_And_Analyze (
3110 Last (SE.Actions_To_Be_Wrapped_Before), L);
3113 SE.Actions_To_Be_Wrapped_Before := L;
3115 if Is_List_Member (SE.Node_To_Be_Wrapped) then
3116 Set_Parent (L, Parent (SE.Node_To_Be_Wrapped));
3118 Set_Parent (L, SE.Node_To_Be_Wrapped);
3123 end Store_Before_Actions_In_Scope;
3125 --------------------------------
3126 -- Wrap_Transient_Declaration --
3127 --------------------------------
3129 -- If a transient scope has been established during the processing of the
3130 -- Expression of an Object_Declaration, it is not possible to wrap the
3131 -- declaration into a transient block as usual case, otherwise the object
3132 -- would be itself declared in the wrong scope. Therefore, all entities (if
3133 -- any) defined in the transient block are moved to the proper enclosing
3134 -- scope, furthermore, if they are controlled variables they are finalized
3135 -- right after the declaration. The finalization list of the transient
3136 -- scope is defined as a renaming of the enclosing one so during their
3137 -- initialization they will be attached to the proper finalization
3138 -- list. For instance, the following declaration :
3140 -- X : Typ := F (G (A), G (B));
3142 -- (where G(A) and G(B) return controlled values, expanded as _v1 and _v2)
3143 -- is expanded into :
3145 -- _local_final_list_1 : Finalizable_Ptr;
3146 -- X : Typ := [ complex Expression-Action ];
3147 -- Finalize_One(_v1);
3148 -- Finalize_One (_v2);
3150 procedure Wrap_Transient_Declaration (N : Node_Id) is
3152 LC : Entity_Id := Empty;
3154 Loc : constant Source_Ptr := Sloc (N);
3155 Enclosing_S : Entity_Id;
3157 Next_N : constant Node_Id := Next (N);
3161 Enclosing_S := Scope (S);
3163 -- Insert Actions kept in the Scope stack
3165 Insert_Actions_In_Scope_Around (N);
3167 -- If the declaration is consuming some secondary stack, mark the
3168 -- Enclosing scope appropriately.
3170 Uses_SS := Uses_Sec_Stack (S);
3173 -- Create a List controller and rename the final list to be its
3174 -- internal final pointer:
3175 -- Lxxx : Simple_List_Controller;
3176 -- Fxxx : Finalizable_Ptr renames Lxxx.F;
3178 if Present (Finalization_Chain_Entity (S)) then
3179 LC := Make_Defining_Identifier (Loc, New_Internal_Name ('L'));
3182 Make_Object_Declaration (Loc,
3183 Defining_Identifier => LC,
3184 Object_Definition =>
3185 New_Reference_To (RTE (RE_Simple_List_Controller), Loc)),
3187 Make_Object_Renaming_Declaration (Loc,
3188 Defining_Identifier => Finalization_Chain_Entity (S),
3189 Subtype_Mark => New_Reference_To (RTE (RE_Finalizable_Ptr), Loc),
3191 Make_Selected_Component (Loc,
3192 Prefix => New_Reference_To (LC, Loc),
3193 Selector_Name => Make_Identifier (Loc, Name_F))));
3195 -- Put the declaration at the beginning of the declaration part
3196 -- to make sure it will be before all other actions that have been
3197 -- inserted before N.
3199 Insert_List_Before_And_Analyze (First (List_Containing (N)), Nodes);
3201 -- Generate the Finalization calls by finalizing the list
3202 -- controller right away. It will be re-finalized on scope
3203 -- exit but it doesn't matter. It cannot be done when the
3204 -- call initializes a renaming object though because in this
3205 -- case, the object becomes a pointer to the temporary and thus
3206 -- increases its life span.
3208 if Nkind (N) = N_Object_Renaming_Declaration
3209 and then Controlled_Type (Etype (Defining_Identifier (N)))
3216 Ref => New_Reference_To (LC, Loc),
3218 With_Detach => New_Reference_To (Standard_False, Loc));
3219 if Present (Next_N) then
3220 Insert_List_Before_And_Analyze (Next_N, Nodes);
3222 Append_List_To (List_Containing (N), Nodes);
3227 -- Put the local entities back in the enclosing scope, and set the
3228 -- Is_Public flag appropriately.
3230 Transfer_Entities (S, Enclosing_S);
3232 -- Mark the enclosing dynamic scope so that the sec stack will be
3233 -- released upon its exit unless this is a function that returns on
3234 -- the sec stack in which case this will be done by the caller.
3237 S := Enclosing_Dynamic_Scope (S);
3239 if Ekind (S) = E_Function
3240 and then Requires_Transient_Scope (Etype (S))
3244 Set_Uses_Sec_Stack (S);
3245 Check_Restriction (No_Secondary_Stack, N);
3248 end Wrap_Transient_Declaration;
3250 -------------------------------
3251 -- Wrap_Transient_Expression --
3252 -------------------------------
3254 -- Insert actions before <Expression>:
3256 -- (lines marked with <CTRL> are expanded only in presence of Controlled
3257 -- objects needing finalization)
3261 -- _M : constant Mark_Id := SS_Mark;
3262 -- Local_Final_List : System.FI.Finalizable_Ptr; <CTRL>
3264 -- procedure _Clean is
3267 -- System.FI.Finalize_List (Local_Final_List); <CTRL>
3273 -- _E := <Expression>;
3278 -- then expression is replaced by _E
3280 procedure Wrap_Transient_Expression (N : Node_Id) is
3281 Loc : constant Source_Ptr := Sloc (N);
3282 E : constant Entity_Id :=
3283 Make_Defining_Identifier (Loc, New_Internal_Name ('E'));
3284 Etyp : constant Entity_Id := Etype (N);
3287 Insert_Actions (N, New_List (
3288 Make_Object_Declaration (Loc,
3289 Defining_Identifier => E,
3290 Object_Definition => New_Reference_To (Etyp, Loc)),
3292 Make_Transient_Block (Loc,
3294 Make_Assignment_Statement (Loc,
3295 Name => New_Reference_To (E, Loc),
3296 Expression => Relocate_Node (N)))));
3298 Rewrite (N, New_Reference_To (E, Loc));
3299 Analyze_And_Resolve (N, Etyp);
3300 end Wrap_Transient_Expression;
3302 ------------------------------
3303 -- Wrap_Transient_Statement --
3304 ------------------------------
3306 -- Transform <Instruction> into
3308 -- (lines marked with <CTRL> are expanded only in presence of Controlled
3309 -- objects needing finalization)
3312 -- _M : Mark_Id := SS_Mark;
3313 -- Local_Final_List : System.FI.Finalizable_Ptr ; <CTRL>
3315 -- procedure _Clean is
3318 -- System.FI.Finalize_List (Local_Final_List); <CTRL>
3329 procedure Wrap_Transient_Statement (N : Node_Id) is
3330 Loc : constant Source_Ptr := Sloc (N);
3331 New_Statement : constant Node_Id := Relocate_Node (N);
3334 Rewrite (N, Make_Transient_Block (Loc, New_Statement));
3336 -- With the scope stack back to normal, we can call analyze on the
3337 -- resulting block. At this point, the transient scope is being
3338 -- treated like a perfectly normal scope, so there is nothing
3339 -- special about it.
3341 -- Note: Wrap_Transient_Statement is called with the node already
3342 -- analyzed (i.e. Analyzed (N) is True). This is important, since
3343 -- otherwise we would get a recursive processing of the node when
3344 -- we do this Analyze call.
3347 end Wrap_Transient_Statement;