X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gold%2Ffileread.cc;h=c4ab6b7d04e9d3d3c3971466c424f6029c681913;hb=aa989b27d0bad451455416953c0e5026e229863a;hp=a16738a0d593531271af644f6ce4439fb032faed;hpb=7411e9a828d5384857b444cc701cdab6e5f4d676;p=deliverable%2Fbinutils-gdb.git diff --git a/gold/fileread.cc b/gold/fileread.cc index a16738a0d5..c4ab6b7d04 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-2019 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)); @@ -900,45 +1015,40 @@ Input_file::find_file(const Dirsearch& dirpath, int* pindex, else if (input_argument->is_lib() || input_argument->is_searched_file()) { - std::string n1, n2; + std::vector names; + names.reserve(2); if (input_argument->is_lib()) { - n1 = "lib"; - n1 += input_argument->name(); + std::string prefix = "lib"; + prefix += input_argument->name(); if (parameters->options().is_static() || !input_argument->options().Bdynamic()) - n1 += ".a"; + names.push_back(prefix + ".a"); else { - n2 = n1 + ".a"; - n1 += ".so"; + names.push_back(prefix + ".so"); + names.push_back(prefix + ".a"); } } else - n1 = input_argument->name(); - - if (Input_file::try_extra_search_path(pindex, input_argument, n1, - found_name, namep)) - return true; + names.push_back(input_argument->name()); - if (!n2.empty() && Input_file::try_extra_search_path(pindex, - input_argument, n2, - found_name, namep)) - return true; + 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(n1, n2, is_in_sysroot, pindex); + name = dirpath.find(names, is_in_sysroot, pindex, found_name); if (name.empty()) { gold_error(_("cannot find %s%s"), - input_argument->is_lib() ? "-l" : "", + input_argument->is_lib() ? "-l" : "", input_argument->name()); return false; } - if (n2.empty() || name[name.length() - 1] == 'o') - *found_name = n1; - else - *found_name = n2; *namep = name; return true; } @@ -948,22 +1058,21 @@ Input_file::find_file(const Dirsearch& dirpath, int* pindex, gold_assert(input_argument->extra_search_path() != NULL); if (try_extra_search_path(pindex, input_argument, input_argument->name(), - found_name, namep)) - return true; + 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(input_argument->name(), "", - is_in_sysroot, &index); + --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; - } - *found_name = input_argument->name(); + { + gold_error(_("cannot find %s"), + input_argument->name()); + return false; + } *namep = name; *pindex = index + 1; return true;