mirror of
https://github.com/darlinghq/darling-gdb.git
synced 2024-12-05 02:47:05 +00:00
15f8229bbf
(Read_symbols::requeue): New function. (Read_symbols::do_read_symbols): If make_elf_object fails because the target type is not configured, and the file was searched for, issue a warning and retry with the next directory. (Add_symbols::run): If the file has an incompatible format, and it was searched for, requeue the Read_symbols task. On error, release the object. * readsyms.h (class Read_symbols): Add dirindex_ field. Add dirindex parameter to constructor. Change all callers. Declare incompatible_warning and requeue. (class Add_symbols): Add dirpath_, dirindex_, mapfile_, input_argument_ and input_group_ fields. Add them to constructor. Change all callers. (class Read_script): Add dirindex_ field. Add it to constructor. Change all callers. * archive.cc (Archive::setup): Remove input_objects parameter. Change all callers. (Archive::get_file_and_offset): Likewise. (Archive::read_all_symbols): Likewise. (Archive::read_symbols): Likewise. (Archive::get_elf_object_for_member): Remove input_objects parameter. Add punconfigured parameter. Change all callers. (Archive::add_symbols): Change return type to bool. Check return value of include_member. (Archive::include_all_members): Likewise. (Archive::include_member): Change return type to bool. Return false if first included object has incompatible target. Set included_member_ field. (Add_archive_symbols::run): If add_symbols returns false, requeue Read_symbols task. * archive.h (class Archive): Add included_member_ field. Initialize it in constructor. Add input_file and searched_for methods. Update declarations. (class Add_archive_symbols): Add dirpath_, dirindex_, and input_argument_ fields. Add them to constructor. Change all callers. * script.cc: Include "target-select.h". (class Parser_closure): Add skip_on_incompatible_target_ and found_incompatible_target_ fields. Add skip_on_incompatible_target parameter to constructor. Change all callers. Add methods skip_on_incompatible_target, clear_skip_on_incompatible_target, found_incompatible_target, and set_found_incompatible_target. (read_input_script): Add dirindex parameter. Change all callers. If parser finds an incompatible target, requeue Read_symbols task. (script_set_symbol): Clear skip_on_incompatible_target in closure. (script_add_assertion, script_parse_option): Likewise. (script_start_sections, script_add_phdr): Likewise. (script_check_output_format): New function. * script.h (read_input_script): Update declaration. * script-c.h (script_check_output_format): Declare. * yyscript.y (file_cmd): Handle OUTPUT_FORMAT. (ignore_cmd): Remove OUTPUT_FORMAT. * fileread.cc (Input_file::Input_file): Add explicit this. (Input_file::will_search_for): New function. (Input_file::open): Add pindex parameter. Change all callers. * fileread.h (class Input_file): Add input_file_argument method. Declare will_search_for. Update declarations. * object.cc (make_elf_object): Add punconfigured parameter. Change all callers. * object.h (class Object): Make input_file public. Add searched_for method. (make_elf_object): Update declaration. * dirsearch.cc (Dirsearch::find): Add pindex parameter. Use it to restart search. * dirsearch.h (class Dirsearch): Update declaration. * options.h (class General_options): Add --warn-search-mismatch. * parameters.cc (Parameters::is_compatible_target): New function. * parameters.h (class Parameters): Declare is_compatible_target. * workqueue.cc (Workqueue::add_blocker): New function. * workqueue.h (class Workqueue): Declare add_blocker.
519 lines
14 KiB
C++
519 lines
14 KiB
C++
// fileread.h -- read files for gold -*- C++ -*-
|
|
|
|
// Copyright 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
|
|
// Written by Ian Lance Taylor <iant@google.com>.
|
|
|
|
// This file is part of gold.
|
|
|
|
// This program is free software; you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation; either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with this program; if not, write to the Free Software
|
|
// Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
|
|
// MA 02110-1301, USA.
|
|
|
|
// Classes used to read data from binary input files.
|
|
|
|
#ifndef GOLD_FILEREAD_H
|
|
#define GOLD_FILEREAD_H
|
|
|
|
#include <list>
|
|
#include <map>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
#include "token.h"
|
|
|
|
namespace gold
|
|
{
|
|
|
|
class Position_dependent_options;
|
|
class Input_file_argument;
|
|
class Dirsearch;
|
|
class File_view;
|
|
|
|
// File_read manages a file descriptor and mappings for a file we are
|
|
// reading.
|
|
|
|
class File_read
|
|
{
|
|
public:
|
|
File_read()
|
|
: name_(), descriptor_(-1), is_descriptor_opened_(false), object_count_(0),
|
|
size_(0), token_(false), views_(), saved_views_(), contents_(NULL),
|
|
mapped_bytes_(0), released_(true)
|
|
{ }
|
|
|
|
~File_read();
|
|
|
|
// Open a file.
|
|
bool
|
|
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 Task*, const std::string& name, const unsigned char* contents,
|
|
off_t size);
|
|
|
|
// Return the file name.
|
|
const std::string&
|
|
filename() const
|
|
{ return this->name_; }
|
|
|
|
// 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(const Task* t);
|
|
|
|
// Unlock the file.
|
|
void
|
|
unlock(const Task* t);
|
|
|
|
// Test whether the object is locked.
|
|
bool
|
|
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
|
|
filesize() const
|
|
{ return this->size_; }
|
|
|
|
// Return a view into the file starting at file offset START for
|
|
// 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 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, 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 OFFSET,
|
|
// ALIGNED and CACHE parameters are as in get_view.
|
|
File_view*
|
|
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_entry> 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_;
|
|
}
|
|
|
|
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, section_size_type size, const unsigned char* data,
|
|
unsigned int byteshift, bool cache, bool mapped)
|
|
: start_(start), size_(size), data_(data), lock_count_(0),
|
|
byteshift_(byteshift), cache_(cache), mapped_(mapped), accessed_(true)
|
|
{ }
|
|
|
|
~View();
|
|
|
|
off_t
|
|
start() const
|
|
{ return this->start_; }
|
|
|
|
section_size_type
|
|
size() const
|
|
{ return this->size_; }
|
|
|
|
const unsigned char*
|
|
data() const
|
|
{ return this->data_; }
|
|
|
|
void
|
|
lock();
|
|
|
|
void
|
|
unlock();
|
|
|
|
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_;
|
|
// 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_;
|
|
// Whether the view is mapped into memory. If not, data_ points
|
|
// to memory allocated using new[].
|
|
bool mapped_;
|
|
// 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<std::pair<off_t, unsigned int>, View*> Views;
|
|
|
|
// A simple list of Views.
|
|
typedef std::list<View*> Saved_views;
|
|
|
|
// Open the descriptor if necessary.
|
|
void
|
|
reopen_descriptor();
|
|
|
|
// Find a view into the file.
|
|
View*
|
|
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, 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 offset, off_t start, section_size_type size,
|
|
bool aligned, bool cache);
|
|
|
|
// Clear the file views.
|
|
void
|
|
clear_views(bool);
|
|
|
|
// The size of a file page for buffering data.
|
|
static const off_t page_size = 8192;
|
|
|
|
// Given a file offset, return the page offset.
|
|
static off_t
|
|
page_offset(off_t file_offset)
|
|
{ return file_offset & ~ (page_size - 1); }
|
|
|
|
// Given a file size, return the size to read integral pages.
|
|
static off_t
|
|
pages(off_t file_size)
|
|
{ return (file_size + (page_size - 1)) & ~ (page_size - 1); }
|
|
|
|
// The maximum number of entries we will pass to ::readv.
|
|
static const size_t max_readv_entries = 128;
|
|
|
|
// 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_;
|
|
// 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 of file data that persists even when the file is unlocked.
|
|
// Callers should destroy these when no longer required. These are
|
|
// obtained form File_read::get_lasting_view. They may only be
|
|
// destroyed when the underlying File_read is locked.
|
|
|
|
class File_view
|
|
{
|
|
public:
|
|
// This may only be called when the underlying File_read is locked.
|
|
~File_view();
|
|
|
|
// Return a pointer to the data associated with this view.
|
|
const unsigned char*
|
|
data() const
|
|
{ return this->data_; }
|
|
|
|
private:
|
|
File_view(const File_view&);
|
|
File_view& operator=(const 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_read& file_;
|
|
File_read::View* view_;
|
|
const unsigned char* data_;
|
|
};
|
|
|
|
// All the information we hold for a single input file. This can be
|
|
// an object file, a shared library, or an archive.
|
|
|
|
class Input_file
|
|
{
|
|
public:
|
|
Input_file(const Input_file_argument* input_argument)
|
|
: 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 Task*, const char* name, const unsigned char* contents,
|
|
off_t size);
|
|
|
|
// Return the command line argument.
|
|
const Input_file_argument*
|
|
input_file_argument() const
|
|
{ return this->input_argument_; }
|
|
|
|
// 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 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 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.
|
|
bool is_in_sysroot_;
|
|
};
|
|
|
|
} // end namespace gold
|
|
|
|
#endif // !defined(GOLD_FILEREAD_H)
|