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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [gcc/] [ada/] [lib.ads] - Blame information for rev 706

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 706 jeremybenn
------------------------------------------------------------------------------
2
--                                                                          --
3
--                         GNAT COMPILER COMPONENTS                         --
4
--                                                                          --
5
--                                  L I B                                   --
6
--                                                                          --
7
--                                 S p e c                                  --
8
--                                                                          --
9
--          Copyright (C) 1992-2011, 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.                                     --
17
--                                                                          --
18
-- As a special exception under Section 7 of GPL version 3, you are granted --
19
-- additional permissions described in the GCC Runtime Library Exception,   --
20
-- version 3.1, as published by the Free Software Foundation.               --
21
--                                                                          --
22
-- You should have received a copy of the GNU General Public License and    --
23
-- a copy of the GCC Runtime Library Exception along with this program;     --
24
-- see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see    --
25
-- <http://www.gnu.org/licenses/>.                                          --
26
--                                                                          --
27
-- GNAT was originally developed  by the GNAT team at  New York University. --
28
-- Extensive contributions were provided by Ada Core Technologies Inc.      --
29
--                                                                          --
30
------------------------------------------------------------------------------
31
 
32
--  This package contains routines for accessing and outputting the library
33
--  information. It contains the routine to load subsidiary units.
34
 
35
with Alloc;
36
with Namet; use Namet;
37
with Table;
38
with Types; use Types;
39
 
40
package Lib is
41
 
42
   type Unit_Ref_Table is array (Pos range <>) of Unit_Number_Type;
43
   --  Type to hold list of indirect references to unit number table
44
 
45
   type Compiler_State_Type is (Parsing, Analyzing);
46
   Compiler_State : Compiler_State_Type;
47
   --  Indicates current state of compilation. This is used to implement the
48
   --  function In_Extended_Main_Source_Unit.
49
 
50
   Parsing_Main_Extended_Source : Boolean := False;
51
   --  Set True if we are currently parsing a file that is part of the main
52
   --  extended source (the main unit, its spec, or one of its subunits). This
53
   --  flag to implement In_Extended_Main_Source_Unit.
54
 
55
   Analysing_Subunit_Of_Main : Boolean := False;
56
   --  Set to True when analyzing a subunit of the main source. When True, if
57
   --  the subunit is preprocessed and -gnateG is specified, then the
58
   --  preprocessed file (.prep) is written.
59
 
60
   --------------------------------------------
61
   -- General Approach to Library Management --
62
   --------------------------------------------
63
 
64
   --  As described in GNote #1, when a unit is compiled, all its subsidiary
65
   --  units are recompiled, including the following:
66
 
67
   --    (a) Corresponding spec for a body
68
   --    (b) Parent spec of a child library spec
69
   --    (d) With'ed specs
70
   --    (d) Parent body of a subunit
71
   --    (e) Subunits corresponding to any specified stubs
72
   --    (f) Bodies of inlined subprograms that are called
73
   --    (g) Bodies of generic subprograms or packages that are instantiated
74
   --    (h) Bodies of packages containing either of the above two items
75
   --    (i) Specs and bodies of runtime units
76
   --    (j) Parent specs for with'ed child library units
77
 
78
   --  If a unit is being compiled only for syntax checking, then no subsidiary
79
   --  units are loaded, the syntax check applies only to the main unit,
80
   --  i.e. the one contained in the source submitted to the library.
81
 
82
   --  If a unit is being compiled for syntax and semantic checking, then only
83
   --  cases (a)-(d) loads are performed, since the full semantic checking can
84
   --  be carried out without needing (e)-(i) loads. In this case no object
85
   --  file, or library information file, is generated, so the missing units
86
   --  do not affect the results.
87
 
88
   --  Specifications of library subprograms, subunits, and generic specs
89
   --  and bodies, can only be compiled in syntax/semantic checking mode,
90
   --  since no code is ever generated directly for these units. In the case
91
   --  of subunits, only the compilation of the ultimate parent unit generates
92
   --  actual code. If a subunit is submitted to the compiler in syntax/
93
   --  semantic checking mode, the parent (or parents in the nested case) are
94
   --  semantically checked only up to the point of the corresponding stub.
95
 
96
   --  If code is being generated, then all the above units are required,
97
   --  although the need for bodies of inlined procedures can be suppressed
98
   --  by the use of a switch that sets the mode to ignore pragma Inline
99
   --  statements.
100
 
101
   --  The two main sections of the front end, Par and Sem, are recursive.
102
   --  Compilation proceeds unit by unit making recursive calls as necessary.
103
   --  The process is controlled from the GNAT main program, which makes calls
104
   --  to Par and Sem sequence for the main unit.
105
 
106
   --  Par parses the given unit, and then, after the parse is complete, uses
107
   --  the Par.Load subprogram to load all its subsidiary units in categories
108
   --  (a)-(d) above, installing pointers to the loaded units in the parse
109
   --  tree, as described in a later section of this spec. If any of these
110
   --  required units is missing, a fatal error is signalled, so that no
111
   --  attempt is made to run Sem in such cases, since it is assumed that
112
   --  too many cascaded errors would result, and the confusion would not
113
   --  be helpful.
114
 
115
   --  Following the call to Par on the main unit, the entire tree of required
116
   --  units is thus loaded, and Sem is called on the main unit. The parameter
117
   --  passed to Sem is the unit to be analyzed. The visibility table, which
118
   --  is a single global structure, starts out containing only the entries
119
   --  for the visible entities in Standard. Every call to Sem establishes a
120
   --  new scope stack table, pushing an entry for Standard on entry to provide
121
   --  the proper initial scope environment.
122
 
123
   --  Sem first proceeds to perform semantic analysis on the currently loaded
124
   --  units as follows:
125
 
126
   --    In the case of a body (case (a) above), Sem analyzes the corresponding
127
   --    spec, using a recursive call to Sem. As is always expected to be the
128
   --    case with calls to Sem, any entities installed in the visibility table
129
   --    are removed on exit from Sem, so that these entities have to be
130
   --    reinstalled on return to continue the analysis of the body which of
131
   --    course needs visibility of these entities.
132
   --
133
   --    In the case of the parent of a child spec (case (b) above), a similar
134
   --    call is made to Sem to analyze the parent. Again, on return, the
135
   --    entities from the analyzed parent spec have to be installed in the
136
   --    visibility table of the caller (the child unit), which must have
137
   --    visibility to the entities in its parent spec.
138
 
139
   --    For with'ed specs (case (c) above), a recursive call to Sem is made
140
   --    to analyze each spec in turn. After all the spec's have been analyzed,
141
   --    but not till that point, the entities from all the with'ed units are
142
   --    reinstalled in the visibility table so that the caller can proceed
143
   --    with the analysis of the unit doing the with's with the necessary
144
   --    entities made either potentially use visible or visible by selection
145
   --    as needed.
146
 
147
   --    Case (d) arises when Sem is passed a subunit to analyze. This means
148
   --    that the main unit is a subunit, and the unit passed to Sem is either
149
   --    the main unit, or one of its ancestors that is still a subunit. Since
150
   --    analysis must start at the top of the tree, Sem essentially cancels
151
   --    the current call by immediately making a call to analyze the parent
152
   --    (when this call is finished it immediately returns, so logically this
153
   --    call is like a goto). The subunit will then be analyzed at the proper
154
   --    time as described for the stub case. Note that we also turn off the
155
   --    indication that code should be generated in this case, since the only
156
   --    time we generate code for subunits is when compiling the main parent.
157
 
158
   --    Case (e), subunits corresponding to stubs, are handled as the stubs
159
   --    are encountered. There are three sub-cases:
160
 
161
   --      If the subunit has already been loaded, then this means that the
162
   --      main unit was a subunit, and we are back on our way down to it
163
   --      after following the initial processing described for case (d).
164
   --      In this case we analyze this particular subunit, as described
165
   --      for the case where we are generating code, but when we get back
166
   --      we are all done, since the rest of the parent is irrelevant. To
167
   --      get out of the parent, we raise the exception Subunit_Found, which
168
   --      is handled at the outer level of Sem.
169
 
170
   --      The cases where the subunit has not already been loaded correspond
171
   --      to cases where the main unit was a parent. In this case the action
172
   --      depends on whether or not we are generating code. If we are not
173
   --      generating code, then this is the case where we can simply ignore
174
   --      the subunit, since in checking mode we don't even want to insist
175
   --      that the subunit exist, much less waste time checking it.
176
 
177
   --      If we are generating code, then we need to load and analyze
178
   --      all subunits. This is achieved with a call to Lib.Load to load
179
   --      and parse the unit, followed by processing that installs the
180
   --      context clause of the subunit, analyzes the subunit, and then
181
   --      removes the context clause (from the visibility chains of the
182
   --      parent). Note that we do *not* do a recursive call to Sem in
183
   --      this case, precisely because we need to do the analysis of the
184
   --      subunit with the current visibility table and scope stack.
185
 
186
   --    Case (f) applies only to subprograms for which a pragma Inline is
187
   --    given, providing that the compiler is operating in the mode where
188
   --    pragma Inline's are activated. When the expander encounters a call
189
   --    to such a subprogram, it loads the body of the subprogram if it has
190
   --    not already been loaded, and calls Sem to process it.
191
 
192
   --    Case (g) is similar to case (f), except that the body of a generic
193
   --    is unconditionally required, regardless of compiler mode settings.
194
   --    As in the subprogram case, when the expander encounters a generic
195
   --    instantiation, it loads the generic body of the subprogram if it
196
   --    has not already been loaded, and calls Sem to process it.
197
 
198
   --    Case (h) arises when a package contains either an inlined subprogram
199
   --    which is called, or a generic which is instantiated. In this case the
200
   --    body of the package must be loaded and analyzed with a call to Sem.
201
 
202
   --    Case (i) is handled by adding implicit with clauses to the context
203
   --    clauses of all units that potentially reference the relevant runtime
204
   --    entities. Note that since we have the full set of units available,
205
   --    the parser can always determine the set of runtime units that is
206
   --    needed. These with clauses do not have associated use clauses, so
207
   --    all references to the entities must be by selection. Once the with
208
   --    clauses have been added, subsequent processing is as for normal
209
   --    with clauses.
210
 
211
   --    Case (j) is also handled by adding appropriate implicit with clauses
212
   --    to any unit that withs a child unit. Again there is no use clause,
213
   --    and subsequent processing proceeds as for an explicit with clause.
214
 
215
   --  Sem thus completes the loading of all required units, except those
216
   --  required for inline subprogram bodies or inlined generics. If any
217
   --  of these load attempts fails, then the expander will not be called,
218
   --  even if code was to be generated. If the load attempts all succeed
219
   --  then the expander is called, though the attempt to generate code may
220
   --  still fail if an error occurs during a load attempt for an inlined
221
   --  body or a generic body.
222
 
223
   -------------------------------------------
224
   -- Special Handling of Subprogram Bodies --
225
   -------------------------------------------
226
 
227
   --  A subprogram body (in an adb file) may stand for both a spec and a body.
228
   --  A simple model (and one that was adopted through version 2.07) is simply
229
   --  to assume that such an adb file acts as its own spec if no ads file is
230
   --  is present.
231
 
232
   --  However, this is not correct. RM 10.1.4(4) requires that such a body
233
   --  act as a spec unless a subprogram declaration of the same name is
234
   --  already present. The correct interpretation of this in GNAT library
235
   --  terms is to ignore an existing ads file of the same name unless this
236
   --  ads file contains a subprogram declaration with the same name.
237
 
238
   --  If there is an ads file with a unit other than a subprogram declaration
239
   --  with the same name, then a fatal message is output, noting that this
240
   --  irrelevant file must be deleted before the body can be compiled. See
241
   --  ACVC test CA1020D to see how this processing is required.
242
 
243
   -----------------
244
   -- Global Data --
245
   -----------------
246
 
247
   Current_Sem_Unit : Unit_Number_Type := Main_Unit;
248
   --  Unit number of unit currently being analyzed/expanded. This is set when
249
   --  ever a new unit is entered, saving and restoring the old value, so that
250
   --  it always reflects the unit currently being analyzed. The initial value
251
   --  of Main_Unit ensures that a proper value is set initially, and in
252
   --  particular for analysis of configuration pragmas in gnat.adc.
253
 
254
   Main_Unit_Entity : Entity_Id;
255
   --  Entity of main unit, same as Cunit_Entity (Main_Unit) except where
256
   --  Main_Unit is a body with a separate spec, in which case it is the
257
   --  entity for the spec.
258
 
259
   -----------------
260
   -- Units Table --
261
   -----------------
262
 
263
   --  The units table has an entry for each unit (source file) read in by the
264
   --  current compilation. The table is indexed by the unit number value,
265
   --  The first entry in the table, subscript Main_Unit, is for the main file.
266
   --  Each entry in this units table contains the following data.
267
 
268
   --    Unit_File_Name
269
   --      The name of the source file containing the unit. Set when the entry
270
   --      is created by a call to Lib.Load, and then cannot be changed.
271
 
272
   --    Source_Index
273
   --      The index in the source file table of the corresponding source file.
274
   --      Set when the entry is created by a call to Lib.Load and then cannot
275
   --      be changed.
276
 
277
   --    Munit_Index
278
   --      The index of the unit within the file for multiple unit per file
279
   --      mode. Set to zero in normal single unit per file mode.
280
 
281
   --    Error_Location
282
   --      This is copied from the Sloc field of the Enode argument passed
283
   --      to Load_Unit. It refers to the enclosing construct which caused
284
   --      this unit to be loaded, e.g. most typically the with clause that
285
   --      referenced the unit, and is used for error handling in Par.Load.
286
 
287
   --    Expected_Unit
288
   --      This is the expected unit name for a file other than the main unit,
289
   --      since these are cases where we load the unit using Lib.Load and we
290
   --      know the unit that is expected. It must be the same as Unit_Name
291
   --      if it is set (see test in Par.Load). Expected_Unit is set to
292
   --      No_Name for the main unit.
293
 
294
   --    Unit_Name
295
   --      The name of the unit. Initialized to No_Name by Lib.Load, and then
296
   --      set by the parser when the unit is parsed to the unit name actually
297
   --      found in the file (which should, in the absence of errors) be the
298
   --      same name as Expected_Unit.
299
 
300
   --    Cunit
301
   --      Pointer to the N_Compilation_Unit node. Initially set to Empty by
302
   --      Lib.Load, and then reset to the required node by the parser when
303
   --      the unit is parsed.
304
 
305
   --    Cunit_Entity
306
   --      Pointer to the entity node for the compilation unit. Initially set
307
   --      to Empty by Lib.Load, and then reset to the required entity by the
308
   --      parser when the unit is parsed.
309
 
310
   --    Dependency_Num
311
   --      This is the number of the unit within the generated dependency
312
   --      lines (D lines in the ALI file) which are sorted into alphabetical
313
   --      order. The number is ones origin, so a value of 2 refers to the
314
   --      second generated D line. The Dependency_Number values are set
315
   --      as the D lines are generated, and are used to generate proper
316
   --      unit references in the generated xref information and SCO output.
317
 
318
   --    Dynamic_Elab
319
   --      A flag indicating if this unit was compiled with dynamic elaboration
320
   --      checks specified (as the result of using the -gnatE compilation
321
   --      option or a pragma Elaboration_Checks (Dynamic).
322
 
323
   --    Fatal_Error
324
   --      A flag that is initialized to False, and gets set to True if a fatal
325
   --      error occurs during the processing of a unit. A fatal error is one
326
   --      defined as serious enough to stop the next phase of the compiler
327
   --      from running (i.e. fatal error during parsing stops semantics,
328
   --      fatal error during semantics stops code generation). Note that
329
   --      currently, errors of any kind cause Fatal_Error to be set, but
330
   --      eventually perhaps only errors labeled as Fatal_Errors should be
331
   --      this severe if we decide to try Sem on sources with minor errors.
332
 
333
   --    Generate_Code
334
   --      This flag is set True for all units in the current file for which
335
   --      code is to be generated. This includes the unit explicitly compiled,
336
   --      together with its specification, and any subunits.
337
 
338
   --    Has_RACW
339
   --      A Boolean flag, initially set to False when a unit entry is created,
340
   --      and set to True if the unit defines a remote access to class wide
341
   --      (RACW) object. This is used for controlling generation of the RA
342
   --      attribute in the ali file.
343
 
344
   --    Is_Compiler_Unit
345
   --      A Boolean flag, initially set False by default, set to True if a
346
   --      pragma Compiler_Unit appears in the unit.
347
 
348
   --    Ident_String
349
   --      N_String_Literal node from a valid pragma Ident that applies to
350
   --      this unit. If no Ident pragma applies to the unit, then Empty.
351
 
352
   --    Loading
353
   --      A flag that is used to catch circular WITH dependencies. It is set
354
   --      True when an entry is initially created in the file table, and set
355
   --      False when the load is completed, or ends with an error.
356
 
357
   --    Main_Priority
358
   --      This field is used to indicate the priority of a possible main
359
   --      program, as set by a pragma Priority. A value of -1 indicates
360
   --      that the default priority is to be used (and is also used for
361
   --      entries that do not correspond to possible main programs).
362
 
363
   --    Main_CPU
364
   --      This field is used to indicate the affinity of a possible main
365
   --      program, as set by a pragma CPU. A value of -1 indicates
366
   --      that the default affinity is to be used (and is also used for
367
   --      entries that do not correspond to possible main programs).
368
 
369
   --    Has_Allocator
370
   --      This flag is set if a subprogram unit has an allocator after the
371
   --      BEGIN (it is used to set the AB flag in the M ALI line).
372
 
373
   --    OA_Setting
374
   --      This is a character field containing L if Optimize_Alignment mode
375
   --      was set locally, and O/T/S for Off/Time/Space default if not.
376
 
377
   --    Serial_Number
378
   --      This field holds a serial number used by New_Internal_Name to
379
   --      generate unique temporary numbers on a unit by unit basis. The
380
   --      only access to this field is via the Increment_Serial_Number
381
   --      routine which increments the current value and returns it. This
382
   --      serial number is separate for each unit.
383
 
384
   --    Version
385
   --      This field holds the version of the unit, which is computed as
386
   --      the exclusive or of the checksums of this unit, and all its
387
   --      semantically dependent units. Access to the version number field
388
   --      is not direct, but is done through the routines described below.
389
   --      When a unit table entry is created, this field is initialized to
390
   --      the checksum of the corresponding source file. Version_Update is
391
   --      then called to reflect the contributions of any unit on which this
392
   --      unit is semantically dependent.
393
 
394
   --  The units table is reset to empty at the start of the compilation of
395
   --  each main unit by Lib.Initialize. Entries are then added by calls to
396
   --  the Lib.Load procedure. The following subprograms are used to access
397
   --  and modify entries in the Units table. Individual entries are accessed
398
   --  using a unit number value which ranges from Main_Unit (the first entry,
399
   --  which is always for the current main unit) to Last_Unit.
400
 
401
   Default_Main_Priority : constant Int := -1;
402
   --  Value used in Main_Priority field to indicate default main priority
403
 
404
   Default_Main_CPU : constant Int := -1;
405
   --  Value used in Main_CPU field to indicate default main affinity
406
 
407
   function Cunit            (U : Unit_Number_Type) return Node_Id;
408
   function Cunit_Entity     (U : Unit_Number_Type) return Entity_Id;
409
   function Dependency_Num   (U : Unit_Number_Type) return Nat;
410
   function Dynamic_Elab     (U : Unit_Number_Type) return Boolean;
411
   function Error_Location   (U : Unit_Number_Type) return Source_Ptr;
412
   function Expected_Unit    (U : Unit_Number_Type) return Unit_Name_Type;
413
   function Fatal_Error      (U : Unit_Number_Type) return Boolean;
414
   function Generate_Code    (U : Unit_Number_Type) return Boolean;
415
   function Ident_String     (U : Unit_Number_Type) return Node_Id;
416
   function Has_Allocator    (U : Unit_Number_Type) return Boolean;
417
   function Has_RACW         (U : Unit_Number_Type) return Boolean;
418
   function Is_Compiler_Unit (U : Unit_Number_Type) return Boolean;
419
   function Loading          (U : Unit_Number_Type) return Boolean;
420
   function Main_CPU         (U : Unit_Number_Type) return Int;
421
   function Main_Priority    (U : Unit_Number_Type) return Int;
422
   function Munit_Index      (U : Unit_Number_Type) return Nat;
423
   function OA_Setting       (U : Unit_Number_Type) return Character;
424
   function Source_Index     (U : Unit_Number_Type) return Source_File_Index;
425
   function Unit_File_Name   (U : Unit_Number_Type) return File_Name_Type;
426
   function Unit_Name        (U : Unit_Number_Type) return Unit_Name_Type;
427
   --  Get value of named field from given units table entry
428
 
429
   procedure Set_Cunit            (U : Unit_Number_Type; N : Node_Id);
430
   procedure Set_Cunit_Entity     (U : Unit_Number_Type; E : Entity_Id);
431
   procedure Set_Dynamic_Elab     (U : Unit_Number_Type; B : Boolean := True);
432
   procedure Set_Error_Location   (U : Unit_Number_Type; W : Source_Ptr);
433
   procedure Set_Fatal_Error      (U : Unit_Number_Type; B : Boolean := True);
434
   procedure Set_Generate_Code    (U : Unit_Number_Type; B : Boolean := True);
435
   procedure Set_Has_RACW         (U : Unit_Number_Type; B : Boolean := True);
436
   procedure Set_Has_Allocator    (U : Unit_Number_Type; B : Boolean := True);
437
   procedure Set_Is_Compiler_Unit (U : Unit_Number_Type; B : Boolean := True);
438
   procedure Set_Ident_String     (U : Unit_Number_Type; N : Node_Id);
439
   procedure Set_Loading          (U : Unit_Number_Type; B : Boolean := True);
440
   procedure Set_Main_CPU         (U : Unit_Number_Type; P : Int);
441
   procedure Set_Main_Priority    (U : Unit_Number_Type; P : Int);
442
   procedure Set_OA_Setting       (U : Unit_Number_Type; C : Character);
443
   procedure Set_Unit_Name        (U : Unit_Number_Type; N : Unit_Name_Type);
444
   --  Set value of named field for given units table entry. Note that we
445
   --  do not have an entry for each possible field, since some of the fields
446
   --  can only be set by specialized interfaces (defined below).
447
 
448
   function Version_Get (U : Unit_Number_Type) return Word_Hex_String;
449
   --  Returns the version as a string with 8 hex digits (upper case letters)
450
 
451
   function Last_Unit return Unit_Number_Type;
452
   --  Unit number of last allocated unit
453
 
454
   function Num_Units return Nat;
455
   --  Number of units currently in unit table
456
 
457
   procedure Remove_Unit (U : Unit_Number_Type);
458
   --  Remove unit U from unit table. Currently this is effective only
459
   --  if U is the last unit currently stored in the unit table.
460
 
461
   function Entity_Is_In_Main_Unit (E : Entity_Id) return Boolean;
462
   --  Returns True if the entity E is declared in the main unit, or, in
463
   --  its corresponding spec, or one of its subunits. Entities declared
464
   --  within generic instantiations return True if the instantiation is
465
   --  itself "in the main unit" by this definition. Otherwise False.
466
 
467
   function Get_Source_Unit (N : Node_Or_Entity_Id) return Unit_Number_Type;
468
   pragma Inline (Get_Source_Unit);
469
   function Get_Source_Unit (S : Source_Ptr) return Unit_Number_Type;
470
   --  Return unit number of file identified by given source pointer value.
471
   --  This call must always succeed, since any valid source pointer value
472
   --  belongs to some previously loaded module. If the given source pointer
473
   --  value is within an instantiation, this function returns the unit number
474
   --  of the template, i.e. the unit containing the source code corresponding
475
   --  to the given Source_Ptr value. The version taking a Node_Id argument, N,
476
   --  simply applies the function to Sloc (N).
477
 
478
   function Get_Code_Unit (N : Node_Or_Entity_Id) return Unit_Number_Type;
479
   pragma Inline (Get_Code_Unit);
480
   function Get_Code_Unit (S : Source_Ptr) return Unit_Number_Type;
481
   --  This is like Get_Source_Unit, except that in the instantiation case,
482
   --  it uses the location of the top level instantiation, rather than the
483
   --  template, so it returns the unit number containing the code that
484
   --  corresponds to the node N, or the source location S.
485
 
486
   function In_Same_Source_Unit (N1, N2 : Node_Or_Entity_Id) return Boolean;
487
   pragma Inline (In_Same_Source_Unit);
488
   --  Determines if the two nodes or entities N1 and N2 are in the same
489
   --  source unit, the criterion being that Get_Source_Unit yields the
490
   --  same value for each argument.
491
 
492
   function In_Same_Code_Unit (N1, N2 : Node_Or_Entity_Id) return Boolean;
493
   pragma Inline (In_Same_Code_Unit);
494
   --  Determines if the two nodes or entities N1 and N2 are in the same
495
   --  code unit, the criterion being that Get_Code_Unit yields the same
496
   --  value for each argument.
497
 
498
   function In_Same_Extended_Unit (N1, N2 : Node_Or_Entity_Id) return Boolean;
499
   pragma Inline (In_Same_Extended_Unit);
500
   --  Determines if two nodes or entities N1 and N2 are in the same
501
   --  extended unit, where an extended unit is defined as a unit and all
502
   --  its subunits (considered recursively, i.e. subunits of subunits are
503
   --  included). Returns true if S1 and S2 are in the same extended unit
504
   --  and False otherwise.
505
 
506
   function In_Same_Extended_Unit (S1, S2 : Source_Ptr) return Boolean;
507
   pragma Inline (In_Same_Extended_Unit);
508
   --  Determines if the two source locations S1 and S2 are in the same
509
   --  extended unit, where an extended unit is defined as a unit and all
510
   --  its subunits (considered recursively, i.e. subunits of subunits are
511
   --  included). Returns true if S1 and S2 are in the same extended unit
512
   --  and False otherwise.
513
 
514
   function In_Extended_Main_Code_Unit
515
     (N : Node_Or_Entity_Id) return Boolean;
516
   --  Return True if the node is in the generated code of the extended main
517
   --  unit, defined as the main unit, its specification (if any), and all
518
   --  its subunits (considered recursively). Units for which this enquiry
519
   --  returns True are those for which code will be generated. Nodes from
520
   --  instantiations are included in the extended main unit for this call.
521
   --  If the main unit is itself a subunit, then the extended main code unit
522
   --  includes its parent unit, and the parent unit spec if it is separate.
523
 
524
   function In_Extended_Main_Code_Unit (Loc : Source_Ptr) return Boolean;
525
   --  Same function as above, but argument is a source pointer rather
526
   --  than a node.
527
 
528
   function In_Extended_Main_Source_Unit
529
     (N : Node_Or_Entity_Id) return Boolean;
530
   --  Return True if the node is in the source text of the extended main
531
   --  unit, defined as the main unit, its specification (if any), and all
532
   --  its subunits (considered recursively). Units for which this enquiry
533
   --  returns True are those for which code will be generated. This differs
534
   --  from In_Extended_Main_Code_Unit only in that instantiations are not
535
   --  included for the purposes of this call. If the main unit is itself
536
   --  a subunit, then the extended main source unit includes its parent unit,
537
   --  and the parent unit spec if it is separate.
538
 
539
   function In_Extended_Main_Source_Unit (Loc : Source_Ptr) return Boolean;
540
   --  Same function as above, but argument is a source pointer
541
 
542
   function In_Predefined_Unit (N : Node_Or_Entity_Id) return Boolean;
543
   --  Returns True if the given node or entity appears within the source text
544
   --  of a predefined unit (i.e. within Ada, Interfaces, System or within one
545
   --  of the descendent packages of one of these three packages).
546
 
547
   function In_Predefined_Unit (S : Source_Ptr) return Boolean;
548
   --  Same function as above but argument is a source pointer
549
 
550
   function Earlier_In_Extended_Unit (S1, S2 : Source_Ptr) return Boolean;
551
   --  Given two Sloc values for which In_Same_Extended_Unit is true, determine
552
   --  if S1 appears before S2. Returns True if S1 appears before S2, and False
553
   --  otherwise. The result is undefined if S1 and S2 are not in the same
554
   --  extended unit. Note: this routine will not give reliable results if
555
   --  called after Sprint has been called with -gnatD set.
556
 
557
   function Exact_Source_Name (Loc : Source_Ptr) return String;
558
   --  Return name of entity at location Loc exactly as written in the source.
559
   --  this includes copying the wide character encodings exactly as they were
560
   --  used in the source, so the caller must be aware of the possibility of
561
   --  such encodings.
562
 
563
   function Compilation_Switches_Last return Nat;
564
   --  Return the count of stored compilation switches
565
 
566
   function Get_Compilation_Switch (N : Pos) return String_Ptr;
567
   --  Return the Nth stored compilation switch, or null if less than N
568
   --  switches have been stored. Used by ASIS and back ends written in Ada.
569
 
570
   function Get_Cunit_Unit_Number (N : Node_Id) return Unit_Number_Type;
571
   --  Return unit number of the unit whose N_Compilation_Unit node is the
572
   --  one passed as an argument. This must always succeed since the node
573
   --  could not have been built without making a unit table entry.
574
 
575
   function Get_Cunit_Entity_Unit_Number
576
     (E : Entity_Id) return Unit_Number_Type;
577
   --  Return unit number of the unit whose compilation unit spec entity is
578
   --  the one passed as an argument. This must always succeed since the
579
   --  entity could not have been built without making a unit table entry.
580
 
581
   function Increment_Serial_Number return Nat;
582
   --  Increment Serial_Number field for current unit, and return the
583
   --  incremented value.
584
 
585
   procedure Synchronize_Serial_Number;
586
   --  This function increments the Serial_Number field for the current unit
587
   --  but does not return the incremented value. This is used when there
588
   --  is a situation where one path of control increments a serial number
589
   --  (using Increment_Serial_Number), and the other path does not and it is
590
   --  important to keep the serial numbers synchronized in the two cases (e.g.
591
   --  when the references in a package and a client must be kept consistent).
592
 
593
   procedure Replace_Linker_Option_String
594
     (S            : String_Id;
595
      Match_String : String);
596
   --  Replace an existing Linker_Option if the prefix Match_String matches,
597
   --  otherwise call Store_Linker_Option_String.
598
 
599
   procedure Store_Compilation_Switch (Switch : String);
600
   --  Called to register a compilation switch, either front-end or back-end,
601
   --  which may influence the generated output file(s). Switch is the text of
602
   --  the switch to store (except that -fRTS gets changed back to --RTS).
603
 
604
   procedure Enable_Switch_Storing;
605
   --  Enable registration of switches by Store_Compilation_Switch. Used to
606
   --  avoid registering switches added automatically by the gcc driver at the
607
   --  beginning of the command line.
608
 
609
   procedure Disable_Switch_Storing;
610
   --  Disable registration of switches by Store_Compilation_Switch. Used to
611
   --  avoid registering switches added automatically by the gcc driver at the
612
   --  end of the command line.
613
 
614
   procedure Store_Linker_Option_String (S : String_Id);
615
   --  This procedure is called to register the string from a pragma
616
   --  Linker_Option. The argument is the Id of the string to register.
617
 
618
   procedure Store_Note (N : Node_Id);
619
   --  This procedure is called to register a pragma N for which a notes
620
   --  entry is required.
621
 
622
   procedure Initialize;
623
   --  Initialize internal tables
624
 
625
   procedure Lock;
626
   --  Lock internal tables before calling back end
627
 
628
   procedure Unlock;
629
   --  Unlock internal tables, in cases where the back end needs to modify them
630
 
631
   procedure Tree_Read;
632
   --  Initializes internal tables from current tree file using the relevant
633
   --  Table.Tree_Read routines.
634
 
635
   procedure Tree_Write;
636
   --  Writes out internal tables to current tree file using the relevant
637
   --  Table.Tree_Write routines.
638
 
639
   function Is_Loaded (Uname : Unit_Name_Type) return Boolean;
640
   --  Determines if unit with given name is already loaded, i.e. there is
641
   --  already an entry in the file table with this unit name for which the
642
   --  corresponding file was found and parsed. Note that the Fatal_Error flag
643
   --  of this entry must be checked before proceeding with further processing.
644
 
645
   procedure Version_Referenced (S : String_Id);
646
   --  This routine is called from Exp_Attr to register the use of a Version
647
   --  or Body_Version attribute. The argument is the external name used to
648
   --  access the version string.
649
 
650
   procedure List (File_Names_Only : Boolean := False);
651
   --  Lists units in active library (i.e. generates output consisting of a
652
   --  sorted listing of the units represented in File table, except for the
653
   --  main unit). If File_Names_Only is set to True, then the list includes
654
   --  only file names, and no other information. Otherwise the unit name and
655
   --  time stamp are also output. File_Names_Only also restricts the list to
656
   --  exclude any predefined files.
657
 
658
   function Generic_May_Lack_ALI (Sfile : File_Name_Type) return Boolean;
659
   --  Generic units must be separately compiled. Since we always use
660
   --  macro substitution for generics, the resulting object file is a dummy
661
   --  one with no code, but the ALI file has the normal form, and we need
662
   --  this ALI file so that the binder can work out a correct order of
663
   --  elaboration.
664
 
665
   --  However, ancient versions of GNAT used to not generate code or ALI
666
   --  files for generic units, and this would yield complex order of
667
   --  elaboration issues. These were fixed in GNAT 3.10. The support for not
668
   --  compiling language-defined library generics was retained nonetheless
669
   --  to facilitate bootstrap. Specifically, it is convenient to have
670
   --  the same list of files to be compiled for all stages. So, if the
671
   --  bootstrap compiler does not generate code for a given file, then
672
   --  the stage1 compiler (and binder) also must deal with the case of
673
   --  that file not being compiled. The predicate Generic_May_Lack_ALI is
674
   --  True for those generic units for which missing ALI files are allowed.
675
 
676
private
677
   pragma Inline (Cunit);
678
   pragma Inline (Cunit_Entity);
679
   pragma Inline (Dependency_Num);
680
   pragma Inline (Fatal_Error);
681
   pragma Inline (Generate_Code);
682
   pragma Inline (Has_Allocator);
683
   pragma Inline (Has_RACW);
684
   pragma Inline (Is_Compiler_Unit);
685
   pragma Inline (Increment_Serial_Number);
686
   pragma Inline (Loading);
687
   pragma Inline (Main_CPU);
688
   pragma Inline (Main_Priority);
689
   pragma Inline (Munit_Index);
690
   pragma Inline (OA_Setting);
691
   pragma Inline (Set_Cunit);
692
   pragma Inline (Set_Cunit_Entity);
693
   pragma Inline (Set_Fatal_Error);
694
   pragma Inline (Set_Generate_Code);
695
   pragma Inline (Set_Has_Allocator);
696
   pragma Inline (Set_Has_RACW);
697
   pragma Inline (Set_Loading);
698
   pragma Inline (Set_Main_CPU);
699
   pragma Inline (Set_Main_Priority);
700
   pragma Inline (Set_OA_Setting);
701
   pragma Inline (Set_Unit_Name);
702
   pragma Inline (Source_Index);
703
   pragma Inline (Unit_File_Name);
704
   pragma Inline (Unit_Name);
705
 
706
   type Unit_Record is record
707
      Unit_File_Name   : File_Name_Type;
708
      Unit_Name        : Unit_Name_Type;
709
      Munit_Index      : Nat;
710
      Expected_Unit    : Unit_Name_Type;
711
      Source_Index     : Source_File_Index;
712
      Cunit            : Node_Id;
713
      Cunit_Entity     : Entity_Id;
714
      Dependency_Num   : Int;
715
      Ident_String     : Node_Id;
716
      Main_Priority    : Int;
717
      Main_CPU         : Int;
718
      Serial_Number    : Nat;
719
      Version          : Word;
720
      Error_Location   : Source_Ptr;
721
      Fatal_Error      : Boolean;
722
      Generate_Code    : Boolean;
723
      Has_RACW         : Boolean;
724
      Is_Compiler_Unit : Boolean;
725
      Dynamic_Elab     : Boolean;
726
      Loading          : Boolean;
727
      Has_Allocator    : Boolean;
728
      OA_Setting       : Character;
729
   end record;
730
 
731
   --  The following representation clause ensures that the above record
732
   --  has no holes. We do this so that when instances of this record are
733
   --  written by Tree_Gen, we do not write uninitialized values to the file.
734
 
735
   for Unit_Record use record
736
      Unit_File_Name   at  0 range 0 .. 31;
737
      Unit_Name        at  4 range 0 .. 31;
738
      Munit_Index      at  8 range 0 .. 31;
739
      Expected_Unit    at 12 range 0 .. 31;
740
      Source_Index     at 16 range 0 .. 31;
741
      Cunit            at 20 range 0 .. 31;
742
      Cunit_Entity     at 24 range 0 .. 31;
743
      Dependency_Num   at 28 range 0 .. 31;
744
      Ident_String     at 32 range 0 .. 31;
745
      Main_Priority    at 36 range 0 .. 31;
746
      Main_CPU         at 40 range 0 .. 31;
747
      Serial_Number    at 44 range 0 .. 31;
748
      Version          at 48 range 0 .. 31;
749
      Error_Location   at 52 range 0 .. 31;
750
      Fatal_Error      at 56 range 0 ..  7;
751
      Generate_Code    at 57 range 0 ..  7;
752
      Has_RACW         at 58 range 0 ..  7;
753
      Dynamic_Elab     at 59 range 0 ..  7;
754
      Is_Compiler_Unit at 60 range 0 ..  7;
755
      OA_Setting       at 61 range 0 ..  7;
756
      Loading          at 62 range 0 ..  7;
757
      Has_Allocator    at 63 range 0 ..  7;
758
   end record;
759
 
760
   for Unit_Record'Size use 64 * 8;
761
   --  This ensures that we did not leave out any fields
762
 
763
   package Units is new Table.Table (
764
     Table_Component_Type => Unit_Record,
765
     Table_Index_Type     => Unit_Number_Type,
766
     Table_Low_Bound      => Main_Unit,
767
     Table_Initial        => Alloc.Units_Initial,
768
     Table_Increment      => Alloc.Units_Increment,
769
     Table_Name           => "Units");
770
 
771
   --  The following table stores strings from pragma Linker_Option lines
772
 
773
   type Linker_Option_Entry is record
774
      Option : String_Id;
775
      --  The string for the linker option line
776
 
777
      Unit : Unit_Number_Type;
778
      --  The unit from which the linker option comes
779
   end record;
780
 
781
   package Linker_Option_Lines is new Table.Table (
782
     Table_Component_Type => Linker_Option_Entry,
783
     Table_Index_Type     => Integer,
784
     Table_Low_Bound      => 1,
785
     Table_Initial        => Alloc.Linker_Option_Lines_Initial,
786
     Table_Increment      => Alloc.Linker_Option_Lines_Increment,
787
     Table_Name           => "Linker_Option_Lines");
788
 
789
   --  The following table stores references to pragmas that generate Notes
790
 
791
   type Notes_Entry is record
792
      Pragma_Node : Node_Id;
793
      Unit        : Unit_Number_Type;
794
   end record;
795
 
796
   package Notes is new Table.Table (
797
     Table_Component_Type => Notes_Entry,
798
     Table_Index_Type     => Integer,
799
     Table_Low_Bound      => 1,
800
     Table_Initial        => Alloc.Notes_Initial,
801
     Table_Increment      => Alloc.Notes_Increment,
802
     Table_Name           => "Notes");
803
 
804
   --  The following table records the compilation switches used to compile
805
   --  the main unit. The table includes only switches. It excludes -o
806
   --  switches as well as artifacts of the gcc/gnat1 interface such as
807
   --  -quiet, -dumpbase, or -auxbase.
808
 
809
   --  This table is set as part of the compiler argument scanning in
810
   --  Back_End. It can also be reset in -gnatc mode from the data in an
811
   --  existing ali file, and is read and written by the Tree_Read and
812
   --  Tree_Write routines for ASIS.
813
 
814
   package Compilation_Switches is new Table.Table (
815
     Table_Component_Type => String_Ptr,
816
     Table_Index_Type     => Nat,
817
     Table_Low_Bound      => 1,
818
     Table_Initial        => 30,
819
     Table_Increment      => 100,
820
     Table_Name           => "Compilation_Switches");
821
 
822
   Load_Msg_Sloc : Source_Ptr;
823
   --  Location for placing error messages (a token in the main source text)
824
   --  This is set from Sloc (Enode) by Load only in the case where this Sloc
825
   --  is in the main source file. This ensures that not found messages and
826
   --  circular dependency messages reference the original with in this source.
827
 
828
   type Load_Stack_Entry is record
829
      Unit_Number : Unit_Number_Type;
830
      With_Node   : Node_Id;
831
   end record;
832
 
833
   --  The Load_Stack table contains a list of unit numbers (indexes into the
834
   --  unit table) of units being loaded on a single dependency chain, and a
835
   --  flag to indicate whether this unit is loaded through a limited_with
836
   --  clause. The First entry is the main unit. The second entry, if present
837
   --  is a unit on which the first unit depends, etc. This stack is used to
838
   --  generate error messages showing the dependency chain if a file is not
839
   --  found, or whether a true circular dependency exists.  The Load_Unit
840
   --  function makes an entry in this table when it is called, and removes
841
   --  the entry just before it returns.
842
 
843
   package Load_Stack is new Table.Table (
844
     Table_Component_Type => Load_Stack_Entry,
845
     Table_Index_Type     => Int,
846
     Table_Low_Bound      => 0,
847
     Table_Initial        => Alloc.Load_Stack_Initial,
848
     Table_Increment      => Alloc.Load_Stack_Increment,
849
     Table_Name           => "Load_Stack");
850
 
851
   procedure Sort (Tbl : in out Unit_Ref_Table);
852
   --  This procedure sorts the given unit reference table in order of
853
   --  ascending unit names, where the ordering relation is as described
854
   --  by the comparison routines provided by package Uname.
855
 
856
   --  The Version_Ref table records Body_Version and Version attribute
857
   --  references. The entries are simply the strings for the external
858
   --  names that correspond to the referenced values.
859
 
860
   package Version_Ref is new Table.Table (
861
     Table_Component_Type => String_Id,
862
     Table_Index_Type     => Nat,
863
     Table_Low_Bound      => 1,
864
     Table_Initial        => 20,
865
     Table_Increment      => 100,
866
     Table_Name           => "Version_Ref");
867
 
868
end Lib;

powered by: WebSVN 2.1.0

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