* bindgen.adb: Minor reformatting * cstand.adb: Minor reformatting * fmap.adb: Minor reformatting Change name from Add for Add_To_File_Map (Add is much too generic) Change Path_Name_Of to Mapped_Path_Name Change File_Name_Of to Mapped_File_Name Fix copyright dates in header * fmap.ads: Change name from Add for Add_To_File_Map (Add is much too generic) Change Path_Name_Of to Mapped_Path_Name Change File_Name_Of to Mapped_File_Name Fix copyright dates in header * fname-uf.adb: Minor reformatting. New names of stuff in Fmap. Add use clause for Fmap. * make.adb: Minor reformatting * osint.adb: Minor reformatting. Change of names in Fmap. Add use clause for Fmap. * prj-env.adb: Minor reformatting * prj-env.ads: Minor reformatting * switch.adb: Minor reformatting. Do proper raise of Bad_Switch if error found (there were odd exceptions to this general rule in -gnatec/-gnatem processing) * raise.c (__gnat_eh_personality): Exception handling personality routine for Ada. Still in rough state, inspired from the C++ version and still containing a bunch of debugging artifacts. (parse_lsda_header, get_ttype_entry): Local (static) helpers, also inspired from the C++ library. * raise.c (eh_personality): Add comments. Part of work for the GCC 3 exception handling integration. * Makefile.in: Remove use of 5smastop.adb which is obsolete. (HIE_SOURCES): Add s-secsta.ad{s,b}. (HIE_OBJS): Add s-fat*.o (RAVEN_SOURCES): Remove files that are no longer required. Add interrupt handling files. (RAVEN_MOD): Removed, no longer needed. * a-ngelfu.adb: Remove ??? comment for inappropriate Inline_Always Add 2001 to copyright date * g-regpat.adb: Change pragma Inline_Always to Inline. There is no need to force universal inlining for these cases. * s-taprob.adb: Minor clean ups so that this unit can be used in Ravenscar HI. * exp_ch7.adb: Allow use of secondary stack in HI mode. Disallow it when pragma Restrictions (No_Secondary_Stack) is specified. * prj-tree.ads (Project_Node_Record): Add comments for components Pkg_Id and Case_Insensitive. * g-socket.adb: Minor reformatting. Found while reading code. * prj-tree.ads: Minor reformatting From-SVN: r48195
2811 lines
96 KiB
Ada
2811 lines
96 KiB
Ada
------------------------------------------------------------------------------
|
|
-- --
|
|
-- GNAT COMPILER COMPONENTS --
|
|
-- --
|
|
-- E X P _ C H 7 --
|
|
-- --
|
|
-- B o d y --
|
|
-- --
|
|
-- $Revision$
|
|
-- --
|
|
-- Copyright (C) 1992-2001, Free Software Foundation, Inc. --
|
|
-- --
|
|
-- GNAT is free software; you can redistribute it and/or modify it under --
|
|
-- terms of the GNU General Public License as published by the Free Soft- --
|
|
-- ware Foundation; either version 2, or (at your option) any later ver- --
|
|
-- sion. GNAT is distributed in the hope that it will be useful, but WITH- --
|
|
-- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY --
|
|
-- or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License --
|
|
-- for more details. You should have received a copy of the GNU General --
|
|
-- Public License distributed with GNAT; see file COPYING. If not, write --
|
|
-- to the Free Software Foundation, 59 Temple Place - Suite 330, Boston, --
|
|
-- MA 02111-1307, USA. --
|
|
-- --
|
|
-- GNAT was originally developed by the GNAT team at New York University. --
|
|
-- It is now maintained by Ada Core Technologies Inc (http://www.gnat.com). --
|
|
-- --
|
|
------------------------------------------------------------------------------
|
|
|
|
-- This package contains virtually all expansion mechanisms related to
|
|
-- - controlled types
|
|
-- - transient scopes
|
|
|
|
with Atree; use Atree;
|
|
with Debug; use Debug;
|
|
with Einfo; use Einfo;
|
|
with Exp_Ch9; use Exp_Ch9;
|
|
with Exp_Ch11; use Exp_Ch11;
|
|
with Exp_Dbug; use Exp_Dbug;
|
|
with Exp_Tss; use Exp_Tss;
|
|
with Exp_Util; use Exp_Util;
|
|
with Freeze; use Freeze;
|
|
with Hostparm; use Hostparm;
|
|
with Lib; use Lib;
|
|
with Lib.Xref; use Lib.Xref;
|
|
with Nlists; use Nlists;
|
|
with Nmake; use Nmake;
|
|
with Opt; use Opt;
|
|
with Output; use Output;
|
|
with Restrict; use Restrict;
|
|
with Rtsfind; use Rtsfind;
|
|
with Targparm; use Targparm;
|
|
with Sinfo; use Sinfo;
|
|
with Sem; use Sem;
|
|
with Sem_Ch3; use Sem_Ch3;
|
|
with Sem_Ch7; use Sem_Ch7;
|
|
with Sem_Ch8; use Sem_Ch8;
|
|
with Sem_Res; use Sem_Res;
|
|
with Sem_Type; use Sem_Type;
|
|
with Sem_Util; use Sem_Util;
|
|
with Snames; use Snames;
|
|
with Stand; use Stand;
|
|
with Tbuild; use Tbuild;
|
|
with Uintp; use Uintp;
|
|
|
|
package body Exp_Ch7 is
|
|
|
|
--------------------------------
|
|
-- Transient Scope Management --
|
|
--------------------------------
|
|
|
|
-- A transient scope is created when temporary objects are created by the
|
|
-- compiler. These temporary objects are allocated on the secondary stack
|
|
-- and the transient scope is responsible for finalizing the object when
|
|
-- appropriate and reclaiming the memory at the right time. The temporary
|
|
-- objects are generally the objects allocated to store the result of a
|
|
-- function returning an unconstrained or a tagged value. Expressions
|
|
-- needing to be wrapped in a transient scope (functions calls returning
|
|
-- unconstrained or tagged values) may appear in 3 different contexts which
|
|
-- lead to 3 different kinds of transient scope expansion:
|
|
|
|
-- 1. In a simple statement (procedure call, assignment, ...). In
|
|
-- this case the instruction is wrapped into a transient block.
|
|
-- (See Wrap_Transient_Statement for details)
|
|
|
|
-- 2. In an expression of a control structure (test in a IF statement,
|
|
-- expression in a CASE statement, ...).
|
|
-- (See Wrap_Transient_Expression for details)
|
|
|
|
-- 3. In a expression of an object_declaration. No wrapping is possible
|
|
-- here, so the finalization actions, if any are done right after the
|
|
-- declaration and the secondary stack deallocation is done in the
|
|
-- proper enclosing scope (see Wrap_Transient_Declaration for details)
|
|
|
|
-- Note about function returning tagged types: It has been decided to
|
|
-- always allocate their result in the secondary stack while it is not
|
|
-- absolutely mandatory when the tagged type is constrained because the
|
|
-- caller knows the size of the returned object and thus could allocate the
|
|
-- result in the primary stack. But, allocating them always in the
|
|
-- secondary stack simplifies many implementation hassles:
|
|
|
|
-- - If it is dispatching function call, the computation of the size of
|
|
-- the result is possible but complex from the outside.
|
|
|
|
-- - If the returned type is controlled, the assignment of the returned
|
|
-- value to the anonymous object involves an Adjust, and we have no
|
|
-- easy way to access the anonymous object created by the back-end
|
|
|
|
-- - If the returned type is class-wide, this is an unconstrained type
|
|
-- anyway
|
|
|
|
-- Furthermore, the little loss in efficiency which is the result of this
|
|
-- decision is not such a big deal because function returning tagged types
|
|
-- are not very much used in real life as opposed to functions returning
|
|
-- access to a tagged type
|
|
|
|
--------------------------------------------------
|
|
-- Transient Blocks and Finalization Management --
|
|
--------------------------------------------------
|
|
|
|
function Find_Node_To_Be_Wrapped (N : Node_Id) return Node_Id;
|
|
-- N is a node wich may generate a transient scope. Loop over the
|
|
-- parent pointers of N until it find the appropriate node to
|
|
-- wrap. It it returns Empty, it means that no transient scope is
|
|
-- needed in this context.
|
|
|
|
function Make_Clean
|
|
(N : Node_Id;
|
|
Clean : Entity_Id;
|
|
Mark : Entity_Id;
|
|
Flist : Entity_Id;
|
|
Is_Task : Boolean;
|
|
Is_Master : Boolean;
|
|
Is_Protected_Subprogram : Boolean;
|
|
Is_Task_Allocation_Block : Boolean;
|
|
Is_Asynchronous_Call_Block : Boolean)
|
|
return Node_Id;
|
|
-- Expand a the clean-up procedure for controlled and/or transient
|
|
-- block, and/or task master or task body, or blocks used to
|
|
-- implement task allocation or asynchronous entry calls, or
|
|
-- procedures used to implement protected procedures. Clean is the
|
|
-- entity for such a procedure. Mark is the entity for the secondary
|
|
-- stack mark, if empty only controlled block clean-up will be
|
|
-- performed. Flist is the entity for the local final list, if empty
|
|
-- only transient scope clean-up will be performed. The flags
|
|
-- Is_Task and Is_Master control the calls to the corresponding
|
|
-- finalization actions for a task body or for an entity that is a
|
|
-- task master.
|
|
|
|
procedure Set_Node_To_Be_Wrapped (N : Node_Id);
|
|
-- Set the field Node_To_Be_Wrapped of the current scope
|
|
|
|
procedure Insert_Actions_In_Scope_Around (N : Node_Id);
|
|
-- Insert the before-actions kept in the scope stack before N, and the
|
|
-- after after-actions, after N which must be a member of a list.
|
|
|
|
function Make_Transient_Block
|
|
(Loc : Source_Ptr;
|
|
Action : Node_Id)
|
|
return Node_Id;
|
|
-- Create a transient block whose name is Scope, which is also a
|
|
-- controlled block if Flist is not empty and whose only code is
|
|
-- Action (either a single statement or single declaration).
|
|
|
|
type Final_Primitives is (Initialize_Case, Adjust_Case, Finalize_Case);
|
|
-- This enumeration type is defined in order to ease sharing code for
|
|
-- building finalization procedures for composite types.
|
|
|
|
Name_Of : constant array (Final_Primitives) of Name_Id :=
|
|
(Initialize_Case => Name_Initialize,
|
|
Adjust_Case => Name_Adjust,
|
|
Finalize_Case => Name_Finalize);
|
|
|
|
Deep_Name_Of : constant array (Final_Primitives) of Name_Id :=
|
|
(Initialize_Case => Name_uDeep_Initialize,
|
|
Adjust_Case => Name_uDeep_Adjust,
|
|
Finalize_Case => Name_uDeep_Finalize);
|
|
|
|
procedure Build_Record_Deep_Procs (Typ : Entity_Id);
|
|
-- Build the deep Initialize/Adjust/Finalize for a record Typ with
|
|
-- Has_Component_Component set and store them using the TSS mechanism.
|
|
|
|
procedure Build_Array_Deep_Procs (Typ : Entity_Id);
|
|
-- Build the deep Initialize/Adjust/Finalize for a record Typ with
|
|
-- Has_Controlled_Component set and store them using the TSS mechanism.
|
|
|
|
function Make_Deep_Proc
|
|
(Prim : Final_Primitives;
|
|
Typ : Entity_Id;
|
|
Stmts : List_Id)
|
|
return Node_Id;
|
|
-- This function generates the tree for Deep_Initialize, Deep_Adjust
|
|
-- or Deep_Finalize procedures according to the first parameter,
|
|
-- these procedures operate on the type Typ. The Stmts parameter
|
|
-- gives the body of the procedure.
|
|
|
|
function Make_Deep_Array_Body
|
|
(Prim : Final_Primitives;
|
|
Typ : Entity_Id)
|
|
return List_Id;
|
|
-- This function generates the list of statements for implementing
|
|
-- Deep_Initialize, Deep_Adjust or Deep_Finalize procedures
|
|
-- according to the first parameter, these procedures operate on the
|
|
-- array type Typ.
|
|
|
|
function Make_Deep_Record_Body
|
|
(Prim : Final_Primitives;
|
|
Typ : Entity_Id)
|
|
return List_Id;
|
|
-- This function generates the list of statements for implementing
|
|
-- Deep_Initialize, Deep_Adjust or Deep_Finalize procedures
|
|
-- according to the first parameter, these procedures operate on the
|
|
-- record type Typ.
|
|
|
|
function Convert_View
|
|
(Proc : Entity_Id;
|
|
Arg : Node_Id;
|
|
Ind : Pos := 1)
|
|
return Node_Id;
|
|
-- Proc is one of the Initialize/Adjust/Finalize operations, and
|
|
-- Arg is the argument being passed to it. Ind indicates which
|
|
-- formal of procedure Proc we are trying to match. This function
|
|
-- will, if necessary, generate an conversion between the partial
|
|
-- and full view of Arg to match the type of the formal of Proc,
|
|
-- or force a conversion to the class-wide type in the case where
|
|
-- the operation is abstract.
|
|
|
|
-----------------------------
|
|
-- Finalization Management --
|
|
-----------------------------
|
|
|
|
-- This part describe how Initialization/Adjusment/Finalization procedures
|
|
-- are generated and called. Two cases must be considered, types that are
|
|
-- Controlled (Is_Controlled flag set) and composite types that contain
|
|
-- controlled components (Has_Controlled_Component flag set). In the first
|
|
-- case the procedures to call are the user-defined primitive operations
|
|
-- Initialize/Adjust/Finalize. In the second case, GNAT generates
|
|
-- Deep_Initialize, Deep_Adjust and Deep_Finalize that are in charge of
|
|
-- calling the former procedures on the controlled components.
|
|
|
|
-- For records with Has_Controlled_Component set, a hidden "controller"
|
|
-- component is inserted. This controller component contains its own
|
|
-- finalization list on which all controlled components are attached
|
|
-- creating an indirection on the upper-level Finalization list. This
|
|
-- technique facilitates the management of objects whose number of
|
|
-- controlled components changes during execution. This controller
|
|
-- component is itself controlled and is attached to the upper-level
|
|
-- finalization chain. Its adjust primitive is in charge of calling
|
|
-- adjust on the components and adusting the finalization pointer to
|
|
-- match their new location (see a-finali.adb)
|
|
|
|
-- It is not possible to use a similar technique for arrays that have
|
|
-- Has_Controlled_Component set. In this case, deep procedures are
|
|
-- generated that call initialize/adjust/finalize + attachment or
|
|
-- detachment on the finalization list for all component.
|
|
|
|
-- Initialize calls: they are generated for declarations or dynamic
|
|
-- allocations of Controlled objects with no initial value. They are
|
|
-- always followed by an attachment to the current Finalization
|
|
-- Chain. For the dynamic allocation case this the chain attached to
|
|
-- the scope of the access type definition otherwise, this is the chain
|
|
-- of the current scope.
|
|
|
|
-- Adjust Calls: They are generated on 2 occasions: (1) for
|
|
-- declarations or dynamic allocations of Controlled objects with an
|
|
-- initial value. (2) after an assignment. In the first case they are
|
|
-- followed by an attachment to the final chain, in the second case
|
|
-- they are not.
|
|
|
|
-- Finalization Calls: They are generated on (1) scope exit, (2)
|
|
-- assignments, (3) unchecked deallocations. In case (3) they have to
|
|
-- be detached from the final chain, in case (2) they must not and in
|
|
-- case (1) this is not important since we are exiting the scope
|
|
-- anyway.
|
|
|
|
-- Here is a simple example of the expansion of a controlled block :
|
|
|
|
-- declare
|
|
-- X : Controlled ;
|
|
-- Y : Controlled := Init;
|
|
--
|
|
-- type R is record
|
|
-- C : Controlled;
|
|
-- end record;
|
|
-- W : R;
|
|
-- Z : R := (C => X);
|
|
-- begin
|
|
-- X := Y;
|
|
-- W := Z;
|
|
-- end;
|
|
--
|
|
-- is expanded into
|
|
--
|
|
-- declare
|
|
-- _L : System.FI.Finalizable_Ptr;
|
|
|
|
-- procedure _Clean is
|
|
-- begin
|
|
-- Abort_Defer;
|
|
-- System.FI.Finalize_List (_L);
|
|
-- Abort_Undefer;
|
|
-- end _Clean;
|
|
|
|
-- X : Controlled;
|
|
-- Initialize (X);
|
|
-- Attach_To_Final_List (_L, Finalizable (X), 1);
|
|
-- Y : Controlled := Init;
|
|
-- Adjust (Y);
|
|
-- Attach_To_Final_List (_L, Finalizable (Y), 1);
|
|
--
|
|
-- type R is record
|
|
-- _C : Record_Controller;
|
|
-- C : Controlled;
|
|
-- end record;
|
|
-- W : R;
|
|
-- Deep_Initialize (W, _L, 1);
|
|
-- Z : R := (C => X);
|
|
-- Deep_Adjust (Z, _L, 1);
|
|
|
|
-- begin
|
|
-- Finalize (X);
|
|
-- X := Y;
|
|
-- Adjust (X);
|
|
|
|
-- Deep_Finalize (W, False);
|
|
-- W := Z;
|
|
-- Deep_Adjust (W, _L, 0);
|
|
-- at end
|
|
-- _Clean;
|
|
-- end;
|
|
|
|
function Global_Flist_Ref (Flist_Ref : Node_Id) return Boolean;
|
|
-- Return True if Flist_Ref refers to a global final list, either
|
|
-- the object GLobal_Final_List which is used to attach standalone
|
|
-- objects, or any of the list controllers associated with library
|
|
-- level access to controlled objects
|
|
|
|
----------------------------
|
|
-- Build_Array_Deep_Procs --
|
|
----------------------------
|
|
|
|
procedure Build_Array_Deep_Procs (Typ : Entity_Id) is
|
|
begin
|
|
Set_TSS (Typ,
|
|
Make_Deep_Proc (
|
|
Prim => Initialize_Case,
|
|
Typ => Typ,
|
|
Stmts => Make_Deep_Array_Body (Initialize_Case, Typ)));
|
|
|
|
if not Is_Return_By_Reference_Type (Typ) then
|
|
Set_TSS (Typ,
|
|
Make_Deep_Proc (
|
|
Prim => Adjust_Case,
|
|
Typ => Typ,
|
|
Stmts => Make_Deep_Array_Body (Adjust_Case, Typ)));
|
|
end if;
|
|
|
|
Set_TSS (Typ,
|
|
Make_Deep_Proc (
|
|
Prim => Finalize_Case,
|
|
Typ => Typ,
|
|
Stmts => Make_Deep_Array_Body (Finalize_Case, Typ)));
|
|
end Build_Array_Deep_Procs;
|
|
|
|
-----------------------------
|
|
-- Build_Controlling_Procs --
|
|
-----------------------------
|
|
|
|
procedure Build_Controlling_Procs (Typ : Entity_Id) is
|
|
begin
|
|
if Is_Array_Type (Typ) then
|
|
Build_Array_Deep_Procs (Typ);
|
|
|
|
else pragma Assert (Is_Record_Type (Typ));
|
|
Build_Record_Deep_Procs (Typ);
|
|
end if;
|
|
end Build_Controlling_Procs;
|
|
|
|
----------------------
|
|
-- Build_Final_List --
|
|
----------------------
|
|
|
|
procedure Build_Final_List (N : Node_Id; Typ : Entity_Id) is
|
|
Loc : constant Source_Ptr := Sloc (N);
|
|
|
|
begin
|
|
Set_Associated_Final_Chain (Typ,
|
|
Make_Defining_Identifier (Loc,
|
|
New_External_Name (Chars (Typ), 'L')));
|
|
|
|
Insert_Action (N,
|
|
Make_Object_Declaration (Loc,
|
|
Defining_Identifier =>
|
|
Associated_Final_Chain (Typ),
|
|
Object_Definition =>
|
|
New_Reference_To
|
|
(RTE (RE_List_Controller), Loc)));
|
|
end Build_Final_List;
|
|
|
|
-----------------------------
|
|
-- Build_Record_Deep_Procs --
|
|
-----------------------------
|
|
|
|
procedure Build_Record_Deep_Procs (Typ : Entity_Id) is
|
|
begin
|
|
Set_TSS (Typ,
|
|
Make_Deep_Proc (
|
|
Prim => Initialize_Case,
|
|
Typ => Typ,
|
|
Stmts => Make_Deep_Record_Body (Initialize_Case, Typ)));
|
|
|
|
if not Is_Return_By_Reference_Type (Typ) then
|
|
Set_TSS (Typ,
|
|
Make_Deep_Proc (
|
|
Prim => Adjust_Case,
|
|
Typ => Typ,
|
|
Stmts => Make_Deep_Record_Body (Adjust_Case, Typ)));
|
|
end if;
|
|
|
|
Set_TSS (Typ,
|
|
Make_Deep_Proc (
|
|
Prim => Finalize_Case,
|
|
Typ => Typ,
|
|
Stmts => Make_Deep_Record_Body (Finalize_Case, Typ)));
|
|
end Build_Record_Deep_Procs;
|
|
|
|
---------------------
|
|
-- Controlled_Type --
|
|
---------------------
|
|
|
|
function Controlled_Type (T : Entity_Id) return Boolean is
|
|
begin
|
|
-- Class-wide types are considered controlled because they may contain
|
|
-- an extension that has controlled components
|
|
|
|
return (Is_Class_Wide_Type (T)
|
|
and then not No_Run_Time
|
|
and then not In_Finalization_Root (T))
|
|
or else Is_Controlled (T)
|
|
or else Has_Controlled_Component (T)
|
|
or else (Is_Concurrent_Type (T)
|
|
and then Present (Corresponding_Record_Type (T))
|
|
and then Controlled_Type (Corresponding_Record_Type (T)));
|
|
end Controlled_Type;
|
|
|
|
--------------------------
|
|
-- Controller_Component --
|
|
--------------------------
|
|
|
|
function Controller_Component (Typ : Entity_Id) return Entity_Id is
|
|
T : Entity_Id := Base_Type (Typ);
|
|
Comp : Entity_Id;
|
|
Comp_Scop : Entity_Id;
|
|
Res : Entity_Id := Empty;
|
|
Res_Scop : Entity_Id := Empty;
|
|
|
|
begin
|
|
if Is_Class_Wide_Type (T) then
|
|
T := Root_Type (T);
|
|
end if;
|
|
|
|
if Is_Private_Type (T) then
|
|
T := Underlying_Type (T);
|
|
end if;
|
|
|
|
-- Fetch the outermost controller
|
|
|
|
Comp := First_Entity (T);
|
|
while Present (Comp) loop
|
|
if Chars (Comp) = Name_uController then
|
|
Comp_Scop := Scope (Original_Record_Component (Comp));
|
|
|
|
-- If this controller is at the outermost level, no need to
|
|
-- look for another one
|
|
|
|
if Comp_Scop = T then
|
|
return Comp;
|
|
|
|
-- Otherwise record the outermost one and continue looking
|
|
|
|
elsif Res = Empty or else Is_Ancestor (Res_Scop, Comp_Scop) then
|
|
Res := Comp;
|
|
Res_Scop := Comp_Scop;
|
|
end if;
|
|
end if;
|
|
|
|
Next_Entity (Comp);
|
|
end loop;
|
|
|
|
-- If we fall through the loop, there is no controller component
|
|
|
|
return Res;
|
|
end Controller_Component;
|
|
|
|
------------------
|
|
-- Convert_View --
|
|
------------------
|
|
|
|
function Convert_View
|
|
(Proc : Entity_Id;
|
|
Arg : Node_Id;
|
|
Ind : Pos := 1)
|
|
return Node_Id
|
|
is
|
|
Fent : Entity_Id := First_Entity (Proc);
|
|
Ftyp : Entity_Id;
|
|
Atyp : Entity_Id;
|
|
|
|
begin
|
|
for J in 2 .. Ind loop
|
|
Next_Entity (Fent);
|
|
end loop;
|
|
|
|
Ftyp := Etype (Fent);
|
|
|
|
if Nkind (Arg) = N_Type_Conversion
|
|
or else Nkind (Arg) = N_Unchecked_Type_Conversion
|
|
then
|
|
Atyp := Entity (Subtype_Mark (Arg));
|
|
else
|
|
Atyp := Etype (Arg);
|
|
end if;
|
|
|
|
if Is_Abstract (Proc) and then Is_Tagged_Type (Ftyp) then
|
|
return Unchecked_Convert_To (Class_Wide_Type (Ftyp), Arg);
|
|
|
|
elsif Ftyp /= Atyp
|
|
and then Present (Atyp)
|
|
and then
|
|
(Is_Private_Type (Ftyp) or else Is_Private_Type (Atyp))
|
|
and then Underlying_Type (Atyp) = Underlying_Type (Ftyp)
|
|
then
|
|
return Unchecked_Convert_To (Ftyp, Arg);
|
|
|
|
-- If the argument is already a conversion, as generated by
|
|
-- Make_Init_Call, set the target type to the type of the formal
|
|
-- directly, to avoid spurious typing problems.
|
|
|
|
elsif (Nkind (Arg) = N_Unchecked_Type_Conversion
|
|
or else Nkind (Arg) = N_Type_Conversion)
|
|
and then not Is_Class_Wide_Type (Atyp)
|
|
then
|
|
Set_Subtype_Mark (Arg, New_Occurrence_Of (Ftyp, Sloc (Arg)));
|
|
Set_Etype (Arg, Ftyp);
|
|
return Arg;
|
|
|
|
else
|
|
return Arg;
|
|
end if;
|
|
end Convert_View;
|
|
|
|
-------------------------------
|
|
-- Establish_Transient_Scope --
|
|
-------------------------------
|
|
|
|
-- This procedure is called each time a transient block has to be inserted
|
|
-- that is to say for each call to a function with unconstrained ot tagged
|
|
-- result. It creates a new scope on the stack scope in order to enclose
|
|
-- all transient variables generated
|
|
|
|
procedure Establish_Transient_Scope (N : Node_Id; Sec_Stack : Boolean) is
|
|
Loc : constant Source_Ptr := Sloc (N);
|
|
Wrap_Node : Node_Id;
|
|
|
|
Sec_Stk : constant Boolean :=
|
|
Sec_Stack and not Functions_Return_By_DSP_On_Target;
|
|
-- We never need a secondary stack if functions return by DSP
|
|
|
|
begin
|
|
-- Do not create a transient scope if we are already inside one
|
|
|
|
for S in reverse Scope_Stack.First .. Scope_Stack.Last loop
|
|
|
|
if Scope_Stack.Table (S).Is_Transient then
|
|
if Sec_Stk then
|
|
Set_Uses_Sec_Stack (Scope_Stack.Table (S).Entity);
|
|
end if;
|
|
|
|
return;
|
|
|
|
-- If we have encountered Standard there are no enclosing
|
|
-- transient scopes.
|
|
|
|
elsif Scope_Stack.Table (S).Entity = Standard_Standard then
|
|
exit;
|
|
|
|
end if;
|
|
end loop;
|
|
|
|
Wrap_Node := Find_Node_To_Be_Wrapped (N);
|
|
|
|
-- Case of no wrap node, false alert, no transient scope needed
|
|
|
|
if No (Wrap_Node) then
|
|
null;
|
|
|
|
-- Transient scope is required
|
|
|
|
else
|
|
New_Scope (New_Internal_Entity (E_Block, Current_Scope, Loc, 'B'));
|
|
Set_Scope_Is_Transient;
|
|
|
|
if Sec_Stk then
|
|
Set_Uses_Sec_Stack (Current_Scope);
|
|
Check_Restriction (No_Secondary_Stack, N);
|
|
end if;
|
|
|
|
Set_Etype (Current_Scope, Standard_Void_Type);
|
|
Set_Node_To_Be_Wrapped (Wrap_Node);
|
|
|
|
if Debug_Flag_W then
|
|
Write_Str (" <Transient>");
|
|
Write_Eol;
|
|
end if;
|
|
end if;
|
|
end Establish_Transient_Scope;
|
|
|
|
----------------------------
|
|
-- Expand_Cleanup_Actions --
|
|
----------------------------
|
|
|
|
procedure Expand_Cleanup_Actions (N : Node_Id) is
|
|
Loc : Source_Ptr;
|
|
S : constant Entity_Id :=
|
|
Current_Scope;
|
|
Flist : constant Entity_Id :=
|
|
Finalization_Chain_Entity (S);
|
|
Is_Task : constant Boolean :=
|
|
(Nkind (Original_Node (N)) = N_Task_Body);
|
|
Is_Master : constant Boolean :=
|
|
Nkind (N) /= N_Entry_Body
|
|
and then Is_Task_Master (N);
|
|
Is_Protected : constant Boolean :=
|
|
Nkind (N) = N_Subprogram_Body
|
|
and then Is_Protected_Subprogram_Body (N);
|
|
Is_Task_Allocation : constant Boolean :=
|
|
Nkind (N) = N_Block_Statement
|
|
and then Is_Task_Allocation_Block (N);
|
|
Is_Asynchronous_Call : constant Boolean :=
|
|
Nkind (N) = N_Block_Statement
|
|
and then Is_Asynchronous_Call_Block (N);
|
|
|
|
Clean : Entity_Id;
|
|
Mark : Entity_Id := Empty;
|
|
New_Decls : List_Id := New_List;
|
|
Blok : Node_Id;
|
|
Wrapped : Boolean;
|
|
Chain : Entity_Id := Empty;
|
|
Decl : Node_Id;
|
|
Old_Poll : Boolean;
|
|
|
|
begin
|
|
|
|
-- Compute a location that is not directly in the user code in
|
|
-- order to avoid to generate confusing debug info. A good
|
|
-- approximation is the name of the outer user-defined scope
|
|
|
|
declare
|
|
S1 : Entity_Id := S;
|
|
|
|
begin
|
|
while not Comes_From_Source (S1) and then S1 /= Standard_Standard loop
|
|
S1 := Scope (S1);
|
|
end loop;
|
|
|
|
Loc := Sloc (S1);
|
|
end;
|
|
|
|
-- There are cleanup actions only if the secondary stack needs
|
|
-- releasing or some finalizations are needed or in the context
|
|
-- of tasking
|
|
|
|
if Uses_Sec_Stack (Current_Scope)
|
|
and then not Sec_Stack_Needed_For_Return (Current_Scope)
|
|
then
|
|
null;
|
|
elsif No (Flist)
|
|
and then not Is_Master
|
|
and then not Is_Task
|
|
and then not Is_Protected
|
|
and then not Is_Task_Allocation
|
|
and then not Is_Asynchronous_Call
|
|
then
|
|
return;
|
|
end if;
|
|
|
|
-- Set polling off, since we don't need to poll during cleanup
|
|
-- actions, and indeed for the cleanup routine, which is executed
|
|
-- with aborts deferred, we don't want polling.
|
|
|
|
Old_Poll := Polling_Required;
|
|
Polling_Required := False;
|
|
|
|
-- Make sure we have a declaration list, since we will add to it
|
|
|
|
if No (Declarations (N)) then
|
|
Set_Declarations (N, New_List);
|
|
end if;
|
|
|
|
-- The task activation call has already been built for task
|
|
-- allocation blocks.
|
|
|
|
if not Is_Task_Allocation then
|
|
Build_Task_Activation_Call (N);
|
|
end if;
|
|
|
|
if Is_Master then
|
|
Establish_Task_Master (N);
|
|
end if;
|
|
|
|
-- If secondary stack is in use, expand:
|
|
-- _Mxx : constant Mark_Id := SS_Mark;
|
|
|
|
-- Suppress calls to SS_Mark and SS_Release if Java_VM,
|
|
-- since we never use the secondary stack on the JVM.
|
|
|
|
if Uses_Sec_Stack (Current_Scope)
|
|
and then not Sec_Stack_Needed_For_Return (Current_Scope)
|
|
and then not Java_VM
|
|
then
|
|
Mark := Make_Defining_Identifier (Loc, New_Internal_Name ('M'));
|
|
Append_To (New_Decls,
|
|
Make_Object_Declaration (Loc,
|
|
Defining_Identifier => Mark,
|
|
Object_Definition => New_Reference_To (RTE (RE_Mark_Id), Loc),
|
|
Expression =>
|
|
Make_Function_Call (Loc,
|
|
Name => New_Reference_To (RTE (RE_SS_Mark), Loc))));
|
|
|
|
Set_Uses_Sec_Stack (Current_Scope, False);
|
|
end if;
|
|
|
|
-- If finalization list is present then expand:
|
|
-- Local_Final_List : System.FI.Finalizable_Ptr;
|
|
|
|
if Present (Flist) then
|
|
Append_To (New_Decls,
|
|
Make_Object_Declaration (Loc,
|
|
Defining_Identifier => Flist,
|
|
Object_Definition =>
|
|
New_Reference_To (RTE (RE_Finalizable_Ptr), Loc)));
|
|
end if;
|
|
|
|
-- Clean-up procedure definition
|
|
|
|
Clean := Make_Defining_Identifier (Loc, Name_uClean);
|
|
Set_Suppress_Elaboration_Warnings (Clean);
|
|
Append_To (New_Decls,
|
|
Make_Clean (N, Clean, Mark, Flist,
|
|
Is_Task,
|
|
Is_Master,
|
|
Is_Protected,
|
|
Is_Task_Allocation,
|
|
Is_Asynchronous_Call));
|
|
|
|
-- If exception handlers are present, wrap the Sequence of
|
|
-- statements in a block because it is not possible to get
|
|
-- exception handlers and an AT END call in the same scope.
|
|
|
|
if Present (Exception_Handlers (Handled_Statement_Sequence (N))) then
|
|
Blok :=
|
|
Make_Block_Statement (Loc,
|
|
Handled_Statement_Sequence => Handled_Statement_Sequence (N));
|
|
Set_Handled_Statement_Sequence (N,
|
|
Make_Handled_Sequence_Of_Statements (Loc, New_List (Blok)));
|
|
Wrapped := True;
|
|
|
|
-- Otherwise we do not wrap
|
|
|
|
else
|
|
Wrapped := False;
|
|
Blok := Empty;
|
|
end if;
|
|
|
|
-- Don't move the _chain Activation_Chain declaration in task
|
|
-- allocation blocks. Task allocation blocks use this object
|
|
-- in their cleanup handlers, and gigi complains if it is declared
|
|
-- in the sequence of statements of the scope that declares the
|
|
-- handler.
|
|
|
|
if Is_Task_Allocation then
|
|
Chain := Activation_Chain_Entity (N);
|
|
Decl := First (Declarations (N));
|
|
|
|
while Nkind (Decl) /= N_Object_Declaration
|
|
or else Defining_Identifier (Decl) /= Chain
|
|
loop
|
|
Next (Decl);
|
|
pragma Assert (Present (Decl));
|
|
end loop;
|
|
|
|
Remove (Decl);
|
|
Prepend_To (New_Decls, Decl);
|
|
end if;
|
|
|
|
-- Now we move the declarations into the Sequence of statements
|
|
-- in order to get them protected by the AT END call. It may seem
|
|
-- weird to put declarations in the sequence of statement but in
|
|
-- fact nothing forbids that at the tree level. We also set the
|
|
-- First_Real_Statement field so that we remember where the real
|
|
-- statements (i.e. original statements) begin. Note that if we
|
|
-- wrapped the statements, the first real statement is inside the
|
|
-- inner block. If the First_Real_Statement is already set (as is
|
|
-- the case for subprogram bodies that are expansions of task bodies)
|
|
-- then do not reset it, because its declarative part would migrate
|
|
-- to the statement part.
|
|
|
|
if not Wrapped then
|
|
if No (First_Real_Statement (Handled_Statement_Sequence (N))) then
|
|
Set_First_Real_Statement (Handled_Statement_Sequence (N),
|
|
First (Statements (Handled_Statement_Sequence (N))));
|
|
end if;
|
|
|
|
else
|
|
Set_First_Real_Statement (Handled_Statement_Sequence (N), Blok);
|
|
end if;
|
|
|
|
Append_List_To (Declarations (N),
|
|
Statements (Handled_Statement_Sequence (N)));
|
|
Set_Statements (Handled_Statement_Sequence (N), Declarations (N));
|
|
|
|
-- We need to reset the Sloc of the handled statement sequence to
|
|
-- properly reflect the new initial "statement" in the sequence.
|
|
|
|
Set_Sloc
|
|
(Handled_Statement_Sequence (N), Sloc (First (Declarations (N))));
|
|
|
|
-- The declarations of the _Clean procedure and finalization chain
|
|
-- replace the old declarations that have been moved inward
|
|
|
|
Set_Declarations (N, New_Decls);
|
|
Analyze_Declarations (New_Decls);
|
|
|
|
-- The At_End call is attached to the sequence of statements.
|
|
|
|
declare
|
|
HSS : Node_Id;
|
|
|
|
begin
|
|
-- If the construct is a protected subprogram, then the call to
|
|
-- the corresponding unprotected program appears in a block which
|
|
-- is the last statement in the body, and it is this block that
|
|
-- must be covered by the At_End handler.
|
|
|
|
if Is_Protected then
|
|
HSS := Handled_Statement_Sequence
|
|
(Last (Statements (Handled_Statement_Sequence (N))));
|
|
else
|
|
HSS := Handled_Statement_Sequence (N);
|
|
end if;
|
|
|
|
Set_At_End_Proc (HSS, New_Occurrence_Of (Clean, Loc));
|
|
Expand_At_End_Handler (HSS, Empty);
|
|
end;
|
|
|
|
-- Restore saved polling mode
|
|
|
|
Polling_Required := Old_Poll;
|
|
end Expand_Cleanup_Actions;
|
|
|
|
-------------------------------
|
|
-- Expand_Ctrl_Function_Call --
|
|
-------------------------------
|
|
|
|
procedure Expand_Ctrl_Function_Call (N : Node_Id) is
|
|
Loc : constant Source_Ptr := Sloc (N);
|
|
Rtype : constant Entity_Id := Etype (N);
|
|
Utype : constant Entity_Id := Underlying_Type (Rtype);
|
|
Ref : Node_Id;
|
|
Action : Node_Id;
|
|
|
|
Attach_Level : Uint := Uint_1;
|
|
Len_Ref : Node_Id := Empty;
|
|
|
|
function Last_Array_Component
|
|
(Ref : Node_Id;
|
|
Typ : Entity_Id)
|
|
return Node_Id;
|
|
-- Creates a reference to the last component of the array object
|
|
-- designated by Ref whose type is Typ.
|
|
|
|
function Last_Array_Component
|
|
(Ref : Node_Id;
|
|
Typ : Entity_Id)
|
|
return Node_Id
|
|
is
|
|
N : Int;
|
|
Index_List : List_Id := New_List;
|
|
|
|
begin
|
|
N := 1;
|
|
while N <= Number_Dimensions (Typ) loop
|
|
Append_To (Index_List,
|
|
Make_Attribute_Reference (Loc,
|
|
Prefix => Duplicate_Subexpr (Ref),
|
|
Attribute_Name => Name_Last,
|
|
Expressions => New_List (
|
|
Make_Integer_Literal (Loc, N))));
|
|
|
|
N := N + 1;
|
|
end loop;
|
|
|
|
return
|
|
Make_Indexed_Component (Loc,
|
|
Prefix => Duplicate_Subexpr (Ref),
|
|
Expressions => Index_List);
|
|
end Last_Array_Component;
|
|
|
|
-- Start of processing for Expand_Ctrl_Function_Call
|
|
|
|
begin
|
|
-- Optimization, if the returned value (which is on the sec-stack)
|
|
-- is returned again, no need to copy/readjust/finalize, we can just
|
|
-- pass the value thru (see Expand_N_Return_Statement), and thus no
|
|
-- attachment is needed
|
|
|
|
if Nkind (Parent (N)) = N_Return_Statement then
|
|
return;
|
|
end if;
|
|
|
|
-- Resolution is now finished, make sure we don't start analysis again
|
|
-- because of the duplication
|
|
|
|
Set_Analyzed (N);
|
|
Ref := Duplicate_Subexpr (N);
|
|
|
|
-- Now we can generate the Attach Call, note that this value is
|
|
-- always in the (secondary) stack and thus is attached to a singly
|
|
-- linked final list:
|
|
--
|
|
-- Resx := F (X)'reference;
|
|
-- Attach_To_Final_List (_Lx, Resx.all, 1);
|
|
-- or when there are controlled components
|
|
-- Attach_To_Final_List (_Lx, Resx._controller, 1);
|
|
-- or if it is an array with is_controlled components
|
|
-- Attach_To_Final_List (_Lx, Resx (Resx'last), 3);
|
|
-- An attach level of 3 means that a whole array is to be
|
|
-- attached to the finalization list
|
|
-- or if it is an array with has_controlled components
|
|
-- Attach_To_Final_List (_Lx, Resx (Resx'last)._controller, 3);
|
|
|
|
if Has_Controlled_Component (Rtype) then
|
|
declare
|
|
T1 : Entity_Id := Rtype;
|
|
T2 : Entity_Id := Utype;
|
|
|
|
begin
|
|
if Is_Array_Type (T2) then
|
|
Len_Ref :=
|
|
Make_Attribute_Reference (Loc,
|
|
Prefix => Duplicate_Subexpr (Unchecked_Convert_To (T2, Ref)),
|
|
Attribute_Name => Name_Length);
|
|
end if;
|
|
|
|
while Is_Array_Type (T2) loop
|
|
if T1 /= T2 then
|
|
Ref := Unchecked_Convert_To (T2, Ref);
|
|
end if;
|
|
Ref := Last_Array_Component (Ref, T2);
|
|
Attach_Level := Uint_3;
|
|
T1 := Component_Type (T2);
|
|
T2 := Underlying_Type (T1);
|
|
end loop;
|
|
|
|
if Has_Controlled_Component (T2) then
|
|
if T1 /= T2 then
|
|
Ref := Unchecked_Convert_To (T2, Ref);
|
|
end if;
|
|
Ref :=
|
|
Make_Selected_Component (Loc,
|
|
Prefix => Ref,
|
|
Selector_Name => Make_Identifier (Loc, Name_uController));
|
|
end if;
|
|
end;
|
|
|
|
-- Here we know that 'Ref' has a controller so we may as well
|
|
-- attach it directly
|
|
|
|
Action :=
|
|
Make_Attach_Call (
|
|
Obj_Ref => Ref,
|
|
Flist_Ref => Find_Final_List (Current_Scope),
|
|
With_Attach => Make_Integer_Literal (Loc, Attach_Level));
|
|
|
|
else
|
|
-- Here, we have a controlled type that does not seem to have
|
|
-- controlled components but it could be a class wide type whose
|
|
-- further derivations have controlled components. So we don't know
|
|
-- if the object itself needs to be attached or if it
|
|
-- has a record controller. We need to call a runtime function
|
|
-- (Deep_Tag_Attach) which knows what to do thanks to the
|
|
-- RC_Offset in the dispatch table.
|
|
|
|
Action :=
|
|
Make_Procedure_Call_Statement (Loc,
|
|
Name => New_Reference_To (RTE (RE_Deep_Tag_Attach), Loc),
|
|
Parameter_Associations => New_List (
|
|
Find_Final_List (Current_Scope),
|
|
|
|
Make_Attribute_Reference (Loc,
|
|
Prefix => Ref,
|
|
Attribute_Name => Name_Address),
|
|
|
|
Make_Integer_Literal (Loc, Attach_Level)));
|
|
end if;
|
|
|
|
if Present (Len_Ref) then
|
|
Action :=
|
|
Make_Implicit_If_Statement (N,
|
|
Condition => Make_Op_Gt (Loc,
|
|
Left_Opnd => Len_Ref,
|
|
Right_Opnd => Make_Integer_Literal (Loc, 0)),
|
|
Then_Statements => New_List (Action));
|
|
end if;
|
|
|
|
Insert_Action (N, Action);
|
|
end Expand_Ctrl_Function_Call;
|
|
|
|
---------------------------
|
|
-- Expand_N_Package_Body --
|
|
---------------------------
|
|
|
|
-- Add call to Activate_Tasks if body is an activator (actual
|
|
-- processing is in chapter 9).
|
|
|
|
-- Generate subprogram descriptor for elaboration routine
|
|
|
|
-- ENcode entity names in package body
|
|
|
|
procedure Expand_N_Package_Body (N : Node_Id) is
|
|
Ent : Entity_Id := Corresponding_Spec (N);
|
|
|
|
begin
|
|
-- This is done only for non-generic packages
|
|
|
|
if Ekind (Ent) = E_Package then
|
|
New_Scope (Corresponding_Spec (N));
|
|
Build_Task_Activation_Call (N);
|
|
Pop_Scope;
|
|
end if;
|
|
|
|
Set_Elaboration_Flag (N, Corresponding_Spec (N));
|
|
|
|
-- Generate a subprogram descriptor for the elaboration routine of
|
|
-- a package body if the package body has no pending instantiations
|
|
-- and it has generated at least one exception handler
|
|
|
|
if Present (Handler_Records (Body_Entity (Ent)))
|
|
and then Is_Compilation_Unit (Ent)
|
|
and then not Delay_Subprogram_Descriptors (Body_Entity (Ent))
|
|
then
|
|
Generate_Subprogram_Descriptor_For_Package
|
|
(N, Body_Entity (Ent));
|
|
end if;
|
|
|
|
Set_In_Package_Body (Ent, False);
|
|
|
|
-- Set to encode entity names in package body before gigi is called
|
|
|
|
Qualify_Entity_Names (N);
|
|
end Expand_N_Package_Body;
|
|
|
|
----------------------------------
|
|
-- Expand_N_Package_Declaration --
|
|
----------------------------------
|
|
|
|
-- Add call to Activate_Tasks if there are tasks declared and the
|
|
-- package has no body. Note that in Ada83, this may result in
|
|
-- premature activation of some tasks, given that we cannot tell
|
|
-- whether a body will eventually appear.
|
|
|
|
procedure Expand_N_Package_Declaration (N : Node_Id) is
|
|
begin
|
|
if Nkind (Parent (N)) = N_Compilation_Unit
|
|
and then not Body_Required (Parent (N))
|
|
and then not Unit_Requires_Body (Defining_Entity (N))
|
|
and then Present (Activation_Chain_Entity (N))
|
|
then
|
|
New_Scope (Defining_Entity (N));
|
|
Build_Task_Activation_Call (N);
|
|
Pop_Scope;
|
|
end if;
|
|
|
|
-- Note: it is not necessary to worry about generating a subprogram
|
|
-- descriptor, since the only way to get exception handlers into a
|
|
-- package spec is to include instantiations, and that would cause
|
|
-- generation of subprogram descriptors to be delayed in any case.
|
|
|
|
-- Set to encode entity names in package spec before gigi is called
|
|
|
|
Qualify_Entity_Names (N);
|
|
end Expand_N_Package_Declaration;
|
|
|
|
---------------------
|
|
-- Find_Final_List --
|
|
---------------------
|
|
|
|
function Find_Final_List
|
|
(E : Entity_Id;
|
|
Ref : Node_Id := Empty)
|
|
return Node_Id
|
|
is
|
|
Loc : constant Source_Ptr := Sloc (Ref);
|
|
S : Entity_Id;
|
|
Id : Entity_Id;
|
|
R : Node_Id;
|
|
|
|
begin
|
|
-- Case of an internal component. The Final list is the record
|
|
-- controller of the enclosing record
|
|
|
|
if Present (Ref) then
|
|
R := Ref;
|
|
loop
|
|
case Nkind (R) is
|
|
when N_Unchecked_Type_Conversion | N_Type_Conversion =>
|
|
R := Expression (R);
|
|
|
|
when N_Indexed_Component | N_Explicit_Dereference =>
|
|
R := Prefix (R);
|
|
|
|
when N_Selected_Component =>
|
|
R := Prefix (R);
|
|
exit;
|
|
|
|
when N_Identifier =>
|
|
exit;
|
|
|
|
when others =>
|
|
raise Program_Error;
|
|
end case;
|
|
end loop;
|
|
|
|
return
|
|
Make_Selected_Component (Loc,
|
|
Prefix =>
|
|
Make_Selected_Component (Loc,
|
|
Prefix => R,
|
|
Selector_Name => Make_Identifier (Loc, Name_uController)),
|
|
Selector_Name => Make_Identifier (Loc, Name_F));
|
|
|
|
-- Case of a dynamically allocated object. The final list is the
|
|
-- corresponding list controller (The next entity in the scope of
|
|
-- the access type with the right type). If the type comes from a
|
|
-- With_Type clause, no controller was created, and we use the
|
|
-- global chain instead.
|
|
|
|
elsif Is_Access_Type (E) then
|
|
if not From_With_Type (E) then
|
|
return
|
|
Make_Selected_Component (Loc,
|
|
Prefix =>
|
|
New_Reference_To
|
|
(Associated_Final_Chain (Base_Type (E)), Loc),
|
|
Selector_Name => Make_Identifier (Loc, Name_F));
|
|
else
|
|
return New_Reference_To (RTE (RE_Global_Final_List), Sloc (E));
|
|
end if;
|
|
|
|
else
|
|
if Is_Dynamic_Scope (E) then
|
|
S := E;
|
|
else
|
|
S := Enclosing_Dynamic_Scope (E);
|
|
end if;
|
|
|
|
-- When the finalization chain entity is 'Error', it means that
|
|
-- there should not be any chain at that level and that the
|
|
-- enclosing one should be used
|
|
|
|
-- This is a nasty kludge, see ??? note in exp_ch11
|
|
|
|
while Finalization_Chain_Entity (S) = Error loop
|
|
S := Enclosing_Dynamic_Scope (S);
|
|
end loop;
|
|
|
|
if S = Standard_Standard then
|
|
return New_Reference_To (RTE (RE_Global_Final_List), Sloc (E));
|
|
else
|
|
if No (Finalization_Chain_Entity (S)) then
|
|
|
|
Id := Make_Defining_Identifier (Sloc (S),
|
|
New_Internal_Name ('F'));
|
|
Set_Finalization_Chain_Entity (S, Id);
|
|
|
|
-- Set momentarily some semantics attributes to allow normal
|
|
-- analysis of expansions containing references to this chain.
|
|
-- Will be fully decorated during the expansion of the scope
|
|
-- itself
|
|
|
|
Set_Ekind (Id, E_Variable);
|
|
Set_Etype (Id, RTE (RE_Finalizable_Ptr));
|
|
end if;
|
|
|
|
return New_Reference_To (Finalization_Chain_Entity (S), Sloc (E));
|
|
end if;
|
|
end if;
|
|
end Find_Final_List;
|
|
|
|
-----------------------------
|
|
-- Find_Node_To_Be_Wrapped --
|
|
-----------------------------
|
|
|
|
function Find_Node_To_Be_Wrapped (N : Node_Id) return Node_Id is
|
|
P : Node_Id;
|
|
The_Parent : Node_Id;
|
|
|
|
begin
|
|
The_Parent := N;
|
|
loop
|
|
P := The_Parent;
|
|
pragma Assert (P /= Empty);
|
|
The_Parent := Parent (P);
|
|
|
|
case Nkind (The_Parent) is
|
|
|
|
-- Simple statement can be wrapped
|
|
|
|
when N_Pragma =>
|
|
return The_Parent;
|
|
|
|
-- Usually assignments are good candidate for wrapping
|
|
-- except when they have been generated as part of a
|
|
-- controlled aggregate where the wrapping should take
|
|
-- place more globally.
|
|
|
|
when N_Assignment_Statement =>
|
|
if No_Ctrl_Actions (The_Parent) then
|
|
null;
|
|
else
|
|
return The_Parent;
|
|
end if;
|
|
|
|
-- An entry call statement is a special case if it occurs in
|
|
-- the context of a Timed_Entry_Call. In this case we wrap
|
|
-- the entire timed entry call.
|
|
|
|
when N_Entry_Call_Statement |
|
|
N_Procedure_Call_Statement =>
|
|
if Nkind (Parent (The_Parent)) = N_Entry_Call_Alternative
|
|
and then
|
|
Nkind (Parent (Parent (The_Parent))) = N_Timed_Entry_Call
|
|
then
|
|
return Parent (Parent (The_Parent));
|
|
else
|
|
return The_Parent;
|
|
end if;
|
|
|
|
-- Object declarations are also a boundary for the transient scope
|
|
-- even if they are not really wrapped
|
|
-- (see Wrap_Transient_Declaration)
|
|
|
|
when N_Object_Declaration |
|
|
N_Object_Renaming_Declaration |
|
|
N_Subtype_Declaration =>
|
|
return The_Parent;
|
|
|
|
-- The expression itself is to be wrapped if its parent is a
|
|
-- compound statement or any other statement where the expression
|
|
-- is known to be scalar
|
|
|
|
when N_Accept_Alternative |
|
|
N_Attribute_Definition_Clause |
|
|
N_Case_Statement |
|
|
N_Code_Statement |
|
|
N_Delay_Alternative |
|
|
N_Delay_Until_Statement |
|
|
N_Delay_Relative_Statement |
|
|
N_Discriminant_Association |
|
|
N_Elsif_Part |
|
|
N_Entry_Body_Formal_Part |
|
|
N_Exit_Statement |
|
|
N_If_Statement |
|
|
N_Iteration_Scheme |
|
|
N_Terminate_Alternative =>
|
|
return P;
|
|
|
|
when N_Attribute_Reference =>
|
|
|
|
if Is_Procedure_Attribute_Name
|
|
(Attribute_Name (The_Parent))
|
|
then
|
|
return The_Parent;
|
|
end if;
|
|
|
|
-- ??? No scheme yet for "for I in Expression'Range loop"
|
|
-- ??? the current scheme for Expression wrapping doesn't apply
|
|
-- ??? because a RANGE is NOT an expression. Tricky problem...
|
|
-- ??? while this problem is not solved we have a potential for
|
|
-- ??? leak and unfinalized intermediate objects here.
|
|
|
|
when N_Loop_Parameter_Specification =>
|
|
return Empty;
|
|
|
|
-- The following nodes contains "dummy calls" which don't
|
|
-- need to be wrapped.
|
|
|
|
when N_Parameter_Specification |
|
|
N_Discriminant_Specification |
|
|
N_Component_Declaration =>
|
|
return Empty;
|
|
|
|
-- The return statement is not to be wrapped when the function
|
|
-- itself needs wrapping at the outer-level
|
|
|
|
when N_Return_Statement =>
|
|
if Requires_Transient_Scope (Return_Type (The_Parent)) then
|
|
return Empty;
|
|
else
|
|
return The_Parent;
|
|
end if;
|
|
|
|
-- If we leave a scope without having been able to find a node to
|
|
-- wrap, something is going wrong but this can happen in error
|
|
-- situation that are not detected yet (such as a dynamic string
|
|
-- in a pragma export)
|
|
|
|
when N_Subprogram_Body |
|
|
N_Package_Declaration |
|
|
N_Package_Body |
|
|
N_Block_Statement =>
|
|
return Empty;
|
|
|
|
-- otherwise continue the search
|
|
|
|
when others =>
|
|
null;
|
|
end case;
|
|
end loop;
|
|
end Find_Node_To_Be_Wrapped;
|
|
|
|
----------------------
|
|
-- Global_Flist_Ref --
|
|
----------------------
|
|
|
|
function Global_Flist_Ref (Flist_Ref : Node_Id) return Boolean is
|
|
Flist : Entity_Id;
|
|
|
|
begin
|
|
-- Look for the Global_Final_List
|
|
|
|
if Is_Entity_Name (Flist_Ref) then
|
|
Flist := Entity (Flist_Ref);
|
|
|
|
-- Look for the final list associated with an access to controlled
|
|
|
|
elsif Nkind (Flist_Ref) = N_Selected_Component
|
|
and then Is_Entity_Name (Prefix (Flist_Ref))
|
|
then
|
|
Flist := Entity (Prefix (Flist_Ref));
|
|
else
|
|
return False;
|
|
end if;
|
|
|
|
return Present (Flist)
|
|
and then Present (Scope (Flist))
|
|
and then Enclosing_Dynamic_Scope (Flist) = Standard_Standard;
|
|
end Global_Flist_Ref;
|
|
|
|
----------------------------------
|
|
-- Has_New_Controlled_Component --
|
|
----------------------------------
|
|
|
|
function Has_New_Controlled_Component (E : Entity_Id) return Boolean is
|
|
Comp : Entity_Id;
|
|
|
|
begin
|
|
if not Is_Tagged_Type (E) then
|
|
return Has_Controlled_Component (E);
|
|
elsif not Is_Derived_Type (E) then
|
|
return Has_Controlled_Component (E);
|
|
end if;
|
|
|
|
Comp := First_Component (E);
|
|
while Present (Comp) loop
|
|
|
|
if Chars (Comp) = Name_uParent then
|
|
null;
|
|
|
|
elsif Scope (Original_Record_Component (Comp)) = E
|
|
and then Controlled_Type (Etype (Comp))
|
|
then
|
|
return True;
|
|
end if;
|
|
|
|
Next_Component (Comp);
|
|
end loop;
|
|
|
|
return False;
|
|
end Has_New_Controlled_Component;
|
|
|
|
--------------------------
|
|
-- In_Finalization_Root --
|
|
--------------------------
|
|
|
|
-- It would seem simpler to test Scope (RTE (RE_Root_Controlled)) but
|
|
-- the purpose of this function is to avoid a circular call to Rtsfind
|
|
-- which would been caused by such a test.
|
|
|
|
function In_Finalization_Root (E : Entity_Id) return Boolean is
|
|
S : constant Entity_Id := Scope (E);
|
|
|
|
begin
|
|
return Chars (Scope (S)) = Name_System
|
|
and then Chars (S) = Name_Finalization_Root
|
|
and then Scope (Scope (S)) = Standard_Standard;
|
|
end In_Finalization_Root;
|
|
|
|
------------------------------------
|
|
-- Insert_Actions_In_Scope_Around --
|
|
------------------------------------
|
|
|
|
procedure Insert_Actions_In_Scope_Around (N : Node_Id) is
|
|
SE : Scope_Stack_Entry renames Scope_Stack.Table (Scope_Stack.Last);
|
|
|
|
begin
|
|
if Present (SE.Actions_To_Be_Wrapped_Before) then
|
|
Insert_List_Before (N, SE.Actions_To_Be_Wrapped_Before);
|
|
SE.Actions_To_Be_Wrapped_Before := No_List;
|
|
end if;
|
|
|
|
if Present (SE.Actions_To_Be_Wrapped_After) then
|
|
Insert_List_After (N, SE.Actions_To_Be_Wrapped_After);
|
|
SE.Actions_To_Be_Wrapped_After := No_List;
|
|
end if;
|
|
end Insert_Actions_In_Scope_Around;
|
|
|
|
-----------------------
|
|
-- Make_Adjust_Call --
|
|
-----------------------
|
|
|
|
function Make_Adjust_Call
|
|
(Ref : Node_Id;
|
|
Typ : Entity_Id;
|
|
Flist_Ref : Node_Id;
|
|
With_Attach : Node_Id)
|
|
return List_Id
|
|
is
|
|
Loc : constant Source_Ptr := Sloc (Ref);
|
|
Res : constant List_Id := New_List;
|
|
Utyp : Entity_Id;
|
|
Proc : Entity_Id;
|
|
Cref : Node_Id := Ref;
|
|
Cref2 : Node_Id;
|
|
Attach : Node_Id := With_Attach;
|
|
|
|
begin
|
|
if Is_Class_Wide_Type (Typ) then
|
|
Utyp := Underlying_Type (Base_Type (Root_Type (Typ)));
|
|
else
|
|
Utyp := Underlying_Type (Base_Type (Typ));
|
|
end if;
|
|
|
|
Set_Assignment_OK (Cref);
|
|
|
|
-- Deal with non-tagged derivation of private views
|
|
|
|
if Is_Untagged_Derivation (Typ) then
|
|
Utyp := Underlying_Type (Root_Type (Base_Type (Typ)));
|
|
Cref := Unchecked_Convert_To (Utyp, Cref);
|
|
Set_Assignment_OK (Cref);
|
|
-- To prevent problems with UC see 1.156 RH ???
|
|
end if;
|
|
|
|
-- If the underlying_type is a subtype, we are dealing with
|
|
-- the completion of a private type. We need to access
|
|
-- the base type and generate a conversion to it.
|
|
|
|
if Utyp /= Base_Type (Utyp) then
|
|
pragma Assert (Is_Private_Type (Typ));
|
|
Utyp := Base_Type (Utyp);
|
|
Cref := Unchecked_Convert_To (Utyp, Cref);
|
|
end if;
|
|
|
|
-- We do not need to attach to one of the Global Final Lists
|
|
-- the objects whose type is Finalize_Storage_Only
|
|
|
|
if Finalize_Storage_Only (Typ)
|
|
and then (Global_Flist_Ref (Flist_Ref)
|
|
or else Entity (Constant_Value (RTE (RE_Garbage_Collected)))
|
|
= Standard_True)
|
|
then
|
|
Attach := Make_Integer_Literal (Loc, 0);
|
|
end if;
|
|
|
|
-- Generate:
|
|
-- Deep_Adjust (Flist_Ref, Ref, With_Attach);
|
|
|
|
if Has_Controlled_Component (Utyp)
|
|
or else Is_Class_Wide_Type (Typ)
|
|
then
|
|
if Is_Tagged_Type (Utyp) then
|
|
Proc := Find_Prim_Op (Utyp, Deep_Name_Of (Adjust_Case));
|
|
|
|
else
|
|
Proc := TSS (Utyp, Deep_Name_Of (Adjust_Case));
|
|
end if;
|
|
|
|
Cref := Convert_View (Proc, Cref, 2);
|
|
|
|
Append_To (Res,
|
|
Make_Procedure_Call_Statement (Loc,
|
|
Name => New_Reference_To (Proc, Loc),
|
|
Parameter_Associations =>
|
|
New_List (Flist_Ref, Cref, Attach)));
|
|
|
|
-- Generate:
|
|
-- if With_Attach then
|
|
-- Attach_To_Final_List (Ref, Flist_Ref);
|
|
-- end if;
|
|
-- Adjust (Ref);
|
|
|
|
else -- Is_Controlled (Utyp)
|
|
|
|
Proc := Find_Prim_Op (Utyp, Name_Of (Adjust_Case));
|
|
Cref := Convert_View (Proc, Cref);
|
|
Cref2 := New_Copy_Tree (Cref);
|
|
|
|
Append_To (Res,
|
|
Make_Procedure_Call_Statement (Loc,
|
|
Name => New_Reference_To (Proc, Loc),
|
|
Parameter_Associations => New_List (Cref2)));
|
|
|
|
Append_To (Res, Make_Attach_Call (Cref, Flist_Ref, Attach));
|
|
|
|
-- Treat this as a reference to Adjust if the Adjust routine
|
|
-- comes from source. The call is not explicit, but it is near
|
|
-- enough, and we won't typically get explicit adjust calls.
|
|
|
|
if Comes_From_Source (Proc) then
|
|
Generate_Reference (Proc, Ref);
|
|
end if;
|
|
end if;
|
|
|
|
return Res;
|
|
end Make_Adjust_Call;
|
|
|
|
----------------------
|
|
-- Make_Attach_Call --
|
|
----------------------
|
|
|
|
-- Generate:
|
|
-- System.FI.Attach_To_Final_List (Flist, Ref, Nb_Link)
|
|
|
|
function Make_Attach_Call
|
|
(Obj_Ref : Node_Id;
|
|
Flist_Ref : Node_Id;
|
|
With_Attach : Node_Id)
|
|
return Node_Id
|
|
is
|
|
Loc : constant Source_Ptr := Sloc (Obj_Ref);
|
|
|
|
begin
|
|
-- Optimization: If the number of links is statically '0', don't
|
|
-- call the attach_proc.
|
|
|
|
if Nkind (With_Attach) = N_Integer_Literal
|
|
and then Intval (With_Attach) = Uint_0
|
|
then
|
|
return Make_Null_Statement (Loc);
|
|
end if;
|
|
|
|
return
|
|
Make_Procedure_Call_Statement (Loc,
|
|
Name => New_Reference_To (RTE (RE_Attach_To_Final_List), Loc),
|
|
Parameter_Associations => New_List (
|
|
Flist_Ref,
|
|
OK_Convert_To (RTE (RE_Finalizable), Obj_Ref),
|
|
With_Attach));
|
|
end Make_Attach_Call;
|
|
|
|
----------------
|
|
-- Make_Clean --
|
|
----------------
|
|
|
|
function Make_Clean
|
|
(N : Node_Id;
|
|
Clean : Entity_Id;
|
|
Mark : Entity_Id;
|
|
Flist : Entity_Id;
|
|
Is_Task : Boolean;
|
|
Is_Master : Boolean;
|
|
Is_Protected_Subprogram : Boolean;
|
|
Is_Task_Allocation_Block : Boolean;
|
|
Is_Asynchronous_Call_Block : Boolean)
|
|
return Node_Id
|
|
is
|
|
Loc : constant Source_Ptr := Sloc (Clean);
|
|
|
|
Stmt : List_Id := New_List;
|
|
Sbody : Node_Id;
|
|
Spec : Node_Id;
|
|
Name : Node_Id;
|
|
Param : Node_Id;
|
|
Unlock : Node_Id;
|
|
Param_Type : Entity_Id;
|
|
Pid : Entity_Id := Empty;
|
|
Cancel_Param : Entity_Id;
|
|
|
|
begin
|
|
if Is_Task then
|
|
if Restricted_Profile then
|
|
Append_To
|
|
(Stmt, Build_Runtime_Call (Loc, RE_Complete_Restricted_Task));
|
|
else
|
|
Append_To (Stmt, Build_Runtime_Call (Loc, RE_Complete_Task));
|
|
end if;
|
|
|
|
elsif Is_Master then
|
|
if Restrictions (No_Task_Hierarchy) = False then
|
|
Append_To (Stmt, Build_Runtime_Call (Loc, RE_Complete_Master));
|
|
end if;
|
|
|
|
elsif Is_Protected_Subprogram then
|
|
|
|
-- Add statements to the cleanup handler of the (ordinary)
|
|
-- subprogram expanded to implement a protected subprogram,
|
|
-- unlocking the protected object parameter and undeferring abortion.
|
|
-- If this is a protected procedure, and the object contains
|
|
-- entries, this also calls the entry service routine.
|
|
|
|
-- NOTE: This cleanup handler references _object, a parameter
|
|
-- to the procedure.
|
|
|
|
-- Find the _object parameter representing the protected object.
|
|
|
|
Spec := Parent (Corresponding_Spec (N));
|
|
|
|
Param := First (Parameter_Specifications (Spec));
|
|
loop
|
|
Param_Type := Etype (Parameter_Type (Param));
|
|
|
|
if Ekind (Param_Type) = E_Record_Type then
|
|
Pid := Corresponding_Concurrent_Type (Param_Type);
|
|
end if;
|
|
|
|
exit when not Present (Param) or else Present (Pid);
|
|
Next (Param);
|
|
end loop;
|
|
|
|
pragma Assert (Present (Param));
|
|
|
|
-- If the associated protected object declares entries,
|
|
-- a protected procedure has to service entry queues.
|
|
-- In this case, add
|
|
|
|
-- Service_Entries (_object._object'Access);
|
|
|
|
-- _object is the record used to implement the protected object.
|
|
-- It is a parameter to the protected subprogram.
|
|
|
|
if Nkind (Specification (N)) = N_Procedure_Specification
|
|
and then Has_Entries (Pid)
|
|
then
|
|
if Abort_Allowed
|
|
or else Restrictions (No_Entry_Queue) = False
|
|
or else Number_Entries (Pid) > 1
|
|
then
|
|
Name := New_Reference_To (RTE (RE_Service_Entries), Loc);
|
|
else
|
|
Name := New_Reference_To (RTE (RE_Service_Entry), Loc);
|
|
end if;
|
|
|
|
Append_To (Stmt,
|
|
Make_Procedure_Call_Statement (Loc,
|
|
Name => Name,
|
|
Parameter_Associations => New_List (
|
|
Make_Attribute_Reference (Loc,
|
|
Prefix =>
|
|
Make_Selected_Component (Loc,
|
|
Prefix => New_Reference_To (
|
|
Defining_Identifier (Param), Loc),
|
|
Selector_Name =>
|
|
Make_Identifier (Loc, Name_uObject)),
|
|
Attribute_Name => Name_Unchecked_Access))));
|
|
end if;
|
|
|
|
-- Unlock (_object._object'Access);
|
|
|
|
-- _object is the record used to implement the protected object.
|
|
-- It is a parameter to the protected subprogram.
|
|
|
|
-- If the protected object is controlled (i.e it has entries or
|
|
-- needs finalization for interrupt handling), call Unlock_Entries,
|
|
-- except if the protected object follows the ravenscar profile, in
|
|
-- which case call Unlock_Entry, otherwise call the simplified
|
|
-- version, Unlock.
|
|
|
|
if Has_Entries (Pid)
|
|
or else Has_Interrupt_Handler (Pid)
|
|
or else Has_Attach_Handler (Pid)
|
|
then
|
|
if Abort_Allowed
|
|
or else Restrictions (No_Entry_Queue) = False
|
|
or else Number_Entries (Pid) > 1
|
|
then
|
|
Unlock := New_Reference_To (RTE (RE_Unlock_Entries), Loc);
|
|
else
|
|
Unlock := New_Reference_To (RTE (RE_Unlock_Entry), Loc);
|
|
end if;
|
|
|
|
else
|
|
Unlock := New_Reference_To (RTE (RE_Unlock), Loc);
|
|
end if;
|
|
|
|
Append_To (Stmt,
|
|
Make_Procedure_Call_Statement (Loc,
|
|
Name => Unlock,
|
|
Parameter_Associations => New_List (
|
|
Make_Attribute_Reference (Loc,
|
|
Prefix =>
|
|
Make_Selected_Component (Loc,
|
|
Prefix =>
|
|
New_Reference_To (Defining_Identifier (Param), Loc),
|
|
Selector_Name =>
|
|
Make_Identifier (Loc, Name_uObject)),
|
|
Attribute_Name => Name_Unchecked_Access))));
|
|
|
|
if Abort_Allowed then
|
|
-- Abort_Undefer;
|
|
|
|
Append_To (Stmt,
|
|
Make_Procedure_Call_Statement (Loc,
|
|
Name =>
|
|
New_Reference_To (
|
|
RTE (RE_Abort_Undefer), Loc),
|
|
Parameter_Associations => Empty_List));
|
|
end if;
|
|
|
|
elsif Is_Task_Allocation_Block then
|
|
|
|
-- Add a call to Expunge_Unactivated_Tasks to the cleanup
|
|
-- handler of a block created for the dynamic allocation of
|
|
-- tasks:
|
|
|
|
-- Expunge_Unactivated_Tasks (_chain);
|
|
|
|
-- where _chain is the list of tasks created by the allocator
|
|
-- but not yet activated. This list will be empty unless
|
|
-- the block completes abnormally.
|
|
|
|
-- This only applies to dynamically allocated tasks;
|
|
-- other unactivated tasks are completed by Complete_Task or
|
|
-- Complete_Master.
|
|
|
|
-- NOTE: This cleanup handler references _chain, a local
|
|
-- object.
|
|
|
|
Append_To (Stmt,
|
|
Make_Procedure_Call_Statement (Loc,
|
|
Name =>
|
|
New_Reference_To (
|
|
RTE (RE_Expunge_Unactivated_Tasks), Loc),
|
|
Parameter_Associations => New_List (
|
|
New_Reference_To (Activation_Chain_Entity (N), Loc))));
|
|
|
|
elsif Is_Asynchronous_Call_Block then
|
|
|
|
-- Add a call to attempt to cancel the asynchronous entry call
|
|
-- whenever the block containing the abortable part is exited.
|
|
|
|
-- NOTE: This cleanup handler references C, a local object
|
|
|
|
-- Get the argument to the Cancel procedure
|
|
Cancel_Param := Entry_Cancel_Parameter (Entity (Identifier (N)));
|
|
|
|
-- If it is of type Communication_Block, this must be a
|
|
-- protected entry call.
|
|
|
|
if Is_RTE (Etype (Cancel_Param), RE_Communication_Block) then
|
|
|
|
Append_To (Stmt,
|
|
|
|
-- if Enqueued (Cancel_Parameter) then
|
|
|
|
Make_Implicit_If_Statement (Clean,
|
|
Condition => Make_Function_Call (Loc,
|
|
Name => New_Reference_To (
|
|
RTE (RE_Enqueued), Loc),
|
|
Parameter_Associations => New_List (
|
|
New_Reference_To (Cancel_Param, Loc))),
|
|
Then_Statements => New_List (
|
|
|
|
-- Cancel_Protected_Entry_Call (Cancel_Param);
|
|
|
|
Make_Procedure_Call_Statement (Loc,
|
|
Name => New_Reference_To (
|
|
RTE (RE_Cancel_Protected_Entry_Call), Loc),
|
|
Parameter_Associations => New_List (
|
|
New_Reference_To (Cancel_Param, Loc))))));
|
|
|
|
-- Asynchronous delay
|
|
|
|
elsif Is_RTE (Etype (Cancel_Param), RE_Delay_Block) then
|
|
Append_To (Stmt,
|
|
Make_Procedure_Call_Statement (Loc,
|
|
Name => New_Reference_To (RTE (RE_Cancel_Async_Delay), Loc),
|
|
Parameter_Associations => New_List (
|
|
Make_Attribute_Reference (Loc,
|
|
Prefix => New_Reference_To (Cancel_Param, Loc),
|
|
Attribute_Name => Name_Unchecked_Access))));
|
|
|
|
-- Task entry call
|
|
|
|
else
|
|
-- Append call to Cancel_Task_Entry_Call (C);
|
|
|
|
Append_To (Stmt,
|
|
Make_Procedure_Call_Statement (Loc,
|
|
Name => New_Reference_To (
|
|
RTE (RE_Cancel_Task_Entry_Call),
|
|
Loc),
|
|
Parameter_Associations => New_List (
|
|
New_Reference_To (Cancel_Param, Loc))));
|
|
|
|
end if;
|
|
end if;
|
|
|
|
if Present (Flist) then
|
|
Append_To (Stmt,
|
|
Make_Procedure_Call_Statement (Loc,
|
|
Name => New_Reference_To (RTE (RE_Finalize_List), Loc),
|
|
Parameter_Associations => New_List (
|
|
New_Reference_To (Flist, Loc))));
|
|
end if;
|
|
|
|
if Present (Mark) then
|
|
Append_To (Stmt,
|
|
Make_Procedure_Call_Statement (Loc,
|
|
Name => New_Reference_To (RTE (RE_SS_Release), Loc),
|
|
Parameter_Associations => New_List (
|
|
New_Reference_To (Mark, Loc))));
|
|
end if;
|
|
|
|
Sbody :=
|
|
Make_Subprogram_Body (Loc,
|
|
Specification =>
|
|
Make_Procedure_Specification (Loc,
|
|
Defining_Unit_Name => Clean),
|
|
|
|
Declarations => New_List,
|
|
|
|
Handled_Statement_Sequence =>
|
|
Make_Handled_Sequence_Of_Statements (Loc,
|
|
Statements => Stmt));
|
|
|
|
if Present (Flist) or else Is_Task or else Is_Master then
|
|
Wrap_Cleanup_Procedure (Sbody);
|
|
end if;
|
|
|
|
-- We do not want debug information for _Clean routines,
|
|
-- since it just confuses the debugging operation unless
|
|
-- we are debugging generated code.
|
|
|
|
if not Debug_Generated_Code then
|
|
Set_Debug_Info_Off (Clean, True);
|
|
end if;
|
|
|
|
return Sbody;
|
|
end Make_Clean;
|
|
|
|
--------------------------
|
|
-- Make_Deep_Array_Body --
|
|
--------------------------
|
|
|
|
-- Array components are initialized and adjusted in the normal order
|
|
-- and finalized in the reverse order. Exceptions are handled and
|
|
-- Program_Error is re-raise in the Adjust and Finalize case
|
|
-- (RM 7.6.1(12)). Generate the following code :
|
|
--
|
|
-- procedure Deep_<P> -- with <P> being Initialize or Adjust or Finalize
|
|
-- (L : in out Finalizable_Ptr;
|
|
-- V : in out Typ)
|
|
-- is
|
|
-- begin
|
|
-- for J1 in Typ'First (1) .. Typ'Last (1) loop
|
|
-- ^ reverse ^ -- in the finalization case
|
|
-- ...
|
|
-- for J2 in Typ'First (n) .. Typ'Last (n) loop
|
|
-- Make_<P>_Call (Typ, V (J1, .. , Jn), L, V);
|
|
-- end loop;
|
|
-- ...
|
|
-- end loop;
|
|
-- exception -- not in the
|
|
-- when others => raise Program_Error; -- Initialize case
|
|
-- end Deep_<P>;
|
|
|
|
function Make_Deep_Array_Body
|
|
(Prim : Final_Primitives;
|
|
Typ : Entity_Id)
|
|
return List_Id
|
|
is
|
|
Loc : constant Source_Ptr := Sloc (Typ);
|
|
|
|
Index_List : constant List_Id := New_List;
|
|
-- Stores the list of references to the indexes (one per dimension)
|
|
|
|
function One_Component return List_Id;
|
|
-- Create one statement to initialize/adjust/finalize one array
|
|
-- component, designated by a full set of indices.
|
|
|
|
function One_Dimension (N : Int) return List_Id;
|
|
-- Create loop to deal with one dimension of the array. The single
|
|
-- statement in the body of the loop initializes the inner dimensions if
|
|
-- any, or else a single component.
|
|
|
|
-------------------
|
|
-- One_Component --
|
|
-------------------
|
|
|
|
function One_Component return List_Id is
|
|
Comp_Typ : constant Entity_Id := Component_Type (Typ);
|
|
Comp_Ref : constant Node_Id :=
|
|
Make_Indexed_Component (Loc,
|
|
Prefix => Make_Identifier (Loc, Name_V),
|
|
Expressions => Index_List);
|
|
|
|
begin
|
|
-- Set the etype of the component Reference, which is used to
|
|
-- determine whether a conversion to a parent type is needed.
|
|
|
|
Set_Etype (Comp_Ref, Comp_Typ);
|
|
|
|
case Prim is
|
|
when Initialize_Case =>
|
|
return Make_Init_Call (Comp_Ref, Comp_Typ,
|
|
Make_Identifier (Loc, Name_L),
|
|
Make_Identifier (Loc, Name_B));
|
|
|
|
when Adjust_Case =>
|
|
return Make_Adjust_Call (Comp_Ref, Comp_Typ,
|
|
Make_Identifier (Loc, Name_L),
|
|
Make_Identifier (Loc, Name_B));
|
|
|
|
when Finalize_Case =>
|
|
return Make_Final_Call (Comp_Ref, Comp_Typ,
|
|
Make_Identifier (Loc, Name_B));
|
|
end case;
|
|
end One_Component;
|
|
|
|
-------------------
|
|
-- One_Dimension --
|
|
-------------------
|
|
|
|
function One_Dimension (N : Int) return List_Id is
|
|
Index : Entity_Id;
|
|
|
|
begin
|
|
if N > Number_Dimensions (Typ) then
|
|
return One_Component;
|
|
|
|
else
|
|
Index :=
|
|
Make_Defining_Identifier (Loc, New_External_Name ('J', N));
|
|
|
|
Append_To (Index_List, New_Reference_To (Index, Loc));
|
|
|
|
return New_List (
|
|
Make_Implicit_Loop_Statement (Typ,
|
|
Identifier => Empty,
|
|
Iteration_Scheme =>
|
|
Make_Iteration_Scheme (Loc,
|
|
Loop_Parameter_Specification =>
|
|
Make_Loop_Parameter_Specification (Loc,
|
|
Defining_Identifier => Index,
|
|
Discrete_Subtype_Definition =>
|
|
Make_Attribute_Reference (Loc,
|
|
Prefix => Make_Identifier (Loc, Name_V),
|
|
Attribute_Name => Name_Range,
|
|
Expressions => New_List (
|
|
Make_Integer_Literal (Loc, N))),
|
|
Reverse_Present => Prim = Finalize_Case)),
|
|
Statements => One_Dimension (N + 1)));
|
|
end if;
|
|
end One_Dimension;
|
|
|
|
-- Start of processing for Make_Deep_Array_Body
|
|
|
|
begin
|
|
return One_Dimension (1);
|
|
end Make_Deep_Array_Body;
|
|
|
|
--------------------
|
|
-- Make_Deep_Proc --
|
|
--------------------
|
|
|
|
-- Generate:
|
|
-- procedure DEEP_<prim>
|
|
-- (L : IN OUT Finalizable_Ptr; -- not for Finalize
|
|
-- V : IN OUT <typ>;
|
|
-- B : IN Short_Short_Integer) is
|
|
-- begin
|
|
-- <stmts>;
|
|
-- exception -- Finalize and Adjust Cases only
|
|
-- raise Program_Error; -- idem
|
|
-- end DEEP_<prim>;
|
|
|
|
function Make_Deep_Proc
|
|
(Prim : Final_Primitives;
|
|
Typ : Entity_Id;
|
|
Stmts : List_Id)
|
|
return Entity_Id
|
|
is
|
|
Loc : constant Source_Ptr := Sloc (Typ);
|
|
Formals : List_Id;
|
|
Proc_Name : Entity_Id;
|
|
Handler : List_Id := No_List;
|
|
Subp_Body : Node_Id;
|
|
Type_B : Entity_Id;
|
|
|
|
begin
|
|
if Prim = Finalize_Case then
|
|
Formals := New_List;
|
|
Type_B := Standard_Boolean;
|
|
|
|
else
|
|
Formals := New_List (
|
|
Make_Parameter_Specification (Loc,
|
|
Defining_Identifier => Make_Defining_Identifier (Loc, Name_L),
|
|
In_Present => True,
|
|
Out_Present => True,
|
|
Parameter_Type =>
|
|
New_Reference_To (RTE (RE_Finalizable_Ptr), Loc)));
|
|
Type_B := Standard_Short_Short_Integer;
|
|
end if;
|
|
|
|
Append_To (Formals,
|
|
Make_Parameter_Specification (Loc,
|
|
Defining_Identifier => Make_Defining_Identifier (Loc, Name_V),
|
|
In_Present => True,
|
|
Out_Present => True,
|
|
Parameter_Type => New_Reference_To (Typ, Loc)));
|
|
|
|
Append_To (Formals,
|
|
Make_Parameter_Specification (Loc,
|
|
Defining_Identifier => Make_Defining_Identifier (Loc, Name_B),
|
|
Parameter_Type => New_Reference_To (Type_B, Loc)));
|
|
|
|
if Prim = Finalize_Case or else Prim = Adjust_Case then
|
|
Handler := New_List (
|
|
Make_Exception_Handler (Loc,
|
|
Exception_Choices => New_List (Make_Others_Choice (Loc)),
|
|
Statements => New_List (
|
|
Make_Raise_Program_Error (Loc))));
|
|
end if;
|
|
|
|
Proc_Name := Make_Defining_Identifier (Loc, Deep_Name_Of (Prim));
|
|
|
|
Subp_Body :=
|
|
Make_Subprogram_Body (Loc,
|
|
Specification =>
|
|
Make_Procedure_Specification (Loc,
|
|
Defining_Unit_Name => Proc_Name,
|
|
Parameter_Specifications => Formals),
|
|
|
|
Declarations => Empty_List,
|
|
Handled_Statement_Sequence =>
|
|
Make_Handled_Sequence_Of_Statements (Loc,
|
|
Statements => Stmts,
|
|
Exception_Handlers => Handler));
|
|
|
|
return Proc_Name;
|
|
end Make_Deep_Proc;
|
|
|
|
---------------------------
|
|
-- Make_Deep_Record_Body --
|
|
---------------------------
|
|
|
|
-- The Deep procedures call the appropriate Controlling proc on the
|
|
-- the controller component. In the init case, it also attach the
|
|
-- controller to the current finalization list.
|
|
|
|
function Make_Deep_Record_Body
|
|
(Prim : Final_Primitives;
|
|
Typ : Entity_Id)
|
|
return List_Id
|
|
is
|
|
Loc : constant Source_Ptr := Sloc (Typ);
|
|
Controller_Typ : Entity_Id;
|
|
Obj_Ref : constant Node_Id := Make_Identifier (Loc, Name_V);
|
|
Controller_Ref : constant Node_Id :=
|
|
Make_Selected_Component (Loc,
|
|
Prefix => Obj_Ref,
|
|
Selector_Name =>
|
|
Make_Identifier (Loc, Name_uController));
|
|
|
|
begin
|
|
if Is_Return_By_Reference_Type (Typ) then
|
|
Controller_Typ := RTE (RE_Limited_Record_Controller);
|
|
else
|
|
Controller_Typ := RTE (RE_Record_Controller);
|
|
end if;
|
|
|
|
case Prim is
|
|
when Initialize_Case =>
|
|
declare
|
|
Res : constant List_Id := New_List;
|
|
|
|
begin
|
|
Append_List_To (Res,
|
|
Make_Init_Call (
|
|
Ref => Controller_Ref,
|
|
Typ => Controller_Typ,
|
|
Flist_Ref => Make_Identifier (Loc, Name_L),
|
|
With_Attach => Make_Identifier (Loc, Name_B)));
|
|
|
|
-- When the type is also a controlled type by itself,
|
|
-- Initialize it and attach it at the end of the internal
|
|
-- finalization chain
|
|
|
|
if Is_Controlled (Typ) then
|
|
Append_To (Res,
|
|
Make_Procedure_Call_Statement (Loc,
|
|
Name => New_Reference_To (
|
|
Find_Prim_Op (Typ, Name_Of (Prim)), Loc),
|
|
|
|
Parameter_Associations =>
|
|
New_List (New_Copy_Tree (Obj_Ref))));
|
|
|
|
Append_To (Res, Make_Attach_Call (
|
|
Obj_Ref => New_Copy_Tree (Obj_Ref),
|
|
Flist_Ref =>
|
|
Make_Selected_Component (Loc,
|
|
Prefix => New_Copy_Tree (Controller_Ref),
|
|
Selector_Name => Make_Identifier (Loc, Name_F)),
|
|
With_Attach => Make_Integer_Literal (Loc, 1)));
|
|
end if;
|
|
|
|
return Res;
|
|
end;
|
|
|
|
when Adjust_Case =>
|
|
return
|
|
Make_Adjust_Call (Controller_Ref, Controller_Typ,
|
|
Make_Identifier (Loc, Name_L),
|
|
Make_Identifier (Loc, Name_B));
|
|
|
|
when Finalize_Case =>
|
|
return
|
|
Make_Final_Call (Controller_Ref, Controller_Typ,
|
|
Make_Identifier (Loc, Name_B));
|
|
end case;
|
|
end Make_Deep_Record_Body;
|
|
|
|
----------------------
|
|
-- Make_Final_Call --
|
|
----------------------
|
|
|
|
function Make_Final_Call
|
|
(Ref : Node_Id;
|
|
Typ : Entity_Id;
|
|
With_Detach : Node_Id)
|
|
return List_Id
|
|
is
|
|
Loc : constant Source_Ptr := Sloc (Ref);
|
|
Res : constant List_Id := New_List;
|
|
Cref : Node_Id;
|
|
Cref2 : Node_Id;
|
|
Proc : Entity_Id;
|
|
Utyp : Entity_Id;
|
|
|
|
begin
|
|
if Is_Class_Wide_Type (Typ) then
|
|
Utyp := Root_Type (Typ);
|
|
Cref := Ref;
|
|
|
|
elsif Is_Concurrent_Type (Typ) then
|
|
Utyp := Corresponding_Record_Type (Typ);
|
|
Cref := Convert_Concurrent (Ref, Typ);
|
|
|
|
elsif Is_Private_Type (Typ)
|
|
and then Present (Full_View (Typ))
|
|
and then Is_Concurrent_Type (Full_View (Typ))
|
|
then
|
|
Utyp := Corresponding_Record_Type (Full_View (Typ));
|
|
Cref := Convert_Concurrent (Ref, Full_View (Typ));
|
|
else
|
|
Utyp := Typ;
|
|
Cref := Ref;
|
|
end if;
|
|
|
|
Utyp := Underlying_Type (Base_Type (Utyp));
|
|
Set_Assignment_OK (Cref);
|
|
|
|
-- Deal with non-tagged derivation of private views
|
|
|
|
if Is_Untagged_Derivation (Typ) then
|
|
Utyp := Underlying_Type (Root_Type (Base_Type (Typ)));
|
|
Cref := Unchecked_Convert_To (Utyp, Cref);
|
|
Set_Assignment_OK (Cref);
|
|
-- To prevent problems with UC see 1.156 RH ???
|
|
end if;
|
|
|
|
-- If the underlying_type is a subtype, we are dealing with
|
|
-- the completion of a private type. We need to access
|
|
-- the base type and generate a conversion to it.
|
|
|
|
if Utyp /= Base_Type (Utyp) then
|
|
pragma Assert (Is_Private_Type (Typ));
|
|
Utyp := Base_Type (Utyp);
|
|
Cref := Unchecked_Convert_To (Utyp, Cref);
|
|
end if;
|
|
|
|
-- Generate:
|
|
-- Deep_Finalize (Ref, With_Detach);
|
|
|
|
if Has_Controlled_Component (Utyp)
|
|
or else Is_Class_Wide_Type (Typ)
|
|
then
|
|
if Is_Tagged_Type (Utyp) then
|
|
Proc := Find_Prim_Op (Utyp, Deep_Name_Of (Finalize_Case));
|
|
else
|
|
Proc := TSS (Utyp, Deep_Name_Of (Finalize_Case));
|
|
end if;
|
|
|
|
Cref := Convert_View (Proc, Cref);
|
|
|
|
Append_To (Res,
|
|
Make_Procedure_Call_Statement (Loc,
|
|
Name => New_Reference_To (Proc, Loc),
|
|
Parameter_Associations =>
|
|
New_List (Cref, With_Detach)));
|
|
|
|
-- Generate:
|
|
-- if With_Detach then
|
|
-- Finalize_One (Ref);
|
|
-- else
|
|
-- Finalize (Ref);
|
|
-- end if;
|
|
|
|
else
|
|
Proc := Find_Prim_Op (Utyp, Name_Of (Finalize_Case));
|
|
|
|
if Chars (With_Detach) = Chars (Standard_True) then
|
|
Append_To (Res,
|
|
Make_Procedure_Call_Statement (Loc,
|
|
Name => New_Reference_To (RTE (RE_Finalize_One), Loc),
|
|
Parameter_Associations => New_List (
|
|
OK_Convert_To (RTE (RE_Finalizable), Cref))));
|
|
|
|
elsif Chars (With_Detach) = Chars (Standard_False) then
|
|
Append_To (Res,
|
|
Make_Procedure_Call_Statement (Loc,
|
|
Name => New_Reference_To (Proc, Loc),
|
|
Parameter_Associations =>
|
|
New_List (Convert_View (Proc, Cref))));
|
|
|
|
else
|
|
Cref2 := New_Copy_Tree (Cref);
|
|
Append_To (Res,
|
|
Make_Implicit_If_Statement (Ref,
|
|
Condition => With_Detach,
|
|
Then_Statements => New_List (
|
|
Make_Procedure_Call_Statement (Loc,
|
|
Name => New_Reference_To (RTE (RE_Finalize_One), Loc),
|
|
Parameter_Associations => New_List (
|
|
OK_Convert_To (RTE (RE_Finalizable), Cref)))),
|
|
|
|
Else_Statements => New_List (
|
|
Make_Procedure_Call_Statement (Loc,
|
|
Name => New_Reference_To (Proc, Loc),
|
|
Parameter_Associations =>
|
|
New_List (Convert_View (Proc, Cref2))))));
|
|
end if;
|
|
end if;
|
|
|
|
-- Treat this as a reference to Finalize if the Finalize routine
|
|
-- comes from source. The call is not explicit, but it is near
|
|
-- enough, and we won't typically get explicit adjust calls.
|
|
|
|
if Comes_From_Source (Proc) then
|
|
Generate_Reference (Proc, Ref);
|
|
end if;
|
|
return Res;
|
|
end Make_Final_Call;
|
|
|
|
--------------------
|
|
-- Make_Init_Call --
|
|
--------------------
|
|
|
|
function Make_Init_Call
|
|
(Ref : Node_Id;
|
|
Typ : Entity_Id;
|
|
Flist_Ref : Node_Id;
|
|
With_Attach : Node_Id)
|
|
return List_Id
|
|
is
|
|
Loc : constant Source_Ptr := Sloc (Ref);
|
|
Is_Conc : Boolean;
|
|
Res : constant List_Id := New_List;
|
|
Proc : Entity_Id;
|
|
Utyp : Entity_Id;
|
|
Cref : Node_Id;
|
|
Cref2 : Node_Id;
|
|
Attach : Node_Id := With_Attach;
|
|
|
|
begin
|
|
if Is_Concurrent_Type (Typ) then
|
|
Is_Conc := True;
|
|
Utyp := Corresponding_Record_Type (Typ);
|
|
Cref := Convert_Concurrent (Ref, Typ);
|
|
|
|
elsif Is_Private_Type (Typ)
|
|
and then Present (Full_View (Typ))
|
|
and then Is_Concurrent_Type (Underlying_Type (Typ))
|
|
then
|
|
Is_Conc := True;
|
|
Utyp := Corresponding_Record_Type (Underlying_Type (Typ));
|
|
Cref := Convert_Concurrent (Ref, Underlying_Type (Typ));
|
|
|
|
else
|
|
Is_Conc := False;
|
|
Utyp := Typ;
|
|
Cref := Ref;
|
|
end if;
|
|
|
|
Utyp := Underlying_Type (Base_Type (Utyp));
|
|
|
|
Set_Assignment_OK (Cref);
|
|
|
|
-- Deal with non-tagged derivation of private views
|
|
|
|
if Is_Untagged_Derivation (Typ)
|
|
and then not Is_Conc
|
|
then
|
|
Utyp := Underlying_Type (Root_Type (Base_Type (Typ)));
|
|
Cref := Unchecked_Convert_To (Utyp, Cref);
|
|
Set_Assignment_OK (Cref);
|
|
-- To prevent problems with UC see 1.156 RH ???
|
|
end if;
|
|
|
|
-- If the underlying_type is a subtype, we are dealing with
|
|
-- the completion of a private type. We need to access
|
|
-- the base type and generate a conversion to it.
|
|
|
|
if Utyp /= Base_Type (Utyp) then
|
|
pragma Assert (Is_Private_Type (Typ));
|
|
Utyp := Base_Type (Utyp);
|
|
Cref := Unchecked_Convert_To (Utyp, Cref);
|
|
end if;
|
|
|
|
-- We do not need to attach to one of the Global Final Lists
|
|
-- the objects whose type is Finalize_Storage_Only
|
|
|
|
if Finalize_Storage_Only (Typ)
|
|
and then (Global_Flist_Ref (Flist_Ref)
|
|
or else Entity (Constant_Value (RTE (RE_Garbage_Collected)))
|
|
= Standard_True)
|
|
then
|
|
Attach := Make_Integer_Literal (Loc, 0);
|
|
end if;
|
|
|
|
-- Generate:
|
|
-- Deep_Initialize (Ref, Flist_Ref);
|
|
|
|
if Has_Controlled_Component (Utyp) then
|
|
Proc := TSS (Utyp, Deep_Name_Of (Initialize_Case));
|
|
|
|
Cref := Convert_View (Proc, Cref, 2);
|
|
|
|
Append_To (Res,
|
|
Make_Procedure_Call_Statement (Loc,
|
|
Name => New_Reference_To (Proc, Loc),
|
|
Parameter_Associations => New_List (
|
|
Node1 => Flist_Ref,
|
|
Node2 => Cref,
|
|
Node3 => Attach)));
|
|
|
|
-- Generate:
|
|
-- Attach_To_Final_List (Ref, Flist_Ref);
|
|
-- Initialize (Ref);
|
|
|
|
else -- Is_Controlled (Utyp)
|
|
Proc := Find_Prim_Op (Utyp, Name_Of (Initialize_Case));
|
|
Cref := Convert_View (Proc, Cref);
|
|
Cref2 := New_Copy_Tree (Cref);
|
|
|
|
Append_To (Res,
|
|
Make_Procedure_Call_Statement (Loc,
|
|
Name => New_Reference_To (Proc, Loc),
|
|
Parameter_Associations => New_List (Cref2)));
|
|
|
|
Append_To (Res,
|
|
Make_Attach_Call (Cref, Flist_Ref, Attach));
|
|
|
|
-- Treat this as a reference to Initialize if Initialize routine
|
|
-- comes from source. The call is not explicit, but it is near
|
|
-- enough, and we won't typically get explicit adjust calls.
|
|
|
|
if Comes_From_Source (Proc) then
|
|
Generate_Reference (Proc, Ref);
|
|
end if;
|
|
end if;
|
|
|
|
return Res;
|
|
end Make_Init_Call;
|
|
|
|
--------------------------
|
|
-- Make_Transient_Block --
|
|
--------------------------
|
|
|
|
-- If finalization is involved, this function just wraps the instruction
|
|
-- into a block whose name is the transient block entity, and then
|
|
-- Expand_Cleanup_Actions (called on the expansion of the handled
|
|
-- sequence of statements will do the necessary expansions for
|
|
-- cleanups).
|
|
|
|
function Make_Transient_Block
|
|
(Loc : Source_Ptr;
|
|
Action : Node_Id)
|
|
return Node_Id
|
|
is
|
|
Flist : constant Entity_Id := Finalization_Chain_Entity (Current_Scope);
|
|
Decls : constant List_Id := New_List;
|
|
Par : constant Node_Id := Parent (Action);
|
|
Instrs : constant List_Id := New_List (Action);
|
|
Blk : Node_Id;
|
|
|
|
begin
|
|
-- Case where only secondary stack use is involved
|
|
|
|
if Uses_Sec_Stack (Current_Scope)
|
|
and then No (Flist)
|
|
and then Nkind (Action) /= N_Return_Statement
|
|
and then Nkind (Par) /= N_Exception_Handler
|
|
then
|
|
|
|
declare
|
|
S : Entity_Id;
|
|
K : Entity_Kind;
|
|
begin
|
|
S := Scope (Current_Scope);
|
|
loop
|
|
K := Ekind (S);
|
|
|
|
-- At the outer level, no need to release the sec stack
|
|
|
|
if S = Standard_Standard then
|
|
Set_Uses_Sec_Stack (Current_Scope, False);
|
|
exit;
|
|
|
|
-- In a function, only release the sec stack if the
|
|
-- function does not return on the sec stack otherwise
|
|
-- the result may be lost. The caller is responsible for
|
|
-- releasing.
|
|
|
|
elsif K = E_Function then
|
|
Set_Uses_Sec_Stack (Current_Scope, False);
|
|
|
|
if not Requires_Transient_Scope (Etype (S)) then
|
|
if not Functions_Return_By_DSP_On_Target then
|
|
Set_Uses_Sec_Stack (S, True);
|
|
Check_Restriction (No_Secondary_Stack, Action);
|
|
end if;
|
|
end if;
|
|
|
|
exit;
|
|
|
|
-- In a loop or entry we should install a block encompassing
|
|
-- all the construct. For now just release right away.
|
|
|
|
elsif K = E_Loop or else K = E_Entry then
|
|
exit;
|
|
|
|
-- In a procedure or a block, we release on exit of the
|
|
-- procedure or block. ??? memory leak can be created by
|
|
-- recursive calls.
|
|
|
|
elsif K = E_Procedure
|
|
or else K = E_Block
|
|
then
|
|
if not Functions_Return_By_DSP_On_Target then
|
|
Set_Uses_Sec_Stack (S, True);
|
|
Check_Restriction (No_Secondary_Stack, Action);
|
|
end if;
|
|
|
|
Set_Uses_Sec_Stack (Current_Scope, False);
|
|
exit;
|
|
|
|
else
|
|
S := Scope (S);
|
|
end if;
|
|
end loop;
|
|
end;
|
|
end if;
|
|
|
|
-- Insert actions stuck in the transient scopes as well as all
|
|
-- freezing nodes needed by those actions
|
|
|
|
Insert_Actions_In_Scope_Around (Action);
|
|
|
|
declare
|
|
Last_Inserted : Node_Id := Prev (Action);
|
|
|
|
begin
|
|
if Present (Last_Inserted) then
|
|
Freeze_All (First_Entity (Current_Scope), Last_Inserted);
|
|
end if;
|
|
end;
|
|
|
|
Blk :=
|
|
Make_Block_Statement (Loc,
|
|
Identifier => New_Reference_To (Current_Scope, Loc),
|
|
Declarations => Decls,
|
|
Handled_Statement_Sequence =>
|
|
Make_Handled_Sequence_Of_Statements (Loc, Statements => Instrs),
|
|
Has_Created_Identifier => True);
|
|
|
|
-- When the transient scope was established, we pushed the entry for
|
|
-- the transient scope onto the scope stack, so that the scope was
|
|
-- active for the installation of finalizable entities etc. Now we
|
|
-- must remove this entry, since we have constructed a proper block.
|
|
|
|
Pop_Scope;
|
|
|
|
return Blk;
|
|
end Make_Transient_Block;
|
|
|
|
------------------------
|
|
-- Node_To_Be_Wrapped --
|
|
------------------------
|
|
|
|
function Node_To_Be_Wrapped return Node_Id is
|
|
begin
|
|
return Scope_Stack.Table (Scope_Stack.Last).Node_To_Be_Wrapped;
|
|
end Node_To_Be_Wrapped;
|
|
|
|
----------------------------
|
|
-- Set_Node_To_Be_Wrapped --
|
|
----------------------------
|
|
|
|
procedure Set_Node_To_Be_Wrapped (N : Node_Id) is
|
|
begin
|
|
Scope_Stack.Table (Scope_Stack.Last).Node_To_Be_Wrapped := N;
|
|
end Set_Node_To_Be_Wrapped;
|
|
|
|
----------------------------------
|
|
-- Store_After_Actions_In_Scope --
|
|
----------------------------------
|
|
|
|
procedure Store_After_Actions_In_Scope (L : List_Id) is
|
|
SE : Scope_Stack_Entry renames Scope_Stack.Table (Scope_Stack.Last);
|
|
|
|
begin
|
|
if Present (SE.Actions_To_Be_Wrapped_After) then
|
|
Insert_List_Before_And_Analyze (
|
|
First (SE.Actions_To_Be_Wrapped_After), L);
|
|
|
|
else
|
|
SE.Actions_To_Be_Wrapped_After := L;
|
|
|
|
if Is_List_Member (SE.Node_To_Be_Wrapped) then
|
|
Set_Parent (L, Parent (SE.Node_To_Be_Wrapped));
|
|
else
|
|
Set_Parent (L, SE.Node_To_Be_Wrapped);
|
|
end if;
|
|
|
|
Analyze_List (L);
|
|
end if;
|
|
end Store_After_Actions_In_Scope;
|
|
|
|
-----------------------------------
|
|
-- Store_Before_Actions_In_Scope --
|
|
-----------------------------------
|
|
|
|
procedure Store_Before_Actions_In_Scope (L : List_Id) is
|
|
SE : Scope_Stack_Entry renames Scope_Stack.Table (Scope_Stack.Last);
|
|
|
|
begin
|
|
if Present (SE.Actions_To_Be_Wrapped_Before) then
|
|
Insert_List_After_And_Analyze (
|
|
Last (SE.Actions_To_Be_Wrapped_Before), L);
|
|
|
|
else
|
|
SE.Actions_To_Be_Wrapped_Before := L;
|
|
|
|
if Is_List_Member (SE.Node_To_Be_Wrapped) then
|
|
Set_Parent (L, Parent (SE.Node_To_Be_Wrapped));
|
|
else
|
|
Set_Parent (L, SE.Node_To_Be_Wrapped);
|
|
end if;
|
|
|
|
Analyze_List (L);
|
|
end if;
|
|
end Store_Before_Actions_In_Scope;
|
|
|
|
--------------------------------
|
|
-- Wrap_Transient_Declaration --
|
|
--------------------------------
|
|
|
|
-- If a transient scope has been established during the processing of the
|
|
-- Expression of an Object_Declaration, it is not possible to wrap the
|
|
-- declaration into a transient block as usual case, otherwise the object
|
|
-- would be itself declared in the wrong scope. Therefore, all entities (if
|
|
-- any) defined in the transient block are moved to the proper enclosing
|
|
-- scope, furthermore, if they are controlled variables they are finalized
|
|
-- right after the declaration. The finalization list of the transient
|
|
-- scope is defined as a renaming of the enclosing one so during their
|
|
-- initialization they will be attached to the proper finalization
|
|
-- list. For instance, the following declaration :
|
|
|
|
-- X : Typ := F (G (A), G (B));
|
|
|
|
-- (where G(A) and G(B) return controlled values, expanded as _v1 and _v2)
|
|
-- is expanded into :
|
|
|
|
-- _local_final_list_1 : Finalizable_Ptr;
|
|
-- X : Typ := [ complex Expression-Action ];
|
|
-- Finalize_One(_v1);
|
|
-- Finalize_One (_v2);
|
|
|
|
procedure Wrap_Transient_Declaration (N : Node_Id) is
|
|
S : Entity_Id;
|
|
LC : Entity_Id := Empty;
|
|
Nodes : List_Id;
|
|
Loc : constant Source_Ptr := Sloc (N);
|
|
Enclosing_S : Entity_Id;
|
|
Uses_SS : Boolean;
|
|
Next_N : constant Node_Id := Next (N);
|
|
|
|
begin
|
|
S := Current_Scope;
|
|
Enclosing_S := Scope (S);
|
|
|
|
-- Insert Actions kept in the Scope stack
|
|
|
|
Insert_Actions_In_Scope_Around (N);
|
|
|
|
-- If the declaration is consuming some secondary stack, mark the
|
|
-- Enclosing scope appropriately.
|
|
|
|
Uses_SS := Uses_Sec_Stack (S);
|
|
Pop_Scope;
|
|
|
|
-- Create a List controller and rename the final list to be its
|
|
-- internal final pointer:
|
|
-- Lxxx : Simple_List_Controller;
|
|
-- Fxxx : Finalizable_Ptr renames Lxxx.F;
|
|
|
|
if Present (Finalization_Chain_Entity (S)) then
|
|
LC := Make_Defining_Identifier (Loc, New_Internal_Name ('L'));
|
|
|
|
Nodes := New_List (
|
|
Make_Object_Declaration (Loc,
|
|
Defining_Identifier => LC,
|
|
Object_Definition =>
|
|
New_Reference_To (RTE (RE_Simple_List_Controller), Loc)),
|
|
|
|
Make_Object_Renaming_Declaration (Loc,
|
|
Defining_Identifier => Finalization_Chain_Entity (S),
|
|
Subtype_Mark => New_Reference_To (RTE (RE_Finalizable_Ptr), Loc),
|
|
Name =>
|
|
Make_Selected_Component (Loc,
|
|
Prefix => New_Reference_To (LC, Loc),
|
|
Selector_Name => Make_Identifier (Loc, Name_F))));
|
|
|
|
-- Put the declaration at the beginning of the declaration part
|
|
-- to make sure it will be before all other actions that have been
|
|
-- inserted before N.
|
|
|
|
Insert_List_Before_And_Analyze (First (List_Containing (N)), Nodes);
|
|
|
|
-- Generate the Finalization calls by finalizing the list
|
|
-- controller right away. It will be re-finalized on scope
|
|
-- exit but it doesn't matter. It cannot be done when the
|
|
-- call initializes a renaming object though because in this
|
|
-- case, the object becomes a pointer to the temporary and thus
|
|
-- increases its life span.
|
|
|
|
if Nkind (N) = N_Object_Renaming_Declaration
|
|
and then Controlled_Type (Etype (Defining_Identifier (N)))
|
|
then
|
|
null;
|
|
|
|
else
|
|
Nodes :=
|
|
Make_Final_Call (
|
|
Ref => New_Reference_To (LC, Loc),
|
|
Typ => Etype (LC),
|
|
With_Detach => New_Reference_To (Standard_False, Loc));
|
|
if Present (Next_N) then
|
|
Insert_List_Before_And_Analyze (Next_N, Nodes);
|
|
else
|
|
Append_List_To (List_Containing (N), Nodes);
|
|
end if;
|
|
end if;
|
|
end if;
|
|
|
|
-- Put the local entities back in the enclosing scope, and set the
|
|
-- Is_Public flag appropriately.
|
|
|
|
Transfer_Entities (S, Enclosing_S);
|
|
|
|
-- Mark the enclosing dynamic scope so that the sec stack will be
|
|
-- released upon its exit unless this is a function that returns on
|
|
-- the sec stack in which case this will be done by the caller.
|
|
|
|
if Uses_SS then
|
|
S := Enclosing_Dynamic_Scope (S);
|
|
|
|
if Ekind (S) = E_Function
|
|
and then Requires_Transient_Scope (Etype (S))
|
|
then
|
|
null;
|
|
else
|
|
Set_Uses_Sec_Stack (S);
|
|
Check_Restriction (No_Secondary_Stack, N);
|
|
end if;
|
|
end if;
|
|
end Wrap_Transient_Declaration;
|
|
|
|
-------------------------------
|
|
-- Wrap_Transient_Expression --
|
|
-------------------------------
|
|
|
|
-- Insert actions before <Expression>:
|
|
|
|
-- (lines marked with <CTRL> are expanded only in presence of Controlled
|
|
-- objects needing finalization)
|
|
|
|
-- _E : Etyp;
|
|
-- declare
|
|
-- _M : constant Mark_Id := SS_Mark;
|
|
-- Local_Final_List : System.FI.Finalizable_Ptr; <CTRL>
|
|
|
|
-- procedure _Clean is
|
|
-- begin
|
|
-- Abort_Defer;
|
|
-- System.FI.Finalize_List (Local_Final_List); <CTRL>
|
|
-- SS_Release (M);
|
|
-- Abort_Undefer;
|
|
-- end _Clean;
|
|
|
|
-- begin
|
|
-- _E := <Expression>;
|
|
-- at end
|
|
-- _Clean;
|
|
-- end;
|
|
|
|
-- then expression is replaced by _E
|
|
|
|
procedure Wrap_Transient_Expression (N : Node_Id) is
|
|
Loc : constant Source_Ptr := Sloc (N);
|
|
E : constant Entity_Id :=
|
|
Make_Defining_Identifier (Loc, New_Internal_Name ('E'));
|
|
Etyp : Entity_Id := Etype (N);
|
|
|
|
begin
|
|
Insert_Actions (N, New_List (
|
|
Make_Object_Declaration (Loc,
|
|
Defining_Identifier => E,
|
|
Object_Definition => New_Reference_To (Etyp, Loc)),
|
|
|
|
Make_Transient_Block (Loc,
|
|
Action =>
|
|
Make_Assignment_Statement (Loc,
|
|
Name => New_Reference_To (E, Loc),
|
|
Expression => Relocate_Node (N)))));
|
|
|
|
Rewrite (N, New_Reference_To (E, Loc));
|
|
Analyze_And_Resolve (N, Etyp);
|
|
end Wrap_Transient_Expression;
|
|
|
|
------------------------------
|
|
-- Wrap_Transient_Statement --
|
|
------------------------------
|
|
|
|
-- Transform <Instruction> into
|
|
|
|
-- (lines marked with <CTRL> are expanded only in presence of Controlled
|
|
-- objects needing finalization)
|
|
|
|
-- declare
|
|
-- _M : Mark_Id := SS_Mark;
|
|
-- Local_Final_List : System.FI.Finalizable_Ptr ; <CTRL>
|
|
|
|
-- procedure _Clean is
|
|
-- begin
|
|
-- Abort_Defer;
|
|
-- System.FI.Finalize_List (Local_Final_List); <CTRL>
|
|
-- SS_Release (_M);
|
|
-- Abort_Undefer;
|
|
-- end _Clean;
|
|
|
|
-- begin
|
|
-- <Instr uction>;
|
|
-- at end
|
|
-- _Clean;
|
|
-- end;
|
|
|
|
procedure Wrap_Transient_Statement (N : Node_Id) is
|
|
Loc : constant Source_Ptr := Sloc (N);
|
|
New_Statement : constant Node_Id := Relocate_Node (N);
|
|
|
|
begin
|
|
Rewrite (N, Make_Transient_Block (Loc, New_Statement));
|
|
|
|
-- With the scope stack back to normal, we can call analyze on the
|
|
-- resulting block. At this point, the transient scope is being
|
|
-- treated like a perfectly normal scope, so there is nothing
|
|
-- special about it.
|
|
|
|
-- Note: Wrap_Transient_Statement is called with the node already
|
|
-- analyzed (i.e. Analyzed (N) is True). This is important, since
|
|
-- otherwise we would get a recursive processing of the node when
|
|
-- we do this Analyze call.
|
|
|
|
Analyze (N);
|
|
end Wrap_Transient_Statement;
|
|
|
|
end Exp_Ch7;
|