1 ------------------------------------------------------------------------------
3 -- GNAT COMPILER COMPONENTS --
9 -- Copyright (C) 1992-2006, 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 2, 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 COPYING. If not, write --
19 -- to the Free Software Foundation, 51 Franklin Street, Fifth Floor, --
20 -- Boston, MA 02110-1301, USA. --
22 -- GNAT was originally developed by the GNAT team at New York University. --
23 -- Extensive contributions were provided by Ada Core Technologies Inc. --
25 ------------------------------------------------------------------------------
27 -- Expand routines for chapter 9 constructs
29 with Types; use Types;
33 type Subprogram_Protection_Mode is
37 -- This type is used to distinguish the different protection modes of a
38 -- protected subprogram.
40 procedure Add_Discriminal_Declarations
45 -- This routine is used to add discriminal declarations to task and
46 -- protected operation bodies. The discriminants are available by normal
47 -- selection from the concurrent object (whose name is passed as the third
48 -- parameter). Discriminant references inside the body have already
49 -- been replaced by references to the corresponding discriminals. The
50 -- declarations constructed by this procedure hook the references up with
53 -- discriminal_name : discr_type renames name.discriminant_name;
55 -- Obviously we could have expanded the discriminant references in the
56 -- first place to be the appropriate selection, but this turns out to
57 -- be hard to do because it would introduce difference in handling of
58 -- discriminant references depending on their location.
60 procedure Add_Private_Declarations
65 -- This routine is used to add private declarations to protected bodies.
66 -- These are analogous to the discriminal declarations added to tasks
67 -- and protected operations, and consist of a renaming of each private
68 -- object to a selection from the concurrent object passed as an extra
69 -- parameter to each such operation:
70 -- private_name : private_type renames name.private_name;
71 -- As with discriminals, private references inside the protected
72 -- subprogram bodies have already been replaced by references to the
73 -- corresponding privals.
75 procedure Build_Activation_Chain_Entity (N : Node_Id);
76 -- Given a declaration N of an object that is a task, or contains tasks
77 -- (other than allocators to tasks) this routine ensures that an activation
78 -- chain has been declared in the appropriate scope, building the required
79 -- declaration for the chain variable if not. The name of this variable
80 -- is always _Chain and it is accessed by name.
82 function Build_Call_With_Task (N : Node_Id; E : Entity_Id) return Node_Id;
83 -- N is a node representing the name of a task or an access to a task.
84 -- The value returned is a call to the function whose name is the entity
85 -- E (typically a runtime routine entity obtained using RTE) with the
86 -- Task_Id of the associated task as the parameter. The caller is
87 -- responsible for analyzing and resolving the resulting tree.
89 procedure Build_Master_Entity (E : Entity_Id);
90 -- Given an entity E for the declaration of an object containing tasks
91 -- or of a type declaration for an allocator whose designated type is a
92 -- task or contains tasks, this routine marks the appropriate enclosing
93 -- context as a master, and also declares a variable called _Master in
94 -- the current declarative part which captures the value of Current_Master
95 -- (if not already built by a prior call). We build this object (instead
96 -- of just calling Current_Master) for two reasons. First it is clearly
97 -- more efficient to call Current_Master only once for a bunch of tasks
98 -- in the same declarative part, and second it makes things easier in
99 -- generating the initialization routines, since they can just reference
100 -- the object _Master by name, and they will get the proper Current_Master
101 -- value at the outer level, and copy in the parameter value for the outer
102 -- initialization call if the call is for a nested component). Note that
103 -- in the case of nested packages, we only really need to make one such
104 -- object at the outer level, but it is much easier to generate one per
107 function Build_Protected_Sub_Specification
110 Mode : Subprogram_Protection_Mode) return Node_Id;
111 -- Build specification for protected subprogram. This is called when
112 -- expanding a protected type, and also when expanding the declaration for
113 -- an Access_To_Protected_Subprogram type. In the latter case, Prottyp is
114 -- empty, and the first parameter of the signature of the protected op is
115 -- of type System.Address.
117 procedure Build_Protected_Subprogram_Call
121 External : Boolean := True);
122 -- The node N is a subprogram or entry call to a protected subprogram.
123 -- This procedure rewrites this call with the appropriate expansion.
124 -- Name is the subprogram, and Rec is the record corresponding to the
125 -- protected object. External is False if the call is to another
126 -- protected subprogram within the same object.
128 procedure Build_Task_Activation_Call (N : Node_Id);
129 -- This procedure is called for constructs that can be task activators
130 -- i.e. task bodies, subprogram bodies, package bodies and blocks. If
131 -- the construct is a task activator (as indicated by the non-empty
132 -- setting of Activation_Chain_Entity, either in the construct, or, in
133 -- the case of a package body, in its associated package spec), then
134 -- a call to Activate_Tasks with this entity as the single parameter
135 -- is inserted at the start of the statements of the activator.
137 procedure Build_Task_Allocate_Block
141 -- This routine is used in the case of allocators where the designated
142 -- type is a task or contains tasks. In this case, the normal initialize
143 -- call is replaced by:
145 -- blockname : label;
146 -- blockname : declare
147 -- _Chain : Activation_Chain;
149 -- procedure _Expunge is
151 -- Expunge_Unactivated_Tasks (_Chain);
156 -- Activate_Tasks (_Chain);
161 -- to get the task or tasks created and initialized. The expunge call
162 -- ensures that any tasks that get created but not activated due to an
163 -- exception are properly expunged (it has no effect in the normal case)
164 -- The argument N is the allocator, and Args is the list of arguments
165 -- for the initialization call, constructed by the caller, which uses
166 -- the Master_Id of the access type as the _Master parameter, and _Chain
167 -- (defined above) as the _Chain parameter.
169 procedure Build_Task_Allocate_Block_With_Init_Stmts
172 Init_Stmts : List_Id);
173 -- Ada 2005 (AI-287): Similar to previous routine, but used to expand
174 -- allocated aggregates with default initialized components. Init_Stmts
175 -- contains the list of statements required to initialize the allocated
176 -- aggregate. It replaces the call to Init (Args) done by
177 -- Build_Task_Allocate_Block.
179 function Concurrent_Ref (N : Node_Id) return Node_Id;
180 -- Given the name of a concurrent object (task or protected object), or
181 -- the name of an access to a concurrent object, this function returns an
182 -- expression referencing the associated Task_Id or Protection object,
183 -- respectively. Note that a special case is when the name is a reference
184 -- to a task type name. This can only happen within a task body, and the
185 -- meaning is to get the Task_Id for the currently executing task.
187 function Convert_Concurrent
191 -- N is an expression of type Typ. If the type is not a concurrent
192 -- type then it is returned unchanged. If it is a task or protected
193 -- reference, Convert_Concurrent creates an unchecked conversion node
194 -- from this expression to the corresponding concurrent record type
195 -- value. We need this in any situation where the concurrent type is
196 -- used, because the actual concurrent object is an object of the
197 -- corresponding concurrent type, and manipulations on the concurrent
198 -- object actually manipulate the corresponding object of the record
201 function Entry_Index_Expression
207 -- Returns an expression to compute a task entry index given the name
208 -- of the entry or entry family. For the case of a task entry family,
209 -- the Index parameter contains the expression for the subscript.
210 -- Ttyp is the task type.
212 procedure Establish_Task_Master (N : Node_Id);
213 -- Given a subprogram body, or a block statement, or a task body, this
214 -- proccedure makes the necessary transformations required of a task
215 -- master (add Enter_Master call at start, and establish a cleanup
216 -- routine to make sure Complete_Master is called on exit).
218 procedure Expand_Access_Protected_Subprogram_Type (N : Node_Id);
219 -- Build Equivalent_Type for an Access_to_protected_Subprogram
221 procedure Expand_Accept_Declarations (N : Node_Id; Ent : Entity_Id);
222 -- Expand declarations required for accept statement. See bodies of
223 -- both Expand_Accept_Declarations and Expand_N_Accept_Statement for
224 -- full details of the nature and use of these declarations, which
225 -- are inserted immediately before the accept node N. The second
226 -- argument is the entity for the corresponding entry.
228 procedure Expand_Entry_Barrier (N : Node_Id; Ent : Entity_Id);
229 -- Expand the entry barrier into a function. This is called directly
230 -- from Analyze_Entry_Body so that the discriminals and privals of the
231 -- barrier can be attached to the function declaration list, and a new
232 -- set prepared for the entry body procedure, bedore the entry body
233 -- statement sequence can be expanded. The resulting function is analyzed
234 -- now, within the context of the protected object, to resolve calls to
235 -- other protected functions.
237 procedure Expand_Entry_Body_Declarations (N : Node_Id);
238 -- Expand declarations required for the expansion of the
239 -- statements of the body.
241 procedure Expand_N_Abort_Statement (N : Node_Id);
242 procedure Expand_N_Accept_Statement (N : Node_Id);
243 procedure Expand_N_Asynchronous_Select (N : Node_Id);
244 procedure Expand_N_Conditional_Entry_Call (N : Node_Id);
245 procedure Expand_N_Delay_Relative_Statement (N : Node_Id);
246 procedure Expand_N_Delay_Until_Statement (N : Node_Id);
247 procedure Expand_N_Entry_Body (N : Node_Id);
248 procedure Expand_N_Entry_Call_Statement (N : Node_Id);
249 procedure Expand_N_Entry_Declaration (N : Node_Id);
250 procedure Expand_N_Protected_Body (N : Node_Id);
252 procedure Expand_N_Protected_Type_Declaration (N : Node_Id);
253 -- Expands protected type declarations. This results, among
254 -- other things, in the declaration of a record type for the
255 -- representation of protected objects and (if there are entries)
256 -- in an entry service procedure. The Protection value used by
257 -- the GNARL to control the object will always be the first
258 -- field of the record, and the entry service procedure spec
259 -- (if it exists) will always immediately follow the record
260 -- declaration. This allows these two nodes to be found from
261 -- the type using Corresponding_Record, without benefit of
262 -- of further attributes.
264 procedure Expand_N_Requeue_Statement (N : Node_Id);
265 procedure Expand_N_Selective_Accept (N : Node_Id);
266 procedure Expand_N_Single_Task_Declaration (N : Node_Id);
267 procedure Expand_N_Task_Body (N : Node_Id);
268 procedure Expand_N_Task_Type_Declaration (N : Node_Id);
269 procedure Expand_N_Timed_Entry_Call (N : Node_Id);
271 procedure Expand_Protected_Body_Declarations
273 Spec_Id : Entity_Id);
274 -- Expand declarations required for a protected body. See bodies of
275 -- both Expand_Protected_Body_Declarations and Expand_N_Protected_Body
276 -- for full details of the nature and use of these declarations.
277 -- The second argument is the entity for the corresponding
278 -- protected type declaration.
280 function External_Subprogram (E : Entity_Id) return Entity_Id;
281 -- return the external version of a protected operation, which locks
282 -- the object before invoking the internal protected subprogram body.
284 function First_Protected_Operation (D : List_Id) return Node_Id;
285 -- Given the declarations list for a protected body, find the
286 -- first protected operation body.
288 function Make_Task_Create_Call (Task_Rec : Entity_Id) return Node_Id;
289 -- Given the entity of the record type created for a task type, build
290 -- the call to Create_Task
292 function Make_Initialize_Protection
293 (Protect_Rec : Entity_Id)
295 -- Given the entity of the record type created for a protected type, build
296 -- a list of statements needed for proper initialization of the object.
298 function Next_Protected_Operation (N : Node_Id) return Node_Id;
299 -- Given a protected operation node (a subprogram or entry body),
300 -- find the following node in the declarations list.
302 procedure Set_Discriminals (Dec : Node_Id);
303 -- Replace discriminals in a protected type for use by the
304 -- next protected operation on the type. Each operation needs a
305 -- new set of discirminals, since it needs a unique renaming of
306 -- the discriminant fields in the record used to implement the
309 procedure Set_Privals
313 After_Barrier : Boolean := False);
314 -- Associates a new set of privals (placeholders for later access to
315 -- private components of protected objects) with the private object
316 -- declarations of a protected object. These will be used to expand
317 -- the references to private objects in the next protected
318 -- subprogram or entry body to be expanded.
320 -- The flag After_Barrier indicates whether this is called after building
321 -- the barrier function for an entry body. This flag determines whether
322 -- the privals should have source names (which simplifies debugging) or
323 -- internally generated names. Entry barriers contain no debuggable code,
324 -- and there may be visibility conflicts between an entry index and a
325 -- a prival, so privals for barrier function have internal names.