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-2015, 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 28with Types; use Types; 29 30package 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_Protected_Declaration (N : Node_Id); 272 procedure Expand_N_Single_Task_Declaration (N : Node_Id); 273 procedure Expand_N_Task_Body (N : Node_Id); 274 procedure Expand_N_Task_Type_Declaration (N : Node_Id); 275 procedure Expand_N_Timed_Entry_Call (N : Node_Id); 276 277 procedure Expand_Protected_Body_Declarations 278 (N : Node_Id; 279 Spec_Id : Entity_Id); 280 -- Expand declarations required for a protected body. See bodies of both 281 -- Expand_Protected_Body_Declarations and Expand_N_Protected_Body for full 282 -- details of the nature and use of these declarations. The second argument 283 -- is the entity for the corresponding protected type declaration. 284 285 function External_Subprogram (E : Entity_Id) return Entity_Id; 286 -- return the external version of a protected operation, which locks 287 -- the object before invoking the internal protected subprogram body. 288 289 function Find_Master_Scope (E : Entity_Id) return Entity_Id; 290 -- When a type includes tasks, a master entity is created in the scope, to 291 -- be used by the runtime during activation. In general the master is the 292 -- immediate scope in which the type is declared, but in Ada 2005, in the 293 -- presence of synchronized classwide interfaces, the immediate scope of 294 -- an anonymous access type may be a transient scope, which has no run-time 295 -- presence. In this case, the scope of the master is the innermost scope 296 -- that comes from source. 297 298 function First_Protected_Operation (D : List_Id) return Node_Id; 299 -- Given the declarations list for a protected body, find the 300 -- first protected operation body. 301 302 procedure Install_Private_Data_Declarations 303 (Loc : Source_Ptr; 304 Spec_Id : Entity_Id; 305 Conc_Typ : Entity_Id; 306 Body_Nod : Node_Id; 307 Decls : List_Id; 308 Barrier : Boolean := False; 309 Family : Boolean := False); 310 -- This routines generates several types, objects and object renamings used 311 -- in the handling of discriminants and private components of protected and 312 -- task types. It also generates the entry index for entry families. Formal 313 -- Spec_Id denotes an entry, entry family or a subprogram, Conc_Typ is the 314 -- concurrent type where Spec_Id resides, Body_Nod is the corresponding 315 -- body of Spec_Id, Decls are the declarations of the subprogram or entry. 316 -- Flag Barrier denotes whether the context is an entry barrier function. 317 -- Flag Family is used in conjunction with Barrier to denote a barrier for 318 -- an entry family. 319 -- 320 -- The generated types, entities and renamings are: 321 -- 322 -- * If flag Barrier is set or Spec_Id denotes a protected entry or an 323 -- entry family, generate: 324 -- 325 -- type prot_typVP is access prot_typV; 326 -- _object : prot_typVP := prot_typV (_O); 327 -- 328 -- where prot_typV is the corresponding record of a protected type and 329 -- _O is a formal parameter representing the concurrent object of either 330 -- the barrier function or the entry (family). 331 -- 332 -- * If Conc_Typ is a protected type, create a renaming for the Protection 333 -- field _object: 334 -- 335 -- conc_typR : protection_typ renames _object._object; 336 -- 337 -- * If Conc_Typ has discriminants, create renamings of the form: 338 -- 339 -- discr_nameD : discr_typ renames _object.discr_name; 340 -- or 341 -- discr_nameD : discr_typ renames _task.discr_name; 342 -- 343 -- * If Conc_Typ denotes a protected type and has private components, 344 -- generate renamings of the form: 345 -- 346 -- comp_name : comp_typ renames _object.comp_name; 347 -- 348 -- * Finally, is flag Barrier and Family are set or Spec_Id denotes an 349 -- entry family, generate the entry index constant: 350 -- 351 -- subtype Jnn is <Type of Index> range Low .. High; 352 -- J : constant Jnn := 353 -- Jnn'Val (_E - <Index expression> + Jnn'Pos (Jnn'First)); 354 -- 355 -- All the above declarations are inserted in the order shown to the front 356 -- of Decls. 357 358 function Make_Task_Create_Call (Task_Rec : Entity_Id) return Node_Id; 359 -- Given the entity of the record type created for a task type, build 360 -- the call to Create_Task 361 362 function Make_Initialize_Protection 363 (Protect_Rec : Entity_Id) return List_Id; 364 -- Given the entity of the record type created for a protected type, build 365 -- a list of statements needed for proper initialization of the object. 366 367 function Next_Protected_Operation (N : Node_Id) return Node_Id; 368 -- Given a protected operation node (a subprogram or entry body), find the 369 -- following node in the declarations list. 370 371 procedure Set_Discriminals (Dec : Node_Id); 372 -- Replace discriminals in a protected type for use by the next protected 373 -- operation on the type. Each operation needs a new set of discriminals, 374 -- since it needs a unique renaming of the discriminant fields in the 375 -- record used to implement the protected type. 376 377end Exp_Ch9; 378