gold/fileread.h

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