[Ada] Stabilization of Elaboration order v4.0

This patch introduces several changes to the new elaboration order
mechanism:

   * Instantiations processed in the context of invocation graph
     encoding now yield a relation which is later transformed into an
     invocation edge. This ensures that the unit where the instantiation
     resides properly depends on the unit where the body of the generic
     is.

   * The diagnostics of cycles that involve invocation edges now use a
     set to avoid infinite recursion when visiting paths that represent
     recursive code.

   * Various diagnostics that suggest the use of switches have been
     updated to indicate which tool the switches apply to.

   * Bindo can now output the dependencies of various units that specify
     why a predecessor unit must be elaborated prior to a successor
     unit. This functionality implements binder switch -e (output
     complete list of elaboration order dependencies).

   * The output of the elaboration order is now identical to that
     emitted by Binde.

   * The nature of the invocation graph encoding is now recorded in the
     ALI record rather than the Unit record of a unit. This ensures that
     both the spec and body share the same encoding kind.

   * A section on debugging elaboration order issues is now available in
     Bindo.

2019-07-05  Hristian Kirtchev  <kirtchev@adacore.com>

gcc/ada/

	* ali.adb (For_Each_Invocation_Construct,
	For_Each_Invocation_Relation): New version.
	(Scan_ALI): Initialize field Invocation_Graph_Encoding.
	(Set_Invocation_Graph_Encoding): Update the setting of the
	invocation graph encoding.
	* ali.ads: Move field Invocation_Graph_Encoding from Unit_Record
	to ALI_Record because the encoding applies to the whole ALI,
	rather than one of the units (spec or body) for which the ALI
	file was created.
	(For_Each_Invocation_Construct, For_Each_Invocation_Relation):
	New version.
	* bindo.adb: Update the section on switches.  Complete the
	section of debugging elaboration order issues.
	(Find_Elaboration_Order): Prepare the routine for the switch
	from the old to the new elaboration order mechanism.
	* bindo-diagnostics.adb (Find_And_Output_Invocation_Paths):
	Manage a visited set used by Visit_Vertex.
	(Output_All_Cycles_Suggestions,
	Output_Dynamic_Model_Suggestions): Clarify the nature of the
	suggested switch.
	(Output_Elaborate_Body_Transition): Update the diagnostic to
	emit a better message.
	(Output_Forced_Suggestions, Output_Full_Encoding_Suggestions):
	Clarify the nature of the suggested switch.
	(Visit_Vertex): Update the parameter profile to add a set of
	invokers visited during the transition. This set prevents
	infinite exploration of the graph in case the invocations are
	recursive.
	* bindo-elaborators.adb: Add a use clause for
	Bindo.Writers.Dependency_Writers.
	(Elaborate_Units_Common): Output the library graph after it has
	been augmented with invocation edges. Output just the components
	instead of outputting the whole library graph again.
	(Elaborate_Units_Dynamic, Elaborate_Units_Static): Output the
	dependencies as expressed in the library graph.
	* bindo-units.adb (Invocation_Graph_Encoding): Update the
	extraction of the invocation graph encoding.
	* bindo-writers.adb: Add with and use clauses for Binderr and
	Butil.
	(palgc, plgc): New debug routine.
	(Write_Components): Moved to the spec. Add a header for the
	output.
	(Write_Dependencies, Write_Dependencies_Of_Vertex,
	Write_Dependency_Edge): New routine.
	(Write_Elaboration_Order): Update the logic to follow the format
	of Binde's order output.
	(Write_Library_Graph): Do not output the components every time
	the graph is written.
	(Write_Unit): Output the invocation graph encoding of the unit.
	Output the invocation constructs and relations for the unit
	only.
	* bindo-writers.ads (Write_Components): Moved from the body.
	(Write_Dependencies): New routine.
	* bindusg.adb: Prepare the routine for the switch from the old
	to the new elaboration order mechanism.
	* debug.adb: Binder switch -d_O is now not associated with any
	functionality.
	* einfo.adb (Is_Elaboration_Target): The attribute applies to
	packages, as specified by the comment on the attribute usage.
	* opt.ads: Add a global flag which controls the choice between
	the new and the legacy elaboration order mechanism.
	* sem_elab.adb: Add Package_Target to type Target_Kind.
	(Build_Elaborate_Body_Procedure, Build_Elaborate_Procedure,
	Build_Elaborate_Spec_Procedure, Check_Elaboration_Scenarios,
	Check_SPARK_Model_In_Effect): Use Main_Unit_Entity to obtain the
	entity of the main unit.
	(Create_Package_Rep): New routine.
	(Create_Target_Rep): Add processing for packages.
	(Declaration_Placement_Of_Node, Has_Prior_Elaboration): Use
	Main_Unit_Entity to obtain the entity of the main
	 unit.
	(Invocation_Graph_Recording_OK): Prepare the routine for the
	switch from the old to the new elaboration order mechanism.
	(Main_Unit_Entity): New routine.
	(Meet_Elaboration_Requirement,
	Process_Conditional_ABE_Variable_Reference): Use
	Main_Unit_Entity to obtain the entity of the main unit.
	(Process_Invocation_Instantiation): New routine.
	(Process_Invocation_Scenario): Add processing for
	instantiations.
	* switch-b.adb (Scan_Binder_Switches): Prepare the routine for
	the switch from the old to the new elaboration order mechanism.

From-SVN: r273128

1 files changed, 45 insertions, 1 deletions

diff --git a/gcc/ada/ali.adb b/gcc/ada/ali.adb
index aa8b242..feea73f 100644
--- a/gcc/ada/ali.adb
+++ b/gcc/ada/ali.adb
@@ -510,6 +510,27 @@ package body ALI is
       end loop;
    end For_Each_Invocation_Construct;
 
+   -----------------------------------
+   -- For_Each_Invocation_Construct --
+   -----------------------------------
+
+   procedure For_Each_Invocation_Construct
+     (U_Id      : Unit_Id;
+      Processor : Invocation_Construct_Processor_Ptr)
+   is
+      pragma Assert (Present (U_Id));
+      pragma Assert (Processor /= null);
+
+      U_Rec : Unit_Record renames Units.Table (U_Id);
+
+   begin
+      for IC_Id in U_Rec.First_Invocation_Construct ..
+                   U_Rec.Last_Invocation_Construct
+      loop
+         Processor.all (IC_Id);
+      end loop;
+   end For_Each_Invocation_Construct;
+
    ----------------------------------
    -- For_Each_Invocation_Relation --
    ----------------------------------
@@ -527,6 +548,27 @@ package body ALI is
       end loop;
    end For_Each_Invocation_Relation;
 
+   ----------------------------------
+   -- For_Each_Invocation_Relation --
+   ----------------------------------
+
+   procedure For_Each_Invocation_Relation
+     (U_Id      : Unit_Id;
+      Processor : Invocation_Relation_Processor_Ptr)
+   is
+      pragma Assert (Present (U_Id));
+      pragma Assert (Processor /= null);
+
+      U_Rec : Unit_Record renames Units.Table (U_Id);
+
+   begin
+      for IR_Id in U_Rec.First_Invocation_Relation ..
+                   U_Rec.Last_Invocation_Relation
+      loop
+         Processor.all (IR_Id);
+      end loop;
+   end For_Each_Invocation_Relation;
+
    ----------
    -- Hash --
    ----------
@@ -1831,6 +1873,7 @@ package body ALI is
         First_Specific_Dispatching   => Specific_Dispatching.Last + 1,
         First_Unit                   => No_Unit_Id,
         GNATprove_Mode               => False,
+        Invocation_Graph_Encoding    => No_Encoding,
         Last_Interrupt_State         => Interrupt_States.Last,
         Last_Sdep                    => No_Sdep_Id,
         Last_Specific_Dispatching    => Specific_Dispatching.Last,
@@ -3807,9 +3850,10 @@ package body ALI is
       if Update_Units then
          declare
             Curr_Unit : Unit_Record renames Units.Table (Units.Last);
+            Curr_ALI  : ALIs_Record renames ALIs.Table  (Curr_Unit.My_ALI);
 
          begin
-            Curr_Unit.Invocation_Graph_Encoding := Kind;
+            Curr_ALI.Invocation_Graph_Encoding := Kind;
          end;
       end if;
    end Set_Invocation_Graph_Encoding;