diff options
Diffstat (limited to 'binutils-2.25/gold/cref.cc')
| -rw-r--r-- | binutils-2.25/gold/cref.cc | 407 |
1 files changed, 407 insertions, 0 deletions
diff --git a/binutils-2.25/gold/cref.cc b/binutils-2.25/gold/cref.cc new file mode 100644 index 00000000..ebd48a91 --- /dev/null +++ b/binutils-2.25/gold/cref.cc @@ -0,0 +1,407 @@ +// cref.cc -- cross reference for gold + +// Copyright 2008, 2010 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 "symtab.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; + + // Print a cross reference table. + void + print_cref(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; + + // For --cref, we build a cross reference table which maps from + // symbols to lists of objects. The symbols are sorted + // alphabetically. + + class Cref_table_compare + { + public: + bool + operator()(const Symbol*, const Symbol*) const; + }; + + typedef std::map<const Symbol*, Objects*, Cref_table_compare> Cref_table; + + // 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; + + // Gather cross reference information. + void + gather_cref(const Objects*, Cref_table*) 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); + } +} + +// Sort symbols for the cross reference table. + +bool +Cref_inputs::Cref_table_compare::operator()(const Symbol* s1, + const Symbol* s2) const +{ + int i = strcmp(s1->name(), s2->name()); + if (i != 0) + return i < 0; + + if (s1->version() == NULL) + { + if (s2->version() != NULL) + return true; + } + else if (s2->version() == NULL) + return false; + else + { + i = strcmp(s1->version(), s2->version()); + if (i != 0) + return i < 0; + } + + // We should never have two different symbols with the same name and + // version. + if (s1 == s2) + return false; + gold_unreachable(); +} + +// Gather cross reference information from a list of inputs. + +void +Cref_inputs::gather_cref(const Objects* objects, Cref_table* table) const +{ + for (Objects::const_iterator po = objects->begin(); + po != objects->end(); + ++po) + { + const Object::Symbols* symbols = (*po)->get_global_symbols(); + if (symbols == NULL) + continue; + for (Object::Symbols::const_iterator ps = symbols->begin(); + ps != symbols->end(); + ++ps) + { + const Symbol* sym = *ps; + if (sym == NULL) + continue; + Objects* const onull = NULL; + std::pair<Cref_table::iterator, bool> ins = + table->insert(std::make_pair(sym, onull)); + Cref_table::iterator pc = ins.first; + if (ins.second) + pc->second = new Objects(); + if (sym->source() == Symbol::FROM_OBJECT + && sym->object() == *po + && sym->is_defined()) + pc->second->insert(pc->second->begin(), *po); + else + pc->second->push_back(*po); + } + } +} + +// The column where the file name starts in a cross reference table. + +static const size_t filecol = 50; + +// Print a cross reference table. + +void +Cref_inputs::print_cref(const Symbol_table*, FILE* f) const +{ + Cref_table table; + this->gather_cref(&this->objects_, &table); + for (Archives::const_iterator p = this->archives_.begin(); + p != this->archives_.end(); + ++p) + this->gather_cref(p->second.objects, &table); + + for (Cref_table::const_iterator pc = table.begin(); + pc != table.end(); + ++pc) + { + // If all the objects are dynamic, skip this symbol. + const Symbol* sym = pc->first; + const Objects* objects = pc->second; + Objects::const_iterator po; + for (po = objects->begin(); po != objects->end(); ++po) + if (!(*po)->is_dynamic()) + break; + if (po == objects->end()) + continue; + + std::string s = sym->demangled_name(); + if (sym->version() != NULL) + { + s += '@'; + if (sym->is_default()) + s += '@'; + s += sym->version(); + } + + fputs(s.c_str(), f); + + size_t len = s.length(); + + for (po = objects->begin(); po != objects->end(); ++po) + { + int n = len < filecol ? filecol - len : 1; + fprintf(f, "%*c%s\n", n, ' ', (*po)->name().c_str()); + len = 0; + } + } +} + +// 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); + } +} + +// Print a cross reference table. + +void +Cref::print_cref(const Symbol_table* symtab, FILE* f) const +{ + fprintf(f, _("\nCross Reference Table\n\n")); + const char* msg = _("Symbol"); + int len = filecol - strlen(msg); + fprintf(f, "%s%*c%s\n", msg, len, ' ', _("File")); + + if (parameters->options().cref() && this->inputs_ != NULL) + this->inputs_->print_cref(symtab, f); +} + +} // End namespace gold. |