Import binutils-2.20
[dragonfly.git] / contrib / binutils-2.20 / 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_(), contents_(NULL),
69       mapped_bytes_(0), released_(true)
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     View(off_t start, section_size_type size, const unsigned char* data,
238          unsigned int byteshift, bool cache, bool mapped)
239       : start_(start), size_(size), data_(data), lock_count_(0),
240         byteshift_(byteshift), cache_(cache), mapped_(mapped), accessed_(true)
241     { }
242
243     ~View();
244
245     off_t
246     start() const
247     { return this->start_; }
248
249     section_size_type
250     size() const
251     { return this->size_; }
252
253     const unsigned char*
254     data() const
255     { return this->data_; }
256
257     void
258     lock();
259
260     void
261     unlock();
262
263     bool
264     is_locked();
265
266     unsigned int
267     byteshift() const
268     { return this->byteshift_; }
269
270     void
271     set_cache()
272     { this->cache_ = true; }
273
274     void
275     clear_cache()
276     { this->cache_ = false; }
277
278     bool
279     should_cache() const
280     { return this->cache_; }
281
282     void
283     set_accessed()
284     { this->accessed_ = true; }
285
286     void
287     clear_accessed()
288     { this->accessed_= false; }
289
290     bool
291     accessed() const
292     { return this->accessed_; }
293
294    private:
295     View(const View&);
296     View& operator=(const View&);
297
298     // The file offset of the start of the view.
299     off_t start_;
300     // The size of the view.
301     section_size_type size_;
302     // A pointer to the actual bytes.
303     const unsigned char* data_;
304     // The number of locks on this view.
305     int lock_count_;
306     // The number of bytes that the view is shifted relative to the
307     // underlying file.  This is used to align data.  This is normally
308     // zero, except possibly for an object in an archive.
309     unsigned int byteshift_;
310     // Whether the view is cached.
311     bool cache_;
312     // Whether the view is mapped into memory.  If not, data_ points
313     // to memory allocated using new[].
314     bool mapped_;
315     // Whether the view has been accessed recently.
316     bool accessed_;
317   };
318
319   friend class View;
320   friend class File_view;
321
322   // The type of a mapping from page start and byte shift to views.
323   typedef std::map<std::pair<off_t, unsigned int>, View*> Views;
324
325   // A simple list of Views.
326   typedef std::list<View*> Saved_views;
327
328   // Open the descriptor if necessary.
329   void
330   reopen_descriptor();
331
332   // Find a view into the file.
333   View*
334   find_view(off_t start, section_size_type size, unsigned int byteshift,
335             View** vshifted) const;
336
337   // Read data from the file into a buffer.
338   void
339   do_read(off_t start, section_size_type size, void* p);
340
341   // Add a view.
342   void
343   add_view(View*);
344
345   // Make a view into the file.
346   View*
347   make_view(off_t start, section_size_type size, unsigned int byteshift,
348             bool cache);
349
350   // Find or make a view into the file.
351   View*
352   find_or_make_view(off_t offset, off_t start, section_size_type size,
353                     bool aligned, bool cache);
354
355   // Clear the file views.
356   void
357   clear_views(bool);
358
359   // The size of a file page for buffering data.
360   static const off_t page_size = 8192;
361
362   // Given a file offset, return the page offset.
363   static off_t
364   page_offset(off_t file_offset)
365   { return file_offset & ~ (page_size - 1); }
366
367   // Given a file size, return the size to read integral pages.
368   static off_t
369   pages(off_t file_size)
370   { return (file_size + (page_size - 1)) & ~ (page_size - 1); }
371
372   // The maximum number of entries we will pass to ::readv.
373 #ifdef HAVE_READV
374   static const size_t max_readv_entries = 128;
375 #else
376   // On targets that don't have readv set the max to 1 so readv is not
377   // used.
378   static const size_t max_readv_entries = 1;
379 #endif
380
381   // Use readv to read data.
382   void
383   do_readv(off_t base, const Read_multiple&, size_t start, size_t count);
384
385   // File name.
386   std::string name_;
387   // File descriptor.
388   int descriptor_;
389   // Whether we have regained the descriptor after releasing the file.
390   bool is_descriptor_opened_;
391   // The number of objects associated with this file.  This will be
392   // more than 1 in the case of an archive.
393   int object_count_;
394   // File size.
395   off_t size_;
396   // A token used to lock the file.
397   Task_token token_;
398   // Buffered views into the file.
399   Views views_;
400   // List of views which were locked but had to be removed from views_
401   // because they were not large enough.
402   Saved_views saved_views_;
403   // Specified file contents.  Used only for testing purposes.
404   const unsigned char* contents_;
405   // Total amount of space mapped into memory.  This is only changed
406   // while the file is locked.  When we unlock the file, we transfer
407   // the total to total_mapped_bytes, and reset this to zero.
408   size_t mapped_bytes_;
409   // Whether the file was released.
410   bool released_;
411 };
412
413 // A view of file data that persists even when the file is unlocked.
414 // Callers should destroy these when no longer required.  These are
415 // obtained form File_read::get_lasting_view.  They may only be
416 // destroyed when the underlying File_read is locked.
417
418 class File_view
419 {
420  public:
421   // This may only be called when the underlying File_read is locked.
422   ~File_view();
423
424   // Return a pointer to the data associated with this view.
425   const unsigned char*
426   data() const
427   { return this->data_; }
428
429  private:
430   File_view(const File_view&);
431   File_view& operator=(const File_view&);
432
433   friend class File_read;
434
435   // Callers have to get these via File_read::get_lasting_view.
436   File_view(File_read& file, File_read::View* view, const unsigned char* data)
437     : file_(file), view_(view), data_(data)
438   { }
439
440   File_read& file_;
441   File_read::View* view_;
442   const unsigned char* data_;
443 };
444
445 // All the information we hold for a single input file.  This can be
446 // an object file, a shared library, or an archive.
447
448 class Input_file
449 {
450  public:
451   Input_file(const Input_file_argument* input_argument)
452     : input_argument_(input_argument), found_name_(), file_(),
453       is_in_sysroot_(false)
454   { }
455
456   // Create an input file with the contents already provided.  This is
457   // only used for testing.  With this path, don't call the open
458   // method.
459   Input_file(const Task*, const char* name, const unsigned char* contents,
460              off_t size);
461
462   // Return the command line argument.
463   const Input_file_argument*
464   input_file_argument() const
465   { return this->input_argument_; }
466
467   // Return whether this is a file that we will search for in the list
468   // of directories.
469   bool
470   will_search_for() const;
471
472   // Open the file.  If the open fails, this will report an error and
473   // return false.  If there is a search, it starts at directory
474   // *PINDEX.  *PINDEX should be initialized to zero.  It may be
475   // restarted to find the next file with a matching name by
476   // incrementing the result and calling this again.
477   bool
478   open(const Dirsearch&, const Task*, int *pindex);
479
480   // Return the name given by the user.  For -lc this will return "c".
481   const char*
482   name() const;
483
484   // Return the file name.  For -lc this will return something like
485   // "/usr/lib/libc.so".
486   const std::string&
487   filename() const
488   { return this->file_.filename(); }
489
490   // Return the name under which we found the file, corresponding to
491   // the command line.  For -lc this will return something like
492   // "libc.so".
493   const std::string&
494   found_name() const
495   { return this->found_name_; }
496
497   // Return the position dependent options.
498   const Position_dependent_options&
499   options() const;
500
501   // Return the file.
502   File_read&
503   file()
504   { return this->file_; }
505
506   const File_read&
507   file() const
508   { return this->file_; }
509
510   // Whether we found the file in a directory in the system root.
511   bool
512   is_in_sysroot() const
513   { return this->is_in_sysroot_; }
514
515   // Whether this file is in a system directory.
516   bool
517   is_in_system_directory() const;
518
519   // Return whether this file is to be read only for its symbols.
520   bool
521   just_symbols() const;
522
523  private:
524   Input_file(const Input_file&);
525   Input_file& operator=(const Input_file&);
526
527   // Open a binary file.
528   bool
529   open_binary(const Task* task, const std::string& name);
530
531   // The argument from the command line.
532   const Input_file_argument* input_argument_;
533   // The name under which we opened the file.  This is like the name
534   // on the command line, but -lc turns into libc.so (or whatever).
535   // It only includes the full path if the path was on the command
536   // line.
537   std::string found_name_;
538   // The file after we open it.
539   File_read file_;
540   // Whether we found the file in a directory in the system root.
541   bool is_in_sysroot_;
542 };
543
544 } // end namespace gold
545
546 #endif // !defined(GOLD_FILEREAD_H)