blob: 3df78bf0ceedf612314ec068579641153bf3195a [file] [log] [blame]
------------------------------------------------------------------------------
-- --
-- GNAT COMPILER COMPONENTS --
-- --
-- B I N D E --
-- --
-- B o d y --
-- --
-- Copyright (C) 1992-2021, 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. See the GNU General Public License --
-- for more details. You should have received a copy of the GNU General --
-- Public License distributed with GNAT; see file COPYING3. If not, go to --
-- http://www.gnu.org/licenses for a complete copy of the license. --
-- --
-- GNAT was originally developed by the GNAT team at New York University. --
-- Extensive contributions were provided by Ada Core Technologies Inc. --
-- --
------------------------------------------------------------------------------
with Binderr; use Binderr;
with Butil; use Butil;
with Debug; use Debug;
with Fname; use Fname;
with Opt; use Opt;
with Osint;
with Output; use Output;
with Table;
with Types; use Types;
with System.Case_Util; use System.Case_Util;
with System.HTable;
package body Binde is
use Unit_Id_Tables;
-- We now have Elab_New, a new elaboration-order algorithm.
--
-- However, any change to elaboration order can break some programs.
-- Therefore, we are keeping the old algorithm in place, to be selected
-- by switches.
--
-- The new algorithm has the following interesting properties:
--
-- * The static and dynamic models use the same elaboration order. The
-- static model might get an error, but if it does not, it will use
-- the same order as the dynamic model.
--
-- * Each SCC (see below) is elaborated together; that is, units from
-- different SCCs are not interspersed.
--
-- * In particular, this implies that if an SCC contains just a spec and
-- the corresponding body, and nothing else, the body will be
-- elaborated immediately after the spec. This is expected to result
-- in a better elaboration order for most programs, because in this
-- case, a call from outside the library unit cannot get ABE.
--
-- * Pragmas Elaborate_All (explicit and implicit) are ignored. Instead,
-- we behave as if every legal pragma Elaborate_All were present. That
-- is, if it would be legal to have "pragma Elaborate_All(Y);" on X,
-- then we behave as if such a pragma exists, even if it does not.
Do_Old : constant Boolean := False;
Do_New : constant Boolean := True;
-- True to enable the old and new algorithms, respectively. Used for
-- debugging/experimentation.
Doing_New : Boolean := False;
-- True if we are currently doing the new algorithm. Print certain
-- messages only when doing the "new" elab order algorithm, so we don't get
-- duplicates. And use different heuristics in Better_Choice_Optimistic.
-- The following data structures are used to represent the graph that is
-- used to determine the elaboration order (using a topological sort).
-- The following structures are used to record successors. If B is a
-- successor of A in this table, it means that A must be elaborated before
-- B is elaborated. For example, if Y (body) says "with X;", then Y (body)
-- will be a successor of X (spec), and X (spec) will be a predecessor of
-- Y (body).
--
-- Note that we store the successors of each unit explicitly. We don't
-- store the predecessors, but we store a count of them.
--
-- The basic algorithm is to first compute a directed graph of units (type
-- Unit_Node_Record, below), with successors as edges. A unit is "ready"
-- (to be chosen as the next to be elaborated) if it has no predecessors
-- that have not yet been chosen. We use heuristics to decide which of the
-- ready units should be elaborated next, and "choose" that one (which
-- means we append it to the elaboration-order table).
type Successor_Id is new Nat;
-- Identification of single successor entry
No_Successor : constant Successor_Id := 0;
-- Used to indicate end of list of successors
type Elab_All_Id is new Nat;
-- Identification of Elab_All entry link
No_Elab_All_Link : constant Elab_All_Id := 0;
-- Used to indicate end of list
-- Succ_Reason indicates the reason for a particular elaboration link
type Succ_Reason is
(Withed,
-- After directly with's Before, so the spec of Before must be
-- elaborated before After is elaborated.
Forced,
-- Before and After come from a pair of lines in the forced-elaboration-
-- order file.
Elab,
-- After directly mentions Before in a pragma Elaborate, so the body of
-- Before must be elaborated before After is elaborated.
Elab_All,
-- After either mentions Before directly in a pragma Elaborate_All, or
-- mentions a third unit, X, which itself requires that Before be
-- elaborated before unit X is elaborated. The Elab_All_Link list traces
-- the dependencies in the latter case.
Elab_All_Desirable,
-- This is just like Elab_All, except that the Elaborate_All was not
-- explicitly present in the source, but rather was created by the front
-- end, which decided that it was "desirable".
Elab_Desirable,
-- This is just like Elab, except that the Elaborate was not explicitly
-- present in the source, but rather was created by the front end, which
-- decided that it was "desirable".
Spec_First);
-- After is a body, and Before is the corresponding spec
-- Successor_Link contains the information for one link
type Successor_Link is record
Before : Unit_Id;
-- Predecessor unit
After : Unit_Id;
-- Successor unit
Next : Successor_Id;
-- Next successor on this list
Reason : Succ_Reason;
-- Reason for this link
Elab_Body : Boolean;
-- Set True if this link is needed for the special Elaborate_Body
-- processing described below.
Reason_Unit : Unit_Id;
-- For Reason = Elab, or Elab_All or Elab_Desirable, records the unit
-- containing the pragma leading to the link.
Elab_All_Link : Elab_All_Id;
-- If Reason = Elab_All or Elab_Desirable, then this points to the
-- first element in a list of Elab_All entries that record the with
-- chain resulting in this particular dependency.
end record;
-- Note on handling of Elaborate_Body. Basically, if we have a pragma
-- Elaborate_Body in a unit, it means that the spec and body have to be
-- handled as a single entity from the point of view of determining an
-- elaboration order. What we do is to essentially remove the body from
-- consideration completely, and transfer all its links (other than the
-- spec link) to the spec. Then when the spec gets chosen, we choose the
-- body right afterwards. We mark the links that get moved from the body to
-- the spec by setting their Elab_Body flag True, so that we can understand
-- what is going on.
Succ_First : constant := 1;
package Succ is new Table.Table
(Table_Component_Type => Successor_Link,
Table_Index_Type => Successor_Id,
Table_Low_Bound => Succ_First,
Table_Initial => 500,
Table_Increment => 200,
Table_Name => "Succ");
-- For the case of Elaborate_All, the following table is used to record
-- chains of with relationships that lead to the Elab_All link. These are
-- used solely for diagnostic purposes
type Elab_All_Entry is record
Needed_By : Unit_Name_Type;
-- Name of unit from which referencing unit was with'ed or otherwise
-- needed as a result of Elaborate_All or Elaborate_Desirable.
Next_Elab : Elab_All_Id;
-- Link to next entry on chain (No_Elab_All_Link marks end of list)
end record;
package Elab_All_Entries is new Table.Table
(Table_Component_Type => Elab_All_Entry,
Table_Index_Type => Elab_All_Id,
Table_Low_Bound => 1,
Table_Initial => 2000,
Table_Increment => 200,
Table_Name => "Elab_All_Entries");
type Unit_Id_Array_Ptr is access Unit_Id_Array;
-- A Unit_Node_Record is built for each active unit
type Unit_Node_Record is record
Successors : Successor_Id;
-- Pointer to list of links for successor nodes
Num_Pred : Int;
-- Number of predecessors for this unit that have not yet been chosen.
-- Normally non-negative, but can go negative in the case of units
-- chosen by the diagnose error procedure (when cycles are being removed
-- from the graph).
Nextnp : Unit_Id;
-- Forward pointer for list of units with no predecessors
Visited : Boolean;
-- Used in computing transitive closure for Elaborate_All and also in
-- locating cycles and paths in the diagnose routines.
Elab_Position : Nat;
-- Initialized to zero. Set non-zero when a unit is chosen and placed in
-- the elaboration order. The value represents the ordinal position in
-- the elaboration order.
-- The following are for Elab_New. We compute the strongly connected
-- components (SCCs) of the directed graph of units. The edges are the
-- Successors, which do not include pragmas Elaborate_All (explicit or
-- implicit) in Elab_New. In addition, we assume there is a edge
-- pointing from a body to its corresponding spec; this edge is not
-- included in Successors, because of course a spec is elaborated BEFORE
-- its body, not after.
SCC_Root : Unit_Id;
-- Each unit points to the root of its SCC, which is just an arbitrary
-- member of the SCC. Two units are in the same SCC if and only if their
-- SCC_Roots are equal. U is the root of its SCC if and only if
-- SCC(U)=U.
Nodes : Unit_Id_Array_Ptr;
-- Present only in the root of an SCC. This is the set of units in the
-- SCC, in no particular order.
SCC_Num_Pred : Int;
-- Present only in the root of an SCC. This is the number of predecessor
-- units of the SCC that are in other SCCs, and that have not yet been
-- chosen.
Validate_Seen : Boolean := False;
-- See procedure Validate below
end record;
package UNR is new Table.Table
(Table_Component_Type => Unit_Node_Record,
Table_Index_Type => Unit_Id,
Table_Low_Bound => First_Unit_Entry,
Table_Initial => 500,
Table_Increment => 200,
Table_Name => "UNR");
No_Pred : Unit_Id;
-- Head of list of items with no predecessors
Num_Left : Int;
-- Number of entries not yet dealt with
Cur_Unit : Unit_Id;
-- Current unit, set by Gather_Dependencies, and picked up in Build_Link to
-- set the Reason_Unit field of the created dependency link.
Num_Chosen : Nat;
-- Number of units chosen in the elaboration order so far
Diagnose_Elaboration_Problem_Called : Boolean := False;
-- True if Diagnose_Elaboration_Problem was called. Used in an assertion.
-----------------------
-- Local Subprograms --
-----------------------
function Debug_Flag_Older return Boolean;
function Debug_Flag_Old return Boolean;
-- True if debug flags select the old or older algorithms. Pretty much any
-- change to elaboration order can break some programs. For example,
-- programs can depend on elaboration order even without failing
-- access-before-elaboration checks. A trivial example is a program that
-- prints text during elaboration. Therefore, we have flags to revert to
-- the old(er) algorithms.
procedure Validate (Order : Unit_Id_Array; Doing_New : Boolean);
-- Assert that certain properties are true
function Better_Choice_Optimistic
(U1 : Unit_Id;
U2 : Unit_Id) return Boolean;
-- U1 and U2 are both permitted candidates for selection as the next unit
-- to be elaborated. This function determines whether U1 is a better choice
-- than U2, i.e. should be elaborated in preference to U2, based on a set
-- of heuristics that establish a friendly and predictable order (see body
-- for details). The result is True if U1 is a better choice than U2, and
-- False if it is a worse choice, or there is no preference between them.
function Better_Choice_Pessimistic
(U1 : Unit_Id;
U2 : Unit_Id) return Boolean;
-- This is like Better_Choice_Optimistic, and has the same interface, but
-- returns true if U1 is a worse choice than U2 in the sense of the -p
-- (pessimistic elaboration order) switch. We still have to obey Ada rules,
-- so it is not quite the direct inverse of Better_Choice_Optimistic.
function Better_Choice (U1 : Unit_Id; U2 : Unit_Id) return Boolean;
-- Calls Better_Choice_Optimistic or Better_Choice_Pessimistic as
-- appropriate. Also takes care of the U2 = No_Unit_Id case.
procedure Build_Link
(Before : Unit_Id;
After : Unit_Id;
R : Succ_Reason;
Ea_Id : Elab_All_Id := No_Elab_All_Link);
-- Establish a successor link, Before must be elaborated before After, and
-- the reason for the link is R. Ea_Id is the contents to be placed in the
-- Elab_All_Link of the entry.
procedure Choose
(Elab_Order : in out Unit_Id_Table;
Chosen : Unit_Id;
Msg : String);
-- Chosen is the next entry chosen in the elaboration order. This procedure
-- updates all data structures appropriately.
function Corresponding_Body (U : Unit_Id) return Unit_Id;
pragma Inline (Corresponding_Body);
-- Given a unit that is a spec for which there is a separate body, return
-- the unit id of the body. It is an error to call this routine with a unit
-- that is not a spec, or that does not have a separate body.
function Corresponding_Spec (U : Unit_Id) return Unit_Id;
pragma Inline (Corresponding_Spec);
-- Given a unit that is a body for which there is a separate spec, return
-- the unit id of the spec. It is an error to call this routine with a unit
-- that is not a body, or that does not have a separate spec.
procedure Diagnose_Elaboration_Problem
(Elab_Order : in out Unit_Id_Table);
pragma No_Return (Diagnose_Elaboration_Problem);
-- Called when no elaboration order can be found. Outputs an appropriate
-- diagnosis of the problem, and then abandons the bind.
procedure Elab_All_Links
(Before : Unit_Id;
After : Unit_Id;
Reason : Succ_Reason;
Link : Elab_All_Id);
-- Used to compute the transitive closure of elaboration links for an
-- Elaborate_All pragma (Reason = Elab_All) or for an indication of
-- Elaborate_All_Desirable (Reason = Elab_All_Desirable). Unit After has a
-- pragma Elaborate_All or the front end has determined that a reference
-- probably requires Elaborate_All, and unit Before must be previously
-- elaborated. First a link is built making sure that unit Before is
-- elaborated before After, then a recursive call ensures that we also
-- build links for any units needed by Before (i.e. these units must/should
-- also be elaborated before After). Link is used to build a chain of
-- Elab_All_Entries to explain the reason for a link. The value passed is
-- the chain so far.
procedure Elab_Error_Msg (S : Successor_Id);
-- Given a successor link, outputs an error message of the form
-- "$ must be elaborated before $ ..." where ... is the reason.
procedure Force_Elab_Order;
-- Gather dependencies from the forced-elaboration-order file (-f switch)
procedure Gather_Dependencies;
-- Compute dependencies, building the Succ and UNR tables
procedure Init;
-- Initialize global data structures in this package body
function Is_Body_Unit (U : Unit_Id) return Boolean;
pragma Inline (Is_Body_Unit);
-- Determines if given unit is a body
function Is_Pure_Or_Preelab_Unit (U : Unit_Id) return Boolean;
-- Returns True if corresponding unit is Pure or Preelaborate. Includes
-- dealing with testing flags on spec if it is given a body.
function Is_Waiting_Body (U : Unit_Id) return Boolean;
pragma Inline (Is_Waiting_Body);
-- Determines if U is a waiting body, defined as a body that has
-- not been elaborated, but whose spec has been elaborated.
function Make_Elab_All_Entry
(Unam : Unit_Name_Type;
Link : Elab_All_Id) return Elab_All_Id;
-- Make an Elab_All_Entries table entry with the given Unam and Link
function Unit_Id_Of (Uname : Unit_Name_Type) return Unit_Id;
-- This function uses the Info field set in the names table to obtain
-- the unit Id of a unit, given its name id value.
procedure Write_Closure (Order : Unit_Id_Array);
-- Write the closure. This is for the -R and -Ra switches, "list closure
-- display".
procedure Write_Dependencies;
-- Write out dependencies (called only if appropriate option is set)
procedure Write_Elab_All_Chain (S : Successor_Id);
-- If the reason for the link S is Elaborate_All or Elaborate_Desirable,
-- then this routine will output the "needed by" explanation chain.
procedure Write_Elab_Order (Order : Unit_Id_Array; Title : String);
-- Display elaboration order. This is for the -l switch. Title is a heading
-- to print; an empty string is passed to indicate Zero_Formatting.
package Elab_New is
-- Implementation of the new algorithm
procedure Write_SCC (U : Unit_Id);
-- Write the unit names of the units in the SCC in which U lives
procedure Find_Elab_Order (Elab_Order : out Unit_Id_Table);
Elab_Cycle_Found : Boolean := False;
-- Set True if Find_Elab_Order found a cycle (usually an illegal pragma
-- Elaborate_All, explicit or implicit).
function SCC (U : Unit_Id) return Unit_Id;
-- The root of the strongly connected component containing U
function SCC_Num_Pred (U : Unit_Id) return Int;
-- The SCC_Num_Pred of the SCC in which U lives
function Nodes (U : Unit_Id) return Unit_Id_Array_Ptr;
-- The nodes of the strongly connected component containing U
end Elab_New;
use Elab_New;
package Elab_Old is
-- Implementation of the old algorithm
procedure Find_Elab_Order (Elab_Order : out Unit_Id_Table);
end Elab_Old;
-- Most of the code is shared between old and new; such code is outside
-- packages Elab_Old and Elab_New.
-------------------
-- Better_Choice --
-------------------
function Better_Choice (U1 : Unit_Id; U2 : Unit_Id) return Boolean is
pragma Assert (U1 /= No_Unit_Id);
begin
if U2 = No_Unit_Id then
return True;
end if;
if Pessimistic_Elab_Order then
return Better_Choice_Pessimistic (U1, U2);
else
return Better_Choice_Optimistic (U1, U2);
end if;
end Better_Choice;
------------------------------
-- Better_Choice_Optimistic --
------------------------------
function Better_Choice_Optimistic
(U1 : Unit_Id;
U2 : Unit_Id) return Boolean
is
UT1 : Unit_Record renames Units.Table (U1);
UT2 : Unit_Record renames Units.Table (U2);
begin
if Debug_Flag_B then
Write_Str ("Better_Choice_Optimistic (");
Write_Unit_Name (UT1.Uname);
Write_Str (", ");
Write_Unit_Name (UT2.Uname);
Write_Line (")");
end if;
-- Note: the checks here are applied in sequence, and the ordering is
-- significant (i.e. the more important criteria are applied first).
-- Prefer a waiting body to one that is not a waiting body
if Is_Waiting_Body (U1) and then not Is_Waiting_Body (U2) then
if Debug_Flag_B then
Write_Line (" True: u1 is waiting body, u2 is not");
end if;
return True;
elsif Is_Waiting_Body (U2) and then not Is_Waiting_Body (U1) then
if Debug_Flag_B then
Write_Line (" False: u2 is waiting body, u1 is not");
end if;
return False;
-- Prefer a predefined unit to a non-predefined unit
elsif UT1.Predefined and then not UT2.Predefined then
if Debug_Flag_B then
Write_Line (" True: u1 is predefined, u2 is not");
end if;
return True;
elsif UT2.Predefined and then not UT1.Predefined then
if Debug_Flag_B then
Write_Line (" False: u2 is predefined, u1 is not");
end if;
return False;
-- Prefer an internal unit to a non-internal unit
elsif UT1.Internal and then not UT2.Internal then
if Debug_Flag_B then
Write_Line (" True: u1 is internal, u2 is not");
end if;
return True;
elsif UT2.Internal and then not UT1.Internal then
if Debug_Flag_B then
Write_Line (" False: u2 is internal, u1 is not");
end if;
return False;
-- Prefer a pure or preelaborated unit to one that is not. Pure should
-- come before preelaborated.
elsif Is_Pure_Or_Preelab_Unit (U1)
and then not
Is_Pure_Or_Preelab_Unit (U2)
then
if Debug_Flag_B then
Write_Line (" True: u1 is pure/preelab, u2 is not");
end if;
return True;
elsif Is_Pure_Or_Preelab_Unit (U2)
and then not
Is_Pure_Or_Preelab_Unit (U1)
then
if Debug_Flag_B then
Write_Line (" False: u2 is pure/preelab, u1 is not");
end if;
return False;
-- Prefer a body to a spec
elsif Is_Body_Unit (U1) and then not Is_Body_Unit (U2) then
if Debug_Flag_B then
Write_Line (" True: u1 is body, u2 is not");
end if;
return True;
elsif Is_Body_Unit (U2) and then not Is_Body_Unit (U1) then
if Debug_Flag_B then
Write_Line (" False: u2 is body, u1 is not");
end if;
return False;
-- If both are waiting bodies, then prefer the one whose spec is more
-- recently elaborated. Consider the following:
-- spec of A
-- spec of B
-- body of A or B?
-- The normal waiting body preference would have placed the body of A
-- before the spec of B if it could. Since it could not, then it must be
-- the case that A depends on B. It is therefore a good idea to put the
-- body of B first.
elsif Is_Waiting_Body (U1) and then Is_Waiting_Body (U2) then
declare
Result : constant Boolean :=
UNR.Table (Corresponding_Spec (U1)).Elab_Position >
UNR.Table (Corresponding_Spec (U2)).Elab_Position;
begin
if Debug_Flag_B then
if Result then
Write_Line (" True: based on waiting body elab positions");
else
Write_Line (" False: based on waiting body elab positions");
end if;
end if;
return Result;
end;
end if;
-- Remaining choice rules are disabled by Debug flag -do
if not Debug_Flag_Older then
-- The following deal with the case of specs that have been marked
-- as Elaborate_Body_Desirable. We generally want to delay these
-- specs as long as possible, so that the bodies have a better chance
-- of being elaborated closer to the specs.
-- If we have two units, one of which is a spec for which this flag
-- is set, and the other is not, we prefer to delay the spec for
-- which the flag is set.
if not UT1.Elaborate_Body_Desirable
and then UT2.Elaborate_Body_Desirable
then
if Debug_Flag_B then
Write_Line (" True: u1 is elab body desirable, u2 is not");
end if;
return True;
elsif not UT2.Elaborate_Body_Desirable
and then UT1.Elaborate_Body_Desirable
then
if Debug_Flag_B then
Write_Line (" False: u1 is elab body desirable, u2 is not");
end if;
return False;
-- If we have two specs that are both marked as Elaborate_Body
-- desirable, we prefer the one whose body is nearer to being able
-- to be elaborated, based on the Num_Pred count. This helps to
-- ensure bodies are as close to specs as possible.
elsif UT1.Elaborate_Body_Desirable
and then UT2.Elaborate_Body_Desirable
then
declare
Result : constant Boolean :=
UNR.Table (Corresponding_Body (U1)).Num_Pred <
UNR.Table (Corresponding_Body (U2)).Num_Pred;
begin
if Debug_Flag_B then
if Result then
Write_Line (" True based on Num_Pred compare");
else
Write_Line (" False based on Num_Pred compare");
end if;
end if;
return Result;
end;
end if;
end if;
-- If we have two specs in the same SCC, choose the one whose body is
-- closer to being ready.
if Doing_New
and then SCC (U1) = SCC (U2)
and then Units.Table (U1).Utype = Is_Spec
and then Units.Table (U2).Utype = Is_Spec
and then UNR.Table (Corresponding_Body (U1)).Num_Pred /=
UNR.Table (Corresponding_Body (U2)).Num_Pred
then
if UNR.Table (Corresponding_Body (U1)).Num_Pred <
UNR.Table (Corresponding_Body (U2)).Num_Pred
then
if Debug_Flag_B then
Write_Str (" True: same SCC; ");
Write_Int (UNR.Table (Corresponding_Body (U1)).Num_Pred);
Write_Str (" < ");
Write_Int (UNR.Table (Corresponding_Body (U2)).Num_Pred);
Write_Eol;
end if;
return True;
else
if Debug_Flag_B then
Write_Str (" False: same SCC; ");
Write_Int (UNR.Table (Corresponding_Body (U1)).Num_Pred);
Write_Str (" > ");
Write_Int (UNR.Table (Corresponding_Body (U2)).Num_Pred);
Write_Eol;
end if;
return False;
end if;
end if;
-- If we fall through, it means that no preference rule applies, so we
-- use alphabetical order to at least give a deterministic result.
if Debug_Flag_B then
Write_Line (" choose on alpha order");
end if;
return Uname_Less (UT1.Uname, UT2.Uname);
end Better_Choice_Optimistic;
-------------------------------
-- Better_Choice_Pessimistic --
-------------------------------
function Better_Choice_Pessimistic
(U1 : Unit_Id;
U2 : Unit_Id) return Boolean
is
UT1 : Unit_Record renames Units.Table (U1);
UT2 : Unit_Record renames Units.Table (U2);
begin
if Debug_Flag_B then
Write_Str ("Better_Choice_Pessimistic (");
Write_Unit_Name (UT1.Uname);
Write_Str (", ");
Write_Unit_Name (UT2.Uname);
Write_Line (")");
end if;
-- Note: the checks here are applied in sequence, and the ordering is
-- significant (i.e. the more important criteria are applied first).
-- If either unit is predefined or internal, then we use the normal
-- Better_Choice_Optimistic rule, since we don't want to disturb the
-- elaboration rules of the language with -p; same treatment for
-- Pure/Preelab.
-- Prefer a predefined unit to a non-predefined unit
if UT1.Predefined and then not UT2.Predefined then
if Debug_Flag_B then
Write_Line (" True: u1 is predefined, u2 is not");
end if;
return True;
elsif UT2.Predefined and then not UT1.Predefined then
if Debug_Flag_B then
Write_Line (" False: u2 is predefined, u1 is not");
end if;
return False;
-- Prefer an internal unit to a non-internal unit
elsif UT1.Internal and then not UT2.Internal then
if Debug_Flag_B then
Write_Line (" True: u1 is internal, u2 is not");
end if;
return True;
elsif UT2.Internal and then not UT1.Internal then
if Debug_Flag_B then
Write_Line (" False: u2 is internal, u1 is not");
end if;
return False;
-- Prefer a pure or preelaborated unit to one that is not
elsif Is_Pure_Or_Preelab_Unit (U1)
and then not
Is_Pure_Or_Preelab_Unit (U2)
then
if Debug_Flag_B then
Write_Line (" True: u1 is pure/preelab, u2 is not");
end if;
return True;
elsif Is_Pure_Or_Preelab_Unit (U2)
and then not
Is_Pure_Or_Preelab_Unit (U1)
then
if Debug_Flag_B then
Write_Line (" False: u2 is pure/preelab, u1 is not");
end if;
return False;
-- Prefer anything else to a waiting body. We want to make bodies wait
-- as long as possible, till we are forced to choose them.
elsif Is_Waiting_Body (U1) and then not Is_Waiting_Body (U2) then
if Debug_Flag_B then
Write_Line (" False: u1 is waiting body, u2 is not");
end if;
return False;
elsif Is_Waiting_Body (U2) and then not Is_Waiting_Body (U1) then
if Debug_Flag_B then
Write_Line (" True: u2 is waiting body, u1 is not");
end if;
return True;
-- Prefer a spec to a body (this is mandatory)
elsif Is_Body_Unit (U1) and then not Is_Body_Unit (U2) then
if Debug_Flag_B then
Write_Line (" False: u1 is body, u2 is not");
end if;
return False;
elsif Is_Body_Unit (U2) and then not Is_Body_Unit (U1) then
if Debug_Flag_B then
Write_Line (" True: u2 is body, u1 is not");
end if;
return True;
-- If both are waiting bodies, then prefer the one whose spec is less
-- recently elaborated. Consider the following:
-- spec of A
-- spec of B
-- body of A or B?
-- The normal waiting body preference would have placed the body of A
-- before the spec of B if it could. Since it could not, then it must be
-- the case that A depends on B. It is therefore a good idea to put the
-- body of B last so that if there is an elaboration order problem, we
-- will find it (that's what pessimistic order is about).
elsif Is_Waiting_Body (U1) and then Is_Waiting_Body (U2) then
declare
Result : constant Boolean :=
UNR.Table (Corresponding_Spec (U1)).Elab_Position <
UNR.Table (Corresponding_Spec (U2)).Elab_Position;
begin
if Debug_Flag_B then
if Result then
Write_Line (" True: based on waiting body elab positions");
else
Write_Line (" False: based on waiting body elab positions");
end if;
end if;
return Result;
end;
end if;
-- Remaining choice rules are disabled by Debug flag -do
if not Debug_Flag_Older then
-- The following deal with the case of specs that have been marked as
-- Elaborate_Body_Desirable. In the normal case, we generally want to
-- delay the elaboration of these specs as long as possible, so that
-- bodies have better chance of being elaborated closer to the specs.
-- Better_Choice_Pessimistic as usual wants to do the opposite and
-- elaborate such specs as early as possible.
-- If we have two units, one of which is a spec for which this flag
-- is set, and the other is not, we normally prefer to delay the spec
-- for which the flag is set, so again Better_Choice_Pessimistic does
-- the opposite.
if not UT1.Elaborate_Body_Desirable
and then UT2.Elaborate_Body_Desirable
then
if Debug_Flag_B then
Write_Line (" False: u1 is elab body desirable, u2 is not");
end if;
return False;
elsif not UT2.Elaborate_Body_Desirable
and then UT1.Elaborate_Body_Desirable
then
if Debug_Flag_B then
Write_Line (" True: u1 is elab body desirable, u2 is not");
end if;
return True;
-- If we have two specs that are both marked as Elaborate_Body
-- desirable, we normally prefer the one whose body is nearer to
-- being able to be elaborated, based on the Num_Pred count. This
-- helps to ensure bodies are as close to specs as possible. As
-- usual, Better_Choice_Pessimistic does the opposite.
elsif UT1.Elaborate_Body_Desirable
and then UT2.Elaborate_Body_Desirable
then
declare
Result : constant Boolean :=
UNR.Table (Corresponding_Body (U1)).Num_Pred >=
UNR.Table (Corresponding_Body (U2)).Num_Pred;
begin
if Debug_Flag_B then
if Result then
Write_Line (" True based on Num_Pred compare");
else
Write_Line (" False based on Num_Pred compare");
end if;
end if;
return Result;
end;
end if;
end if;
-- If we fall through, it means that no preference rule applies, so we
-- use alphabetical order to at least give a deterministic result. Since
-- Better_Choice_Pessimistic is in the business of stirring up the
-- order, we will use reverse alphabetical ordering.
if Debug_Flag_B then
Write_Line (" choose on reverse alpha order");
end if;
return Uname_Less (UT2.Uname, UT1.Uname);
end Better_Choice_Pessimistic;
----------------
-- Build_Link --
----------------
procedure Build_Link
(Before : Unit_Id;
After : Unit_Id;
R : Succ_Reason;
Ea_Id : Elab_All_Id := No_Elab_All_Link)
is
Cspec : Unit_Id;
begin
Succ.Append
((Before => Before,
After => No_Unit_Id, -- filled in below
Next => UNR.Table (Before).Successors,
Reason => R,
Elab_Body => False, -- set correctly below
Reason_Unit => Cur_Unit,
Elab_All_Link => Ea_Id));
UNR.Table (Before).Successors := Succ.Last;
-- Deal with special Elab_Body case. If the After of this link is
-- a body whose spec has Elaborate_All set, and this is not the link
-- directly from the body to the spec, then we make the After of the
-- link reference its spec instead, marking the link appropriately.
if Units.Table (After).Utype = Is_Body then
Cspec := Corresponding_Spec (After);
if Units.Table (Cspec).Elaborate_Body
and then Cspec /= Before
then
Succ.Table (Succ.Last).After := Cspec;
Succ.Table (Succ.Last).Elab_Body := True;
UNR.Table (Cspec).Num_Pred := UNR.Table (Cspec).Num_Pred + 1;
return;
end if;
end if;
-- Fall through on normal case
Succ.Table (Succ.Last).After := After;
Succ.Table (Succ.Last).Elab_Body := False;
UNR.Table (After).Num_Pred := UNR.Table (After).Num_Pred + 1;
end Build_Link;
------------
-- Choose --
------------
procedure Choose
(Elab_Order : in out Unit_Id_Table;
Chosen : Unit_Id;
Msg : String)
is
pragma Assert (Chosen /= No_Unit_Id);
S : Successor_Id;
U : Unit_Id;
begin
if Debug_Flag_C then
Write_Str ("Choosing Unit ");
Write_Unit_Name (Units.Table (Chosen).Uname);
Write_Str (Msg);
end if;
-- We shouldn't be choosing something with unelaborated predecessors,
-- and we shouldn't call this twice on the same unit. But that's not
-- true when this is called from Diagnose_Elaboration_Problem.
if Errors_Detected = 0 then
pragma Assert (UNR.Table (Chosen).Num_Pred = 0);
pragma Assert (UNR.Table (Chosen).Elab_Position = 0);
pragma Assert (not Doing_New or else SCC_Num_Pred (Chosen) = 0);
null;
end if;
-- Add to elaboration order. Note that units having no elaboration code
-- are not treated specially yet. The special casing of this is in
-- Bindgen, where Gen_Elab_Calls skips over them. Meanwhile we need them
-- here, because the object file list is also driven by the contents of
-- the Elab_Order table.
Append (Elab_Order, Chosen);
-- Remove from No_Pred list. This is a little inefficient and may be we
-- should doubly link the list, but it will do for now.
if No_Pred = Chosen then
No_Pred := UNR.Table (Chosen).Nextnp;
else
U := No_Pred;
while U /= No_Unit_Id loop
if UNR.Table (U).Nextnp = Chosen then
UNR.Table (U).Nextnp := UNR.Table (Chosen).Nextnp;
goto Done_Removal;
end if;
U := UNR.Table (U).Nextnp;
end loop;
-- Here if we didn't find it on the No_Pred list. This can happen
-- only in calls from the Diagnose_Elaboration_Problem routine,
-- where cycles are being removed arbitrarily from the graph.
pragma Assert (Errors_Detected > 0);
<<Done_Removal>> null;
end if;
-- For all successors, decrement the number of predecessors, and if it
-- becomes zero, then add to no-predecessor list.
S := UNR.Table (Chosen).Successors;
pragma Annotate (CodePeer, Modified, S);
while S /= No_Successor loop
U := Succ.Table (S).After;
UNR.Table (U).Num_Pred := UNR.Table (U).Num_Pred - 1;
if Debug_Flag_N then
Write_Str (" decrementing Num_Pred for unit ");
Write_Unit_Name (Units.Table (U).Uname);
Write_Str (" new value = ");
Write_Int (UNR.Table (U).Num_Pred);
Write_Eol;
end if;
if UNR.Table (U).Num_Pred = 0 then
UNR.Table (U).Nextnp := No_Pred;
No_Pred := U;
end if;
if Doing_New and then SCC (U) /= SCC (Chosen) then
UNR.Table (SCC (U)).SCC_Num_Pred :=
UNR.Table (SCC (U)).SCC_Num_Pred - 1;
if Debug_Flag_N then
Write_Str (" decrementing SCC_Num_Pred for unit ");
Write_Unit_Name (Units.Table (U).Uname);
Write_Str (" new value = ");
Write_Int (SCC_Num_Pred (U));
Write_Eol;
end if;
end if;
S := Succ.Table (S).Next;
end loop;
-- All done, adjust number of units left count and set elaboration pos
Num_Left := Num_Left - 1;
Num_Chosen := Num_Chosen + 1;
pragma Assert
(Errors_Detected > 0 or else Num_Chosen = Last (Elab_Order));
pragma Assert (Units.Last = UNR.Last);
pragma Assert (Num_Chosen + Num_Left = Int (UNR.Last));
if Debug_Flag_C then
Write_Str (" ");
Write_Int (Int (Num_Chosen));
Write_Str ("+");
Write_Int (Num_Left);
Write_Str ("=");
Write_Int (Int (UNR.Last));
Write_Eol;
end if;
UNR.Table (Chosen).Elab_Position := Num_Chosen;
-- If we just chose a spec with Elaborate_Body set, then we must
-- immediately elaborate the body, before any other units.
if Units.Table (Chosen).Elaborate_Body then
-- If the unit is a spec only, then there is no body. This is a bit
-- odd given that Elaborate_Body is here, but it is valid in an RCI
-- unit, where we only have the interface in the stub bind.
if Units.Table (Chosen).Utype = Is_Spec_Only
and then Units.Table (Chosen).RCI
then
null;
-- If this unit is an interface to a stand-alone library, then we
-- don't want to elaborate the body -- that will happen as part of
-- the library.
elsif Units.Table (Chosen).SAL_Interface then
null;
else
Choose
(Elab_Order => Elab_Order,
Chosen => Corresponding_Body (Chosen),
Msg => " [Elaborate_Body]");
end if;
end if;
end Choose;
------------------------
-- Corresponding_Body --
------------------------
-- Currently if the body and spec are separate, then they appear as two
-- separate units in the same ALI file, with the body appearing first and
-- the spec appearing second.
function Corresponding_Body (U : Unit_Id) return Unit_Id is
begin
pragma Assert (Units.Table (U).Utype = Is_Spec);
return U - 1;
end Corresponding_Body;
------------------------
-- Corresponding_Spec --
------------------------
-- Currently if the body and spec are separate, then they appear as two
-- separate units in the same ALI file, with the body appearing first and
-- the spec appearing second.
function Corresponding_Spec (U : Unit_Id) return Unit_Id is
begin
pragma Assert (Units.Table (U).Utype = Is_Body);
return U + 1;
end Corresponding_Spec;
--------------------
-- Debug_Flag_Old --
--------------------
function Debug_Flag_Old return Boolean is
begin
-- If the user specified both flags, we want to use the older algorithm,
-- rather than some confusing mix of the two.
return Debug_Flag_P and not Debug_Flag_O;
end Debug_Flag_Old;
----------------------
-- Debug_Flag_Older --
----------------------
function Debug_Flag_Older return Boolean is
begin
return Debug_Flag_O;
end Debug_Flag_Older;
----------------------------------
-- Diagnose_Elaboration_Problem --
----------------------------------
procedure Diagnose_Elaboration_Problem
(Elab_Order : in out Unit_Id_Table)
is
function Find_Path
(Ufrom : Unit_Id;
Uto : Unit_Id;
ML : Nat) return Boolean;
-- Recursive routine used to find a path from node Ufrom to node Uto.
-- If a path exists, returns True and outputs an appropriate set of
-- error messages giving the path. Also calls Choose for each of the
-- nodes so that they get removed from the remaining set. There are
-- two cases of calls, either Ufrom = Uto for an attempt to find a
-- cycle, or Ufrom is a spec and Uto the corresponding body for the
-- case of an unsatisfiable Elaborate_Body pragma. ML is the minimum
-- acceptable length for a path.
---------------
-- Find_Path --
---------------
function Find_Path
(Ufrom : Unit_Id;
Uto : Unit_Id;
ML : Nat) return Boolean
is
function Find_Link (U : Unit_Id; PL : Nat) return Boolean;
-- This is the inner recursive routine, it determines if a path
-- exists from U to Uto, and if so returns True and outputs the
-- appropriate set of error messages. PL is the path length
---------------
-- Find_Link --
---------------
function Find_Link (U : Unit_Id; PL : Nat) return Boolean is
S : Successor_Id;
begin
-- Recursion ends if we are at terminating node and the path is
-- sufficiently long, generate error message and return True.
if U = Uto and then PL >= ML then
Choose (Elab_Order, U, " [Find_Link: base]");
return True;
-- All done if already visited
elsif UNR.Table (U).Visited then
return False;
-- Otherwise mark as visited and look at all successors
else
UNR.Table (U).Visited := True;
S := UNR.Table (U).Successors;
while S /= No_Successor loop
if Find_Link (Succ.Table (S).After, PL + 1) then
Elab_Error_Msg (S);
Choose (Elab_Order, U, " [Find_Link: recursive]");
return True;
end if;
S := Succ.Table (S).Next;
end loop;
-- Falling through means this does not lead to a path
return False;
end if;
end Find_Link;
-- Start of processing for Find_Path
begin
-- Initialize all non-chosen nodes to not visited yet
for U in Units.First .. Units.Last loop
UNR.Table (U).Visited := UNR.Table (U).Elab_Position /= 0;
end loop;
-- Now try to find the path
return Find_Link (Ufrom, 0);
end Find_Path;
-- Start of processing for Diagnose_Elaboration_Problem
begin
Diagnose_Elaboration_Problem_Called := True;
Set_Standard_Error;
-- Output state of things if debug flag N set
if Debug_Flag_N then
declare
NP : Int;
begin
Write_Eol;
Write_Eol;
Write_Line ("Diagnose_Elaboration_Problem called");
Write_Line ("List of remaining unchosen units and predecessors");
for U in Units.First .. Units.Last loop
if UNR.Table (U).Elab_Position = 0 then
NP := UNR.Table (U).Num_Pred;
Write_Eol;
Write_Str (" Unchosen unit: #");
Write_Int (Int (U));
Write_Str (" ");
Write_Unit_Name (Units.Table (U).Uname);
Write_Str (" (Num_Pred = ");
Write_Int (NP);
Write_Line (")");
if NP = 0 then
if Units.Table (U).Elaborate_Body then
Write_Line
(" (not chosen because of Elaborate_Body)");
else
Write_Line (" ****************** why not chosen?");
end if;
end if;
-- Search links list to find unchosen predecessors
for S in Succ.First .. Succ.Last loop
declare
SL : Successor_Link renames Succ.Table (S);
begin
if SL.After = U
and then UNR.Table (SL.Before).Elab_Position = 0
then
Write_Str (" unchosen predecessor: #");
Write_Int (Int (SL.Before));
Write_Str (" ");
Write_Unit_Name (Units.Table (SL.Before).Uname);
Write_Eol;
NP := NP - 1;
end if;
end;
end loop;
if NP /= 0 then
Write_Line (" **************** Num_Pred value wrong!");
end if;
end if;
end loop;
end;
end if;
-- Output the header for the error, and manually increment the error
-- count. We are using Error_Msg_Output rather than Error_Msg here for
-- two reasons:
-- This is really only one error, not one for each line
-- We want this output on standard output since it is voluminous
-- But we do need to deal with the error count manually in this case
Errors_Detected := Errors_Detected + 1;
Error_Msg_Output ("elaboration circularity detected", Info => False);
-- Try to find cycles starting with any of the remaining nodes that have
-- not yet been chosen. There must be at least one (there is some reason
-- we are being called).
for U in Units.First .. Units.Last loop
if UNR.Table (U).Elab_Position = 0 then
if Find_Path (U, U, 1) then
raise Unrecoverable_Error;
end if;
end if;
end loop;
-- We should never get here, since we were called for some reason, and
-- we should have found and eliminated at least one bad path.
raise Program_Error;
end Diagnose_Elaboration_Problem;
--------------------
-- Elab_All_Links --
--------------------
procedure Elab_All_Links
(Before : Unit_Id;
After : Unit_Id;
Reason : Succ_Reason;
Link : Elab_All_Id)
is
begin
if UNR.Table (Before).Visited then
return;
end if;
-- Build the direct link for Before
UNR.Table (Before).Visited := True;
Build_Link (Before, After, Reason, Link);
-- Process all units with'ed by Before recursively
for W in Units.Table (Before).First_With ..
Units.Table (Before).Last_With
loop
-- Skip if this with is an interface to a stand-alone library. Skip
-- also if no ALI file for this WITH, happens for language defined
-- generics while bootstrapping the compiler (see body of routine
-- Lib.Writ.Write_With_Lines). Finally, skip if it is a limited with
-- clause, which does not impose an elaboration link.
if not Withs.Table (W).SAL_Interface
and then Withs.Table (W).Afile /= No_File
and then not Withs.Table (W).Limited_With
then
declare
Info : constant Int :=
Get_Name_Table_Int (Withs.Table (W).Uname);
begin
-- If the unit is unknown, for some unknown reason, fail
-- graciously explaining that the unit is unknown. Without
-- this check, gnatbind will crash in Unit_Id_Of.
if Info = 0 or else Unit_Id (Info) = No_Unit_Id then
declare
Withed : String :=
Get_Name_String (Withs.Table (W).Uname);
Last_Withed : Natural := Withed'Last;
Withing : String :=
Get_Name_String
(Units.Table (Before).Uname);
Last_Withing : Natural := Withing'Last;
Spec_Body : String := " (Spec)";
begin
To_Mixed (Withed);
To_Mixed (Withing);
if Last_Withed > 2
and then Withed (Last_Withed - 1) = '%'
then
Last_Withed := Last_Withed - 2;
end if;
if Last_Withing > 2
and then Withing (Last_Withing - 1) = '%'
then
Last_Withing := Last_Withing - 2;
end if;
if Units.Table (Before).Utype = Is_Body
or else Units.Table (Before).Utype = Is_Body_Only
then
Spec_Body := " (Body)";
end if;
Osint.Fail
("could not find unit "
& Withed (Withed'First .. Last_Withed) & " needed by "
& Withing (Withing'First .. Last_Withing) & Spec_Body);
end;
end if;
Elab_All_Links
(Unit_Id_Of (Withs.Table (W).Uname),
After,
Reason,
Make_Elab_All_Entry (Withs.Table (W).Uname, Link));
end;
end if;
end loop;
-- Process corresponding body, if there is one
if Units.Table (Before).Utype = Is_Spec then
Elab_All_Links
(Corresponding_Body (Before),
After, Reason,
Make_Elab_All_Entry
(Units.Table (Corresponding_Body (Before)).Uname, Link));
end if;
end Elab_All_Links;
--------------------
-- Elab_Error_Msg --
--------------------
procedure Elab_Error_Msg (S : Successor_Id) is
SL : Successor_Link renames Succ.Table (S);
begin
-- Nothing to do if internal unit involved and no -da flag
if not Debug_Flag_A
and then
(Is_Internal_File_Name (Units.Table (SL.Before).Sfile)
or else
Is_Internal_File_Name (Units.Table (SL.After).Sfile))
then
return;
end if;
-- Here we want to generate output
Error_Msg_Unit_1 := Units.Table (SL.Before).Uname;
if SL.Elab_Body then
Error_Msg_Unit_2 := Units.Table (Corresponding_Body (SL.After)).Uname;
else
Error_Msg_Unit_2 := Units.Table (SL.After).Uname;
end if;
Error_Msg_Output (" $ must be elaborated before $", Info => True);
Error_Msg_Unit_1 := Units.Table (SL.Reason_Unit).Uname;
case SL.Reason is
when Withed =>
Error_Msg_Output
(" reason: with clause",
Info => True);
when Forced =>
Error_Msg_Output
(" reason: forced by -f switch",
Info => True);
when Elab =>
Error_Msg_Output
(" reason: pragma Elaborate in unit $",
Info => True);
when Elab_All =>
Error_Msg_Output
(" reason: pragma Elaborate_All in unit $",
Info => True);
when Elab_All_Desirable =>
Error_Msg_Output
(" reason: implicit Elaborate_All in unit $",
Info => True);
Error_Msg_Output
(" recompile $ with -gnatel for full details",
Info => True);
when Elab_Desirable =>
Error_Msg_Output
(" reason: implicit Elaborate in unit $",
Info => True);
Error_Msg_Output
(" recompile $ with -gnatel for full details",
Info => True);
when Spec_First =>
Error_Msg_Output
(" reason: spec always elaborated before body",
Info => True);
end case;
Write_Elab_All_Chain (S);
if SL.Elab_Body then
Error_Msg_Unit_1 := Units.Table (SL.Before).Uname;
Error_Msg_Unit_2 := Units.Table (SL.After).Uname;
Error_Msg_Output
(" $ must therefore be elaborated before $", True);
Error_Msg_Unit_1 := Units.Table (SL.After).Uname;
Error_Msg_Output
(" (because $ has a pragma Elaborate_Body)", True);
end if;
if not Zero_Formatting then
Write_Eol;
end if;
end Elab_Error_Msg;
---------------------
-- Find_Elab_Order --
---------------------
procedure Find_Elab_Order
(Elab_Order : out Unit_Id_Table;
First_Main_Lib_File : File_Name_Type)
is
function Num_Spec_Body_Pairs (Order : Unit_Id_Array) return Nat;
-- Number of cases where the body of a unit immediately follows the
-- corresponding spec. Such cases are good, because calls to that unit
-- from outside can't get ABE.
-------------------------
-- Num_Spec_Body_Pairs --
-------------------------
function Num_Spec_Body_Pairs (Order : Unit_Id_Array) return Nat is
Result : Nat := 0;
begin
for J in Order'First + 1 .. Order'Last loop
if Units.Table (Order (J - 1)).Utype = Is_Spec
and then Units.Table (Order (J)).Utype = Is_Body
and then Corresponding_Spec (Order (J)) = Order (J - 1)
then
Result := Result + 1;
end if;
end loop;
return Result;
end Num_Spec_Body_Pairs;
-- Local variables
Old_Elab_Order : Unit_Id_Table;
-- Start of processing for Find_Elab_Order
begin
-- Output warning if -p used with no -gnatE units
if Pessimistic_Elab_Order
and not Dynamic_Elaboration_Checks_Specified
then
Error_Msg ("?use of -p switch questionable");
Error_Msg ("?since all units compiled with static elaboration model");
end if;
if Do_New and not Debug_Flag_Old and not Debug_Flag_Older then
if Debug_Flag_V then
Write_Line ("Doing new...");
end if;
Doing_New := True;
Init;
Elab_New.Find_Elab_Order (Elab_Order);
end if;
-- Elab_New does not support the pessimistic order, so if that was
-- requested, use the old results. Use Elab_Old if -dp or -do was
-- selected. Elab_New does not yet give proper error messages for
-- illegal Elaborate_Alls, so if there is one, run Elab_Old.
if Do_Old
or Pessimistic_Elab_Order
or Debug_Flag_Old
or Debug_Flag_Older
or Elab_Cycle_Found
then
if Debug_Flag_V then
Write_Line ("Doing old...");
end if;
Doing_New := False;
Init;
Elab_Old.Find_Elab_Order (Old_Elab_Order);
end if;
pragma Assert (Elab_Cycle_Found <= -- implies
Diagnose_Elaboration_Problem_Called);
declare
Old_Order : Unit_Id_Array renames
Old_Elab_Order.Table (1 .. Last (Old_Elab_Order));
begin
if Do_Old and Do_New then
declare
New_Order : Unit_Id_Array renames
Elab_Order.Table (1 .. Last (Elab_Order));
Old_Pairs : constant Nat := Num_Spec_Body_Pairs (Old_Order);
New_Pairs : constant Nat := Num_Spec_Body_Pairs (New_Order);
begin
Write_Line (Get_Name_String (First_Main_Lib_File));
pragma Assert (Old_Order'Length = New_Order'Length);
pragma Debug (Validate (Old_Order, Doing_New => False));
pragma Debug (Validate (New_Order, Doing_New => True));
-- Misc debug printouts that can be used for experimentation by
-- changing the 'if's below.
if True then
if New_Order = Old_Order then
Write_Line ("Elab_New: same order.");
else
Write_Line ("Elab_New: diff order.");
end if;
end if;
if New_Order /= Old_Order and then False then
Write_Line ("Elaboration orders differ:");
Write_Elab_Order
(Old_Order, Title => "OLD ELABORATION ORDER");
Write_Elab_Order
(New_Order, Title => "NEW ELABORATION ORDER");
end if;
if True then
Write_Str ("Pairs: ");
Write_Int (Old_Pairs);
if Old_Pairs = New_Pairs then
Write_Str (" = ");
elsif Old_Pairs < New_Pairs then
Write_Str (" < ");
else
Write_Str (" > ");
end if;
Write_Int (New_Pairs);
Write_Eol;
end if;
if Old_Pairs /= New_Pairs and then False then
Write_Str ("Pairs: ");
Write_Int (Old_Pairs);
if Old_Pairs < New_Pairs then
Write_Str (" < ");
else
Write_Str (" > ");
end if;
Write_Int (New_Pairs);
Write_Eol;
if Old_Pairs /= New_Pairs and then Debug_Flag_V then
Write_Elab_Order
(Old_Order, Title => "OLD ELABORATION ORDER");
Write_Elab_Order
(New_Order, Title => "NEW ELABORATION ORDER");
pragma Assert (New_Pairs >= Old_Pairs);
end if;
end if;
end;
end if;
-- The Elab_New algorithm doesn't implement the -p switch, so if that
-- was used, use the results from the old algorithm. Likewise if the
-- user has requested the old algorithm.
if Pessimistic_Elab_Order or Debug_Flag_Old or Debug_Flag_Older then
pragma Assert
(Last (Elab_Order) = 0
or else Last (Elab_Order) = Old_Order'Last);
Init (Elab_Order);
Append_All (Elab_Order, Old_Order);
end if;
-- Now set the Elab_Positions in the Units table. It is important to
-- do this late, in case we're running both Elab_New and Elab_Old.
declare
New_Order : Unit_Id_Array renames
Elab_Order.Table (1 .. Last (Elab_Order));
Units_Array : Units.Table_Type renames
Units.Table (Units.First .. Units.Last);
begin
for J in New_Order'Range loop
pragma Assert
(UNR.Table (New_Order (J)).Elab_Position = J);
Units_Array (New_Order (J)).Elab_Position := J;
end loop;
if Errors_Detected = 0 then
-- Display elaboration order if -l was specified
if Elab_Order_Output then
if Zero_Formatting then
Write_Elab_Order (New_Order, Title => "");
else
Write_Elab_Order
(New_Order, Title => "ELABORATION ORDER");
end if;
end if;
-- Display list of sources in the closure (except predefined
-- sources) if -R was used. Include predefined sources if -Ra
-- was used.
if List_Closure then
Write_Closure (New_Order);
end if;
end if;
end;
end;
end Find_Elab_Order;
----------------------
-- Force_Elab_Order --
----------------------
procedure Force_Elab_Order is
subtype Header_Num is Unit_Name_Type'Base range 0 .. 2**16 - 1;
function Hash (N : Unit_Name_Type) return Header_Num;
package Name_Map is new System.HTable.Simple_HTable
(Header_Num => Header_Num,
Element => Logical_Line_Number,
No_Element => No_Line_Number,
Key => Unit_Name_Type,
Hash => Hash,
Equal => "=");
-- Name_Map contains an entry for each file name seen, mapped to the
-- line number where we saw it first. This is used to give an error for
-- duplicates.
----------
-- Hash --
----------
function Hash (N : Unit_Name_Type) return Header_Num is
-- Name_Ids are already widely dispersed; no need for any actual
-- hashing. Just subtract to make it zero based, and "mod" to
-- bring it in range.
begin
return (N - Unit_Name_Type'First) mod (Header_Num'Last + 1);
end Hash;
-- Local variables
Cur_Line_Number : Logical_Line_Number;
Error : Boolean := False;
Iter : Forced_Units_Iterator;
Prev_Unit : Unit_Id := No_Unit_Id;
Uname : Unit_Name_Type;
-- Start of processing for Force_Elab_Order
begin
Iter := Iterate_Forced_Units;
while Has_Next (Iter) loop
Next (Iter, Uname, Cur_Line_Number);
declare
Dup : constant Logical_Line_Number := Name_Map.Get (Uname);
begin
if Dup = No_Line_Number then
Name_Map.Set (Uname, Cur_Line_Number);
-- We don't need to give the "not present" message in the case
-- of "duplicate unit", because we would have already given the
-- "not present" message on the first occurrence.
if Get_Name_Table_Int (Uname) = 0
or else Unit_Id (Get_Name_Table_Int (Uname)) = No_Unit_Id
then
Error := True;
if Doing_New then
Write_Line
("""" & Get_Name_String (Uname)
& """: not present; ignored");
end if;
end if;
else
Error := True;
if Doing_New then
Error_Msg_Nat_1 := Nat (Cur_Line_Number);
Error_Msg_Unit_1 := Uname;
Error_Msg_Nat_2 := Nat (Dup);
Error_Msg
(Force_Elab_Order_File.all
& ":#: duplicate unit name $ from line #");
end if;
end if;
end;
if not Error then
declare
Cur_Unit : constant Unit_Id := Unit_Id_Of (Uname);
begin
if Is_Internal_File_Name (Units.Table (Cur_Unit).Sfile) then
if Doing_New then
Write_Line
("""" & Get_Name_String (Uname)
& """: predefined unit ignored");
end if;
else
if Prev_Unit /= No_Unit_Id then
if Doing_New then
Write_Unit_Name (Units.Table (Prev_Unit).Uname);
Write_Str (" <-- ");
Write_Unit_Name (Units.Table (Cur_Unit).Uname);
Write_Eol;
end if;
Build_Link
(Before => Prev_Unit,
After => Cur_Unit,
R => Forced);
end if;
Prev_Unit := Cur_Unit;
end if;
end;
end if;
end loop;
end Force_Elab_Order;
-------------------------
-- Gather_Dependencies --
-------------------------
procedure Gather_Dependencies is
Withed_Unit : Unit_Id;
begin
-- Loop through all units
for U in Units.First .. Units.Last loop
Cur_Unit := U;
-- If this is not an interface to a stand-alone library and there is
-- a body and a spec, then spec must be elaborated first. Note that
-- the corresponding spec immediately follows the body.
if not Units.Table (U).SAL_Interface
and then Units.Table (U).Utype = Is_Body
then
Build_Link (Corresponding_Spec (U), U, Spec_First);
end if;
-- If this unit is not an interface to a stand-alone library, process
-- WITH references for this unit ignoring interfaces to stand-alone
-- libraries.
if not Units.Table (U).SAL_Interface then
for W in Units.Table (U).First_With ..
Units.Table (U).Last_With
loop
if Withs.Table (W).Sfile /= No_File
and then (not Withs.Table (W).SAL_Interface)
then
-- Check for special case of withing a unit that does not
-- exist any more. If the unit was completely missing we
-- would already have detected this, but a nasty case arises
-- when we have a subprogram body with no spec, and some
-- obsolete unit with's a previous (now disappeared) spec.
if Get_Name_Table_Int (Withs.Table (W).Uname) = 0 then
if Doing_New then
Error_Msg_File_1 := Units.Table (U).Sfile;
Error_Msg_Unit_1 := Withs.Table (W).Uname;
Error_Msg ("{ depends on $ which no longer exists");
end if;
goto Next_With;
end if;
Withed_Unit := Unit_Id_Of (Withs.Table (W).Uname);
-- Pragma Elaborate_All case, for this we use the recursive
-- Elab_All_Links procedure to establish the links.
-- Elab_New ignores Elaborate_All and Elab_All_Desirable,
-- except for error messages.
if Withs.Table (W).Elaborate_All and then not Doing_New then
-- Reset flags used to stop multiple visits to a given
-- node.
for Uref in UNR.First .. UNR.Last loop
UNR.Table (Uref).Visited := False;
end loop;
-- Now establish all the links we need
Elab_All_Links
(Withed_Unit, U, Elab_All,
Make_Elab_All_Entry
(Withs.Table (W).Uname, No_Elab_All_Link));
-- Elaborate_All_Desirable case, for this we establish the
-- same links as above, but with a different reason.
elsif Withs.Table (W).Elab_All_Desirable
and then not Doing_New
then
-- Reset flags used to stop multiple visits to a given
-- node.
for Uref in UNR.First .. UNR.Last loop
UNR.Table (Uref).Visited := False;
end loop;
-- Now establish all the links we need
Elab_All_Links
(Withed_Unit, U, Elab_All_Desirable,
Make_Elab_All_Entry
(Withs.Table (W).Uname, No_Elab_All_Link));
-- Pragma Elaborate case. We must build a link for the
-- withed unit itself, and also the corresponding body if
-- there is one.
-- However, skip this processing if there is no ALI file for
-- the WITH entry, because this means it is a generic (even
-- when we fix the generics so that an ALI file is present,
-- we probably still will have no ALI file for unchecked and
-- other special cases).
elsif Withs.Table (W).Elaborate
and then Withs.Table (W).Afile /= No_File
then
Build_Link (Withed_Unit, U, Withed);
if Units.Table (Withed_Unit).Utype = Is_Spec then
Build_Link
(Corresponding_Body (Withed_Unit), U, Elab);
end if;
-- Elaborate_Desirable case, for this we establish the same
-- links as above, but with a different reason.
elsif Withs.Table (W).Elab_Desirable then
Build_Link (Withed_Unit, U, Withed);
if Units.Table (Withed_Unit).Utype = Is_Spec then
Build_Link
(Corresponding_Body (Withed_Unit),
U, Elab_Desirable);
end if;
-- A limited_with does not establish an elaboration
-- dependence (that's the whole point).
elsif Withs.Table (W).Limited_With then
null;
-- Case of normal WITH with no elaboration pragmas, just
-- build the single link to the directly referenced unit
else
Build_Link (Withed_Unit, U, Withed);
end if;
end if;
<<Next_With>>
null;
end loop;
end if;
end loop;
-- If -f<elab_order> switch was given, take into account dependences
-- specified in the file <elab_order>.
if Force_Elab_Order_File /= null then
Force_Elab_Order;
end if;
-- Output elaboration dependencies if option is set
if Elab_Dependency_Output or Debug_Flag_E then
if Doing_New then
Write_Dependencies;
end if;
end if;
end Gather_Dependencies;
----------
-- Init --
----------
procedure Init is
begin
Num_Chosen := 0;
Num_Left := Int (Units.Last - Units.First + 1);
Succ.Init;
Elab_All_Entries.Init;
UNR.Init;
-- Initialize unit table for elaboration control
for U in Units.First .. Units.Last loop
UNR.Append
((Successors => No_Successor,
Num_Pred => 0,
Nextnp => No_Unit_Id,
Visited => False,
Elab_Position => 0,
SCC_Root => No_Unit_Id,
Nodes => null,
SCC_Num_Pred => 0,
Validate_Seen => False));
end loop;
end Init;
------------------
-- Is_Body_Unit --
------------------
function Is_Body_Unit (U : Unit_Id) return Boolean is
begin
return
Units.Table (U).Utype = Is_Body
or else Units.Table (U).Utype = Is_Body_Only;
end Is_Body_Unit;
-----------------------------
-- Is_Pure_Or_Preelab_Unit --
-----------------------------
function Is_Pure_Or_Preelab_Unit (U : Unit_Id) return Boolean is
begin
-- If we have a body with separate spec, test flags on the spec
if Units.Table (U).Utype = Is_Body then
return
Units.Table (Corresponding_Spec (U)).Preelab
or else Units.Table (Corresponding_Spec (U)).Pure;
-- Otherwise we have a spec or body acting as spec, test flags on unit
else
return Units.Table (U).Preelab or else Units.Table (U).Pure;
end if;
end Is_Pure_Or_Preelab_Unit;
---------------------
-- Is_Waiting_Body --
---------------------
function Is_Waiting_Body (U : Unit_Id) return Boolean is
begin
return
Units.Table (U).Utype = Is_Body
and then UNR.Table (Corresponding_Spec (U)).Elab_Position /= 0;
end Is_Waiting_Body;
-------------------------
-- Make_Elab_All_Entry --
-------------------------
function Make_Elab_All_Entry
(Unam : Unit_Name_Type;
Link : Elab_All_Id) return Elab_All_Id
is
begin
Elab_All_Entries.Append ((Needed_By => Unam, Next_Elab => Link));
return Elab_All_Entries.Last;
end Make_Elab_All_Entry;
----------------
-- Unit_Id_Of --
----------------
function Unit_Id_Of (Uname : Unit_Name_Type) return Unit_Id is
Info : constant Int := Get_Name_Table_Int (Uname);
begin
pragma Assert (Info /= 0 and then Unit_Id (Info) /= No_Unit_Id);
return Unit_Id (Info);
end Unit_Id_Of;
--------------
-- Validate --
--------------
procedure Validate (Order : Unit_Id_Array; Doing_New : Boolean) is
Cur_SCC : Unit_Id := No_Unit_Id;
OK : Boolean := True;
Msg : String := "Old: ";
begin
if Doing_New then
Msg := "New: ";
end if;
-- For each unit, assert that its successors are elaborated after it
for J in Order'Range loop
declare
U : constant Unit_Id := Order (J);
S : Successor_Id := UNR.Table (U).Successors;
begin
while S /= No_Successor loop
if UNR.Table (Succ.Table (S).After).Elab_Position <=
UNR.Table (U).Elab_Position
then
OK := False;
Write_Line (Msg & " elab order failed");
end if;
S := Succ.Table (S).Next;
end loop;
end;
end loop;
-- An SCC of size 2 units necessarily consists of a spec and the
-- corresponding body. Assert that the body is elaborated immediately
-- after the spec, with nothing in between. (We only have SCCs in the
-- new algorithm.)
if Doing_New then
for J in Order'Range loop
declare
U : constant Unit_Id := Order (J);
begin
if Nodes (U)'Length = 2 then
if Units.Table (U).Utype = Is_Spec then
if Order (J + 1) /= Corresponding_Body (U) then
OK := False;
Write_Line (Msg & "Bad spec with SCC of size 2:");
Write_SCC (SCC (U));
end if;
end if;
if Units.Table (U).Utype = Is_Body then
if Order (J - 1) /= Corresponding_Spec (U) then
OK := False;
Write_Line (Msg & "Bad body with SCC of size 2:");
Write_SCC (SCC (U));
end if;
end if;
end if;
end;
end loop;
-- Assert that all units of an SCC are elaborated together, with no
-- units from other SCCs in between. The above spec/body case is a
-- special case of this general rule.
for J in Order'Range loop
declare
U : constant Unit_Id := Order (J);
begin
if SCC (U) /= Cur_SCC then
Cur_SCC := SCC (U);
if UNR.Table (Cur_SCC).Validate_Seen then
OK := False;
Write_Line (Msg & "SCC not elaborated together:");
Write_SCC (Cur_SCC);
end if;
UNR.Table (Cur_SCC).Validate_Seen := True;
end if;
end;
end loop;
end if;
pragma Assert (OK);
end Validate;
-------------------
-- Write_Closure --
-------------------
procedure Write_Closure (Order : Unit_Id_Array) is
package Closure_Sources is new Table.Table
(Table_Component_Type => File_Name_Type,
Table_Index_Type => Natural,
Table_Low_Bound => 1,
Table_Initial => 10,
Table_Increment => 100,
Table_Name => "Gnatbind.Closure_Sources");
-- Table to record the sources in the closure, to avoid duplications
function Put_In_Sources (S : File_Name_Type) return Boolean;
-- Check if S is already in table Sources and put in Sources if it is
-- not. Return False if the source is already in Sources, and True if
-- it is added.
--------------------
-- Put_In_Sources --
--------------------
function Put_In_Sources (S : File_Name_Type) return Boolean is
begin
for J in 1 .. Closure_Sources.Last loop
if Closure_Sources.Table (J) = S then
return False;
end if;
end loop;
Closure_Sources.Append (S);
return True;
end Put_In_Sources;
-- Local variables
Source : File_Name_Type;
-- Start of processing for Write_Closure
begin
Closure_Sources.Init;
if not Zero_Formatting then
Write_Eol;
Write_Line ("REFERENCED SOURCES");
end if;
for J in reverse Order'Range loop
Source := Units.Table (Order (J)).Sfile;
-- Do not include same source more than once
if Put_In_Sources (Source)
-- Do not include run-time units unless -Ra switch set
and then (List_Closure_All
or else not Is_Internal_File_Name (Source))
then
if not Zero_Formatting then
Write_Str (" ");
end if;
Write_Line (Get_Name_String (Source));
end if;
end loop;
-- Subunits do not appear in the elaboration table because they are
-- subsumed by their parent units, but we need to list them for other
-- tools. For now they are listed after other files, rather than right
-- after their parent, since there is no easy link between the
-- elaboration table and the ALIs table. As subunits may appear
-- repeatedly in the list, if the parent unit appears in the context of
-- several units in the closure, duplicates are suppressed.
for J in Sdep.First .. Sdep.Last loop
Source := Sdep.Table (J).Sfile;
if Sdep.Table (J).Subunit_Name /= No_Name
and then Put_In_Sources (Source)
and then not Is_Internal_File_Name (Source)
then
if not Zero_Formatting then
Write_Str (" ");
end if;
Write_Line (Get_Name_String (Source));
end if;
end loop;
if not Zero_Formatting then
Write_Eol;
end if;
end Write_Closure;
------------------------
-- Write_Dependencies --
------------------------
procedure Write_Dependencies is
begin
if not Zero_Formatting then
Write_Eol;
Write_Line (" ELABORATION ORDER DEPENDENCIES");
Write_Eol;
end if;
Info_Prefix_Suppress := True;
for S in Succ_First .. Succ.Last loop
Elab_Error_Msg (S);
end loop;
Info_Prefix_Suppress := False;
if not Zero_Formatting then
Write_Eol;
end if;
end Write_Dependencies;
--------------------------
-- Write_Elab_All_Chain --
--------------------------
procedure Write_Elab_All_Chain (S : Successor_Id) is
ST : constant Successor_Link := Succ.Table (S);
After : constant Unit_Name_Type := Units.Table (ST.After).Uname;
L : Elab_All_Id;
Nam : Unit_Name_Type;
First_Name : Boolean := True;
begin
if ST.Reason in Elab_All .. Elab_All_Desirable then
L := ST.Elab_All_Link;
pragma Annotate (CodePeer, Modified, L);
while L /= No_Elab_All_Link loop
Nam := Elab_All_Entries.Table (L).Needed_By;
Error_Msg_Unit_1 := Nam;
Error_Msg_Output (" $", Info => True);
Get_Name_String (Nam);
if Name_Buffer (Name_Len) = 'b' then
if First_Name then
Error_Msg_Output
(" must be elaborated along with its spec:",
Info => True);
else
Error_Msg_Output
(" which must be elaborated along with its "
& "spec:",
Info => True);
end if;
else
if First_Name then
Error_Msg_Output
(" is withed by:",
Info => True);
else
Error_Msg_Output
(" which is withed by:",
Info => True);
end if;
end if;
First_Name := False;
L := Elab_All_Entries.Table (L).Next_Elab;
end loop;
Error_Msg_Unit_1 := After;
Error_Msg_Output (" $", Info => True);
end if;
end Write_Elab_All_Chain;
----------------------
-- Write_Elab_Order --
----------------------
procedure Write_Elab_Order
(Order : Unit_Id_Array; Title : String)
is
begin
if Title /= "" then
Write_Eol;
Write_Line (Title);
end if;
for J in Order'Range loop
if not Units.Table (Order (J)).SAL_Interface then
if not Zero_Formatting then
Write_Str (" ");
end if;
Write_Unit_Name (Units.Table (Order (J)).Uname);
Write_Eol;
end if;
end loop;
if Title /= "" then
Write_Eol;
end if;
end Write_Elab_Order;
--------------
-- Elab_New --
--------------
package body Elab_New is
generic
type Node is (<>);
First_Node : Node;
Last_Node : Node;
type Node_Array is array (Pos range <>) of Node;
with function Successors (N : Node) return Node_Array;
with procedure Create_SCC (Root : Node; Nodes : Node_Array);
procedure Compute_Strongly_Connected_Components;
-- Compute SCCs for a directed graph. The nodes in the graph are all
-- values of type Node in the range First_Node .. Last_Node.
-- Successors(N) returns the nodes pointed to by the edges emanating
-- from N. Create_SCC is a callback that is called once for each SCC,
-- passing in the Root node for that SCC (which is an arbitrary node in
-- the SCC used as a representative of that SCC), and the set of Nodes
-- in that SCC.
--
-- This is generic, in case we want to use it elsewhere; then we could
-- move this into a separate library unit. Unfortunately, it's not as
-- generic as one might like. Ideally, we would have "type Node is
-- private;", and pass in iterators to iterate over all nodes, and over
-- the successors of a given node. However, that leads to using advanced
-- features of Ada that are not allowed in the compiler and binder for
-- bootstrapping reasons. It also leads to trampolines, which are not
-- allowed in the compiler and binder. Restricting Node to be discrete
-- allows us to iterate over all nodes with a 'for' loop, and allows us
-- to attach temporary information to nodes by having an array indexed
-- by Node.
procedure Compute_Unit_SCCs;
-- Use the above generic procedure to compute the SCCs for the graph of
-- units. Store in each Unit_Node_Record the SCC_Root and Nodes
-- components. Also initialize the SCC_Num_Pred components.
procedure Find_Elab_All_Errors;
-- Generate an error for illegal Elaborate_All pragmas (explicit or
-- implicit). A pragma Elaborate_All (Y) on unit X is legal if and only
-- if X and Y are in different SCCs.
-------------------------------------------
-- Compute_Strongly_Connected_Components --
-------------------------------------------
procedure Compute_Strongly_Connected_Components is
-- This uses Tarjan's algorithm for finding SCCs. Comments here are
-- intended to tell what it does, but if you want to know how it
-- works, you have to look it up. Please do not modify this code
-- without reading up on Tarjan's algorithm.
subtype Node_Index is Nat;
No_Index : constant Node_Index := 0;
Num_Nodes : constant Nat :=
Node'Pos (Last_Node) - Node'Pos (First_Node) + 1;
Stack : Node_Array (1 .. Num_Nodes);
Top : Node_Index := 0;
-- Stack of nodes, pushed when first visited. All nodes of an SCC are
-- popped at once when the SCC is found.
subtype Valid_Node is Node range First_Node .. Last_Node;
Node_Indices : array (Valid_Node) of Node_Index :=
(others => No_Index);
-- Each node has an "index", which is the sequential number in the
-- order in which they are visited in the recursive walk. No_Index
-- means "not yet visited"; we want to avoid walking any node more
-- than once.
Index : Node_Index := 1;
-- Next value to be assigned to a node index
Low_Links : array (Valid_Node) of Node_Index;
-- Low_Links (N) is the smallest index of nodes reachable from N
On_Stack : array (Valid_Node) of Boolean := (others => False);
-- True if the node is currently on the stack
procedure Walk (N : Valid_Node);
-- Recursive depth-first graph walk, with the node index used to
-- avoid visiting a node more than once.
----------
-- Walk --
----------
procedure Walk (N : Valid_Node) is
Stack_Position_Of_N : constant Pos := Top + 1;
S : constant Node_Array := Successors (N);
begin
-- Assign the index and low link, increment Index for next call to
-- Walk.
Node_Indices (N) := Index;
Low_Links (N) := Index;
Index := Index + 1;
-- Push it on the stack:
Top := Stack_Position_Of_N;
Stack (Top) := N;
On_Stack (N) := True;
-- Walk not-yet-visited subnodes, and update low link for visited
-- ones as appropriate.
for J in S'Range loop
if Node_Indices (S (J)) = No_Index then
Walk (S (J));
Low_Links (N) :=
Node_Index'Min (Low_Links (N), Low_Links (S (J)));
elsif On_Stack (S (J)) then
Low_Links (N) :=
Node_Index'Min (Low_Links (N), Node_Indices (S (J)));
end if;
end loop;
-- If the index is (still) equal to the low link, we've found an
-- SCC. Pop the whole SCC off the stack, and call Create_SCC.
if Low_Links (N) = Node_Indices (N) then
declare
SCC : Node_Array renames
Stack (Stack_Position_Of_N .. Top);
pragma Assert (SCC'Length >= 1);
pragma Assert (SCC (SCC'First) = N);
begin
for J in SCC'Range loop
On_Stack (SCC (J)) := False;
end loop;
Create_SCC (Root => N, Nodes => SCC);
pragma Assert (Top - SCC'Length = Stack_Position_Of_N - 1);
Top := Stack_Position_Of_N - 1; -- pop all
end;
end if;
end Walk;
-- Start of processing for Compute_Strongly_Connected_Components
begin
-- Walk all the nodes that have not yet been walked
for N in Valid_Node loop
if Node_Indices (N) = No_Index then
Walk (N);
end if;
end loop;
end Compute_Strongly_Connected_Components;
-----------------------
-- Compute_Unit_SCCs --
-----------------------
procedure Compute_Unit_SCCs is
function Successors (U : Unit_Id) return Unit_Id_Array;
-- Return all the units that must be elaborated after U. In addition,
-- if U is a body, include the corresponding spec; this ensures that
-- a spec/body pair are always in the same SCC.
procedure Create_SCC (Root : Unit_Id; Nodes : Unit_Id_Array);
-- Set Nodes of the Root, and set SCC_Root of all the Nodes
procedure Init_SCC_Num_Pred (U : Unit_Id);
-- Initialize the SCC_Num_Pred fields, so that the root of each SCC
-- has a count of the number of successors of all the units in the
-- SCC, but only for successors outside the SCC.
procedure Compute_SCCs is new Compute_Strongly_Connected_Components
(Node => Unit_Id,
First_Node => Units.First,
Last_Node => Units.Last,
Node_Array => Unit_Id_Array,
Successors => Successors,
Create_SCC => Create_SCC);
----------------
-- Create_SCC --
----------------
procedure Create_SCC (Root : Unit_Id; Nodes : Unit_Id_Array) is
begin
if Debug_Flag_V then
Write_Str ("Root = ");
Write_Int (Int (Root));
Write_Str (" ");
Write_Unit_Name (Units.Table (Root).Uname);
Write_Str (" -- ");
Write_Int (Nodes'Length);
Write_Line (" units:");
for J in Nodes'Range loop
Write_Str (" ");
Write_Int (Int (Nodes (J)));
Write_Str (" ");
Write_Unit_Name (Units.Table (Nodes (J)).Uname);
Write_Eol;
end loop;
end if;
pragma Assert (Nodes (Nodes'First) = Root);
pragma Assert (UNR.Table (Root).Nodes = null);
UNR.Table (Root).Nodes := new Unit_Id_Array'(Nodes);
for J in Nodes'Range loop
pragma Assert (SCC (Nodes (J)) = No_Unit_Id);
UNR.Table (Nodes (J)).SCC_Root := Root;
end loop;
end Create_SCC;
----------------
-- Successors --
----------------
function Successors (U : Unit_Id) return Unit_Id_Array is
S : Successor_Id := UNR.Table (U).Successors;
Tab : Unit_Id_Table;
begin
-- Pretend that a spec is a successor of its body (even though it
-- isn't), just so both get included.
if Units.Table (U).Utype = Is_Body then
Append (Tab, Corresponding_Spec (U));
end if;
-- Now include the real successors
while S /= No_Successor loop
pragma Assert (Succ.Table (S).Before = U);
Append (Tab, Succ.Table (S).After);
S := Succ.Table (S).Next;
end loop;
declare
Result : constant Unit_Id_Array := Tab.Table (1 .. Last (Tab));
begin
Free (Tab);
return Result;
end;
end Successors;
-----------------------
-- Init_SCC_Num_Pred --
-----------------------
procedure Init_SCC_Num_Pred (U : Unit_Id) is
begin
if UNR.Table (U).Visited then
return;
end if;
UNR.Table (U).Visited := True;
declare
S : Successor_Id := UNR.Table (U).Successors;
begin
while S /= No_Successor loop
pragma Assert (Succ.Table (S).Before = U);
Init_SCC_Num_Pred (Succ.Table (S).After);
if SCC (U) /= SCC (Succ.Table (S).After) then
UNR.Table (SCC (Succ.Table (S).After)).SCC_Num_Pred :=
UNR.Table (SCC (Succ.Table (S).After)).SCC_Num_Pred + 1;
end if;
S := Succ.Table (S).Next;
end loop;
end;
end Init_SCC_Num_Pred;
-- Start of processing for Compute_Unit_SCCs
begin
Compute_SCCs;
for Uref in UNR.First .. UNR.Last loop
pragma Assert (not UNR.Table (Uref).Visited);
null;
end loop;
for Uref in UNR.First .. UNR.Last loop
Init_SCC_Num_Pred (Uref);
end loop;
-- Assert that SCC_Root of all units has been set to a valid unit,
-- and that SCC_Num_Pred has not been modified in non-root units.
for Uref in UNR.First .. UNR.Last loop
pragma Assert (UNR.Table (Uref).SCC_Root /= No_Unit_Id);
pragma Assert (UNR.Table (Uref).SCC_Root in UNR.First .. UNR.Last);
if SCC (Uref) /= Uref then
pragma Assert (UNR.Table (Uref).SCC_Num_Pred = 0);
null;
end if;
end loop;
end Compute_Unit_SCCs;
--------------------------
-- Find_Elab_All_Errors --
--------------------------
procedure Find_Elab_All_Errors is
Withed_Unit : Unit_Id;
begin
for U in Units.First .. Units.Last loop
-- If this unit is not an interface to a stand-alone library,
-- process WITH references for this unit ignoring interfaces to
-- stand-alone libraries.
if not Units.Table (U).SAL_Interface then
for W in Units.Table (U).First_With ..
Units.Table (U).Last_With
loop
if Withs.Table (W).Sfile /= No_File
and then (not Withs.Table (W).SAL_Interface)
then
-- Check for special case of withing a unit that does not
-- exist any more.
if Get_Name_Table_Int (Withs.Table (W).Uname) = 0 then
goto Next_With;
end if;
Withed_Unit := Unit_Id_Of (Withs.Table (W).Uname);
-- If it's Elaborate_All or Elab_All_Desirable, check
-- that the withER and withEE are not in the same SCC.
if Withs.Table (W).Elaborate_All
or else Withs.Table (W).Elab_All_Desirable
then
if SCC (U) = SCC (Withed_Unit) then
Elab_Cycle_Found := True;
-- We could probably give better error messages
-- than Elab_Old here, but for now, to avoid
-- disruption, we don't give any error here.
-- Instead, we set the Elab_Cycle_Found flag above,
-- and then run the Elab_Old algorithm to issue the
-- error message. Ideally, we would like to print
-- multiple errors rather than stopping after the
-- first cycle.
if False then
Error_Msg_Output
("illegal pragma Elaborate_All",
Info => False);
end if;
end if;
end if;
end if;
<<Next_With>>
null;
end loop;
end if;
end loop;
end Find_Elab_All_Errors;
---------------------
-- Find_Elab_Order --
---------------------
procedure Find_Elab_Order (Elab_Order : out Unit_Id_Table) is
Best_So_Far : Unit_Id;
U : Unit_Id;
begin
-- Gather dependencies and output them if option set
Gather_Dependencies;
Compute_Unit_SCCs;
-- Initialize the no-predecessor list
No_Pred := No_Unit_Id;
for U in UNR.First .. UNR.Last loop
if UNR.Table (U).Num_Pred = 0 then
UNR.Table (U).Nextnp := No_Pred;
No_Pred := U;
end if;
end loop;
-- OK, now we determine the elaboration order proper. All we do is to
-- select the best choice from the no-predecessor list until all the
-- nodes have been chosen.
Outer : loop
if Debug_Flag_N then
Write_Line ("Outer loop");
end if;
-- If there are no nodes with predecessors, then either we are
-- done, as indicated by Num_Left being set to zero, or we have a
-- circularity. In the latter case, diagnose the circularity,
-- removing it from the graph and
-- continue. Diagnose_Elaboration_Problem always raises an
-- exception, so the loop never goes around more than once.
Get_No_Pred : while No_Pred = No_Unit_Id loop
exit Outer when Num_Left < 1;
Diagnose_Elaboration_Problem (Elab_Order);
end loop Get_No_Pred;
U := No_Pred;
Best_So_Far := No_Unit_Id;
-- Loop to choose best entry in No_Pred list
No_Pred_Search : loop
if Debug_Flag_N then
Write_Str (" considering choice of ");
Write_Unit_Name (Units.Table (U).Uname);
Write_Eol;
if Units.Table (U).Elaborate_Body then
Write_Str
(" Elaborate_Body = True, Num_Pred for body = ");
Write_Int
(UNR.Table (Corresponding_Body (U)).Num_Pred);
else
Write_Str
(" Elaborate_Body = False");
end if;
Write_Eol;
end if;
-- Don't even consider units whose SCC is not ready. This
-- ensures that all units of an SCC will be elaborated
-- together, with no other units in between.
if SCC_Num_Pred (U) = 0
and then Better_Choice (U, Best_So_Far)
then
if Debug_Flag_N then
Write_Line (" tentatively chosen (best so far)");
end if;
Best_So_Far := U;
else
if Debug_Flag_N then
Write_Line (" SCC not ready");
end if;
end if;
U := UNR.Table (U).Nextnp;
exit No_Pred_Search when U = No_Unit_Id;
end loop No_Pred_Search;
-- If there are no units on the No_Pred list whose SCC is ready,
-- there must be a cycle. Defer to Elab_Old to print an error
-- message.
if Best_So_Far = No_Unit_Id then
Elab_Cycle_Found := True;
return;
end if;
-- Choose the best candidate found
Choose (Elab_Order, Best_So_Far, " [Best_So_Far]");
-- If it's a spec with a body, and the body is not yet chosen,
-- choose the body if possible. The case where the body is
-- already chosen is Elaborate_Body; the above call to Choose
-- the spec will also Choose the body.
if Units.Table (Best_So_Far).Utype = Is_Spec
and then UNR.Table
(Corresponding_Body (Best_So_Far)).Elab_Position = 0
then
declare
Choose_The_Body : constant Boolean :=
UNR.Table (Corresponding_Body
(Best_So_Far)).Num_Pred = 0;
begin
if Debug_Flag_B then
Write_Str ("Can we choose the body?... ");
if Choose_The_Body then
Write_Line ("Yes!");
else
Write_Line ("No.");
end if;
end if;
if Choose_The_Body then
Choose
(Elab_Order => Elab_Order,
Chosen => Corresponding_Body (Best_So_Far),
Msg => " [body]");
end if;
end;
end if;
-- Finally, choose all the rest of the units in the same SCC as
-- Best_So_Far. If it hasn't been chosen (Elab_Position = 0), and
-- it's ready to be chosen (Num_Pred = 0), then we can choose it.
loop
declare
Chose_One_Or_More : Boolean := False;
SCC : Unit_Id_Array renames Nodes (Best_So_Far).all;
begin
for J in SCC'Range loop
if UNR.Table (SCC (J)).Elab_Position = 0
and then UNR.Table (SCC (J)).Num_Pred = 0
then
Chose_One_Or_More := True;
Choose (Elab_Order, SCC (J), " [same SCC]");
end if;
end loop;
exit when not Chose_One_Or_More;
end;
end loop;
end loop Outer;
Find_Elab_All_Errors;
end Find_Elab_Order;
-----------
-- Nodes --
-----------
function Nodes (U : Unit_Id) return Unit_Id_Array_Ptr is
begin
return UNR.Table (SCC (U)).Nodes;
end Nodes;
---------
-- SCC --
---------
function SCC (U : Unit_Id) return Unit_Id is
begin
return UNR.Table (U).SCC_Root;
end SCC;
------------------
-- SCC_Num_Pred --
------------------
function SCC_Num_Pred (U : Unit_Id) return Int is
begin
return UNR.Table (SCC (U)).SCC_Num_Pred;
end SCC_Num_Pred;
---------------
-- Write_SCC --
---------------
procedure Write_SCC (U : Unit_Id) is
pragma Assert (SCC (U) = U);
begin
for J in Nodes (U)'Range loop
Write_Int (UNR.Table (Nodes (U) (J)).Elab_Position);
Write_Str (". ");
Write_Unit_Name (Units.Table (Nodes (U) (J)).Uname);
Write_Eol;
end loop;
Write_Eol;
end Write_SCC;
end Elab_New;
--------------
-- Elab_Old --
--------------
package body Elab_Old is
---------------------
-- Find_Elab_Order --
---------------------
procedure Find_Elab_Order (Elab_Order : out Unit_Id_Table) is
Best_So_Far : Unit_Id;
U : Unit_Id;
begin
-- Gather dependencies and output them if option set
Gather_Dependencies;
-- Initialize the no-predecessor list
No_Pred := No_Unit_Id;
for U in UNR.First .. UNR.Last loop
if UNR.Table (U).Num_Pred = 0 then
UNR.Table (U).Nextnp := No_Pred;
No_Pred := U;
end if;
end loop;
-- OK, now we determine the elaboration order proper. All we do is to
-- select the best choice from the no-predecessor list until all the
-- nodes have been chosen.
Outer : loop
-- If there are no nodes with predecessors, then either we are
-- done, as indicated by Num_Left being set to zero, or we have a
-- circularity. In the latter case, diagnose the circularity,
-- removing it from the graph and continue.
-- Diagnose_Elaboration_Problem always raises an exception, so the
-- loop never goes around more than once.
Get_No_Pred : while No_Pred = No_Unit_Id loop
exit Outer when Num_Left < 1;
Diagnose_Elaboration_Problem (Elab_Order);
end loop Get_No_Pred;
U := No_Pred;
Best_So_Far := No_Unit_Id;
-- Loop to choose best entry in No_Pred list
No_Pred_Search : loop
if Debug_Flag_N then
Write_Str (" considering choice of ");
Write_Unit_Name (Units.Table (U).Uname);
Write_Eol;
if Units.Table (U).Elaborate_Body then
Write_Str
(" Elaborate_Body = True, Num_Pred for body = ");
Write_Int
(UNR.Table (Corresponding_Body (U)).Num_Pred);
else
Write_Str
(" Elaborate_Body = False");
end if;
Write_Eol;
end if;
-- This is a candididate to be considered for choice
if Better_Choice (U, Best_So_Far) then
if Debug_Flag_N then
Write_Line (" tentatively chosen (best so far)");
end if;
Best_So_Far := U;
end if;
U := UNR.Table (U).Nextnp;
exit No_Pred_Search when U = No_Unit_Id;
end loop No_Pred_Search;
-- Choose the best candidate found
Choose (Elab_Order, Best_So_Far, " [Elab_Old Best_So_Far]");
end loop Outer;
end Find_Elab_Order;
end Elab_Old;
end Binde;