X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=gold%2Ffileread.cc;h=c4ab6b7d04e9d3d3c3971466c424f6029c681913;hb=refs%2Fheads%2Fsandbox%2Fakazmin%2Ftizen_version;hp=901c52802d2f6682acfaf3a2d5df3fefb12ec287;hpb=8851eccaec28f25f56fab5ba5d8ae44f71729975;p=external%2Fbinutils.git diff --git a/gold/fileread.cc b/gold/fileread.cc index 901c528..c4ab6b7 100644 --- a/gold/fileread.cc +++ b/gold/fileread.cc @@ -1,6 +1,6 @@ // fileread.cc -- read files for gold -// Copyright 2006, 2007 Free Software Foundation, Inc. +// Copyright (C) 2006-2019 Free Software Foundation, Inc. // Written by Ian Lance Taylor . // This file is part of gold. @@ -24,35 +24,131 @@ #include #include +#include #include #include + +#ifdef HAVE_SYS_MMAN_H #include +#endif + +#ifdef HAVE_READV #include +#endif + +#include #include "filenames.h" +#include "debug.h" #include "parameters.h" #include "options.h" #include "dirsearch.h" #include "target.h" #include "binary.h" +#include "descriptors.h" +#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 +readv(int, const iovec*, int) +{ + gold_unreachable(); +} +#endif + 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() { gold_assert(!this->is_locked()); - if (!this->mapped_) - delete[] this->data_; - else + switch (this->data_ownership_) { + case DATA_ALLOCATED_ARRAY: + 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; + default: + gold_unreachable(); } } @@ -77,26 +173,17 @@ File_read::View::is_locked() // Class File_read. -// 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; - -// The File_read class is designed to support file descriptor caching, -// but this is not currently implemented. - File_read::~File_read() { gold_assert(this->token_.is_writable()); - if (this->descriptor_ >= 0) + if (this->is_descriptor_opened_) { - if (close(this->descriptor_) < 0) - gold_warning(_("close of %s failed: %s"), - this->name_.c_str(), strerror(errno)); + release_descriptor(this->descriptor_, true); this->descriptor_ = -1; + this->is_descriptor_opened_ = false; } this->name_.clear(); - this->clear_views(true); + this->clear_views(CLEAR_VIEWS_ALL); } // Open the file. @@ -106,22 +193,26 @@ File_read::open(const Task* task, const std::string& name) { gold_assert(this->token_.is_writable() && this->descriptor_ < 0 + && !this->is_descriptor_opened_ && this->name_.empty()); this->name_ = name; - this->descriptor_ = ::open(this->name_.c_str(), O_RDONLY); + this->descriptor_ = open_descriptor(-1, this->name_.c_str(), + O_RDONLY); if (this->descriptor_ >= 0) { + this->is_descriptor_opened_ = true; struct stat s; if (::fstat(this->descriptor_, &s) < 0) gold_error(_("%s: fstat failed: %s"), 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->token_.add_writer(task); } - this->token_.add_writer(task); - return this->descriptor_ >= 0; } @@ -133,14 +224,33 @@ File_read::open(const Task* task, const std::string& name, { gold_assert(this->token_.is_writable() && this->descriptor_ < 0 + && !this->is_descriptor_opened_ && this->name_.empty()); this->name_ = name; - this->contents_ = contents; + this->whole_file_view_ = new View(0, size, contents, 0, false, + View::DATA_NOT_OWNED); + this->add_view(this->whole_file_view_); this->size_ = size; this->token_.add_writer(task); return true; } +// Reopen a descriptor if necessary. + +void +File_read::reopen_descriptor() +{ + if (!this->is_descriptor_opened_) + { + this->descriptor_ = open_descriptor(this->descriptor_, + this->name_.c_str(), + O_RDONLY); + if (this->descriptor_ < 0) + gold_fatal(_("could not reopen file %s"), this->name_.c_str()); + this->is_descriptor_opened_ = true; + } +} + // Release the file. This is called when we are done with the file in // a Task. @@ -149,13 +259,30 @@ File_read::release() { gold_assert(this->is_locked()); - File_read::total_mapped_bytes += this->mapped_bytes_; - File_read::current_mapped_bytes += this->mapped_bytes_; + if (!parameters->options_valid() || parameters->options().stats()) + { + file_counts_initialize_lock.initialize(); + Hold_optional_lock hl(file_counts_lock); + File_read::total_mapped_bytes += this->mapped_bytes_; + File_read::current_mapped_bytes += this->mapped_bytes_; + if (File_read::current_mapped_bytes > File_read::maximum_mapped_bytes) + File_read::maximum_mapped_bytes = File_read::current_mapped_bytes; + } + this->mapped_bytes_ = 0; - if (File_read::current_mapped_bytes > File_read::maximum_mapped_bytes) - File_read::maximum_mapped_bytes = File_read::current_mapped_bytes; - this->clear_views(false); + // Only clear views if there is only one attached object. Otherwise + // we waste time trying to clear cached archive views. Similarly + // for releasing the descriptor. + if (this->object_count_ <= 1) + { + this->clear_views(CLEAR_VIEWS_NORMAL); + if (this->is_descriptor_opened_) + { + release_descriptor(this->descriptor_, false); + this->is_descriptor_opened_ = false; + } + } this->released_ = true; } @@ -166,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; } @@ -175,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); } @@ -193,57 +322,95 @@ File_read::is_locked() const // See if we have a view which covers the file starting at START for // SIZE bytes. Return a pointer to the View if found, NULL if not. +// If BYTESHIFT is not -1U, the returned View must have the specified +// byte shift; otherwise, it may have any byte shift. If VSHIFTED is +// not NULL, this sets *VSHIFTED to a view which would have worked if +// not for the requested BYTESHIFT. inline File_read::View* -File_read::find_view(off_t start, section_size_type size) const +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; + + // If we have the whole file mmapped, and the alignment is right, + // we can return it. + if (this->whole_file_view_) + if (byteshift == -1U || byteshift == 0) + return this->whole_file_view_; + off_t page = File_read::page_offset(start); - Views::const_iterator p = this->views_.lower_bound(page); - if (p == this->views_.end() || p->first > page) + unsigned int bszero = 0; + Views::const_iterator p = this->views_.upper_bound(std::make_pair(page - 1, + bszero)); + + while (p != this->views_.end() && p->first.first <= page) { - if (p == this->views_.begin()) - return NULL; - --p; - } + if (p->second->start() <= start + && (p->second->start() + static_cast(p->second->size()) + >= start + static_cast(size))) + { + if (byteshift == -1U || byteshift == p->second->byteshift()) + { + p->second->set_accessed(); + return p->second; + } - if (p->second->start() + static_cast(p->second->size()) - < start + static_cast(size)) - return NULL; + if (vshifted != NULL && *vshifted == NULL) + *vshifted = p->second; + } - p->second->set_accessed(); + ++p; + } - return p->second; + return NULL; } // Read SIZE bytes from the file starting at offset START. Read into // the buffer at P. void -File_read::do_read(off_t start, section_size_type size, void* p) const +File_read::do_read(off_t start, section_size_type size, void* p) { ssize_t bytes; - if (this->contents_ != NULL) + if (this->whole_file_view_ != NULL) { bytes = this->size_ - start; if (static_cast(bytes) >= size) { - memcpy(p, this->contents_ + start, size); + memcpy(p, this->whole_file_view_->data() + start, size); return; } } else { - bytes = ::pread(this->descriptor_, p, size, start); - if (static_cast(bytes) == size) - return; + this->reopen_descriptor(); - 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"), @@ -256,55 +423,60 @@ File_read::do_read(off_t start, section_size_type size, void* p) const // Read data from the file. void -File_read::read(off_t start, section_size_type size, void* p) const +File_read::read(off_t start, section_size_type size, void* p) { - const File_read::View* pv = this->find_view(start, size); + const File_read::View* pv = this->find_view(start, size, -1U, NULL); if (pv != NULL) { - memcpy(p, pv->data() + (start - pv->start()), size); + memcpy(p, pv->data() + (start - pv->start() + pv->byteshift()), size); return; } this->do_read(start, size, p); } -// Find an existing view or make a new one. +// Add a new view. There may already be an existing view at this +// offset. If there is, the new view will be larger, and should +// replace the old view. -File_read::View* -File_read::find_or_make_view(off_t start, section_size_type size, bool cache) +void +File_read::add_view(File_read::View* v) { - gold_assert(!this->token_.is_writable()); - this->released_ = false; + std::pair ins = + this->views_.insert(std::make_pair(std::make_pair(v->start(), + v->byteshift()), + v)); + if (ins.second) + return; - File_read::View* v = this->find_view(start, size); - if (v != NULL) + // There was an existing view at this offset. It must not be large + // enough. We can't delete it here, since something might be using + // it; we put it on a list to be deleted when the file is unlocked. + File_read::View* vold = ins.first->second; + gold_assert(vold->size() < v->size()); + if (vold->should_cache()) { - if (cache) - v->set_cache(); - return v; + v->set_cache(); + vold->clear_cache(); } + this->saved_views_.push_back(vold); - off_t poff = File_read::page_offset(start); + ins.first->second = v; +} - File_read::View* const vnull = NULL; - std::pair ins = - this->views_.insert(std::make_pair(poff, vnull)); +// Make a new view with a specified byteshift, reading the data from +// the file. - if (!ins.second) - { - // There was an existing view at this offset. It must not be - // large enough. We can't delete it here, since something might - // be using it; put it on a list to be deleted when the file is - // unlocked. - v = ins.first->second; - gold_assert(v->size() - (start - v->start()) < size); - if (v->should_cache()) - cache = true; - v->clear_cache(); - this->saved_views_.push_back(v); - } +File_read::View* +File_read::make_view(off_t start, section_size_type size, + unsigned int byteshift, bool cache) +{ + gold_assert(size > 0); + gold_assert(start <= this->size_ + && (static_cast(size) + <= static_cast(this->size_ - start))); - // We need to map data from the file. + off_t poff = File_read::page_offset(start); section_size_type psize = File_read::pages(size + (start - poff)); @@ -314,48 +486,150 @@ File_read::find_or_make_view(off_t start, section_size_type size, bool cache) gold_assert(psize >= size); } - if (this->contents_ != NULL) + void* p; + View::Data_ownership ownership; + if (byteshift != 0) { - unsigned char* p = new unsigned char[psize]; - this->do_read(poff, psize, p); - v = new File_read::View(poff, psize, p, cache, false); + p = malloc(psize + byteshift); + if (p == NULL) + gold_nomem(); + memset(p, 0, byteshift); + this->do_read(poff, psize, static_cast(p) + byteshift); + ownership = View::DATA_ALLOCATED_ARRAY; } else { - 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->reopen_descriptor(); + 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; +} + +// Find a View or make a new one, shifted as required by the file +// offset OFFSET and ALIGNED. + +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(poff), - static_cast(psize), - strerror(errno)); + static_cast(size), + static_cast(start)); - this->mapped_bytes_ += psize; + unsigned int byteshift; + if (offset == 0) + byteshift = 0; + else + { + unsigned int target_size = (!parameters->target_valid() + ? 64 + : parameters->target().get_size()); + byteshift = offset & ((target_size / 8) - 1); + + // Set BYTESHIFT to the number of dummy bytes which must be + // inserted before the data in order for this data to be + // aligned. + if (byteshift != 0) + byteshift = (target_size / 8) - byteshift; + } - const unsigned char* pbytes = static_cast(p); - v = new File_read::View(poff, psize, pbytes, cache, true); + // If --map-whole-files is set, make sure we have a + // whole file view. Options may not yet be ready, e.g., + // when reading a version script. We then default to + // --no-map-whole-files. + if (this->whole_file_view_ == NULL + && parameters->options_valid() + && parameters->options().map_whole_files()) + this->whole_file_view_ = this->make_view(0, this->size_, 0, cache); + + // Try to find a View with the required BYTESHIFT. + File_read::View* vshifted; + File_read::View* v = this->find_view(offset + start, size, + aligned ? byteshift : -1U, + &vshifted); + if (v != NULL) + { + if (cache) + v->set_cache(); + return v; } - ins.first->second = v; - return v; + // If VSHIFTED is not NULL, then it has the data we need, but with + // the wrong byteshift. + v = vshifted; + if (v != NULL) + { + gold_assert(aligned); + + 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, + cache, View::DATA_ALLOCATED_ARRAY); + + this->add_view(shifted_view); + return shifted_view; + } + + // Make a new view. If we don't need an aligned view, use a + // byteshift of 0, so that we can use mmap. + return this->make_view(offset + start, size, + aligned ? byteshift : 0, + cache); } // Get a view into the file. const unsigned char* -File_read::get_view(off_t start, section_size_type size, bool cache) +File_read::get_view(off_t offset, off_t start, section_size_type size, + bool aligned, bool cache) { - File_read::View* pv = this->find_or_make_view(start, size, cache); - return pv->data() + (start - pv->start()); + File_read::View* pv = this->find_or_make_view(offset, start, size, + aligned, cache); + return pv->data() + (offset + start - pv->start() + pv->byteshift()); } File_view* -File_read::get_lasting_view(off_t start, section_size_type size, bool cache) +File_read::get_lasting_view(off_t offset, off_t start, section_size_type size, + bool aligned, bool cache) { - File_read::View* pv = this->find_or_make_view(start, size, cache); + File_read::View* pv = this->find_or_make_view(offset, start, size, + aligned, cache); pv->lock(); - return new File_view(*this, pv, pv->data() + (start - pv->start())); + return new File_view(*this, pv, + (pv->data() + + (offset + start - pv->start() + pv->byteshift()))); } // Use readv to read COUNT entries from RM starting at START. BASE @@ -397,6 +671,8 @@ File_read::do_readv(off_t base, const Read_multiple& rm, size_t start, last_offset = i_entry.file_offset + i_entry.size; } + this->reopen_descriptor(); + gold_assert(iov_index < sizeof iov / sizeof iov[0]); if (::lseek(this->descriptor_, base + first_offset, SEEK_SET) < 0) @@ -414,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) @@ -431,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; @@ -447,21 +734,23 @@ File_read::read_multiple(off_t base, const Read_multiple& rm) else { File_read::View* view = this->find_view(base + i_off, - end_off - i_off); + end_off - i_off, + -1U, NULL); if (view == NULL) this->do_readv(base, rm, i, j - i); else { const unsigned char* v = (view->data() - + (base + i_off - view->start())); + + (base + i_off - view->start() + + view->byteshift())); for (size_t k = i; k < j; ++k) { 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); @@ -500,25 +789,33 @@ File_read::clear_view_cache_marks() // the next object. void -File_read::clear_views(bool destroying) +File_read::clear_views(Clear_views_mode mode) { + bool keep_files_mapped = (parameters->options_valid() + && parameters->options().keep_files_mapped()); Views::iterator p = this->views_.begin(); while (p != this->views_.end()) { bool should_delete; - if (p->second->is_locked()) + if (p->second->is_locked() || p->second->is_permanent_view()) should_delete = false; - else if (destroying) + else if (mode == CLEAR_VIEWS_ALL) should_delete = true; - else if (p->second->should_cache()) + 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()) + else if (this->object_count_ > 1 + && p->second->accessed() + && mode != CLEAR_VIEWS_ARCHIVE) should_delete = false; else should_delete = true; if (should_delete) { + if (p->second == this->whole_file_view_) + this->whole_file_view_ = NULL; delete p->second; // map::erase invalidates only the iterator to the deleted @@ -529,7 +826,6 @@ File_read::clear_views(bool destroying) } else { - gold_assert(!destroying); p->second->clear_accessed(); ++p; } @@ -545,7 +841,7 @@ File_read::clear_views(bool destroying) } else { - gold_assert(!destroying); + gold_assert(mode != CLEAR_VIEWS_ALL); ++q; } } @@ -572,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, @@ -579,9 +885,9 @@ Input_file::Input_file(const Task* task, const char* name, : file_() { this->input_argument_ = - new Input_file_argument(name, false, "", false, - Position_dependent_options()); - bool ok = file_.open(task, name, contents, size); + new Input_file_argument(name, Input_file_argument::INPUT_FILE_TYPE_FILE, + "", false, Position_dependent_options()); + bool ok = this->file_.open(task, name, contents, size); gold_assert(ok); } @@ -601,6 +907,16 @@ Input_file::name() const return this->input_argument_->name(); } +// Return whether this file is in a system directory. + +bool +Input_file::is_in_system_directory() const +{ + if (this->is_in_sysroot()) + return true; + return parameters->options().is_in_system_directory(this->filename()); +} + // Return whether we are only reading symbols. bool @@ -609,102 +925,192 @@ Input_file::just_symbols() const return this->input_argument_->just_symbols(); } -// Open the file. +// Return whether this is a file that we will search for in the list +// of directories. + +bool +Input_file::will_search_for() const +{ + return (!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)); +} + +// Return the file last modification time. Calls gold_fatal if the stat +// system call failed. + +Timespec +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)); +#ifdef HAVE_STAT_ST_MTIM + return Timespec(file_stat.st_mtim.tv_sec, file_stat.st_mtim.tv_nsec); +#else + return Timespec(file_stat.st_mtime, 0); +#endif +} + +// 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; or -// B) input_argument_->extra_search_path() is not empty. -// In both cases, we look in extra_search_path + library_path to find +// A) input_argument_->is_lib() is true; +// B) input_argument_->is_searched_file() is true; or +// C) input_argument_->extra_search_path() is not empty. +// In each, we look in extra_search_path + library_path to find // the file location, rather than the current directory. bool -Input_file::open(const General_options& options, const Dirsearch& dirpath, - const Task* task) +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 and extra_search_path - // is empty - if (IS_ABSOLUTE_PATH (this->input_argument_->name()) - || (!this->input_argument_->is_lib() - && this->input_argument_->extra_search_path() == NULL)) + // 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(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 - else if (this->input_argument_->is_lib()) + // Case 3: is_lib is true or is_searched_file is true + 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("lib"); - n1 += this->input_argument_->name(); - std::string n2; - if (options.is_static() - || this->input_argument_->options().Bstatic()) - n1 += ".a"; - else + std::vector names; + names.reserve(2); + if (input_argument->is_lib()) { - n2 = n1 + ".a"; - n1 += ".so"; + std::string prefix = "lib"; + prefix += input_argument->name(); + if (parameters->options().is_static() + || !input_argument->options().Bdynamic()) + names.push_back(prefix + ".a"); + else + { + names.push_back(prefix + ".so"); + names.push_back(prefix + ".a"); + } } - name = dirpath.find(n1, n2, &this->is_in_sysroot_); + else + 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 -l%s"), - this->input_argument_->name()); + gold_error(_("cannot find %s%s"), + 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 (::stat(name.c_str(), &dummy_stat) < 0) - { - // extra_search_path failed, so check the normal search-path. - name = dirpath.find(this->input_argument_->name(), "", - &this->is_in_sysroot_); - if (name.empty()) - { - gold_error(_("cannot find %s"), - this->input_argument_->name()); - return false; - } - } - 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. General_options::Object_format format = - this->input_argument_->options().format(); + this->input_argument_->options().format_enum(); bool ok; if (format == General_options::OBJECT_FORMAT_ELF) - ok = this->file_.open(task, name); + { + ok = this->file_.open(task, name); + this->format_ = FORMAT_ELF; + } else { gold_assert(format == General_options::OBJECT_FORMAT_BINARY); - ok = this->open_binary(options, task, name); + ok = this->open_binary(task, name); + this->format_ = FORMAT_BINARY; } if (!ok) { gold_error(_("cannot open %s: %s"), name.c_str(), strerror(errno)); + this->format_ = FORMAT_NONE; return false; } @@ -714,21 +1120,17 @@ Input_file::open(const General_options& options, const Dirsearch& dirpath, // Open a file for --format binary. bool -Input_file::open_binary(const General_options&, - const Task* task, const std::string& name) +Input_file::open_binary(const Task* task, const std::string& name) { // In order to open a binary file, we need machine code, size, and // endianness. We may not have a valid target at this point, in // which case we use the default target. - const Target* target; - if (parameters->target_valid()) - target = ¶meters->target(); - else - target = ¶meters->default_target(); + parameters_force_valid_target(); + const Target& target(parameters->target()); - Binary_to_elf binary_to_elf(target->machine_code(), - target->get_size(), - target->is_big_endian(), + Binary_to_elf binary_to_elf(target.machine_code(), + target.get_size(), + target.is_big_endian(), name); if (!binary_to_elf.convert(task)) return false;