| // cref.cc -- cross reference for gold |
| |
| // Copyright 2008 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. |
| |
| #include "gold.h" |
| |
| #include <cerrno> |
| #include <cstdio> |
| #include <cstring> |
| #include <map> |
| #include <string> |
| #include <vector> |
| |
| #include "object.h" |
| #include "archive.h" |
| #include "cref.h" |
| |
| namespace gold |
| { |
| |
| // Class Cref_inputs. This is used to hold the list of input files |
| // for cross referencing. |
| |
| class Cref_inputs |
| { |
| public: |
| Cref_inputs() |
| : objects_(), archives_(), current_(&this->objects_) |
| { } |
| |
| // Add an input object file. |
| void |
| add_object(Object* object); |
| |
| // Start adding an archive. We support nested archives for future |
| // flexibility. |
| void |
| add_archive_start(Archive*); |
| |
| // Finish adding an archive. |
| void |
| add_archive_stop(Archive*); |
| |
| // Report symbol counts. |
| void |
| print_symbol_counts(const Symbol_table*, FILE*) const; |
| |
| private: |
| // A list of input objects. |
| typedef std::vector<Object*> Objects; |
| |
| // Information we record for an archive. |
| struct Archive_info |
| { |
| // Archive name. |
| std::string name; |
| // List of objects included from the archive. |
| Objects* objects; |
| // Number of archive members. |
| size_t member_count; |
| }; |
| |
| // A mapping from the name of an archive to the list of objects in |
| // that archive. |
| typedef std::map<std::string, Archive_info> Archives; |
| |
| // Report symbol counts for a list of Objects. |
| void |
| print_objects_symbol_counts(const Symbol_table*, FILE*, const Objects*) const; |
| |
| // Report symbol counts for an object. |
| void |
| print_object_symbol_counts(const Symbol_table*, FILE*, const Object*) const; |
| |
| // List of input objects. |
| Objects objects_; |
| // List of input archives. This is a mapping from the archive file |
| // name to the list of objects. |
| Archives archives_; |
| // The list to which we are currently adding objects. |
| Objects* current_; |
| }; |
| |
| // Add an object. |
| |
| void |
| Cref_inputs::add_object(Object* object) |
| { |
| this->current_->push_back(object); |
| } |
| |
| // Start adding an archive. |
| |
| void |
| Cref_inputs::add_archive_start(Archive* archive) |
| { |
| gold_assert(this->current_ == &this->objects_); |
| if (this->archives_.find(archive->name()) == this->archives_.end()) |
| { |
| Archive_info* pai = &this->archives_[archive->name()]; |
| pai->name = archive->filename(); |
| pai->objects = new Objects(); |
| pai->member_count = archive->count_members(); |
| } |
| this->current_ = this->archives_[archive->name()].objects; |
| } |
| |
| // Stop adding an archive. |
| |
| void |
| Cref_inputs::add_archive_stop(Archive*) |
| { |
| gold_assert(this->current_ != &this->objects_); |
| this->current_ = &this->objects_; |
| } |
| |
| // Report symbol counts for an object. |
| |
| void |
| Cref_inputs::print_object_symbol_counts(const Symbol_table* symtab, |
| FILE* f, |
| const Object* object) const |
| { |
| size_t defined, used; |
| object->get_global_symbol_counts(symtab, &defined, &used); |
| fprintf(f, "symbols %s %zu %zu\n", object->name().c_str(), defined, used); |
| } |
| |
| // Report symbol counts for a list of Inputs. |
| |
| void |
| Cref_inputs::print_objects_symbol_counts(const Symbol_table* symtab, |
| FILE* f, |
| const Objects* objects) const |
| { |
| for (Objects::const_iterator p = objects->begin(); |
| p != objects->end(); |
| ++p) |
| this->print_object_symbol_counts(symtab, f, *p); |
| } |
| |
| // Print symbol counts. This implements --print-symbol-counts. This |
| // is intended to be easily read by a program. This outputs a series |
| // of lines. There are two different types of lines. |
| |
| // The first is "symbols FILENAME DEFINED USED". FILENAME is the name |
| // of an object file included in the link; for an archive, this will |
| // be ARCHIVEFILENAME(MEMBERNAME). DEFINED is the number of symbols |
| // which the object file defines. USED is the number of symbols which |
| // are used in the final output; this is the number of symbols which |
| // appear in the final output table as having been defined by this |
| // object. These numbers will be different when weak symbols are |
| // used, and they will be different for dynamic objects. |
| |
| // The second is "archives FILENAME MEMBERS USED". FILENAME is the |
| // name of an archive file included in the link. MEMBERS is the |
| // number of members of the archive. USED is the number of archive |
| // members included in the link. |
| |
| void |
| Cref_inputs::print_symbol_counts(const Symbol_table* symtab, FILE* f) const |
| { |
| this->print_objects_symbol_counts(symtab, f, &this->objects_); |
| for (Archives::const_iterator p = this->archives_.begin(); |
| p != this->archives_.end(); |
| ++p) |
| { |
| fprintf(f, "archive %s %zu %zu\n", p->second.name.c_str(), |
| p->second.member_count, p->second.objects->size()); |
| this->print_objects_symbol_counts(symtab, f, p->second.objects); |
| } |
| } |
| |
| // Class Cref. |
| |
| // Make sure the Cref_inputs object has been created. |
| |
| void |
| Cref::need_inputs() |
| { |
| if (this->inputs_ == NULL) |
| this->inputs_ = new Cref_inputs(); |
| } |
| |
| // Add an input object file. |
| |
| void |
| Cref::add_object(Object* object) |
| { |
| this->need_inputs(); |
| this->inputs_->add_object(object); |
| } |
| |
| // Start adding an archive. |
| |
| void |
| Cref::add_archive_start(Archive* archive) |
| { |
| this->need_inputs(); |
| this->inputs_->add_archive_start(archive); |
| } |
| |
| // Stop adding an archive. |
| |
| void |
| Cref::add_archive_stop(Archive* archive) |
| { |
| this->inputs_->add_archive_stop(archive); |
| } |
| |
| // Print symbol counts. |
| |
| void |
| Cref::print_symbol_counts(const Symbol_table* symtab) const |
| { |
| if (parameters->options().user_set_print_symbol_counts() |
| && this->inputs_ != NULL) |
| { |
| FILE* f; |
| if (strcmp(parameters->options().print_symbol_counts(), "-") == 0) |
| f = stdout; |
| else |
| { |
| f = fopen(parameters->options().print_symbol_counts(), "w"); |
| if (f == NULL) |
| gold_error(_("cannot open symbol count file %s: %s"), |
| parameters->options().print_symbol_counts(), |
| strerror(errno)); |
| } |
| if (f != NULL) |
| this->inputs_->print_symbol_counts(symtab, f); |
| } |
| } |
| |
| } // End namespace gold. |