------------------------------------------------------------------------------ | |

-- -- | |

-- GNAT COMPILER COMPONENTS -- | |

-- -- | |

-- B I N D O . E L A B O R A T O R S -- | |

-- -- | |

-- B o d y -- | |

-- -- | |

-- Copyright (C) 2019-2022, 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 Butil; use Butil; | |

with Debug; use Debug; | |

with Output; use Output; | |

with Types; use Types; | |

with Bindo.Augmentors; | |

use Bindo.Augmentors; | |

use Bindo.Augmentors.Library_Graph_Augmentors; | |

with Bindo.Builders; | |

use Bindo.Builders; | |

use Bindo.Builders.Invocation_Graph_Builders; | |

use Bindo.Builders.Library_Graph_Builders; | |

with Bindo.Diagnostics; | |

use Bindo.Diagnostics; | |

with Bindo.Units; | |

use Bindo.Units; | |

with Bindo.Validators; | |

use Bindo.Validators; | |

use Bindo.Validators.Elaboration_Order_Validators; | |

with Bindo.Writers; | |

use Bindo.Writers; | |

use Bindo.Writers.ALI_Writers; | |

use Bindo.Writers.Dependency_Writers; | |

use Bindo.Writers.Elaboration_Order_Writers; | |

use Bindo.Writers.Invocation_Graph_Writers; | |

use Bindo.Writers.Library_Graph_Writers; | |

use Bindo.Writers.Phase_Writers; | |

use Bindo.Writers.Unit_Closure_Writers; | |

with GNAT; use GNAT; | |

with GNAT.Graphs; use GNAT.Graphs; | |

package body Bindo.Elaborators is | |

-- The following type defines the advancement of the elaboration order | |

-- algorithm in terms of steps. | |

type Elaboration_Order_Step is new Natural; | |

Initial_Step : constant Elaboration_Order_Step := | |

Elaboration_Order_Step'First; | |

---------------------------------------------- | |

-- Invocation_And_Library_Graph_Elaborators -- | |

---------------------------------------------- | |

package body Invocation_And_Library_Graph_Elaborators is | |

----------------------- | |

-- Local subprograms -- | |

----------------------- | |

procedure Create_Component_Vertex_Sets | |

(G : Library_Graph; | |

Comp : Component_Id; | |

Elaborable_Vertices : out LGV_Sets.Membership_Set; | |

Waiting_Vertices : out LGV_Sets.Membership_Set; | |

Step : Elaboration_Order_Step); | |

pragma Inline (Create_Component_Vertex_Sets); | |

-- Split all vertices of component Comp of library graph G as follows: | |

-- | |

-- * Elaborable vertices are added to set Elaborable_Vertices. | |

-- | |

-- * Vertices that are still waiting on their predecessors to be | |

-- elaborated are added to set Waiting_Vertices. | |

-- | |

-- Step is the current step in the elaboration order. | |

procedure Create_Vertex_Sets | |

(G : Library_Graph; | |

Elaborable_Vertices : out LGV_Sets.Membership_Set; | |

Waiting_Vertices : out LGV_Sets.Membership_Set; | |

Step : Elaboration_Order_Step); | |

pragma Inline (Create_Vertex_Sets); | |

-- Split all vertices of library graph G as follows: | |

-- | |

-- * Elaborable vertices are added to set Elaborable_Vertices. | |

-- | |

-- * Vertices that are still waiting on their predecessors to be | |

-- elaborated are added to set Waiting_Vertices. | |

-- | |

-- Step is the current step in the elaboration order. | |

procedure Elaborate_Component | |

(G : Library_Graph; | |

Comp : Component_Id; | |

All_Elaborable_Vertices : LGV_Sets.Membership_Set; | |

All_Waiting_Vertices : LGV_Sets.Membership_Set; | |

Order : in out Unit_Id_Table; | |

Step : Elaboration_Order_Step); | |

pragma Inline (Elaborate_Component); | |

-- Elaborate as many vertices as possible that appear in component Comp | |

-- of library graph G. The sets contain vertices arranged as follows: | |

-- | |

-- * All_Elaborable_Vertices - all elaborable vertices in the library | |

-- graph. | |

-- | |

-- * All_Waiting_Vertices - all vertices in the library graph that are | |

-- waiting on predecessors to be elaborated. | |

-- | |

-- Order is the elaboration order. Step denotes the current step in the | |

-- elaboration order. | |

procedure Elaborate_Library_Graph | |

(G : Library_Graph; | |

Order : out Unit_Id_Table; | |

Status : out Elaboration_Order_Status); | |

pragma Inline (Elaborate_Library_Graph); | |

-- Elaborate as many vertices as possible of library graph G. Order is | |

-- the elaboration order. Status is the condition of the elaboration | |

-- order. | |

procedure Elaborate_Vertex | |

(G : Library_Graph; | |

Vertex : Library_Graph_Vertex_Id; | |

All_Elaborable_Vertices : LGV_Sets.Membership_Set; | |

All_Waiting_Vertices : LGV_Sets.Membership_Set; | |

Comp_Elaborable_Vertices : LGV_Sets.Membership_Set; | |

Comp_Waiting_Vertices : LGV_Sets.Membership_Set; | |

Order : in out Unit_Id_Table; | |

Step : Elaboration_Order_Step; | |

Indent : Indentation_Level); | |

pragma Inline (Elaborate_Vertex); | |

-- Elaborate vertex Vertex of library graph G by adding its unit to | |

-- elaboration order Order. The routine updates awaiting successors | |

-- where applicable. The sets contain vertices arranged as follows: | |

-- | |

-- * All_Elaborable_Vertices - all elaborable vertices in the library | |

-- graph. | |

-- | |

-- * All_Waiting_Vertices - all vertices in the library graph that are | |

-- waiting on predecessors to be elaborated. | |

-- | |

-- * Comp_Elaborable_Vertices - all elaborable vertices found in the | |

-- component of Vertex. | |

-- | |

-- * Comp_Waiting_Vertices - all vertices found in the component of | |

-- Vertex that are still waiting on predecessors to be elaborated. | |

-- | |

-- Order denotes the elaboration order. Step is the current step in the | |

-- elaboration order. Indent denotes the desired indentation level for | |

-- tracing. | |

function Find_Best_Elaborable_Vertex | |

(G : Library_Graph; | |

Set : LGV_Sets.Membership_Set; | |

Step : Elaboration_Order_Step; | |

Indent : Indentation_Level) return Library_Graph_Vertex_Id; | |

pragma Inline (Find_Best_Elaborable_Vertex); | |

-- Find the best vertex of library graph G from membership set S that | |

-- can be elaborated. Step is the current step in the elaboration order. | |

-- Indent is the desired indentation level for tracing. | |

function Find_Best_Vertex | |

(G : Library_Graph; | |

Set : LGV_Sets.Membership_Set; | |

Is_Suitable_Vertex : LGV_Predicate_Ptr; | |

Compare_Vertices : LGV_Comparator_Ptr; | |

Initial_Best_Msg : String; | |

Subsequent_Best_Msg : String; | |

Step : Elaboration_Order_Step; | |

Indent : Indentation_Level) | |

return Library_Graph_Vertex_Id; | |

pragma Inline (Find_Best_Vertex); | |

-- Find the best vertex of library graph G from membership set S which | |

-- satisfies predicate Is_Suitable_Vertex and is preferred by comparator | |

-- Compare_Vertices. Initial_Best_Msg is emitted on the first candidate | |

-- vertex. Subsequent_Best_Msg is emitted whenever a better vertex is | |

-- discovered. Step is the current step in the elaboration order. Indent | |

-- is the desired indentation level for tracing. | |

function Find_Best_Weakly_Elaborable_Vertex | |

(G : Library_Graph; | |

Set : LGV_Sets.Membership_Set; | |

Step : Elaboration_Order_Step; | |

Indent : Indentation_Level) return Library_Graph_Vertex_Id; | |

pragma Inline (Find_Best_Weakly_Elaborable_Vertex); | |

-- Find the best vertex of library graph G from membership set S that | |

-- can be weakly elaborated. Step is the current step in the elaboration | |

-- order. Indent is the desired indentation level for tracing. | |

function Has_Elaborable_Body | |

(G : Library_Graph; | |

Vertex : Library_Graph_Vertex_Id) return Boolean; | |

pragma Inline (Has_Elaborable_Body); | |

-- Determine whether vertex Vertex of library graph G has a body that is | |

-- elaborable. It is assumed that the vertex has been elaborated. | |

procedure Insert_Elaborable_Successor | |

(G : Library_Graph; | |

Vertex : Library_Graph_Vertex_Id; | |

Elaborable_Vertices : LGV_Sets.Membership_Set; | |

All_Waiting_Vertices : LGV_Sets.Membership_Set; | |

Comp_Waiting_Vertices : LGV_Sets.Membership_Set; | |

Msg : String; | |

Step : Elaboration_Order_Step; | |

Indent : Indentation_Level); | |

pragma Inline (Insert_Elaborable_Successor); | |

-- Add elaborable successor Vertex of library graph G to membership set | |

-- Elaborable_Vertices and remove it from both All_Waiting_Vertices and | |

-- Comp_Waiting_Vertices. Msg is a message emitted for tracing purposes. | |

-- Step is the current step in the elaboration order. Indent denotes the | |

-- desired indentation level for tracing. | |

procedure Insert_Vertex | |

(G : Library_Graph; | |

Vertex : Library_Graph_Vertex_Id; | |

Set : LGV_Sets.Membership_Set; | |

Msg : String; | |

Step : Elaboration_Order_Step; | |

Indent : Indentation_Level); | |

pragma Inline (Insert_Vertex); | |

-- Add vertex Vertex of library graph G to membership set Set. Msg is | |

-- a message emitted for tracing purposes. Step is the current step in | |

-- the elaboration order. Indent is the desired indentation level for | |

-- tracing. | |

function Is_Better_Elaborable_Vertex | |

(G : Library_Graph; | |

Vertex : Library_Graph_Vertex_Id; | |

Compared_To : Library_Graph_Vertex_Id) return Precedence_Kind; | |

pragma Inline (Is_Better_Elaborable_Vertex); | |

-- Determine whether vertex Vertex of library graph G is a better choice | |

-- for elaboration compared to vertex Compared_To. | |

function Is_Better_Weakly_Elaborable_Vertex | |

(G : Library_Graph; | |

Vertex : Library_Graph_Vertex_Id; | |

Compared_To : Library_Graph_Vertex_Id) return Precedence_Kind; | |

pragma Inline (Is_Better_Weakly_Elaborable_Vertex); | |

-- Determine whether vertex Vertex of library graph G is a better choice | |

-- for weak elaboration compared to vertex Compared_To. | |

function Is_Suitable_Elaborable_Vertex | |

(G : Library_Graph; | |

Vertex : Library_Graph_Vertex_Id) return Boolean; | |

pragma Inline (Is_Suitable_Elaborable_Vertex); | |

-- Determine whether vertex Vertex of library graph G is suitable for | |

-- elaboration. | |

function Is_Suitable_Weakly_Elaborable_Vertex | |

(G : Library_Graph; | |

Vertex : Library_Graph_Vertex_Id) return Boolean; | |

pragma Inline (Is_Suitable_Weakly_Elaborable_Vertex); | |

-- Determine whether vertex Vertex of library graph G is suitable for | |

-- weak elaboration. | |

procedure Set_Unit_Elaboration_Positions (Order : Unit_Id_Table); | |

pragma Inline (Set_Unit_Elaboration_Positions); | |

-- Set the ALI.Units positions of all elaboration units in order Order | |

procedure Trace_Component | |

(G : Library_Graph; | |

Comp : Component_Id; | |

Msg : String; | |

Step : Elaboration_Order_Step); | |

pragma Inline (Trace_Component); | |

-- Write elaboration-related information for component Comp of library | |

-- graph G to standard output, starting with message Msg. Step is the | |

-- current step in the elaboration order. | |

procedure Trace_Step (Step : Elaboration_Order_Step); | |

pragma Inline (Trace_Step); | |

-- Write current step Step of the elaboration order to standard output | |

procedure Trace_Vertex | |

(G : Library_Graph; | |

Vertex : Library_Graph_Vertex_Id; | |

Msg : String; | |

Step : Elaboration_Order_Step; | |

Indent : Indentation_Level); | |

pragma Inline (Trace_Vertex); | |

-- Write elaboration-related information for vertex Vertex of library | |

-- graph G to standard output, starting with message Msg. Step is the | |

-- current step in the elaboration order. Indent denotes the desired | |

-- indentation level for tracing. | |

procedure Trace_Vertices | |

(G : Library_Graph; | |

Set : LGV_Sets.Membership_Set; | |

Set_Msg : String; | |

Vertex_Msg : String; | |

Step : Elaboration_Order_Step; | |

Indent : Indentation_Level); | |

pragma Inline (Trace_Vertices); | |

-- Write the candidate vertices of library graph G present in membership | |

-- set Set to standard output, starting with message Set_Msg. Vertex_Msg | |

-- is the message emitted prior to each vertex. Step denotes the current | |

-- step in the elaboration order. Indent denotes the desired indentation | |

-- level for tracing. | |

procedure Update_Successor | |

(G : Library_Graph; | |

Edge : Library_Graph_Edge_Id; | |

All_Elaborable_Vertices : LGV_Sets.Membership_Set; | |

All_Waiting_Vertices : LGV_Sets.Membership_Set; | |

Comp_Elaborable_Vertices : LGV_Sets.Membership_Set; | |

Comp_Waiting_Vertices : LGV_Sets.Membership_Set; | |

Step : Elaboration_Order_Step; | |

Indent : Indentation_Level); | |

pragma Inline (Update_Successor); | |

-- Notify the successor of edge Edge of library graph G along with its | |

-- component that their predecessor has just been elaborated. This may | |

-- cause new vertices to become elaborable. The sets contain vertices | |

-- arranged as follows: | |

-- | |

-- * All_Elaborable_Vertices - all elaborable vertices in the library | |

-- graph. | |

-- | |

-- * All_Waiting_Vertices - all vertices in the library graph that are | |

-- waiting on predecessors to be elaborated. | |

-- | |

-- * Comp_Elaborable_Vertices - all elaborable vertices found in the | |

-- component of Vertex. | |

-- | |

-- * Comp_Waiting_Vertices - all vertices found in the component of | |

-- Vertex that are still waiting on predecessors to be elaborated. | |

-- | |

-- Step is the current step in the elaboration order. Indent denotes the | |

-- desired indentation level for tracing. | |

procedure Update_Successors | |

(G : Library_Graph; | |

Vertex : Library_Graph_Vertex_Id; | |

All_Elaborable_Vertices : LGV_Sets.Membership_Set; | |

All_Waiting_Vertices : LGV_Sets.Membership_Set; | |

Comp_Elaborable_Vertices : LGV_Sets.Membership_Set; | |

Comp_Waiting_Vertices : LGV_Sets.Membership_Set; | |

Step : Elaboration_Order_Step; | |

Indent : Indentation_Level); | |

pragma Inline (Update_Successors); | |

-- Notify all successors of vertex Vertex of library graph G along with | |

-- their components that their predecessor has just been elaborated. | |

-- This may cause new vertices to become elaborable. The sets contain | |

-- vertices arranged as follows: | |

-- | |

-- * All_Elaborable_Vertices - all elaborable vertices in the library | |

-- graph. | |

-- | |

-- * All_Waiting_Vertices - all vertices in the library graph that are | |

-- waiting on predecessors to be elaborated. | |

-- | |

-- * Comp_Elaborable_Vertices - all elaborable vertices found in the | |

-- component of Vertex. | |

-- | |

-- * Comp_Waiting_Vertices - all vertices found in the component of | |

-- Vertex that are still waiting on predecessors to be elaborated. | |

-- | |

-- Step is the current step in the elaboration order. Indent denotes the | |

-- desired indentation level for tracing. | |

---------------------------------- | |

-- Create_Component_Vertex_Sets -- | |

---------------------------------- | |

procedure Create_Component_Vertex_Sets | |

(G : Library_Graph; | |

Comp : Component_Id; | |

Elaborable_Vertices : out LGV_Sets.Membership_Set; | |

Waiting_Vertices : out LGV_Sets.Membership_Set; | |

Step : Elaboration_Order_Step) | |

is | |

pragma Assert (Present (G)); | |

pragma Assert (Present (Comp)); | |

Num_Of_Vertices : constant Natural := | |

Number_Of_Component_Vertices (G, Comp); | |

Iter : Component_Vertex_Iterator; | |

Vertex : Library_Graph_Vertex_Id; | |

begin | |

Elaborable_Vertices := LGV_Sets.Create (Num_Of_Vertices); | |

Waiting_Vertices := LGV_Sets.Create (Num_Of_Vertices); | |

Iter := Iterate_Component_Vertices (G, Comp); | |

while Has_Next (Iter) loop | |

Next (Iter, Vertex); | |

-- Add the vertex to the proper set depending on whether it can be | |

-- elaborated. | |

if Is_Elaborable_Vertex (G, Vertex) then | |

Insert_Vertex | |

(G => G, | |

Vertex => Vertex, | |

Set => Elaborable_Vertices, | |

Msg => "add elaborable component vertex", | |

Step => Step, | |

Indent => No_Indentation); | |

else | |

Insert_Vertex | |

(G => G, | |

Vertex => Vertex, | |

Set => Waiting_Vertices, | |

Msg => "add waiting component vertex", | |

Step => Step, | |

Indent => No_Indentation); | |

end if; | |

end loop; | |

end Create_Component_Vertex_Sets; | |

------------------------ | |

-- Create_Vertex_Sets -- | |

------------------------ | |

procedure Create_Vertex_Sets | |

(G : Library_Graph; | |

Elaborable_Vertices : out LGV_Sets.Membership_Set; | |

Waiting_Vertices : out LGV_Sets.Membership_Set; | |

Step : Elaboration_Order_Step) | |

is | |

pragma Assert (Present (G)); | |

Num_Of_Vertices : constant Natural := Number_Of_Vertices (G); | |

Iter : Library_Graphs.All_Vertex_Iterator; | |

Vertex : Library_Graph_Vertex_Id; | |

begin | |

Elaborable_Vertices := LGV_Sets.Create (Num_Of_Vertices); | |

Waiting_Vertices := LGV_Sets.Create (Num_Of_Vertices); | |

Iter := Iterate_All_Vertices (G); | |

while Has_Next (Iter) loop | |

Next (Iter, Vertex); | |

-- Add the vertex to the proper set depending on whether it can be | |

-- elaborated. | |

if Is_Elaborable_Vertex (G, Vertex) then | |

Insert_Vertex | |

(G => G, | |

Vertex => Vertex, | |

Set => Elaborable_Vertices, | |

Msg => "add elaborable vertex", | |

Step => Step, | |

Indent => No_Indentation); | |

else | |

Insert_Vertex | |

(G => G, | |

Vertex => Vertex, | |

Set => Waiting_Vertices, | |

Msg => "add waiting vertex", | |

Step => Step, | |

Indent => No_Indentation); | |

end if; | |

end loop; | |

end Create_Vertex_Sets; | |

------------------------- | |

-- Elaborate_Component -- | |

------------------------- | |

procedure Elaborate_Component | |

(G : Library_Graph; | |

Comp : Component_Id; | |

All_Elaborable_Vertices : LGV_Sets.Membership_Set; | |

All_Waiting_Vertices : LGV_Sets.Membership_Set; | |

Order : in out Unit_Id_Table; | |

Step : Elaboration_Order_Step) | |

is | |

Comp_Elaborable_Vertices : LGV_Sets.Membership_Set; | |

Comp_Waiting_Vertices : LGV_Sets.Membership_Set; | |

Vertex : Library_Graph_Vertex_Id; | |

begin | |

pragma Assert (Present (G)); | |

pragma Assert (Present (Comp)); | |

pragma Assert (LGV_Sets.Present (All_Elaborable_Vertices)); | |

pragma Assert (LGV_Sets.Present (All_Waiting_Vertices)); | |

Trace_Component | |

(G => G, | |

Comp => Comp, | |

Msg => "elaborating component", | |

Step => Step); | |

-- Divide all vertices of the component into an elaborable and | |

-- waiting vertex set. | |

Create_Component_Vertex_Sets | |

(G => G, | |

Comp => Comp, | |

Elaborable_Vertices => Comp_Elaborable_Vertices, | |

Waiting_Vertices => Comp_Waiting_Vertices, | |

Step => Step); | |

loop | |

Trace_Vertices | |

(G => G, | |

Set => Comp_Elaborable_Vertices, | |

Set_Msg => "elaborable component vertices", | |

Vertex_Msg => "elaborable component vertex", | |

Step => Step, | |

Indent => Nested_Indentation); | |

Trace_Vertices | |

(G => G, | |

Set => Comp_Waiting_Vertices, | |

Set_Msg => "waiting component vertices", | |

Vertex_Msg => "waiting component vertex", | |

Step => Step, | |

Indent => Nested_Indentation); | |

Vertex := | |

Find_Best_Elaborable_Vertex | |

(G => G, | |

Set => Comp_Elaborable_Vertices, | |

Step => Step, | |

Indent => Nested_Indentation); | |

-- The component lacks an elaborable vertex. This indicates that | |

-- either all vertices of the component have been elaborated or | |

-- the graph has a circularity. Locate the best weak vertex that | |

-- was compiled with the dynamic model to elaborate from the set | |

-- waiting vertices. This action assumes that certain invocations | |

-- will not take place at elaboration time. An order produced in | |

-- this fashion may fail an ABE check at run time. | |

if not Present (Vertex) then | |

Vertex := | |

Find_Best_Weakly_Elaborable_Vertex | |

(G => G, | |

Set => Comp_Waiting_Vertices, | |

Step => Step, | |

Indent => Nested_Indentation); | |

end if; | |

-- Stop the elaboration when either all vertices of the component | |

-- have been elaborated, or the graph contains a circularity. | |

exit when not Present (Vertex); | |

-- Try to elaborate as many vertices within the component as | |

-- possible. Each successful elaboration signals the appropriate | |

-- successors and components that they have one less predecessor | |

-- to wait on. | |

Elaborate_Vertex | |

(G => G, | |

Vertex => Vertex, | |

All_Elaborable_Vertices => All_Elaborable_Vertices, | |

All_Waiting_Vertices => All_Waiting_Vertices, | |

Comp_Elaborable_Vertices => Comp_Elaborable_Vertices, | |

Comp_Waiting_Vertices => Comp_Waiting_Vertices, | |

Order => Order, | |

Step => Step, | |

Indent => Nested_Indentation); | |

end loop; | |

LGV_Sets.Destroy (Comp_Elaborable_Vertices); | |

LGV_Sets.Destroy (Comp_Waiting_Vertices); | |

end Elaborate_Component; | |

----------------------------- | |

-- Elaborate_Library_Graph -- | |

----------------------------- | |

procedure Elaborate_Library_Graph | |

(G : Library_Graph; | |

Order : out Unit_Id_Table; | |

Status : out Elaboration_Order_Status) | |

is | |

Elaborable_Vertices : LGV_Sets.Membership_Set; | |

Step : Elaboration_Order_Step; | |

Vertex : Library_Graph_Vertex_Id; | |

Waiting_Vertices : LGV_Sets.Membership_Set; | |

begin | |

pragma Assert (Present (G)); | |

Step := Initial_Step; | |

-- Divide all vertices of the library graph into an elaborable and | |

-- waiting vertex set. | |

Create_Vertex_Sets | |

(G => G, | |

Elaborable_Vertices => Elaborable_Vertices, | |

Waiting_Vertices => Waiting_Vertices, | |

Step => Step); | |

loop | |

Step := Step + 1; | |

Trace_Vertices | |

(G => G, | |

Set => Elaborable_Vertices, | |

Set_Msg => "elaborable vertices", | |

Vertex_Msg => "elaborable vertex", | |

Step => Step, | |

Indent => No_Indentation); | |

Trace_Vertices | |

(G => G, | |

Set => Waiting_Vertices, | |

Set_Msg => "waiting vertices", | |

Vertex_Msg => "waiting vertex", | |

Step => Step, | |

Indent => No_Indentation); | |

Vertex := | |

Find_Best_Elaborable_Vertex | |

(G => G, | |

Set => Elaborable_Vertices, | |

Step => Step, | |

Indent => No_Indentation); | |

-- The graph lacks an elaborable vertex. This indicates that | |

-- either all vertices have been elaborated or the graph has a | |

-- circularity. Find the best weak vertex that was compiled with | |

-- the dynamic model to elaborate from set of waiting vertices. | |

-- This action assumes that certain invocations will not take | |

-- place at elaboration time. An order produced in this fashion | |

-- may fail an ABE check at run time. | |

if not Present (Vertex) then | |

Vertex := | |

Find_Best_Weakly_Elaborable_Vertex | |

(G => G, | |

Set => Waiting_Vertices, | |

Step => Step, | |

Indent => No_Indentation); | |

end if; | |

-- Stop the elaboration when either all vertices of the graph have | |

-- been elaborated, or the graph contains a circularity. | |

exit when not Present (Vertex); | |

-- Elaborate the component of the vertex by trying to elaborate as | |

-- many vertices within the component as possible. Each successful | |

-- elaboration signals the appropriate successors and components | |

-- that they have one less predecessor to wait on. | |

Elaborate_Component | |

(G => G, | |

Comp => Component (G, Vertex), | |

All_Elaborable_Vertices => Elaborable_Vertices, | |

All_Waiting_Vertices => Waiting_Vertices, | |

Order => Order, | |

Step => Step); | |

end loop; | |

-- The graph contains an Elaborate_All circularity when at least one | |

-- edge subject to the related pragma appears in a component. | |

if Has_Elaborate_All_Cycle (G) then | |

Status := Order_Has_Elaborate_All_Circularity; | |

-- The graph contains a circularity when at least one vertex failed | |

-- to elaborate. | |

elsif LGV_Sets.Size (Waiting_Vertices) /= 0 then | |

Status := Order_Has_Circularity; | |

-- Otherwise the elaboration order is satisfactory | |

else | |

Status := Order_OK; | |

end if; | |

LGV_Sets.Destroy (Elaborable_Vertices); | |

LGV_Sets.Destroy (Waiting_Vertices); | |

end Elaborate_Library_Graph; | |

--------------------- | |

-- Elaborate_Units -- | |

--------------------- | |

procedure Elaborate_Units | |

(Order : out Unit_Id_Table; | |

Main_Lib_File : File_Name_Type) | |

is | |

pragma Unreferenced (Main_Lib_File); | |

Inv_Graph : Invocation_Graph; | |

Lib_Graph : Library_Graph; | |

Status : Elaboration_Order_Status; | |

begin | |

Start_Phase (Unit_Elaboration); | |

-- Initialize all unit-related data structures and gather all units | |

-- that need elaboration. | |

Initialize_Units; | |

Collect_Elaborable_Units; | |

-- Create the library graph that captures the dependencies between | |

-- library items. | |

Lib_Graph := Build_Library_Graph; | |

-- Create the invocation graph that represents the flow of execution | |

Inv_Graph := Build_Invocation_Graph (Lib_Graph); | |

-- Traverse the invocation graph starting from elaboration code in | |

-- order to discover transitions of the execution flow from a unit | |

-- to a unit that result in extra edges within the library graph. | |

Augment_Library_Graph (Inv_Graph); | |

-- Create the component graph by collapsing all library items into | |

-- library units and traversing the library graph. | |

Find_Components (Lib_Graph); | |

-- Output the contents of the ALI tables and both graphs to standard | |

-- output now that they have been fully decorated. | |

Write_ALI_Tables; | |

Write_Invocation_Graph (Inv_Graph); | |

Write_Library_Graph (Lib_Graph); | |

-- Traverse the library graph to determine the elaboration order of | |

-- units. | |

Elaborate_Library_Graph (Lib_Graph, Order, Status); | |

-- The elaboration order is satisfactory | |

if Status = Order_OK then | |

Validate_Elaboration_Order (Order); | |

-- Set attribute Elab_Position of table ALI.Units for all units in | |

-- the elaboration order. | |

Set_Unit_Elaboration_Positions (Order); | |

-- Output the dependencies among units when switch -e (output | |

-- complete list of elaboration order dependencies) is active. | |

Write_Dependencies (Lib_Graph); | |

-- Output the elaboration order when switch -l (output chosen | |

-- elaboration order) is in effect. | |

Write_Elaboration_Order (Order); | |

-- Output the sources referenced in the closure of the order when | |

-- switch -R (list sources referenced in closure) is in effect. | |

Write_Unit_Closure (Order); | |

-- Otherwise the library graph contains at least one circularity | |

else | |

Diagnose_Circularities (Inv_Graph); | |

end if; | |

Destroy (Inv_Graph); | |

Destroy (Lib_Graph); | |

-- Destroy all unit-related data structures | |

Finalize_Units; | |

End_Phase (Unit_Elaboration); | |

-- Halt the bind when there is no satisfactory elaboration order | |

if Status /= Order_OK then | |

raise Unrecoverable_Error; | |

end if; | |

end Elaborate_Units; | |

---------------------- | |

-- Elaborate_Vertex -- | |

---------------------- | |

procedure Elaborate_Vertex | |

(G : Library_Graph; | |

Vertex : Library_Graph_Vertex_Id; | |

All_Elaborable_Vertices : LGV_Sets.Membership_Set; | |

All_Waiting_Vertices : LGV_Sets.Membership_Set; | |

Comp_Elaborable_Vertices : LGV_Sets.Membership_Set; | |

Comp_Waiting_Vertices : LGV_Sets.Membership_Set; | |

Order : in out Unit_Id_Table; | |

Step : Elaboration_Order_Step; | |

Indent : Indentation_Level) | |

is | |

begin | |

pragma Assert (Present (G)); | |

pragma Assert (Present (Vertex)); | |

pragma Assert (Needs_Elaboration (G, Vertex)); | |

pragma Assert (LGV_Sets.Present (All_Elaborable_Vertices)); | |

pragma Assert (LGV_Sets.Present (All_Waiting_Vertices)); | |

pragma Assert (LGV_Sets.Present (Comp_Elaborable_Vertices)); | |

pragma Assert (LGV_Sets.Present (Comp_Waiting_Vertices)); | |

Trace_Vertex | |

(G => G, | |

Vertex => Vertex, | |

Msg => "elaborating vertex", | |

Step => Step, | |

Indent => Indent); | |

-- Remove the vertex from both elaborable sets. This is needed when | |

-- the vertex is both an overall best candidate among all vertices, | |

-- and the best candidate within the component. | |

LGV_Sets.Delete (All_Elaborable_Vertices, Vertex); | |

LGV_Sets.Delete (Comp_Elaborable_Vertices, Vertex); | |

-- Remove the vertex from both waiting sets. This is needed when a | |

-- weakly elaborable vertex is both an overall best candidate among | |

-- all waiting vertices and the best waiting candidate within the | |

-- component. | |

LGV_Sets.Delete (All_Waiting_Vertices, Vertex); | |

LGV_Sets.Delete (Comp_Waiting_Vertices, Vertex); | |

-- Mark the vertex as elaborated in order to prevent further attempts | |

-- to re-elaborate it. | |

Set_In_Elaboration_Order (G, Vertex); | |

-- Add the unit represented by the vertex to the elaboration order | |

Unit_Id_Tables.Append (Order, Unit (G, Vertex)); | |

-- Notify all successors and their components that they have one | |

-- fewer predecessor to wait on. This may cause some successors to | |

-- be included in one of the sets. | |

Update_Successors | |

(G => G, | |

Vertex => Vertex, | |

All_Elaborable_Vertices => All_Elaborable_Vertices, | |

All_Waiting_Vertices => All_Waiting_Vertices, | |

Comp_Elaborable_Vertices => Comp_Elaborable_Vertices, | |

Comp_Waiting_Vertices => Comp_Waiting_Vertices, | |

Step => Step, | |

Indent => Indent + Nested_Indentation); | |

-- Elaborate an eligible completing body immediately after its spec. | |

-- This action satisfies the semantics of pragma Elaborate_Body. In | |

-- addition, it ensures that a body will not "drift" too far from its | |

-- spec in case invocation edges are removed from the library graph. | |

if Has_Elaborable_Body (G, Vertex) then | |

Elaborate_Vertex | |

(G => G, | |

Vertex => Proper_Body (G, Vertex), | |

All_Elaborable_Vertices => All_Elaborable_Vertices, | |

All_Waiting_Vertices => All_Waiting_Vertices, | |

Comp_Elaborable_Vertices => Comp_Elaborable_Vertices, | |

Comp_Waiting_Vertices => Comp_Waiting_Vertices, | |

Order => Order, | |

Step => Step, | |

Indent => Indent); | |

end if; | |

end Elaborate_Vertex; | |

--------------------------------- | |

-- Find_Best_Elaborable_Vertex -- | |

--------------------------------- | |

function Find_Best_Elaborable_Vertex | |

(G : Library_Graph; | |

Set : LGV_Sets.Membership_Set; | |

Step : Elaboration_Order_Step; | |

Indent : Indentation_Level) return Library_Graph_Vertex_Id | |

is | |

begin | |

pragma Assert (Present (G)); | |

pragma Assert (LGV_Sets.Present (Set)); | |

return | |

Find_Best_Vertex | |

(G => G, | |

Set => Set, | |

Is_Suitable_Vertex => | |

Is_Suitable_Elaborable_Vertex'Access, | |

Compare_Vertices => | |

Is_Better_Elaborable_Vertex'Access, | |

Initial_Best_Msg => "initial best elaborable vertex", | |

Subsequent_Best_Msg => "better elaborable vertex", | |

Step => Step, | |

Indent => Indent); | |

end Find_Best_Elaborable_Vertex; | |

---------------------- | |

-- Find_Best_Vertex -- | |

---------------------- | |

function Find_Best_Vertex | |

(G : Library_Graph; | |

Set : LGV_Sets.Membership_Set; | |

Is_Suitable_Vertex : LGV_Predicate_Ptr; | |

Compare_Vertices : LGV_Comparator_Ptr; | |

Initial_Best_Msg : String; | |

Subsequent_Best_Msg : String; | |

Step : Elaboration_Order_Step; | |

Indent : Indentation_Level) | |

return Library_Graph_Vertex_Id | |

is | |

Best_Vertex : Library_Graph_Vertex_Id; | |

Current_Vertex : Library_Graph_Vertex_Id; | |

Iter : LGV_Sets.Iterator; | |

begin | |

pragma Assert (Present (G)); | |

pragma Assert (LGV_Sets.Present (Set)); | |

pragma Assert (Is_Suitable_Vertex /= null); | |

pragma Assert (Compare_Vertices /= null); | |

-- Assume that there is no candidate | |

Best_Vertex := No_Library_Graph_Vertex; | |

-- Inspect all vertices in the set, looking for the best candidate | |

-- according to the comparator. | |

Iter := LGV_Sets.Iterate (Set); | |

while LGV_Sets.Has_Next (Iter) loop | |

LGV_Sets.Next (Iter, Current_Vertex); | |

pragma Assert (Needs_Elaboration (G, Current_Vertex)); | |

if Is_Suitable_Vertex.all (G, Current_Vertex) then | |

-- A previous iteration already picked the best candidate. | |

-- Update the best candidate when the current vertex is a | |

-- better choice. | |

if Present (Best_Vertex) then | |

if Compare_Vertices.all | |

(G => G, | |

Vertex => Current_Vertex, | |

Compared_To => Best_Vertex) = Higher_Precedence | |

then | |

Best_Vertex := Current_Vertex; | |

Trace_Vertex | |

(G => G, | |

Vertex => Best_Vertex, | |

Msg => Subsequent_Best_Msg, | |

Step => Step, | |

Indent => Indent); | |

end if; | |

-- Otherwise this is the first candidate | |

else | |

Best_Vertex := Current_Vertex; | |

Trace_Vertex | |

(G => G, | |

Vertex => Best_Vertex, | |

Msg => Initial_Best_Msg, | |

Step => Step, | |

Indent => Indent); | |

end if; | |

end if; | |

end loop; | |

return Best_Vertex; | |

end Find_Best_Vertex; | |

---------------------------------------- | |

-- Find_Best_Weakly_Elaborable_Vertex -- | |

---------------------------------------- | |

function Find_Best_Weakly_Elaborable_Vertex | |

(G : Library_Graph; | |

Set : LGV_Sets.Membership_Set; | |

Step : Elaboration_Order_Step; | |

Indent : Indentation_Level) return Library_Graph_Vertex_Id | |

is | |

begin | |

pragma Assert (Present (G)); | |

pragma Assert (LGV_Sets.Present (Set)); | |

return | |

Find_Best_Vertex | |

(G => G, | |

Set => Set, | |

Is_Suitable_Vertex => | |

Is_Suitable_Weakly_Elaborable_Vertex'Access, | |

Compare_Vertices => | |

Is_Better_Weakly_Elaborable_Vertex'Access, | |

Initial_Best_Msg => "initial best weakly elaborable vertex", | |

Subsequent_Best_Msg => "better weakly elaborable vertex", | |

Step => Step, | |

Indent => Indent); | |

end Find_Best_Weakly_Elaborable_Vertex; | |

------------------------- | |

-- Has_Elaborable_Body -- | |

------------------------- | |

function Has_Elaborable_Body | |

(G : Library_Graph; | |

Vertex : Library_Graph_Vertex_Id) return Boolean | |

is | |

begin | |

pragma Assert (Present (G)); | |

pragma Assert (Present (Vertex)); | |

-- The body of an already-elaborated spec subject to Elaborate_Body | |

-- is always elaborable. | |

if Is_Spec_With_Elaborate_Body (G, Vertex) then | |

return True; | |

elsif Is_Spec_With_Body (G, Vertex) then | |

return Is_Elaborable_Vertex (G, Proper_Body (G, Vertex)); | |

end if; | |

return False; | |

end Has_Elaborable_Body; | |

--------------------------------- | |

-- Insert_Elaborable_Successor -- | |

--------------------------------- | |

procedure Insert_Elaborable_Successor | |

(G : Library_Graph; | |

Vertex : Library_Graph_Vertex_Id; | |

Elaborable_Vertices : LGV_Sets.Membership_Set; | |

All_Waiting_Vertices : LGV_Sets.Membership_Set; | |

Comp_Waiting_Vertices : LGV_Sets.Membership_Set; | |

Msg : String; | |

Step : Elaboration_Order_Step; | |

Indent : Indentation_Level) | |

is | |

pragma Assert (Present (G)); | |

pragma Assert (Present (Vertex)); | |

pragma Assert (LGV_Sets.Present (Elaborable_Vertices)); | |

pragma Assert (LGV_Sets.Present (All_Waiting_Vertices)); | |

pragma Assert (LGV_Sets.Present (Comp_Waiting_Vertices)); | |

Complement : constant Library_Graph_Vertex_Id := | |

Complementary_Vertex | |

(G => G, | |

Vertex => Vertex, | |

Force_Complement => False); | |

begin | |

-- Remove the successor from both waiting vertex sets because it may | |

-- be the best vertex to elaborate across the whole graph and within | |

-- its component. | |

LGV_Sets.Delete (All_Waiting_Vertices, Vertex); | |

LGV_Sets.Delete (Comp_Waiting_Vertices, Vertex); | |

Insert_Vertex | |

(G => G, | |

Vertex => Vertex, | |

Set => Elaborable_Vertices, | |

Msg => Msg, | |

Step => Step, | |

Indent => Indent); | |

if Present (Complement) then | |

-- Remove the complement of the successor from both waiting vertex | |

-- sets because it may be the best vertex to elaborate across the | |

-- whole graph and within its component. | |

LGV_Sets.Delete (All_Waiting_Vertices, Complement); | |

LGV_Sets.Delete (Comp_Waiting_Vertices, Complement); | |

Insert_Vertex | |

(G => G, | |

Vertex => Complement, | |

Set => Elaborable_Vertices, | |

Msg => Msg, | |

Step => Step, | |

Indent => Indent); | |

end if; | |

end Insert_Elaborable_Successor; | |

------------------- | |

-- Insert_Vertex -- | |

------------------- | |

procedure Insert_Vertex | |

(G : Library_Graph; | |

Vertex : Library_Graph_Vertex_Id; | |

Set : LGV_Sets.Membership_Set; | |

Msg : String; | |

Step : Elaboration_Order_Step; | |

Indent : Indentation_Level) | |

is | |

begin | |

pragma Assert (Present (G)); | |

pragma Assert (Present (Vertex)); | |

pragma Assert (Needs_Elaboration (G, Vertex)); | |

pragma Assert (LGV_Sets.Present (Set)); | |

-- Nothing to do when the vertex is already present in the set | |

if LGV_Sets.Contains (Set, Vertex) then | |

return; | |

end if; | |

Trace_Vertex | |

(G => G, | |

Vertex => Vertex, | |

Msg => Msg, | |

Step => Step, | |

Indent => Indent); | |

-- Add the vertex to the set | |

LGV_Sets.Insert (Set, Vertex); | |

end Insert_Vertex; | |

--------------------------------- | |

-- Is_Better_Elaborable_Vertex -- | |

--------------------------------- | |

function Is_Better_Elaborable_Vertex | |

(G : Library_Graph; | |

Vertex : Library_Graph_Vertex_Id; | |

Compared_To : Library_Graph_Vertex_Id) return Precedence_Kind | |

is | |

begin | |

pragma Assert (Present (G)); | |

pragma Assert (Present (Vertex)); | |

pragma Assert (Present (Compared_To)); | |

-- Prefer a spec with Elaborate_Body over its corresponding body | |

if Is_Elaborate_Body_Pair | |

(G => G, | |

Spec_Vertex => Vertex, | |

Body_Vertex => Compared_To) | |

then | |

return Higher_Precedence; | |

elsif Is_Elaborate_Body_Pair | |

(G => G, | |

Spec_Vertex => Compared_To, | |

Body_Vertex => Vertex) | |

then | |

return Lower_Precedence; | |

-- Prefer a predefined unit over a non-predefined unit | |

elsif Is_Predefined_Unit (G, Vertex) | |

and then not Is_Predefined_Unit (G, Compared_To) | |

then | |

return Higher_Precedence; | |

elsif not Is_Predefined_Unit (G, Vertex) | |

and then Is_Predefined_Unit (G, Compared_To) | |

then | |

return Lower_Precedence; | |

-- Prefer an internal unit over a non-internal unit | |

elsif Is_Internal_Unit (G, Vertex) | |

and then not Is_Internal_Unit (G, Compared_To) | |

then | |

return Higher_Precedence; | |

elsif not Is_Internal_Unit (G, Vertex) | |

and then Is_Internal_Unit (G, Compared_To) | |

then | |

return Lower_Precedence; | |

-- Prefer a preelaborated unit over a non-preelaborated unit | |

elsif Is_Preelaborated_Unit (G, Vertex) | |

and then not Is_Preelaborated_Unit (G, Compared_To) | |

then | |

return Higher_Precedence; | |

elsif not Is_Preelaborated_Unit (G, Vertex) | |

and then Is_Preelaborated_Unit (G, Compared_To) | |

then | |

return Lower_Precedence; | |

-- Otherwise default to lexicographical order to ensure deterministic | |

-- behavior. | |

elsif Uname_Less (Name (G, Vertex), Name (G, Compared_To)) then | |

return Higher_Precedence; | |

else | |

return Lower_Precedence; | |

end if; | |

end Is_Better_Elaborable_Vertex; | |

---------------------------------------- | |

-- Is_Better_Weakly_Elaborable_Vertex -- | |

---------------------------------------- | |

function Is_Better_Weakly_Elaborable_Vertex | |

(G : Library_Graph; | |

Vertex : Library_Graph_Vertex_Id; | |

Compared_To : Library_Graph_Vertex_Id) return Precedence_Kind | |

is | |

Comp_Strong_Preds : Natural; | |

Comp_Weak_Preds : Natural; | |

Vertex_Strong_Preds : Natural; | |

Vertex_Weak_Preds : Natural; | |

begin | |

pragma Assert (Present (G)); | |

pragma Assert (Present (Vertex)); | |

pragma Assert (Present (Compared_To)); | |

-- Obtain the number of pending predecessors for both candidates, | |

-- taking into account Elaborate_Body pairs. | |

Pending_Predecessors_For_Elaboration | |

(G => G, | |

Vertex => Vertex, | |

Strong_Preds => Vertex_Strong_Preds, | |

Weak_Preds => Vertex_Weak_Preds); | |

Pending_Predecessors_For_Elaboration | |

(G => G, | |

Vertex => Compared_To, | |

Strong_Preds => Comp_Strong_Preds, | |

Weak_Preds => Comp_Weak_Preds); | |

-- Neither candidate should be waiting on strong predecessors, | |

-- otherwise the candidate cannot be weakly elaborated. | |

pragma Assert (Vertex_Strong_Preds = 0); | |

pragma Assert (Comp_Strong_Preds = 0); | |

-- Prefer a unit with fewer weak predecessors over a unit with more | |

-- weak predecessors. | |

if Vertex_Weak_Preds < Comp_Weak_Preds then | |

return Higher_Precedence; | |

elsif Vertex_Weak_Preds > Comp_Weak_Preds then | |

return Lower_Precedence; | |

-- Otherwise default to lexicographical order to ensure deterministic | |

-- behavior. | |

elsif Uname_Less (Name (G, Vertex), Name (G, Compared_To)) then | |

return Higher_Precedence; | |

else | |

return Lower_Precedence; | |

end if; | |

end Is_Better_Weakly_Elaborable_Vertex; | |

----------------------------------- | |

-- Is_Suitable_Elaborable_Vertex -- | |

----------------------------------- | |

function Is_Suitable_Elaborable_Vertex | |

(G : Library_Graph; | |

Vertex : Library_Graph_Vertex_Id) return Boolean | |

is | |

begin | |

pragma Assert (Present (G)); | |

pragma Assert (Present (Vertex)); | |

-- A vertex is suitable for elaboration as long it is not waiting on | |

-- any predecessors, ignoring the static or dynamic model. | |

return Is_Elaborable_Vertex (G, Vertex); | |

end Is_Suitable_Elaborable_Vertex; | |

------------------------------------------ | |

-- Is_Suitable_Weakly_Elaborable_Vertex -- | |

------------------------------------------ | |

function Is_Suitable_Weakly_Elaborable_Vertex | |

(G : Library_Graph; | |

Vertex : Library_Graph_Vertex_Id) return Boolean | |

is | |

begin | |

pragma Assert (Present (G)); | |

pragma Assert (Present (Vertex)); | |

-- A vertex is suitable for weak elaboration when it is waiting on | |

-- weak predecessors only, and the unit it represents was compiled | |

-- using the dynamic model. | |

return | |

Is_Dynamically_Elaborated (G, Vertex) | |

and then Is_Weakly_Elaborable_Vertex (G, Vertex); | |

end Is_Suitable_Weakly_Elaborable_Vertex; | |

------------------------------------ | |

-- Set_Unit_Elaboration_Positions -- | |

------------------------------------ | |

procedure Set_Unit_Elaboration_Positions (Order : Unit_Id_Table) is | |

U_Id : Unit_Id; | |

begin | |

for Position in Unit_Id_Tables.First .. | |

Unit_Id_Tables.Last (Order) | |

loop | |

U_Id := Order.Table (Position); | |

ALI.Units.Table (U_Id).Elab_Position := Position; | |

end loop; | |

end Set_Unit_Elaboration_Positions; | |

--------------------- | |

-- Trace_Component -- | |

--------------------- | |

procedure Trace_Component | |

(G : Library_Graph; | |

Comp : Component_Id; | |

Msg : String; | |

Step : Elaboration_Order_Step) | |

is | |

begin | |

pragma Assert (Present (G)); | |

pragma Assert (Present (Comp)); | |

-- Nothing to do when switch -d_T (output elaboration order and cycle | |

-- detection trace information) is not in effect. | |

if not Debug_Flag_Underscore_TT then | |

return; | |

end if; | |

Trace_Step (Step); | |

Write_Str (Msg); | |

Write_Str (" (Comp_Id_"); | |

Write_Int (Int (Comp)); | |

Write_Str (")"); | |

Write_Eol; | |

Trace_Step (Step); | |

Indent_By (Nested_Indentation); | |

Write_Str ("pending strong predecessors: "); | |

Write_Num (Int (Pending_Strong_Predecessors (G, Comp))); | |

Write_Eol; | |

Trace_Step (Step); | |

Indent_By (Nested_Indentation); | |

Write_Str ("pending weak predecessors : "); | |

Write_Num (Int (Pending_Weak_Predecessors (G, Comp))); | |

Write_Eol; | |

end Trace_Component; | |

---------------- | |

-- Trace_Step -- | |

---------------- | |

procedure Trace_Step (Step : Elaboration_Order_Step) is | |

begin | |

-- Nothing to do when switch -d_T (output elaboration order and cycle | |

-- detection trace information) is not in effect. | |

if not Debug_Flag_Underscore_TT then | |

return; | |

end if; | |

Write_Num | |

(Val => Int (Step), | |

Val_Indent => Step_Column); | |

Write_Str (": "); | |

end Trace_Step; | |

------------------ | |

-- Trace_Vertex -- | |

------------------ | |

procedure Trace_Vertex | |

(G : Library_Graph; | |

Vertex : Library_Graph_Vertex_Id; | |

Msg : String; | |

Step : Elaboration_Order_Step; | |

Indent : Indentation_Level) | |

is | |

pragma Assert (Present (G)); | |

pragma Assert (Present (Vertex)); | |

Attr_Indent : constant Indentation_Level := | |

Indent + Nested_Indentation; | |

Comp : constant Component_Id := Component (G, Vertex); | |

begin | |

-- Nothing to do when switch -d_T (output elaboration order and cycle | |

-- detection trace information) is not in effect. | |

if not Debug_Flag_Underscore_TT then | |

return; | |

end if; | |

Trace_Step (Step); | |

Indent_By (Indent); | |

Write_Str (Msg); | |

Write_Str (" (LGV_Id_"); | |

Write_Int (Int (Vertex)); | |

Write_Str (")"); | |

Write_Eol; | |

Trace_Step (Step); | |

Indent_By (Attr_Indent); | |

Write_Str ("name = "); | |

Write_Name (Name (G, Vertex)); | |

Write_Eol; | |

Trace_Step (Step); | |

Indent_By (Attr_Indent); | |

Write_Str ("Component (Comp_Id_"); | |

Write_Int (Int (Comp)); | |

Write_Str (")"); | |

Write_Eol; | |

Trace_Step (Step); | |

Indent_By (Attr_Indent); | |

Write_Str ("pending strong predecessors: "); | |

Write_Num (Int (Pending_Strong_Predecessors (G, Vertex))); | |

Write_Eol; | |

Trace_Step (Step); | |

Indent_By (Attr_Indent); | |

Write_Str ("pending weak predecessors : "); | |

Write_Num (Int (Pending_Weak_Predecessors (G, Vertex))); | |

Write_Eol; | |

Trace_Step (Step); | |

Indent_By (Attr_Indent); | |

Write_Str ("pending strong components : "); | |

Write_Num (Int (Pending_Strong_Predecessors (G, Comp))); | |

Write_Eol; | |

Trace_Step (Step); | |

Indent_By (Attr_Indent); | |

Write_Str ("pending weak components : "); | |

Write_Num (Int (Pending_Weak_Predecessors (G, Comp))); | |

Write_Eol; | |

end Trace_Vertex; | |

-------------------- | |

-- Trace_Vertices -- | |

-------------------- | |

procedure Trace_Vertices | |

(G : Library_Graph; | |

Set : LGV_Sets.Membership_Set; | |

Set_Msg : String; | |

Vertex_Msg : String; | |

Step : Elaboration_Order_Step; | |

Indent : Indentation_Level) | |

is | |

Vertex_Indent : constant Indentation_Level := | |

Indent + Nested_Indentation; | |

Iter : LGV_Sets.Iterator; | |

Vertex : Library_Graph_Vertex_Id; | |

begin | |

pragma Assert (Present (G)); | |

pragma Assert (LGV_Sets.Present (Set)); | |

-- Nothing to do when switch -d_T (output elaboration order and cycle | |

-- detection trace information) is not in effect. | |

if not Debug_Flag_Underscore_TT then | |

return; | |

end if; | |

Trace_Step (Step); | |

Indent_By (Indent); | |

Write_Str (Set_Msg); | |

Write_Str (": "); | |

Write_Int (Int (LGV_Sets.Size (Set))); | |

Write_Eol; | |

Iter := LGV_Sets.Iterate (Set); | |

while LGV_Sets.Has_Next (Iter) loop | |

LGV_Sets.Next (Iter, Vertex); | |

Trace_Vertex | |

(G => G, | |

Vertex => Vertex, | |

Msg => Vertex_Msg, | |

Step => Step, | |

Indent => Vertex_Indent); | |

end loop; | |

end Trace_Vertices; | |

---------------------- | |

-- Update_Successor -- | |

---------------------- | |

procedure Update_Successor | |

(G : Library_Graph; | |

Edge : Library_Graph_Edge_Id; | |

All_Elaborable_Vertices : LGV_Sets.Membership_Set; | |

All_Waiting_Vertices : LGV_Sets.Membership_Set; | |

Comp_Elaborable_Vertices : LGV_Sets.Membership_Set; | |

Comp_Waiting_Vertices : LGV_Sets.Membership_Set; | |

Step : Elaboration_Order_Step; | |

Indent : Indentation_Level) | |

is | |

pragma Assert (Present (G)); | |

pragma Assert (Present (Edge)); | |

pragma Assert (LGV_Sets.Present (All_Elaborable_Vertices)); | |

pragma Assert (LGV_Sets.Present (All_Waiting_Vertices)); | |

pragma Assert (LGV_Sets.Present (Comp_Elaborable_Vertices)); | |

pragma Assert (LGV_Sets.Present (Comp_Waiting_Vertices)); | |

Pred : constant Library_Graph_Vertex_Id := Predecessor (G, Edge); | |

Succ : constant Library_Graph_Vertex_Id := Successor (G, Edge); | |

pragma Assert (Needs_Elaboration (G, Pred)); | |

pragma Assert (Needs_Elaboration (G, Succ)); | |

In_Different_Components : constant Boolean := | |

not In_Same_Component | |

(G => G, | |

Left => Pred, | |

Right => Succ); | |

Succ_Comp : constant Component_Id := Component (G, Succ); | |

Vertex_Indent : constant Indentation_Level := | |

Indent + Nested_Indentation; | |

Iter : Component_Vertex_Iterator; | |

Vertex : Library_Graph_Vertex_Id; | |

begin | |

Trace_Vertex | |

(G => G, | |

Vertex => Succ, | |

Msg => "updating successor", | |

Step => Step, | |

Indent => Indent); | |

-- Notify the successor that it has one less predecessor to wait on. | |

-- This effectively eliminates the edge that links the two. | |

Decrement_Pending_Predecessors | |

(G => G, | |

Vertex => Succ, | |

Edge => Edge); | |

-- The predecessor and successor reside in different components. | |

-- Notify the successor component it has one fewer components to | |

-- wait on. | |

if In_Different_Components then | |

Decrement_Pending_Predecessors | |

(G => G, | |

Comp => Succ_Comp, | |

Edge => Edge); | |

end if; | |

-- At this point the successor may become elaborable when its final | |

-- predecessor or final predecessor component has been elaborated. | |

if Is_Elaborable_Vertex (G, Succ) then | |

-- The predecessor and successor reside in different components. | |

-- The successor must not be added to the candidates of Pred's | |

-- component because this will mix units from the two components. | |

-- Instead, the successor is added to the set of all elaborable | |

-- vertices. | |

if In_Different_Components then | |

Insert_Elaborable_Successor | |

(G => G, | |

Vertex => Succ, | |

Elaborable_Vertices => All_Elaborable_Vertices, | |

All_Waiting_Vertices => All_Waiting_Vertices, | |

Comp_Waiting_Vertices => Comp_Waiting_Vertices, | |

Msg => "add elaborable successor", | |

Step => Step, | |

Indent => Vertex_Indent); | |

-- Otherwise the predecessor and successor reside within the same | |

-- component. Pred's component gains another elaborable vertex. | |

else | |

Insert_Elaborable_Successor | |

(G => G, | |

Vertex => Succ, | |

Elaborable_Vertices => Comp_Elaborable_Vertices, | |

All_Waiting_Vertices => All_Waiting_Vertices, | |

Comp_Waiting_Vertices => Comp_Waiting_Vertices, | |

Msg => | |

"add elaborable component successor", | |

Step => Step, | |

Indent => Vertex_Indent); | |

end if; | |

end if; | |

-- At this point the successor component may become elaborable when | |

-- its final predecessor component is elaborated. This in turn may | |

-- allow vertices of the successor component to be elaborated. | |

if In_Different_Components | |

and then Is_Elaborable_Component (G, Succ_Comp) | |

then | |

Iter := Iterate_Component_Vertices (G, Succ_Comp); | |

while Has_Next (Iter) loop | |

Next (Iter, Vertex); | |

if Is_Elaborable_Vertex (G, Vertex) then | |

Insert_Elaborable_Successor | |

(G => G, | |

Vertex => Vertex, | |

Elaborable_Vertices => All_Elaborable_Vertices, | |

All_Waiting_Vertices => All_Waiting_Vertices, | |

Comp_Waiting_Vertices => Comp_Waiting_Vertices, | |

Msg => "add elaborable vertex", | |

Step => Step, | |

Indent => Vertex_Indent); | |

end if; | |

end loop; | |

end if; | |

end Update_Successor; | |

----------------------- | |

-- Update_Successors -- | |

----------------------- | |

procedure Update_Successors | |

(G : Library_Graph; | |

Vertex : Library_Graph_Vertex_Id; | |

All_Elaborable_Vertices : LGV_Sets.Membership_Set; | |

All_Waiting_Vertices : LGV_Sets.Membership_Set; | |

Comp_Elaborable_Vertices : LGV_Sets.Membership_Set; | |

Comp_Waiting_Vertices : LGV_Sets.Membership_Set; | |

Step : Elaboration_Order_Step; | |

Indent : Indentation_Level) | |

is | |

Edge : Library_Graph_Edge_Id; | |

Iter : Edges_To_Successors_Iterator; | |

begin | |

pragma Assert (Present (G)); | |

pragma Assert (Present (Vertex)); | |

pragma Assert (Needs_Elaboration (G, Vertex)); | |

pragma Assert (LGV_Sets.Present (All_Elaborable_Vertices)); | |

pragma Assert (LGV_Sets.Present (All_Waiting_Vertices)); | |

pragma Assert (LGV_Sets.Present (Comp_Elaborable_Vertices)); | |

pragma Assert (LGV_Sets.Present (Comp_Waiting_Vertices)); | |

Iter := Iterate_Edges_To_Successors (G, Vertex); | |

while Has_Next (Iter) loop | |

Next (Iter, Edge); | |

pragma Assert (Predecessor (G, Edge) = Vertex); | |

Update_Successor | |

(G => G, | |

Edge => Edge, | |

All_Elaborable_Vertices => All_Elaborable_Vertices, | |

All_Waiting_Vertices => All_Waiting_Vertices, | |

Comp_Elaborable_Vertices => Comp_Elaborable_Vertices, | |

Comp_Waiting_Vertices => Comp_Waiting_Vertices, | |

Step => Step, | |

Indent => Indent); | |

end loop; | |

end Update_Successors; | |

end Invocation_And_Library_Graph_Elaborators; | |

end Bindo.Elaborators; |