1 // fileread.cc -- read files for gold 2 3 // Copyright (C) 2006-2022 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 #include "gold.h" 24 25 #include <cstring> 26 #include <cerrno> 27 #include <climits> 28 #include <fcntl.h> 29 #include <unistd.h> 30 31 #ifdef HAVE_SYS_MMAN_H 32 #include <sys/mman.h> 33 #endif 34 35 #ifdef HAVE_READV 36 #include <sys/uio.h> 37 #endif 38 39 #include <sys/stat.h> 40 #include "filenames.h" 41 42 #include "debug.h" 43 #include "parameters.h" 44 #include "options.h" 45 #include "dirsearch.h" 46 #include "target.h" 47 #include "binary.h" 48 #include "descriptors.h" 49 #include "gold-threads.h" 50 #include "fileread.h" 51 52 // For systems without mmap support. 53 #ifndef HAVE_MMAP 54 # define mmap gold_mmap 55 # define munmap gold_munmap 56 # ifndef MAP_FAILED 57 # define MAP_FAILED (reinterpret_cast<void*>(-1)) 58 # endif 59 # ifndef PROT_READ 60 # define PROT_READ 0 61 # endif 62 # ifndef MAP_PRIVATE 63 # define MAP_PRIVATE 0 64 # endif 65 66 # ifndef ENOSYS 67 # define ENOSYS EINVAL 68 # endif 69 70 static void * 71 gold_mmap(void *, size_t, int, int, int, off_t) 72 { 73 errno = ENOSYS; 74 return MAP_FAILED; 75 } 76 77 static int 78 gold_munmap(void *, size_t) 79 { 80 errno = ENOSYS; 81 return -1; 82 } 83 84 #endif 85 86 #ifndef HAVE_READV 87 struct iovec { void* iov_base; size_t iov_len; }; 88 ssize_t 89 readv(int, const iovec*, int) 90 { 91 gold_unreachable(); 92 } 93 #endif 94 95 namespace gold 96 { 97 98 // Get the last modified time of an unopened file. 99 100 bool 101 get_mtime(const char* filename, Timespec* mtime) 102 { 103 struct stat file_stat; 104 105 if (stat(filename, &file_stat) < 0) 106 return false; 107 #ifdef HAVE_STAT_ST_MTIM 108 mtime->seconds = file_stat.st_mtim.tv_sec; 109 mtime->nanoseconds = file_stat.st_mtim.tv_nsec; 110 #else 111 mtime->seconds = file_stat.st_mtime; 112 mtime->nanoseconds = 0; 113 #endif 114 return true; 115 } 116 117 // Class File_read. 118 119 // A lock for the File_read static variables. 120 static Lock* file_counts_lock = NULL; 121 static Initialize_lock file_counts_initialize_lock(&file_counts_lock); 122 123 // The File_read static variables. 124 unsigned long long File_read::total_mapped_bytes; 125 unsigned long long File_read::current_mapped_bytes; 126 unsigned long long File_read::maximum_mapped_bytes; 127 std::vector<std::string> File_read::files_read; 128 129 // Class File_read::View. 130 131 File_read::View::~View() 132 { 133 gold_assert(!this->is_locked()); 134 switch (this->data_ownership_) 135 { 136 case DATA_ALLOCATED_ARRAY: 137 free(const_cast<unsigned char*>(this->data_)); 138 break; 139 case DATA_MMAPPED: 140 if (::munmap(const_cast<unsigned char*>(this->data_), this->size_) != 0) 141 gold_warning(_("munmap failed: %s"), strerror(errno)); 142 if (!parameters->options_valid() || parameters->options().stats()) 143 { 144 file_counts_initialize_lock.initialize(); 145 Hold_optional_lock hl(file_counts_lock); 146 File_read::current_mapped_bytes -= this->size_; 147 } 148 break; 149 case DATA_NOT_OWNED: 150 break; 151 default: 152 gold_unreachable(); 153 } 154 } 155 156 void 157 File_read::View::lock() 158 { 159 ++this->lock_count_; 160 } 161 162 void 163 File_read::View::unlock() 164 { 165 gold_assert(this->lock_count_ > 0); 166 --this->lock_count_; 167 } 168 169 bool 170 File_read::View::is_locked() 171 { 172 return this->lock_count_ > 0; 173 } 174 175 // Class File_read. 176 177 File_read::~File_read() 178 { 179 gold_assert(this->token_.is_writable()); 180 if (this->is_descriptor_opened_) 181 { 182 release_descriptor(this->descriptor_, true); 183 this->descriptor_ = -1; 184 this->is_descriptor_opened_ = false; 185 } 186 this->name_.clear(); 187 this->clear_views(CLEAR_VIEWS_ALL); 188 } 189 190 // Open the file. 191 192 bool 193 File_read::open(const Task* task, const std::string& name) 194 { 195 gold_assert(this->token_.is_writable() 196 && this->descriptor_ < 0 197 && !this->is_descriptor_opened_ 198 && this->name_.empty()); 199 this->name_ = name; 200 201 this->descriptor_ = open_descriptor(-1, this->name_.c_str(), 202 O_RDONLY); 203 204 if (this->descriptor_ >= 0) 205 { 206 this->is_descriptor_opened_ = true; 207 struct stat s; 208 if (::fstat(this->descriptor_, &s) < 0) 209 gold_error(_("%s: fstat failed: %s"), 210 this->name_.c_str(), strerror(errno)); 211 this->size_ = s.st_size; 212 gold_debug(DEBUG_FILES, "Attempt to open %s succeeded", 213 this->name_.c_str()); 214 this->token_.add_writer(task); 215 file_counts_initialize_lock.initialize(); 216 Hold_optional_lock hl(file_counts_lock); 217 record_file_read(this->name_); 218 } 219 220 return this->descriptor_ >= 0; 221 } 222 223 // Open the file with the contents in memory. 224 225 bool 226 File_read::open(const Task* task, const std::string& name, 227 const unsigned char* contents, off_t size) 228 { 229 gold_assert(this->token_.is_writable() 230 && this->descriptor_ < 0 231 && !this->is_descriptor_opened_ 232 && this->name_.empty()); 233 this->name_ = name; 234 this->whole_file_view_ = new View(0, size, contents, 0, false, 235 View::DATA_NOT_OWNED); 236 this->add_view(this->whole_file_view_); 237 this->size_ = size; 238 this->token_.add_writer(task); 239 return true; 240 } 241 242 // Reopen a descriptor if necessary. 243 244 void 245 File_read::reopen_descriptor() 246 { 247 if (!this->is_descriptor_opened_) 248 { 249 this->descriptor_ = open_descriptor(this->descriptor_, 250 this->name_.c_str(), 251 O_RDONLY); 252 if (this->descriptor_ < 0) 253 gold_fatal(_("could not reopen file %s"), this->name_.c_str()); 254 this->is_descriptor_opened_ = true; 255 } 256 } 257 258 // Release the file. This is called when we are done with the file in 259 // a Task. 260 261 void 262 File_read::release() 263 { 264 gold_assert(this->is_locked()); 265 266 if (!parameters->options_valid() || parameters->options().stats()) 267 { 268 file_counts_initialize_lock.initialize(); 269 Hold_optional_lock hl(file_counts_lock); 270 File_read::total_mapped_bytes += this->mapped_bytes_; 271 File_read::current_mapped_bytes += this->mapped_bytes_; 272 if (File_read::current_mapped_bytes > File_read::maximum_mapped_bytes) 273 File_read::maximum_mapped_bytes = File_read::current_mapped_bytes; 274 } 275 276 this->mapped_bytes_ = 0; 277 278 // Only clear views if there is only one attached object. Otherwise 279 // we waste time trying to clear cached archive views. Similarly 280 // for releasing the descriptor. 281 if (this->object_count_ <= 1) 282 { 283 this->clear_views(CLEAR_VIEWS_NORMAL); 284 if (this->is_descriptor_opened_) 285 { 286 release_descriptor(this->descriptor_, false); 287 this->is_descriptor_opened_ = false; 288 } 289 } 290 291 this->released_ = true; 292 } 293 294 // Lock the file. 295 296 void 297 File_read::lock(const Task* task) 298 { 299 gold_assert(this->released_); 300 gold_debug(DEBUG_FILES, "Locking file \"%s\"", this->name_.c_str()); 301 this->token_.add_writer(task); 302 this->released_ = false; 303 } 304 305 // Unlock the file. 306 307 void 308 File_read::unlock(const Task* task) 309 { 310 gold_debug(DEBUG_FILES, "Unlocking file \"%s\"", this->name_.c_str()); 311 this->release(); 312 this->token_.remove_writer(task); 313 } 314 315 // Return whether the file is locked. 316 317 bool 318 File_read::is_locked() const 319 { 320 if (!this->token_.is_writable()) 321 return true; 322 // The file is not locked, so it should have been released. 323 gold_assert(this->released_); 324 return false; 325 } 326 327 // See if we have a view which covers the file starting at START for 328 // SIZE bytes. Return a pointer to the View if found, NULL if not. 329 // If BYTESHIFT is not -1U, the returned View must have the specified 330 // byte shift; otherwise, it may have any byte shift. If VSHIFTED is 331 // not NULL, this sets *VSHIFTED to a view which would have worked if 332 // not for the requested BYTESHIFT. 333 334 inline File_read::View* 335 File_read::find_view(off_t start, section_size_type size, 336 unsigned int byteshift, File_read::View** vshifted) const 337 { 338 gold_assert(start <= this->size_ 339 && (static_cast<unsigned long long>(size) 340 <= static_cast<unsigned long long>(this->size_ - start))); 341 342 if (vshifted != NULL) 343 *vshifted = NULL; 344 345 // If we have the whole file mmapped, and the alignment is right, 346 // we can return it. 347 if (this->whole_file_view_) 348 if (byteshift == -1U || byteshift == 0) 349 return this->whole_file_view_; 350 351 off_t page = File_read::page_offset(start); 352 353 unsigned int bszero = 0; 354 Views::const_iterator p = this->views_.upper_bound(std::make_pair(page - 1, 355 bszero)); 356 357 while (p != this->views_.end() && p->first.first <= page) 358 { 359 if (p->second->start() <= start 360 && (p->second->start() + static_cast<off_t>(p->second->size()) 361 >= start + static_cast<off_t>(size))) 362 { 363 if (byteshift == -1U || byteshift == p->second->byteshift()) 364 { 365 p->second->set_accessed(); 366 return p->second; 367 } 368 369 if (vshifted != NULL && *vshifted == NULL) 370 *vshifted = p->second; 371 } 372 373 ++p; 374 } 375 376 return NULL; 377 } 378 379 // Read SIZE bytes from the file starting at offset START. Read into 380 // the buffer at P. 381 382 void 383 File_read::do_read(off_t start, section_size_type size, void* p) 384 { 385 ssize_t bytes; 386 if (this->whole_file_view_ != NULL) 387 { 388 // See PR 23765 for an example of a testcase that triggers this error. 389 if (((ssize_t) start) < 0) 390 gold_fatal(_("%s: read failed, starting offset (%#llx) less than zero"), 391 this->filename().c_str(), 392 static_cast<long long>(start)); 393 394 bytes = this->size_ - start; 395 if (static_cast<section_size_type>(bytes) >= size) 396 { 397 memcpy(p, this->whole_file_view_->data() + start, size); 398 return; 399 } 400 } 401 else 402 { 403 this->reopen_descriptor(); 404 405 char *read_ptr = static_cast<char *>(p); 406 off_t read_pos = start; 407 size_t to_read = size; 408 do 409 { 410 bytes = ::pread(this->descriptor_, read_ptr, to_read, read_pos); 411 if (bytes < 0) 412 gold_fatal(_("%s: pread failed: %s"), 413 this->filename().c_str(), strerror(errno)); 414 415 read_pos += bytes; 416 read_ptr += bytes; 417 to_read -= bytes; 418 if (to_read == 0) 419 return; 420 } 421 while (bytes > 0); 422 423 bytes = size - to_read; 424 } 425 426 gold_fatal(_("%s: file too short: read only %lld of %lld bytes at %lld"), 427 this->filename().c_str(), 428 static_cast<long long>(bytes), 429 static_cast<long long>(size), 430 static_cast<long long>(start)); 431 } 432 433 // Read data from the file. 434 435 void 436 File_read::read(off_t start, section_size_type size, void* p) 437 { 438 const File_read::View* pv = this->find_view(start, size, -1U, NULL); 439 if (pv != NULL) 440 { 441 memcpy(p, pv->data() + (start - pv->start() + pv->byteshift()), size); 442 return; 443 } 444 445 this->do_read(start, size, p); 446 } 447 448 // Add a new view. There may already be an existing view at this 449 // offset. If there is, the new view will be larger, and should 450 // replace the old view. 451 452 void 453 File_read::add_view(File_read::View* v) 454 { 455 std::pair<Views::iterator, bool> ins = 456 this->views_.insert(std::make_pair(std::make_pair(v->start(), 457 v->byteshift()), 458 v)); 459 if (ins.second) 460 return; 461 462 // There was an existing view at this offset. It must not be large 463 // enough. We can't delete it here, since something might be using 464 // it; we put it on a list to be deleted when the file is unlocked. 465 File_read::View* vold = ins.first->second; 466 gold_assert(vold->size() < v->size()); 467 if (vold->should_cache()) 468 { 469 v->set_cache(); 470 vold->clear_cache(); 471 } 472 this->saved_views_.push_back(vold); 473 474 ins.first->second = v; 475 } 476 477 // Make a new view with a specified byteshift, reading the data from 478 // the file. 479 480 File_read::View* 481 File_read::make_view(off_t start, section_size_type size, 482 unsigned int byteshift, bool cache) 483 { 484 gold_assert(size > 0); 485 gold_assert(start <= this->size_ 486 && (static_cast<unsigned long long>(size) 487 <= static_cast<unsigned long long>(this->size_ - start))); 488 489 off_t poff = File_read::page_offset(start); 490 491 section_size_type psize = File_read::pages(size + (start - poff)); 492 493 if (poff + static_cast<off_t>(psize) >= this->size_) 494 { 495 psize = this->size_ - poff; 496 gold_assert(psize >= size); 497 } 498 499 void* p; 500 View::Data_ownership ownership; 501 if (byteshift != 0) 502 { 503 p = malloc(psize + byteshift); 504 if (p == NULL) 505 gold_nomem(); 506 memset(p, 0, byteshift); 507 this->do_read(poff, psize, static_cast<unsigned char*>(p) + byteshift); 508 ownership = View::DATA_ALLOCATED_ARRAY; 509 } 510 else 511 { 512 this->reopen_descriptor(); 513 p = ::mmap(NULL, psize, PROT_READ, MAP_PRIVATE, this->descriptor_, poff); 514 if (p != MAP_FAILED) 515 { 516 ownership = View::DATA_MMAPPED; 517 this->mapped_bytes_ += psize; 518 } 519 else 520 { 521 p = malloc(psize); 522 if (p == NULL) 523 gold_nomem(); 524 this->do_read(poff, psize, p); 525 ownership = View::DATA_ALLOCATED_ARRAY; 526 } 527 } 528 529 const unsigned char* pbytes = static_cast<const unsigned char*>(p); 530 File_read::View* v = new File_read::View(poff, psize, pbytes, byteshift, 531 cache, ownership); 532 533 this->add_view(v); 534 535 return v; 536 } 537 538 // Find a View or make a new one, shifted as required by the file 539 // offset OFFSET and ALIGNED. 540 541 File_read::View* 542 File_read::find_or_make_view(off_t offset, off_t start, 543 section_size_type size, bool aligned, bool cache) 544 { 545 // Check that start and end of the view are within the file. 546 if (start > this->size_ 547 || (static_cast<unsigned long long>(size) 548 > static_cast<unsigned long long>(this->size_ - start))) 549 gold_fatal(_("%s: attempt to map %lld bytes at offset %lld exceeds " 550 "size of file; the file may be corrupt"), 551 this->filename().c_str(), 552 static_cast<long long>(size), 553 static_cast<long long>(start)); 554 555 unsigned int byteshift; 556 if (offset == 0) 557 byteshift = 0; 558 else 559 { 560 unsigned int target_size = (!parameters->target_valid() 561 ? 64 562 : parameters->target().get_size()); 563 byteshift = offset & ((target_size / 8) - 1); 564 565 // Set BYTESHIFT to the number of dummy bytes which must be 566 // inserted before the data in order for this data to be 567 // aligned. 568 if (byteshift != 0) 569 byteshift = (target_size / 8) - byteshift; 570 } 571 572 // If --map-whole-files is set, make sure we have a 573 // whole file view. Options may not yet be ready, e.g., 574 // when reading a version script. We then default to 575 // --no-map-whole-files. 576 if (this->whole_file_view_ == NULL 577 && parameters->options_valid() 578 && parameters->options().map_whole_files()) 579 this->whole_file_view_ = this->make_view(0, this->size_, 0, cache); 580 581 // Try to find a View with the required BYTESHIFT. 582 File_read::View* vshifted; 583 File_read::View* v = this->find_view(offset + start, size, 584 aligned ? byteshift : -1U, 585 &vshifted); 586 if (v != NULL) 587 { 588 if (cache) 589 v->set_cache(); 590 return v; 591 } 592 593 // If VSHIFTED is not NULL, then it has the data we need, but with 594 // the wrong byteshift. 595 v = vshifted; 596 if (v != NULL) 597 { 598 gold_assert(aligned); 599 600 unsigned char* pbytes; 601 pbytes = static_cast<unsigned char*>(malloc(v->size() + byteshift)); 602 if (pbytes == NULL) 603 gold_nomem(); 604 memset(pbytes, 0, byteshift); 605 memcpy(pbytes + byteshift, v->data() + v->byteshift(), v->size()); 606 607 File_read::View* shifted_view = 608 new File_read::View(v->start(), v->size(), pbytes, byteshift, 609 cache, View::DATA_ALLOCATED_ARRAY); 610 611 this->add_view(shifted_view); 612 return shifted_view; 613 } 614 615 // Make a new view. If we don't need an aligned view, use a 616 // byteshift of 0, so that we can use mmap. 617 return this->make_view(offset + start, size, 618 aligned ? byteshift : 0, 619 cache); 620 } 621 622 // Get a view into the file. 623 624 const unsigned char* 625 File_read::get_view(off_t offset, off_t start, section_size_type size, 626 bool aligned, bool cache) 627 { 628 File_read::View* pv = this->find_or_make_view(offset, start, size, 629 aligned, cache); 630 return pv->data() + (offset + start - pv->start() + pv->byteshift()); 631 } 632 633 File_view* 634 File_read::get_lasting_view(off_t offset, off_t start, section_size_type size, 635 bool aligned, bool cache) 636 { 637 File_read::View* pv = this->find_or_make_view(offset, start, size, 638 aligned, cache); 639 pv->lock(); 640 return new File_view(*this, pv, 641 (pv->data() 642 + (offset + start - pv->start() + pv->byteshift()))); 643 } 644 645 // Use readv to read COUNT entries from RM starting at START. BASE 646 // must be added to all file offsets in RM. 647 648 void 649 File_read::do_readv(off_t base, const Read_multiple& rm, size_t start, 650 size_t count) 651 { 652 unsigned char discard[File_read::page_size]; 653 iovec iov[File_read::max_readv_entries * 2]; 654 size_t iov_index = 0; 655 656 off_t first_offset = rm[start].file_offset; 657 off_t last_offset = first_offset; 658 ssize_t want = 0; 659 for (size_t i = 0; i < count; ++i) 660 { 661 const Read_multiple_entry& i_entry(rm[start + i]); 662 663 if (i_entry.file_offset > last_offset) 664 { 665 size_t skip = i_entry.file_offset - last_offset; 666 gold_assert(skip <= sizeof discard); 667 668 iov[iov_index].iov_base = discard; 669 iov[iov_index].iov_len = skip; 670 ++iov_index; 671 672 want += skip; 673 } 674 675 iov[iov_index].iov_base = i_entry.buffer; 676 iov[iov_index].iov_len = i_entry.size; 677 ++iov_index; 678 679 want += i_entry.size; 680 681 last_offset = i_entry.file_offset + i_entry.size; 682 } 683 684 this->reopen_descriptor(); 685 686 gold_assert(iov_index < sizeof iov / sizeof iov[0]); 687 688 if (::lseek(this->descriptor_, base + first_offset, SEEK_SET) < 0) 689 gold_fatal(_("%s: lseek failed: %s"), 690 this->filename().c_str(), strerror(errno)); 691 692 ssize_t got = ::readv(this->descriptor_, iov, iov_index); 693 694 if (got < 0) 695 gold_fatal(_("%s: readv failed: %s"), 696 this->filename().c_str(), strerror(errno)); 697 if (got != want) 698 gold_fatal(_("%s: file too short: read only %zd of %zd bytes at %lld"), 699 this->filename().c_str(), 700 got, want, static_cast<long long>(base + first_offset)); 701 } 702 703 // Portable IOV_MAX. 704 705 #if !defined(HAVE_READV) 706 #define GOLD_IOV_MAX 1 707 #elif defined(IOV_MAX) 708 #define GOLD_IOV_MAX IOV_MAX 709 #else 710 #define GOLD_IOV_MAX (File_read::max_readv_entries * 2) 711 #endif 712 713 // Read several pieces of data from the file. 714 715 void 716 File_read::read_multiple(off_t base, const Read_multiple& rm) 717 { 718 static size_t iov_max = GOLD_IOV_MAX; 719 size_t count = rm.size(); 720 size_t i = 0; 721 while (i < count) 722 { 723 // Find up to MAX_READV_ENTRIES consecutive entries which are 724 // less than one page apart. 725 const Read_multiple_entry& i_entry(rm[i]); 726 off_t i_off = i_entry.file_offset; 727 off_t end_off = i_off + i_entry.size; 728 size_t j; 729 for (j = i + 1; j < count; ++j) 730 { 731 if (j - i >= File_read::max_readv_entries || j - i >= iov_max / 2) 732 break; 733 const Read_multiple_entry& j_entry(rm[j]); 734 off_t j_off = j_entry.file_offset; 735 gold_assert(j_off >= end_off); 736 off_t j_end_off = j_off + j_entry.size; 737 if (j_end_off - end_off >= File_read::page_size) 738 break; 739 end_off = j_end_off; 740 } 741 742 if (j == i + 1) 743 this->read(base + i_off, i_entry.size, i_entry.buffer); 744 else 745 { 746 File_read::View* view = this->find_view(base + i_off, 747 end_off - i_off, 748 -1U, NULL); 749 if (view == NULL) 750 this->do_readv(base, rm, i, j - i); 751 else 752 { 753 const unsigned char* v = (view->data() 754 + (base + i_off - view->start() 755 + view->byteshift())); 756 for (size_t k = i; k < j; ++k) 757 { 758 const Read_multiple_entry& k_entry(rm[k]); 759 gold_assert((convert_to_section_size_type(k_entry.file_offset 760 - i_off) 761 + k_entry.size) 762 <= convert_to_section_size_type(end_off 763 - i_off)); 764 memcpy(k_entry.buffer, 765 v + (k_entry.file_offset - i_off), 766 k_entry.size); 767 } 768 } 769 } 770 771 i = j; 772 } 773 } 774 775 // Mark all views as no longer cached. 776 777 void 778 File_read::clear_view_cache_marks() 779 { 780 // Just ignore this if there are multiple objects associated with 781 // the file. Otherwise we will wind up uncaching and freeing some 782 // views for other objects. 783 if (this->object_count_ > 1) 784 return; 785 786 for (Views::iterator p = this->views_.begin(); 787 p != this->views_.end(); 788 ++p) 789 p->second->clear_cache(); 790 for (Saved_views::iterator p = this->saved_views_.begin(); 791 p != this->saved_views_.end(); 792 ++p) 793 (*p)->clear_cache(); 794 } 795 796 // Remove all the file views. For a file which has multiple 797 // associated objects (i.e., an archive), we keep accessed views 798 // around until next time, in the hopes that they will be useful for 799 // the next object. 800 801 void 802 File_read::clear_views(Clear_views_mode mode) 803 { 804 bool keep_files_mapped = (parameters->options_valid() 805 && parameters->options().keep_files_mapped()); 806 Views::iterator p = this->views_.begin(); 807 while (p != this->views_.end()) 808 { 809 bool should_delete; 810 if (p->second->is_locked() || p->second->is_permanent_view()) 811 should_delete = false; 812 else if (mode == CLEAR_VIEWS_ALL) 813 should_delete = true; 814 else if ((p->second->should_cache() 815 || p->second == this->whole_file_view_) 816 && keep_files_mapped) 817 should_delete = false; 818 else if (this->object_count_ > 1 819 && p->second->accessed() 820 && mode != CLEAR_VIEWS_ARCHIVE) 821 should_delete = false; 822 else 823 should_delete = true; 824 825 if (should_delete) 826 { 827 if (p->second == this->whole_file_view_) 828 this->whole_file_view_ = NULL; 829 delete p->second; 830 831 // map::erase invalidates only the iterator to the deleted 832 // element. 833 Views::iterator pe = p; 834 ++p; 835 this->views_.erase(pe); 836 } 837 else 838 { 839 p->second->clear_accessed(); 840 ++p; 841 } 842 } 843 844 Saved_views::iterator q = this->saved_views_.begin(); 845 while (q != this->saved_views_.end()) 846 { 847 if (!(*q)->is_locked()) 848 { 849 delete *q; 850 q = this->saved_views_.erase(q); 851 } 852 else 853 { 854 gold_assert(mode != CLEAR_VIEWS_ALL); 855 ++q; 856 } 857 } 858 } 859 860 // Print statistical information to stderr. This is used for --stats. 861 862 void 863 File_read::print_stats() 864 { 865 fprintf(stderr, _("%s: total bytes mapped for read: %llu\n"), 866 program_name, File_read::total_mapped_bytes); 867 fprintf(stderr, _("%s: maximum bytes mapped for read at one time: %llu\n"), 868 program_name, File_read::maximum_mapped_bytes); 869 } 870 871 // Class File_view. 872 873 File_view::~File_view() 874 { 875 gold_assert(this->file_.is_locked()); 876 this->view_->unlock(); 877 } 878 879 // Class Input_file. 880 881 // Create a file given just the filename. 882 883 Input_file::Input_file(const char* name) 884 : found_name_(), file_(), is_in_sysroot_(false), format_(FORMAT_NONE) 885 { 886 this->input_argument_ = 887 new Input_file_argument(name, Input_file_argument::INPUT_FILE_TYPE_FILE, 888 "", false, Position_dependent_options()); 889 } 890 891 // Create a file for testing. 892 893 Input_file::Input_file(const Task* task, const char* name, 894 const unsigned char* contents, off_t size) 895 : file_() 896 { 897 this->input_argument_ = 898 new Input_file_argument(name, Input_file_argument::INPUT_FILE_TYPE_FILE, 899 "", false, Position_dependent_options()); 900 bool ok = this->file_.open(task, name, contents, size); 901 gold_assert(ok); 902 } 903 904 // Return the position dependent options in force for this file. 905 906 const Position_dependent_options& 907 Input_file::options() const 908 { 909 return this->input_argument_->options(); 910 } 911 912 // Return the name given by the user. For -lc this will return "c". 913 914 const char* 915 Input_file::name() const 916 { 917 return this->input_argument_->name(); 918 } 919 920 // Return whether this file is in a system directory. 921 922 bool 923 Input_file::is_in_system_directory() const 924 { 925 if (this->is_in_sysroot()) 926 return true; 927 return parameters->options().is_in_system_directory(this->filename()); 928 } 929 930 // Return whether we are only reading symbols. 931 932 bool 933 Input_file::just_symbols() const 934 { 935 return this->input_argument_->just_symbols(); 936 } 937 938 // Return whether this is a file that we will search for in the list 939 // of directories. 940 941 bool 942 Input_file::will_search_for() const 943 { 944 return (!IS_ABSOLUTE_PATH(this->input_argument_->name()) 945 && (this->input_argument_->is_lib() 946 || this->input_argument_->is_searched_file() 947 || this->input_argument_->extra_search_path() != NULL)); 948 } 949 950 // Return the file last modification time. Calls gold_fatal if the stat 951 // system call failed. 952 953 Timespec 954 File_read::get_mtime() 955 { 956 struct stat file_stat; 957 this->reopen_descriptor(); 958 959 if (fstat(this->descriptor_, &file_stat) < 0) 960 gold_fatal(_("%s: stat failed: %s"), this->name_.c_str(), 961 strerror(errno)); 962 #ifdef HAVE_STAT_ST_MTIM 963 return Timespec(file_stat.st_mtim.tv_sec, file_stat.st_mtim.tv_nsec); 964 #else 965 return Timespec(file_stat.st_mtime, 0); 966 #endif 967 } 968 969 // Try to find a file in the extra search dirs. Returns true on success. 970 971 bool 972 Input_file::try_extra_search_path(int* pindex, 973 const Input_file_argument* input_argument, 974 std::string filename, std::string* found_name, 975 std::string* namep) 976 { 977 if (input_argument->extra_search_path() == NULL) 978 return false; 979 980 std::string name = input_argument->extra_search_path(); 981 if (!IS_DIR_SEPARATOR(name[name.length() - 1])) 982 name += '/'; 983 name += filename; 984 985 struct stat dummy_stat; 986 if (*pindex > 0 || ::stat(name.c_str(), &dummy_stat) < 0) 987 return false; 988 989 *found_name = filename; 990 *namep = name; 991 return true; 992 } 993 994 // Find the actual file. 995 // If the filename is not absolute, we assume it is in the current 996 // directory *except* when: 997 // A) input_argument_->is_lib() is true; 998 // B) input_argument_->is_searched_file() is true; or 999 // C) input_argument_->extra_search_path() is not empty. 1000 // In each, we look in extra_search_path + library_path to find 1001 // the file location, rather than the current directory. 1002 1003 bool 1004 Input_file::find_file(const Dirsearch& dirpath, int* pindex, 1005 const Input_file_argument* input_argument, 1006 bool* is_in_sysroot, 1007 std::string* found_name, std::string* namep) 1008 { 1009 std::string name; 1010 1011 // Case 1: name is an absolute file, just try to open it 1012 // Case 2: name is relative but is_lib is false, is_searched_file is false, 1013 // and extra_search_path is empty 1014 if (IS_ABSOLUTE_PATH(input_argument->name()) 1015 || (!input_argument->is_lib() 1016 && !input_argument->is_searched_file() 1017 && input_argument->extra_search_path() == NULL)) 1018 { 1019 name = input_argument->name(); 1020 *found_name = name; 1021 *namep = name; 1022 return true; 1023 } 1024 // Case 3: is_lib is true or is_searched_file is true 1025 else if (input_argument->is_lib() 1026 || input_argument->is_searched_file()) 1027 { 1028 std::vector<std::string> names; 1029 names.reserve(2); 1030 if (input_argument->is_lib()) 1031 { 1032 std::string prefix = "lib"; 1033 prefix += input_argument->name(); 1034 if (parameters->options().is_static() 1035 || !input_argument->options().Bdynamic()) 1036 names.push_back(prefix + ".a"); 1037 else 1038 { 1039 names.push_back(prefix + ".so"); 1040 names.push_back(prefix + ".a"); 1041 } 1042 } 1043 else 1044 names.push_back(input_argument->name()); 1045 1046 for (std::vector<std::string>::const_iterator n = names.begin(); 1047 n != names.end(); 1048 ++n) 1049 if (Input_file::try_extra_search_path(pindex, input_argument, *n, 1050 found_name, namep)) 1051 return true; 1052 1053 // It is not in the extra_search_path. 1054 name = dirpath.find(names, is_in_sysroot, pindex, found_name); 1055 if (name.empty()) 1056 { 1057 gold_error(_("cannot find %s%s"), 1058 input_argument->is_lib() ? "-l" : "", 1059 input_argument->name()); 1060 return false; 1061 } 1062 *namep = name; 1063 return true; 1064 } 1065 // Case 4: extra_search_path is not empty 1066 else 1067 { 1068 gold_assert(input_argument->extra_search_path() != NULL); 1069 1070 if (try_extra_search_path(pindex, input_argument, input_argument->name(), 1071 found_name, namep)) 1072 return true; 1073 1074 // extra_search_path failed, so check the normal search-path. 1075 int index = *pindex; 1076 if (index > 0) 1077 --index; 1078 name = dirpath.find(std::vector<std::string>(1, input_argument->name()), 1079 is_in_sysroot, &index, found_name); 1080 if (name.empty()) 1081 { 1082 gold_error(_("cannot find %s"), 1083 input_argument->name()); 1084 return false; 1085 } 1086 *namep = name; 1087 *pindex = index + 1; 1088 return true; 1089 } 1090 } 1091 1092 // Open the file. 1093 1094 bool 1095 Input_file::open(const Dirsearch& dirpath, const Task* task, int* pindex) 1096 { 1097 std::string name; 1098 if (!Input_file::find_file(dirpath, pindex, this->input_argument_, 1099 &this->is_in_sysroot_, &this->found_name_, &name)) 1100 return false; 1101 1102 // Now that we've figured out where the file lives, try to open it. 1103 1104 General_options::Object_format format = 1105 this->input_argument_->options().format_enum(); 1106 bool ok; 1107 if (format == General_options::OBJECT_FORMAT_ELF) 1108 { 1109 ok = this->file_.open(task, name); 1110 this->format_ = FORMAT_ELF; 1111 } 1112 else 1113 { 1114 gold_assert(format == General_options::OBJECT_FORMAT_BINARY); 1115 ok = this->open_binary(task, name); 1116 this->format_ = FORMAT_BINARY; 1117 } 1118 1119 if (!ok) 1120 { 1121 gold_error(_("cannot open %s: %s"), 1122 name.c_str(), strerror(errno)); 1123 this->format_ = FORMAT_NONE; 1124 return false; 1125 } 1126 1127 return true; 1128 } 1129 1130 // Open a file for --format binary. 1131 1132 bool 1133 Input_file::open_binary(const Task* task, const std::string& name) 1134 { 1135 // In order to open a binary file, we need machine code, size, and 1136 // endianness. We may not have a valid target at this point, in 1137 // which case we use the default target. 1138 parameters_force_valid_target(); 1139 const Target& target(parameters->target()); 1140 1141 Binary_to_elf binary_to_elf(target.machine_code(), 1142 target.get_size(), 1143 target.is_big_endian(), 1144 name); 1145 if (!binary_to_elf.convert(task)) 1146 return false; 1147 return this->file_.open(task, name, binary_to_elf.converted_data_leak(), 1148 binary_to_elf.converted_size()); 1149 } 1150 1151 void 1152 File_read::record_file_read(const std::string& name) 1153 { 1154 File_read::files_read.push_back(name); 1155 } 1156 1157 void 1158 File_read::write_dependency_file(const char* dependency_file_name, 1159 const char* output_file_name) 1160 { 1161 FILE *depfile = fopen(dependency_file_name, "w"); 1162 1163 fprintf(depfile, "%s:", output_file_name); 1164 for (std::vector<std::string>::const_iterator it = files_read.begin(); 1165 it != files_read.end(); 1166 ++it) 1167 fprintf(depfile, " \\\n %s", it->c_str()); 1168 fprintf(depfile, "\n"); 1169 1170 for (std::vector<std::string>::const_iterator it = files_read.begin(); 1171 it != files_read.end(); 1172 ++it) 1173 fprintf(depfile, "\n%s:\n", it->c_str()); 1174 1175 fclose(depfile); 1176 } 1177 1178 } // End namespace gold. 1179