1// cref.cc -- cross reference for gold
2
3// Copyright (C) 2008-2020 Free Software Foundation, Inc.
4// Written by Ian Lance Taylor <iant@google.com>.
5
6// This file is part of gold.
7
8// This program is free software; you can redistribute it and/or modify
9// it under the terms of the GNU General Public License as published by
10// the Free Software Foundation; either version 3 of the License, or
11// (at your option) any later version.
12
13// This program is distributed in the hope that it will be useful,
14// but WITHOUT ANY WARRANTY; without even the implied warranty of
15// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16// GNU General Public License for more details.
17
18// You should have received a copy of the GNU General Public License
19// along with this program; if not, write to the Free Software
20// Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21// MA 02110-1301, USA.
22
23#include "gold.h"
24
25#include <cerrno>
26#include <cstdio>
27#include <cstring>
28#include <map>
29#include <string>
30#include <vector>
31
32#include "object.h"
33#include "archive.h"
34#include "symtab.h"
35#include "cref.h"
36
37namespace gold
38{
39
40// Class Cref_inputs.  This is used to hold the list of input files
41// for cross referencing.
42
43class Cref_inputs
44{
45 public:
46  Cref_inputs()
47    : objects_(), archives_(), current_(&this->objects_)
48  { }
49
50  // Add an input object file.
51  void
52  add_object(Object* object);
53
54  // Start adding an archive.  We support nested archives for future
55  // flexibility.
56  void
57  add_archive_start(Archive*);
58
59  // Finish adding an archive.
60  void
61  add_archive_stop(Archive*);
62
63  // Report symbol counts.
64  void
65  print_symbol_counts(const Symbol_table*, FILE*) const;
66
67  // Print a cross reference table.
68  void
69  print_cref(const Symbol_table*, FILE*) const;
70
71 private:
72  // A list of input objects.
73  typedef std::vector<Object*> Objects;
74
75  // Information we record for an archive.
76  struct Archive_info
77  {
78    // Archive name.
79    std::string name;
80    // List of objects included from the archive.
81    Objects* objects;
82    // Number of archive members.
83    size_t member_count;
84  };
85
86  // A mapping from the name of an archive to the list of objects in
87  // that archive.
88  typedef std::map<std::string, Archive_info> Archives;
89
90  // For --cref, we build a cross reference table which maps from
91  // symbols to lists of objects.  The symbols are sorted
92  // alphabetically.
93
94  class Cref_table_compare
95  {
96  public:
97    bool
98    operator()(const Symbol*, const Symbol*) const;
99  };
100
101  typedef std::map<const Symbol*, Objects*, Cref_table_compare> Cref_table;
102
103  // Report symbol counts for a list of Objects.
104  void
105  print_objects_symbol_counts(const Symbol_table*, FILE*, const Objects*) const;
106
107  // Report symbol counts for an object.
108  void
109  print_object_symbol_counts(const Symbol_table*, FILE*, const Object*) const;
110
111  // Gather cross reference information.
112  void
113  gather_cref(const Objects*, Cref_table*) const;
114
115  // List of input objects.
116  Objects objects_;
117  // List of input archives.  This is a mapping from the archive file
118  // name to the list of objects.
119  Archives archives_;
120  // The list to which we are currently adding objects.
121  Objects* current_;
122};
123
124// Add an object.
125
126void
127Cref_inputs::add_object(Object* object)
128{
129  this->current_->push_back(object);
130}
131
132// Start adding an archive.
133
134void
135Cref_inputs::add_archive_start(Archive* archive)
136{
137  gold_assert(this->current_ == &this->objects_);
138  if (this->archives_.find(archive->name()) == this->archives_.end())
139    {
140      Archive_info* pai = &this->archives_[archive->name()];
141      pai->name = archive->filename();
142      pai->objects = new Objects();
143      pai->member_count = archive->count_members();
144    }
145  this->current_ = this->archives_[archive->name()].objects;
146}
147
148// Stop adding an archive.
149
150void
151Cref_inputs::add_archive_stop(Archive*)
152{
153  gold_assert(this->current_ != &this->objects_);
154  this->current_ = &this->objects_;
155}
156
157// Report symbol counts for an object.
158
159void
160Cref_inputs::print_object_symbol_counts(const Symbol_table* symtab,
161					FILE* f,
162					const Object* object) const
163{
164  size_t defined, used;
165  object->get_global_symbol_counts(symtab, &defined, &used);
166  fprintf(f, "symbols %s %zu %zu\n", object->name().c_str(), defined, used);
167}
168
169// Report symbol counts for a list of inputs.
170
171void
172Cref_inputs::print_objects_symbol_counts(const Symbol_table* symtab,
173					 FILE* f,
174					 const Objects* objects) const
175{
176  for (Objects::const_iterator p = objects->begin();
177       p != objects->end();
178       ++p)
179    this->print_object_symbol_counts(symtab, f, *p);
180}
181
182// Print symbol counts.  This implements --print-symbol-counts.  This
183// is intended to be easily read by a program.  This outputs a series
184// of lines.  There are two different types of lines.
185
186// The first is "symbols FILENAME DEFINED USED".  FILENAME is the name
187// of an object file included in the link; for an archive, this will
188// be ARCHIVEFILENAME(MEMBERNAME).  DEFINED is the number of symbols
189// which the object file defines.  USED is the number of symbols which
190// are used in the final output; this is the number of symbols which
191// appear in the final output table as having been defined by this
192// object.  These numbers will be different when weak symbols are
193// used, and they will be different for dynamic objects.
194
195// The second is "archives FILENAME MEMBERS USED".  FILENAME is the
196// name of an archive file included in the link.  MEMBERS is the
197// number of members of the archive.  USED is the number of archive
198// members included in the link.
199
200void
201Cref_inputs::print_symbol_counts(const Symbol_table* symtab, FILE* f) const
202{
203  this->print_objects_symbol_counts(symtab, f, &this->objects_);
204  for (Archives::const_iterator p = this->archives_.begin();
205       p != this->archives_.end();
206       ++p)
207    {
208      fprintf(f, "archive %s %zu %zu\n", p->second.name.c_str(),
209	     p->second.member_count, p->second.objects->size());
210      this->print_objects_symbol_counts(symtab, f, p->second.objects);
211    }
212}
213
214// Sort symbols for the cross reference table.
215
216bool
217Cref_inputs::Cref_table_compare::operator()(const Symbol* s1,
218					    const Symbol* s2) const
219{
220  int i = strcmp(s1->name(), s2->name());
221  if (i != 0)
222    return i < 0;
223
224  if (s1->version() == NULL)
225    {
226      if (s2->version() != NULL)
227	return true;
228    }
229  else if (s2->version() == NULL)
230    return false;
231  else
232    {
233      i = strcmp(s1->version(), s2->version());
234      if (i != 0)
235	return i < 0;
236    }
237
238  // We should never have two different symbols with the same name and
239  // version, where one doesn't forward to the other.
240  if (s1 == s2)
241    return false;
242  if (s1->is_forwarder() && !s2->is_forwarder())
243    return true;
244  if (!s1->is_forwarder() && s2->is_forwarder())
245    return false;
246  gold_unreachable();
247}
248
249// Gather cross reference information from a list of inputs.
250
251void
252Cref_inputs::gather_cref(const Objects* objects, Cref_table* table) const
253{
254  for (Objects::const_iterator po = objects->begin();
255       po != objects->end();
256       ++po)
257    {
258      const Object::Symbols* symbols = (*po)->get_global_symbols();
259      if (symbols == NULL)
260	continue;
261      for (Object::Symbols::const_iterator ps = symbols->begin();
262	   ps != symbols->end();
263	   ++ps)
264	{
265	  const Symbol* sym = *ps;
266	  if (sym == NULL)
267	    continue;
268	  Objects* const onull = NULL;
269	  std::pair<Cref_table::iterator, bool> ins =
270	    table->insert(std::make_pair(sym, onull));
271	  Cref_table::iterator pc = ins.first;
272	  if (ins.second)
273	    pc->second = new Objects();
274	  if (sym->source() == Symbol::FROM_OBJECT
275	      && sym->object() == *po
276	      && sym->is_defined())
277	    pc->second->insert(pc->second->begin(), *po);
278	  else
279	    pc->second->push_back(*po);
280	}
281    }
282}
283
284// The column where the file name starts in a cross reference table.
285
286static const size_t filecol = 50;
287
288// Print a cross reference table.
289
290void
291Cref_inputs::print_cref(const Symbol_table*, FILE* f) const
292{
293  Cref_table table;
294  this->gather_cref(&this->objects_, &table);
295  for (Archives::const_iterator p = this->archives_.begin();
296       p != this->archives_.end();
297       ++p)
298    this->gather_cref(p->second.objects, &table);
299
300  for (Cref_table::const_iterator pc = table.begin();
301       pc != table.end();
302       ++pc)
303    {
304      // If all the objects are dynamic, skip this symbol.
305      const Symbol* sym = pc->first;
306      const Objects* objects = pc->second;
307      Objects::const_iterator po;
308      for (po = objects->begin(); po != objects->end(); ++po)
309	if (!(*po)->is_dynamic())
310	  break;
311      if (po == objects->end())
312	continue;
313
314      std::string s = sym->demangled_name();
315      if (sym->version() != NULL)
316	{
317	  s += '@';
318	  if (sym->is_default())
319	    s += '@';
320	  s += sym->version();
321	}
322
323      fputs(s.c_str(), f);
324
325      size_t len = s.length();
326
327      for (po = objects->begin(); po != objects->end(); ++po)
328	{
329	  int n = len < filecol ? filecol - len : 1;
330	  fprintf(f, "%*c%s\n", n, ' ', (*po)->name().c_str());
331	  len = 0;
332	}
333    }
334}
335
336// Class Cref.
337
338// Make sure the Cref_inputs object has been created.
339
340void
341Cref::need_inputs()
342{
343  if (this->inputs_ == NULL)
344    this->inputs_ = new Cref_inputs();
345}
346
347// Add an input object file.
348
349void
350Cref::add_object(Object* object)
351{
352  this->need_inputs();
353  this->inputs_->add_object(object);
354}
355
356// Start adding an archive.
357
358void
359Cref::add_archive_start(Archive* archive)
360{
361  this->need_inputs();
362  this->inputs_->add_archive_start(archive);
363}
364
365// Stop adding an archive.
366
367void
368Cref::add_archive_stop(Archive* archive)
369{
370  this->inputs_->add_archive_stop(archive);
371}
372
373// Print symbol counts.
374
375void
376Cref::print_symbol_counts(const Symbol_table* symtab) const
377{
378  if (parameters->options().user_set_print_symbol_counts()
379      && this->inputs_ != NULL)
380    {
381      FILE* f;
382      if (strcmp(parameters->options().print_symbol_counts(), "-") == 0)
383	f = stdout;
384      else
385	{
386	  f = fopen(parameters->options().print_symbol_counts(), "w");
387	  if (f == NULL)
388	    gold_error(_("cannot open symbol count file %s: %s"),
389		       parameters->options().print_symbol_counts(),
390		       strerror(errno));
391	}
392      if (f != NULL)
393	this->inputs_->print_symbol_counts(symtab, f);
394    }
395}
396
397// Print a cross reference table.
398
399void
400Cref::print_cref(const Symbol_table* symtab, FILE* f) const
401{
402  fprintf(f, _("\nCross Reference Table\n\n"));
403  const char* msg = _("Symbol");
404  int len = filecol - strlen(msg);
405  fprintf(f, "%s%*c%s\n", msg, len, ' ', _("File"));
406
407  if (parameters->options().cref() && this->inputs_ != NULL)
408    this->inputs_->print_cref(symtab, f);
409}
410
411} // End namespace gold.
412