Commit | Line | Data |
---|---|---|
bae7f79e ILT |
1 | // fileread.cc -- read files for gold |
2 | ||
6cb15b7f ILT |
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 | ||
bae7f79e ILT |
23 | #include "gold.h" |
24 | ||
bae7f79e ILT |
25 | #include <cstring> |
26 | #include <cerrno> | |
27 | #include <fcntl.h> | |
28 | #include <unistd.h> | |
d1038c21 | 29 | #include <sys/mman.h> |
51dee2fe | 30 | #include "filenames.h" |
bae7f79e ILT |
31 | |
32 | #include "options.h" | |
33 | #include "dirsearch.h" | |
34 | #include "fileread.h" | |
35 | ||
36 | namespace gold | |
37 | { | |
38 | ||
39 | // Class File_read::View. | |
40 | ||
41 | File_read::View::~View() | |
42 | { | |
a3ad94ed | 43 | gold_assert(!this->is_locked()); |
d1038c21 ILT |
44 | if (!this->mapped_) |
45 | delete[] this->data_; | |
46 | else | |
47 | { | |
48 | if (::munmap(const_cast<unsigned char*>(this->data_), this->size_) != 0) | |
75f2446e | 49 | gold_warning(_("munmap failed: %s"), strerror(errno)); |
e44fcf3b ILT |
50 | |
51 | File_read::current_mapped_bytes -= this->size_; | |
d1038c21 | 52 | } |
bae7f79e ILT |
53 | } |
54 | ||
55 | void | |
56 | File_read::View::lock() | |
57 | { | |
58 | ++this->lock_count_; | |
59 | } | |
60 | ||
61 | void | |
62 | File_read::View::unlock() | |
63 | { | |
a3ad94ed | 64 | gold_assert(this->lock_count_ > 0); |
bae7f79e ILT |
65 | --this->lock_count_; |
66 | } | |
67 | ||
68 | bool | |
69 | File_read::View::is_locked() | |
70 | { | |
71 | return this->lock_count_ > 0; | |
72 | } | |
73 | ||
74 | // Class File_read. | |
75 | ||
e44fcf3b ILT |
76 | // The File_read static variables. |
77 | unsigned long long File_read::total_mapped_bytes; | |
78 | unsigned long long File_read::current_mapped_bytes; | |
79 | unsigned long long File_read::maximum_mapped_bytes; | |
80 | ||
bae7f79e ILT |
81 | // The File_read class is designed to support file descriptor caching, |
82 | // but this is not currently implemented. | |
83 | ||
84 | File_read::~File_read() | |
85 | { | |
a3ad94ed | 86 | gold_assert(this->lock_count_ == 0); |
bae7f79e ILT |
87 | if (this->descriptor_ >= 0) |
88 | { | |
89 | if (close(this->descriptor_) < 0) | |
75f2446e ILT |
90 | gold_warning(_("close of %s failed: %s"), |
91 | this->name_.c_str(), strerror(errno)); | |
bae7f79e ILT |
92 | this->descriptor_ = -1; |
93 | } | |
94 | this->name_.clear(); | |
95 | this->clear_views(true); | |
96 | } | |
97 | ||
5a6f7e2d ILT |
98 | // Open the file. |
99 | ||
bae7f79e ILT |
100 | bool |
101 | File_read::open(const std::string& name) | |
102 | { | |
a3ad94ed ILT |
103 | gold_assert(this->lock_count_ == 0 |
104 | && this->descriptor_ < 0 | |
105 | && this->name_.empty()); | |
bae7f79e | 106 | this->name_ = name; |
82dcae9d | 107 | |
bae7f79e | 108 | this->descriptor_ = ::open(this->name_.c_str(), O_RDONLY); |
82dcae9d ILT |
109 | |
110 | if (this->descriptor_ >= 0) | |
111 | { | |
112 | struct stat s; | |
113 | if (::fstat(this->descriptor_, &s) < 0) | |
75f2446e ILT |
114 | gold_error(_("%s: fstat failed: %s"), |
115 | this->name_.c_str(), strerror(errno)); | |
82dcae9d ILT |
116 | this->size_ = s.st_size; |
117 | } | |
118 | ||
bae7f79e | 119 | ++this->lock_count_; |
82dcae9d | 120 | |
bae7f79e ILT |
121 | return this->descriptor_ >= 0; |
122 | } | |
123 | ||
5a6f7e2d ILT |
124 | // Open the file for testing purposes. |
125 | ||
126 | bool | |
127 | File_read::open(const std::string& name, const unsigned char* contents, | |
82dcae9d | 128 | off_t size) |
bae7f79e | 129 | { |
5a6f7e2d ILT |
130 | gold_assert(this->lock_count_ == 0 |
131 | && this->descriptor_ < 0 | |
132 | && this->name_.empty()); | |
133 | this->name_ = name; | |
134 | this->contents_ = contents; | |
82dcae9d | 135 | this->size_ = size; |
5a6f7e2d ILT |
136 | ++this->lock_count_; |
137 | return true; | |
bae7f79e ILT |
138 | } |
139 | ||
140 | void | |
141 | File_read::lock() | |
142 | { | |
143 | ++this->lock_count_; | |
144 | } | |
145 | ||
146 | void | |
147 | File_read::unlock() | |
148 | { | |
a3ad94ed | 149 | gold_assert(this->lock_count_ > 0); |
bae7f79e | 150 | --this->lock_count_; |
9eb9fa57 | 151 | if (this->lock_count_ == 0) |
e44fcf3b ILT |
152 | { |
153 | File_read::total_mapped_bytes += this->mapped_bytes_; | |
154 | File_read::current_mapped_bytes += this->mapped_bytes_; | |
155 | this->mapped_bytes_ = 0; | |
156 | if (File_read::current_mapped_bytes > File_read::maximum_mapped_bytes) | |
157 | File_read::maximum_mapped_bytes = File_read::current_mapped_bytes; | |
158 | ||
159 | this->clear_views(false); | |
160 | } | |
bae7f79e ILT |
161 | } |
162 | ||
163 | bool | |
164 | File_read::is_locked() | |
165 | { | |
166 | return this->lock_count_ > 0; | |
167 | } | |
168 | ||
169 | // See if we have a view which covers the file starting at START for | |
170 | // SIZE bytes. Return a pointer to the View if found, NULL if not. | |
171 | ||
ead1e424 | 172 | inline File_read::View* |
c71c6f56 | 173 | File_read::find_view(off_t start, off_t size) const |
bae7f79e | 174 | { |
ead1e424 | 175 | off_t page = File_read::page_offset(start); |
c71c6f56 | 176 | Views::const_iterator p = this->views_.find(page); |
ead1e424 ILT |
177 | if (p == this->views_.end()) |
178 | return NULL; | |
179 | if (p->second->size() - (start - page) < size) | |
180 | return NULL; | |
181 | return p->second; | |
bae7f79e ILT |
182 | } |
183 | ||
82dcae9d | 184 | // Read SIZE bytes from the file starting at offset START. Read into |
9eb9fa57 | 185 | // the buffer at P. |
bae7f79e | 186 | |
9eb9fa57 | 187 | void |
c71c6f56 | 188 | File_read::do_read(off_t start, off_t size, void* p) const |
bae7f79e | 189 | { |
9eb9fa57 | 190 | off_t bytes; |
82dcae9d | 191 | if (this->contents_ != NULL) |
bae7f79e | 192 | { |
9eb9fa57 ILT |
193 | bytes = this->size_ - start; |
194 | if (bytes >= size) | |
195 | { | |
196 | memcpy(p, this->contents_ + start, size); | |
197 | return; | |
198 | } | |
bae7f79e | 199 | } |
9eb9fa57 | 200 | else |
82dcae9d | 201 | { |
9eb9fa57 ILT |
202 | bytes = ::pread(this->descriptor_, p, size, start); |
203 | if (bytes == size) | |
204 | return; | |
82dcae9d | 205 | |
9eb9fa57 ILT |
206 | if (bytes < 0) |
207 | { | |
75f2446e ILT |
208 | gold_fatal(_("%s: pread failed: %s"), |
209 | this->filename().c_str(), strerror(errno)); | |
210 | return; | |
9eb9fa57 | 211 | } |
bae7f79e | 212 | } |
9eb9fa57 | 213 | |
75f2446e ILT |
214 | gold_fatal(_("%s: file too short: read only %lld of %lld bytes at %lld"), |
215 | this->filename().c_str(), | |
216 | static_cast<long long>(bytes), | |
217 | static_cast<long long>(size), | |
218 | static_cast<long long>(start)); | |
bae7f79e ILT |
219 | } |
220 | ||
ba45d247 ILT |
221 | // Read data from the file. |
222 | ||
bae7f79e | 223 | void |
c71c6f56 | 224 | File_read::read(off_t start, off_t size, void* p) const |
ba45d247 ILT |
225 | { |
226 | gold_assert(this->lock_count_ > 0); | |
227 | ||
228 | File_read::View* pv = this->find_view(start, size); | |
229 | if (pv != NULL) | |
230 | { | |
231 | memcpy(p, pv->data() + (start - pv->start()), size); | |
232 | return; | |
233 | } | |
234 | ||
9eb9fa57 | 235 | this->do_read(start, size, p); |
bae7f79e ILT |
236 | } |
237 | ||
238 | // Find an existing view or make a new one. | |
239 | ||
240 | File_read::View* | |
9eb9fa57 | 241 | File_read::find_or_make_view(off_t start, off_t size, bool cache) |
bae7f79e | 242 | { |
a3ad94ed | 243 | gold_assert(this->lock_count_ > 0); |
bae7f79e | 244 | |
ead1e424 ILT |
245 | off_t poff = File_read::page_offset(start); |
246 | ||
247 | File_read::View* const vnull = NULL; | |
248 | std::pair<Views::iterator, bool> ins = | |
249 | this->views_.insert(std::make_pair(poff, vnull)); | |
250 | ||
251 | if (!ins.second) | |
252 | { | |
253 | // There was an existing view at this offset. | |
254 | File_read::View* v = ins.first->second; | |
255 | if (v->size() - (start - v->start()) >= size) | |
9eb9fa57 ILT |
256 | { |
257 | if (cache) | |
258 | v->set_cache(); | |
259 | return v; | |
260 | } | |
ead1e424 ILT |
261 | |
262 | // This view is not large enough. | |
263 | this->saved_views_.push_back(v); | |
264 | } | |
265 | ||
82dcae9d ILT |
266 | // We need to read data from the file. We read full pages for |
267 | // greater efficiency on small files. | |
ead1e424 ILT |
268 | |
269 | off_t psize = File_read::pages(size + (start - poff)); | |
bae7f79e | 270 | |
82dcae9d ILT |
271 | if (poff + psize >= this->size_) |
272 | { | |
273 | psize = this->size_ - poff; | |
274 | gold_assert(psize >= size); | |
275 | } | |
ead1e424 | 276 | |
d1038c21 | 277 | File_read::View* v; |
ead1e424 | 278 | |
d1038c21 ILT |
279 | if (this->contents_ != NULL) |
280 | { | |
281 | unsigned char* p = new unsigned char[psize]; | |
282 | this->do_read(poff, psize, p); | |
283 | v = new File_read::View(poff, psize, p, cache, false); | |
284 | } | |
285 | else | |
286 | { | |
287 | void* p = ::mmap(NULL, psize, PROT_READ, MAP_SHARED, | |
288 | this->descriptor_, poff); | |
289 | if (p == MAP_FAILED) | |
75f2446e ILT |
290 | gold_fatal(_("%s: mmap offset %lld size %lld failed: %s"), |
291 | this->filename().c_str(), | |
292 | static_cast<long long>(poff), | |
293 | static_cast<long long>(psize), | |
294 | strerror(errno)); | |
d1038c21 | 295 | |
e44fcf3b ILT |
296 | this->mapped_bytes_ += psize; |
297 | ||
d1038c21 ILT |
298 | const unsigned char* pbytes = static_cast<const unsigned char*>(p); |
299 | v = new File_read::View(poff, psize, pbytes, cache, true); | |
300 | } | |
ead1e424 | 301 | |
82dcae9d ILT |
302 | ins.first->second = v; |
303 | return v; | |
bae7f79e ILT |
304 | } |
305 | ||
306 | // This implementation of get_view just reads into a memory buffer, | |
307 | // which we store on view_list_. At some point we should support | |
308 | // mmap. | |
309 | ||
310 | const unsigned char* | |
9eb9fa57 | 311 | File_read::get_view(off_t start, off_t size, bool cache) |
ba45d247 ILT |
312 | { |
313 | gold_assert(this->lock_count_ > 0); | |
9eb9fa57 | 314 | File_read::View* pv = this->find_or_make_view(start, size, cache); |
bae7f79e ILT |
315 | return pv->data() + (start - pv->start()); |
316 | } | |
317 | ||
318 | File_view* | |
9eb9fa57 | 319 | File_read::get_lasting_view(off_t start, off_t size, bool cache) |
bae7f79e | 320 | { |
a3ad94ed | 321 | gold_assert(this->lock_count_ > 0); |
9eb9fa57 | 322 | File_read::View* pv = this->find_or_make_view(start, size, cache); |
bae7f79e ILT |
323 | pv->lock(); |
324 | return new File_view(*this, pv, pv->data() + (start - pv->start())); | |
325 | } | |
326 | ||
327 | // Remove all the file views. | |
328 | ||
329 | void | |
330 | File_read::clear_views(bool destroying) | |
331 | { | |
fcf29b24 ILT |
332 | Views::iterator p = this->views_.begin(); |
333 | while (p != this->views_.end()) | |
bae7f79e | 334 | { |
9eb9fa57 ILT |
335 | if (!p->second->is_locked() |
336 | && (destroying || !p->second->should_cache())) | |
fcf29b24 ILT |
337 | { |
338 | delete p->second; | |
339 | ||
340 | // map::erase invalidates only the iterator to the deleted | |
341 | // element. | |
342 | Views::iterator pe = p; | |
343 | ++p; | |
344 | this->views_.erase(pe); | |
345 | } | |
ead1e424 | 346 | else |
bae7f79e | 347 | { |
a3ad94ed | 348 | gold_assert(!destroying); |
fcf29b24 | 349 | ++p; |
bae7f79e | 350 | } |
ead1e424 | 351 | } |
ead1e424 | 352 | |
fcf29b24 ILT |
353 | Saved_views::iterator q = this->saved_views_.begin(); |
354 | while (q != this->saved_views_.end()) | |
ead1e424 | 355 | { |
fcf29b24 ILT |
356 | if (!(*q)->is_locked() |
357 | && (destroying || !(*q)->should_cache())) | |
bae7f79e | 358 | { |
fcf29b24 ILT |
359 | delete *q; |
360 | q = this->saved_views_.erase(q); | |
ead1e424 ILT |
361 | } |
362 | else | |
363 | { | |
a3ad94ed | 364 | gold_assert(!destroying); |
fcf29b24 | 365 | ++q; |
bae7f79e ILT |
366 | } |
367 | } | |
368 | } | |
369 | ||
e44fcf3b ILT |
370 | // Print statistical information to stderr. This is used for --stats. |
371 | ||
372 | void | |
373 | File_read::print_stats() | |
374 | { | |
375 | fprintf(stderr, _("%s: total bytes mapped for read: %llu\n"), | |
376 | program_name, File_read::total_mapped_bytes); | |
377 | fprintf(stderr, _("%s: maximum bytes mapped for read at one time: %llu\n"), | |
378 | program_name, File_read::maximum_mapped_bytes); | |
379 | } | |
380 | ||
bae7f79e ILT |
381 | // Class File_view. |
382 | ||
383 | File_view::~File_view() | |
384 | { | |
a3ad94ed | 385 | gold_assert(this->file_.is_locked()); |
bae7f79e ILT |
386 | this->view_->unlock(); |
387 | } | |
388 | ||
389 | // Class Input_file. | |
390 | ||
5a6f7e2d ILT |
391 | // Create a file for testing. |
392 | ||
393 | Input_file::Input_file(const char* name, const unsigned char* contents, | |
394 | off_t size) | |
395 | : file_() | |
396 | { | |
397 | this->input_argument_ = | |
51dee2fe | 398 | new Input_file_argument(name, false, "", Position_dependent_options()); |
5a6f7e2d ILT |
399 | bool ok = file_.open(name, contents, size); |
400 | gold_assert(ok); | |
401 | } | |
402 | ||
403 | // Open the file. | |
404 | ||
51dee2fe ILT |
405 | // If the filename is not absolute, we assume it is in the current |
406 | // directory *except* when: | |
407 | // A) input_argument_->is_lib() is true; or | |
408 | // B) input_argument_->extra_search_path() is not empty. | |
409 | // In both cases, we look in extra_search_path + library_path to find | |
410 | // the file location, rather than the current directory. | |
411 | ||
75f2446e | 412 | bool |
bae7f79e ILT |
413 | Input_file::open(const General_options& options, const Dirsearch& dirpath) |
414 | { | |
415 | std::string name; | |
51dee2fe ILT |
416 | |
417 | // Case 1: name is an absolute file, just try to open it | |
418 | // Case 2: name is relative but is_lib is false and extra_search_path | |
419 | // is empty | |
420 | if (IS_ABSOLUTE_PATH (this->input_argument_->name()) | |
421 | || (!this->input_argument_->is_lib() | |
422 | && this->input_argument_->extra_search_path() == NULL)) | |
e2aacd2c ILT |
423 | { |
424 | name = this->input_argument_->name(); | |
425 | this->found_name_ = name; | |
426 | } | |
51dee2fe ILT |
427 | // Case 3: is_lib is true |
428 | else if (this->input_argument_->is_lib()) | |
bae7f79e | 429 | { |
51dee2fe ILT |
430 | // We don't yet support extra_search_path with -l. |
431 | gold_assert(this->input_argument_->extra_search_path() == NULL); | |
bae7f79e | 432 | std::string n1("lib"); |
5a6f7e2d | 433 | n1 += this->input_argument_->name(); |
bae7f79e | 434 | std::string n2; |
61611222 ILT |
435 | if (options.is_static() |
436 | || this->input_argument_->options().do_static_search()) | |
f6ce93d6 ILT |
437 | n1 += ".a"; |
438 | else | |
439 | { | |
440 | n2 = n1 + ".a"; | |
441 | n1 += ".so"; | |
442 | } | |
ad2d6943 | 443 | name = dirpath.find(n1, n2, &this->is_in_sysroot_); |
bae7f79e ILT |
444 | if (name.empty()) |
445 | { | |
a0c4fb0a | 446 | gold_error(_("cannot find -l%s"), |
75f2446e ILT |
447 | this->input_argument_->name()); |
448 | return false; | |
bae7f79e | 449 | } |
e2aacd2c ILT |
450 | if (n2.empty() || name[name.length() - 1] == 'o') |
451 | this->found_name_ = n1; | |
452 | else | |
453 | this->found_name_ = n2; | |
bae7f79e | 454 | } |
51dee2fe ILT |
455 | // Case 4: extra_search_path is not empty |
456 | else | |
457 | { | |
458 | gold_assert(this->input_argument_->extra_search_path() != NULL); | |
459 | ||
460 | // First, check extra_search_path. | |
461 | name = this->input_argument_->extra_search_path(); | |
462 | if (!IS_DIR_SEPARATOR (name[name.length() - 1])) | |
463 | name += '/'; | |
464 | name += this->input_argument_->name(); | |
465 | struct stat dummy_stat; | |
466 | if (::stat(name.c_str(), &dummy_stat) < 0) | |
467 | { | |
468 | // extra_search_path failed, so check the normal search-path. | |
ad2d6943 ILT |
469 | name = dirpath.find(this->input_argument_->name(), "", |
470 | &this->is_in_sysroot_); | |
51dee2fe ILT |
471 | if (name.empty()) |
472 | { | |
a0c4fb0a | 473 | gold_error(_("cannot find %s"), |
75f2446e ILT |
474 | this->input_argument_->name()); |
475 | return false; | |
51dee2fe ILT |
476 | } |
477 | } | |
e2aacd2c | 478 | this->found_name_ = this->input_argument_->name(); |
51dee2fe ILT |
479 | } |
480 | ||
481 | // Now that we've figured out where the file lives, try to open it. | |
bae7f79e ILT |
482 | if (!this->file_.open(name)) |
483 | { | |
a0c4fb0a | 484 | gold_error(_("cannot open %s: %s"), |
75f2446e ILT |
485 | name.c_str(), strerror(errno)); |
486 | return false; | |
bae7f79e | 487 | } |
75f2446e ILT |
488 | |
489 | return true; | |
bae7f79e ILT |
490 | } |
491 | ||
492 | } // End namespace gold. |