Subversion Repositories openrisc_me

------------------------------------------------------------------------------

--                                                                          --

--                         GNAT COMPILER COMPONENTS                         --

--                                                                          --

--                              E X P _ C H 7                               --

--                                                                          --

--                                 S p e c                                  --

--                                                                          --

--          Copyright (C) 1992-2009, 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 (which 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;