Subversion Repositories openrisc

------------------------------------------------------------------------------
--                                                                          --
--                         GNAT COMPILER COMPONENTS                         --
--                                                                          --
--                             M L I B . U T L                              --
--                                                                          --
--                                 B o d y                                  --
--                                                                          --
--                     Copyright (C) 2002-2008, AdaCore                     --
--                                                                          --
-- 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 MLib.Fil; use MLib.Fil;
with MLib.Tgt; use MLib.Tgt;
with Opt;
with Osint;
with Output;   use Output;
 
with Interfaces.C.Strings; use Interfaces.C.Strings;
 
with System;
 
package body MLib.Utl is
 
   Adalib_Path : String_Access := null;
   --  Path of the GNAT adalib directory, specified in procedure
   --  Specify_Adalib_Dir. Used in function Lib_Directory.
 
   Gcc_Name : String_Access;
   --  Default value of the "gcc" executable used in procedure Gcc
 
   Gcc_Exec : String_Access;
   --  The full path name of the "gcc" executable
 
   Ar_Name : String_Access;
   --  The name of the archive builder for the platform, set when procedure Ar
   --  is called for the first time.
 
   Ar_Exec : String_Access;
   --  The full path name of the archive builder
 
   Ar_Options : String_List_Access;
   --  The minimum options used when invoking the archive builder
 
   Ar_Append_Options : String_List_Access;
   --  The options to be used when invoking the archive builder to add chunks
   --  of object files, when building the archive in chunks.
 
   Opt_Length : Natural := 0;
   --  The max number of options for the Archive_Builder
 
   Initial_Size : Natural := 0;
   --  The minimum number of bytes for the invocation of the Archive Builder
   --  (without name of the archive or object files).
 
   Ranlib_Name : String_Access;
   --  The name of the archive indexer for the platform, if there is one
 
   Ranlib_Exec : String_Access := null;
   --  The full path name of the archive indexer
 
   Ranlib_Options : String_List_Access := null;
   --  The options to be used when invoking the archive indexer, if any
 
   --------
   -- Ar --
   --------
 
   procedure Ar (Output_File : String; Objects : Argument_List) is
      Full_Output_File : constant String :=
                             Ext_To (Output_File, Archive_Ext);
 
      Arguments   : Argument_List_Access;
      Last_Arg    : Natural := 0;
      Success     : Boolean;
      Line_Length : Natural := 0;
 
      Maximum_Size : Integer;
      pragma Import (C, Maximum_Size, "__gnat_link_max");
      --  Maximum number of bytes to put in an invocation of the
      --  Archive_Builder.
 
      Size : Integer;
      --  The number of bytes for the invocation of the archive builder
 
      Current_Object : Natural;
 
      procedure Display;
      --  Display an invocation of the Archive Builder
 
      -------------
      -- Display --
      -------------
 
      procedure Display is
      begin
         if not Opt.Quiet_Output then
            Write_Str (Ar_Name.all);
            Line_Length := Ar_Name'Length;
 
            for J in 1 .. Last_Arg loop
 
               --  Make sure the Output buffer does not overflow
 
               if Line_Length + 1 + Arguments (J)'Length > Buffer_Max then
                  Write_Eol;
                  Line_Length := 0;
               end if;
 
               Write_Char (' ');
 
               --  Only output the first object files when not in verbose mode
 
               if (not Opt.Verbose_Mode) and then J = Opt_Length + 3 then
                  Write_Str ("...");
                  exit;
               end if;
 
               Write_Str (Arguments (J).all);
               Line_Length := Line_Length + 1 + Arguments (J)'Length;
            end loop;
 
            Write_Eol;
         end if;
 
      end Display;
 
   begin
      if Ar_Exec = null then
         Ar_Name := Osint.Program_Name (Archive_Builder, "gnatmake");
         Ar_Exec := Locate_Exec_On_Path (Ar_Name.all);
 
         if Ar_Exec = null then
            Free (Ar_Name);
            Ar_Name := new String'(Archive_Builder);
            Ar_Exec := Locate_Exec_On_Path (Ar_Name.all);
         end if;
 
         if Ar_Exec = null then
            Fail (Ar_Name.all & " not found in path");
 
         elsif Opt.Verbose_Mode then
            Write_Str  ("found ");
            Write_Line (Ar_Exec.all);
         end if;
 
         Ar_Options := Archive_Builder_Options;
 
         Initial_Size := 0;
         for J in Ar_Options'Range loop
            Initial_Size := Initial_Size + Ar_Options (J)'Length + 1;
         end loop;
 
         Ar_Append_Options := Archive_Builder_Append_Options;
 
         Opt_Length := Ar_Options'Length;
 
         if Ar_Append_Options /= null then
            Opt_Length := Natural'Max (Ar_Append_Options'Length, Opt_Length);
 
            Size := 0;
            for J in Ar_Append_Options'Range loop
               Size := Size + Ar_Append_Options (J)'Length + 1;
            end loop;
 
            Initial_Size := Integer'Max (Initial_Size, Size);
         end if;
 
         --  ranlib
 
         Ranlib_Name := Osint.Program_Name (Archive_Indexer, "gnatmake");
 
         if Ranlib_Name'Length > 0 then
            Ranlib_Exec := Locate_Exec_On_Path (Ranlib_Name.all);
 
            if Ranlib_Exec = null then
               Free (Ranlib_Name);
               Ranlib_Name := new String'(Archive_Indexer);
               Ranlib_Exec := Locate_Exec_On_Path (Ranlib_Name.all);
            end if;
 
            if Ranlib_Exec /= null and then Opt.Verbose_Mode then
               Write_Str ("found ");
               Write_Line (Ranlib_Exec.all);
            end if;
         end if;
 
         Ranlib_Options := Archive_Indexer_Options;
      end if;
 
      Arguments :=
        new String_List (1 .. 1 + Opt_Length + Objects'Length);
      Arguments (1 .. Ar_Options'Length) := Ar_Options.all; --  "ar cr ..."
      Arguments (Ar_Options'Length + 1) := new String'(Full_Output_File);
 
      Delete_File (Full_Output_File);
 
      Size := Initial_Size + Full_Output_File'Length + 1;
 
      --  Check the full size of a call of the archive builder with all the
      --  object files.
 
      for J in Objects'Range loop
         Size := Size + Objects (J)'Length + 1;
      end loop;
 
      --  If the size is not too large or if it is not possible to build the
      --  archive in chunks, build the archive in a single invocation.
 
      if Size <= Maximum_Size or else Ar_Append_Options = null then
         Last_Arg := Ar_Options'Length + 1 + Objects'Length;
         Arguments (Ar_Options'Length + 2 .. Last_Arg) := Objects;
 
         Display;
 
         Spawn (Ar_Exec.all, Arguments (1 .. Last_Arg), Success);
 
      else
         --  Build the archive in several invocation, making sure to not
         --  go over the maximum size for each invocation.
 
         Last_Arg := Ar_Options'Length + 1;
         Current_Object := Objects'First;
         Size := Initial_Size + Full_Output_File'Length + 1;
 
         --  First invocation
 
         while Current_Object <= Objects'Last loop
            Size := Size + Objects (Current_Object)'Length + 1;
            exit when Size > Maximum_Size;
            Last_Arg := Last_Arg + 1;
            Arguments (Last_Arg) := Objects (Current_Object);
            Current_Object := Current_Object + 1;
         end loop;
 
         Display;
 
         Spawn (Ar_Exec.all, Arguments (1 .. Last_Arg), Success);
 
         Arguments (1 .. Ar_Append_Options'Length) := Ar_Append_Options.all;
         Arguments
           (Ar_Append_Options'Length + 1) := new String'(Full_Output_File);
 
         --  Appending invocation(s)
 
         Big_Loop : while Success and then Current_Object <= Objects'Last loop
            Last_Arg := Ar_Append_Options'Length + 1;
            Size := Initial_Size + Full_Output_File'Length + 1;
 
            Inner_Loop : while Current_Object <= Objects'Last loop
               Size := Size + Objects (Current_Object)'Length + 1;
               exit Inner_Loop when Size > Maximum_Size;
               Last_Arg := Last_Arg + 1;
               Arguments (Last_Arg) := Objects (Current_Object);
               Current_Object := Current_Object + 1;
            end loop Inner_Loop;
 
            Display;
 
            Spawn (Ar_Exec.all, Arguments (1 .. Last_Arg), Success);
         end loop Big_Loop;
      end if;
 
      if not Success then
         Fail (Ar_Name.all & " execution error.");
      end if;
 
      --  If we have found ranlib, run it over the library
 
      if Ranlib_Exec /= null then
         if not Opt.Quiet_Output then
            Write_Str  (Ranlib_Name.all);
            Write_Char (' ');
            Write_Line (Arguments (Ar_Options'Length + 1).all);
         end if;
 
         Spawn
           (Ranlib_Exec.all,
            Ranlib_Options.all & (Arguments (Ar_Options'Length + 1)),
            Success);
 
         if not Success then
            Fail (Ranlib_Name.all & " execution error.");
         end if;
      end if;
   end Ar;
 
   -----------------
   -- Delete_File --
   -----------------
 
   procedure Delete_File (Filename : String) is
      File    : constant String := Filename & ASCII.NUL;
      Success : Boolean;
 
   begin
      Delete_File (File'Address, Success);
 
      if Opt.Verbose_Mode then
         if Success then
            Write_Str ("deleted ");
 
         else
            Write_Str ("could not delete ");
         end if;
 
         Write_Line (Filename);
      end if;
   end Delete_File;
 
   ---------
   -- Gcc --
   ---------
 
   procedure Gcc
     (Output_File : String;
      Objects     : Argument_List;
      Options     : Argument_List;
      Options_2   : Argument_List;
      Driver_Name : Name_Id := No_Name)
   is
      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.
 
      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_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.
 
      Opening : aliased constant String := """";
      Closing : aliased constant String := '"' & ASCII.LF;
      --  Needed to quote object paths in object list files when GNU linker
      --  is used.
 
      Tname    : String_Access;
      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.
 
      Closing_Status : Boolean;
      --  For call to Close
 
      Arguments :
        Argument_List
          (1 .. 7 + Objects'Length + Options'Length + Options_2'Length);
 
      A       : Natural := 0;
      Success : Boolean;
 
      Out_Opt : constant String_Access := new String'("-o");
      Out_V   : constant String_Access := new String'(Output_File);
      Lib_Dir : constant String_Access := new String'("-L" & Lib_Directory);
      Lib_Opt : constant String_Access := new String'(Dynamic_Option);
 
      Driver : String_Access;
 
      type Object_Position is (First, Second, Last);
 
      Position : Object_Position;
 
      procedure Write_RF (A : System.Address; N : Integer);
      --  Write a string to the response file and check if it was successful.
      --  Fail the program if it was not successful (disk full).
 
      --------------
      -- Write_RF --
      --------------
 
      procedure Write_RF (A : System.Address; N : Integer) is
         Status : Integer;
      begin
         Status := Write (Tname_FD, A, N);
 
         if Status /= N then
            Fail ("cannot generate response file to link library: disk full");
         end if;
      end Write_RF;
 
   begin
      if Driver_Name = No_Name then
         if Gcc_Exec = null then
            if Gcc_Name = null then
               Gcc_Name := Osint.Program_Name ("gcc", "gnatmake");
            end if;
 
            Gcc_Exec := Locate_Exec_On_Path (Gcc_Name.all);
 
            if Gcc_Exec = null then
               Fail (Gcc_Name.all & " not found in path");
            end if;
         end if;
 
         Driver := Gcc_Exec;
 
      else
         Driver := Locate_Exec_On_Path (Get_Name_String (Driver_Name));
 
         if Driver = null then
            Fail (Get_Name_String (Driver_Name) & " not found in path");
         end if;
      end if;
 
      Link_Bytes := 0;
 
      if Lib_Opt'Length /= 0 then
         A := A + 1;
         Arguments (A) := Lib_Opt;
         Link_Bytes := Link_Bytes + Lib_Opt'Length + 1;
      end if;
 
      A := A + 1;
      Arguments (A) := Out_Opt;
      Link_Bytes := Link_Bytes + Out_Opt'Length + 1;
 
      A := A + 1;
      Arguments (A) := Out_V;
      Link_Bytes := Link_Bytes + Out_V'Length + 1;
 
      A := A + 1;
      Arguments (A) := Lib_Dir;
      Link_Bytes := Link_Bytes + Lib_Dir'Length + 1;
 
      A := A + Options'Length;
      Arguments (A - Options'Length + 1 .. A) := Options;
 
      for J in Options'Range loop
         Link_Bytes := Link_Bytes + Options (J)'Length + 1;
      end loop;
 
      if not Opt.Quiet_Output then
         Write_Str (Driver.all);
 
         for J in 1 .. A loop
            Write_Char (' ');
            Write_Str  (Arguments (J).all);
         end loop;
 
         --  Do not display all the object files if not in verbose mode, only
         --  the first one.
 
         Position := First;
         for J in Objects'Range loop
            if Opt.Verbose_Mode or else Position = First then
               Write_Char (' ');
               Write_Str (Objects (J).all);
               Position := Second;
 
            elsif Position = Second then
               Write_Str (" ...");
               Position := Last;
            end if;
         end loop;
 
         for J in Options_2'Range loop
            Write_Char (' ');
            Write_Str (Options_2 (J).all);
         end loop;
 
         Write_Eol;
      end if;
 
      for J in Objects'Range loop
         Link_Bytes := Link_Bytes + Objects (J)'Length + 1;
      end loop;
 
      for J in Options_2'Range loop
         Link_Bytes := Link_Bytes + Options_2 (J)'Length + 1;
      end loop;
 
      if Object_List_File_Supported and then Link_Bytes > Link_Max then
         --  Create a temporary file containing the object files, one object
         --  file per line for maximal compatibility with linkers supporting
         --  this option.
 
         Create_Temp_File (Tname_FD, Tname);
 
         --  If target is using the GNU linker we must add a special header
         --  and footer in the response file.
 
         --  The syntax is : INPUT (object1.o object2.o ... )
 
         --  Because the GNU linker does not like name with characters such
         --  as '!', we must put the object paths between double quotes.
 
         if Using_GNU_Linker then
            declare
               GNU_Header : aliased constant String := "INPUT (";
 
            begin
               Write_RF (GNU_Header'Address, GNU_Header'Length);
            end;
         end if;
 
         for J in Objects'Range loop
            --  Opening quote for GNU linker
 
            if Using_GNU_Linker then
               Write_RF (Opening'Address, 1);
            end if;
 
            Write_RF
                (Objects (J).all'Address, Objects (J).all'Length);
 
            --  Closing quote for GNU linker
 
            if Using_GNU_Linker then
               Write_RF (Closing'Address, 2);
 
            else
               Write_RF (ASCII.LF'Address, 1);
            end if;
         end loop;
 
         --  Handle GNU linker response file footer
 
         if Using_GNU_Linker then
            declare
               GNU_Footer : aliased constant String := ")";
 
            begin
               Write_RF (GNU_Footer'Address, GNU_Footer'Length);
            end;
         end if;
 
         Close (Tname_FD, Closing_Status);
 
         if not Closing_Status then
            Fail ("cannot generate response file to link library: disk full");
         end if;
 
         A := A + 1;
         Arguments (A) :=
           new String'(Value (Object_File_Option_Ptr) & Tname.all);
 
      else
         A := A + Objects'Length;
         Arguments (A - Objects'Length + 1 .. A) := Objects;
      end if;
 
      A := A + Options_2'Length;
      Arguments (A - Options_2'Length + 1 .. A) := Options_2;
 
      Spawn (Driver.all, Arguments (1 .. A), Success);
 
      if Tname /= null then
         Delete_File (Tname.all, Closing_Status);
 
         if not Closing_Status then
            Write_Str ("warning: could not delete response file """);
            Write_Str (Tname.all);
            Write_Line (""" to link library");
         end if;
      end if;
 
      if not Success then
         if Driver_Name = No_Name then
            Fail (Gcc_Name.all & " execution error");
         else
            Fail (Get_Name_String (Driver_Name) & " execution error");
         end if;
      end if;
   end Gcc;
 
   -------------------
   -- Lib_Directory --
   -------------------
 
   function Lib_Directory return String is
      Libgnat : constant String := Tgt.Libgnat;
 
   begin
      --  If procedure Specify_Adalib_Dir has been called, used the specified
      --  value.
 
      if Adalib_Path /= null then
         return Adalib_Path.all;
      end if;
 
      Name_Len := Libgnat'Length;
      Name_Buffer (1 .. Name_Len) := Libgnat;
      Get_Name_String (Osint.Find_File (Name_Enter, Osint.Library));
 
      --  Remove libgnat.a
 
      return Name_Buffer (1 .. Name_Len - Libgnat'Length);
   end Lib_Directory;
 
   ------------------------
   -- Specify_Adalib_Dir --
   ------------------------
 
   procedure Specify_Adalib_Dir (Path : String) is
   begin
      if Path'Length = 0 then
         Adalib_Path := null;
      else
         Adalib_Path := new String'(Path);
      end if;
   end Specify_Adalib_Dir;
 
end MLib.Utl;