X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gold%2Ffileread.cc;h=bebe0aba8d08132b4cba10d4ccc696d5f0475f13;hb=121b3efd49f98e4049281b3ba7a258e650e40b38;hp=10e1dec223bfcaa67b4aa8f3dd76a84705cbce4d;hpb=68ed838c0d5d6e20450e43264ce2e60981d085d0;p=deliverable%2Fbinutils-gdb.git diff --git a/gold/fileread.cc b/gold/fileread.cc index 10e1dec223..bebe0aba8d 100644 --- a/gold/fileread.cc +++ b/gold/fileread.cc @@ -1,6 +1,6 @@ // fileread.cc -- read files for gold -// Copyright 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc. +// Copyright (C) 2006-2020 Free Software Foundation, Inc. // Written by Ian Lance Taylor . // This file is part of gold. @@ -24,9 +24,13 @@ #include #include +#include #include #include + +#ifdef HAVE_SYS_MMAN_H #include +#endif #ifdef HAVE_READV #include @@ -45,6 +49,40 @@ #include "gold-threads.h" #include "fileread.h" +// For systems without mmap support. +#ifndef HAVE_MMAP +# define mmap gold_mmap +# define munmap gold_munmap +# ifndef MAP_FAILED +# define MAP_FAILED (reinterpret_cast(-1)) +# endif +# ifndef PROT_READ +# define PROT_READ 0 +# endif +# ifndef MAP_PRIVATE +# define MAP_PRIVATE 0 +# endif + +# ifndef ENOSYS +# define ENOSYS EINVAL +# endif + +static void * +gold_mmap(void *, size_t, int, int, int, off_t) +{ + errno = ENOSYS; + return MAP_FAILED; +} + +static int +gold_munmap(void *, size_t) +{ + errno = ENOSYS; + return -1; +} + +#endif + #ifndef HAVE_READV struct iovec { void* iov_base; size_t iov_len; }; ssize_t @@ -57,6 +95,36 @@ readv(int, const iovec*, int) namespace gold { +// Get the last modified time of an unopened file. + +bool +get_mtime(const char* filename, Timespec* mtime) +{ + struct stat file_stat; + + if (stat(filename, &file_stat) < 0) + return false; +#ifdef HAVE_STAT_ST_MTIM + mtime->seconds = file_stat.st_mtim.tv_sec; + mtime->nanoseconds = file_stat.st_mtim.tv_nsec; +#else + mtime->seconds = file_stat.st_mtime; + mtime->nanoseconds = 0; +#endif + return true; +} + +// Class File_read. + +// A lock for the File_read static variables. +static Lock* file_counts_lock = NULL; +static Initialize_lock file_counts_initialize_lock(&file_counts_lock); + +// The File_read static variables. +unsigned long long File_read::total_mapped_bytes; +unsigned long long File_read::current_mapped_bytes; +unsigned long long File_read::maximum_mapped_bytes; + // Class File_read::View. File_read::View::~View() @@ -65,12 +133,17 @@ File_read::View::~View() switch (this->data_ownership_) { case DATA_ALLOCATED_ARRAY: - delete[] this->data_; + free(const_cast(this->data_)); break; case DATA_MMAPPED: if (::munmap(const_cast(this->data_), this->size_) != 0) - gold_warning(_("munmap failed: %s"), strerror(errno)); - File_read::current_mapped_bytes -= this->size_; + gold_warning(_("munmap failed: %s"), strerror(errno)); + if (!parameters->options_valid() || parameters->options().stats()) + { + file_counts_initialize_lock.initialize(); + Hold_optional_lock hl(file_counts_lock); + File_read::current_mapped_bytes -= this->size_; + } break; case DATA_NOT_OWNED: break; @@ -100,15 +173,6 @@ File_read::View::is_locked() // Class File_read. -// A lock for the File_read static variables. -static Lock* file_counts_lock = NULL; -static Initialize_lock file_counts_initialize_lock(&file_counts_lock); - -// The File_read static variables. -unsigned long long File_read::total_mapped_bytes; -unsigned long long File_read::current_mapped_bytes; -unsigned long long File_read::maximum_mapped_bytes; - File_read::~File_read() { gold_assert(this->token_.is_writable()); @@ -145,7 +209,7 @@ File_read::open(const Task* task, const std::string& name) this->name_.c_str(), strerror(errno)); this->size_ = s.st_size; gold_debug(DEBUG_FILES, "Attempt to open %s succeeded", - this->name_.c_str()); + this->name_.c_str()); this->token_.add_writer(task); } @@ -164,7 +228,7 @@ File_read::open(const Task* task, const std::string& name, && this->name_.empty()); this->name_ = name; this->whole_file_view_ = new View(0, size, contents, 0, false, - View::DATA_NOT_OWNED); + View::DATA_NOT_OWNED); this->add_view(this->whole_file_view_); this->size_ = size; this->token_.add_writer(task); @@ -229,6 +293,7 @@ void File_read::lock(const Task* task) { gold_assert(this->released_); + gold_debug(DEBUG_FILES, "Locking file \"%s\"", this->name_.c_str()); this->token_.add_writer(task); this->released_ = false; } @@ -238,6 +303,7 @@ File_read::lock(const Task* task) void File_read::unlock(const Task* task) { + gold_debug(DEBUG_FILES, "Unlocking file \"%s\"", this->name_.c_str()); this->release(); this->token_.remove_writer(task); } @@ -265,6 +331,10 @@ inline File_read::View* File_read::find_view(off_t start, section_size_type size, unsigned int byteshift, File_read::View** vshifted) const { + gold_assert(start <= this->size_ + && (static_cast(size) + <= static_cast(this->size_ - start))); + if (vshifted != NULL) *vshifted = NULL; @@ -321,16 +391,26 @@ File_read::do_read(off_t start, section_size_type size, void* p) else { this->reopen_descriptor(); - bytes = ::pread(this->descriptor_, p, size, start); - if (static_cast(bytes) == size) - return; - if (bytes < 0) + char *read_ptr = static_cast(p); + off_t read_pos = start; + size_t to_read = size; + do { - gold_fatal(_("%s: pread failed: %s"), - this->filename().c_str(), strerror(errno)); - return; + bytes = ::pread(this->descriptor_, read_ptr, to_read, read_pos); + if (bytes < 0) + gold_fatal(_("%s: pread failed: %s"), + this->filename().c_str(), strerror(errno)); + + read_pos += bytes; + read_ptr += bytes; + to_read -= bytes; + if (to_read == 0) + return; } + while (bytes > 0); + + bytes = size - to_read; } gold_fatal(_("%s: file too short: read only %lld of %lld bytes at %lld"), @@ -392,16 +472,9 @@ File_read::make_view(off_t start, section_size_type size, unsigned int byteshift, bool cache) { gold_assert(size > 0); - - // Check that start and end of the view are within the file. - if (start > this->size_ - || (static_cast(size) - > static_cast(this->size_ - start))) - gold_fatal(_("%s: attempt to map %lld bytes at offset %lld exceeds " - "size of file; the file may be corrupt"), - this->filename().c_str(), - static_cast(size), - static_cast(start)); + gold_assert(start <= this->size_ + && (static_cast(size) + <= static_cast(this->size_ - start))); off_t poff = File_read::page_offset(start); @@ -413,34 +486,40 @@ File_read::make_view(off_t start, section_size_type size, gold_assert(psize >= size); } - File_read::View* v; + void* p; + View::Data_ownership ownership; if (byteshift != 0) { - unsigned char* p = new unsigned char[psize + byteshift]; + p = malloc(psize + byteshift); + if (p == NULL) + gold_nomem(); memset(p, 0, byteshift); - this->do_read(poff, psize, p + byteshift); - v = new File_read::View(poff, psize, p, byteshift, cache, - View::DATA_ALLOCATED_ARRAY); + this->do_read(poff, psize, static_cast(p) + byteshift); + ownership = View::DATA_ALLOCATED_ARRAY; } else { this->reopen_descriptor(); - void* p = ::mmap(NULL, psize, PROT_READ, MAP_PRIVATE, - this->descriptor_, poff); - if (p == MAP_FAILED) - gold_fatal(_("%s: mmap offset %lld size %lld failed: %s"), - this->filename().c_str(), - static_cast(poff), - static_cast(psize), - strerror(errno)); - - this->mapped_bytes_ += psize; - - const unsigned char* pbytes = static_cast(p); - v = new File_read::View(poff, psize, pbytes, 0, cache, - View::DATA_MMAPPED); + p = ::mmap(NULL, psize, PROT_READ, MAP_PRIVATE, this->descriptor_, poff); + if (p != MAP_FAILED) + { + ownership = View::DATA_MMAPPED; + this->mapped_bytes_ += psize; + } + else + { + p = malloc(psize); + if (p == NULL) + gold_nomem(); + this->do_read(poff, psize, p); + ownership = View::DATA_ALLOCATED_ARRAY; + } } + const unsigned char* pbytes = static_cast(p); + File_read::View* v = new File_read::View(poff, psize, pbytes, byteshift, + cache, ownership); + this->add_view(v); return v; @@ -453,6 +532,16 @@ File_read::View* File_read::find_or_make_view(off_t offset, off_t start, section_size_type size, bool aligned, bool cache) { + // Check that start and end of the view are within the file. + if (start > this->size_ + || (static_cast(size) + > static_cast(this->size_ - start))) + gold_fatal(_("%s: attempt to map %lld bytes at offset %lld exceeds " + "size of file; the file may be corrupt"), + this->filename().c_str(), + static_cast(size), + static_cast(start)); + unsigned int byteshift; if (offset == 0) byteshift = 0; @@ -498,12 +587,15 @@ File_read::find_or_make_view(off_t offset, off_t start, { gold_assert(aligned); - unsigned char* pbytes = new unsigned char[v->size() + byteshift]; + unsigned char* pbytes; + pbytes = static_cast(malloc(v->size() + byteshift)); + if (pbytes == NULL) + gold_nomem(); memset(pbytes, 0, byteshift); memcpy(pbytes + byteshift, v->data() + v->byteshift(), v->size()); File_read::View* shifted_view = - new File_read::View(v->start(), v->size(), pbytes, byteshift, + new File_read::View(v->start(), v->size(), pbytes, byteshift, cache, View::DATA_ALLOCATED_ARRAY); this->add_view(shifted_view); @@ -598,11 +690,22 @@ File_read::do_readv(off_t base, const Read_multiple& rm, size_t start, got, want, static_cast(base + first_offset)); } +// Portable IOV_MAX. + +#if !defined(HAVE_READV) +#define GOLD_IOV_MAX 1 +#elif defined(IOV_MAX) +#define GOLD_IOV_MAX IOV_MAX +#else +#define GOLD_IOV_MAX (File_read::max_readv_entries * 2) +#endif + // Read several pieces of data from the file. void File_read::read_multiple(off_t base, const Read_multiple& rm) { + static size_t iov_max = GOLD_IOV_MAX; size_t count = rm.size(); size_t i = 0; while (i < count) @@ -615,7 +718,7 @@ File_read::read_multiple(off_t base, const Read_multiple& rm) size_t j; for (j = i + 1; j < count; ++j) { - if (j - i >= File_read::max_readv_entries) + if (j - i >= File_read::max_readv_entries || j - i >= iov_max / 2) break; const Read_multiple_entry& j_entry(rm[j]); off_t j_off = j_entry.file_offset; @@ -644,10 +747,10 @@ File_read::read_multiple(off_t base, const Read_multiple& rm) { const Read_multiple_entry& k_entry(rm[k]); gold_assert((convert_to_section_size_type(k_entry.file_offset - - i_off) - + k_entry.size) + - i_off) + + k_entry.size) <= convert_to_section_size_type(end_off - - i_off)); + - i_off)); memcpy(k_entry.buffer, v + (k_entry.file_offset - i_off), k_entry.size); @@ -698,11 +801,13 @@ File_read::clear_views(Clear_views_mode mode) should_delete = false; else if (mode == CLEAR_VIEWS_ALL) should_delete = true; - else if (p->second->should_cache() && keep_files_mapped) + else if ((p->second->should_cache() + || p->second == this->whole_file_view_) + && keep_files_mapped) should_delete = false; else if (this->object_count_ > 1 - && p->second->accessed() - && mode != CLEAR_VIEWS_ARCHIVE) + && p->second->accessed() + && mode != CLEAR_VIEWS_ARCHIVE) should_delete = false; else should_delete = true; @@ -763,6 +868,16 @@ File_view::~File_view() // Class Input_file. +// Create a file given just the filename. + +Input_file::Input_file(const char* name) + : found_name_(), file_(), is_in_sysroot_(false), format_(FORMAT_NONE) +{ + this->input_argument_ = + new Input_file_argument(name, Input_file_argument::INPUT_FILE_TYPE_FILE, + "", false, Position_dependent_options()); +} + // Create a file for testing. Input_file::Input_file(const Task* task, const char* name, @@ -771,7 +886,7 @@ Input_file::Input_file(const Task* task, const char* name, { this->input_argument_ = new Input_file_argument(name, Input_file_argument::INPUT_FILE_TYPE_FILE, - "", false, Position_dependent_options()); + "", false, Position_dependent_options()); bool ok = this->file_.open(task, name, contents, size); gold_assert(ok); } @@ -830,7 +945,7 @@ File_read::get_mtime() { struct stat file_stat; this->reopen_descriptor(); - + if (fstat(this->descriptor_, &file_stat) < 0) gold_fatal(_("%s: stat failed: %s"), this->name_.c_str(), strerror(errno)); @@ -841,8 +956,32 @@ File_read::get_mtime() #endif } -// Open the file. +// Try to find a file in the extra search dirs. Returns true on success. + +bool +Input_file::try_extra_search_path(int* pindex, + const Input_file_argument* input_argument, + std::string filename, std::string* found_name, + std::string* namep) +{ + if (input_argument->extra_search_path() == NULL) + return false; + + std::string name = input_argument->extra_search_path(); + if (!IS_DIR_SEPARATOR(name[name.length() - 1])) + name += '/'; + name += filename; + struct stat dummy_stat; + if (*pindex > 0 || ::stat(name.c_str(), &dummy_stat) < 0) + return false; + + *found_name = filename; + *namep = name; + return true; +} + +// Find the actual file. // If the filename is not absolute, we assume it is in the current // directory *except* when: // A) input_argument_->is_lib() is true; @@ -852,85 +991,103 @@ File_read::get_mtime() // the file location, rather than the current directory. bool -Input_file::open(const Dirsearch& dirpath, const Task* task, int *pindex) +Input_file::find_file(const Dirsearch& dirpath, int* pindex, + const Input_file_argument* input_argument, + bool* is_in_sysroot, + std::string* found_name, std::string* namep) { std::string name; // Case 1: name is an absolute file, just try to open it // Case 2: name is relative but is_lib is false, is_searched_file is false, // and extra_search_path is empty - if (IS_ABSOLUTE_PATH(this->input_argument_->name()) - || (!this->input_argument_->is_lib() - && !this->input_argument_->is_searched_file() - && this->input_argument_->extra_search_path() == NULL)) + if (IS_ABSOLUTE_PATH(input_argument->name()) + || (!input_argument->is_lib() + && !input_argument->is_searched_file() + && input_argument->extra_search_path() == NULL)) { - name = this->input_argument_->name(); - this->found_name_ = name; + name = input_argument->name(); + *found_name = name; + *namep = name; + return true; } // Case 3: is_lib is true or is_searched_file is true - else if (this->input_argument_->is_lib() - || this->input_argument_->is_searched_file()) + else if (input_argument->is_lib() + || input_argument->is_searched_file()) { - // We don't yet support extra_search_path with -l. - gold_assert(this->input_argument_->extra_search_path() == NULL); - std::string n1, n2; - if (this->input_argument_->is_lib()) + std::vector names; + names.reserve(2); + if (input_argument->is_lib()) { - n1 = "lib"; - n1 += this->input_argument_->name(); + std::string prefix = "lib"; + prefix += input_argument->name(); if (parameters->options().is_static() - || !this->input_argument_->options().Bdynamic()) - n1 += ".a"; + || !input_argument->options().Bdynamic()) + names.push_back(prefix + ".a"); else { - n2 = n1 + ".a"; - n1 += ".so"; + names.push_back(prefix + ".so"); + names.push_back(prefix + ".a"); } } else - n1 = this->input_argument_->name(); - name = dirpath.find(n1, n2, &this->is_in_sysroot_, pindex); + names.push_back(input_argument->name()); + + for (std::vector::const_iterator n = names.begin(); + n != names.end(); + ++n) + if (Input_file::try_extra_search_path(pindex, input_argument, *n, + found_name, namep)) + return true; + + // It is not in the extra_search_path. + name = dirpath.find(names, is_in_sysroot, pindex, found_name); if (name.empty()) { gold_error(_("cannot find %s%s"), - this->input_argument_->is_lib() ? "-l" : "", - this->input_argument_->name()); + input_argument->is_lib() ? "-l" : "", + input_argument->name()); return false; } - if (n2.empty() || name[name.length() - 1] == 'o') - this->found_name_ = n1; - else - this->found_name_ = n2; + *namep = name; + return true; } // Case 4: extra_search_path is not empty else { - gold_assert(this->input_argument_->extra_search_path() != NULL); - - // First, check extra_search_path. - name = this->input_argument_->extra_search_path(); - if (!IS_DIR_SEPARATOR (name[name.length() - 1])) - name += '/'; - name += this->input_argument_->name(); - struct stat dummy_stat; - if (*pindex > 0 || ::stat(name.c_str(), &dummy_stat) < 0) - { - // extra_search_path failed, so check the normal search-path. - int index = *pindex; - if (index > 0) - --index; - name = dirpath.find(this->input_argument_->name(), "", - &this->is_in_sysroot_, &index); - if (name.empty()) - { - gold_error(_("cannot find %s"), - this->input_argument_->name()); - return false; - } - *pindex = index + 1; - } - this->found_name_ = this->input_argument_->name(); + gold_assert(input_argument->extra_search_path() != NULL); + + if (try_extra_search_path(pindex, input_argument, input_argument->name(), + found_name, namep)) + return true; + + // extra_search_path failed, so check the normal search-path. + int index = *pindex; + if (index > 0) + --index; + name = dirpath.find(std::vector(1, input_argument->name()), + is_in_sysroot, &index, found_name); + if (name.empty()) + { + gold_error(_("cannot find %s"), + input_argument->name()); + return false; + } + *namep = name; + *pindex = index + 1; + return true; } +} + +// Open the file. + +bool +Input_file::open(const Dirsearch& dirpath, const Task* task, int* pindex) +{ + std::string name; + if (!Input_file::find_file(dirpath, pindex, this->input_argument_, + &this->is_in_sysroot_, &this->found_name_, &name)) + return false; // Now that we've figured out where the file lives, try to open it.