1 ------------------------------------------------------------------------------
3 -- GNAT COMPILER COMPONENTS --
9 -- Copyright (C) 1992-2008, Free Software Foundation, Inc. --
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. --
21 -- GNAT was originally developed by the GNAT team at New York University. --
22 -- Extensive contributions were provided by Ada Core Technologies Inc. --
24 ------------------------------------------------------------------------------
26 -- Expand routines for chapter 9 constructs
28 with Types
; use Types
;
32 type Subprogram_Protection_Mode
is
36 -- This type is used to distinguish the different protection modes of a
37 -- protected subprogram.
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.
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.
53 function Build_Corresponding_Record
56 Loc
: Source_Ptr
) return Node_Id
;
57 -- Common to tasks and protected types. Copy discriminant specifications,
58 -- build record declaration. N is the type declaration, Ctyp is the
59 -- concurrent entity (task type or protected type).
61 function Build_Entry_Names
(Conc_Typ
: Entity_Id
) return Node_Id
;
62 -- Create the statements which populate the entry names array of a task or
63 -- protected type. The statements are wrapped inside a block due to a local
66 procedure Build_Master_Entity
(E
: Entity_Id
);
67 -- Given an entity E for the declaration of an object containing tasks
68 -- or of a type declaration for an allocator whose designated type is a
69 -- task or contains tasks, this routine marks the appropriate enclosing
70 -- context as a master, and also declares a variable called _Master in
71 -- the current declarative part which captures the value of Current_Master
72 -- (if not already built by a prior call). We build this object (instead
73 -- of just calling Current_Master) for two reasons. First it is clearly
74 -- more efficient to call Current_Master only once for a bunch of tasks
75 -- in the same declarative part, and second it makes things easier in
76 -- generating the initialization routines, since they can just reference
77 -- the object _Master by name, and they will get the proper Current_Master
78 -- value at the outer level, and copy in the parameter value for the outer
79 -- initialization call if the call is for a nested component). Note that
80 -- in the case of nested packages, we only really need to make one such
81 -- object at the outer level, but it is much easier to generate one per
84 function Build_Protected_Sub_Specification
87 Mode
: Subprogram_Protection_Mode
) return Node_Id
;
88 -- Build the specification for protected subprogram. This is called when
89 -- expanding a protected type, and also when expanding the declaration for
90 -- an Access_To_Protected_Subprogram type. In the latter case, Prot_Typ is
91 -- empty, and the first parameter of the signature of the protected op is
92 -- of type System.Address.
94 procedure Build_Protected_Subprogram_Call
98 External
: Boolean := True);
99 -- The node N is a subprogram or entry call to a protected subprogram.
100 -- This procedure rewrites this call with the appropriate expansion.
101 -- Name is the subprogram, and Rec is the record corresponding to the
102 -- protected object. External is False if the call is to another
103 -- protected subprogram within the same object.
105 procedure Build_Task_Activation_Call
(N
: Node_Id
);
106 -- This procedure is called for constructs that can be task activators
107 -- i.e. task bodies, subprogram bodies, package bodies and blocks. If
108 -- the construct is a task activator (as indicated by the non-empty
109 -- setting of Activation_Chain_Entity, either in the construct, or, in
110 -- the case of a package body, in its associated package spec), then
111 -- a call to Activate_Tasks with this entity as the single parameter
112 -- is inserted at the start of the statements of the activator.
114 procedure Build_Task_Allocate_Block
118 -- This routine is used in the case of allocators where the designated
119 -- type is a task or contains tasks. In this case, the normal initialize
120 -- call is replaced by:
122 -- blockname : label;
123 -- blockname : declare
124 -- _Chain : Activation_Chain;
126 -- procedure _Expunge is
128 -- Expunge_Unactivated_Tasks (_Chain);
133 -- Activate_Tasks (_Chain);
138 -- to get the task or tasks created and initialized. The expunge call
139 -- ensures that any tasks that get created but not activated due to an
140 -- exception are properly expunged (it has no effect in the normal case)
141 -- The argument N is the allocator, and Args is the list of arguments
142 -- for the initialization call, constructed by the caller, which uses
143 -- the Master_Id of the access type as the _Master parameter, and _Chain
144 -- (defined above) as the _Chain parameter.
146 procedure Build_Task_Allocate_Block_With_Init_Stmts
149 Init_Stmts
: List_Id
);
150 -- Ada 2005 (AI-287): Similar to previous routine, but used to expand
151 -- allocated aggregates with default initialized components. Init_Stmts
152 -- contains the list of statements required to initialize the allocated
153 -- aggregate. It replaces the call to Init (Args) done by
154 -- Build_Task_Allocate_Block.
156 function Concurrent_Ref
(N
: Node_Id
) return Node_Id
;
157 -- Given the name of a concurrent object (task or protected object), or
158 -- the name of an access to a concurrent object, this function returns an
159 -- expression referencing the associated Task_Id or Protection object,
160 -- respectively. Note that a special case is when the name is a reference
161 -- to a task type name. This can only happen within a task body, and the
162 -- meaning is to get the Task_Id for the currently executing task.
164 function Convert_Concurrent
166 Typ
: Entity_Id
) return Node_Id
;
167 -- N is an expression of type Typ. If the type is not a concurrent type
168 -- then it is returned unchanged. If it is a task or protected reference,
169 -- Convert_Concurrent creates an unchecked conversion node from this
170 -- expression to the corresponding concurrent record type value. We need
171 -- this in any situation where the concurrent type is used, because the
172 -- actual concurrent object is an object of the corresponding concurrent
173 -- type, and manipulations on the concurrent object actually manipulate the
174 -- corresponding object of the record type.
176 function Entry_Index_Expression
182 -- Returns an expression to compute a task entry index given the name
183 -- of the entry or entry family. For the case of a task entry family,
184 -- the Index parameter contains the expression for the subscript.
185 -- Ttyp is the task type.
187 procedure Establish_Task_Master
(N
: Node_Id
);
188 -- Given a subprogram body, or a block statement, or a task body, this
189 -- procedure makes the necessary transformations required of a task
190 -- master (add Enter_Master call at start, and establish a cleanup
191 -- routine to make sure Complete_Master is called on exit).
193 procedure Expand_Access_Protected_Subprogram_Type
(N
: Node_Id
);
194 -- Build Equivalent_Type for an Access_to_protected_Subprogram
196 procedure Expand_Accept_Declarations
(N
: Node_Id
; Ent
: Entity_Id
);
197 -- Expand declarations required for accept statement. See bodies of
198 -- both Expand_Accept_Declarations and Expand_N_Accept_Statement for
199 -- full details of the nature and use of these declarations, which
200 -- are inserted immediately before the accept node N. The second
201 -- argument is the entity for the corresponding entry.
203 procedure Expand_Entry_Barrier
(N
: Node_Id
; Ent
: Entity_Id
);
204 -- Expand the entry barrier into a function. This is called directly
205 -- from Analyze_Entry_Body so that the discriminals and privals of the
206 -- barrier can be attached to the function declaration list, and a new
207 -- set prepared for the entry body procedure, before the entry body
208 -- statement sequence can be expanded. The resulting function is analyzed
209 -- now, within the context of the protected object, to resolve calls to
210 -- other protected functions.
212 procedure Expand_N_Abort_Statement
(N
: Node_Id
);
213 procedure Expand_N_Accept_Statement
(N
: Node_Id
);
214 procedure Expand_N_Asynchronous_Select
(N
: Node_Id
);
215 procedure Expand_N_Conditional_Entry_Call
(N
: Node_Id
);
216 procedure Expand_N_Delay_Relative_Statement
(N
: Node_Id
);
217 procedure Expand_N_Delay_Until_Statement
(N
: Node_Id
);
218 procedure Expand_N_Entry_Body
(N
: Node_Id
);
219 procedure Expand_N_Entry_Call_Statement
(N
: Node_Id
);
220 procedure Expand_N_Entry_Declaration
(N
: Node_Id
);
221 procedure Expand_N_Protected_Body
(N
: Node_Id
);
223 procedure Expand_N_Protected_Type_Declaration
(N
: Node_Id
);
224 -- Expands protected type declarations. This results, among other things,
225 -- in the declaration of a record type for the representation of protected
226 -- objects and (if there are entries) in an entry service procedure. The
227 -- Protection value used by the GNARL to control the object will always be
228 -- the first field of the record, and the entry service procedure spec (if
229 -- it exists) will always immediately follow the record declaration. This
230 -- allows these two nodes to be found from the type, without benefit of
231 -- further attributes, using Corresponding_Record.
233 procedure Expand_N_Requeue_Statement
(N
: Node_Id
);
234 procedure Expand_N_Selective_Accept
(N
: Node_Id
);
235 procedure Expand_N_Single_Task_Declaration
(N
: Node_Id
);
236 procedure Expand_N_Task_Body
(N
: Node_Id
);
237 procedure Expand_N_Task_Type_Declaration
(N
: Node_Id
);
238 procedure Expand_N_Timed_Entry_Call
(N
: Node_Id
);
240 procedure Expand_Protected_Body_Declarations
242 Spec_Id
: Entity_Id
);
243 -- Expand declarations required for a protected body. See bodies of both
244 -- Expand_Protected_Body_Declarations and Expand_N_Protected_Body for full
245 -- details of the nature and use of these declarations. The second argument
246 -- is the entity for the corresponding protected type declaration.
248 function External_Subprogram
(E
: Entity_Id
) return Entity_Id
;
249 -- return the external version of a protected operation, which locks
250 -- the object before invoking the internal protected subprogram body.
252 function First_Protected_Operation
(D
: List_Id
) return Node_Id
;
253 -- Given the declarations list for a protected body, find the
254 -- first protected operation body.
256 procedure Install_Private_Data_Declarations
259 Conc_Typ
: Entity_Id
;
262 Barrier
: Boolean := False;
263 Family
: Boolean := False);
264 -- This routines generates several types, objects and object renamings used
265 -- in the handling of discriminants and private components of protected and
266 -- task types. It also generates the entry index for entry families. Formal
267 -- Spec_Id denotes an entry, entry family or a subprogram, Conc_Typ is the
268 -- concurrent type where Spec_Id resides, Body_Nod is the corresponding
269 -- body of Spec_Id, Decls are the declarations of the subprogram or entry.
270 -- Flag Barrier denotes whether the context is an entry barrier function.
271 -- Flag Family is used in conjunction with Barrier to denote a barrier for
274 -- The generated types, entities and renamings are:
276 -- * If flag Barrier is set or Spec_Id denotes a protected entry or an
277 -- entry family, generate:
279 -- type prot_typVP is access prot_typV;
280 -- _object : prot_typVP := prot_typV (_O);
282 -- where prot_typV is the corresponding record of a protected type and
283 -- _O is a formal parameter representing the concurrent object of either
284 -- the barrier function or the entry (family).
286 -- * If Conc_Typ is a protected type, create a renaming for the Protection
289 -- conc_typR : protection_typ renames _object._object;
291 -- * If Conc_Typ has discriminants, create renamings of the form:
293 -- discr_nameD : discr_typ renames _object.discr_name;
295 -- discr_nameD : discr_typ renames _task.discr_name;
297 -- * If Conc_Typ denotes a protected type and has private components,
298 -- generate renamings of the form:
300 -- comp_name : comp_typ renames _object.comp_name;
302 -- * Finally, is flag Barrier and Family are set or Spec_Id denotes an
303 -- entry family, generate the entry index constant:
305 -- subtype Jnn is <Type of Index> range Low .. High;
306 -- J : constant Jnn :=
307 -- Jnn'Val (_E - <Index expression> + Jnn'Pos (Jnn'First));
309 -- All the above declarations are inserted in the order shown to the front
312 function Make_Task_Create_Call
(Task_Rec
: Entity_Id
) return Node_Id
;
313 -- Given the entity of the record type created for a task type, build
314 -- the call to Create_Task
316 function Make_Initialize_Protection
317 (Protect_Rec
: Entity_Id
) return List_Id
;
318 -- Given the entity of the record type created for a protected type, build
319 -- a list of statements needed for proper initialization of the object.
321 function Next_Protected_Operation
(N
: Node_Id
) return Node_Id
;
322 -- Given a protected operation node (a subprogram or entry body), find the
323 -- following node in the declarations list.
325 procedure Set_Discriminals
(Dec
: Node_Id
);
326 -- Replace discriminals in a protected type for use by the next protected
327 -- operation on the type. Each operation needs a new set of discriminals,
328 -- since it needs a unique renaming of the discriminant fields in the
329 -- record used to implement the protected type.