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