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