Subversion Repositories openrisc

------------------------------------------------------------------------------

--                                                                          --

--                         GNAT COMPILER COMPONENTS                         --

--                                                                          --

--                                  L I B                                   --

--                                                                          --

--                                 S p e c                                  --

--                                                                          --

--          Copyright (C) 1992-2011, Free Software Foundation, Inc.         --

--                                                                          --

-- GNAT is free software;  you can  redistribute it  and/or modify it under --

-- terms of the  GNU General Public License as published  by the Free Soft- --

-- ware  Foundation;  either version 3,  or (at your option) any later ver- --

-- sion.  GNAT is distributed in the hope that it will be useful, but WITH- --

-- OUT ANY WARRANTY;  without even the  implied warranty of MERCHANTABILITY --

-- or FITNESS FOR A PARTICULAR PURPOSE.                                     --

--                                                                          --

-- As a special exception under Section 7 of GPL version 3, you are granted --

-- additional permissions described in the GCC Runtime Library Exception,   --

-- version 3.1, as published by the Free Software Foundation.               --

--                                                                          --

-- You should have received a copy of the GNU General Public License and    --

-- a copy of the GCC Runtime Library Exception along with this program;     --

-- see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see    --

-- <http://www.gnu.org/licenses/>.                                          --

--                                                                          --

-- GNAT was originally developed  by the GNAT team at  New York University. --

-- Extensive contributions were provided by Ada Core Technologies Inc.      --

--                                                                          --

------------------------------------------------------------------------------

--  This package contains routines for accessing and outputting the library

--  information. It contains the routine to load subsidiary units.

with Alloc;

with Namet; use Namet;

with Table;

with Types; use Types;

package Lib is

   type Unit_Ref_Table is array (Pos range <>) of Unit_Number_Type;

   --  Type to hold list of indirect references to unit number table

   type Compiler_State_Type is (Parsing, Analyzing);

   Compiler_State : Compiler_State_Type;

   --  Indicates current state of compilation. This is used to implement the

   --  function In_Extended_Main_Source_Unit.

   Parsing_Main_Extended_Source : Boolean := False;

   --  Set True if we are currently parsing a file that is part of the main

   --  extended source (the main unit, its spec, or one of its subunits). This

   --  flag to implement In_Extended_Main_Source_Unit.

   Analysing_Subunit_Of_Main : Boolean := False;

   --  Set to True when analyzing a subunit of the main source. When True, if

   --  the subunit is preprocessed and -gnateG is specified, then the

   --  preprocessed file (.prep) is written.

   --------------------------------------------

   -- General Approach to Library Management --

   --------------------------------------------

   --  As described in GNote #1, when a unit is compiled, all its subsidiary

   --  units are recompiled, including the following:

   --    (a) Corresponding spec for a body

   --    (b) Parent spec of a child library spec

   --    (d) With'ed specs

   --    (d) Parent body of a subunit

   --    (e) Subunits corresponding to any specified stubs

   --    (f) Bodies of inlined subprograms that are called

   --    (g) Bodies of generic subprograms or packages that are instantiated

   --    (h) Bodies of packages containing either of the above two items

   --    (i) Specs and bodies of runtime units

   --    (j) Parent specs for with'ed child library units

   --  If a unit is being compiled only for syntax checking, then no subsidiary

   --  units are loaded, the syntax check applies only to the main unit,

   --  i.e. the one contained in the source submitted to the library.

   --  If a unit is being compiled for syntax and semantic checking, then only

   --  cases (a)-(d) loads are performed, since the full semantic checking can

   --  be carried out without needing (e)-(i) loads. In this case no object

   --  file, or library information file, is generated, so the missing units

   --  do not affect the results.

   --  Specifications of library subprograms, subunits, and generic specs

   --  and bodies, can only be compiled in syntax/semantic checking mode,

   --  since no code is ever generated directly for these units. In the case

   --  of subunits, only the compilation of the ultimate parent unit generates

   --  actual code. If a subunit is submitted to the compiler in syntax/

   --  semantic checking mode, the parent (or parents in the nested case) are

   --  semantically checked only up to the point of the corresponding stub.

   --  If code is being generated, then all the above units are required,

   --  although the need for bodies of inlined procedures can be suppressed

   --  by the use of a switch that sets the mode to ignore pragma Inline

   --  statements.

   --  The two main sections of the front end, Par and Sem, are recursive.

   --  Compilation proceeds unit by unit making recursive calls as necessary.

   --  The process is controlled from the GNAT main program, which makes calls

   --  to Par and Sem sequence for the main unit.

   --  Par parses the given unit, and then, after the parse is complete, uses

   --  the Par.Load subprogram to load all its subsidiary units in categories

   --  (a)-(d) above, installing pointers to the loaded units in the parse

   --  tree, as described in a later section of this spec. If any of these

   --  required units is missing, a fatal error is signalled, so that no

   --  attempt is made to run Sem in such cases, since it is assumed that

   --  too many cascaded errors would result, and the confusion would not

   --  be helpful.

   --  Following the call to Par on the main unit, the entire tree of required

   --  units is thus loaded, and Sem is called on the main unit. The parameter

   --  passed to Sem is the unit to be analyzed. The visibility table, which

   --  is a single global structure, starts out containing only the entries

   --  for the visible entities in Standard. Every call to Sem establishes a

   --  new scope stack table, pushing an entry for Standard on entry to provide

   --  the proper initial scope environment.

   --  Sem first proceeds to perform semantic analysis on the currently loaded

   --  units as follows:

   --    In the case of a body (case (a) above), Sem analyzes the corresponding

   --    spec, using a recursive call to Sem. As is always expected to be the

   --    case with calls to Sem, any entities installed in the visibility table

   --    are removed on exit from Sem, so that these entities have to be

   --    reinstalled on return to continue the analysis of the body which of

   --    course needs visibility of these entities.

   --

   --    In the case of the parent of a child spec (case (b) above), a similar

   --    call is made to Sem to analyze the parent. Again, on return, the

   --    entities from the analyzed parent spec have to be installed in the

   --    visibility table of the caller (the child unit), which must have

   --    visibility to the entities in its parent spec.

   --    For with'ed specs (case (c) above), a recursive call to Sem is made

   --    to analyze each spec in turn. After all the spec's have been analyzed,

   --    but not till that point, the entities from all the with'ed units are

   --    reinstalled in the visibility table so that the caller can proceed

   --    with the analysis of the unit doing the with's with the necessary

   --    entities made either potentially use visible or visible by selection

   --    as needed.

   --    Case (d) arises when Sem is passed a subunit to analyze. This means

   --    that the main unit is a subunit, and the unit passed to Sem is either

   --    the main unit, or one of its ancestors that is still a subunit. Since

   --    analysis must start at the top of the tree, Sem essentially cancels

   --    the current call by immediately making a call to analyze the parent

   --    (when this call is finished it immediately returns, so logically this

   --    call is like a goto). The subunit will then be analyzed at the proper

   --    time as described for the stub case. Note that we also turn off the

   --    indication that code should be generated in this case, since the only

   --    time we generate code for subunits is when compiling the main parent.

   --    Case (e), subunits corresponding to stubs, are handled as the stubs

   --    are encountered. There are three sub-cases:

   --      If the subunit has already been loaded, then this means that the

   --      main unit was a subunit, and we are back on our way down to it

   --      after following the initial processing described for case (d).

   --      In this case we analyze this particular subunit, as described

   --      for the case where we are generating code, but when we get back

   --      we are all done, since the rest of the parent is irrelevant. To

   --      get out of the parent, we raise the exception Subunit_Found, which

   --      is handled at the outer level of Sem.

   --      The cases where the subunit has not already been loaded correspond

   --      to cases where the main unit was a parent. In this case the action

   --      depends on whether or not we are generating code. If we are not

   --      generating code, then this is the case where we can simply ignore

   --      the subunit, since in checking mode we don't even want to insist

   --      that the subunit exist, much less waste time checking it.

   --      If we are generating code, then we need to load and analyze

   --      all subunits. This is achieved with a call to Lib.Load to load

   --      and parse the unit, followed by processing that installs the

   --      context clause of the subunit, analyzes the subunit, and then

   --      removes the context clause (from the visibility chains of the

   --      parent). Note that we do *not* do a recursive call to Sem in

   --      this case, precisely because we need to do the analysis of the

   --      subunit with the current visibility table and scope stack.

   --    Case (f) applies only to subprograms for which a pragma Inline is

   --    given, providing that the compiler is operating in the mode where

   --    pragma Inline's are activated. When the expander encounters a call

   --    to such a subprogram, it loads the body of the subprogram if it has

   --    not already been loaded, and calls Sem to process it.

   --    Case (g) is similar to case (f), except that the body of a generic

   --    is unconditionally required, regardless of compiler mode settings.

   --    As in the subprogram case, when the expander encounters a generic

   --    instantiation, it loads the generic body of the subprogram if it

   --    has not already been loaded, and calls Sem to process it.

   --    Case (h) arises when a package contains either an inlined subprogram

   --    which is called, or a generic which is instantiated. In this case the

   --    body of the package must be loaded and analyzed with a call to Sem.

   --    Case (i) is handled by adding implicit with clauses to the context

   --    clauses of all units that potentially reference the relevant runtime

   --    entities. Note that since we have the full set of units available,

   --    the parser can always determine the set of runtime units that is

   --    needed. These with clauses do not have associated use clauses, so

   --    all references to the entities must be by selection. Once the with

   --    clauses have been added, subsequent processing is as for normal

   --    with clauses.

   --    Case (j) is also handled by adding appropriate implicit with clauses

   --    to any unit that withs a child unit. Again there is no use clause,

   --    and subsequent processing proceeds as for an explicit with clause.

   --  Sem thus completes the loading of all required units, except those

   --  required for inline subprogram bodies or inlined generics. If any

   --  of these load attempts fails, then the expander will not be called,

   --  even if code was to be generated. If the load attempts all succeed

   --  then the expander is called, though the attempt to generate code may

   --  still fail if an error occurs during a load attempt for an inlined

   --  body or a generic body.

   -------------------------------------------

   -- Special Handling of Subprogram Bodies --

   -------------------------------------------

   --  A subprogram body (in an adb file) may stand for both a spec and a body.

   --  A simple model (and one that was adopted through version 2.07) is simply

   --  to assume that such an adb file acts as its own spec if no ads file is

   --  is present.

   --  However, this is not correct. RM 10.1.4(4) requires that such a body

   --  act as a spec unless a subprogram declaration of the same name is

   --  already present. The correct interpretation of this in GNAT library

   --  terms is to ignore an existing ads file of the same name unless this

   --  ads file contains a subprogram declaration with the same name.

   --  If there is an ads file with a unit other than a subprogram declaration

   --  with the same name, then a fatal message is output, noting that this

   --  irrelevant file must be deleted before the body can be compiled. See

   --  ACVC test CA1020D to see how this processing is required.

   -----------------

   -- Global Data --

   -----------------

   Current_Sem_Unit : Unit_Number_Type := Main_Unit;

   --  Unit number of unit currently being analyzed/expanded. This is set when

   --  ever a new unit is entered, saving and restoring the old value, so that

   --  it always reflects the unit currently being analyzed. The initial value

   --  of Main_Unit ensures that a proper value is set initially, and in

   --  particular for analysis of configuration pragmas in gnat.adc.

   Main_Unit_Entity : Entity_Id;

   --  Entity of main unit, same as Cunit_Entity (Main_Unit) except where

   --  Main_Unit is a body with a separate spec, in which case it is the

   --  entity for the spec.

   -----------------

   -- Units Table --

   -----------------

   --  The units table has an entry for each unit (source file) read in by the

   --  current compilation. The table is indexed by the unit number value,

   --  The first entry in the table, subscript Main_Unit, is for the main file.

   --  Each entry in this units table contains the following data.

   --    Unit_File_Name

   --      The name of the source file containing the unit. Set when the entry

   --      is created by a call to Lib.Load, and then cannot be changed.

   --    Source_Index

   --      The index in the source file table of the corresponding source file.

   --      Set when the entry is created by a call to Lib.Load and then cannot

   --      be changed.

   --    Munit_Index

   --      The index of the unit within the file for multiple unit per file

   --      mode. Set to zero in normal single unit per file mode.

   --    Error_Location

   --      This is copied from the Sloc field of the Enode argument passed

   --      to Load_Unit. It refers to the enclosing construct which caused

   --      this unit to be loaded, e.g. most typically the with clause that

   --      referenced the unit, and is used for error handling in Par.Load.

   --    Expected_Unit

   --      This is the expected unit name for a file other than the main unit,

   --      since these are cases where we load the unit using Lib.Load and we

   --      know the unit that is expected. It must be the same as Unit_Name

   --      if it is set (see test in Par.Load). Expected_Unit is set to

   --      No_Name for the main unit.

   --    Unit_Name

   --      The name of the unit. Initialized to No_Name by Lib.Load, and then

   --      set by the parser when the unit is parsed to the unit name actually

   --      found in the file (which should, in the absence of errors) be the

   --      same name as Expected_Unit.

   --    Cunit

   --      Pointer to the N_Compilation_Unit node. Initially set to Empty by

   --      Lib.Load, and then reset to the required node by the parser when

   --      the unit is parsed.

   --    Cunit_Entity

   --      Pointer to the entity node for the compilation unit. Initially set

   --      to Empty by Lib.Load, and then reset to the required entity by the

   --      parser when the unit is parsed.

   --    Dependency_Num

   --      This is the number of the unit within the generated dependency

   --      lines (D lines in the ALI file) which are sorted into alphabetical

   --      order. The number is ones origin, so a value of 2 refers to the

   --      second generated D line. The Dependency_Number values are set

   --      as the D lines are generated, and are used to generate proper

   --      unit references in the generated xref information and SCO output.

   --    Dynamic_Elab

   --      A flag indicating if this unit was compiled with dynamic elaboration

   --      checks specified (as the result of using the -gnatE compilation

   --      option or a pragma Elaboration_Checks (Dynamic).

   --    Fatal_Error

   --      A flag that is initialized to False, and gets set to True if a fatal

   --      error occurs during the processing of a unit. A fatal error is one

   --      defined as serious enough to stop the next phase of the compiler

   --      from running (i.e. fatal error during parsing stops semantics,

   --      fatal error during semantics stops code generation). Note that

   --      currently, errors of any kind cause Fatal_Error to be set, but

   --      eventually perhaps only errors labeled as Fatal_Errors should be

   --      this severe if we decide to try Sem on sources with minor errors.

   --    Generate_Code

   --      This flag is set True for all units in the current file for which

   --      code is to be generated. This includes the unit explicitly compiled,

   --      together with its specification, and any subunits.

   --    Has_RACW

   --      A Boolean flag, initially set to False when a unit entry is created,

   --      and set to True if the unit defines a remote access to class wide

   --      (RACW) object. This is used for controlling generation of the RA

   --      attribute in the ali file.

   --    Is_Compiler_Unit

   --      A Boolean flag, initially set False by default, set to True if a

   --      pragma Compiler_Unit appears in the unit.

   --    Ident_String

   --      N_String_Literal node from a valid pragma Ident that applies to

   --      this unit. If no Ident pragma applies to the unit, then Empty.

   --    Loading

   --      A flag that is used to catch circular WITH dependencies. It is set

   --      True when an entry is initially created in the file table, and set

   --      False when the load is completed, or ends with an error.

   --    Main_Priority

   --      This field is used to indicate the priority of a possible main

   --      program, as set by a pragma Priority. A value of -1 indicates

   --      that the default priority is to be used (and is also used for

   --      entries that do not correspond to possible main programs).

   --    Main_CPU

   --      This field is used to indicate the affinity of a possible main

   --      program, as set by a pragma CPU. A value of -1 indicates

   --      that the default affinity is to be used (and is also used for

   --      entries that do not correspond to possible main programs).

   --    Has_Allocator

   --      This flag is set if a subprogram unit has an allocator after the

   --      BEGIN (it is used to set the AB flag in the M ALI line).

   --    OA_Setting

   --      This is a character field containing L if Optimize_Alignment mode

   --      was set locally, and O/T/S for Off/Time/Space default if not.

   --    Serial_Number

   --      This field holds a serial number used by New_Internal_Name to

   --      generate unique temporary numbers on a unit by unit basis. The

   --      only access to this field is via the Increment_Serial_Number

   --      routine which increments the current value and returns it. This

   --      serial number is separate for each unit.

   --    Version

   --      This field holds the version of the unit, which is computed as

   --      the exclusive or of the checksums of this unit, and all its

   --      semantically dependent units. Access to the version number field

   --      is not direct, but is done through the routines described below.

   --      When a unit table entry is created, this field is initialized to

   --      the checksum of the corresponding source file. Version_Update is

   --      then called to reflect the contributions of any unit on which this

   --      unit is semantically dependent.

   --  The units table is reset to empty at the start of the compilation of

   --  each main unit by Lib.Initialize. Entries are then added by calls to

   --  the Lib.Load procedure. The following subprograms are used to access

   --  and modify entries in the Units table. Individual entries are accessed

   --  using a unit number value which ranges from Main_Unit (the first entry,

   --  which is always for the current main unit) to Last_Unit.

   Default_Main_Priority : constant Int := -1;

   --  Value used in Main_Priority field to indicate default main priority

   Default_Main_CPU : constant Int := -1;

   --  Value used in Main_CPU field to indicate default main affinity

   function Cunit            (U : Unit_Number_Type) return Node_Id;

   function Cunit_Entity     (U : Unit_Number_Type) return Entity_Id;

   function Dependency_Num   (U : Unit_Number_Type) return Nat;

   function Dynamic_Elab     (U : Unit_Number_Type) return Boolean;

   function Error_Location   (U : Unit_Number_Type) return Source_Ptr;

   function Expected_Unit    (U : Unit_Number_Type) return Unit_Name_Type;

   function Fatal_Error      (U : Unit_Number_Type) return Boolean;

   function Generate_Code    (U : Unit_Number_Type) return Boolean;

   function Ident_String     (U : Unit_Number_Type) return Node_Id;

   function Has_Allocator    (U : Unit_Number_Type) return Boolean;

   function Has_RACW         (U : Unit_Number_Type) return Boolean;

   function Is_Compiler_Unit (U : Unit_Number_Type) return Boolean;

   function Loading          (U : Unit_Number_Type) return Boolean;

   function Main_CPU         (U : Unit_Number_Type) return Int;

   function Main_Priority    (U : Unit_Number_Type) return Int;

   function Munit_Index      (U : Unit_Number_Type) return Nat;

   function OA_Setting       (U : Unit_Number_Type) return Character;

   function Source_Index     (U : Unit_Number_Type) return Source_File_Index;

   function Unit_File_Name   (U : Unit_Number_Type) return File_Name_Type;

   function Unit_Name        (U : Unit_Number_Type) return Unit_Name_Type;

   --  Get value of named field from given units table entry

   procedure Set_Cunit            (U : Unit_Number_Type; N : Node_Id);

   procedure Set_Cunit_Entity     (U : Unit_Number_Type; E : Entity_Id);

   procedure Set_Dynamic_Elab     (U : Unit_Number_Type; B : Boolean := True);

   procedure Set_Error_Location   (U : Unit_Number_Type; W : Source_Ptr);

   procedure Set_Fatal_Error      (U : Unit_Number_Type; B : Boolean := True);

   procedure Set_Generate_Code    (U : Unit_Number_Type; B : Boolean := True);

   procedure Set_Has_RACW         (U : Unit_Number_Type; B : Boolean := True);

   procedure Set_Has_Allocator    (U : Unit_Number_Type; B : Boolean := True);

   procedure Set_Is_Compiler_Unit (U : Unit_Number_Type; B : Boolean := True);

   procedure Set_Ident_String     (U : Unit_Number_Type; N : Node_Id);

   procedure Set_Loading          (U : Unit_Number_Type; B : Boolean := True);

   procedure Set_Main_CPU         (U : Unit_Number_Type; P : Int);

   procedure Set_Main_Priority    (U : Unit_Number_Type; P : Int);

   procedure Set_OA_Setting       (U : Unit_Number_Type; C : Character);

   procedure Set_Unit_Name        (U : Unit_Number_Type; N : Unit_Name_Type);

   --  Set value of named field for given units table entry. Note that we

   --  do not have an entry for each possible field, since some of the fields

   --  can only be set by specialized interfaces (defined below).

   function Version_Get (U : Unit_Number_Type) return Word_Hex_String;

   --  Returns the version as a string with 8 hex digits (upper case letters)

   function Last_Unit return Unit_Number_Type;

   --  Unit number of last allocated unit

   function Num_Units return Nat;

   --  Number of units currently in unit table

   procedure Remove_Unit (U : Unit_Number_Type);

   --  Remove unit U from unit table. Currently this is effective only

   --  if U is the last unit currently stored in the unit table.

   function Entity_Is_In_Main_Unit (E : Entity_Id) return Boolean;

   --  Returns True if the entity E is declared in the main unit, or, in

   --  its corresponding spec, or one of its subunits. Entities declared

   --  within generic instantiations return True if the instantiation is

   --  itself "in the main unit" by this definition. Otherwise False.

   function Get_Source_Unit (N : Node_Or_Entity_Id) return Unit_Number_Type;

   pragma Inline (Get_Source_Unit);

   function Get_Source_Unit (S : Source_Ptr) return Unit_Number_Type;

   --  Return unit number of file identified by given source pointer value.

   --  This call must always succeed, since any valid source pointer value

   --  belongs to some previously loaded module. If the given source pointer

   --  value is within an instantiation, this function returns the unit number

   --  of the template, i.e. the unit containing the source code corresponding

   --  to the given Source_Ptr value. The version taking a Node_Id argument, N,

   --  simply applies the function to Sloc (N).

   function Get_Code_Unit (N : Node_Or_Entity_Id) return Unit_Number_Type;

   pragma Inline (Get_Code_Unit);

   function Get_Code_Unit (S : Source_Ptr) return Unit_Number_Type;

   --  This is like Get_Source_Unit, except that in the instantiation case,

   --  it uses the location of the top level instantiation, rather than the

   --  template, so it returns the unit number containing the code that

   --  corresponds to the node N, or the source location S.

   function In_Same_Source_Unit (N1, N2 : Node_Or_Entity_Id) return Boolean;

   pragma Inline (In_Same_Source_Unit);

   --  Determines if the two nodes or entities N1 and N2 are in the same

   --  source unit, the criterion being that Get_Source_Unit yields the

   --  same value for each argument.

   function In_Same_Code_Unit (N1, N2 : Node_Or_Entity_Id) return Boolean;

   pragma Inline (In_Same_Code_Unit);

   --  Determines if the two nodes or entities N1 and N2 are in the same

   --  code unit, the criterion being that Get_Code_Unit yields the same

   --  value for each argument.

   function In_Same_Extended_Unit (N1, N2 : Node_Or_Entity_Id) return Boolean;

   pragma Inline (In_Same_Extended_Unit);

   --  Determines if two nodes or entities N1 and N2 are in the same

   --  extended unit, where an extended unit is defined as a unit and all

   --  its subunits (considered recursively, i.e. subunits of subunits are

   --  included). Returns true if S1 and S2 are in the same extended unit

   --  and False otherwise.

   function In_Same_Extended_Unit (S1, S2 : Source_Ptr) return Boolean;

   pragma Inline (In_Same_Extended_Unit);

   --  Determines if the two source locations S1 and S2 are in the same

   --  extended unit, where an extended unit is defined as a unit and all

   --  its subunits (considered recursively, i.e. subunits of subunits are

   --  included). Returns true if S1 and S2 are in the same extended unit

   --  and False otherwise.

   function In_Extended_Main_Code_Unit

     (N : Node_Or_Entity_Id) return Boolean;

   --  Return True if the node is in the generated code of the extended main

   --  unit, defined as the main unit, its specification (if any), and all

   --  its subunits (considered recursively). Units for which this enquiry

   --  returns True are those for which code will be generated. Nodes from

   --  instantiations are included in the extended main unit for this call.

   --  If the main unit is itself a subunit, then the extended main code unit

   --  includes its parent unit, and the parent unit spec if it is separate.

   function In_Extended_Main_Code_Unit (Loc : Source_Ptr) return Boolean;

   --  Same function as above, but argument is a source pointer rather

   --  than a node.

   function In_Extended_Main_Source_Unit

     (N : Node_Or_Entity_Id) return Boolean;

   --  Return True if the node is in the source text of the extended main

   --  unit, defined as the main unit, its specification (if any), and all

   --  its subunits (considered recursively). Units for which this enquiry

   --  returns True are those for which code will be generated. This differs

   --  from In_Extended_Main_Code_Unit only in that instantiations are not

   --  included for the purposes of this call. If the main unit is itself

   --  a subunit, then the extended main source unit includes its parent unit,

   --  and the parent unit spec if it is separate.

   function In_Extended_Main_Source_Unit (Loc : Source_Ptr) return Boolean;

   --  Same function as above, but argument is a source pointer

   function In_Predefined_Unit (N : Node_Or_Entity_Id) return Boolean;

   --  Returns True if the given node or entity appears within the source text

   --  of a predefined unit (i.e. within Ada, Interfaces, System or within one

   --  of the descendent packages of one of these three packages).

   function In_Predefined_Unit (S : Source_Ptr) return Boolean;

   --  Same function as above but argument is a source pointer

   function Earlier_In_Extended_Unit (S1, S2 : Source_Ptr) return Boolean;

   --  Given two Sloc values for which In_Same_Extended_Unit is true, determine

   --  if S1 appears before S2. Returns True if S1 appears before S2, and False

   --  otherwise. The result is undefined if S1 and S2 are not in the same

   --  extended unit. Note: this routine will not give reliable results if

   --  called after Sprint has been called with -gnatD set.

   function Exact_Source_Name (Loc : Source_Ptr) return String;

   --  Return name of entity at location Loc exactly as written in the source.

   --  this includes copying the wide character encodings exactly as they were

   --  used in the source, so the caller must be aware of the possibility of

   --  such encodings.

   function Compilation_Switches_Last return Nat;

   --  Return the count of stored compilation switches

   function Get_Compilation_Switch (N : Pos) return String_Ptr;

   --  Return the Nth stored compilation switch, or null if less than N

   --  switches have been stored. Used by ASIS and back ends written in Ada.

   function Get_Cunit_Unit_Number (N : Node_Id) return Unit_Number_Type;

   --  Return unit number of the unit whose N_Compilation_Unit node is the

   --  one passed as an argument. This must always succeed since the node

   --  could not have been built without making a unit table entry.

   function Get_Cunit_Entity_Unit_Number

     (E : Entity_Id) return Unit_Number_Type;

   --  Return unit number of the unit whose compilation unit spec entity is

   --  the one passed as an argument. This must always succeed since the

   --  entity could not have been built without making a unit table entry.

   function Increment_Serial_Number return Nat;

   --  Increment Serial_Number field for current unit, and return the

   --  incremented value.

   procedure Synchronize_Serial_Number;

   --  This function increments the Serial_Number field for the current unit

   --  but does not return the incremented value. This is used when there

   --  is a situation where one path of control increments a serial number

   --  (using Increment_Serial_Number), and the other path does not and it is

   --  important to keep the serial numbers synchronized in the two cases (e.g.

   --  when the references in a package and a client must be kept consistent).

   procedure Replace_Linker_Option_String

     (S            : String_Id;

      Match_String : String);

   --  Replace an existing Linker_Option if the prefix Match_String matches,

   --  otherwise call Store_Linker_Option_String.

   procedure Store_Compilation_Switch (Switch : String);

   --  Called to register a compilation switch, either front-end or back-end,

   --  which may influence the generated output file(s). Switch is the text of

   --  the switch to store (except that -fRTS gets changed back to --RTS).

   procedure Enable_Switch_Storing;

   --  Enable registration of switches by Store_Compilation_Switch. Used to

   --  avoid registering switches added automatically by the gcc driver at the

   --  beginning of the command line.

   procedure Disable_Switch_Storing;

   --  Disable registration of switches by Store_Compilation_Switch. Used to

   --  avoid registering switches added automatically by the gcc driver at the

   --  end of the command line.

   procedure Store_Linker_Option_String (S : String_Id);

   --  This procedure is called to register the string from a pragma

   --  Linker_Option. The argument is the Id of the string to register.

   procedure Store_Note (N : Node_Id);

   --  This procedure is called to register a pragma N for which a notes

   --  entry is required.

   procedure Initialize;

   --  Initialize internal tables

   procedure Lock;

   --  Lock internal tables before calling back end

   procedure Unlock;

   --  Unlock internal tables, in cases where the back end needs to modify them

   procedure Tree_Read;

   --  Initializes internal tables from current tree file using the relevant

   --  Table.Tree_Read routines.

   procedure Tree_Write;

   --  Writes out internal tables to current tree file using the relevant

   --  Table.Tree_Write routines.

   function Is_Loaded (Uname : Unit_Name_Type) return Boolean;

   --  Determines if unit with given name is already loaded, i.e. there is

   --  already an entry in the file table with this unit name for which the

   --  corresponding file was found and parsed. Note that the Fatal_Error flag

   --  of this entry must be checked before proceeding with further processing.

   procedure Version_Referenced (S : String_Id);

   --  This routine is called from Exp_Attr to register the use of a Version

   --  or Body_Version attribute. The argument is the external name used to

   --  access the version string.

   procedure List (File_Names_Only : Boolean := False);

   --  Lists units in active library (i.e. generates output consisting of a

   --  sorted listing of the units represented in File table, except for the

   --  main unit). If File_Names_Only is set to True, then the list includes

   --  only file names, and no other information. Otherwise the unit name and

   --  time stamp are also output. File_Names_Only also restricts the list to

   --  exclude any predefined files.

   function Generic_May_Lack_ALI (Sfile : File_Name_Type) return Boolean;

   --  Generic units must be separately compiled. Since we always use

   --  macro substitution for generics, the resulting object file is a dummy

   --  one with no code, but the ALI file has the normal form, and we need

   --  this ALI file so that the binder can work out a correct order of

   --  elaboration.

   --  However, ancient versions of GNAT used to not generate code or ALI

   --  files for generic units, and this would yield complex order of

   --  elaboration issues. These were fixed in GNAT 3.10. The support for not

   --  compiling language-defined library generics was retained nonetheless

   --  to facilitate bootstrap. Specifically, it is convenient to have

   --  the same list of files to be compiled for all stages. So, if the

   --  bootstrap compiler does not generate code for a given file, then

   --  the stage1 compiler (and binder) also must deal with the case of

   --  that file not being compiled. The predicate Generic_May_Lack_ALI is

   --  True for those generic units for which missing ALI files are allowed.

private

   pragma Inline (Cunit);

   pragma Inline (Cunit_Entity);

   pragma Inline (Dependency_Num);

   pragma Inline (Fatal_Error);

   pragma Inline (Generate_Code);

   pragma Inline (Has_Allocator);

   pragma Inline (Has_RACW);

   pragma Inline (Is_Compiler_Unit);

   pragma Inline (Increment_Serial_Number);

   pragma Inline (Loading);

   pragma Inline (Main_CPU);

   pragma Inline (Main_Priority);

   pragma Inline (Munit_Index);

   pragma Inline (OA_Setting);

   pragma Inline (Set_Cunit);

   pragma Inline (Set_Cunit_Entity);

   pragma Inline (Set_Fatal_Error);

   pragma Inline (Set_Generate_Code);

   pragma Inline (Set_Has_Allocator);

   pragma Inline (Set_Has_RACW);

   pragma Inline (Set_Loading);

   pragma Inline (Set_Main_CPU);

   pragma Inline (Set_Main_Priority);

   pragma Inline (Set_OA_Setting);

   pragma Inline (Set_Unit_Name);

   pragma Inline (Source_Index);

   pragma Inline (Unit_File_Name);

   pragma Inline (Unit_Name);

   type Unit_Record is record

      Unit_File_Name   : File_Name_Type;

      Unit_Name        : Unit_Name_Type;

      Munit_Index      : Nat;

      Expected_Unit    : Unit_Name_Type;

      Source_Index     : Source_File_Index;

      Cunit            : Node_Id;

      Cunit_Entity     : Entity_Id;

      Dependency_Num   : Int;

      Ident_String     : Node_Id;

      Main_Priority    : Int;

      Main_CPU         : Int;

      Serial_Number    : Nat;

      Version          : Word;

      Error_Location   : Source_Ptr;

      Fatal_Error      : Boolean;

      Generate_Code    : Boolean;

      Has_RACW         : Boolean;

      Is_Compiler_Unit : Boolean;

      Dynamic_Elab     : Boolean;

      Loading          : Boolean;

      Has_Allocator    : Boolean;

      OA_Setting       : Character;

   end record;

   --  The following representation clause ensures that the above record

   --  has no holes. We do this so that when instances of this record are

   --  written by Tree_Gen, we do not write uninitialized values to the file.

   for Unit_Record use record

      Unit_File_Name   at  0 range 0 .. 31;

      Unit_Name        at  4 range 0 .. 31;

      Munit_Index      at  8 range 0 .. 31;

      Expected_Unit    at 12 range 0 .. 31;

      Source_Index     at 16 range 0 .. 31;

      Cunit            at 20 range 0 .. 31;

      Cunit_Entity     at 24 range 0 .. 31;

      Dependency_Num   at 28 range 0 .. 31;

      Ident_String     at 32 range 0 .. 31;

      Main_Priority    at 36 range 0 .. 31;

      Main_CPU         at 40 range 0 .. 31;

      Serial_Number    at 44 range 0 .. 31;

      Version          at 48 range 0 .. 31;

      Error_Location   at 52 range 0 .. 31;

      Fatal_Error      at 56 range 0 ..  7;

      Generate_Code    at 57 range 0 ..  7;

      Has_RACW         at 58 range 0 ..  7;

      Dynamic_Elab     at 59 range 0 ..  7;

      Is_Compiler_Unit at 60 range 0 ..  7;

      OA_Setting       at 61 range 0 ..  7;

      Loading          at 62 range 0 ..  7;

      Has_Allocator    at 63 range 0 ..  7;

   end record;

   for Unit_Record'Size use 64 * 8;

   --  This ensures that we did not leave out any fields

   package Units is new Table.Table (

     Table_Component_Type => Unit_Record,

     Table_Index_Type     => Unit_Number_Type,

     Table_Low_Bound      => Main_Unit,

     Table_Initial        => Alloc.Units_Initial,

     Table_Increment      => Alloc.Units_Increment,

     Table_Name           => "Units");

   --  The following table stores strings from pragma Linker_Option lines

   type Linker_Option_Entry is record

      Option : String_Id;

      --  The string for the linker option line

      Unit : Unit_Number_Type;

      --  The unit from which the linker option comes

   end record;

   package Linker_Option_Lines is new Table.Table (

     Table_Component_Type => Linker_Option_Entry,

     Table_Index_Type     => Integer,

     Table_Low_Bound      => 1,

     Table_Initial        => Alloc.Linker_Option_Lines_Initial,

     Table_Increment      => Alloc.Linker_Option_Lines_Increment,

     Table_Name           => "Linker_Option_Lines");

   --  The following table stores references to pragmas that generate Notes

   type Notes_Entry is record

      Pragma_Node : Node_Id;

      Unit        : Unit_Number_Type;

   end record;

   package Notes is new Table.Table (