1------------------------------------------------------------------------------ 2-- -- 3-- GNAT COMPILER COMPONENTS -- 4-- -- 5-- L I B -- 6-- -- 7-- S p e c -- 8-- -- 9-- Copyright (C) 1992-2012, 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 35with Alloc; 36with Namet; use Namet; 37with Table; 38with Types; use Types; 39 40package 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 procedure Write_Unit_Info 677 (Unit_Num : Unit_Number_Type; 678 Item : Node_Id; 679 Prefix : String := ""; 680 Withs : Boolean := False); 681 -- Print out debugging information about the unit. Prefix precedes the rest 682 -- of the printout. If Withs is True, we print out units with'ed by this 683 -- unit (not counting limited withs). 684 685private 686 pragma Inline (Cunit); 687 pragma Inline (Cunit_Entity); 688 pragma Inline (Dependency_Num); 689 pragma Inline (Fatal_Error); 690 pragma Inline (Generate_Code); 691 pragma Inline (Has_Allocator); 692 pragma Inline (Has_RACW); 693 pragma Inline (Is_Compiler_Unit); 694 pragma Inline (Increment_Serial_Number); 695 pragma Inline (Loading); 696 pragma Inline (Main_CPU); 697 pragma Inline (Main_Priority); 698 pragma Inline (Munit_Index); 699 pragma Inline (OA_Setting); 700 pragma Inline (Set_Cunit); 701 pragma Inline (Set_Cunit_Entity); 702 pragma Inline (Set_Fatal_Error); 703 pragma Inline (Set_Generate_Code); 704 pragma Inline (Set_Has_Allocator); 705 pragma Inline (Set_Has_RACW); 706 pragma Inline (Set_Loading); 707 pragma Inline (Set_Main_CPU); 708 pragma Inline (Set_Main_Priority); 709 pragma Inline (Set_OA_Setting); 710 pragma Inline (Set_Unit_Name); 711 pragma Inline (Source_Index); 712 pragma Inline (Unit_File_Name); 713 pragma Inline (Unit_Name); 714 715 type Unit_Record is record 716 Unit_File_Name : File_Name_Type; 717 Unit_Name : Unit_Name_Type; 718 Munit_Index : Nat; 719 Expected_Unit : Unit_Name_Type; 720 Source_Index : Source_File_Index; 721 Cunit : Node_Id; 722 Cunit_Entity : Entity_Id; 723 Dependency_Num : Int; 724 Ident_String : Node_Id; 725 Main_Priority : Int; 726 Main_CPU : Int; 727 Serial_Number : Nat; 728 Version : Word; 729 Error_Location : Source_Ptr; 730 Fatal_Error : Boolean; 731 Generate_Code : Boolean; 732 Has_RACW : Boolean; 733 Is_Compiler_Unit : Boolean; 734 Dynamic_Elab : Boolean; 735 Loading : Boolean; 736 Has_Allocator : Boolean; 737 OA_Setting : Character; 738 end record; 739 740 -- The following representation clause ensures that the above record 741 -- has no holes. We do this so that when instances of this record are 742 -- written by Tree_Gen, we do not write uninitialized values to the file. 743 744 for Unit_Record use record 745 Unit_File_Name at 0 range 0 .. 31; 746 Unit_Name at 4 range 0 .. 31; 747 Munit_Index at 8 range 0 .. 31; 748 Expected_Unit at 12 range 0 .. 31; 749 Source_Index at 16 range 0 .. 31; 750 Cunit at 20 range 0 .. 31; 751 Cunit_Entity at 24 range 0 .. 31; 752 Dependency_Num at 28 range 0 .. 31; 753 Ident_String at 32 range 0 .. 31; 754 Main_Priority at 36 range 0 .. 31; 755 Main_CPU at 40 range 0 .. 31; 756 Serial_Number at 44 range 0 .. 31; 757 Version at 48 range 0 .. 31; 758 Error_Location at 52 range 0 .. 31; 759 Fatal_Error at 56 range 0 .. 7; 760 Generate_Code at 57 range 0 .. 7; 761 Has_RACW at 58 range 0 .. 7; 762 Dynamic_Elab at 59 range 0 .. 7; 763 Is_Compiler_Unit at 60 range 0 .. 7; 764 OA_Setting at 61 range 0 .. 7; 765 Loading at 62 range 0 .. 7; 766 Has_Allocator at 63 range 0 .. 7; 767 end record; 768 769 for Unit_Record'Size use 64 * 8; 770 -- This ensures that we did not leave out any fields 771 772 package Units is new Table.Table ( 773 Table_Component_Type => Unit_Record, 774 Table_Index_Type => Unit_Number_Type, 775 Table_Low_Bound => Main_Unit, 776 Table_Initial => Alloc.Units_Initial, 777 Table_Increment => Alloc.Units_Increment, 778 Table_Name => "Units"); 779 780 -- The following table stores strings from pragma Linker_Option lines 781 782 type Linker_Option_Entry is record 783 Option : String_Id; 784 -- The string for the linker option line 785 786 Unit : Unit_Number_Type; 787 -- The unit from which the linker option comes 788 end record; 789 790 package Linker_Option_Lines is new Table.Table ( 791 Table_Component_Type => Linker_Option_Entry, 792 Table_Index_Type => Integer, 793 Table_Low_Bound => 1, 794 Table_Initial => Alloc.Linker_Option_Lines_Initial, 795 Table_Increment => Alloc.Linker_Option_Lines_Increment, 796 Table_Name => "Linker_Option_Lines"); 797 798 -- The following table stores references to pragmas that generate Notes 799 800 type Notes_Entry is record 801 Pragma_Node : Node_Id; 802 Unit : Unit_Number_Type; 803 end record; 804 805 package Notes is new Table.Table ( 806 Table_Component_Type => Notes_Entry, 807 Table_Index_Type => Integer, 808 Table_Low_Bound => 1, 809 Table_Initial => Alloc.Notes_Initial, 810 Table_Increment => Alloc.Notes_Increment, 811 Table_Name => "Notes"); 812 813 -- The following table records the compilation switches used to compile 814 -- the main unit. The table includes only switches. It excludes -o 815 -- switches as well as artifacts of the gcc/gnat1 interface such as 816 -- -quiet, -dumpbase, or -auxbase. 817 818 -- This table is set as part of the compiler argument scanning in 819 -- Back_End. It can also be reset in -gnatc mode from the data in an 820 -- existing ali file, and is read and written by the Tree_Read and 821 -- Tree_Write routines for ASIS. 822 823 package Compilation_Switches is new Table.Table ( 824 Table_Component_Type => String_Ptr, 825 Table_Index_Type => Nat, 826 Table_Low_Bound => 1, 827 Table_Initial => 30, 828 Table_Increment => 100, 829 Table_Name => "Compilation_Switches"); 830 831 Load_Msg_Sloc : Source_Ptr; 832 -- Location for placing error messages (a token in the main source text) 833 -- This is set from Sloc (Enode) by Load only in the case where this Sloc 834 -- is in the main source file. This ensures that not found messages and 835 -- circular dependency messages reference the original with in this source. 836 837 type Load_Stack_Entry is record 838 Unit_Number : Unit_Number_Type; 839 With_Node : Node_Id; 840 end record; 841 842 -- The Load_Stack table contains a list of unit numbers (indexes into the 843 -- unit table) of units being loaded on a single dependency chain, and a 844 -- flag to indicate whether this unit is loaded through a limited_with 845 -- clause. The First entry is the main unit. The second entry, if present 846 -- is a unit on which the first unit depends, etc. This stack is used to 847 -- generate error messages showing the dependency chain if a file is not 848 -- found, or whether a true circular dependency exists. The Load_Unit 849 -- function makes an entry in this table when it is called, and removes 850 -- the entry just before it returns. 851 852 package Load_Stack is new Table.Table ( 853 Table_Component_Type => Load_Stack_Entry, 854 Table_Index_Type => Int, 855 Table_Low_Bound => 0, 856 Table_Initial => Alloc.Load_Stack_Initial, 857 Table_Increment => Alloc.Load_Stack_Increment, 858 Table_Name => "Load_Stack"); 859 860 procedure Sort (Tbl : in out Unit_Ref_Table); 861 -- This procedure sorts the given unit reference table in order of 862 -- ascending unit names, where the ordering relation is as described 863 -- by the comparison routines provided by package Uname. 864 865 -- The Version_Ref table records Body_Version and Version attribute 866 -- references. The entries are simply the strings for the external 867 -- names that correspond to the referenced values. 868 869 package Version_Ref is new Table.Table ( 870 Table_Component_Type => String_Id, 871 Table_Index_Type => Nat, 872 Table_Low_Bound => 1, 873 Table_Initial => 20, 874 Table_Increment => 100, 875 Table_Name => "Version_Ref"); 876 877end Lib; 878