1 // fileread.h -- read files for gold -*- C++ -*-
3 // Copyright 2006, 2007 Free Software Foundation, Inc.
4 // Written by Ian Lance Taylor <iant@google.com>.
6 // This file is part of gold.
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.
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.
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.
23 // Classes used to read data from binary input files.
25 #ifndef GOLD_FILEREAD_H
26 #define GOLD_FILEREAD_H
41 // File_read manages a file descriptor for a file we are reading. We
42 // close file descriptors if we run out of them, so this class reopens
43 // the file as needed.
49 : name_(), descriptor_(-1), object_count_(0), size_(0), token_(false),
50 views_(), saved_views_(), contents_(NULL
), mapped_bytes_(0),
58 open(const Task
*, const std::string
& name
);
60 // Pretend to open the file, but provide the file contents. No
61 // actual file system activity will occur. This is used for
64 open(const Task
*, const std::string
& name
, const unsigned char* contents
,
67 // Return the file name.
70 { return this->name_
; }
72 // Add an object associated with a file.
75 { ++this->object_count_
; }
77 // Remove an object associated with a file.
80 { --this->object_count_
; }
82 // Lock the file for exclusive access within a particular Task::run
83 // execution. This means that the descriptor can not be closed.
84 // This routine may only be called when the workqueue lock is held.
88 // Unlock the descriptor, permitting it to be closed if necessary.
90 unlock(const Task
* t
);
92 // Test whether the object is locked.
96 // Return the token, so that the task can be queued.
99 { return &this->token_
; }
101 // Release the file. This indicates that we aren't going to do
102 // anything further with it until it is unlocked. This is used
103 // because a Task which locks the file never calls either lock or
104 // unlock; it just locks the token. The basic rule is that a Task
105 // which locks a file via the Task::locks interface must explicitly
106 // call release() when it is done. This is not necessary for code
107 // which calls unlock() on the file.
111 // Return the size of the file.
114 { return this->size_
; }
116 // Return a view into the file starting at file offset START for
117 // SIZE bytes. The pointer will remain valid until the File_read is
118 // unlocked. It is an error if we can not read enough data from the
119 // file. The CACHE parameter is a hint as to whether it will be
120 // useful to cache this data for later accesses--i.e., later calls
121 // to get_view, read, or get_lasting_view which retrieve the same
124 get_view(off_t start
, section_size_type size
, bool cache
);
126 // Read data from the file into the buffer P starting at file offset
127 // START for SIZE bytes.
129 read(off_t start
, section_size_type size
, void* p
) const;
131 // Return a lasting view into the file starting at file offset START
132 // for SIZE bytes. This is allocated with new, and the caller is
133 // responsible for deleting it when done. The data associated with
134 // this view will remain valid until the view is deleted. It is an
135 // error if we can not read enough data from the file. The CACHE
136 // parameter is as in get_view.
138 get_lasting_view(off_t start
, section_size_type size
, bool cache
);
140 // Mark all views as no longer cached.
142 clear_view_cache_marks();
144 // A struct used to do a multiple read.
145 struct Read_multiple_entry
147 // The file offset of the data to read.
149 // The amount of data to read.
150 section_size_type size
;
151 // The buffer where the data should be placed.
152 unsigned char* buffer
;
154 Read_multiple_entry(off_t o
, section_size_type s
, unsigned char* b
)
155 : file_offset(o
), size(s
), buffer(b
)
159 typedef std::vector
<Read_multiple_entry
> Read_multiple
;
161 // Read a bunch of data from the file into various different
162 // locations. The vector must be sorted by ascending file_offset.
163 // BASE is a base offset to be added to all the offsets in the
166 read_multiple(off_t base
, const Read_multiple
&);
168 // Dump statistical information to stderr.
173 // This class may not be copied.
174 File_read(const File_read
&);
175 File_read
& operator=(const File_read
&);
177 // Total bytes mapped into memory during the link. This variable
178 // may not be accurate when running multi-threaded.
179 static unsigned long long total_mapped_bytes
;
181 // Current number of bytes mapped into memory during the link. This
182 // variable may not be accurate when running multi-threaded.
183 static unsigned long long current_mapped_bytes
;
185 // High water mark of bytes mapped into memory during the link.
186 // This variable may not be accurate when running multi-threaded.
187 static unsigned long long maximum_mapped_bytes
;
189 // A view into the file.
193 View(off_t start
, section_size_type size
, const unsigned char* data
,
194 bool cache
, bool mapped
)
195 : start_(start
), size_(size
), data_(data
), lock_count_(0),
196 cache_(cache
), mapped_(mapped
), accessed_(true)
203 { return this->start_
; }
207 { return this->size_
; }
211 { return this->data_
; }
224 { this->cache_
= true; }
228 { this->cache_
= false; }
232 { return this->cache_
; }
236 { this->accessed_
= true; }
240 { this->accessed_
= false; }
244 { return this->accessed_
; }
248 View
& operator=(const View
&);
251 section_size_type size_
;
252 const unsigned char* data_
;
260 friend class File_view
;
262 // Find a view into the file.
264 find_view(off_t start
, section_size_type size
) const;
266 // Read data from the file into a buffer.
268 do_read(off_t start
, section_size_type size
, void* p
) const;
270 // Find or make a view into the file.
272 find_or_make_view(off_t start
, section_size_type size
, bool cache
);
274 // Clear the file views.
278 // The size of a file page for buffering data.
279 static const off_t page_size
= 8192;
281 // Given a file offset, return the page offset.
283 page_offset(off_t file_offset
)
284 { return file_offset
& ~ (page_size
- 1); }
286 // Given a file size, return the size to read integral pages.
288 pages(off_t file_size
)
289 { return (file_size
+ (page_size
- 1)) & ~ (page_size
- 1); }
291 // The type of a mapping from page start to views.
292 typedef std::map
<off_t
, View
*> Views
;
294 // A simple list of Views.
295 typedef std::list
<View
*> Saved_views
;
297 // The maximum number of entries we will pass to ::readv.
298 static const size_t max_readv_entries
= 128;
300 // Use readv to read data.
302 do_readv(off_t base
, const Read_multiple
&, size_t start
, size_t count
);
308 // The number of objects associated with this file. This will be
309 // more than 1 in the case of an archive.
313 // A token used to lock the file.
315 // Buffered views into the file.
317 // List of views which were locked but had to be removed from views_
318 // because they were not large enough.
319 Saved_views saved_views_
;
320 // Specified file contents. Used only for testing purposes.
321 const unsigned char* contents_
;
322 // Total amount of space mapped into memory. This is only changed
323 // while the file is locked. When we unlock the file, we transfer
324 // the total to total_mapped_bytes, and reset this to zero.
325 size_t mapped_bytes_
;
326 // Whether the file was released.
330 // A view of file data that persists even when the file is unlocked.
331 // Callers should destroy these when no longer required. These are
332 // obtained form File_read::get_lasting_view. They may only be
333 // destroyed when the underlying File_read is locked.
338 // This may only be called when the underlying File_read is locked.
341 // Return a pointer to the data associated with this view.
344 { return this->data_
; }
347 File_view(const File_view
&);
348 File_view
& operator=(const File_view
&);
350 friend class File_read
;
352 // Callers have to get these via File_read::get_lasting_view.
353 File_view(File_read
& file
, File_read::View
* view
, const unsigned char* data
)
354 : file_(file
), view_(view
), data_(data
)
358 File_read::View
* view_
;
359 const unsigned char* data_
;
362 // All the information we hold for a single input file. This can be
363 // an object file, a shared library, or an archive.
368 Input_file(const Input_file_argument
* input_argument
)
369 : input_argument_(input_argument
), found_name_(), file_(),
370 is_in_sysroot_(false)
373 // Create an input file with the contents already provided. This is
374 // only used for testing. With this path, don't call the open
376 Input_file(const Task
*, const char* name
, const unsigned char* contents
,
379 // Open the file. If the open fails, this will report an error and
382 open(const General_options
&, const Dirsearch
&, const Task
*);
384 // Return the name given by the user. For -lc this will return "c".
387 { return this->input_argument_
->name(); }
389 // Return the file name. For -lc this will return something like
390 // "/usr/lib/libc.so".
393 { return this->file_
.filename(); }
395 // Return the name under which we found the file, corresponding to
396 // the command line. For -lc this will return something like
400 { return this->found_name_
; }
402 // Return the position dependent options.
403 const Position_dependent_options
&
405 { return this->input_argument_
->options(); }
410 { return this->file_
; }
414 { return this->file_
; }
416 // Whether we found the file in a directory in the system root.
418 is_in_sysroot() const
419 { return this->is_in_sysroot_
; }
422 Input_file(const Input_file
&);
423 Input_file
& operator=(const Input_file
&);
425 // The argument from the command line.
426 const Input_file_argument
* input_argument_
;
427 // The name under which we opened the file. This is like the name
428 // on the command line, but -lc turns into libc.so (or whatever).
429 // It only includes the full path if the path was on the command
431 std::string found_name_
;
432 // The file after we open it.
434 // Whether we found the file in a directory in the system root.
438 } // end namespace gold
440 #endif // !defined(GOLD_FILEREAD_H)