gcc/ada/exp_ch9.ads

   1 ------------------------------------------------------------------------------
   2 --                                                                          --
   3 --                         GNAT COMPILER COMPONENTS                         --
   4 --                                                                          --
   5 --                              E X P _ C H 9                               --
   6 --                                                                          --
   7 --                                 S p e c                                  --
   8 --                                                                          --
   9 --          Copyright (C) 1992-2014, Free Software Foundation, Inc.         --
  10 --                                                                          --
  11 -- GNAT is free software;  you can  redistribute it  and/or modify it under --
  12 -- terms of the  GNU General Public License as published  by the Free Soft- --
  13 -- ware  Foundation;  either version 3,  or (at your option) any later ver- --
  14 -- sion.  GNAT is distributed in the hope that it will be useful, but WITH- --
  15 -- OUT ANY WARRANTY;  without even the  implied warranty of MERCHANTABILITY --
  16 -- or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License --
  17 -- for  more details.  You should have  received  a copy of the GNU General --
  18 -- Public License  distributed with GNAT; see file COPYING3.  If not, go to --
  19 -- http://www.gnu.org/licenses for a complete copy of the license.          --
  20 --                                                                          --
  21 -- GNAT was originally developed  by the GNAT team at  New York University. --
  22 -- Extensive contributions were provided by Ada Core Technologies Inc.      --
  23 --                                                                          --
  24 ------------------------------------------------------------------------------
  25
  26 --  Expand routines for chapter 9 constructs
  27
  28 with Types; use Types;
  29
  30 package Exp_Ch9 is
  31
  32    type Subprogram_Protection_Mode is
  33      (Dispatching_Mode,
  34       Protected_Mode,
  35       Unprotected_Mode);
  36    --  This type is used to distinguish the different protection modes of a
  37    --  protected subprogram.
  38
  39    procedure Build_Activation_Chain_Entity (N : Node_Id);
  40    --  Given a declaration N of an object that is a task, or contains tasks
  41    --  (other than allocators to tasks) this routine ensures that an activation
  42    --  chain has been declared in the appropriate scope, building the required
  43    --  declaration for the chain variable if not. The name of this variable
  44    --  is always _Chain and it is accessed by name.
  45
  46    function Build_Call_With_Task (N : Node_Id; E : Entity_Id) return Node_Id;
  47    --  N is a node representing the name of a task or an access to a task.
  48    --  The value returned is a call to the function whose name is the entity
  49    --  E (typically a runtime routine entity obtained using RTE) with the
  50    --  Task_Id of the associated task as the parameter. The caller is
  51    --  responsible for analyzing and resolving the resulting tree.
  52
  53    procedure Build_Class_Wide_Master (Typ : Entity_Id);
  54    --  Given an access-to-limited class-wide type or an access-to-limited
  55    --  interface, ensure that the designated type has a _master and generate
  56    --  a renaming of the said master to service the access type.
  57
  58    procedure Build_Entry_Names
  59      (Obj_Ref : Node_Id;
  60       Obj_Typ : Entity_Id;
  61       Stmts   : List_Id);
  62    --  Given a concurrent object, create static string names for all entries
  63    --  and entry families. Associate each name with the Protection_Entries or
  64    --  ATCB field of the object. Obj_Ref is a reference to the concurrent
  65    --  object. Obj_Typ is the type of the object. Stmts is the list where all
  66    --  generated code is attached.
  67
  68    procedure Build_Master_Entity (Obj_Or_Typ : Entity_Id);
  69    --  Given the name of an object or a type which is either a task, contains
  70    --  tasks or designates tasks, create a _master in the appropriate scope
  71    --  which captures the value of Current_Master. Mark the nearest enclosing
  72    --  body or block as being a task master.
  73
  74    procedure Build_Master_Renaming
  75      (Ptr_Typ : Entity_Id;
  76       Ins_Nod : Node_Id := Empty);
  77    --  Given an access type Ptr_Typ whose designated type is either a task or
  78    --  contains tasks, create a renaming of the form:
  79    --
  80    --     <Ptr_Typ>M : Master_Id renames _Master;
  81    --
  82    --  where _master denotes the task master of the enclosing context. Ins_Nod
  83    --  is used to provide a specific insertion node for the renaming.
  84
  85    function Build_Private_Protected_Declaration (N : Node_Id) return Entity_Id;
  86    --  A subprogram body without a previous spec that appears in a protected
  87    --  body must be expanded separately to create a subprogram declaration
  88    --  for it, in order to resolve internal calls to it from other protected
  89    --  operations. It would seem that no locking version of the operation is
  90    --  needed, but in fact, in Ada 2005 the subprogram may be used in a call-
  91    --  back, and therefore a protected version of the operation must be
  92    --  generated as well.
  93    --
  94    --  Possibly factor this with Exp_Dist.Copy_Specification ???
  95
  96    function Build_Protected_Sub_Specification
  97      (N        : Node_Id;
  98       Prot_Typ : Entity_Id;
  99       Mode     : Subprogram_Protection_Mode) return Node_Id;
 100    --  Build the specification for protected subprogram. This is called when
 101    --  expanding a protected type, and also when expanding the declaration for
 102    --  an Access_To_Protected_Subprogram type. In the latter case, Prot_Typ is
 103    --  empty, and the first parameter of the signature of the protected op is
 104    --  of type System.Address.
 105
 106    procedure Build_Protected_Subprogram_Call
 107      (N        : Node_Id;
 108       Name     : Node_Id;
 109       Rec      : Node_Id;
 110       External : Boolean := True);
 111    --  The node N is a subprogram or entry call to a protected subprogram. This
 112    --  procedure rewrites this call with the appropriate expansion. Name is the
 113    --  subprogram, and Rec is the record corresponding to the protected object.
 114    --  External is False if the call is to another protected subprogram within
 115    --  the same object.
 116
 117    procedure Build_Protected_Subprogram_Call_Cleanup
 118      (Op_Spec   : Node_Id;
 119       Conc_Typ  : Node_Id;
 120       Loc       : Source_Ptr;
 121       Stmts     : List_Id);
 122    --  Append to Stmts the cleanups after a call to a protected subprogram
 123    --  whose specification is Op_Spec. Conc_Typ is the concurrent type and Loc
 124    --  the sloc for appended statements. The cleanup will either unlock the
 125    --  protected object or serve pending entries.
 126
 127    procedure Build_Task_Activation_Call (N : Node_Id);
 128    --  This procedure is called for constructs that can be task activators,
 129    --  i.e. task bodies, subprogram bodies, package bodies and blocks. If the
 130    --  construct is a task activator (as indicated by the non-empty setting of
 131    --  Activation_Chain_Entity, either in the construct, or, in the case of a
 132    --  package body, in its associated package spec), then a call to
 133    --  Activate_Tasks with this entity as the single parameter is inserted at
 134    --  the start of the statements of the activator.
 135
 136    procedure Build_Task_Allocate_Block
 137      (Actions : List_Id;
 138       N       : Node_Id;
 139       Args    : List_Id);
 140    --  This routine is used in the case of allocators where the designated type
 141    --  is a task or contains tasks. In this case, the normal initialize call
 142    --  is replaced by:
 143    --
 144    --    blockname : label;
 145    --    blockname : declare
 146    --       _Chain  : Activation_Chain;
 147    --
 148    --       procedure _Expunge is
 149    --       begin
 150    --         Expunge_Unactivated_Tasks (_Chain);
 151    --       end;
 152    --
 153    --    begin
 154    --       Init (Args);
 155    --       Activate_Tasks (_Chain);
 156    --    at end
 157    --       _Expunge;
 158    --    end;
 159    --
 160    --  to get the task or tasks created and initialized. The expunge call
 161    --  ensures that any tasks that get created but not activated due to an
 162    --  exception are properly expunged (it has no effect in the normal case).
 163    --  The argument N is the allocator, and Args is the list of arguments for
 164    --  the initialization call, constructed by the caller, which uses the
 165    --  Master_Id of the access type as the _Master parameter, and _Chain
 166    --  (defined above) as the _Chain parameter.
 167
 168    procedure Build_Task_Allocate_Block_With_Init_Stmts
 169      (Actions    : List_Id;
 170       N          : Node_Id;
 171       Init_Stmts : List_Id);
 172    --  Ada 2005 (AI-287): Similar to previous routine, but used to expand
 173    --  allocated aggregates with default initialized components. Init_Stmts
 174    --  contains the list of statements required to initialize the allocated
 175    --  aggregate. It replaces the call to Init (Args) done by
 176    --  Build_Task_Allocate_Block. Also used to expand allocators containing
 177    --  build-in-place function calls.
 178
 179    function Build_Wrapper_Spec
 180      (Subp_Id : Entity_Id;
 181       Obj_Typ : Entity_Id;
 182       Formals : List_Id) return Node_Id;
 183    --  Ada 2005 (AI-345): Build the specification of a primitive operation
 184    --  associated with a protected or task type. This is required to implement
 185    --  dispatching calls through interfaces. Subp_Id is the primitive to be
 186    --  wrapped, Obj_Typ is the type of the newly added formal parameter to
 187    --  handle object notation, Formals are the original entry formals that
 188    --  will be explicitly replicated.
 189
 190    function Concurrent_Ref (N : Node_Id) return Node_Id;
 191    --  Given the name of a concurrent object (task or protected object), or
 192    --  the name of an access to a concurrent object, this function returns an
 193    --  expression referencing the associated Task_Id or Protection object,
 194    --  respectively. Note that a special case is when the name is a reference
 195    --  to a task type name. This can only happen within a task body, and the
 196    --  meaning is to get the Task_Id for the currently executing task.
 197
 198    function Convert_Concurrent
 199      (N   : Node_Id;
 200       Typ : Entity_Id) return Node_Id;
 201    --  N is an expression of type Typ. If the type is not a concurrent type
 202    --  then it is returned unchanged. If it is a task or protected reference,
 203    --  Convert_Concurrent creates an unchecked conversion node from this
 204    --  expression to the corresponding concurrent record type value. We need
 205    --  this in any situation where the concurrent type is used, because the
 206    --  actual concurrent object is an object of the corresponding concurrent
 207    --  type, and manipulations on the concurrent object actually manipulate the
 208    --  corresponding object of the record type.
 209
 210    function Entry_Index_Expression
 211      (Sloc  : Source_Ptr;
 212       Ent   : Entity_Id;
 213       Index : Node_Id;
 214       Ttyp  : Entity_Id)
 215       return  Node_Id;
 216    --  Returns an expression to compute a task entry index given the name of
 217    --  the entry or entry family. For the case of a task entry family, the
 218    --  Index parameter contains the expression for the subscript. Ttyp is the
 219    --  task type.
 220
 221    procedure Establish_Task_Master (N : Node_Id);
 222    --  Given a subprogram body, or a block statement, or a task body, this
 223    --  procedure makes the necessary transformations required of a task master
 224    --  (add Enter_Master call at start, and establish a cleanup routine to make
 225    --  sure Complete_Master is called on exit).
 226
 227    procedure Expand_Access_Protected_Subprogram_Type (N : Node_Id);
 228    --  Build Equivalent_Type for an Access_To_Protected_Subprogram.
 229    --  Equivalent_Type is a record type with two components: a pointer to the
 230    --  protected object, and a pointer to the operation itself.
 231
 232    procedure Expand_Accept_Declarations (N : Node_Id; Ent : Entity_Id);
 233    --  Expand declarations required for accept statement. See bodies of both
 234    --  Expand_Accept_Declarations and Expand_N_Accept_Statement for full
 235    --  details of the nature and use of these declarations, which are inserted
 236    --  immediately before the accept node N. The second argument is the entity
 237    --  for the corresponding entry.
 238
 239    procedure Expand_Entry_Barrier (N : Node_Id; Ent : Entity_Id);
 240    --  Expand the entry barrier into a function. This is called directly
 241    --  from Analyze_Entry_Body so that the discriminals and privals of the
 242    --  barrier can be attached to the function declaration list, and a new
 243    --  set prepared for the entry body procedure, before the entry body
 244    --  statement sequence can be expanded. The resulting function is analyzed
 245    --  now, within the context of the protected object, to resolve calls to
 246    --  other protected functions.
 247
 248    procedure Expand_N_Abort_Statement            (N : Node_Id);
 249    procedure Expand_N_Accept_Statement           (N : Node_Id);
 250    procedure Expand_N_Asynchronous_Select        (N : Node_Id);
 251    procedure Expand_N_Conditional_Entry_Call     (N : Node_Id);
 252    procedure Expand_N_Delay_Relative_Statement   (N : Node_Id);
 253    procedure Expand_N_Delay_Until_Statement      (N : Node_Id);
 254    procedure Expand_N_Entry_Body                 (N : Node_Id);
 255    procedure Expand_N_Entry_Call_Statement       (N : Node_Id);
 256    procedure Expand_N_Entry_Declaration          (N : Node_Id);
 257    procedure Expand_N_Protected_Body             (N : Node_Id);
 258
 259    procedure Expand_N_Protected_Type_Declaration (N : Node_Id);
 260    --  Expands protected type declarations. This results, among other things,
 261    --  in the declaration of a record type for the representation of protected
 262    --  objects and (if there are entries) in an entry service procedure. The
 263    --  Protection value used by the GNARL to control the object will always be
 264    --  the first field of the record, and the entry service procedure spec (if
 265    --  it exists) will always immediately follow the record declaration. This
 266    --  allows these two nodes to be found from the type, without benefit of
 267    --  further attributes, using Corresponding_Record.
 268
 269    procedure Expand_N_Requeue_Statement          (N : Node_Id);
 270    procedure Expand_N_Selective_Accept           (N : Node_Id);
 271    procedure Expand_N_Single_Task_Declaration    (N : Node_Id);
 272    procedure Expand_N_Task_Body                  (N : Node_Id);
 273    procedure Expand_N_Task_Type_Declaration      (N : Node_Id);
 274    procedure Expand_N_Timed_Entry_Call           (N : Node_Id);
 275
 276    procedure Expand_Protected_Body_Declarations
 277      (N       : Node_Id;
 278       Spec_Id : Entity_Id);
 279    --  Expand declarations required for a protected body. See bodies of both
 280    --  Expand_Protected_Body_Declarations and Expand_N_Protected_Body for full
 281    --  details of the nature and use of these declarations. The second argument
 282    --  is the entity for the corresponding protected type declaration.
 283
 284    function External_Subprogram (E : Entity_Id) return Entity_Id;
 285    --  return the external version of a protected operation, which locks
 286    --  the object before invoking the internal protected subprogram body.
 287
 288    function Find_Master_Scope (E : Entity_Id) return Entity_Id;
 289    --  When a type includes tasks, a master entity is created in the scope, to
 290    --  be used by the runtime during activation. In general the master is the
 291    --  immediate scope in which the type is declared, but in Ada 2005, in the
 292    --  presence of synchronized classwide interfaces, the immediate scope of
 293    --  an anonymous access type may be a transient scope, which has no run-time
 294    --  presence. In this case, the scope of the master is the innermost scope
 295    --  that comes from source.
 296
 297    function First_Protected_Operation (D : List_Id) return Node_Id;
 298    --  Given the declarations list for a protected body, find the
 299    --  first protected operation body.
 300
 301    procedure Install_Private_Data_Declarations
 302      (Loc      : Source_Ptr;
 303       Spec_Id  : Entity_Id;
 304       Conc_Typ : Entity_Id;
 305       Body_Nod : Node_Id;
 306       Decls    : List_Id;
 307       Barrier  : Boolean := False;
 308       Family   : Boolean := False);
 309    --  This routines generates several types, objects and object renamings used
 310    --  in the handling of discriminants and private components of protected and
 311    --  task types. It also generates the entry index for entry families. Formal
 312    --  Spec_Id denotes an entry, entry family or a subprogram, Conc_Typ is the
 313    --  concurrent type where Spec_Id resides, Body_Nod is the corresponding
 314    --  body of Spec_Id, Decls are the declarations of the subprogram or entry.
 315    --  Flag Barrier denotes whether the context is an entry barrier function.
 316    --  Flag Family is used in conjunction with Barrier to denote a barrier for
 317    --  an entry family.
 318    --
 319    --  The generated types, entities and renamings are:
 320    --
 321    --  * If flag Barrier is set or Spec_Id denotes a protected entry or an
 322    --    entry family, generate:
 323    --
 324    --      type prot_typVP is access prot_typV;
 325    --      _object : prot_typVP := prot_typV (_O);
 326    --
 327    --    where prot_typV is the corresponding record of a protected type and
 328    --    _O is a formal parameter representing the concurrent object of either
 329    --    the barrier function or the entry (family).
 330    --
 331    --  * If Conc_Typ is a protected type, create a renaming for the Protection
 332    --    field _object:
 333    --
 334    --      conc_typR : protection_typ renames _object._object;
 335    --
 336    --  * If Conc_Typ has discriminants, create renamings of the form:
 337    --
 338    --      discr_nameD : discr_typ renames _object.discr_name;
 339    --        or
 340    --      discr_nameD : discr_typ renames _task.discr_name;
 341    --
 342    --  * If Conc_Typ denotes a protected type and has private components,
 343    --    generate renamings of the form:
 344    --
 345    --      comp_name : comp_typ renames _object.comp_name;
 346    --
 347    --  * Finally, is flag Barrier and Family are set or Spec_Id denotes an
 348    --    entry family, generate the entry index constant:
 349    --
 350    --      subtype Jnn is <Type of Index> range Low .. High;
 351    --      J : constant Jnn :=
 352    --            Jnn'Val (_E - <Index expression> + Jnn'Pos (Jnn'First));
 353    --
 354    --  All the above declarations are inserted in the order shown to the front
 355    --  of Decls.
 356
 357    function Make_Task_Create_Call (Task_Rec : Entity_Id) return Node_Id;
 358    --  Given the entity of the record type created for a task type, build
 359    --  the call to Create_Task
 360
 361    function Make_Initialize_Protection
 362      (Protect_Rec : Entity_Id) return List_Id;
 363    --  Given the entity of the record type created for a protected type, build
 364    --  a list of statements needed for proper initialization of the object.
 365
 366    function Next_Protected_Operation (N : Node_Id) return Node_Id;
 367    --  Given a protected operation node (a subprogram or entry body), find the
 368    --  following node in the declarations list.
 369
 370    procedure Set_Discriminals (Dec : Node_Id);
 371    --  Replace discriminals in a protected type for use by the next protected
 372    --  operation on the type. Each operation needs a new set of discriminals,
 373    --  since it needs a unique renaming of the discriminant fields in the
 374    --  record used to implement the protected type.
 375
 376 end Exp_Ch9;