gold/fileread.h

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