X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gold%2Freadsyms.h;h=5e5f27fbe89b0c933a56ec9adf10b00008b322df;hb=488d02fe7729dda5b9414a3942df68e0c316ce53;hp=bad96c115650413cf7c44bf7d33dcb3c885ce85b;hpb=bae7f79e03d6405f5ceec0e3e24671e6b30f29ed;p=deliverable%2Fbinutils-gdb.git diff --git a/gold/readsyms.h b/gold/readsyms.h index bad96c1156..5e5f27fbe8 100644 --- a/gold/readsyms.h +++ b/gold/readsyms.h @@ -1,15 +1,43 @@ // readsyms.h -- read input file symbols for gold -*- C++ -*- +// Copyright (C) 2006-2019 Free Software Foundation, Inc. +// Written by Ian Lance Taylor . + +// 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. + #ifndef GOLD_READSYMS_H #define GOLD_READSYMS_H -#include "targetsize.h" +#include + #include "workqueue.h" #include "object.h" +#include "incremental.h" namespace gold { +class Input_objects; +class Symbol_table; +class Input_group; +class Archive; +class Finish_group; + // This Task is responsible for reading the symbols from an input // file. This also includes reading the relocations so that we can // check for any that require a PLT and/or a GOT. After the data has @@ -22,34 +50,78 @@ class Read_symbols : public Task { public: // DIRPATH is the list of directories to search for libraries. - // INPUT is the file to read. THIS_BLOCKER is used to prevent the - // associated Add_symbols task from running before the previous one - // has completed; it will be NULL for the first task. NEXT_BLOCKER - // is used to block the next input file from adding symbols. - Read_symbols(const General_options& options, const Dirsearch& dirpath, - const Input_argument& input, Task_token* this_blocker, - Task_token* next_blocker) - : options_(options), dirpath_(dirpath), input_(input), - this_blocker_(this_blocker), next_blocker_(next_blocker) + // INPUT is the file to read. INPUT_GROUP is not NULL if we are in + // the middle of an input group. THIS_BLOCKER is used to prevent + // the associated Add_symbols task from running before the previous + // one has completed; it will be NULL for the first task. + // NEXT_BLOCKER is used to block the next input file from adding + // symbols. + Read_symbols(Input_objects* input_objects, Symbol_table* symtab, + Layout* layout, Dirsearch* dirpath, int dirindex, + Mapfile* mapfile, const Input_argument* input_argument, + Input_group* input_group, Archive_member* member, + Task_token* this_blocker, Task_token* next_blocker) + : input_objects_(input_objects), symtab_(symtab), layout_(layout), + dirpath_(dirpath), dirindex_(dirindex), mapfile_(mapfile), + input_argument_(input_argument), input_group_(input_group), + member_(member), this_blocker_(this_blocker), + next_blocker_(next_blocker) { } ~Read_symbols(); + // If appropriate, issue a warning about skipping an incompatible + // object. + static void + incompatible_warning(const Input_argument*, const Input_file*); + + // Requeue a Read_symbols task to search for the next object with + // the same name. + static void + requeue(Workqueue*, Input_objects*, Symbol_table*, Layout*, Dirsearch*, + int dirindex, Mapfile*, const Input_argument*, Input_group*, + Task_token* next_blocker); + // The standard Task methods. - Is_runnable_type - is_runnable(Workqueue*); + Task_token* + is_runnable(); - Task_locker* - locks(Workqueue*); + void + locks(Task_locker*); void run(Workqueue*); + std::string + get_name() const; + private: - const General_options& options_; - const Dirsearch& dirpath_; - const Input_argument& input_; + // Handle an archive group. + void + do_group(Workqueue*); + + // Handle --start-lib ... --end-lib + bool + do_lib_group(Workqueue*); + + // Handle --whole-archive --start-lib ... --end-lib --no-whole-archive + bool + do_whole_lib_group(Workqueue*); + + // Open and identify the file. + bool + do_read_symbols(Workqueue*); + + Input_objects* input_objects_; + Symbol_table* symtab_; + Layout* layout_; + Dirsearch* dirpath_; + int dirindex_; + Mapfile* mapfile_; + const Input_argument* input_argument_; + Input_group* input_group_; + Archive_member* member_; Task_token* this_blocker_; Task_token* next_blocker_; }; @@ -64,28 +136,352 @@ class Add_symbols : public Task // THIS_BLOCKER is used to prevent this task from running before the // one for the previous input file. NEXT_BLOCKER is used to prevent // the next task from running. - Add_symbols(Object* object, Read_symbols_data sd, Task_token* this_blocker, + Add_symbols(Input_objects* input_objects, Symbol_table* symtab, + Layout* layout, Dirsearch* /*dirpath*/, int /*dirindex*/, + Mapfile* /*mapfile*/, const Input_argument* input_argument, + Object* object, Incremental_library* library, + Read_symbols_data* sd, Task_token* this_blocker, Task_token* next_blocker) - : object_(object), sd_(sd), this_blocker_(this_blocker), - next_blocker_(next_blocker) + : input_objects_(input_objects), symtab_(symtab), layout_(layout), + input_argument_(input_argument), object_(object), library_(library), + sd_(sd), this_blocker_(this_blocker), next_blocker_(next_blocker) { } ~Add_symbols(); // The standard Task methods. - Is_runnable_type - is_runnable(Workqueue*); + Task_token* + is_runnable(); - Task_locker* - locks(Workqueue*); + void + locks(Task_locker*); void run(Workqueue*); + std::string + get_name() const + { return "Add_symbols " + this->object_->name(); } + private: + Input_objects* input_objects_; + Symbol_table* symtab_; + Layout* layout_; + const Input_argument* input_argument_; Object* object_; - Read_symbols_data sd_; + Incremental_library* library_; + Read_symbols_data* sd_; + Task_token* this_blocker_; + Task_token* next_blocker_; +}; + +// This Task is responsible for reading the symbols from an archive +// member that has changed since the last incremental link. + +class Read_member : public Task +{ + public: + // INPUT is the file to read. INPUT_GROUP is not NULL if we are in + // the middle of an input group. THIS_BLOCKER is used to prevent + // the associated Add_symbols task from running before the previous + // one has completed; it will be NULL for the first task. + // NEXT_BLOCKER is used to block the next input file from adding + // symbols. + Read_member(Input_objects* /*input_objects*/, Symbol_table* /*symtab*/, + Layout* /*layout*/, Mapfile* /*mapfile*/, + const Incremental_binary::Input_reader* input_reader, + Task_token* this_blocker, Task_token* next_blocker) + : input_reader_(input_reader), + this_blocker_(this_blocker), next_blocker_(next_blocker) + { } + + ~Read_member(); + + // The standard Task methods. + + Task_token* + is_runnable(); + + void + locks(Task_locker*); + + void + run(Workqueue*); + + std::string + get_name() const + { + return (std::string("Read_member ") + this->input_reader_->filename()); + } + + private: + const Incremental_binary::Input_reader* input_reader_; + Task_token* this_blocker_; + Task_token* next_blocker_; +}; + +// This Task is responsible for processing an input script file that has +// not changed since the last incremental link. + +class Check_script : public Task +{ + public: + Check_script(Layout* layout, Incremental_binary* ibase, + unsigned int input_file_index, + const Incremental_binary::Input_reader* input_reader, + Task_token* this_blocker, Task_token* next_blocker) + : layout_(layout), ibase_(ibase), input_file_index_(input_file_index), + input_reader_(input_reader), this_blocker_(this_blocker), + next_blocker_(next_blocker) + { + this->filename_ = std::string(this->input_reader_->filename()); + } + + ~Check_script(); + + // The standard Task methods. + + Task_token* + is_runnable(); + + void + locks(Task_locker*); + + void + run(Workqueue*); + + std::string + get_name() const + { + return (std::string("Check_script ") + this->input_reader_->filename()); + } + + private: + std::string filename_; + Layout* layout_; + Incremental_binary* ibase_; + unsigned int input_file_index_; + const Incremental_binary::Input_reader* input_reader_; + Task_token* this_blocker_; + Task_token* next_blocker_; +}; + +// This Task is responsible for processing an archive library that has +// not changed since the last incremental link. + +class Check_library : public Task +{ + public: + Check_library(Symbol_table* /*symtab*/, Layout* layout, + Incremental_binary* ibase, + unsigned int input_file_index, + const Incremental_binary::Input_reader* input_reader, + Task_token* this_blocker, Task_token* next_blocker) + : layout_(layout), ibase_(ibase), + input_file_index_(input_file_index), input_reader_(input_reader), + this_blocker_(this_blocker), next_blocker_(next_blocker) + { } + + ~Check_library(); + + // The standard Task methods. + + Task_token* + is_runnable(); + + void + locks(Task_locker*); + + void + run(Workqueue*); + + std::string + get_name() const + { + return (std::string("Check_library ") + this->input_reader_->filename()); + } + + private: + Layout* layout_; + Incremental_binary* ibase_; + unsigned int input_file_index_; + const Incremental_binary::Input_reader* input_reader_; + Task_token* this_blocker_; + Task_token* next_blocker_; +}; + +// This class is used to track the archives in a group. + +class Input_group +{ + public: + typedef std::vector Archives; + typedef Archives::const_iterator const_iterator; + + Input_group() + : archives_() + { } + + ~Input_group(); + + // Add an archive to the group. + void + add_archive(Archive* arch) + { this->archives_.push_back(arch); } + + // Loop over the archives in the group. + + const_iterator + begin() const + { return this->archives_.begin(); } + + const_iterator + end() const + { return this->archives_.end(); } + + private: + Archives archives_; +}; + +// This class starts the handling of a group. It exists only to pick +// up the number of undefined symbols at that point, so that we only +// run back through the group if we saw a new undefined symbol. + +class Start_group : public Task +{ + public: + Start_group(Symbol_table* symtab, Finish_group* finish_group, + Task_token* this_blocker, Task_token* next_blocker) + : symtab_(symtab), finish_group_(finish_group), + this_blocker_(this_blocker), next_blocker_(next_blocker) + { } + + ~Start_group(); + + // The standard Task methods. + + Task_token* + is_runnable(); + + void + locks(Task_locker*); + + void + run(Workqueue*); + + std::string + get_name() const + { return "Start_group"; } + + private: + Symbol_table* symtab_; + Finish_group* finish_group_; + Task_token* this_blocker_; + Task_token* next_blocker_; +}; + +// This class is used to finish up handling a group. It is just a +// closure. + +class Finish_group : public Task +{ + public: + Finish_group(Input_objects* input_objects, Symbol_table* symtab, + Layout* layout, Mapfile* mapfile, Input_group* input_group, + Task_token* next_blocker) + : input_objects_(input_objects), symtab_(symtab), + layout_(layout), mapfile_(mapfile), input_group_(input_group), + saw_undefined_(0), this_blocker_(NULL), next_blocker_(next_blocker) + { } + + ~Finish_group(); + + // Set the number of undefined symbols when we start processing the + // group. This is called by the Start_group task. + void + set_saw_undefined(size_t saw_undefined) + { this->saw_undefined_ = saw_undefined; } + + // Set the blocker to use for this task. + void + set_blocker(Task_token* this_blocker) + { + gold_assert(this->this_blocker_ == NULL); + this->this_blocker_ = this_blocker; + } + + // The standard Task methods. + + Task_token* + is_runnable(); + + void + locks(Task_locker*); + + void + run(Workqueue*); + + std::string + get_name() const + { return "Finish_group"; } + + private: + Input_objects* input_objects_; + Symbol_table* symtab_; + Layout* layout_; + Mapfile* mapfile_; + Input_group* input_group_; + size_t saw_undefined_; + Task_token* this_blocker_; + Task_token* next_blocker_; +}; + +// This class is used to read a file which was not recognized as an +// object or archive. It tries to read it as a linker script, using +// the tokens to serialize with the calls to Add_symbols. + +class Read_script : public Task +{ + public: + Read_script(Symbol_table* symtab, Layout* layout, Dirsearch* dirpath, + int dirindex, Input_objects* input_objects, Mapfile* mapfile, + Input_group* input_group, const Input_argument* input_argument, + Input_file* input_file, Task_token* this_blocker, + Task_token* next_blocker) + : symtab_(symtab), layout_(layout), dirpath_(dirpath), dirindex_(dirindex), + input_objects_(input_objects), mapfile_(mapfile), + input_group_(input_group), input_argument_(input_argument), + input_file_(input_file), this_blocker_(this_blocker), + next_blocker_(next_blocker) + { } + + ~Read_script(); + + // The standard Task methods. + + Task_token* + is_runnable(); + + void + locks(Task_locker*); + + void + run(Workqueue*); + + std::string + get_name() const; + + private: + Symbol_table* symtab_; + Layout* layout_; + Dirsearch* dirpath_; + int dirindex_; + Input_objects* input_objects_; + Mapfile* mapfile_; + Input_group* input_group_; + const Input_argument* input_argument_; + Input_file* input_file_; Task_token* this_blocker_; Task_token* next_blocker_; };