Subversion Repositories openrisc_me

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

--                                                                          --

--                         GNAT COMPILER COMPONENTS                         --

--                                                                          --

--                             G N A T L I N K                              --

--                                                                          --

--                                 B o d y                                  --

--                                                                          --

--          Copyright (C) 1996-2009, 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.      --

--                                                                          --

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

--  Gnatlink usage: please consult the gnat documentation

with ALI;      use ALI;

with Csets;

with Gnatvsn;  use Gnatvsn;

with Hostparm;

with Indepsw;  use Indepsw;

with Namet;    use Namet;

with Opt;

with Osint;    use Osint;

with Output;   use Output;

with Snames;

with Switch;   use Switch;

with System;   use System;

with Table;

with Targparm; use Targparm;

with Types;

with Ada.Command_Line;     use Ada.Command_Line;

with Ada.Exceptions;       use Ada.Exceptions;

with System.OS_Lib;        use System.OS_Lib;

with System.CRTL;

with Interfaces.C_Streams; use Interfaces.C_Streams;

with Interfaces.C.Strings; use Interfaces.C.Strings;

procedure Gnatlink is

   pragma Ident (Gnatvsn.Gnat_Static_Version_String);

   Shared_Libgcc_String : constant String := "-shared-libgcc";

   Shared_Libgcc        : constant String_Access :=

                            new String'(Shared_Libgcc_String);

   --  Used to invoke gcc when the binder is invoked with -shared

   Static_Libgcc_String : constant String := "-static-libgcc";

   Static_Libgcc        : constant String_Access :=

                            new String'(Static_Libgcc_String);

   --  Used to invoke gcc when shared libs are not used

   package Gcc_Linker_Options is new Table.Table (

     Table_Component_Type => String_Access,

     Table_Index_Type     => Integer,

     Table_Low_Bound      => 1,

     Table_Initial        => 20,

     Table_Increment      => 100,

     Table_Name           => "Gnatlink.Gcc_Linker_Options");

   --  Comments needed ???

   package Libpath is new Table.Table (

     Table_Component_Type => Character,

     Table_Index_Type     => Integer,

     Table_Low_Bound      => 1,

     Table_Initial        => 4096,

     Table_Increment      => 100,

     Table_Name           => "Gnatlink.Libpath");

   --  Comments needed ???

   package Linker_Options is new Table.Table (

     Table_Component_Type => String_Access,

     Table_Index_Type     => Integer,

     Table_Low_Bound      => 1,

     Table_Initial        => 20,

     Table_Increment      => 100,

     Table_Name           => "Gnatlink.Linker_Options");

   --  Comments needed ???

   package Linker_Objects is new Table.Table (

     Table_Component_Type => String_Access,

     Table_Index_Type     => Integer,

     Table_Low_Bound      => 1,

     Table_Initial        => 20,

     Table_Increment      => 100,

     Table_Name           => "Gnatlink.Linker_Objects");

   --  This table collects the objects file to be passed to the linker. In the

   --  case where the linker command line is too long then programs objects

   --  are put on the Response_File_Objects table. Note that the binder object

   --  file and the user's objects remain in this table. This is very

   --  important because on the GNU linker command line the -L switch is not

   --  used to look for objects files but -L switch is used to look for

   --  objects listed in the response file. This is not a problem with the

   --  applications objects as they are specified with a full name.

   package Response_File_Objects is new Table.Table (

     Table_Component_Type => String_Access,

     Table_Index_Type     => Integer,

     Table_Low_Bound      => 1,

     Table_Initial        => 20,

     Table_Increment      => 100,

     Table_Name           => "Gnatlink.Response_File_Objects");

   --  This table collects the objects file that are to be put in the response

   --  file. Only application objects are collected there (see details in

   --  Linker_Objects table comments)

   package Binder_Options_From_ALI is new Table.Table (

     Table_Component_Type => String_Access,

     Table_Index_Type     => Integer,

     Table_Low_Bound      => 1, -- equals low bound of Argument_List for Spawn

     Table_Initial        => 20,

     Table_Increment      => 100,

     Table_Name           => "Gnatlink.Binder_Options_From_ALI");

   --  This table collects the switches from the ALI file of the main

   --  subprogram.

   package Binder_Options is new Table.Table (

     Table_Component_Type => String_Access,

     Table_Index_Type     => Integer,

     Table_Low_Bound      => 1, -- equals low bound of Argument_List for Spawn

     Table_Initial        => 20,

     Table_Increment      => 100,

     Table_Name           => "Gnatlink.Binder_Options");

   --  This table collects the arguments to be passed to compile the binder

   --  generated file.

   Gcc : String_Access := Program_Name ("gcc", "gnatlink");

   Read_Mode : constant String := "r" & ASCII.NUL;

   Begin_Info : String := "--  BEGIN Object file/option list";

   End_Info   : String := "--  END Object file/option list   ";

   --  Note: above lines are modified in C mode, see option processing

   Gcc_Path             : String_Access;

   Linker_Path          : String_Access;

   Output_File_Name     : String_Access;

   Ali_File_Name        : String_Access;

   Binder_Spec_Src_File : String_Access;

   Binder_Body_Src_File : String_Access;

   Binder_Ali_File      : String_Access;

   Binder_Obj_File      : String_Access;

   Tname    : Temp_File_Name;

   Tname_FD : File_Descriptor := Invalid_FD;

   --  Temporary file used by linker to pass list of object files on

   --  certain systems with limitations on size of arguments.

   Lname : String_Access := null;

   --  File used by linker for CLI target, used to concatenate all .il files

   --  when the command line passed to ilasm is too long

   Debug_Flag_Present : Boolean := False;

   Verbose_Mode       : Boolean := False;

   Very_Verbose_Mode  : Boolean := False;

   Ada_Bind_File : Boolean := True;

   --  Set to True if bind file is generated in Ada

   Standard_Gcc : Boolean := True;

   Compile_Bind_File : Boolean := True;

   --  Set to False if bind file is not to be compiled

   Create_Map_File : Boolean := False;

   --  Set to True by switch -M. The map file name is derived from

   --  the ALI file name (mainprog.ali => mainprog.map).

   Object_List_File_Supported : Boolean;

   for Object_List_File_Supported'Size use Character'Size;

   pragma Import

     (C, Object_List_File_Supported, "__gnat_objlist_file_supported");

   --  Predicate indicating whether the linker has an option whereby the

   --  names of object files can be passed to the linker in a file.

   Object_List_File_Required : Boolean := False;

   --  Set to True to force generation of a response file

   Shared_Libgcc_Default : Character;

   for Shared_Libgcc_Default'Size use Character'Size;

   pragma Import

     (C, Shared_Libgcc_Default, "__gnat_shared_libgcc_default");

   --  Indicates wether libgcc should be statically linked (use 'T') or

   --  dynamically linked (use 'H') by default.

   function Base_Name (File_Name : String) return String;

   --  Return just the file name part without the extension (if present)

   procedure Delete (Name : String);

   --  Wrapper to unlink as status is ignored by this application

   procedure Error_Msg (Message : String);

   --  Output the error or warning Message

   procedure Exit_With_Error (Error : String);

   --  Output Error and exit program with a fatal condition

   procedure Process_Args;

   --  Go through all the arguments and build option tables

   procedure Process_Binder_File (Name : String);

   --  Reads the binder file and extracts linker arguments

   procedure Usage;

   --  Display usage

   procedure Write_Header;

   --  Show user the program name, version and copyright

   procedure Write_Usage;

   --  Show user the program options

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

   -- Base_Name --

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

   function Base_Name (File_Name : String) return String is

      Findex1 : Natural;

      Findex2 : Natural;

   begin

      Findex1 := File_Name'First;

      --  The file might be specified by a full path name. However,

      --  we want the path to be stripped away.

      for J in reverse File_Name'Range loop

         if Is_Directory_Separator (File_Name (J)) then

            Findex1 := J + 1;

            exit;

         end if;

      end loop;

      Findex2 := File_Name'Last;

      while Findex2 > Findex1

        and then File_Name (Findex2) /=  '.'

      loop

         Findex2 := Findex2 - 1;

      end loop;

      if Findex2 = Findex1 then

         Findex2 := File_Name'Last + 1;

      end if;

      return File_Name (Findex1 .. Findex2 - 1);

   end Base_Name;

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

   -- Delete --

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

   procedure Delete (Name : String) is

      Status : int;

      pragma Unreferenced (Status);

   begin

      Status := unlink (Name'Address);

      --  Is it really right to ignore an error here ???

   end Delete;

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

   -- Error_Msg --

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

   procedure Error_Msg (Message : String) is

   begin

      Write_Str (Base_Name (Command_Name));

      Write_Str (": ");

      Write_Str (Message);

      Write_Eol;

   end Error_Msg;

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

   -- Exit_With_Error --

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

   procedure Exit_With_Error (Error : String) is

   begin

      Error_Msg (Error);

      Exit_Program (E_Fatal);

   end Exit_With_Error;

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

   -- Process_Args --

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

   procedure Process_Args is

      Next_Arg  : Integer;

      Skip_Next : Boolean := False;

      --  Set to true if the next argument is to be added into the list of

      --  linker's argument without parsing it.

      procedure Check_Version_And_Help is new Check_Version_And_Help_G (Usage);

      --  Start of processing for Process_Args

   begin

      --  First, check for --version and --help

      Check_Version_And_Help ("GNATLINK", "1995");

      --  Loop through arguments of gnatlink command

      Next_Arg := 1;

      loop

         exit when Next_Arg > Argument_Count;

         Process_One_Arg : declare

            Arg : constant String := Argument (Next_Arg);

         begin

            --  Case of argument which is a switch

            --  We definitely need section by section comments here ???

            if Skip_Next then

               --  This argument must not be parsed, just add it to the

               --  list of linker's options.

               Skip_Next := False;

               Linker_Options.Increment_Last;

               Linker_Options.Table (Linker_Options.Last) :=

                 new String'(Arg);

            elsif Arg'Length /= 0 and then Arg (1) = '-' then

               if Arg'Length > 4 and then Arg (2 .. 5) =  "gnat" then

                  Exit_With_Error

                    ("invalid switch: """ & Arg & """ (gnat not needed here)");

               end if;

               if Arg = "-Xlinker" then

                  --  Next argument should be sent directly to the linker.

                  --  We do not want to parse it here.

                  Skip_Next := True;

                  Linker_Options.Increment_Last;

                  Linker_Options.Table (Linker_Options.Last) :=

                    new String'(Arg);

               elsif Arg (2) = 'g'

                 and then (Arg'Length < 5 or else Arg (2 .. 5) /= "gnat")

               then

                  Debug_Flag_Present := True;

                  Linker_Options.Increment_Last;

                  Linker_Options.Table (Linker_Options.Last) :=

                   new String'(Arg);

                  Binder_Options.Increment_Last;

                  Binder_Options.Table (Binder_Options.Last) :=

                    Linker_Options.Table (Linker_Options.Last);

               elsif Arg'Length >= 3 and then Arg (2) = 'M' then

                  declare

                     Switches : String_List_Access;

                  begin

                     Convert (Map_File, Arg (3 .. Arg'Last), Switches);

                     if Switches /= null then

                        for J in Switches'Range loop

                           Linker_Options.Increment_Last;

                           Linker_Options.Table (Linker_Options.Last) :=

                             Switches (J);

                        end loop;

                     end if;

                  end;

               elsif Arg'Length = 2 then

                  case Arg (2) is

                     when 'A' =>

                        Ada_Bind_File := True;

                        Begin_Info := "--  BEGIN Object file/option list";

                        End_Info   := "--  END Object file/option list   ";

                     when 'b' =>

                        Linker_Options.Increment_Last;

                        Linker_Options.Table (Linker_Options.Last) :=

                          new String'(Arg);

                        Binder_Options.Increment_Last;

                        Binder_Options.Table (Binder_Options.Last) :=

                          Linker_Options.Table (Linker_Options.Last);

                        Next_Arg := Next_Arg + 1;

                        if Next_Arg > Argument_Count then

                           Exit_With_Error ("Missing argument for -b");

                        end if;

                        Get_Machine_Name : declare

                           Name_Arg : constant String_Access :=

                                        new String'(Argument (Next_Arg));

                        begin

                           Linker_Options.Increment_Last;

                           Linker_Options.Table (Linker_Options.Last) :=

                             Name_Arg;

                           Binder_Options.Increment_Last;

                           Binder_Options.Table (Binder_Options.Last) :=

                             Name_Arg;

                        end Get_Machine_Name;

                     when 'C' =>

                        Ada_Bind_File := False;

                        Begin_Info := "/*  BEGIN Object file/option list";

                        End_Info   := "    END Object file/option list */";

                     when 'f' =>

                        if Object_List_File_Supported then

                           Object_List_File_Required := True;

                        else

                           Exit_With_Error

                             ("Object list file not supported on this target");

                        end if;

                     when 'M' =>

                        Create_Map_File := True;

                     when 'n' =>

                        Compile_Bind_File := False;

                     when 'o' =>

                        Next_Arg := Next_Arg + 1;

                        if Next_Arg > Argument_Count then

                           Exit_With_Error ("Missing argument for -o");

                        end if;

                        Output_File_Name :=

                          new String'(Executable_Name

                                        (Argument (Next_Arg),

                                         Only_If_No_Suffix => True));

                     when 'R' =>

                        Opt.Run_Path_Option := False;

                     when 'v' =>

                        --  Support "double" verbose mode.  Second -v

                        --  gets sent to the linker and binder phases.

                        if Verbose_Mode then

                           Very_Verbose_Mode := True;

                           Linker_Options.Increment_Last;

                           Linker_Options.Table (Linker_Options.Last) :=

                            new String'(Arg);

                           Binder_Options.Increment_Last;

                           Binder_Options.Table (Binder_Options.Last) :=

                             Linker_Options.Table (Linker_Options.Last);

                        else

                           Verbose_Mode := True;

                        end if;

                     when others =>

                        Linker_Options.Increment_Last;

                        Linker_Options.Table (Linker_Options.Last) :=

                         new String'(Arg);

                  end case;

               elsif Arg (2) = 'B' then

                  Linker_Options.Increment_Last;

                  Linker_Options.Table (Linker_Options.Last) :=

                    new String'(Arg);

                  Binder_Options.Increment_Last;

                  Binder_Options.Table (Binder_Options.Last) :=

                    Linker_Options.Table (Linker_Options.Last);

               elsif Arg'Length >= 7 and then Arg (1 .. 7) = "--LINK=" then

                  if Arg'Length = 7 then

                     Exit_With_Error ("Missing argument for --LINK=");

                  end if;

                  Linker_Path :=

                    System.OS_Lib.Locate_Exec_On_Path (Arg (8 .. Arg'Last));

                  if Linker_Path = null then

                     Exit_With_Error

                       ("Could not locate linker: " & Arg (8 .. Arg'Last));

                  end if;

               elsif Arg'Length > 6 and then Arg (1 .. 6) = "--GCC=" then

                  declare

                     Program_Args : constant Argument_List_Access :=

                                      Argument_String_To_List

                                                 (Arg (7 .. Arg'Last));

                  begin

                     if Program_Args.all (1).all /= Gcc.all then

                        Gcc := new String'(Program_Args.all (1).all);

                        Standard_Gcc := False;

                     end if;

                     --  Set appropriate flags for switches passed

                     for J in 2 .. Program_Args.all'Last loop

                        declare

                           Arg : constant String := Program_Args.all (J).all;

                           AF  : constant Integer := Arg'First;

                        begin

                           if Arg'Length /= 0 and then Arg (AF) = '-' then

                              if Arg (AF + 1) = 'g'

                                and then (Arg'Length = 2

                                  or else Arg (AF + 2) in '0' .. '3'

                                  or else Arg (AF + 2 .. Arg'Last) = "coff")

                              then

                                 Debug_Flag_Present := True;

                              end if;

                           end if;

                           --  Add directory to source search dirs so that

                           --  Get_Target_Parameters can find system.ads

                           if Arg (AF .. AF + 1) = "-I"

                             and then Arg'Length > 2

                           then

                              Add_Src_Search_Dir (Arg (AF + 2 .. Arg'Last));

                           end if;

                           --  Pass to gcc for compiling binder generated file

                           --  No use passing libraries, it will just generate

                           --  a warning

                           if not (Arg (AF .. AF + 1) = "-l"

                             or else Arg (AF .. AF + 1) = "-L")

                           then

                              Binder_Options.Increment_Last;

                              Binder_Options.Table (Binder_Options.Last) :=

                                new String'(Arg);

                           end if;

                           --  Pass to gcc for linking program

                           Gcc_Linker_Options.Increment_Last;

                           Gcc_Linker_Options.Table

                             (Gcc_Linker_Options.Last) := new String'(Arg);

                        end;

                     end loop;

                  end;

               --  Send all multi-character switches not recognized as

               --  a special case by gnatlink to the linker/loader stage.

               else

                  Linker_Options.Increment_Last;

                  Linker_Options.Table (Linker_Options.Last) :=

                    new String'(Arg);

               end if;

            --  Here if argument is a file name rather than a switch

            else

               --  If explicit ali file, capture it

               if Arg'Length > 4

                 and then Arg (Arg'Last - 3 .. Arg'Last) = ".ali"

               then

                  if Ali_File_Name = null then

                     Ali_File_Name := new String'(Arg);

                  else

                     Exit_With_Error ("cannot handle more than one ALI file");

                  end if;

               --  If target object file, record object file

               elsif Arg'Length > Get_Target_Object_Suffix.all'Length

                 and then Arg

                   (Arg'Last -

                    Get_Target_Object_Suffix.all'Length + 1 .. Arg'Last)

                   = Get_Target_Object_Suffix.all

               then

                  Linker_Objects.Increment_Last;

                  Linker_Objects.Table (Linker_Objects.Last) :=

                    new String'(Arg);

               --  If host object file, record object file

               --  e.g. accept foo.o as well as foo.obj on VMS target

               elsif Arg'Length > Get_Object_Suffix.all'Length

                 and then Arg

                   (Arg'Last - Get_Object_Suffix.all'Length + 1 .. Arg'Last)

                                                = Get_Object_Suffix.all

               then

                  Linker_Objects.Increment_Last;

                  Linker_Objects.Table (Linker_Objects.Last) :=

                    new String'(Arg);

               --  If corresponding ali file exists, capture it

               elsif Ali_File_Name = null

                 and then Is_Regular_File (Arg & ".ali")

               then

                  Ali_File_Name := new String'(Arg & ".ali");

               --  Otherwise assume this is a linker options entry, but

               --  see below for interesting adjustment to this assumption.

               else

                  Linker_Options.Increment_Last;

                  Linker_Options.Table (Linker_Options.Last) :=

                    new String'(Arg);

               end if;

            end if;

         end Process_One_Arg;

         Next_Arg := Next_Arg + 1;

      end loop;

      --  If Ada bind file, then compile it with warnings suppressed, because

      --  otherwise the with of the main program may cause junk warnings.

      if Ada_Bind_File then

         Binder_Options.Increment_Last;

         Binder_Options.Table (Binder_Options.Last) := new String'("-gnatws");

      end if;

      --  If we did not get an ali file at all, and we had at least one

      --  linker option, then assume that was the intended ali file after

      --  all, so that we get a nicer message later on.

      if Ali_File_Name = null

        and then Linker_Options.Last >= Linker_Options.First

      then

         Ali_File_Name :=

           new String'(Linker_Options.Table (Linker_Options.First).all &

                                                                   ".ali");

      end if;

   end Process_Args;

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

   -- Process_Binder_File --

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

   procedure Process_Binder_File (Name : String) is

      Fd : FILEs;

      --  Binder file's descriptor

      Link_Bytes : Integer := 0;

      --  Projected number of bytes for the linker command line

      Link_Max : Integer;

      pragma Import (C, Link_Max, "__gnat_link_max");

      --  Maximum number of bytes on the command line supported by the OS

      --  linker. Passed this limit the response file mechanism must be used

      --  if supported.

      Next_Line : String (1 .. 1000);

      --  Current line value

      Nlast  : Integer;

      Nfirst : Integer;

      --  Current line slice (the slice does not contain line terminator)

      Last : Integer;

      --  Current line last character for shared libraries (without version)

      Objs_Begin : Integer := 0;

      --  First object file index in Linker_Objects table

      Objs_End : Integer := 0;

      --  Last object file index in Linker_Objects table

      Status : int;

      pragma Warnings (Off, Status);

      --  Used for various Interfaces.C_Streams calls

      Closing_Status : Boolean;

      pragma Warnings (Off, Closing_Status);

      --  For call to Close

      GNAT_Static : Boolean := False;

      --  Save state of -static option

      GNAT_Shared : Boolean := False;

      --  Save state of -shared option

      Xlinker_Was_Previous : Boolean := False;

      --  Indicate that "-Xlinker" was the option preceding the current

      --  option. If True, then the current option is never suppressed.

      --  Rollback data

      --  These data items are used to store current binder file context.

      --  The context is composed of the file descriptor position and the

      --  current line together with the slice indexes (first and last

      --  position) for this line. The rollback data are used by the

      --  Store_File_Context and Rollback_File_Context routines below.

      --  The file context mechanism interact only with the Get_Next_Line

      --  call. For example:

      --     Store_File_Context;

      --     Get_Next_Line;

      --     Rollback_File_Context;

      --     Get_Next_Line;

      --  Both Get_Next_Line calls above will read the exact same data from

      --  the file. In other words, Next_Line, Nfirst and Nlast variables

      --  will be set with the exact same values.

      RB_File_Pos  : long;                -- File position

      RB_Next_Line : String (1 .. 1000);  -- Current line content

      RB_Nlast     : Integer;             -- Slice last index

      RB_Nfirst    : Integer;             -- Slice first index

      Run_Path_Option_Ptr : Interfaces.C.Strings.chars_ptr;

      pragma Import (C, Run_Path_Option_Ptr, "__gnat_run_path_option");

      --  Pointer to string representing the native linker option which

      --  specifies the path where the dynamic loader should find shared

      --  libraries. Equal to null string if this system doesn't support it.

      Libgcc_Subdir_Ptr : Interfaces.C.Strings.chars_ptr;

      pragma Import (C, Libgcc_Subdir_Ptr, "__gnat_default_libgcc_subdir");

      --  Pointer to string indicating the installation subdirectory where

      --  a default shared libgcc might be found.

      Object_Library_Ext_Ptr : Interfaces.C.Strings.chars_ptr;

      pragma Import

        (C, Object_Library_Ext_Ptr, "__gnat_object_library_extension");

      --  Pointer to string specifying the default extension for

      --  object libraries, e.g. Unix uses ".a", VMS uses ".olb".

      Object_File_Option_Ptr : Interfaces.C.Strings.chars_ptr;

      pragma Import (C, Object_File_Option_Ptr, "__gnat_object_file_option");

      --  Pointer to a string representing the linker option which specifies

      --  the response file.

      Using_GNU_Linker : Boolean;

      for Using_GNU_Linker'Size use Character'Size;

      pragma Import (C, Using_GNU_Linker, "__gnat_using_gnu_linker");

      --  Predicate indicating whether this target uses the GNU linker. In

      --  this case we must output a GNU linker compatible response file.

      Separate_Run_Path_Options : Boolean;

      for Separate_Run_Path_Options'Size use Character'Size;

      pragma Import

        (C, Separate_Run_Path_Options, "__gnat_separate_run_path_options");

      --  Whether separate rpath options should be emitted for each directory

      Opening : aliased constant String := """";

      Closing : aliased constant String := '"' & ASCII.LF;

      --  Needed to quote object paths in object list files when GNU linker

      --  is used.

      procedure Get_Next_Line;

      --  Read the next line from the binder file without the line

      --  terminator.

      function Index (S, Pattern : String) return Natural;

      --  Return the last occurrence of Pattern in S, or 0 if none

      function Is_Option_Present (Opt : String) return Boolean;

      --  Return true if the option Opt is already present in

      --  Linker_Options table.

      procedure Store_File_Context;

      --  Store current file context, Fd position and current line data.

      --  The file context is stored into the rollback data above (RB_*).