OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [gcc-4.5.1/] [gcc/] [ada/] [exp_ch9.ads] - Blame information for rev 826

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.