X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gold%2Ffileread.h;h=687216ee359dcc12d468c8646173fb24d77a7634;hb=29298bf66f62f2f6c1efb0685623fbc29dfade90;hp=178e7f355e446f2afb8678f8bfb679596aa27234;hpb=5a6f7e2db556f93765b75baf2d1ee1509225410d;p=deliverable%2Fbinutils-gdb.git

diff --git a/gold/fileread.h b/gold/fileread.h
index 178e7f355e..687216ee35 100644
--- a/gold/fileread.h
+++ b/gold/fileread.h
@@ -1,5 +1,25 @@
 // fileread.h -- read files for gold   -*- C++ -*-
 
+// Copyright (C) 2006-2019 Free Software Foundation, Inc.
+// Written by Ian Lance Taylor <iant@google.com>.
+
+// This file is part of gold.
+
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT 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
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
+// MA 02110-1301, USA.
+
 // Classes used to read data from binary input files.
 
 #ifndef GOLD_FILEREAD_H
@@ -8,88 +28,246 @@
 #include <list>
 #include <map>
 #include <string>
+#include <vector>
 
-#include "options.h"
+#include "token.h"
 
 namespace gold
 {
 
+// Since not all system supports stat.st_mtim and struct timespec,
+// we define our own structure and fill the nanoseconds if we can.
+
+struct Timespec
+{
+  Timespec()
+    : seconds(0), nanoseconds(0)
+  { }
+
+  Timespec(time_t a_seconds, int a_nanoseconds)
+    : seconds(a_seconds), nanoseconds(a_nanoseconds)
+  { }
+
+  time_t seconds;
+  int nanoseconds;
+};
+
+// Get the last modified time of an unopened file.  Returns false if the
+// file does not exist.
+
+bool
+get_mtime(const char* filename, Timespec* mtime);
+
+class Position_dependent_options;
+class Input_file_argument;
 class Dirsearch;
 class File_view;
 
-// File_read manages a file descriptor for a file we are reading.  We
-// close file descriptors if we run out of them, so this class reopens
-// the file as needed.
+// File_read manages a file descriptor and mappings for a file we are
+// reading.
 
 class File_read
 {
  public:
   File_read()
-    : name_(), descriptor_(-1), lock_count_(0), views_(),
-      saved_views_(), contents_(NULL), contents_size_(0)
+    : name_(), descriptor_(-1), is_descriptor_opened_(false), object_count_(0),
+      size_(0), token_(false), views_(), saved_views_(), mapped_bytes_(0),
+      released_(true), whole_file_view_(NULL)
   { }
 
   ~File_read();
 
   // Open a file.
   bool
-  open(const std::string& name);
+  open(const Task*, const std::string& name);
 
   // Pretend to open the file, but provide the file contents.  No
   // actual file system activity will occur.  This is used for
   // testing.
   bool
-  open(const std::string& name, const unsigned char* contents, off_t size);
+  open(const Task*, const std::string& name, const unsigned char* contents,
+       off_t size);
 
   // Return the file name.
   const std::string&
   filename() const
   { return this->name_; }
 
-  // Lock the file for access within a particular Task::run execution.
-  // This means that the descriptor can not be closed.  This routine
-  // may only be called from the main thread.
+  // Add an object associated with a file.
   void
-  lock();
+  add_object()
+  { ++this->object_count_; }
 
-  // Unlock the descriptor, permitting it to be closed if necessary.
+  // Remove an object associated with a file.
   void
-  unlock();
-  
+  remove_object()
+  { --this->object_count_; }
+
+  // Lock the file for exclusive access within a particular Task::run
+  // execution.  This routine may only be called when the workqueue
+  // lock is held.
+  void
+  lock(const Task* t);
+
+  // Unlock the file.
+  void
+  unlock(const Task* t);
+
   // Test whether the object is locked.
   bool
-  is_locked();
+  is_locked() const;
+
+  // Return the token, so that the task can be queued.
+  Task_token*
+  token()
+  { return &this->token_; }
+
+  // Release the file.  This indicates that we aren't going to do
+  // anything further with it until it is unlocked.  This is used
+  // because a Task which locks the file never calls either lock or
+  // unlock; it just locks the token.  The basic rule is that a Task
+  // which locks a file via the Task::locks interface must explicitly
+  // call release() when it is done.  This is not necessary for code
+  // which calls unlock() on the file.
+  void
+  release();
 
-  // Return a view into the file.  The pointer will remain valid until
-  // the File_read is unlocked.  If PBYTES is NULL, it is an error if
-  // we can not read enough data.  Otherwise *PBYTES is set to the
-  // number of bytes read.
+  // Return the size of the file.
+  off_t
+  filesize() const
+  { return this->size_; }
+
+  // Return a view into the file starting at file offset START for
+  // SIZE bytes.  OFFSET is the offset into the input file for the
+  // file we are reading; this is zero for a normal object file,
+  // non-zero for an object file in an archive.  ALIGNED is true if
+  // the data must be naturally aligned (i.e., aligned to the size
+  // of a target word); this only matters when OFFSET is not zero.
+  // The pointer will remain valid until the File_read is unlocked.
+  // It is an error if we can not read enough data from the file.
+  // The CACHE parameter is a hint as to whether it will be useful
+  // to cache this data for later accesses--i.e., later calls to
+  // get_view, read, or get_lasting_view which retrieve the same
+  // data.
   const unsigned char*
-  get_view(off_t start, off_t size, off_t *pbytes = NULL);
+  get_view(off_t offset, off_t start, section_size_type size, bool aligned,
+	   bool cache);
 
-  // Read data from the file into the buffer P.  PBYTES is as in
-  // get_view.
+  // Read data from the file into the buffer P starting at file offset
+  // START for SIZE bytes.
   void
-  read(off_t start, off_t size, void* p, off_t *pbytes = NULL);
-
-  // Return a lasting view into the file.  This is allocated with new,
-  // and the caller is responsible for deleting it when done.  The
-  // data associated with this view will remain valid until the view
-  // is deleted.  PBYTES is handled as with get_view.
+  read(off_t start, section_size_type size, void* p);
+
+  // Return a lasting view into the file starting at file offset START
+  // for SIZE bytes.  This is allocated with new, and the caller is
+  // responsible for deleting it when done.  The data associated with
+  // this view will remain valid until the view is deleted.  It is an
+  // error if we can not read enough data from the file.  The OFFSET,
+  // ALIGNED and CACHE parameters are as in get_view.
   File_view*
-  get_lasting_view(off_t start, off_t size, off_t *pbytes = NULL);
+  get_lasting_view(off_t offset, off_t start, section_size_type size,
+		   bool aligned, bool cache);
+
+  // Mark all views as no longer cached.
+  void
+  clear_view_cache_marks();
+
+  // Discard all uncached views.  This is normally done by release(),
+  // but not for objects in archives.  FIXME: This is a complicated
+  // interface, and it would be nice to have something more automatic.
+  void
+  clear_uncached_views()
+  { this->clear_views(CLEAR_VIEWS_ARCHIVE); }
+
+  // A struct used to do a multiple read.
+  struct Read_multiple_entry
+  {
+    // The file offset of the data to read.
+    off_t file_offset;
+    // The amount of data to read.
+    section_size_type size;
+    // The buffer where the data should be placed.
+    unsigned char* buffer;
+
+    Read_multiple_entry(off_t o, section_size_type s, unsigned char* b)
+      : file_offset(o), size(s), buffer(b)
+    { }
+  };
+
+  typedef std::vector<Read_multiple_entry> Read_multiple;
+
+  // Read a bunch of data from the file into various different
+  // locations.  The vector must be sorted by ascending file_offset.
+  // BASE is a base offset to be added to all the offsets in the
+  // vector.
+  void
+  read_multiple(off_t base, const Read_multiple&);
+
+  // Dump statistical information to stderr.
+  static void
+  print_stats();
+
+  // Return the open file descriptor (for plugins).
+  int
+  descriptor()
+  {
+    this->reopen_descriptor();
+    return this->descriptor_;
+  }
+  
+  // Return the file last modification time.  Calls gold_fatal if the stat
+  // system call failed.
+  Timespec
+  get_mtime();
 
  private:
+  // Control for what views to clear.
+  enum Clear_views_mode
+  {
+    // Clear uncached views not used by an archive.
+    CLEAR_VIEWS_NORMAL,
+    // Clear all uncached views (including in an archive).
+    CLEAR_VIEWS_ARCHIVE,
+    // Clear all views (i.e., we're destroying the file).
+    CLEAR_VIEWS_ALL
+  };
+
   // This class may not be copied.
   File_read(const File_read&);
   File_read& operator=(const File_read&);
 
-  // A view into the file when not using mmap.
+  // Total bytes mapped into memory during the link if --stats.
+  static unsigned long long total_mapped_bytes;
+
+  // Current number of bytes mapped into memory during the link if
+  // --stats.
+  static unsigned long long current_mapped_bytes;
+
+  // High water mark of bytes mapped into memory during the link if
+  // --stats.
+  static unsigned long long maximum_mapped_bytes;
+
+  // A view into the file.
   class View
   {
    public:
-    View(off_t start, off_t size, unsigned char* data)
-      : start_(start), size_(size), data_(data), lock_count_(0)
+    // Specifies how to dispose the data on destruction of the view.
+    enum Data_ownership
+    {
+      // Data owned by File object - nothing done in destructor.
+      DATA_NOT_OWNED,
+      // Data allocated with new[] and owned by this object - should
+      // use delete[].
+      DATA_ALLOCATED_ARRAY,
+      // Data mmapped and owned by this object - should munmap.
+      DATA_MMAPPED
+    };
+
+    View(off_t start, section_size_type size, const unsigned char* data,
+	 unsigned int byteshift, bool cache, Data_ownership data_ownership)
+      : start_(start), size_(size), data_(data), lock_count_(0),
+	byteshift_(byteshift), cache_(cache), data_ownership_(data_ownership),
+	accessed_(true)
     { }
 
     ~View();
@@ -98,11 +276,11 @@ class File_read
     start() const
     { return this->start_; }
 
-    off_t
+    section_size_type
     size() const
     { return this->size_; }
 
-    unsigned char*
+    const unsigned char*
     data() const
     { return this->data_; }
 
@@ -115,33 +293,104 @@ class File_read
     bool
     is_locked();
 
+    unsigned int
+    byteshift() const
+    { return this->byteshift_; }
+
+    void
+    set_cache()
+    { this->cache_ = true; }
+
+    void
+    clear_cache()
+    { this->cache_ = false; }
+
+    bool
+    should_cache() const
+    { return this->cache_; }
+
+    void
+    set_accessed()
+    { this->accessed_ = true; }
+
+    void
+    clear_accessed()
+    { this->accessed_= false; }
+
+    bool
+    accessed() const
+    { return this->accessed_; }
+
+    // Returns TRUE if this view contains permanent data -- e.g., data that
+    // was supplied by the owner of the File object.
+    bool
+    is_permanent_view() const
+    { return this->data_ownership_ == DATA_NOT_OWNED; }
+
    private:
     View(const View&);
     View& operator=(const View&);
 
+    // The file offset of the start of the view.
     off_t start_;
-    off_t size_;
-    unsigned char* data_;
+    // The size of the view.
+    section_size_type size_;
+    // A pointer to the actual bytes.
+    const unsigned char* data_;
+    // The number of locks on this view.
     int lock_count_;
+    // The number of bytes that the view is shifted relative to the
+    // underlying file.  This is used to align data.  This is normally
+    // zero, except possibly for an object in an archive.
+    unsigned int byteshift_;
+    // Whether the view is cached.
+    bool cache_;
+    // Whether the view is mapped into memory.  If not, data_ points
+    // to memory allocated using new[].
+    Data_ownership data_ownership_;
+    // Whether the view has been accessed recently.
+    bool accessed_;
   };
 
+  friend class View;
   friend class File_view;
 
+  // The type of a mapping from page start and byte shift to views.
+  typedef std::map<std::pair<off_t, unsigned int>, View*> Views;
+
+  // A simple list of Views.
+  typedef std::list<View*> Saved_views;
+
+  // Open the descriptor if necessary.
+  void
+  reopen_descriptor();
+
   // Find a view into the file.
   View*
-  find_view(off_t start, off_t size);
+  find_view(off_t start, section_size_type size, unsigned int byteshift,
+	    View** vshifted) const;
 
   // Read data from the file into a buffer.
-  off_t
-  do_read(off_t start, off_t size, void* p, off_t* pbytes);
+  void
+  do_read(off_t start, section_size_type size, void* p);
+
+  // Add a view.
+  void
+  add_view(View*);
+
+  // Make a view into the file.
+  View*
+  make_view(off_t start, section_size_type size, unsigned int byteshift,
+	    bool cache);
 
   // Find or make a view into the file.
   View*
-  find_or_make_view(off_t start, off_t size, off_t* pbytes);
+  find_or_make_view(off_t offset, off_t start, section_size_type size,
+		    bool aligned, bool cache);
 
   // Clear the file views.
   void
-  clear_views(bool);
+  clear_views(Clear_views_mode);
 
   // The size of a file page for buffering data.
   static const off_t page_size = 8192;
@@ -156,27 +405,43 @@ class File_read
   pages(off_t file_size)
   { return (file_size + (page_size - 1)) & ~ (page_size - 1); }
 
-  // The type of a mapping from page start to views.
-  typedef std::map<off_t, View*> Views;
+  // The maximum number of entries we will pass to ::readv.
+  static const size_t max_readv_entries = 128;
 
-  // A simple list of Views.
-  typedef std::list<View*> Saved_views;
+  // Use readv to read data.
+  void
+  do_readv(off_t base, const Read_multiple&, size_t start, size_t count);
 
   // File name.
   std::string name_;
   // File descriptor.
   int descriptor_;
-  // Number of locks on the file.
-  int lock_count_;
+  // Whether we have regained the descriptor after releasing the file.
+  bool is_descriptor_opened_;
+  // The number of objects associated with this file.  This will be
+  // more than 1 in the case of an archive.
+  int object_count_;
+  // File size.
+  off_t size_;
+  // A token used to lock the file.
+  Task_token token_;
   // Buffered views into the file.
   Views views_;
   // List of views which were locked but had to be removed from views_
   // because they were not large enough.
   Saved_views saved_views_;
-  // Specified file contents.  Used only for testing purposes.
-  const unsigned char* contents_;
-  // Specified file size.  Used only for testing purposes.
-  off_t contents_size_;
+  // Total amount of space mapped into memory.  This is only changed
+  // while the file is locked.  When we unlock the file, we transfer
+  // the total to total_mapped_bytes, and reset this to zero.
+  size_t mapped_bytes_;
+  // Whether the file was released.
+  bool released_;
+  // A view containing the whole file.  May be NULL if we mmap only
+  // the relevant parts of the file.  Not NULL if:
+  // - Flag --mmap_whole_files is set (default on 64-bit hosts).
+  // - The contents was specified in the constructor.  Used only for
+  //   testing purposes).
+  View* whole_file_view_;
 };
 
 // A view of file data that persists even when the file is unlocked.
@@ -217,39 +482,128 @@ class File_view
 class Input_file
 {
  public:
+  enum Format
+  {
+    FORMAT_NONE,
+    FORMAT_ELF,
+    FORMAT_BINARY
+  };
+
   Input_file(const Input_file_argument* input_argument)
-    : input_argument_(input_argument), file_()
+    : input_argument_(input_argument), found_name_(), file_(),
+      is_in_sysroot_(false), format_(FORMAT_NONE)
   { }
 
+  // Create an input file given just a filename.
+  Input_file(const char* name);
+
   // Create an input file with the contents already provided.  This is
   // only used for testing.  With this path, don't call the open
   // method.
-  Input_file(const char* name, const unsigned char* contents, off_t size);
+  Input_file(const Task*, const char* name, const unsigned char* contents,
+	     off_t size);
 
-  // Open the file.
-  void
-  open(const General_options&, const Dirsearch&);
+  // Return the command line argument.
+  const Input_file_argument*
+  input_file_argument() const
+  { return this->input_argument_; }
 
-  // Return the name given by the user.
+  // Return whether this is a file that we will search for in the list
+  // of directories.
+  bool
+  will_search_for() const;
+
+  // Open the file.  If the open fails, this will report an error and
+  // return false.  If there is a search, it starts at directory
+  // *PINDEX.  *PINDEX should be initialized to zero.  It may be
+  // restarted to find the next file with a matching name by
+  // incrementing the result and calling this again.
+  bool
+  open(const Dirsearch&, const Task*, int* pindex);
+
+  // Return the name given by the user.  For -lc this will return "c".
   const char*
-  name() const
-  { return this->input_argument_->name(); }
+  name() const;
 
-  // Return the file name.
+  // Return the file name.  For -lc this will return something like
+  // "/usr/lib/libc.so".
   const std::string&
   filename() const
   { return this->file_.filename(); }
 
+  // Return the name under which we found the file, corresponding to
+  // the command line.  For -lc this will return something like
+  // "libc.so".
+  const std::string&
+  found_name() const
+  { return this->found_name_; }
+
+  // Return the position dependent options.
+  const Position_dependent_options&
+  options() const;
+
+  // Return the file.
   File_read&
   file()
   { return this->file_; }
 
+  const File_read&
+  file() const
+  { return this->file_; }
+
+  // Whether we found the file in a directory in the system root.
+  bool
+  is_in_sysroot() const
+  { return this->is_in_sysroot_; }
+
+  // Whether this file is in a system directory.
+  bool
+  is_in_system_directory() const;
+
+  // Return whether this file is to be read only for its symbols.
+  bool
+  just_symbols() const;
+
+  // Return the format of the unconverted input file.
+  Format
+  format() const
+  { return this->format_; }
+
+  // Try to find a file in the extra search dirs.  Returns true on success.
+  static bool
+  try_extra_search_path(int* pindex,
+			const Input_file_argument* input_argument,
+			std::string filename, std::string* found_name,
+			std::string* namep);
+
+  // Find the actual file.
+  static bool
+  find_file(const Dirsearch& dirpath, int* pindex,
+	    const Input_file_argument* input_argument,
+	    bool* is_in_sysroot,
+	    std::string* found_name, std::string* namep);
+
  private:
   Input_file(const Input_file&);
   Input_file& operator=(const Input_file&);
 
+  // Open a binary file.
+  bool
+  open_binary(const Task* task, const std::string& name);
+
+  // The argument from the command line.
   const Input_file_argument* input_argument_;
+  // The name under which we opened the file.  This is like the name
+  // on the command line, but -lc turns into libc.so (or whatever).
+  // It only includes the full path if the path was on the command
+  // line.
+  std::string found_name_;
+  // The file after we open it.
   File_read file_;
+  // Whether we found the file in a directory in the system root.
+  bool is_in_sysroot_;
+  // Format of unconverted input file.
+  Format format_;
 };
 
 } // end namespace gold