Initial CVS checkin of gold

1 files changed, 226 insertions, 0 deletions

diff --git a/gold/fileread.h b/gold/fileread.h
new file mode 100644
index 0000000..2181485
--- /dev/null
+++ b/gold/fileread.h
@@ -0,0 +1,226 @@
+// fileread.h -- read files for gold   -*- C++ -*-
+
+// Classes used to read data from binary input files.
+
+#ifndef GOLD_FILEREAD_H
+#define GOLD_FILEREAD_H
+
+#include <string>
+#include <list>
+
+#include "options.h"
+
+namespace gold
+{
+
+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.
+
+class File_read
+{
+ public:
+  File_read()
+    : name_(), descriptor_(-1), lock_count_(0)
+  { }
+  ~File_read();
+
+  // Open a file.
+  bool
+  open(const std::string& name);
+
+  // Return the file name.
+  const std::string&
+  filename() const
+  { return this->name_; }
+
+  // Return the file descriptor.
+  int
+  get_descriptor();
+
+  // 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.
+  void
+  lock();
+
+  // Unlock the descriptor, permitting it to be closed if necessary.
+  void
+  unlock();
+  
+  // Test whether the object is locked.
+  bool
+  is_locked();
+
+  // 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.
+  const unsigned char*
+  get_view(off_t start, off_t size, off_t *pbytes = NULL);
+
+  // Read data from the file into the buffer P.  PBYTES is as in
+  // get_view.
+  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.
+  File_view*
+  get_lasting_view(off_t start, off_t size, off_t *pbytes = NULL);
+
+ private:
+  // 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.
+  class View
+  {
+   public:
+    View(off_t start, off_t size, unsigned char* data)
+      : start_(start), size_(size), data_(data), lock_count_(0)
+    { }
+
+    ~View();
+
+    off_t
+    start() const
+    { return this->start_; }
+
+    off_t
+    size() const
+    { return this->size_; }
+
+    unsigned char*
+    data() const
+    { return this->data_; }
+
+    void
+    lock();
+
+    void
+    unlock();
+
+    bool
+    is_locked();
+
+   private:
+    View(const View&);
+    View& operator=(const View&);
+
+    off_t start_;
+    off_t size_;
+    unsigned char* data_;
+    int lock_count_;
+  };
+
+  friend class File_view;
+
+  View*
+  find_view(off_t start, off_t size);
+
+  off_t
+  do_read(off_t start, off_t size, void* p, off_t* pbytes);
+
+  View*
+  find_or_make_view(off_t start, off_t size, off_t* pbytes);
+
+  void
+  clear_views(bool);
+
+  std::string name_;
+  int descriptor_;
+  int lock_count_;
+  std::list<View*> view_list_;
+};
+
+// A view of file data that persists even when the file is unlocked.
+// Callers should destroy these when no longer required.  These are
+// obtained form File_read::get_lasting_view.  They may only be
+// destroyed when the underlying File_read is locked.
+
+class File_view
+{
+ public:
+  // This may only be called when the underlying File_read is locked.
+  ~File_view();
+
+  // Return a pointer to the data associated with this view.
+  const unsigned char*
+  data() const
+  { return this->data_; }
+
+ private:
+  File_view(const File_view&);
+  File_view& operator=(const File_view&);
+
+  friend class File_read;
+
+  // Callers have to get these via File_read::get_lasting_view.
+  File_view(File_read& file, File_read::View* view, const unsigned char* data)
+    : file_(file), view_(view), data_(data)
+  { }
+
+  File_read& file_;
+  File_read::View* view_;
+  const unsigned char* data_;
+};
+
+// An object which locks a file using RAII.
+
+class File_read_lock
+{
+ public:
+  File_read_lock(File_read& file)
+    : file_(file)
+  { this->file_.lock(); }
+
+  ~File_read_lock()
+  { this->file_.unlock(); }
+
+ private:
+  File_read& file_;
+};
+
+// All the information we hold for a single input file.  This can be
+// an object file, a shared library, or an archive.
+
+class Input_file
+{
+ public:
+  Input_file(const Input_argument& input_argument)
+    : input_argument_(input_argument)
+  { }
+
+  void
+  open(const General_options&, const Dirsearch&);
+
+  // Return the name given by the user.
+  const char*
+  name() const
+  { return this->input_argument_.name(); }
+
+  // Return the file name.
+  const std::string&
+  filename() const
+  { return this->file_.filename(); }
+
+  File_read&
+  file()
+  { return this->file_; }
+
+ private:
+  const Input_argument& input_argument_;
+  File_read file_;
+};
+
+} // end namespace gold
+
+#endif // !defined(GOLD_FILEREAD_H)