X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gold%2Ffileread.h;h=2e27d2f82e2d515be72898990dacfad8fe411654;hb=91d6fa6a035cc7d0b7be5c99c194a64cb80924b0;hp=abeb28e07b952f2fdb6cbc9dfa7210519120e703;hpb=ad2d6943a49fa11ba1e23749973c75feb12dcf6b;p=deliverable%2Fbinutils-gdb.git diff --git a/gold/fileread.h b/gold/fileread.h index abeb28e07b..2e27d2f82e 100644 --- a/gold/fileread.h +++ b/gold/fileread.h @@ -1,6 +1,6 @@ // fileread.h -- read files for gold -*- C++ -*- -// Copyright 2006, 2007 Free Software Foundation, Inc. +// Copyright 2006, 2007, 2008, 2009 Free Software Foundation, Inc. // Written by Ian Lance Taylor . // This file is part of gold. @@ -28,57 +28,103 @@ #include #include #include +#include -#include "options.h" +#include "token.h" namespace gold { +// Since not all system supports stat.st_mtim and struct timespec, +// we define our own structure and fill the nanoseconds if we can. + +struct Timespec +{ + Timespec() + : seconds(0), nanoseconds(0) + { } + + Timespec(time_t a_seconds, int a_nanoseconds) + : seconds(a_seconds), nanoseconds(a_nanoseconds) + { } + + time_t seconds; + int nanoseconds; +}; + +class Position_dependent_options; +class Input_file_argument; class Dirsearch; class File_view; -// File_read manages a file descriptor for a file we are reading. We -// close file descriptors if we run out of them, so this class reopens -// the file as needed. +// File_read manages a file descriptor and mappings for a file we are +// reading. class File_read { public: File_read() - : name_(), descriptor_(-1), size_(0), lock_count_(0), views_(), - saved_views_(), contents_(NULL) + : name_(), descriptor_(-1), is_descriptor_opened_(false), object_count_(0), + size_(0), token_(false), views_(), saved_views_(), mapped_bytes_(0), + released_(true), whole_file_view_(NULL) { } ~File_read(); // Open a file. bool - open(const std::string& name); + open(const Task*, const std::string& name); // Pretend to open the file, but provide the file contents. No // actual file system activity will occur. This is used for // testing. bool - open(const std::string& name, const unsigned char* contents, off_t size); + open(const Task*, const std::string& name, const unsigned char* contents, + off_t size); // Return the file name. const std::string& filename() const { return this->name_; } - // Lock the file for access within a particular Task::run execution. - // This means that the descriptor can not be closed. This routine - // may only be called from the main thread. + // Add an object associated with a file. + void + add_object() + { ++this->object_count_; } + + // Remove an object associated with a file. + void + remove_object() + { --this->object_count_; } + + // Lock the file for exclusive access within a particular Task::run + // execution. This routine may only be called when the workqueue + // lock is held. void - lock(); + lock(const Task* t); - // Unlock the descriptor, permitting it to be closed if necessary. + // Unlock the file. void - unlock(); + unlock(const Task* t); // Test whether the object is locked. bool - is_locked(); + is_locked() const; + + // Return the token, so that the task can be queued. + Task_token* + token() + { return &this->token_; } + + // Release the file. This indicates that we aren't going to do + // anything further with it until it is unlocked. This is used + // because a Task which locks the file never calls either lock or + // unlock; it just locks the token. The basic rule is that a Task + // which locks a file via the Task::locks interface must explicitly + // call release() when it is done. This is not necessary for code + // which calls unlock() on the file. + void + release(); // Return the size of the file. off_t @@ -86,42 +132,125 @@ class File_read { return this->size_; } // Return a view into the file starting at file offset START for - // SIZE bytes. The pointer will remain valid until the File_read is - // unlocked. It is an error if we can not read enough data from the - // file. The CACHE parameter is a hint as to whether it will be + // SIZE bytes. OFFSET is the offset into the input file for the + // file we are reading; this is zero for a normal object file, + // non-zero for an object file in an archive. ALIGNED is true if + // the data must be naturally aligned; this only matters when OFFSET + // is not zero. The pointer will remain valid until the File_read + // is unlocked. It is an error if we can not read enough data from + // the file. The CACHE parameter is a hint as to whether it will be // useful to cache this data for later accesses--i.e., later calls // to get_view, read, or get_lasting_view which retrieve the same // data. const unsigned char* - get_view(off_t start, off_t size, bool cache); + get_view(off_t offset, off_t start, section_size_type size, bool aligned, + bool cache); // Read data from the file into the buffer P starting at file offset // START for SIZE bytes. void - read(off_t start, off_t size, void* p); + read(off_t start, section_size_type size, void* p); // Return a lasting view into the file starting at file offset START // for SIZE bytes. This is allocated with new, and the caller is // responsible for deleting it when done. The data associated with // this view will remain valid until the view is deleted. It is an - // error if we can not read enough data from the file. The CACHE - // parameter is as in get_view. + // error if we can not read enough data from the file. The OFFSET, + // ALIGNED and CACHE parameters are as in get_view. File_view* - get_lasting_view(off_t start, off_t size, bool cache); + get_lasting_view(off_t offset, off_t start, section_size_type size, + bool aligned, bool cache); + + // Mark all views as no longer cached. + void + clear_view_cache_marks(); + + // Discard all uncached views. This is normally done by release(), + // but not for objects in archives. FIXME: This is a complicated + // interface, and it would be nice to have something more automatic. + void + clear_uncached_views() + { this->clear_views(false); } + + // A struct used to do a multiple read. + struct Read_multiple_entry + { + // The file offset of the data to read. + off_t file_offset; + // The amount of data to read. + section_size_type size; + // The buffer where the data should be placed. + unsigned char* buffer; + + Read_multiple_entry(off_t o, section_size_type s, unsigned char* b) + : file_offset(o), size(s), buffer(b) + { } + }; + + typedef std::vector Read_multiple; + + // Read a bunch of data from the file into various different + // locations. The vector must be sorted by ascending file_offset. + // BASE is a base offset to be added to all the offsets in the + // vector. + void + read_multiple(off_t base, const Read_multiple&); + + // Dump statistical information to stderr. + static void + print_stats(); + + // Return the open file descriptor (for plugins). + int + descriptor() + { + this->reopen_descriptor(); + return this->descriptor_; + } + + // Return the file last modification time. Calls gold_fatal if the stat + // system call failed. + Timespec + get_mtime(); private: // This class may not be copied. File_read(const File_read&); File_read& operator=(const File_read&); + // Total bytes mapped into memory during the link. This variable + // may not be accurate when running multi-threaded. + static unsigned long long total_mapped_bytes; + + // Current number of bytes mapped into memory during the link. This + // variable may not be accurate when running multi-threaded. + static unsigned long long current_mapped_bytes; + + // High water mark of bytes mapped into memory during the link. + // This variable may not be accurate when running multi-threaded. + static unsigned long long maximum_mapped_bytes; + // A view into the file. class View { public: - View(off_t start, off_t size, const unsigned char* data, bool cache, - bool mapped) - : start_(start), size_(size), data_(data), lock_count_(0), - cache_(cache), mapped_(mapped) + // Specifies how to dispose the data on destruction of the view. + enum Data_ownership + { + // Data owned by File object - nothing done in destructor. + DATA_NOT_OWNED, + // Data alocated with new[] and owned by this object - should + // use delete[]. + DATA_ALLOCATED_ARRAY, + // Data mmapped and owned by this object - should munmap. + DATA_MMAPPED + }; + + View(off_t vstart, section_size_type vsize, const unsigned char* vdata, + unsigned int vbyteshift, bool cache, Data_ownership data_ownership) + : start_(vstart), size_(vsize), data_(vdata), lock_count_(0), + byteshift_(vbyteshift), cache_(cache), data_ownership_(data_ownership), + accessed_(true) { } ~View(); @@ -130,7 +259,7 @@ class File_read start() const { return this->start_; } - off_t + section_size_type size() const { return this->size_; } @@ -147,39 +276,94 @@ class File_read bool is_locked(); + unsigned int + byteshift() const + { return this->byteshift_; } + void set_cache() { this->cache_ = true; } + void + clear_cache() + { this->cache_ = false; } + bool should_cache() const { return this->cache_; } + void + set_accessed() + { this->accessed_ = true; } + + void + clear_accessed() + { this->accessed_= false; } + + bool + accessed() const + { return this->accessed_; } + private: View(const View&); View& operator=(const View&); + // The file offset of the start of the view. off_t start_; - off_t size_; + // The size of the view. + section_size_type size_; + // A pointer to the actual bytes. const unsigned char* data_; + // The number of locks on this view. int lock_count_; + // The number of bytes that the view is shifted relative to the + // underlying file. This is used to align data. This is normally + // zero, except possibly for an object in an archive. + unsigned int byteshift_; + // Whether the view is cached. bool cache_; - bool mapped_; + // Whether the view is mapped into memory. If not, data_ points + // to memory allocated using new[]. + Data_ownership data_ownership_; + // Whether the view has been accessed recently. + bool accessed_; }; + friend class View; friend class File_view; + // The type of a mapping from page start and byte shift to views. + typedef std::map, View*> Views; + + // A simple list of Views. + typedef std::list Saved_views; + + // Open the descriptor if necessary. + void + reopen_descriptor(); + // Find a view into the file. View* - find_view(off_t start, off_t size); + find_view(off_t start, section_size_type size, unsigned int byteshift, + View** vshifted) const; // Read data from the file into a buffer. void - do_read(off_t start, off_t size, void* p); + do_read(off_t start, section_size_type size, void* p); + + // Add a view. + void + add_view(View*); + + // Make a view into the file. + View* + make_view(off_t start, section_size_type size, unsigned int byteshift, + bool cache); // Find or make a view into the file. View* - find_or_make_view(off_t start, off_t size, bool cache); + find_or_make_view(off_t offset, off_t start, section_size_type size, + bool aligned, bool cache); // Clear the file views. void @@ -198,27 +382,49 @@ class File_read pages(off_t file_size) { return (file_size + (page_size - 1)) & ~ (page_size - 1); } - // The type of a mapping from page start to views. - typedef std::map Views; + // The maximum number of entries we will pass to ::readv. +#ifdef HAVE_READV + static const size_t max_readv_entries = 128; +#else + // On targets that don't have readv set the max to 1 so readv is not + // used. + static const size_t max_readv_entries = 1; +#endif - // A simple list of Views. - typedef std::list Saved_views; + // Use readv to read data. + void + do_readv(off_t base, const Read_multiple&, size_t start, size_t count); // File name. std::string name_; // File descriptor. int descriptor_; + // Whether we have regained the descriptor after releasing the file. + bool is_descriptor_opened_; + // The number of objects associated with this file. This will be + // more than 1 in the case of an archive. + int object_count_; // File size. off_t size_; - // Number of locks on the file. - int lock_count_; + // A token used to lock the file. + Task_token token_; // Buffered views into the file. Views views_; // List of views which were locked but had to be removed from views_ // because they were not large enough. Saved_views saved_views_; - // Specified file contents. Used only for testing purposes. - const unsigned char* contents_; + // Total amount of space mapped into memory. This is only changed + // while the file is locked. When we unlock the file, we transfer + // the total to total_mapped_bytes, and reset this to zero. + size_t mapped_bytes_; + // Whether the file was released. + bool released_; + // A view containing the whole file. May be NULL if we mmap only + // the relevant parts of the file. Not NULL if: + // - Flag --mmap_whole_files is set (default on 64-bit hosts). + // - The contents was specified in the constructor. Used only for + // testing purposes). + View* whole_file_view_; }; // A view of file data that persists even when the file is unlocked. @@ -244,8 +450,8 @@ class File_view friend class File_read; // Callers have to get these via File_read::get_lasting_view. - File_view(File_read& file, File_read::View* view, const unsigned char* data) - : file_(file), view_(view), data_(data) + File_view(File_read& file, File_read::View* view, const unsigned char* vdata) + : file_(file), view_(view), data_(vdata) { } File_read& file_; @@ -260,49 +466,92 @@ class Input_file { public: Input_file(const Input_file_argument* input_argument) - : input_argument_(input_argument), file_(), is_in_sysroot_(false) + : input_argument_(input_argument), found_name_(), file_(), + is_in_sysroot_(false) { } // Create an input file with the contents already provided. This is // only used for testing. With this path, don't call the open // method. - Input_file(const char* name, const unsigned char* contents, off_t size); + Input_file(const Task*, const char* name, const unsigned char* contents, + off_t size); - // Open the file. - void - open(const General_options&, const Dirsearch&); + // Return the command line argument. + const Input_file_argument* + input_file_argument() const + { return this->input_argument_; } - // Return the name given by the user. + // Return whether this is a file that we will search for in the list + // of directories. + bool + will_search_for() const; + + // Open the file. If the open fails, this will report an error and + // return false. If there is a search, it starts at directory + // *PINDEX. *PINDEX should be initialized to zero. It may be + // restarted to find the next file with a matching name by + // incrementing the result and calling this again. + bool + open(const Dirsearch&, const Task*, int *pindex); + + // Return the name given by the user. For -lc this will return "c". const char* - name() const - { return this->input_argument_->name(); } + name() const; - // Return the file name. + // Return the file name. For -lc this will return something like + // "/usr/lib/libc.so". const std::string& filename() const { return this->file_.filename(); } + // Return the name under which we found the file, corresponding to + // the command line. For -lc this will return something like + // "libc.so". + const std::string& + found_name() const + { return this->found_name_; } + // Return the position dependent options. const Position_dependent_options& - options() const - { return this->input_argument_->options(); } + options() const; // Return the file. File_read& file() { return this->file_; } + const File_read& + file() const + { return this->file_; } + // Whether we found the file in a directory in the system root. bool is_in_sysroot() const { return this->is_in_sysroot_; } + // Whether this file is in a system directory. + bool + is_in_system_directory() const; + + // Return whether this file is to be read only for its symbols. + bool + just_symbols() const; + private: Input_file(const Input_file&); Input_file& operator=(const Input_file&); + // Open a binary file. + bool + open_binary(const Task* task, const std::string& name); + // The argument from the command line. const Input_file_argument* input_argument_; + // The name under which we opened the file. This is like the name + // on the command line, but -lc turns into libc.so (or whatever). + // It only includes the full path if the path was on the command + // line. + std::string found_name_; // The file after we open it. File_read file_; // Whether we found the file in a directory in the system root.