411 lines
10 KiB
C++
411 lines
10 KiB
C++
// cref.cc -- cross reference for gold
|
|
|
|
// Copyright (C) 2008-2022 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, where one doesn't forward to the other.
|
|
if (s1 == s2)
|
|
return false;
|
|
if (s1->is_forwarder() && !s2->is_forwarder())
|
|
return true;
|
|
if (!s1->is_forwarder() && s2->is_forwarder())
|
|
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.
|