gold/fileread.h

   1 // fileread.h -- read files for gold   -*- C++ -*-
   2
   3 // Copyright 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
   4 // Written by Ian Lance Taylor <iant@google.com>.
   5
   6 // This file is part of gold.
   7
   8 // This program is free software; you can redistribute it and/or modify
   9 // it under the terms of the GNU General Public License as published by
  10 // the Free Software Foundation; either version 3 of the License, or
  11 // (at your option) any later version.
  12
  13 // This program is distributed in the hope that it will be useful,
  14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 // GNU General Public License for more details.
  17
  18 // You should have received a copy of the GNU General Public License
  19 // along with this program; if not, write to the Free Software
  20 // Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  21 // MA 02110-1301, USA.
  22
  23 // Classes used to read data from binary input files.
  24
  25 #ifndef GOLD_FILEREAD_H
  26 #define GOLD_FILEREAD_H
  27
  28 #include <list>
  29 #include <map>
  30 #include <string>
  31 #include <vector>
  32
  33 #include "token.h"
  34
  35 namespace gold
  36 {
  37
  38 // Since not all system supports stat.st_mtim and struct timespec,
  39 // we define our own structure and fill the nanoseconds if we can.
  40
  41 struct Timespec
  42 {
  43   Timespec()
  44     : seconds(0), nanoseconds(0)
  45   { }
  46
  47   Timespec(time_t a_seconds, int a_nanoseconds)
  48     : seconds(a_seconds), nanoseconds(a_nanoseconds)
  49   { }
  50
  51   time_t seconds;
  52   int nanoseconds;
  53 };
  54
  55 class Position_dependent_options;
  56 class Input_file_argument;
  57 class Dirsearch;
  58 class File_view;
  59
  60 // File_read manages a file descriptor and mappings for a file we are
  61 // reading.
  62
  63 class File_read
  64 {
  65  public:
  66   File_read()
  67     : name_(), descriptor_(-1), is_descriptor_opened_(false), object_count_(0),
  68       size_(0), token_(false), views_(), saved_views_(), mapped_bytes_(0),
  69       released_(true), whole_file_view_(NULL)
  70   { }
  71
  72   ~File_read();
  73
  74   // Open a file.
  75   bool
  76   open(const Task*, const std::string& name);
  77
  78   // Pretend to open the file, but provide the file contents.  No
  79   // actual file system activity will occur.  This is used for
  80   // testing.
  81   bool
  82   open(const Task*, const std::string& name, const unsigned char* contents,
  83        off_t size);
  84
  85   // Return the file name.
  86   const std::string&
  87   filename() const
  88   { return this->name_; }
  89
  90   // Add an object associated with a file.
  91   void
  92   add_object()
  93   { ++this->object_count_; }
  94
  95   // Remove an object associated with a file.
  96   void
  97   remove_object()
  98   { --this->object_count_; }
  99
 100   // Lock the file for exclusive access within a particular Task::run
 101   // execution.  This routine may only be called when the workqueue
 102   // lock is held.
 103   void
 104   lock(const Task* t);
 105
 106   // Unlock the file.
 107   void
 108   unlock(const Task* t);
 109
 110   // Test whether the object is locked.
 111   bool
 112   is_locked() const;
 113
 114   // Return the token, so that the task can be queued.
 115   Task_token*
 116   token()
 117   { return &this->token_; }
 118
 119   // Release the file.  This indicates that we aren't going to do
 120   // anything further with it until it is unlocked.  This is used
 121   // because a Task which locks the file never calls either lock or
 122   // unlock; it just locks the token.  The basic rule is that a Task
 123   // which locks a file via the Task::locks interface must explicitly
 124   // call release() when it is done.  This is not necessary for code
 125   // which calls unlock() on the file.
 126   void
 127   release();
 128
 129   // Return the size of the file.
 130   off_t
 131   filesize() const
 132   { return this->size_; }
 133
 134   // Return a view into the file starting at file offset START for
 135   // SIZE bytes.  OFFSET is the offset into the input file for the
 136   // file we are reading; this is zero for a normal object file,
 137   // non-zero for an object file in an archive.  ALIGNED is true if
 138   // the data must be naturally aligned; this only matters when OFFSET
 139   // is not zero.  The pointer will remain valid until the File_read
 140   // is unlocked.  It is an error if we can not read enough data from
 141   // the file.  The CACHE parameter is a hint as to whether it will be
 142   // useful to cache this data for later accesses--i.e., later calls
 143   // to get_view, read, or get_lasting_view which retrieve the same
 144   // data.
 145   const unsigned char*
 146   get_view(off_t offset, off_t start, section_size_type size, bool aligned,
 147            bool cache);
 148
 149   // Read data from the file into the buffer P starting at file offset
 150   // START for SIZE bytes.
 151   void
 152   read(off_t start, section_size_type size, void* p);
 153
 154   // Return a lasting view into the file starting at file offset START
 155   // for SIZE bytes.  This is allocated with new, and the caller is
 156   // responsible for deleting it when done.  The data associated with
 157   // this view will remain valid until the view is deleted.  It is an
 158   // error if we can not read enough data from the file.  The OFFSET,
 159   // ALIGNED and CACHE parameters are as in get_view.
 160   File_view*
 161   get_lasting_view(off_t offset, off_t start, section_size_type size,
 162                    bool aligned, bool cache);
 163
 164   // Mark all views as no longer cached.
 165   void
 166   clear_view_cache_marks();
 167
 168   // Discard all uncached views.  This is normally done by release(),
 169   // but not for objects in archives.  FIXME: This is a complicated
 170   // interface, and it would be nice to have something more automatic.
 171   void
 172   clear_uncached_views()
 173   { this->clear_views(false); }
 174
 175   // A struct used to do a multiple read.
 176   struct Read_multiple_entry
 177   {
 178     // The file offset of the data to read.
 179     off_t file_offset;
 180     // The amount of data to read.
 181     section_size_type size;
 182     // The buffer where the data should be placed.
 183     unsigned char* buffer;
 184
 185     Read_multiple_entry(off_t o, section_size_type s, unsigned char* b)
 186       : file_offset(o), size(s), buffer(b)
 187     { }
 188   };
 189
 190   typedef std::vector<Read_multiple_entry> Read_multiple;
 191
 192   // Read a bunch of data from the file into various different
 193   // locations.  The vector must be sorted by ascending file_offset.
 194   // BASE is a base offset to be added to all the offsets in the
 195   // vector.
 196   void
 197   read_multiple(off_t base, const Read_multiple&);
 198
 199   // Dump statistical information to stderr.
 200   static void
 201   print_stats();
 202
 203   // Return the open file descriptor (for plugins).
 204   int
 205   descriptor()
 206   {
 207     this->reopen_descriptor();
 208     return this->descriptor_;
 209   }
 210
 211   // Return the file last modification time.  Calls gold_fatal if the stat
 212   // system call failed.
 213   Timespec
 214   get_mtime();
 215
 216  private:
 217   // This class may not be copied.
 218   File_read(const File_read&);
 219   File_read& operator=(const File_read&);
 220
 221   // Total bytes mapped into memory during the link.  This variable
 222   // may not be accurate when running multi-threaded.
 223   static unsigned long long total_mapped_bytes;
 224
 225   // Current number of bytes mapped into memory during the link.  This
 226   // variable may not be accurate when running multi-threaded.
 227   static unsigned long long current_mapped_bytes;
 228
 229   // High water mark of bytes mapped into memory during the link.
 230   // This variable may not be accurate when running multi-threaded.
 231   static unsigned long long maximum_mapped_bytes;
 232
 233   // A view into the file.
 234   class View
 235   {
 236    public:
 237     // Specifies how to dispose the data on destruction of the view.
 238     enum Data_ownership
 239     {
 240       // Data owned by File object - nothing done in destructor.
 241       DATA_NOT_OWNED,
 242       // Data alocated with new[] and owned by this object - should
 243       // use delete[].
 244       DATA_ALLOCATED_ARRAY,
 245       // Data mmapped and owned by this object - should munmap.
 246       DATA_MMAPPED
 247     };
 248
 249     View(off_t start, section_size_type size, const unsigned char* data,
 250          unsigned int byteshift, bool cache, Data_ownership data_ownership)
 251       : start_(start), size_(size), data_(data), lock_count_(0),
 252         byteshift_(byteshift), cache_(cache), data_ownership_(data_ownership),
 253         accessed_(true)
 254     { }
 255
 256     ~View();
 257
 258     off_t
 259     start() const
 260     { return this->start_; }
 261
 262     section_size_type
 263     size() const
 264     { return this->size_; }
 265
 266     const unsigned char*
 267     data() const
 268     { return this->data_; }
 269
 270     void
 271     lock();
 272
 273     void
 274     unlock();
 275
 276     bool
 277     is_locked();
 278
 279     unsigned int
 280     byteshift() const
 281     { return this->byteshift_; }
 282
 283     void
 284     set_cache()
 285     { this->cache_ = true; }
 286
 287     void
 288     clear_cache()
 289     { this->cache_ = false; }
 290
 291     bool
 292     should_cache() const
 293     { return this->cache_; }
 294
 295     void
 296     set_accessed()
 297     { this->accessed_ = true; }
 298
 299     void
 300     clear_accessed()
 301     { this->accessed_= false; }
 302
 303     bool
 304     accessed() const
 305     { return this->accessed_; }
 306
 307    private:
 308     View(const View&);
 309     View& operator=(const View&);
 310
 311     // The file offset of the start of the view.
 312     off_t start_;
 313     // The size of the view.
 314     section_size_type size_;
 315     // A pointer to the actual bytes.
 316     const unsigned char* data_;
 317     // The number of locks on this view.
 318     int lock_count_;
 319     // The number of bytes that the view is shifted relative to the
 320     // underlying file.  This is used to align data.  This is normally
 321     // zero, except possibly for an object in an archive.
 322     unsigned int byteshift_;
 323     // Whether the view is cached.
 324     bool cache_;
 325     // Whether the view is mapped into memory.  If not, data_ points
 326     // to memory allocated using new[].
 327     Data_ownership data_ownership_;
 328     // Whether the view has been accessed recently.
 329     bool accessed_;
 330   };
 331
 332   friend class View;
 333   friend class File_view;
 334
 335   // The type of a mapping from page start and byte shift to views.
 336   typedef std::map<std::pair<off_t, unsigned int>, View*> Views;
 337
 338   // A simple list of Views.
 339   typedef std::list<View*> Saved_views;
 340
 341   // Open the descriptor if necessary.
 342   void
 343   reopen_descriptor();
 344
 345   // Find a view into the file.
 346   View*
 347   find_view(off_t start, section_size_type size, unsigned int byteshift,
 348             View** vshifted) const;
 349
 350   // Read data from the file into a buffer.
 351   void
 352   do_read(off_t start, section_size_type size, void* p);
 353
 354   // Add a view.
 355   void
 356   add_view(View*);
 357
 358   // Make a view into the file.
 359   View*
 360   make_view(off_t start, section_size_type size, unsigned int byteshift,
 361             bool cache);
 362
 363   // Find or make a view into the file.
 364   View*
 365   find_or_make_view(off_t offset, off_t start, section_size_type size,
 366                     bool aligned, bool cache);
 367
 368   // Clear the file views.
 369   void
 370   clear_views(bool);
 371
 372   // The size of a file page for buffering data.
 373   static const off_t page_size = 8192;
 374
 375   // Given a file offset, return the page offset.
 376   static off_t
 377   page_offset(off_t file_offset)
 378   { return file_offset & ~ (page_size - 1); }
 379
 380   // Given a file size, return the size to read integral pages.
 381   static off_t
 382   pages(off_t file_size)
 383   { return (file_size + (page_size - 1)) & ~ (page_size - 1); }
 384
 385   // The maximum number of entries we will pass to ::readv.
 386 #ifdef HAVE_READV
 387   static const size_t max_readv_entries = 128;
 388 #else
 389   // On targets that don't have readv set the max to 1 so readv is not
 390   // used.
 391   static const size_t max_readv_entries = 1;
 392 #endif
 393
 394   // Use readv to read data.
 395   void
 396   do_readv(off_t base, const Read_multiple&, size_t start, size_t count);
 397
 398   // File name.
 399   std::string name_;
 400   // File descriptor.
 401   int descriptor_;
 402   // Whether we have regained the descriptor after releasing the file.
 403   bool is_descriptor_opened_;
 404   // The number of objects associated with this file.  This will be
 405   // more than 1 in the case of an archive.
 406   int object_count_;
 407   // File size.
 408   off_t size_;
 409   // A token used to lock the file.
 410   Task_token token_;
 411   // Buffered views into the file.
 412   Views views_;
 413   // List of views which were locked but had to be removed from views_
 414   // because they were not large enough.
 415   Saved_views saved_views_;
 416   // Total amount of space mapped into memory.  This is only changed
 417   // while the file is locked.  When we unlock the file, we transfer
 418   // the total to total_mapped_bytes, and reset this to zero.
 419   size_t mapped_bytes_;
 420   // Whether the file was released.
 421   bool released_;
 422   // A view containing the whole file.  May be NULL if we mmap only
 423   // the relevant parts of the file.  Not NULL if:
 424   // - Flag --mmap_whole_files is set (default on 64-bit hosts).
 425   // - The contents was specified in the constructor.  Used only for
 426   //   testing purposes).
 427   View* whole_file_view_;
 428 };
 429
 430 // A view of file data that persists even when the file is unlocked.
 431 // Callers should destroy these when no longer required.  These are
 432 // obtained form File_read::get_lasting_view.  They may only be
 433 // destroyed when the underlying File_read is locked.
 434
 435 class File_view
 436 {
 437  public:
 438   // This may only be called when the underlying File_read is locked.
 439   ~File_view();
 440
 441   // Return a pointer to the data associated with this view.
 442   const unsigned char*
 443   data() const
 444   { return this->data_; }
 445
 446  private:
 447   File_view(const File_view&);
 448   File_view& operator=(const File_view&);
 449
 450   friend class File_read;
 451
 452   // Callers have to get these via File_read::get_lasting_view.
 453   File_view(File_read& file, File_read::View* view, const unsigned char* data)
 454     : file_(file), view_(view), data_(data)
 455   { }
 456
 457   File_read& file_;
 458   File_read::View* view_;
 459   const unsigned char* data_;
 460 };
 461
 462 // All the information we hold for a single input file.  This can be
 463 // an object file, a shared library, or an archive.
 464
 465 class Input_file
 466 {
 467  public:
 468   Input_file(const Input_file_argument* input_argument)
 469     : input_argument_(input_argument), found_name_(), file_(),
 470       is_in_sysroot_(false)
 471   { }
 472
 473   // Create an input file with the contents already provided.  This is
 474   // only used for testing.  With this path, don't call the open
 475   // method.
 476   Input_file(const Task*, const char* name, const unsigned char* contents,
 477              off_t size);
 478
 479   // Return the command line argument.
 480   const Input_file_argument*
 481   input_file_argument() const
 482   { return this->input_argument_; }
 483
 484   // Return whether this is a file that we will search for in the list
 485   // of directories.
 486   bool
 487   will_search_for() const;
 488
 489   // Open the file.  If the open fails, this will report an error and
 490   // return false.  If there is a search, it starts at directory
 491   // *PINDEX.  *PINDEX should be initialized to zero.  It may be
 492   // restarted to find the next file with a matching name by
 493   // incrementing the result and calling this again.
 494   bool
 495   open(const Dirsearch&, const Task*, int *pindex);
 496
 497   // Return the name given by the user.  For -lc this will return "c".
 498   const char*
 499   name() const;
 500
 501   // Return the file name.  For -lc this will return something like
 502   // "/usr/lib/libc.so".
 503   const std::string&
 504   filename() const
 505   { return this->file_.filename(); }
 506
 507   // Return the name under which we found the file, corresponding to
 508   // the command line.  For -lc this will return something like
 509   // "libc.so".
 510   const std::string&
 511   found_name() const
 512   { return this->found_name_; }
 513
 514   // Return the position dependent options.
 515   const Position_dependent_options&
 516   options() const;
 517
 518   // Return the file.
 519   File_read&
 520   file()
 521   { return this->file_; }
 522
 523   const File_read&
 524   file() const
 525   { return this->file_; }
 526
 527   // Whether we found the file in a directory in the system root.
 528   bool
 529   is_in_sysroot() const
 530   { return this->is_in_sysroot_; }
 531
 532   // Whether this file is in a system directory.
 533   bool
 534   is_in_system_directory() const;
 535
 536   // Return whether this file is to be read only for its symbols.
 537   bool
 538   just_symbols() const;
 539
 540  private:
 541   Input_file(const Input_file&);
 542   Input_file& operator=(const Input_file&);
 543
 544   // Open a binary file.
 545   bool
 546   open_binary(const Task* task, const std::string& name);
 547
 548   // The argument from the command line.
 549   const Input_file_argument* input_argument_;
 550   // The name under which we opened the file.  This is like the name
 551   // on the command line, but -lc turns into libc.so (or whatever).
 552   // It only includes the full path if the path was on the command
 553   // line.
 554   std::string found_name_;
 555   // The file after we open it.
 556   File_read file_;
 557   // Whether we found the file in a directory in the system root.
 558   bool is_in_sysroot_;
 559 };
 560
 561 } // end namespace gold
 562
 563 #endif // !defined(GOLD_FILEREAD_H)