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