File : 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-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
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_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
377 end Exp_Ch9;