Add const to Object::read and Object::sized_target.
[deliverable/binutils-gdb.git] / gold / fileread.h
1 // fileread.h -- read files for gold -*- C++ -*-
2
3 // Copyright 2006, 2007 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
32 #include "options.h"
33
34 namespace gold
35 {
36
37 class Dirsearch;
38 class File_view;
39
40 // File_read manages a file descriptor for a file we are reading. We
41 // close file descriptors if we run out of them, so this class reopens
42 // the file as needed.
43
44 class File_read
45 {
46 public:
47 File_read()
48 : name_(), descriptor_(-1), size_(0), lock_count_(0), views_(),
49 saved_views_(), contents_(NULL), mapped_bytes_(0)
50 { }
51
52 ~File_read();
53
54 // Open a file.
55 bool
56 open(const std::string& name);
57
58 // Pretend to open the file, but provide the file contents. No
59 // actual file system activity will occur. This is used for
60 // testing.
61 bool
62 open(const std::string& name, const unsigned char* contents, off_t size);
63
64 // Return the file name.
65 const std::string&
66 filename() const
67 { return this->name_; }
68
69 // Lock the file for access within a particular Task::run execution.
70 // This means that the descriptor can not be closed. This routine
71 // may only be called from the main thread.
72 void
73 lock();
74
75 // Unlock the descriptor, permitting it to be closed if necessary.
76 void
77 unlock();
78
79 // Test whether the object is locked.
80 bool
81 is_locked() const;
82
83 // Return the size of the file.
84 off_t
85 filesize() const
86 { return this->size_; }
87
88 // Return a view into the file starting at file offset START for
89 // SIZE bytes. The pointer will remain valid until the File_read is
90 // unlocked. It is an error if we can not read enough data from the
91 // file. The CACHE parameter is a hint as to whether it will be
92 // useful to cache this data for later accesses--i.e., later calls
93 // to get_view, read, or get_lasting_view which retrieve the same
94 // data.
95 const unsigned char*
96 get_view(off_t start, off_t size, bool cache);
97
98 // Read data from the file into the buffer P starting at file offset
99 // START for SIZE bytes.
100 void
101 read(off_t start, off_t size, void* p) const;
102
103 // Return a lasting view into the file starting at file offset START
104 // for SIZE bytes. This is allocated with new, and the caller is
105 // responsible for deleting it when done. The data associated with
106 // this view will remain valid until the view is deleted. It is an
107 // error if we can not read enough data from the file. The CACHE
108 // parameter is as in get_view.
109 File_view*
110 get_lasting_view(off_t start, off_t size, bool cache);
111
112 // Dump statistical information to stderr.
113 static void
114 print_stats();
115
116 private:
117 // This class may not be copied.
118 File_read(const File_read&);
119 File_read& operator=(const File_read&);
120
121 // Total bytes mapped into memory during the link. This variable is
122 // only accessed from the main thread, when unlocking the object.
123 static unsigned long long total_mapped_bytes;
124
125 // Current number of bytes mapped into memory during the link. This
126 // variable is only accessed from the main thread.
127 static unsigned long long current_mapped_bytes;
128
129 // High water mark of bytes mapped into memory during the link.
130 // This variable is only accessed from the main thread.
131 static unsigned long long maximum_mapped_bytes;
132
133 // A view into the file.
134 class View
135 {
136 public:
137 View(off_t start, off_t size, const unsigned char* data, bool cache,
138 bool mapped)
139 : start_(start), size_(size), data_(data), lock_count_(0),
140 cache_(cache), mapped_(mapped)
141 { }
142
143 ~View();
144
145 off_t
146 start() const
147 { return this->start_; }
148
149 off_t
150 size() const
151 { return this->size_; }
152
153 const unsigned char*
154 data() const
155 { return this->data_; }
156
157 void
158 lock();
159
160 void
161 unlock();
162
163 bool
164 is_locked();
165
166 void
167 set_cache()
168 { this->cache_ = true; }
169
170 bool
171 should_cache() const
172 { return this->cache_; }
173
174 private:
175 View(const View&);
176 View& operator=(const View&);
177
178 off_t start_;
179 off_t size_;
180 const unsigned char* data_;
181 int lock_count_;
182 bool cache_;
183 bool mapped_;
184 };
185
186 friend class View;
187 friend class File_view;
188
189 // Find a view into the file.
190 View*
191 find_view(off_t start, off_t size) const;
192
193 // Read data from the file into a buffer.
194 void
195 do_read(off_t start, off_t size, void* p) const;
196
197 // Find or make a view into the file.
198 View*
199 find_or_make_view(off_t start, off_t size, bool cache);
200
201 // Clear the file views.
202 void
203 clear_views(bool);
204
205 // The size of a file page for buffering data.
206 static const off_t page_size = 8192;
207
208 // Given a file offset, return the page offset.
209 static off_t
210 page_offset(off_t file_offset)
211 { return file_offset & ~ (page_size - 1); }
212
213 // Given a file size, return the size to read integral pages.
214 static off_t
215 pages(off_t file_size)
216 { return (file_size + (page_size - 1)) & ~ (page_size - 1); }
217
218 // The type of a mapping from page start to views.
219 typedef std::map<off_t, View*> Views;
220
221 // A simple list of Views.
222 typedef std::list<View*> Saved_views;
223
224 // File name.
225 std::string name_;
226 // File descriptor.
227 int descriptor_;
228 // File size.
229 off_t size_;
230 // Number of locks on the file.
231 int lock_count_;
232 // Buffered views into the file.
233 Views views_;
234 // List of views which were locked but had to be removed from views_
235 // because they were not large enough.
236 Saved_views saved_views_;
237 // Specified file contents. Used only for testing purposes.
238 const unsigned char* contents_;
239 // Total amount of space mapped into memory. This is only changed
240 // while the file is locked. When we unlock the file, we transfer
241 // the total to total_mapped_bytes, and reset this to zero.
242 size_t mapped_bytes_;
243 };
244
245 // A view of file data that persists even when the file is unlocked.
246 // Callers should destroy these when no longer required. These are
247 // obtained form File_read::get_lasting_view. They may only be
248 // destroyed when the underlying File_read is locked.
249
250 class File_view
251 {
252 public:
253 // This may only be called when the underlying File_read is locked.
254 ~File_view();
255
256 // Return a pointer to the data associated with this view.
257 const unsigned char*
258 data() const
259 { return this->data_; }
260
261 private:
262 File_view(const File_view&);
263 File_view& operator=(const File_view&);
264
265 friend class File_read;
266
267 // Callers have to get these via File_read::get_lasting_view.
268 File_view(File_read& file, File_read::View* view, const unsigned char* data)
269 : file_(file), view_(view), data_(data)
270 { }
271
272 File_read& file_;
273 File_read::View* view_;
274 const unsigned char* data_;
275 };
276
277 // All the information we hold for a single input file. This can be
278 // an object file, a shared library, or an archive.
279
280 class Input_file
281 {
282 public:
283 Input_file(const Input_file_argument* input_argument)
284 : input_argument_(input_argument), found_name_(), file_(),
285 is_in_sysroot_(false)
286 { }
287
288 // Create an input file with the contents already provided. This is
289 // only used for testing. With this path, don't call the open
290 // method.
291 Input_file(const char* name, const unsigned char* contents, off_t size);
292
293 // Open the file. If the open fails, this will report an error and
294 // return false.
295 bool
296 open(const General_options&, const Dirsearch&);
297
298 // Return the name given by the user. For -lc this will return "c".
299 const char*
300 name() const
301 { return this->input_argument_->name(); }
302
303 // Return the file name. For -lc this will return something like
304 // "/usr/lib/libc.so".
305 const std::string&
306 filename() const
307 { return this->file_.filename(); }
308
309 // Return the name under which we found the file, corresponding to
310 // the command line. For -lc this will return something like
311 // "libc.so".
312 const std::string&
313 found_name() const
314 { return this->found_name_; }
315
316 // Return the position dependent options.
317 const Position_dependent_options&
318 options() const
319 { return this->input_argument_->options(); }
320
321 // Return the file.
322 File_read&
323 file()
324 { return this->file_; }
325
326 const File_read&
327 file() const
328 { return this->file_; }
329
330 // Whether we found the file in a directory in the system root.
331 bool
332 is_in_sysroot() const
333 { return this->is_in_sysroot_; }
334
335 private:
336 Input_file(const Input_file&);
337 Input_file& operator=(const Input_file&);
338
339 // The argument from the command line.
340 const Input_file_argument* input_argument_;
341 // The name under which we opened the file. This is like the name
342 // on the command line, but -lc turns into libc.so (or whatever).
343 // It only includes the full path if the path was on the command
344 // line.
345 std::string found_name_;
346 // The file after we open it.
347 File_read file_;
348 // Whether we found the file in a directory in the system root.
349 bool is_in_sysroot_;
350 };
351
352 } // end namespace gold
353
354 #endif // !defined(GOLD_FILEREAD_H)
This page took 0.04118 seconds and 5 git commands to generate.