aboutsummaryrefslogtreecommitdiffstats
path: root/gcc-4.4.0/gcc/ada/exp_ch7.ads
diff options
context:
space:
mode:
Diffstat (limited to 'gcc-4.4.0/gcc/ada/exp_ch7.ads')
-rw-r--r--gcc-4.4.0/gcc/ada/exp_ch7.ads248
1 files changed, 248 insertions, 0 deletions
diff --git a/gcc-4.4.0/gcc/ada/exp_ch7.ads b/gcc-4.4.0/gcc/ada/exp_ch7.ads
new file mode 100644
index 000000000..b6c3ff26c
--- /dev/null
+++ b/gcc-4.4.0/gcc/ada/exp_ch7.ads
@@ -0,0 +1,248 @@
+------------------------------------------------------------------------------
+-- --
+-- GNAT COMPILER COMPONENTS --
+-- --
+-- E X P _ C H 7 --
+-- --
+-- S p e c --
+-- --
+-- Copyright (C) 1992-2008, 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 3, 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 COPYING3. If not, go to --
+-- http://www.gnu.org/licenses for a complete copy of the license. --
+-- --
+-- GNAT was originally developed by the GNAT team at New York University. --
+-- Extensive contributions were provided by Ada Core Technologies Inc. --
+-- --
+------------------------------------------------------------------------------
+
+with Namet; use Namet;
+with Types; use Types;
+
+package Exp_Ch7 is
+
+ procedure Expand_N_Package_Body (N : Node_Id);
+ procedure Expand_N_Package_Declaration (N : Node_Id);
+
+ -----------------------------
+ -- Finalization Management --
+ -----------------------------
+
+ function In_Finalization_Root (E : Entity_Id) return Boolean;
+ -- True if current scope is in package System.Finalization_Root. Used
+ -- to avoid certain expansions that would involve circularity in the
+ -- Rtsfind mechanism.
+
+ procedure Build_Final_List (N : Node_Id; Typ : Entity_Id);
+ -- Build finalization list for anonymous access types, and for access
+ -- types that are frozen before their designated types are known to
+ -- be controlled.
+
+ procedure Build_Controlling_Procs (Typ : Entity_Id);
+ -- Typ is a record, and array type having controlled components.
+ -- Create the procedures Deep_Initialize, Deep_Adjust and Deep_Finalize
+ -- that take care of finalization management at run-time.
+
+ procedure Build_Late_Proc (Typ : Entity_Id; Nam : Name_Id);
+ -- Build one controlling procedure when a late body overrides one of
+ -- the controlling operations.
+
+ function Controller_Component (Typ : Entity_Id) return Entity_Id;
+ -- Returns the entity of the component whose name is 'Name_uController'
+
+ function CW_Or_Has_Controlled_Part (T : Entity_Id) return Boolean;
+ -- True if T is a class-wide type, or if it has controlled parts ("part"
+ -- means T or any of its subcomponents). This is the same as
+ -- Needs_Finalization, except when pragma Restrictions (No_Finalization)
+ -- applies, in which case we know that class-wide objects do not contain
+ -- controlled parts.
+
+ procedure Expand_Ctrl_Function_Call (N : Node_Id);
+ -- Expand a call to a function returning a controlled value. That is to
+ -- say attach the result of the call to the current finalization list,
+ -- which is the one of the transient scope created for such constructs.
+
+ function Find_Final_List
+ (E : Entity_Id;
+ Ref : Node_Id := Empty) return Node_Id;
+ -- E is an entity representing a controlled object, a controlled type or a
+ -- scope. If Ref is not empty, it is a reference to a controlled record,
+ -- the closest Final list is in the controller component of the record
+ -- containing Ref otherwise this function returns a reference to the final
+ -- list attached to the closest dynamic scope (that can be E itself)
+ -- creating this final list if necessary.
+
+ function Has_New_Controlled_Component (E : Entity_Id) return Boolean;
+ -- E is a type entity. Give the same result as Has_Controlled_Component
+ -- except for tagged extensions where the result is True only if the
+ -- latest extension contains a controlled component.
+
+ function Make_Attach_Call
+ (Obj_Ref : Node_Id;
+ Flist_Ref : Node_Id;
+ With_Attach : Node_Id) return Node_Id;
+ -- Attach the referenced object to the referenced Final Chain 'Flist_Ref'
+ -- With_Attach is an expression of type Short_Short_Integer which can be
+ -- either '0' to signify no attachment, '1' for attachment to a simply
+ -- linked list or '2' for attachment to a doubly linked list.
+
+ function Make_Init_Call
+ (Ref : Node_Id;
+ Typ : Entity_Id;
+ Flist_Ref : Node_Id;
+ With_Attach : Node_Id) return List_Id;
+ -- Ref is an expression (with no-side effect and is not required to have
+ -- been previously analyzed) that references the object to be initialized.
+ -- Typ is the expected type of Ref, which is either a controlled type
+ -- (Is_Controlled) or a type with controlled components (Has_Controlled).
+ -- With_Attach is an integer expression which is the attachment level,
+ -- see System.Finalization_Implementation.Attach_To_Final_List for the
+ -- documentation of Nb_Link.
+ --
+ -- This function will generate the appropriate calls to make sure that the
+ -- objects referenced by Ref are initialized. The generated code is quite
+ -- different for an IS_Controlled type or a HAS_Controlled type, but this
+ -- is not the problem for the caller, the details are in the body.
+
+ function Make_Adjust_Call
+ (Ref : Node_Id;
+ Typ : Entity_Id;
+ Flist_Ref : Node_Id;
+ With_Attach : Node_Id;
+ Allocator : Boolean := False) return List_Id;
+ -- Ref is an expression (with no-side effect and is not required to have
+ -- been previously analyzed) that references the object to be adjusted. Typ
+ -- is the expected type of Ref, which is a controlled type (Is_Controlled)
+ -- or a type with controlled components (Has_Controlled). With_Attach is an
+ -- integer expression giving the attachment level (see documentation of
+ -- Attach_To_Final_List.Nb_Link param documentation in s-finimp.ads.
+ -- Note: if Typ is Finalize_Storage_Only and the object is at library
+ -- level, then With_Attach will be ignored, and a zero link level will be
+ -- passed to Attach_To_Final_List.
+ --
+ -- This function will generate the appropriate calls to make sure that the
+ -- objects referenced by Ref are adjusted. The generated code is quite
+ -- different depending on the fact the type IS_Controlled or HAS_Controlled
+ -- but this is not the problem of the caller, the details are in the body.
+ -- The objects must be attached when the adjust takes place after an
+ -- initialization expression but not when it takes place after a regular
+ -- assignment.
+ --
+ -- If Allocator is True, we are adjusting a newly-created object. The
+ -- existing chaining pointers should not be left unchanged, because they
+ -- may come from a bit-for-bit copy of those from an initializing object.
+ -- So, when this flag is True, if the chaining pointers should otherwise
+ -- be left unset, instead they are reset to null.
+
+ function Make_Final_Call
+ (Ref : Node_Id;
+ Typ : Entity_Id;
+ With_Detach : Node_Id) return List_Id;
+ -- Ref is an expression (with no-side effect and is not required to have
+ -- been previously analyzed) that references the object to be Finalized.
+ -- Typ is the expected type of Ref, which is a controlled type
+ -- (Is_Controlled) or a type with controlled components (Has_Controlled).
+ -- With_Detach is a boolean expression indicating whether to detach the
+ -- controlled object from whatever finalization list it is currently
+ -- attached to.
+ --
+ -- This function will generate the appropriate calls to make sure that the
+ -- objects referenced by Ref are finalized. The generated code is quite
+ -- different depending on the fact the type IS_Controlled or HAS_Controlled
+ -- but this is not the problem of the caller, the details are in the body.
+ -- The objects must be detached when finalizing an unchecked deallocated
+ -- object but not when finalizing the target of an assignment, it is not
+ -- necessary either on scope exit.
+
+ function Make_Handler_For_Ctrl_Operation (Loc : Source_Ptr) return Node_Id;
+ -- Generate an implicit exception handler with an 'others' choice,
+ -- converting any occurrence to a raise of Program_Error.
+
+ function Needs_Finalization (T : Entity_Id) return Boolean;
+ -- True if T potentially needs finalization actions. True if T is
+ -- controlled, or has subcomponents. Also True if T is a class-wide type,
+ -- because some type extension might add controlled subcomponents, except
+ -- that if pragma Restrictions (No_Finalization) applies, this is False for
+ -- class-wide types.
+
+ --------------------------------------------
+ -- Task and Protected Object finalization --
+ --------------------------------------------
+
+ function Cleanup_Array
+ (N : Node_Id;
+ Obj : Node_Id;
+ Typ : Entity_Id) return List_Id;
+ -- Generate loops to finalize any tasks or simple protected objects that
+ -- are subcomponents of an array.
+
+ function Cleanup_Protected_Object
+ (N : Node_Id;
+ Ref : Node_Id) return Node_Id;
+ -- Generate code to finalize a protected object without entries
+
+ function Cleanup_Record
+ (N : Node_Id;
+ Obj : Node_Id;
+ Typ : Entity_Id) return List_Id;
+ -- For each subcomponent of a record that contains tasks or simple
+ -- protected objects, generate the appropriate finalization call.
+
+ function Cleanup_Task
+ (N : Node_Id;
+ Ref : Node_Id) return Node_Id;
+ -- Generate code to finalize a task
+
+ function Has_Simple_Protected_Object (T : Entity_Id) return Boolean;
+ -- Check whether composite type contains a simple protected component
+
+ function Is_Simple_Protected_Type (T : Entity_Id) return Boolean;
+ -- Check whether argument is a protected type without entries. Protected
+ -- types with entries are controlled, and their cleanup is handled by the
+ -- standard finalization machinery. For simple protected types we generate
+ -- inline code to release their locks.
+
+ --------------------------------
+ -- Transient Scope Management --
+ --------------------------------
+
+ procedure Expand_Cleanup_Actions (N : Node_Id);
+ -- Expand the necessary stuff into a scope to enable finalization of local
+ -- objects and deallocation of transient data when exiting the scope. N is
+ -- a "scope node" that is to say one of the following: N_Block_Statement,
+ -- N_Subprogram_Body, N_Task_Body, N_Entry_Body.
+
+ procedure Establish_Transient_Scope (N : Node_Id; Sec_Stack : Boolean);
+ -- Push a new transient scope on the scope stack. N is the node responsible
+ -- for the need of a transient scope. If Sec_Stack is True then the
+ -- secondary stack is brought in, otherwise it isn't.
+
+ function Node_To_Be_Wrapped return Node_Id;
+ -- return the node to be wrapped if the current scope is transient
+
+ procedure Store_Before_Actions_In_Scope (L : List_Id);
+ -- Append the list L of actions to the end of the before-actions store in
+ -- the top of the scope stack
+
+ procedure Store_After_Actions_In_Scope (L : List_Id);
+ -- Append the list L of actions to the beginning of the after-actions store
+ -- in the top of the scope stack
+
+ procedure Wrap_Transient_Declaration (N : Node_Id);
+ -- N is an object declaration. Expand the finalization calls after the
+ -- declaration and make the outer scope being the transient one.
+
+ procedure Wrap_Transient_Expression (N : Node_Id);
+ -- N is a sub-expression. Expand a transient block around an expression
+
+ procedure Wrap_Transient_Statement (N : Node_Id);
+ -- N is a statement. Expand a transient block around an instruction
+
+end Exp_Ch7;