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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.5.1/] [gcc/] [ada/] [expander.adb] - Blame information for rev 281

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 281 jeremybenn
------------------------------------------------------------------------------
2
--                                                                          --
3
--                         GNAT COMPILER COMPONENTS                         --
4
--                                                                          --
5
--                             E X P A N D E R                              --
6
--                                                                          --
7
--                                 B o d y                                  --
8
--                                                                          --
9
--          Copyright (C) 1992-2008, 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
with Atree;     use Atree;
27
with Debug_A;   use Debug_A;
28
with Errout;    use Errout;
29
with Exp_Aggr;  use Exp_Aggr;
30
with Exp_Attr;  use Exp_Attr;
31
with Exp_Ch2;   use Exp_Ch2;
32
with Exp_Ch3;   use Exp_Ch3;
33
with Exp_Ch4;   use Exp_Ch4;
34
with Exp_Ch5;   use Exp_Ch5;
35
with Exp_Ch6;   use Exp_Ch6;
36
with Exp_Ch7;   use Exp_Ch7;
37
with Exp_Ch8;   use Exp_Ch8;
38
with Exp_Ch9;   use Exp_Ch9;
39
with Exp_Ch11;  use Exp_Ch11;
40
with Exp_Ch12;  use Exp_Ch12;
41
with Exp_Ch13;  use Exp_Ch13;
42
with Exp_Prag;  use Exp_Prag;
43
with Opt;       use Opt;
44
with Rtsfind;   use Rtsfind;
45
with Sem;       use Sem;
46
with Sem_Ch8;   use Sem_Ch8;
47
with Sem_Util;  use Sem_Util;
48
with Sinfo;     use Sinfo;
49
with Table;
50
 
51
package body Expander is
52
 
53
   ----------------
54
   -- Local Data --
55
   ----------------
56
 
57
   --  The following table is used to save values of the Expander_Active flag
58
   --  when they are saved by Expander_Mode_Save_And_Set. We use an extendible
59
   --  table (which is a bit of overkill) because it is easier than figuring
60
   --  out a maximum value or bothering with range checks!
61
 
62
   package Expander_Flags is new Table.Table (
63
     Table_Component_Type => Boolean,
64
     Table_Index_Type     => Int,
65
     Table_Low_Bound      => 0,
66
     Table_Initial        => 32,
67
     Table_Increment      => 200,
68
     Table_Name           => "Expander_Flags");
69
 
70
   ------------
71
   -- Expand --
72
   ------------
73
 
74
   procedure Expand (N : Node_Id) is
75
   begin
76
      --  If we were analyzing a default expression (or other spec expression)
77
      --  the Full_Analysis flag must be off. If we are in expansion mode then
78
      --  we must be performing a full analysis. If we are analyzing a generic
79
      --  then Expansion must be off.
80
 
81
      pragma Assert
82
        (not (Full_Analysis and then In_Spec_Expression)
83
          and then (Full_Analysis or else not Expander_Active)
84
          and then not (Inside_A_Generic and then Expander_Active));
85
 
86
      --  There are three reasons for the Expander_Active flag to be false
87
      --
88
      --  The first is when are not generating code. In this mode the
89
      --  Full_Analysis flag indicates whether we are performing a complete
90
      --  analysis, in which case Full_Analysis = True or a pre-analysis in
91
      --  which case Full_Analysis = False. See the spec of Sem for more
92
      --  info on this.
93
      --
94
      --  The second reason for the Expander_Active flag to be False is that
95
      --  we are performing a pre-analysis. During pre-analysis all expansion
96
      --  activity is turned off to make sure nodes are semantically decorated
97
      --  but no extra nodes are generated. This is for instance needed for
98
      --  the first pass of aggregate semantic processing. Note that in this
99
      --  case the Full_Analysis flag is set to False because the node will
100
      --  subsequently be re-analyzed with expansion on (see the spec of sem).
101
 
102
      --  Finally, expansion is turned off in a regular compilation if there
103
      --  are serious errors. In that case there will be no further expansion,
104
      --  but one cleanup action may be required: if a transient scope was
105
      --  created (e.g. for a function that returns an unconstrained type) the
106
      --  scope may still be on the stack, and must be removed explicitly,
107
      --  given that the expansion actions that would normally process it will
108
      --  not take place. This prevents cascaded errors due to stack mismatch.
109
 
110
      if not Expander_Active then
111
         Set_Analyzed (N, Full_Analysis);
112
 
113
         if Serious_Errors_Detected > 0
114
           and then Scope_Is_Transient
115
         then
116
            Scope_Stack.Table
117
             (Scope_Stack.Last).Actions_To_Be_Wrapped_Before := No_List;
118
            Scope_Stack.Table
119
             (Scope_Stack.Last).Actions_To_Be_Wrapped_After  := No_List;
120
 
121
            Pop_Scope;
122
         end if;
123
 
124
         return;
125
 
126
      else
127
         Debug_A_Entry ("expanding  ", N);
128
 
129
         --  Processing depends on node kind. For full details on the expansion
130
         --  activity required in each case, see bodies of corresponding expand
131
         --  routines.
132
 
133
         begin
134
            case Nkind (N) is
135
 
136
               when N_Abort_Statement =>
137
                  Expand_N_Abort_Statement (N);
138
 
139
               when N_Accept_Statement =>
140
                  Expand_N_Accept_Statement (N);
141
 
142
               when N_Aggregate =>
143
                  Expand_N_Aggregate (N);
144
 
145
               when N_Allocator =>
146
                  Expand_N_Allocator (N);
147
 
148
               when N_And_Then =>
149
                  Expand_N_And_Then (N);
150
 
151
               when N_Assignment_Statement =>
152
                  Expand_N_Assignment_Statement (N);
153
 
154
               when N_Asynchronous_Select =>
155
                  Expand_N_Asynchronous_Select (N);
156
 
157
               when N_Attribute_Definition_Clause =>
158
                  Expand_N_Attribute_Definition_Clause (N);
159
 
160
               when N_Attribute_Reference =>
161
                  Expand_N_Attribute_Reference (N);
162
 
163
               when N_Block_Statement =>
164
                  Expand_N_Block_Statement (N);
165
 
166
               when N_Case_Statement =>
167
                  Expand_N_Case_Statement (N);
168
 
169
               when N_Conditional_Entry_Call =>
170
                  Expand_N_Conditional_Entry_Call (N);
171
 
172
               when N_Conditional_Expression =>
173
                  Expand_N_Conditional_Expression (N);
174
 
175
               when N_Delay_Relative_Statement =>
176
                  Expand_N_Delay_Relative_Statement (N);
177
 
178
               when N_Delay_Until_Statement =>
179
                  Expand_N_Delay_Until_Statement (N);
180
 
181
               when N_Entry_Body =>
182
                  Expand_N_Entry_Body (N);
183
 
184
               when N_Entry_Call_Statement =>
185
                  Expand_N_Entry_Call_Statement (N);
186
 
187
               when N_Entry_Declaration =>
188
                  Expand_N_Entry_Declaration (N);
189
 
190
               when N_Exception_Declaration =>
191
                  Expand_N_Exception_Declaration (N);
192
 
193
               when N_Exception_Renaming_Declaration =>
194
                  Expand_N_Exception_Renaming_Declaration (N);
195
 
196
               when N_Exit_Statement =>
197
                  Expand_N_Exit_Statement (N);
198
 
199
               when N_Expanded_Name =>
200
                  Expand_N_Expanded_Name (N);
201
 
202
               when N_Explicit_Dereference =>
203
                  Expand_N_Explicit_Dereference (N);
204
 
205
               when N_Extended_Return_Statement =>
206
                  Expand_N_Extended_Return_Statement (N);
207
 
208
               when N_Extension_Aggregate =>
209
                  Expand_N_Extension_Aggregate (N);
210
 
211
               when N_Freeze_Entity =>
212
                  Expand_N_Freeze_Entity (N);
213
 
214
               when N_Full_Type_Declaration =>
215
                  Expand_N_Full_Type_Declaration (N);
216
 
217
               when N_Function_Call =>
218
                  Expand_N_Function_Call (N);
219
 
220
               when N_Generic_Instantiation =>
221
                  Expand_N_Generic_Instantiation (N);
222
 
223
               when N_Goto_Statement =>
224
                  Expand_N_Goto_Statement (N);
225
 
226
               when N_Handled_Sequence_Of_Statements =>
227
                  Expand_N_Handled_Sequence_Of_Statements (N);
228
 
229
               when N_Identifier =>
230
                  Expand_N_Identifier (N);
231
 
232
               when N_Indexed_Component =>
233
                  Expand_N_Indexed_Component (N);
234
 
235
               when N_If_Statement =>
236
                  Expand_N_If_Statement (N);
237
 
238
               when N_In =>
239
                  Expand_N_In (N);
240
 
241
               when N_Loop_Statement =>
242
                  Expand_N_Loop_Statement (N);
243
 
244
               when N_Not_In =>
245
                  Expand_N_Not_In (N);
246
 
247
               when N_Null =>
248
                  Expand_N_Null (N);
249
 
250
               when N_Object_Declaration =>
251
                  Expand_N_Object_Declaration (N);
252
 
253
               when N_Object_Renaming_Declaration =>
254
                  Expand_N_Object_Renaming_Declaration (N);
255
 
256
               when N_Op_Add =>
257
                  Expand_N_Op_Add (N);
258
 
259
               when N_Op_Abs =>
260
                  Expand_N_Op_Abs (N);
261
 
262
               when N_Op_And =>
263
                  Expand_N_Op_And (N);
264
 
265
               when N_Op_Concat =>
266
                  Expand_N_Op_Concat (N);
267
 
268
               when N_Op_Divide =>
269
                  Expand_N_Op_Divide (N);
270
 
271
               when N_Op_Eq =>
272
                  Expand_N_Op_Eq (N);
273
 
274
               when N_Op_Expon =>
275
                  Expand_N_Op_Expon (N);
276
 
277
               when N_Op_Ge =>
278
                  Expand_N_Op_Ge (N);
279
 
280
               when N_Op_Gt =>
281
                  Expand_N_Op_Gt (N);
282
 
283
               when N_Op_Le =>
284
                  Expand_N_Op_Le (N);
285
 
286
               when N_Op_Lt =>
287
                  Expand_N_Op_Lt (N);
288
 
289
               when N_Op_Minus =>
290
                  Expand_N_Op_Minus (N);
291
 
292
               when N_Op_Mod =>
293
                  Expand_N_Op_Mod (N);
294
 
295
               when N_Op_Multiply =>
296
                  Expand_N_Op_Multiply (N);
297
 
298
               when N_Op_Ne =>
299
                  Expand_N_Op_Ne (N);
300
 
301
               when N_Op_Not =>
302
                  Expand_N_Op_Not (N);
303
 
304
               when N_Op_Or =>
305
                  Expand_N_Op_Or (N);
306
 
307
               when N_Op_Plus =>
308
                  Expand_N_Op_Plus (N);
309
 
310
               when N_Op_Rem =>
311
                  Expand_N_Op_Rem (N);
312
 
313
               when N_Op_Rotate_Left =>
314
                  Expand_N_Op_Rotate_Left (N);
315
 
316
               when N_Op_Rotate_Right =>
317
                  Expand_N_Op_Rotate_Right (N);
318
 
319
               when N_Op_Shift_Left =>
320
                  Expand_N_Op_Shift_Left (N);
321
 
322
               when N_Op_Shift_Right =>
323
                  Expand_N_Op_Shift_Right (N);
324
 
325
               when N_Op_Shift_Right_Arithmetic =>
326
                  Expand_N_Op_Shift_Right_Arithmetic (N);
327
 
328
               when N_Op_Subtract =>
329
                  Expand_N_Op_Subtract (N);
330
 
331
               when N_Op_Xor =>
332
                  Expand_N_Op_Xor (N);
333
 
334
               when N_Or_Else =>
335
                  Expand_N_Or_Else (N);
336
 
337
               when N_Package_Body =>
338
                  Expand_N_Package_Body (N);
339
 
340
               when N_Package_Declaration =>
341
                  Expand_N_Package_Declaration (N);
342
 
343
               when N_Package_Renaming_Declaration =>
344
                  Expand_N_Package_Renaming_Declaration (N);
345
 
346
               when N_Subprogram_Renaming_Declaration =>
347
                  Expand_N_Subprogram_Renaming_Declaration (N);
348
 
349
               when N_Pragma =>
350
                  Expand_N_Pragma (N);
351
 
352
               when N_Procedure_Call_Statement =>
353
                  Expand_N_Procedure_Call_Statement (N);
354
 
355
               when N_Protected_Type_Declaration =>
356
                  Expand_N_Protected_Type_Declaration (N);
357
 
358
               when N_Protected_Body =>
359
                  Expand_N_Protected_Body (N);
360
 
361
               when N_Qualified_Expression =>
362
                  Expand_N_Qualified_Expression (N);
363
 
364
               when N_Raise_Statement =>
365
                  Expand_N_Raise_Statement (N);
366
 
367
               when N_Raise_Constraint_Error =>
368
                  Expand_N_Raise_Constraint_Error (N);
369
 
370
               when N_Raise_Program_Error =>
371
                  Expand_N_Raise_Program_Error (N);
372
 
373
               when N_Raise_Storage_Error =>
374
                  Expand_N_Raise_Storage_Error (N);
375
 
376
               when N_Real_Literal =>
377
                  Expand_N_Real_Literal (N);
378
 
379
               when N_Record_Representation_Clause =>
380
                  Expand_N_Record_Representation_Clause (N);
381
 
382
               when N_Requeue_Statement =>
383
                  Expand_N_Requeue_Statement (N);
384
 
385
               when N_Simple_Return_Statement =>
386
                  Expand_N_Simple_Return_Statement (N);
387
 
388
               when N_Selected_Component =>
389
                  Expand_N_Selected_Component (N);
390
 
391
               when N_Selective_Accept =>
392
                  Expand_N_Selective_Accept (N);
393
 
394
               when N_Single_Task_Declaration =>
395
                  Expand_N_Single_Task_Declaration (N);
396
 
397
               when N_Slice =>
398
                  Expand_N_Slice (N);
399
 
400
               when N_Subtype_Indication =>
401
                  Expand_N_Subtype_Indication (N);
402
 
403
               when N_Subprogram_Body =>
404
                  Expand_N_Subprogram_Body (N);
405
 
406
               when N_Subprogram_Body_Stub =>
407
                  Expand_N_Subprogram_Body_Stub (N);
408
 
409
               when N_Subprogram_Declaration =>
410
                  Expand_N_Subprogram_Declaration (N);
411
 
412
               when N_Subprogram_Info =>
413
                  Expand_N_Subprogram_Info (N);
414
 
415
               when N_Task_Body =>
416
                  Expand_N_Task_Body (N);
417
 
418
               when N_Task_Type_Declaration =>
419
                  Expand_N_Task_Type_Declaration (N);
420
 
421
               when N_Timed_Entry_Call =>
422
                  Expand_N_Timed_Entry_Call (N);
423
 
424
               when N_Type_Conversion =>
425
                  Expand_N_Type_Conversion (N);
426
 
427
               when N_Unchecked_Expression =>
428
                  Expand_N_Unchecked_Expression (N);
429
 
430
               when N_Unchecked_Type_Conversion =>
431
                  Expand_N_Unchecked_Type_Conversion (N);
432
 
433
               when N_Variant_Part =>
434
                  Expand_N_Variant_Part (N);
435
 
436
               --  For all other node kinds, no expansion activity is required
437
 
438
               when others => null;
439
 
440
            end case;
441
 
442
         exception
443
            when RE_Not_Available =>
444
               return;
445
         end;
446
 
447
         --  Set result as analyzed and then do a possible transient wrap. The
448
         --  transient wrap must be done after the Analyzed flag is set on, so
449
         --  that we do not get a recursive attempt to expand the node N.
450
 
451
         Set_Analyzed (N);
452
 
453
         --  Deal with transient scopes
454
 
455
         if Scope_Is_Transient and then N = Node_To_Be_Wrapped then
456
 
457
            case Nkind (N) is
458
               when N_Statement_Other_Than_Procedure_Call |
459
                    N_Procedure_Call_Statement            =>
460
                  Wrap_Transient_Statement (N);
461
 
462
               when N_Object_Declaration          |
463
                    N_Object_Renaming_Declaration |
464
                    N_Subtype_Declaration         =>
465
                  Wrap_Transient_Declaration (N);
466
 
467
               when others => Wrap_Transient_Expression (N);
468
            end case;
469
         end if;
470
 
471
         Debug_A_Exit ("expanding  ", N, "  (done)");
472
      end if;
473
 
474
   end Expand;
475
 
476
   ---------------------------
477
   -- Expander_Mode_Restore --
478
   ---------------------------
479
 
480
   procedure Expander_Mode_Restore is
481
   begin
482
      --  Not active (has no effect) in ASIS mode (see comments in spec of
483
      --  Expander_Mode_Save_And_Set).
484
 
485
      if ASIS_Mode then
486
         return;
487
      end if;
488
 
489
      --  Otherwise restore the flag
490
 
491
      Expander_Active := Expander_Flags.Table (Expander_Flags.Last);
492
      Expander_Flags.Decrement_Last;
493
 
494
      --  Keep expander off if serious errors detected. In this case we do not
495
      --  need expansion, and continued expansion may cause cascaded errors or
496
      --  compiler bombs.
497
 
498
      if Serious_Errors_Detected /= 0 then
499
         Expander_Active := False;
500
      end if;
501
   end Expander_Mode_Restore;
502
 
503
   --------------------------------
504
   -- Expander_Mode_Save_And_Set --
505
   --------------------------------
506
 
507
   procedure Expander_Mode_Save_And_Set (Status : Boolean) is
508
   begin
509
      --  Not active (has no effect) in ASIS mode (see comments in spec of
510
      --  Expander_Mode_Save_And_Set).
511
 
512
      if ASIS_Mode then
513
         return;
514
      end if;
515
 
516
      --  Otherwise save and set the flag
517
 
518
      Expander_Flags.Increment_Last;
519
      Expander_Flags.Table (Expander_Flags.Last) := Expander_Active;
520
      Expander_Active := Status;
521
   end Expander_Mode_Save_And_Set;
522
 
523
end Expander;

powered by: WebSVN 2.1.0

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