OpenCores
URL https://opencores.org/ocsvn/open8_urisc/open8_urisc/trunk

Subversion Repositories open8_urisc

[/] [open8_urisc/] [trunk/] [gnu/] [binutils/] [gold/] [fileread.h] - Blame information for rev 27

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 27 khays
// 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)

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.