Subversion Repositories openrisc

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

--                                                                          --

--                         GNAT COMPILER COMPONENTS                         --

--                                                                          --

--                                B I N D E                                 --

--                                                                          --

--                                 B o d y                                  --

--                                                                          --

--          Copyright (C) 1992-2010, 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 Namet;    use Namet;

with Opt;      use Opt;

with Osint;

with Output;   use Output;

with Targparm; use Targparm;

with System.Case_Util; use System.Case_Util;

package body Binde is

   --  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 A is a

   --  successor of B in this table, it means that A must be elaborated

   --  before B is elaborated.

   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.

      Elab,

      --  After directly mentions Before in a pragma Elaborate, so the

      --  body of Before must be elaborate 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 elment in a list of Elab_All entries that record the with

      --  chain leading 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 then 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");

   --  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. 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

      Elab_Order : Nat;

      --  Position in elaboration order (zero = not placed yet)

      Visited : Boolean;

      --  Used in computing transitive closure for elaborate all and

      --  also in locating cycles and paths in the diagnose routines.

      Elab_Position : Natural;

      --  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.

   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 : Natural := 0;

   --  Number of units chosen in the elaboration order so far

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

   -- Local Subprograms --

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

   function Better_Choice (U1, 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.

   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 (Chosen : Unit_Id);

   --  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 which 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 which does not have a separate body.

   function Corresponding_Spec (U : Unit_Id) return Unit_Id;

   pragma Inline (Corresponding_Spec);

   --  Given a unit which 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 which does not have a separate spec.

   procedure 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 is required, 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 Gather_Dependencies;

   --  Compute dependencies, building the Succ and UNR tables

   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 which has

   --  not been elaborated, but whose spec has been elaborated.

   function Make_Elab_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 Pessimistic_Better_Choice (U1, U2 : Unit_Id) return Boolean;

   --  This is like Better_Choice, 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.

   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_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.

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

   -- Better_Choice --

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

   function Better_Choice (U1, 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 (");

         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 preelaborable 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 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, there 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_O then

         --  The following deal with the case of specs which 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 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;

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

   -- 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.Increment_Last;

      Succ.Table (Succ.Last).Before          := Before;

      Succ.Table (Succ.Last).Next            := UNR.Table (Before).Successors;

      UNR.Table (Before).Successors          := Succ.Last;

      Succ.Table (Succ.Last).Reason          := R;

      Succ.Table (Succ.Last).Reason_Unit     := Cur_Unit;

      Succ.Table (Succ.Last).Elab_All_Link   := Ea_Id;

      --  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 (Chosen : Unit_Id) is

      S : Successor_Id;

      U : Unit_Id;

   begin

      if Debug_Flag_C then

         Write_Str ("Choosing Unit ");

         Write_Unit_Name (Units.Table (Chosen).Uname);

         Write_Eol;

      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.

      Elab_Order.Increment_Last;

      Elab_Order.Table (Elab_Order.Last) := 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

         --  Note that we just ignore the situation where it does not

         --  appear in the No_Pred list, this happens in calls from the

         --  Diagnose_Elaboration_Problem routine, where cycles are being

         --  removed arbitrarily from the graph.

         U := No_Pred;

         while U /= No_Unit_Id loop

            if UNR.Table (U).Nextnp = Chosen then

               UNR.Table (U).Nextnp := UNR.Table (Chosen).Nextnp;

               exit;

            end if;

            U := UNR.Table (U).Nextnp;

         end loop;

      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;

      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;

         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;

      UNR.Table (Chosen).Elab_Position := Num_Chosen;

      Units.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;

         else

            Choose (Corresponding_Body (Chosen));

         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;

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

   -- Diagnose_Elaboration_Problem --

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

   procedure Diagnose_Elaboration_Problem is

      function Find_Path (Ufrom, 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, 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 (U);

               return True;

            --  All done if already visited, otherwise mark as 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 (U);

                     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 visisted 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_Error

   begin

      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_Str ("Diagnose_Elaboration_Problem called");