contrib/binutils-2.25/gold/symtab.cc

   1 // symtab.cc -- the gold symbol table
   2
   3 // Copyright (C) 2006-2014 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 <cstring>
  26 #include <stdint.h>
  27 #include <algorithm>
  28 #include <set>
  29 #include <string>
  30 #include <utility>
  31 #include "demangle.h"
  32
  33 #include "gc.h"
  34 #include "object.h"
  35 #include "dwarf_reader.h"
  36 #include "dynobj.h"
  37 #include "output.h"
  38 #include "target.h"
  39 #include "workqueue.h"
  40 #include "symtab.h"
  41 #include "script.h"
  42 #include "plugin.h"
  43 #include "incremental.h"
  44
  45 namespace gold
  46 {
  47
  48 // Class Symbol.
  49
  50 // Initialize fields in Symbol.  This initializes everything except u_
  51 // and source_.
  52
  53 void
  54 Symbol::init_fields(const char* name, const char* version,
  55                     elfcpp::STT type, elfcpp::STB binding,
  56                     elfcpp::STV visibility, unsigned char nonvis)
  57 {
  58   this->name_ = name;
  59   this->version_ = version;
  60   this->symtab_index_ = 0;
  61   this->dynsym_index_ = 0;
  62   this->got_offsets_.init();
  63   this->plt_offset_ = -1U;
  64   this->type_ = type;
  65   this->binding_ = binding;
  66   this->visibility_ = visibility;
  67   this->nonvis_ = nonvis;
  68   this->is_def_ = false;
  69   this->is_forwarder_ = false;
  70   this->has_alias_ = false;
  71   this->needs_dynsym_entry_ = false;
  72   this->in_reg_ = false;
  73   this->in_dyn_ = false;
  74   this->has_warning_ = false;
  75   this->is_copied_from_dynobj_ = false;
  76   this->is_forced_local_ = false;
  77   this->is_ordinary_shndx_ = false;
  78   this->in_real_elf_ = false;
  79   this->is_defined_in_discarded_section_ = false;
  80   this->undef_binding_set_ = false;
  81   this->undef_binding_weak_ = false;
  82   this->is_predefined_ = false;
  83 }
  84
  85 // Return the demangled version of the symbol's name, but only
  86 // if the --demangle flag was set.
  87
  88 static std::string
  89 demangle(const char* name)
  90 {
  91   if (!parameters->options().do_demangle())
  92     return name;
  93
  94   // cplus_demangle allocates memory for the result it returns,
  95   // and returns NULL if the name is already demangled.
  96   char* demangled_name = cplus_demangle(name, DMGL_ANSI | DMGL_PARAMS);
  97   if (demangled_name == NULL)
  98     return name;
  99
 100   std::string retval(demangled_name);
 101   free(demangled_name);
 102   return retval;
 103 }
 104
 105 std::string
 106 Symbol::demangled_name() const
 107 {
 108   return demangle(this->name());
 109 }
 110
 111 // Initialize the fields in the base class Symbol for SYM in OBJECT.
 112
 113 template<int size, bool big_endian>
 114 void
 115 Symbol::init_base_object(const char* name, const char* version, Object* object,
 116                          const elfcpp::Sym<size, big_endian>& sym,
 117                          unsigned int st_shndx, bool is_ordinary)
 118 {
 119   this->init_fields(name, version, sym.get_st_type(), sym.get_st_bind(),
 120                     sym.get_st_visibility(), sym.get_st_nonvis());
 121   this->u_.from_object.object = object;
 122   this->u_.from_object.shndx = st_shndx;
 123   this->is_ordinary_shndx_ = is_ordinary;
 124   this->source_ = FROM_OBJECT;
 125   this->in_reg_ = !object->is_dynamic();
 126   this->in_dyn_ = object->is_dynamic();
 127   this->in_real_elf_ = object->pluginobj() == NULL;
 128 }
 129
 130 // Initialize the fields in the base class Symbol for a symbol defined
 131 // in an Output_data.
 132
 133 void
 134 Symbol::init_base_output_data(const char* name, const char* version,
 135                               Output_data* od, elfcpp::STT type,
 136                               elfcpp::STB binding, elfcpp::STV visibility,
 137                               unsigned char nonvis, bool offset_is_from_end,
 138                               bool is_predefined)
 139 {
 140   this->init_fields(name, version, type, binding, visibility, nonvis);
 141   this->u_.in_output_data.output_data = od;
 142   this->u_.in_output_data.offset_is_from_end = offset_is_from_end;
 143   this->source_ = IN_OUTPUT_DATA;
 144   this->in_reg_ = true;
 145   this->in_real_elf_ = true;
 146   this->is_predefined_ = is_predefined;
 147 }
 148
 149 // Initialize the fields in the base class Symbol for a symbol defined
 150 // in an Output_segment.
 151
 152 void
 153 Symbol::init_base_output_segment(const char* name, const char* version,
 154                                  Output_segment* os, elfcpp::STT type,
 155                                  elfcpp::STB binding, elfcpp::STV visibility,
 156                                  unsigned char nonvis,
 157                                  Segment_offset_base offset_base,
 158                                  bool is_predefined)
 159 {
 160   this->init_fields(name, version, type, binding, visibility, nonvis);
 161   this->u_.in_output_segment.output_segment = os;
 162   this->u_.in_output_segment.offset_base = offset_base;
 163   this->source_ = IN_OUTPUT_SEGMENT;
 164   this->in_reg_ = true;
 165   this->in_real_elf_ = true;
 166   this->is_predefined_ = is_predefined;
 167 }
 168
 169 // Initialize the fields in the base class Symbol for a symbol defined
 170 // as a constant.
 171
 172 void
 173 Symbol::init_base_constant(const char* name, const char* version,
 174                            elfcpp::STT type, elfcpp::STB binding,
 175                            elfcpp::STV visibility, unsigned char nonvis,
 176                            bool is_predefined)
 177 {
 178   this->init_fields(name, version, type, binding, visibility, nonvis);
 179   this->source_ = IS_CONSTANT;
 180   this->in_reg_ = true;
 181   this->in_real_elf_ = true;
 182   this->is_predefined_ = is_predefined;
 183 }
 184
 185 // Initialize the fields in the base class Symbol for an undefined
 186 // symbol.
 187
 188 void
 189 Symbol::init_base_undefined(const char* name, const char* version,
 190                             elfcpp::STT type, elfcpp::STB binding,
 191                             elfcpp::STV visibility, unsigned char nonvis)
 192 {
 193   this->init_fields(name, version, type, binding, visibility, nonvis);
 194   this->dynsym_index_ = -1U;
 195   this->source_ = IS_UNDEFINED;
 196   this->in_reg_ = true;
 197   this->in_real_elf_ = true;
 198 }
 199
 200 // Allocate a common symbol in the base.
 201
 202 void
 203 Symbol::allocate_base_common(Output_data* od)
 204 {
 205   gold_assert(this->is_common());
 206   this->source_ = IN_OUTPUT_DATA;
 207   this->u_.in_output_data.output_data = od;
 208   this->u_.in_output_data.offset_is_from_end = false;
 209 }
 210
 211 // Initialize the fields in Sized_symbol for SYM in OBJECT.
 212
 213 template<int size>
 214 template<bool big_endian>
 215 void
 216 Sized_symbol<size>::init_object(const char* name, const char* version,
 217                                 Object* object,
 218                                 const elfcpp::Sym<size, big_endian>& sym,
 219                                 unsigned int st_shndx, bool is_ordinary)
 220 {
 221   this->init_base_object(name, version, object, sym, st_shndx, is_ordinary);
 222   this->value_ = sym.get_st_value();
 223   this->symsize_ = sym.get_st_size();
 224 }
 225
 226 // Initialize the fields in Sized_symbol for a symbol defined in an
 227 // Output_data.
 228
 229 template<int size>
 230 void
 231 Sized_symbol<size>::init_output_data(const char* name, const char* version,
 232                                      Output_data* od, Value_type value,
 233                                      Size_type symsize, elfcpp::STT type,
 234                                      elfcpp::STB binding,
 235                                      elfcpp::STV visibility,
 236                                      unsigned char nonvis,
 237                                      bool offset_is_from_end,
 238                                      bool is_predefined)
 239 {
 240   this->init_base_output_data(name, version, od, type, binding, visibility,
 241                               nonvis, offset_is_from_end, is_predefined);
 242   this->value_ = value;
 243   this->symsize_ = symsize;
 244 }
 245
 246 // Initialize the fields in Sized_symbol for a symbol defined in an
 247 // Output_segment.
 248
 249 template<int size>
 250 void
 251 Sized_symbol<size>::init_output_segment(const char* name, const char* version,
 252                                         Output_segment* os, Value_type value,
 253                                         Size_type symsize, elfcpp::STT type,
 254                                         elfcpp::STB binding,
 255                                         elfcpp::STV visibility,
 256                                         unsigned char nonvis,
 257                                         Segment_offset_base offset_base,
 258                                         bool is_predefined)
 259 {
 260   this->init_base_output_segment(name, version, os, type, binding, visibility,
 261                                  nonvis, offset_base, is_predefined);
 262   this->value_ = value;
 263   this->symsize_ = symsize;
 264 }
 265
 266 // Initialize the fields in Sized_symbol for a symbol defined as a
 267 // constant.
 268
 269 template<int size>
 270 void
 271 Sized_symbol<size>::init_constant(const char* name, const char* version,
 272                                   Value_type value, Size_type symsize,
 273                                   elfcpp::STT type, elfcpp::STB binding,
 274                                   elfcpp::STV visibility, unsigned char nonvis,
 275                                   bool is_predefined)
 276 {
 277   this->init_base_constant(name, version, type, binding, visibility, nonvis,
 278                            is_predefined);
 279   this->value_ = value;
 280   this->symsize_ = symsize;
 281 }
 282
 283 // Initialize the fields in Sized_symbol for an undefined symbol.
 284
 285 template<int size>
 286 void
 287 Sized_symbol<size>::init_undefined(const char* name, const char* version,
 288                                    elfcpp::STT type, elfcpp::STB binding,
 289                                    elfcpp::STV visibility, unsigned char nonvis)
 290 {
 291   this->init_base_undefined(name, version, type, binding, visibility, nonvis);
 292   this->value_ = 0;
 293   this->symsize_ = 0;
 294 }
 295
 296 // Return an allocated string holding the symbol's name as
 297 // name@version.  This is used for relocatable links.
 298
 299 std::string
 300 Symbol::versioned_name() const
 301 {
 302   gold_assert(this->version_ != NULL);
 303   std::string ret = this->name_;
 304   ret.push_back('@');
 305   if (this->is_def_)
 306     ret.push_back('@');
 307   ret += this->version_;
 308   return ret;
 309 }
 310
 311 // Return true if SHNDX represents a common symbol.
 312
 313 bool
 314 Symbol::is_common_shndx(unsigned int shndx)
 315 {
 316   return (shndx == elfcpp::SHN_COMMON
 317           || shndx == parameters->target().small_common_shndx()
 318           || shndx == parameters->target().large_common_shndx());
 319 }
 320
 321 // Allocate a common symbol.
 322
 323 template<int size>
 324 void
 325 Sized_symbol<size>::allocate_common(Output_data* od, Value_type value)
 326 {
 327   this->allocate_base_common(od);
 328   this->value_ = value;
 329 }
 330
 331 // The ""'s around str ensure str is a string literal, so sizeof works.
 332 #define strprefix(var, str)   (strncmp(var, str, sizeof("" str "") - 1) == 0)
 333
 334 // Return true if this symbol should be added to the dynamic symbol
 335 // table.
 336
 337 bool
 338 Symbol::should_add_dynsym_entry(Symbol_table* symtab) const
 339 {
 340   // If the symbol is only present on plugin files, the plugin decided we
 341   // don't need it.
 342   if (!this->in_real_elf())
 343     return false;
 344
 345   // If the symbol is used by a dynamic relocation, we need to add it.
 346   if (this->needs_dynsym_entry())
 347     return true;
 348
 349   // If this symbol's section is not added, the symbol need not be added.
 350   // The section may have been GCed.  Note that export_dynamic is being
 351   // overridden here.  This should not be done for shared objects.
 352   if (parameters->options().gc_sections()
 353       && !parameters->options().shared()
 354       && this->source() == Symbol::FROM_OBJECT
 355       && !this->object()->is_dynamic())
 356     {
 357       Relobj* relobj = static_cast<Relobj*>(this->object());
 358       bool is_ordinary;
 359       unsigned int shndx = this->shndx(&is_ordinary);
 360       if (is_ordinary && shndx != elfcpp::SHN_UNDEF
 361           && !relobj->is_section_included(shndx)
 362           && !symtab->is_section_folded(relobj, shndx))
 363         return false;
 364     }
 365
 366   // If the symbol was forced dynamic in a --dynamic-list file
 367   // or an --export-dynamic-symbol option, add it.
 368   if (!this->is_from_dynobj()
 369       && (parameters->options().in_dynamic_list(this->name())
 370           || parameters->options().is_export_dynamic_symbol(this->name())))
 371     {
 372       if (!this->is_forced_local())
 373         return true;
 374       gold_warning(_("Cannot export local symbol '%s'"),
 375                    this->demangled_name().c_str());
 376       return false;
 377     }
 378
 379   // If the symbol was forced local in a version script, do not add it.
 380   if (this->is_forced_local())
 381     return false;
 382
 383   // If dynamic-list-data was specified, add any STT_OBJECT.
 384   if (parameters->options().dynamic_list_data()
 385       && !this->is_from_dynobj()
 386       && this->type() == elfcpp::STT_OBJECT)
 387     return true;
 388
 389   // If --dynamic-list-cpp-new was specified, add any new/delete symbol.
 390   // If --dynamic-list-cpp-typeinfo was specified, add any typeinfo symbols.
 391   if ((parameters->options().dynamic_list_cpp_new()
 392        || parameters->options().dynamic_list_cpp_typeinfo())
 393       && !this->is_from_dynobj())
 394     {
 395       // TODO(csilvers): We could probably figure out if we're an operator
 396       //                 new/delete or typeinfo without the need to demangle.
 397       char* demangled_name = cplus_demangle(this->name(),
 398                                             DMGL_ANSI | DMGL_PARAMS);
 399       if (demangled_name == NULL)
 400         {
 401           // Not a C++ symbol, so it can't satisfy these flags
 402         }
 403       else if (parameters->options().dynamic_list_cpp_new()
 404                && (strprefix(demangled_name, "operator new")
 405                    || strprefix(demangled_name, "operator delete")))
 406         {
 407           free(demangled_name);
 408           return true;
 409         }
 410       else if (parameters->options().dynamic_list_cpp_typeinfo()
 411                && (strprefix(demangled_name, "typeinfo name for")
 412                    || strprefix(demangled_name, "typeinfo for")))
 413         {
 414           free(demangled_name);
 415           return true;
 416         }
 417       else
 418         free(demangled_name);
 419     }
 420
 421   // If exporting all symbols or building a shared library,
 422   // and the symbol is defined in a regular object and is
 423   // externally visible, we need to add it.
 424   if ((parameters->options().export_dynamic() || parameters->options().shared())
 425       && !this->is_from_dynobj()
 426       && !this->is_undefined()
 427       && this->is_externally_visible())
 428     return true;
 429
 430   return false;
 431 }
 432
 433 // Return true if the final value of this symbol is known at link
 434 // time.
 435
 436 bool
 437 Symbol::final_value_is_known() const
 438 {
 439   // If we are not generating an executable, then no final values are
 440   // known, since they will change at runtime.
 441   if (parameters->options().output_is_position_independent()
 442       || parameters->options().relocatable())
 443     return false;
 444
 445   // If the symbol is not from an object file, and is not undefined,
 446   // then it is defined, and known.
 447   if (this->source_ != FROM_OBJECT)
 448     {
 449       if (this->source_ != IS_UNDEFINED)
 450         return true;
 451     }
 452   else
 453     {
 454       // If the symbol is from a dynamic object, then the final value
 455       // is not known.
 456       if (this->object()->is_dynamic())
 457         return false;
 458
 459       // If the symbol is not undefined (it is defined or common),
 460       // then the final value is known.
 461       if (!this->is_undefined())
 462         return true;
 463     }
 464
 465   // If the symbol is undefined, then whether the final value is known
 466   // depends on whether we are doing a static link.  If we are doing a
 467   // dynamic link, then the final value could be filled in at runtime.
 468   // This could reasonably be the case for a weak undefined symbol.
 469   return parameters->doing_static_link();
 470 }
 471
 472 // Return the output section where this symbol is defined.
 473
 474 Output_section*
 475 Symbol::output_section() const
 476 {
 477   switch (this->source_)
 478     {
 479     case FROM_OBJECT:
 480       {
 481         unsigned int shndx = this->u_.from_object.shndx;
 482         if (shndx != elfcpp::SHN_UNDEF && this->is_ordinary_shndx_)
 483           {
 484             gold_assert(!this->u_.from_object.object->is_dynamic());
 485             gold_assert(this->u_.from_object.object->pluginobj() == NULL);
 486             Relobj* relobj = static_cast<Relobj*>(this->u_.from_object.object);
 487             return relobj->output_section(shndx);
 488           }
 489         return NULL;
 490       }
 491
 492     case IN_OUTPUT_DATA:
 493       return this->u_.in_output_data.output_data->output_section();
 494
 495     case IN_OUTPUT_SEGMENT:
 496     case IS_CONSTANT:
 497     case IS_UNDEFINED:
 498       return NULL;
 499
 500     default:
 501       gold_unreachable();
 502     }
 503 }
 504
 505 // Set the symbol's output section.  This is used for symbols defined
 506 // in scripts.  This should only be called after the symbol table has
 507 // been finalized.
 508
 509 void
 510 Symbol::set_output_section(Output_section* os)
 511 {
 512   switch (this->source_)
 513     {
 514     case FROM_OBJECT:
 515     case IN_OUTPUT_DATA:
 516       gold_assert(this->output_section() == os);
 517       break;
 518     case IS_CONSTANT:
 519       this->source_ = IN_OUTPUT_DATA;
 520       this->u_.in_output_data.output_data = os;
 521       this->u_.in_output_data.offset_is_from_end = false;
 522       break;
 523     case IN_OUTPUT_SEGMENT:
 524     case IS_UNDEFINED:
 525     default:
 526       gold_unreachable();
 527     }
 528 }
 529
 530 // Set the symbol's output segment.  This is used for pre-defined
 531 // symbols whose segments aren't known until after layout is done
 532 // (e.g., __ehdr_start).
 533
 534 void
 535 Symbol::set_output_segment(Output_segment* os, Segment_offset_base base)
 536 {
 537   gold_assert(this->is_predefined_);
 538   this->source_ = IN_OUTPUT_SEGMENT;
 539   this->u_.in_output_segment.output_segment = os;
 540   this->u_.in_output_segment.offset_base = base;
 541 }
 542
 543 // Set the symbol to undefined.  This is used for pre-defined
 544 // symbols whose segments aren't known until after layout is done
 545 // (e.g., __ehdr_start).
 546
 547 void
 548 Symbol::set_undefined()
 549 {
 550   this->source_ = IS_UNDEFINED;
 551   this->is_predefined_ = false;
 552 }
 553
 554 // Class Symbol_table.
 555
 556 Symbol_table::Symbol_table(unsigned int count,
 557                            const Version_script_info& version_script)
 558   : saw_undefined_(0), offset_(0), table_(count), namepool_(),
 559     forwarders_(), commons_(), tls_commons_(), small_commons_(),
 560     large_commons_(), forced_locals_(), warnings_(),
 561     version_script_(version_script), gc_(NULL), icf_(NULL)
 562 {
 563   namepool_.reserve(count);
 564 }
 565
 566 Symbol_table::~Symbol_table()
 567 {
 568 }
 569
 570 // The symbol table key equality function.  This is called with
 571 // Stringpool keys.
 572
 573 inline bool
 574 Symbol_table::Symbol_table_eq::operator()(const Symbol_table_key& k1,
 575                                           const Symbol_table_key& k2) const
 576 {
 577   return k1.first == k2.first && k1.second == k2.second;
 578 }
 579
 580 bool
 581 Symbol_table::is_section_folded(Object* obj, unsigned int shndx) const
 582 {
 583   return (parameters->options().icf_enabled()
 584           && this->icf_->is_section_folded(obj, shndx));
 585 }
 586
 587 // For symbols that have been listed with a -u or --export-dynamic-symbol
 588 // option, add them to the work list to avoid gc'ing them.
 589
 590 void
 591 Symbol_table::gc_mark_undef_symbols(Layout* layout)
 592 {
 593   for (options::String_set::const_iterator p =
 594          parameters->options().undefined_begin();
 595        p != parameters->options().undefined_end();
 596        ++p)
 597     {
 598       const char* name = p->c_str();
 599       Symbol* sym = this->lookup(name);
 600       gold_assert(sym != NULL);
 601       if (sym->source() == Symbol::FROM_OBJECT
 602           && !sym->object()->is_dynamic())
 603         {
 604           this->gc_mark_symbol(sym);
 605         }
 606     }
 607
 608   for (options::String_set::const_iterator p =
 609          parameters->options().export_dynamic_symbol_begin();
 610        p != parameters->options().export_dynamic_symbol_end();
 611        ++p)
 612     {
 613       const char* name = p->c_str();
 614       Symbol* sym = this->lookup(name);
 615       // It's not an error if a symbol named by --export-dynamic-symbol
 616       // is undefined.
 617       if (sym != NULL
 618           && sym->source() == Symbol::FROM_OBJECT
 619           && !sym->object()->is_dynamic())
 620         {
 621           this->gc_mark_symbol(sym);
 622         }
 623     }
 624
 625   for (Script_options::referenced_const_iterator p =
 626          layout->script_options()->referenced_begin();
 627        p != layout->script_options()->referenced_end();
 628        ++p)
 629     {
 630       Symbol* sym = this->lookup(p->c_str());
 631       gold_assert(sym != NULL);
 632       if (sym->source() == Symbol::FROM_OBJECT
 633           && !sym->object()->is_dynamic())
 634         {
 635           this->gc_mark_symbol(sym);
 636         }
 637     }
 638 }
 639
 640 void
 641 Symbol_table::gc_mark_symbol(Symbol* sym)
 642 {
 643   // Add the object and section to the work list.
 644   bool is_ordinary;
 645   unsigned int shndx = sym->shndx(&is_ordinary);
 646   if (is_ordinary && shndx != elfcpp::SHN_UNDEF)
 647     {
 648       gold_assert(this->gc_!= NULL);
 649       this->gc_->worklist().push(Section_id(sym->object(), shndx));
 650     }
 651   parameters->target().gc_mark_symbol(this, sym);
 652 }
 653
 654 // When doing garbage collection, keep symbols that have been seen in
 655 // dynamic objects.
 656 inline void
 657 Symbol_table::gc_mark_dyn_syms(Symbol* sym)
 658 {
 659   if (sym->in_dyn() && sym->source() == Symbol::FROM_OBJECT
 660       && !sym->object()->is_dynamic())
 661     this->gc_mark_symbol(sym);
 662 }
 663
 664 // Make TO a symbol which forwards to FROM.
 665
 666 void
 667 Symbol_table::make_forwarder(Symbol* from, Symbol* to)
 668 {
 669   gold_assert(from != to);
 670   gold_assert(!from->is_forwarder() && !to->is_forwarder());
 671   this->forwarders_[from] = to;
 672   from->set_forwarder();
 673 }
 674
 675 // Resolve the forwards from FROM, returning the real symbol.
 676
 677 Symbol*
 678 Symbol_table::resolve_forwards(const Symbol* from) const
 679 {
 680   gold_assert(from->is_forwarder());
 681   Unordered_map<const Symbol*, Symbol*>::const_iterator p =
 682     this->forwarders_.find(from);
 683   gold_assert(p != this->forwarders_.end());
 684   return p->second;
 685 }
 686
 687 // Look up a symbol by name.
 688
 689 Symbol*
 690 Symbol_table::lookup(const char* name, const char* version) const
 691 {
 692   Stringpool::Key name_key;
 693   name = this->namepool_.find(name, &name_key);
 694   if (name == NULL)
 695     return NULL;
 696
 697   Stringpool::Key version_key = 0;
 698   if (version != NULL)
 699     {
 700       version = this->namepool_.find(version, &version_key);
 701       if (version == NULL)
 702         return NULL;
 703     }
 704
 705   Symbol_table_key key(name_key, version_key);
 706   Symbol_table::Symbol_table_type::const_iterator p = this->table_.find(key);
 707   if (p == this->table_.end())
 708     return NULL;
 709   return p->second;
 710 }
 711
 712 // Resolve a Symbol with another Symbol.  This is only used in the
 713 // unusual case where there are references to both an unversioned
 714 // symbol and a symbol with a version, and we then discover that that
 715 // version is the default version.  Because this is unusual, we do
 716 // this the slow way, by converting back to an ELF symbol.
 717
 718 template<int size, bool big_endian>
 719 void
 720 Symbol_table::resolve(Sized_symbol<size>* to, const Sized_symbol<size>* from)
 721 {
 722   unsigned char buf[elfcpp::Elf_sizes<size>::sym_size];
 723   elfcpp::Sym_write<size, big_endian> esym(buf);
 724   // We don't bother to set the st_name or the st_shndx field.
 725   esym.put_st_value(from->value());
 726   esym.put_st_size(from->symsize());
 727   esym.put_st_info(from->binding(), from->type());
 728   esym.put_st_other(from->visibility(), from->nonvis());
 729   bool is_ordinary;
 730   unsigned int shndx = from->shndx(&is_ordinary);
 731   this->resolve(to, esym.sym(), shndx, is_ordinary, shndx, from->object(),
 732                 from->version());
 733   if (from->in_reg())
 734     to->set_in_reg();
 735   if (from->in_dyn())
 736     to->set_in_dyn();
 737   if (parameters->options().gc_sections())
 738     this->gc_mark_dyn_syms(to);
 739 }
 740
 741 // Record that a symbol is forced to be local by a version script or
 742 // by visibility.
 743
 744 void
 745 Symbol_table::force_local(Symbol* sym)
 746 {
 747   if (!sym->is_defined() && !sym->is_common())
 748     return;
 749   if (sym->is_forced_local())
 750     {
 751       // We already got this one.
 752       return;
 753     }
 754   sym->set_is_forced_local();
 755   this->forced_locals_.push_back(sym);
 756 }
 757
 758 // Adjust NAME for wrapping, and update *NAME_KEY if necessary.  This
 759 // is only called for undefined symbols, when at least one --wrap
 760 // option was used.
 761
 762 const char*
 763 Symbol_table::wrap_symbol(const char* name, Stringpool::Key* name_key)
 764 {
 765   // For some targets, we need to ignore a specific character when
 766   // wrapping, and add it back later.
 767   char prefix = '\0';
 768   if (name[0] == parameters->target().wrap_char())
 769     {
 770       prefix = name[0];
 771       ++name;
 772     }
 773
 774   if (parameters->options().is_wrap(name))
 775     {
 776       // Turn NAME into __wrap_NAME.
 777       std::string s;
 778       if (prefix != '\0')
 779         s += prefix;
 780       s += "__wrap_";
 781       s += name;
 782
 783       // This will give us both the old and new name in NAMEPOOL_, but
 784       // that is OK.  Only the versions we need will wind up in the
 785       // real string table in the output file.
 786       return this->namepool_.add(s.c_str(), true, name_key);
 787     }
 788
 789   const char* const real_prefix = "__real_";
 790   const size_t real_prefix_length = strlen(real_prefix);
 791   if (strncmp(name, real_prefix, real_prefix_length) == 0
 792       && parameters->options().is_wrap(name + real_prefix_length))
 793     {
 794       // Turn __real_NAME into NAME.
 795       std::string s;
 796       if (prefix != '\0')
 797         s += prefix;
 798       s += name + real_prefix_length;
 799       return this->namepool_.add(s.c_str(), true, name_key);
 800     }
 801
 802   return name;
 803 }
 804
 805 // This is called when we see a symbol NAME/VERSION, and the symbol
 806 // already exists in the symbol table, and VERSION is marked as being
 807 // the default version.  SYM is the NAME/VERSION symbol we just added.
 808 // DEFAULT_IS_NEW is true if this is the first time we have seen the
 809 // symbol NAME/NULL.  PDEF points to the entry for NAME/NULL.
 810
 811 template<int size, bool big_endian>
 812 void
 813 Symbol_table::define_default_version(Sized_symbol<size>* sym,
 814                                      bool default_is_new,
 815                                      Symbol_table_type::iterator pdef)
 816 {
 817   if (default_is_new)
 818     {
 819       // This is the first time we have seen NAME/NULL.  Make
 820       // NAME/NULL point to NAME/VERSION, and mark SYM as the default
 821       // version.
 822       pdef->second = sym;
 823       sym->set_is_default();
 824     }
 825   else if (pdef->second == sym)
 826     {
 827       // NAME/NULL already points to NAME/VERSION.  Don't mark the
 828       // symbol as the default if it is not already the default.
 829     }
 830   else
 831     {
 832       // This is the unfortunate case where we already have entries
 833       // for both NAME/VERSION and NAME/NULL.  We now see a symbol
 834       // NAME/VERSION where VERSION is the default version.  We have
 835       // already resolved this new symbol with the existing
 836       // NAME/VERSION symbol.
 837
 838       // It's possible that NAME/NULL and NAME/VERSION are both
 839       // defined in regular objects.  This can only happen if one
 840       // object file defines foo and another defines foo@@ver.  This
 841       // is somewhat obscure, but we call it a multiple definition
 842       // error.
 843
 844       // It's possible that NAME/NULL actually has a version, in which
 845       // case it won't be the same as VERSION.  This happens with
 846       // ver_test_7.so in the testsuite for the symbol t2_2.  We see
 847       // t2_2@@VER2, so we define both t2_2/VER2 and t2_2/NULL.  We
 848       // then see an unadorned t2_2 in an object file and give it
 849       // version VER1 from the version script.  This looks like a
 850       // default definition for VER1, so it looks like we should merge
 851       // t2_2/NULL with t2_2/VER1.  That doesn't make sense, but it's
 852       // not obvious that this is an error, either.  So we just punt.
 853
 854       // If one of the symbols has non-default visibility, and the
 855       // other is defined in a shared object, then they are different
 856       // symbols.
 857
 858       // Otherwise, we just resolve the symbols as though they were
 859       // the same.
 860
 861       if (pdef->second->version() != NULL)
 862         gold_assert(pdef->second->version() != sym->version());
 863       else if (sym->visibility() != elfcpp::STV_DEFAULT
 864                && pdef->second->is_from_dynobj())
 865         ;
 866       else if (pdef->second->visibility() != elfcpp::STV_DEFAULT
 867                && sym->is_from_dynobj())
 868         ;
 869       else
 870         {
 871           const Sized_symbol<size>* symdef;
 872           symdef = this->get_sized_symbol<size>(pdef->second);
 873           Symbol_table::resolve<size, big_endian>(sym, symdef);
 874           this->make_forwarder(pdef->second, sym);
 875           pdef->second = sym;
 876           sym->set_is_default();
 877         }
 878     }
 879 }
 880
 881 // Add one symbol from OBJECT to the symbol table.  NAME is symbol
 882 // name and VERSION is the version; both are canonicalized.  DEF is
 883 // whether this is the default version.  ST_SHNDX is the symbol's
 884 // section index; IS_ORDINARY is whether this is a normal section
 885 // rather than a special code.
 886
 887 // If IS_DEFAULT_VERSION is true, then this is the definition of a
 888 // default version of a symbol.  That means that any lookup of
 889 // NAME/NULL and any lookup of NAME/VERSION should always return the
 890 // same symbol.  This is obvious for references, but in particular we
 891 // want to do this for definitions: overriding NAME/NULL should also
 892 // override NAME/VERSION.  If we don't do that, it would be very hard
 893 // to override functions in a shared library which uses versioning.
 894
 895 // We implement this by simply making both entries in the hash table
 896 // point to the same Symbol structure.  That is easy enough if this is
 897 // the first time we see NAME/NULL or NAME/VERSION, but it is possible
 898 // that we have seen both already, in which case they will both have
 899 // independent entries in the symbol table.  We can't simply change
 900 // the symbol table entry, because we have pointers to the entries
 901 // attached to the object files.  So we mark the entry attached to the
 902 // object file as a forwarder, and record it in the forwarders_ map.
 903 // Note that entries in the hash table will never be marked as
 904 // forwarders.
 905 //
 906 // ORIG_ST_SHNDX and ST_SHNDX are almost always the same.
 907 // ORIG_ST_SHNDX is the section index in the input file, or SHN_UNDEF
 908 // for a special section code.  ST_SHNDX may be modified if the symbol
 909 // is defined in a section being discarded.
 910
 911 template<int size, bool big_endian>
 912 Sized_symbol<size>*
 913 Symbol_table::add_from_object(Object* object,
 914                               const char* name,
 915                               Stringpool::Key name_key,
 916                               const char* version,
 917                               Stringpool::Key version_key,
 918                               bool is_default_version,
 919                               const elfcpp::Sym<size, big_endian>& sym,
 920                               unsigned int st_shndx,
 921                               bool is_ordinary,
 922                               unsigned int orig_st_shndx)
 923 {
 924   // Print a message if this symbol is being traced.
 925   if (parameters->options().is_trace_symbol(name))
 926     {
 927       if (orig_st_shndx == elfcpp::SHN_UNDEF)
 928         gold_info(_("%s: reference to %s"), object->name().c_str(), name);
 929       else
 930         gold_info(_("%s: definition of %s"), object->name().c_str(), name);
 931     }
 932
 933   // For an undefined symbol, we may need to adjust the name using
 934   // --wrap.
 935   if (orig_st_shndx == elfcpp::SHN_UNDEF
 936       && parameters->options().any_wrap())
 937     {
 938       const char* wrap_name = this->wrap_symbol(name, &name_key);
 939       if (wrap_name != name)
 940         {
 941           // If we see a reference to malloc with version GLIBC_2.0,
 942           // and we turn it into a reference to __wrap_malloc, then we
 943           // discard the version number.  Otherwise the user would be
 944           // required to specify the correct version for
 945           // __wrap_malloc.
 946           version = NULL;
 947           version_key = 0;
 948           name = wrap_name;
 949         }
 950     }
 951
 952   Symbol* const snull = NULL;
 953   std::pair<typename Symbol_table_type::iterator, bool> ins =
 954     this->table_.insert(std::make_pair(std::make_pair(name_key, version_key),
 955                                        snull));
 956
 957   std::pair<typename Symbol_table_type::iterator, bool> insdefault =
 958     std::make_pair(this->table_.end(), false);
 959   if (is_default_version)
 960     {
 961       const Stringpool::Key vnull_key = 0;
 962       insdefault = this->table_.insert(std::make_pair(std::make_pair(name_key,
 963                                                                      vnull_key),
 964                                                       snull));
 965     }
 966
 967   // ins.first: an iterator, which is a pointer to a pair.
 968   // ins.first->first: the key (a pair of name and version).
 969   // ins.first->second: the value (Symbol*).
 970   // ins.second: true if new entry was inserted, false if not.
 971
 972   Sized_symbol<size>* ret;
 973   bool was_undefined;
 974   bool was_common;
 975   if (!ins.second)
 976     {
 977       // We already have an entry for NAME/VERSION.
 978       ret = this->get_sized_symbol<size>(ins.first->second);
 979       gold_assert(ret != NULL);
 980
 981       was_undefined = ret->is_undefined();
 982       // Commons from plugins are just placeholders.
 983       was_common = ret->is_common() && ret->object()->pluginobj() == NULL;
 984
 985       this->resolve(ret, sym, st_shndx, is_ordinary, orig_st_shndx, object,
 986                     version);
 987       if (parameters->options().gc_sections())
 988         this->gc_mark_dyn_syms(ret);
 989
 990       if (is_default_version)
 991         this->define_default_version<size, big_endian>(ret, insdefault.second,
 992                                                        insdefault.first);
 993     }
 994   else
 995     {
 996       // This is the first time we have seen NAME/VERSION.
 997       gold_assert(ins.first->second == NULL);
 998
 999       if (is_default_version && !insdefault.second)
1000         {
1001           // We already have an entry for NAME/NULL.  If we override
1002           // it, then change it to NAME/VERSION.
1003           ret = this->get_sized_symbol<size>(insdefault.first->second);
1004
1005           was_undefined = ret->is_undefined();
1006           // Commons from plugins are just placeholders.
1007           was_common = ret->is_common() && ret->object()->pluginobj() == NULL;
1008
1009           this->resolve(ret, sym, st_shndx, is_ordinary, orig_st_shndx, object,
1010                         version);
1011           if (parameters->options().gc_sections())
1012             this->gc_mark_dyn_syms(ret);
1013           ins.first->second = ret;
1014         }
1015       else
1016         {
1017           was_undefined = false;
1018           was_common = false;
1019
1020           Sized_target<size, big_endian>* target =
1021             parameters->sized_target<size, big_endian>();
1022           if (!target->has_make_symbol())
1023             ret = new Sized_symbol<size>();
1024           else
1025             {
1026               ret = target->make_symbol();
1027               if (ret == NULL)
1028                 {
1029                   // This means that we don't want a symbol table
1030                   // entry after all.
1031                   if (!is_default_version)
1032                     this->table_.erase(ins.first);
1033                   else
1034                     {
1035                       this->table_.erase(insdefault.first);
1036                       // Inserting INSDEFAULT invalidated INS.
1037                       this->table_.erase(std::make_pair(name_key,
1038                                                         version_key));
1039                     }
1040                   return NULL;
1041                 }
1042             }
1043
1044           ret->init_object(name, version, object, sym, st_shndx, is_ordinary);
1045
1046           ins.first->second = ret;
1047           if (is_default_version)
1048             {
1049               // This is the first time we have seen NAME/NULL.  Point
1050               // it at the new entry for NAME/VERSION.
1051               gold_assert(insdefault.second);
1052               insdefault.first->second = ret;
1053             }
1054         }
1055
1056       if (is_default_version)
1057         ret->set_is_default();
1058     }
1059
1060   // Record every time we see a new undefined symbol, to speed up
1061   // archive groups.
1062   if (!was_undefined && ret->is_undefined())
1063     {
1064       ++this->saw_undefined_;
1065       if (parameters->options().has_plugins())
1066         parameters->options().plugins()->new_undefined_symbol(ret);
1067     }
1068
1069   // Keep track of common symbols, to speed up common symbol
1070   // allocation.  Don't record commons from plugin objects;
1071   // we need to wait until we see the real symbol in the
1072   // replacement file.
1073   if (!was_common && ret->is_common() && ret->object()->pluginobj() == NULL)
1074     {
1075       if (ret->type() == elfcpp::STT_TLS)
1076         this->tls_commons_.push_back(ret);
1077       else if (!is_ordinary
1078                && st_shndx == parameters->target().small_common_shndx())
1079         this->small_commons_.push_back(ret);
1080       else if (!is_ordinary
1081                && st_shndx == parameters->target().large_common_shndx())
1082         this->large_commons_.push_back(ret);
1083       else
1084         this->commons_.push_back(ret);
1085     }
1086
1087   // If we're not doing a relocatable link, then any symbol with
1088   // hidden or internal visibility is local.
1089   if ((ret->visibility() == elfcpp::STV_HIDDEN
1090        || ret->visibility() == elfcpp::STV_INTERNAL)
1091       && (ret->binding() == elfcpp::STB_GLOBAL
1092           || ret->binding() == elfcpp::STB_GNU_UNIQUE
1093           || ret->binding() == elfcpp::STB_WEAK)
1094       && !parameters->options().relocatable())
1095     this->force_local(ret);
1096
1097   return ret;
1098 }
1099
1100 // Add all the symbols in a relocatable object to the hash table.
1101
1102 template<int size, bool big_endian>
1103 void
1104 Symbol_table::add_from_relobj(
1105     Sized_relobj_file<size, big_endian>* relobj,
1106     const unsigned char* syms,
1107     size_t count,
1108     size_t symndx_offset,
1109     const char* sym_names,
1110     size_t sym_name_size,
1111     typename Sized_relobj_file<size, big_endian>::Symbols* sympointers,
1112     size_t* defined)
1113 {
1114   *defined = 0;
1115
1116   gold_assert(size == parameters->target().get_size());
1117
1118   const int sym_size = elfcpp::Elf_sizes<size>::sym_size;
1119
1120   const bool just_symbols = relobj->just_symbols();
1121
1122   const unsigned char* p = syms;
1123   for (size_t i = 0; i < count; ++i, p += sym_size)
1124     {
1125       (*sympointers)[i] = NULL;
1126
1127       elfcpp::Sym<size, big_endian> sym(p);
1128
1129       unsigned int st_name = sym.get_st_name();
1130       if (st_name >= sym_name_size)
1131         {
1132           relobj->error(_("bad global symbol name offset %u at %zu"),
1133                         st_name, i);
1134           continue;
1135         }
1136
1137       const char* name = sym_names + st_name;
1138
1139       if (strcmp (name, "__gnu_lto_slim") == 0)
1140         gold_info(_("%s: plugin needed to handle lto object"),
1141                   relobj->name().c_str());
1142
1143       bool is_ordinary;
1144       unsigned int st_shndx = relobj->adjust_sym_shndx(i + symndx_offset,
1145                                                        sym.get_st_shndx(),
1146                                                        &is_ordinary);
1147       unsigned int orig_st_shndx = st_shndx;
1148       if (!is_ordinary)
1149         orig_st_shndx = elfcpp::SHN_UNDEF;
1150
1151       if (st_shndx != elfcpp::SHN_UNDEF)
1152         ++*defined;
1153
1154       // A symbol defined in a section which we are not including must
1155       // be treated as an undefined symbol.
1156       bool is_defined_in_discarded_section = false;
1157       if (st_shndx != elfcpp::SHN_UNDEF
1158           && is_ordinary
1159           && !relobj->is_section_included(st_shndx)
1160           && !this->is_section_folded(relobj, st_shndx))
1161         {
1162           st_shndx = elfcpp::SHN_UNDEF;
1163           is_defined_in_discarded_section = true;
1164         }
1165
1166       // In an object file, an '@' in the name separates the symbol
1167       // name from the version name.  If there are two '@' characters,
1168       // this is the default version.
1169       const char* ver = strchr(name, '@');
1170       Stringpool::Key ver_key = 0;
1171       int namelen = 0;
1172       // IS_DEFAULT_VERSION: is the version default?
1173       // IS_FORCED_LOCAL: is the symbol forced local?
1174       bool is_default_version = false;
1175       bool is_forced_local = false;
1176
1177       // FIXME: For incremental links, we don't store version information,
1178       // so we need to ignore version symbols for now.
1179       if (parameters->incremental_update() && ver != NULL)
1180         {
1181           namelen = ver - name;
1182           ver = NULL;
1183         }
1184
1185       if (ver != NULL)
1186         {
1187           // The symbol name is of the form foo@VERSION or foo@@VERSION
1188           namelen = ver - name;
1189           ++ver;
1190           if (*ver == '@')
1191             {
1192               is_default_version = true;
1193               ++ver;
1194             }
1195           ver = this->namepool_.add(ver, true, &ver_key);
1196         }
1197       // We don't want to assign a version to an undefined symbol,
1198       // even if it is listed in the version script.  FIXME: What
1199       // about a common symbol?
1200       else
1201         {
1202           namelen = strlen(name);
1203           if (!this->version_script_.empty()
1204               && st_shndx != elfcpp::SHN_UNDEF)
1205             {
1206               // The symbol name did not have a version, but the
1207               // version script may assign a version anyway.
1208               std::string version;
1209               bool is_global;
1210               if (this->version_script_.get_symbol_version(name, &version,
1211                                                            &is_global))
1212                 {
1213                   if (!is_global)
1214                     is_forced_local = true;
1215                   else if (!version.empty())
1216                     {
1217                       ver = this->namepool_.add_with_length(version.c_str(),
1218                                                             version.length(),
1219                                                             true,
1220                                                             &ver_key);
1221                       is_default_version = true;
1222                     }
1223                 }
1224             }
1225         }
1226
1227       elfcpp::Sym<size, big_endian>* psym = &sym;
1228       unsigned char symbuf[sym_size];
1229       elfcpp::Sym<size, big_endian> sym2(symbuf);
1230       if (just_symbols)
1231         {
1232           memcpy(symbuf, p, sym_size);
1233           elfcpp::Sym_write<size, big_endian> sw(symbuf);
1234           if (orig_st_shndx != elfcpp::SHN_UNDEF
1235               && is_ordinary
1236               && relobj->e_type() == elfcpp::ET_REL)
1237             {
1238               // Symbol values in relocatable object files are section
1239               // relative.  This is normally what we want, but since here
1240               // we are converting the symbol to absolute we need to add
1241               // the section address.  The section address in an object
1242               // file is normally zero, but people can use a linker
1243               // script to change it.
1244               sw.put_st_value(sym.get_st_value()
1245                               + relobj->section_address(orig_st_shndx));
1246             }
1247           st_shndx = elfcpp::SHN_ABS;
1248           is_ordinary = false;
1249           psym = &sym2;
1250         }
1251
1252       // Fix up visibility if object has no-export set.
1253       if (relobj->no_export()
1254           && (orig_st_shndx != elfcpp::SHN_UNDEF || !is_ordinary))
1255         {
1256           // We may have copied symbol already above.
1257           if (psym != &sym2)
1258             {
1259               memcpy(symbuf, p, sym_size);
1260               psym = &sym2;
1261             }
1262
1263           elfcpp::STV visibility = sym2.get_st_visibility();
1264           if (visibility == elfcpp::STV_DEFAULT
1265               || visibility == elfcpp::STV_PROTECTED)
1266             {
1267               elfcpp::Sym_write<size, big_endian> sw(symbuf);
1268               unsigned char nonvis = sym2.get_st_nonvis();
1269               sw.put_st_other(elfcpp::STV_HIDDEN, nonvis);
1270             }
1271         }
1272
1273       Stringpool::Key name_key;
1274       name = this->namepool_.add_with_length(name, namelen, true,
1275                                              &name_key);
1276
1277       Sized_symbol<size>* res;
1278       res = this->add_from_object(relobj, name, name_key, ver, ver_key,
1279                                   is_default_version, *psym, st_shndx,
1280                                   is_ordinary, orig_st_shndx);
1281
1282       if (is_forced_local)
1283         this->force_local(res);
1284
1285       // Do not treat this symbol as garbage if this symbol will be
1286       // exported to the dynamic symbol table.  This is true when
1287       // building a shared library or using --export-dynamic and
1288       // the symbol is externally visible.
1289       if (parameters->options().gc_sections()
1290           && res->is_externally_visible()
1291           && !res->is_from_dynobj()
1292           && (parameters->options().shared()
1293               || parameters->options().export_dynamic()
1294               || parameters->options().in_dynamic_list(res->name())))
1295         this->gc_mark_symbol(res);
1296
1297       if (is_defined_in_discarded_section)
1298         res->set_is_defined_in_discarded_section();
1299
1300       (*sympointers)[i] = res;
1301     }
1302 }
1303
1304 // Add a symbol from a plugin-claimed file.
1305
1306 template<int size, bool big_endian>
1307 Symbol*
1308 Symbol_table::add_from_pluginobj(
1309     Sized_pluginobj<size, big_endian>* obj,
1310     const char* name,
1311     const char* ver,
1312     elfcpp::Sym<size, big_endian>* sym)
1313 {
1314   unsigned int st_shndx = sym->get_st_shndx();
1315   bool is_ordinary = st_shndx < elfcpp::SHN_LORESERVE;
1316
1317   Stringpool::Key ver_key = 0;
1318   bool is_default_version = false;
1319   bool is_forced_local = false;
1320
1321   if (ver != NULL)
1322     {
1323       ver = this->namepool_.add(ver, true, &ver_key);
1324     }
1325   // We don't want to assign a version to an undefined symbol,
1326   // even if it is listed in the version script.  FIXME: What
1327   // about a common symbol?
1328   else
1329     {
1330       if (!this->version_script_.empty()
1331           && st_shndx != elfcpp::SHN_UNDEF)
1332         {
1333           // The symbol name did not have a version, but the
1334           // version script may assign a version anyway.
1335           std::string version;
1336           bool is_global;
1337           if (this->version_script_.get_symbol_version(name, &version,
1338                                                        &is_global))
1339             {
1340               if (!is_global)
1341                 is_forced_local = true;
1342               else if (!version.empty())
1343                 {
1344                   ver = this->namepool_.add_with_length(version.c_str(),
1345                                                         version.length(),
1346                                                         true,
1347                                                         &ver_key);
1348                   is_default_version = true;
1349                 }
1350             }
1351         }
1352     }
1353
1354   Stringpool::Key name_key;
1355   name = this->namepool_.add(name, true, &name_key);
1356
1357   Sized_symbol<size>* res;
1358   res = this->add_from_object(obj, name, name_key, ver, ver_key,
1359                               is_default_version, *sym, st_shndx,
1360                               is_ordinary, st_shndx);
1361
1362   if (is_forced_local)
1363     this->force_local(res);
1364
1365   return res;
1366 }
1367
1368 // Add all the symbols in a dynamic object to the hash table.
1369
1370 template<int size, bool big_endian>
1371 void
1372 Symbol_table::add_from_dynobj(
1373     Sized_dynobj<size, big_endian>* dynobj,
1374     const unsigned char* syms,
1375     size_t count,
1376     const char* sym_names,
1377     size_t sym_name_size,
1378     const unsigned char* versym,
1379     size_t versym_size,
1380     const std::vector<const char*>* version_map,
1381     typename Sized_relobj_file<size, big_endian>::Symbols* sympointers,
1382     size_t* defined)
1383 {
1384   *defined = 0;
1385
1386   gold_assert(size == parameters->target().get_size());
1387
1388   if (dynobj->just_symbols())
1389     {
1390       gold_error(_("--just-symbols does not make sense with a shared object"));
1391       return;
1392     }
1393
1394   // FIXME: For incremental links, we don't store version information,
1395   // so we need to ignore version symbols for now.
1396   if (parameters->incremental_update())
1397     versym = NULL;
1398
1399   if (versym != NULL && versym_size / 2 < count)
1400     {
1401       dynobj->error(_("too few symbol versions"));
1402       return;
1403     }
1404
1405   const int sym_size = elfcpp::Elf_sizes<size>::sym_size;
1406
1407   // We keep a list of all STT_OBJECT symbols, so that we can resolve
1408   // weak aliases.  This is necessary because if the dynamic object
1409   // provides the same variable under two names, one of which is a
1410   // weak definition, and the regular object refers to the weak
1411   // definition, we have to put both the weak definition and the
1412   // strong definition into the dynamic symbol table.  Given a weak
1413   // definition, the only way that we can find the corresponding
1414   // strong definition, if any, is to search the symbol table.
1415   std::vector<Sized_symbol<size>*> object_symbols;
1416
1417   const unsigned char* p = syms;
1418   const unsigned char* vs = versym;
1419   for (size_t i = 0; i < count; ++i, p += sym_size, vs += 2)
1420     {
1421       elfcpp::Sym<size, big_endian> sym(p);
1422
1423       if (sympointers != NULL)
1424         (*sympointers)[i] = NULL;
1425
1426       // Ignore symbols with local binding or that have
1427       // internal or hidden visibility.
1428       if (sym.get_st_bind() == elfcpp::STB_LOCAL
1429           || sym.get_st_visibility() == elfcpp::STV_INTERNAL
1430           || sym.get_st_visibility() == elfcpp::STV_HIDDEN)
1431         continue;
1432
1433       // A protected symbol in a shared library must be treated as a
1434       // normal symbol when viewed from outside the shared library.
1435       // Implement this by overriding the visibility here.
1436       elfcpp::Sym<size, big_endian>* psym = &sym;
1437       unsigned char symbuf[sym_size];
1438       elfcpp::Sym<size, big_endian> sym2(symbuf);
1439       if (sym.get_st_visibility() == elfcpp::STV_PROTECTED)
1440         {
1441           memcpy(symbuf, p, sym_size);
1442           elfcpp::Sym_write<size, big_endian> sw(symbuf);
1443           sw.put_st_other(elfcpp::STV_DEFAULT, sym.get_st_nonvis());
1444           psym = &sym2;
1445         }
1446
1447       unsigned int st_name = psym->get_st_name();
1448       if (st_name >= sym_name_size)
1449         {
1450           dynobj->error(_("bad symbol name offset %u at %zu"),
1451                         st_name, i);
1452           continue;
1453         }
1454
1455       const char* name = sym_names + st_name;
1456
1457       bool is_ordinary;
1458       unsigned int st_shndx = dynobj->adjust_sym_shndx(i, psym->get_st_shndx(),
1459                                                        &is_ordinary);
1460
1461       if (st_shndx != elfcpp::SHN_UNDEF)
1462         ++*defined;
1463
1464       Sized_symbol<size>* res;
1465
1466       if (versym == NULL)
1467         {
1468           Stringpool::Key name_key;
1469           name = this->namepool_.add(name, true, &name_key);
1470           res = this->add_from_object(dynobj, name, name_key, NULL, 0,
1471                                       false, *psym, st_shndx, is_ordinary,
1472                                       st_shndx);
1473         }
1474       else
1475         {
1476           // Read the version information.
1477
1478           unsigned int v = elfcpp::Swap<16, big_endian>::readval(vs);
1479
1480           bool hidden = (v & elfcpp::VERSYM_HIDDEN) != 0;
1481           v &= elfcpp::VERSYM_VERSION;
1482
1483           // The Sun documentation says that V can be VER_NDX_LOCAL,
1484           // or VER_NDX_GLOBAL, or a version index.  The meaning of
1485           // VER_NDX_LOCAL is defined as "Symbol has local scope."
1486           // The old GNU linker will happily generate VER_NDX_LOCAL
1487           // for an undefined symbol.  I don't know what the Sun
1488           // linker will generate.
1489
1490           if (v == static_cast<unsigned int>(elfcpp::VER_NDX_LOCAL)
1491               && st_shndx != elfcpp::SHN_UNDEF)
1492             {
1493               // This symbol should not be visible outside the object.
1494               continue;
1495             }
1496
1497           // At this point we are definitely going to add this symbol.
1498           Stringpool::Key name_key;
1499           name = this->namepool_.add(name, true, &name_key);
1500
1501           if (v == static_cast<unsigned int>(elfcpp::VER_NDX_LOCAL)
1502               || v == static_cast<unsigned int>(elfcpp::VER_NDX_GLOBAL))
1503             {
1504               // This symbol does not have a version.
1505               res = this->add_from_object(dynobj, name, name_key, NULL, 0,
1506                                           false, *psym, st_shndx, is_ordinary,
1507                                           st_shndx);
1508             }
1509           else
1510             {
1511               if (v >= version_map->size())
1512                 {
1513                   dynobj->error(_("versym for symbol %zu out of range: %u"),
1514                                 i, v);
1515                   continue;
1516                 }
1517
1518               const char* version = (*version_map)[v];
1519               if (version == NULL)
1520                 {
1521                   dynobj->error(_("versym for symbol %zu has no name: %u"),
1522                                 i, v);
1523                   continue;
1524                 }
1525
1526               Stringpool::Key version_key;
1527               version = this->namepool_.add(version, true, &version_key);
1528
1529               // If this is an absolute symbol, and the version name
1530               // and symbol name are the same, then this is the
1531               // version definition symbol.  These symbols exist to
1532               // support using -u to pull in particular versions.  We
1533               // do not want to record a version for them.
1534               if (st_shndx == elfcpp::SHN_ABS
1535                   && !is_ordinary
1536                   && name_key == version_key)
1537                 res = this->add_from_object(dynobj, name, name_key, NULL, 0,
1538                                             false, *psym, st_shndx, is_ordinary,
1539                                             st_shndx);
1540               else
1541                 {
1542                   const bool is_default_version =
1543                     !hidden && st_shndx != elfcpp::SHN_UNDEF;
1544                   res = this->add_from_object(dynobj, name, name_key, version,
1545                                               version_key, is_default_version,
1546                                               *psym, st_shndx,
1547                                               is_ordinary, st_shndx);
1548                 }
1549             }
1550         }
1551
1552       // Note that it is possible that RES was overridden by an
1553       // earlier object, in which case it can't be aliased here.
1554       if (st_shndx != elfcpp::SHN_UNDEF
1555           && is_ordinary
1556           && psym->get_st_type() == elfcpp::STT_OBJECT
1557           && res->source() == Symbol::FROM_OBJECT
1558           && res->object() == dynobj)
1559         object_symbols.push_back(res);
1560
1561       if (sympointers != NULL)
1562         (*sympointers)[i] = res;
1563     }
1564
1565   this->record_weak_aliases(&object_symbols);
1566 }
1567
1568 // Add a symbol from a incremental object file.
1569
1570 template<int size, bool big_endian>
1571 Sized_symbol<size>*
1572 Symbol_table::add_from_incrobj(
1573     Object* obj,
1574     const char* name,
1575     const char* ver,
1576     elfcpp::Sym<size, big_endian>* sym)
1577 {
1578   unsigned int st_shndx = sym->get_st_shndx();
1579   bool is_ordinary = st_shndx < elfcpp::SHN_LORESERVE;
1580
1581   Stringpool::Key ver_key = 0;
1582   bool is_default_version = false;
1583   bool is_forced_local = false;
1584
1585   Stringpool::Key name_key;
1586   name = this->namepool_.add(name, true, &name_key);
1587
1588   Sized_symbol<size>* res;
1589   res = this->add_from_object(obj, name, name_key, ver, ver_key,
1590                               is_default_version, *sym, st_shndx,
1591                               is_ordinary, st_shndx);
1592
1593   if (is_forced_local)
1594     this->force_local(res);
1595
1596   return res;
1597 }
1598
1599 // This is used to sort weak aliases.  We sort them first by section
1600 // index, then by offset, then by weak ahead of strong.
1601
1602 template<int size>
1603 class Weak_alias_sorter
1604 {
1605  public:
1606   bool operator()(const Sized_symbol<size>*, const Sized_symbol<size>*) const;
1607 };
1608
1609 template<int size>
1610 bool
1611 Weak_alias_sorter<size>::operator()(const Sized_symbol<size>* s1,
1612                                     const Sized_symbol<size>* s2) const
1613 {
1614   bool is_ordinary;
1615   unsigned int s1_shndx = s1->shndx(&is_ordinary);
1616   gold_assert(is_ordinary);
1617   unsigned int s2_shndx = s2->shndx(&is_ordinary);
1618   gold_assert(is_ordinary);
1619   if (s1_shndx != s2_shndx)
1620     return s1_shndx < s2_shndx;
1621
1622   if (s1->value() != s2->value())
1623     return s1->value() < s2->value();
1624   if (s1->binding() != s2->binding())
1625     {
1626       if (s1->binding() == elfcpp::STB_WEAK)
1627         return true;
1628       if (s2->binding() == elfcpp::STB_WEAK)
1629         return false;
1630     }
1631   return std::string(s1->name()) < std::string(s2->name());
1632 }
1633
1634 // SYMBOLS is a list of object symbols from a dynamic object.  Look
1635 // for any weak aliases, and record them so that if we add the weak
1636 // alias to the dynamic symbol table, we also add the corresponding
1637 // strong symbol.
1638
1639 template<int size>
1640 void
1641 Symbol_table::record_weak_aliases(std::vector<Sized_symbol<size>*>* symbols)
1642 {
1643   // Sort the vector by section index, then by offset, then by weak
1644   // ahead of strong.
1645   std::sort(symbols->begin(), symbols->end(), Weak_alias_sorter<size>());
1646
1647   // Walk through the vector.  For each weak definition, record
1648   // aliases.
1649   for (typename std::vector<Sized_symbol<size>*>::const_iterator p =
1650          symbols->begin();
1651        p != symbols->end();
1652        ++p)
1653     {
1654       if ((*p)->binding() != elfcpp::STB_WEAK)
1655         continue;
1656
1657       // Build a circular list of weak aliases.  Each symbol points to
1658       // the next one in the circular list.
1659
1660       Sized_symbol<size>* from_sym = *p;
1661       typename std::vector<Sized_symbol<size>*>::const_iterator q;
1662       for (q = p + 1; q != symbols->end(); ++q)
1663         {
1664           bool dummy;
1665           if ((*q)->shndx(&dummy) != from_sym->shndx(&dummy)
1666               || (*q)->value() != from_sym->value())
1667             break;
1668
1669           this->weak_aliases_[from_sym] = *q;
1670           from_sym->set_has_alias();
1671           from_sym = *q;
1672         }
1673
1674       if (from_sym != *p)
1675         {
1676           this->weak_aliases_[from_sym] = *p;
1677           from_sym->set_has_alias();
1678         }
1679
1680       p = q - 1;
1681     }
1682 }
1683
1684 // Create and return a specially defined symbol.  If ONLY_IF_REF is
1685 // true, then only create the symbol if there is a reference to it.
1686 // If this does not return NULL, it sets *POLDSYM to the existing
1687 // symbol if there is one.  This sets *RESOLVE_OLDSYM if we should
1688 // resolve the newly created symbol to the old one.  This
1689 // canonicalizes *PNAME and *PVERSION.
1690
1691 template<int size, bool big_endian>
1692 Sized_symbol<size>*
1693 Symbol_table::define_special_symbol(const char** pname, const char** pversion,
1694                                     bool only_if_ref,
1695                                     Sized_symbol<size>** poldsym,
1696                                     bool* resolve_oldsym)
1697 {
1698   *resolve_oldsym = false;
1699   *poldsym = NULL;
1700
1701   // If the caller didn't give us a version, see if we get one from
1702   // the version script.
1703   std::string v;
1704   bool is_default_version = false;
1705   if (*pversion == NULL)
1706     {
1707       bool is_global;
1708       if (this->version_script_.get_symbol_version(*pname, &v, &is_global))
1709         {
1710           if (is_global && !v.empty())
1711             {
1712               *pversion = v.c_str();
1713               // If we get the version from a version script, then we
1714               // are also the default version.
1715               is_default_version = true;
1716             }
1717         }
1718     }
1719
1720   Symbol* oldsym;
1721   Sized_symbol<size>* sym;
1722
1723   bool add_to_table = false;
1724   typename Symbol_table_type::iterator add_loc = this->table_.end();
1725   bool add_def_to_table = false;
1726   typename Symbol_table_type::iterator add_def_loc = this->table_.end();
1727
1728   if (only_if_ref)
1729     {
1730       oldsym = this->lookup(*pname, *pversion);
1731       if (oldsym == NULL && is_default_version)
1732         oldsym = this->lookup(*pname, NULL);
1733       if (oldsym == NULL || !oldsym->is_undefined())
1734         return NULL;
1735
1736       *pname = oldsym->name();
1737       if (is_default_version)
1738         *pversion = this->namepool_.add(*pversion, true, NULL);
1739       else
1740         *pversion = oldsym->version();
1741     }
1742   else
1743     {
1744       // Canonicalize NAME and VERSION.
1745       Stringpool::Key name_key;
1746       *pname = this->namepool_.add(*pname, true, &name_key);
1747
1748       Stringpool::Key version_key = 0;
1749       if (*pversion != NULL)
1750         *pversion = this->namepool_.add(*pversion, true, &version_key);
1751
1752       Symbol* const snull = NULL;
1753       std::pair<typename Symbol_table_type::iterator, bool> ins =
1754         this->table_.insert(std::make_pair(std::make_pair(name_key,
1755                                                           version_key),
1756                                            snull));
1757
1758       std::pair<typename Symbol_table_type::iterator, bool> insdefault =
1759         std::make_pair(this->table_.end(), false);
1760       if (is_default_version)
1761         {
1762           const Stringpool::Key vnull = 0;
1763           insdefault =
1764             this->table_.insert(std::make_pair(std::make_pair(name_key,
1765                                                               vnull),
1766                                                snull));
1767         }
1768
1769       if (!ins.second)
1770         {
1771           // We already have a symbol table entry for NAME/VERSION.
1772           oldsym = ins.first->second;
1773           gold_assert(oldsym != NULL);
1774
1775           if (is_default_version)
1776             {
1777               Sized_symbol<size>* soldsym =
1778                 this->get_sized_symbol<size>(oldsym);
1779               this->define_default_version<size, big_endian>(soldsym,
1780                                                              insdefault.second,
1781                                                              insdefault.first);
1782             }
1783         }
1784       else
1785         {
1786           // We haven't seen this symbol before.
1787           gold_assert(ins.first->second == NULL);
1788
1789           add_to_table = true;
1790           add_loc = ins.first;
1791
1792           if (is_default_version && !insdefault.second)
1793             {
1794               // We are adding NAME/VERSION, and it is the default
1795               // version.  We already have an entry for NAME/NULL.
1796               oldsym = insdefault.first->second;
1797               *resolve_oldsym = true;
1798             }
1799           else
1800             {
1801               oldsym = NULL;
1802
1803               if (is_default_version)
1804                 {
1805                   add_def_to_table = true;
1806                   add_def_loc = insdefault.first;
1807                 }
1808             }
1809         }
1810     }
1811
1812   const Target& target = parameters->target();
1813   if (!target.has_make_symbol())
1814     sym = new Sized_symbol<size>();
1815   else
1816     {
1817       Sized_target<size, big_endian>* sized_target =
1818         parameters->sized_target<size, big_endian>();
1819       sym = sized_target->make_symbol();
1820       if (sym == NULL)
1821         return NULL;
1822     }
1823
1824   if (add_to_table)
1825     add_loc->second = sym;
1826   else
1827     gold_assert(oldsym != NULL);
1828
1829   if (add_def_to_table)
1830     add_def_loc->second = sym;
1831
1832   *poldsym = this->get_sized_symbol<size>(oldsym);
1833
1834   return sym;
1835 }
1836
1837 // Define a symbol based on an Output_data.
1838
1839 Symbol*
1840 Symbol_table::define_in_output_data(const char* name,
1841                                     const char* version,
1842                                     Defined defined,
1843                                     Output_data* od,
1844                                     uint64_t value,
1845                                     uint64_t symsize,
1846                                     elfcpp::STT type,
1847                                     elfcpp::STB binding,
1848                                     elfcpp::STV visibility,
1849                                     unsigned char nonvis,
1850                                     bool offset_is_from_end,
1851                                     bool only_if_ref)
1852 {
1853   if (parameters->target().get_size() == 32)
1854     {
1855 #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG)
1856       return this->do_define_in_output_data<32>(name, version, defined, od,
1857                                                 value, symsize, type, binding,
1858                                                 visibility, nonvis,
1859                                                 offset_is_from_end,
1860                                                 only_if_ref);
1861 #else
1862       gold_unreachable();
1863 #endif
1864     }
1865   else if (parameters->target().get_size() == 64)
1866     {
1867 #if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG)
1868       return this->do_define_in_output_data<64>(name, version, defined, od,
1869                                                 value, symsize, type, binding,
1870                                                 visibility, nonvis,
1871                                                 offset_is_from_end,
1872                                                 only_if_ref);
1873 #else
1874       gold_unreachable();
1875 #endif
1876     }
1877   else
1878     gold_unreachable();
1879 }
1880
1881 // Define a symbol in an Output_data, sized version.
1882
1883 template<int size>
1884 Sized_symbol<size>*
1885 Symbol_table::do_define_in_output_data(
1886     const char* name,
1887     const char* version,
1888     Defined defined,
1889     Output_data* od,
1890     typename elfcpp::Elf_types<size>::Elf_Addr value,
1891     typename elfcpp::Elf_types<size>::Elf_WXword symsize,
1892     elfcpp::STT type,
1893     elfcpp::STB binding,
1894     elfcpp::STV visibility,
1895     unsigned char nonvis,
1896     bool offset_is_from_end,
1897     bool only_if_ref)
1898 {
1899   Sized_symbol<size>* sym;
1900   Sized_symbol<size>* oldsym;
1901   bool resolve_oldsym;
1902
1903   if (parameters->target().is_big_endian())
1904     {
1905 #if defined(HAVE_TARGET_32_BIG) || defined(HAVE_TARGET_64_BIG)
1906       sym = this->define_special_symbol<size, true>(&name, &version,
1907                                                     only_if_ref, &oldsym,
1908                                                     &resolve_oldsym);
1909 #else
1910       gold_unreachable();
1911 #endif
1912     }
1913   else
1914     {
1915 #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_64_LITTLE)
1916       sym = this->define_special_symbol<size, false>(&name, &version,
1917                                                      only_if_ref, &oldsym,
1918                                                      &resolve_oldsym);
1919 #else
1920       gold_unreachable();
1921 #endif
1922     }
1923
1924   if (sym == NULL)
1925     return NULL;
1926
1927   sym->init_output_data(name, version, od, value, symsize, type, binding,
1928                         visibility, nonvis, offset_is_from_end,
1929                         defined == PREDEFINED);
1930
1931   if (oldsym == NULL)
1932     {
1933       if (binding == elfcpp::STB_LOCAL
1934           || this->version_script_.symbol_is_local(name))
1935         this->force_local(sym);
1936       else if (version != NULL)
1937         sym->set_is_default();
1938       return sym;
1939     }
1940
1941   if (Symbol_table::should_override_with_special(oldsym, type, defined))
1942     this->override_with_special(oldsym, sym);
1943
1944   if (resolve_oldsym)
1945     return sym;
1946   else
1947     {
1948       delete sym;
1949       return oldsym;
1950     }
1951 }
1952
1953 // Define a symbol based on an Output_segment.
1954
1955 Symbol*
1956 Symbol_table::define_in_output_segment(const char* name,
1957                                        const char* version,
1958                                        Defined defined,
1959                                        Output_segment* os,
1960                                        uint64_t value,
1961                                        uint64_t symsize,
1962                                        elfcpp::STT type,
1963                                        elfcpp::STB binding,
1964                                        elfcpp::STV visibility,
1965                                        unsigned char nonvis,
1966                                        Symbol::Segment_offset_base offset_base,
1967                                        bool only_if_ref)
1968 {
1969   if (parameters->target().get_size() == 32)
1970     {
1971 #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG)
1972       return this->do_define_in_output_segment<32>(name, version, defined, os,
1973                                                    value, symsize, type,
1974                                                    binding, visibility, nonvis,
1975                                                    offset_base, only_if_ref);
1976 #else
1977       gold_unreachable();
1978 #endif
1979     }
1980   else if (parameters->target().get_size() == 64)
1981     {
1982 #if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG)
1983       return this->do_define_in_output_segment<64>(name, version, defined, os,
1984                                                    value, symsize, type,
1985                                                    binding, visibility, nonvis,
1986                                                    offset_base, only_if_ref);
1987 #else
1988       gold_unreachable();
1989 #endif
1990     }
1991   else
1992     gold_unreachable();
1993 }
1994
1995 // Define a symbol in an Output_segment, sized version.
1996
1997 template<int size>
1998 Sized_symbol<size>*
1999 Symbol_table::do_define_in_output_segment(
2000     const char* name,
2001     const char* version,
2002     Defined defined,
2003     Output_segment* os,
2004     typename elfcpp::Elf_types<size>::Elf_Addr value,
2005     typename elfcpp::Elf_types<size>::Elf_WXword symsize,
2006     elfcpp::STT type,
2007     elfcpp::STB binding,
2008     elfcpp::STV visibility,
2009     unsigned char nonvis,
2010     Symbol::Segment_offset_base offset_base,
2011     bool only_if_ref)
2012 {
2013   Sized_symbol<size>* sym;
2014   Sized_symbol<size>* oldsym;
2015   bool resolve_oldsym;
2016
2017   if (parameters->target().is_big_endian())
2018     {
2019 #if defined(HAVE_TARGET_32_BIG) || defined(HAVE_TARGET_64_BIG)
2020       sym = this->define_special_symbol<size, true>(&name, &version,
2021                                                     only_if_ref, &oldsym,
2022                                                     &resolve_oldsym);
2023 #else
2024       gold_unreachable();
2025 #endif
2026     }
2027   else
2028     {
2029 #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_64_LITTLE)
2030       sym = this->define_special_symbol<size, false>(&name, &version,
2031                                                      only_if_ref, &oldsym,
2032                                                      &resolve_oldsym);
2033 #else
2034       gold_unreachable();
2035 #endif
2036     }
2037
2038   if (sym == NULL)
2039     return NULL;
2040
2041   sym->init_output_segment(name, version, os, value, symsize, type, binding,
2042                            visibility, nonvis, offset_base,
2043                            defined == PREDEFINED);
2044
2045   if (oldsym == NULL)
2046     {
2047       if (binding == elfcpp::STB_LOCAL
2048           || this->version_script_.symbol_is_local(name))
2049         this->force_local(sym);
2050       else if (version != NULL)
2051         sym->set_is_default();
2052       return sym;
2053     }
2054
2055   if (Symbol_table::should_override_with_special(oldsym, type, defined))
2056     this->override_with_special(oldsym, sym);
2057
2058   if (resolve_oldsym)
2059     return sym;
2060   else
2061     {
2062       delete sym;
2063       return oldsym;
2064     }
2065 }
2066
2067 // Define a special symbol with a constant value.  It is a multiple
2068 // definition error if this symbol is already defined.
2069
2070 Symbol*
2071 Symbol_table::define_as_constant(const char* name,
2072                                  const char* version,
2073                                  Defined defined,
2074                                  uint64_t value,
2075                                  uint64_t symsize,
2076                                  elfcpp::STT type,
2077                                  elfcpp::STB binding,
2078                                  elfcpp::STV visibility,
2079                                  unsigned char nonvis,
2080                                  bool only_if_ref,
2081                                  bool force_override)
2082 {
2083   if (parameters->target().get_size() == 32)
2084     {
2085 #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG)
2086       return this->do_define_as_constant<32>(name, version, defined, value,
2087                                              symsize, type, binding,
2088                                              visibility, nonvis, only_if_ref,
2089                                              force_override);
2090 #else
2091       gold_unreachable();
2092 #endif
2093     }
2094   else if (parameters->target().get_size() == 64)
2095     {
2096 #if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG)
2097       return this->do_define_as_constant<64>(name, version, defined, value,
2098                                              symsize, type, binding,
2099                                              visibility, nonvis, only_if_ref,
2100                                              force_override);
2101 #else
2102       gold_unreachable();
2103 #endif
2104     }
2105   else
2106     gold_unreachable();
2107 }
2108
2109 // Define a symbol as a constant, sized version.
2110
2111 template<int size>
2112 Sized_symbol<size>*
2113 Symbol_table::do_define_as_constant(
2114     const char* name,
2115     const char* version,
2116     Defined defined,
2117     typename elfcpp::Elf_types<size>::Elf_Addr value,
2118     typename elfcpp::Elf_types<size>::Elf_WXword symsize,
2119     elfcpp::STT type,
2120     elfcpp::STB binding,
2121     elfcpp::STV visibility,
2122     unsigned char nonvis,
2123     bool only_if_ref,
2124     bool force_override)
2125 {
2126   Sized_symbol<size>* sym;
2127   Sized_symbol<size>* oldsym;
2128   bool resolve_oldsym;
2129
2130   if (parameters->target().is_big_endian())
2131     {
2132 #if defined(HAVE_TARGET_32_BIG) || defined(HAVE_TARGET_64_BIG)
2133       sym = this->define_special_symbol<size, true>(&name, &version,
2134                                                     only_if_ref, &oldsym,
2135                                                     &resolve_oldsym);
2136 #else
2137       gold_unreachable();
2138 #endif
2139     }
2140   else
2141     {
2142 #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_64_LITTLE)
2143       sym = this->define_special_symbol<size, false>(&name, &version,
2144                                                      only_if_ref, &oldsym,
2145                                                      &resolve_oldsym);
2146 #else
2147       gold_unreachable();
2148 #endif
2149     }
2150
2151   if (sym == NULL)
2152     return NULL;
2153
2154   sym->init_constant(name, version, value, symsize, type, binding, visibility,
2155                      nonvis, defined == PREDEFINED);
2156
2157   if (oldsym == NULL)
2158     {
2159       // Version symbols are absolute symbols with name == version.
2160       // We don't want to force them to be local.
2161       if ((version == NULL
2162            || name != version
2163            || value != 0)
2164           && (binding == elfcpp::STB_LOCAL
2165               || this->version_script_.symbol_is_local(name)))
2166         this->force_local(sym);
2167       else if (version != NULL
2168                && (name != version || value != 0))
2169         sym->set_is_default();
2170       return sym;
2171     }
2172
2173   if (force_override
2174       || Symbol_table::should_override_with_special(oldsym, type, defined))
2175     this->override_with_special(oldsym, sym);
2176
2177   if (resolve_oldsym)
2178     return sym;
2179   else
2180     {
2181       delete sym;
2182       return oldsym;
2183     }
2184 }
2185
2186 // Define a set of symbols in output sections.
2187
2188 void
2189 Symbol_table::define_symbols(const Layout* layout, int count,
2190                              const Define_symbol_in_section* p,
2191                              bool only_if_ref)
2192 {
2193   for (int i = 0; i < count; ++i, ++p)
2194     {
2195       Output_section* os = layout->find_output_section(p->output_section);
2196       if (os != NULL)
2197         this->define_in_output_data(p->name, NULL, PREDEFINED, os, p->value,
2198                                     p->size, p->type, p->binding,
2199                                     p->visibility, p->nonvis,
2200                                     p->offset_is_from_end,
2201                                     only_if_ref || p->only_if_ref);
2202       else
2203         this->define_as_constant(p->name, NULL, PREDEFINED, 0, p->size,
2204                                  p->type, p->binding, p->visibility, p->nonvis,
2205                                  only_if_ref || p->only_if_ref,
2206                                  false);
2207     }
2208 }
2209
2210 // Define a set of symbols in output segments.
2211
2212 void
2213 Symbol_table::define_symbols(const Layout* layout, int count,
2214                              const Define_symbol_in_segment* p,
2215                              bool only_if_ref)
2216 {
2217   for (int i = 0; i < count; ++i, ++p)
2218     {
2219       Output_segment* os = layout->find_output_segment(p->segment_type,
2220                                                        p->segment_flags_set,
2221                                                        p->segment_flags_clear);
2222       if (os != NULL)
2223         this->define_in_output_segment(p->name, NULL, PREDEFINED, os, p->value,
2224                                        p->size, p->type, p->binding,
2225                                        p->visibility, p->nonvis,
2226                                        p->offset_base,
2227                                        only_if_ref || p->only_if_ref);
2228       else
2229         this->define_as_constant(p->name, NULL, PREDEFINED, 0, p->size,
2230                                  p->type, p->binding, p->visibility, p->nonvis,
2231                                  only_if_ref || p->only_if_ref,
2232                                  false);
2233     }
2234 }
2235
2236 // Define CSYM using a COPY reloc.  POSD is the Output_data where the
2237 // symbol should be defined--typically a .dyn.bss section.  VALUE is
2238 // the offset within POSD.
2239
2240 template<int size>
2241 void
2242 Symbol_table::define_with_copy_reloc(
2243     Sized_symbol<size>* csym,
2244     Output_data* posd,
2245     typename elfcpp::Elf_types<size>::Elf_Addr value)
2246 {
2247   gold_assert(csym->is_from_dynobj());
2248   gold_assert(!csym->is_copied_from_dynobj());
2249   Object* object = csym->object();
2250   gold_assert(object->is_dynamic());
2251   Dynobj* dynobj = static_cast<Dynobj*>(object);
2252
2253   // Our copied variable has to override any variable in a shared
2254   // library.
2255   elfcpp::STB binding = csym->binding();
2256   if (binding == elfcpp::STB_WEAK)
2257     binding = elfcpp::STB_GLOBAL;
2258
2259   this->define_in_output_data(csym->name(), csym->version(), COPY,
2260                               posd, value, csym->symsize(),
2261                               csym->type(), binding,
2262                               csym->visibility(), csym->nonvis(),
2263                               false, false);
2264
2265   csym->set_is_copied_from_dynobj();
2266   csym->set_needs_dynsym_entry();
2267
2268   this->copied_symbol_dynobjs_[csym] = dynobj;
2269
2270   // We have now defined all aliases, but we have not entered them all
2271   // in the copied_symbol_dynobjs_ map.
2272   if (csym->has_alias())
2273     {
2274       Symbol* sym = csym;
2275       while (true)
2276         {
2277           sym = this->weak_aliases_[sym];
2278           if (sym == csym)
2279             break;
2280           gold_assert(sym->output_data() == posd);
2281
2282           sym->set_is_copied_from_dynobj();
2283           this->copied_symbol_dynobjs_[sym] = dynobj;
2284         }
2285     }
2286 }
2287
2288 // SYM is defined using a COPY reloc.  Return the dynamic object where
2289 // the original definition was found.
2290
2291 Dynobj*
2292 Symbol_table::get_copy_source(const Symbol* sym) const
2293 {
2294   gold_assert(sym->is_copied_from_dynobj());
2295   Copied_symbol_dynobjs::const_iterator p =
2296     this->copied_symbol_dynobjs_.find(sym);
2297   gold_assert(p != this->copied_symbol_dynobjs_.end());
2298   return p->second;
2299 }
2300
2301 // Add any undefined symbols named on the command line.
2302
2303 void
2304 Symbol_table::add_undefined_symbols_from_command_line(Layout* layout)
2305 {
2306   if (parameters->options().any_undefined()
2307       || layout->script_options()->any_unreferenced())
2308     {
2309       if (parameters->target().get_size() == 32)
2310         {
2311 #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG)
2312           this->do_add_undefined_symbols_from_command_line<32>(layout);
2313 #else
2314           gold_unreachable();
2315 #endif
2316         }
2317       else if (parameters->target().get_size() == 64)
2318         {
2319 #if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG)
2320           this->do_add_undefined_symbols_from_command_line<64>(layout);
2321 #else
2322           gold_unreachable();
2323 #endif
2324         }
2325       else
2326         gold_unreachable();
2327     }
2328 }
2329
2330 template<int size>
2331 void
2332 Symbol_table::do_add_undefined_symbols_from_command_line(Layout* layout)
2333 {
2334   for (options::String_set::const_iterator p =
2335          parameters->options().undefined_begin();
2336        p != parameters->options().undefined_end();
2337        ++p)
2338     this->add_undefined_symbol_from_command_line<size>(p->c_str());
2339
2340   for (options::String_set::const_iterator p =
2341          parameters->options().export_dynamic_symbol_begin();
2342        p != parameters->options().export_dynamic_symbol_end();
2343        ++p)
2344     this->add_undefined_symbol_from_command_line<size>(p->c_str());
2345
2346   for (Script_options::referenced_const_iterator p =
2347          layout->script_options()->referenced_begin();
2348        p != layout->script_options()->referenced_end();
2349        ++p)
2350     this->add_undefined_symbol_from_command_line<size>(p->c_str());
2351 }
2352
2353 template<int size>
2354 void
2355 Symbol_table::add_undefined_symbol_from_command_line(const char* name)
2356 {
2357   if (this->lookup(name) != NULL)
2358     return;
2359
2360   const char* version = NULL;
2361
2362   Sized_symbol<size>* sym;
2363   Sized_symbol<size>* oldsym;
2364   bool resolve_oldsym;
2365   if (parameters->target().is_big_endian())
2366     {
2367 #if defined(HAVE_TARGET_32_BIG) || defined(HAVE_TARGET_64_BIG)
2368       sym = this->define_special_symbol<size, true>(&name, &version,
2369                                                     false, &oldsym,
2370                                                     &resolve_oldsym);
2371 #else
2372       gold_unreachable();
2373 #endif
2374     }
2375   else
2376     {
2377 #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_64_LITTLE)
2378       sym = this->define_special_symbol<size, false>(&name, &version,
2379                                                      false, &oldsym,
2380                                                      &resolve_oldsym);
2381 #else
2382       gold_unreachable();
2383 #endif
2384     }
2385
2386   gold_assert(oldsym == NULL);
2387
2388   sym->init_undefined(name, version, elfcpp::STT_NOTYPE, elfcpp::STB_GLOBAL,
2389                       elfcpp::STV_DEFAULT, 0);
2390   ++this->saw_undefined_;
2391 }
2392
2393 // Set the dynamic symbol indexes.  INDEX is the index of the first
2394 // global dynamic symbol.  Pointers to the symbols are stored into the
2395 // vector SYMS.  The names are added to DYNPOOL.  This returns an
2396 // updated dynamic symbol index.
2397
2398 unsigned int
2399 Symbol_table::set_dynsym_indexes(unsigned int index,
2400                                  std::vector<Symbol*>* syms,
2401                                  Stringpool* dynpool,
2402                                  Versions* versions)
2403 {
2404   std::vector<Symbol*> as_needed_sym;
2405
2406   // Allow a target to set dynsym indexes.
2407   if (parameters->target().has_custom_set_dynsym_indexes())
2408     {
2409       std::vector<Symbol*> dyn_symbols;
2410       for (Symbol_table_type::iterator p = this->table_.begin();
2411            p != this->table_.end();
2412            ++p)
2413         {
2414           Symbol* sym = p->second;
2415           if (!sym->should_add_dynsym_entry(this))
2416             sym->set_dynsym_index(-1U);
2417           else
2418             dyn_symbols.push_back(sym);
2419         }
2420
2421       return parameters->target().set_dynsym_indexes(&dyn_symbols, index, syms,
2422                                                      dynpool, versions, this);
2423     }
2424
2425   for (Symbol_table_type::iterator p = this->table_.begin();
2426        p != this->table_.end();
2427        ++p)
2428     {
2429       Symbol* sym = p->second;
2430
2431       // Note that SYM may already have a dynamic symbol index, since
2432       // some symbols appear more than once in the symbol table, with
2433       // and without a version.
2434
2435       if (!sym->should_add_dynsym_entry(this))
2436         sym->set_dynsym_index(-1U);
2437       else if (!sym->has_dynsym_index())
2438         {
2439           sym->set_dynsym_index(index);
2440           ++index;
2441           syms->push_back(sym);
2442           dynpool->add(sym->name(), false, NULL);
2443
2444           // If the symbol is defined in a dynamic object and is
2445           // referenced strongly in a regular object, then mark the
2446           // dynamic object as needed.  This is used to implement
2447           // --as-needed.
2448           if (sym->is_from_dynobj()
2449               && sym->in_reg()
2450               && !sym->is_undef_binding_weak())
2451             sym->object()->set_is_needed();
2452
2453           // Record any version information, except those from
2454           // as-needed libraries not seen to be needed.  Note that the
2455           // is_needed state for such libraries can change in this loop.
2456           if (sym->version() != NULL)
2457             {
2458               if (!sym->is_from_dynobj()
2459                   || !sym->object()->as_needed()
2460                   || sym->object()->is_needed())
2461                 versions->record_version(this, dynpool, sym);
2462               else
2463                 as_needed_sym.push_back(sym);
2464             }
2465         }
2466     }
2467
2468   // Process version information for symbols from as-needed libraries.
2469   for (std::vector<Symbol*>::iterator p = as_needed_sym.begin();
2470        p != as_needed_sym.end();
2471        ++p)
2472     {
2473       Symbol* sym = *p;
2474
2475       if (sym->object()->is_needed())
2476         versions->record_version(this, dynpool, sym);
2477       else
2478         sym->clear_version();
2479     }
2480
2481   // Finish up the versions.  In some cases this may add new dynamic
2482   // symbols.
2483   index = versions->finalize(this, index, syms);
2484
2485   return index;
2486 }
2487
2488 // Set the final values for all the symbols.  The index of the first
2489 // global symbol in the output file is *PLOCAL_SYMCOUNT.  Record the
2490 // file offset OFF.  Add their names to POOL.  Return the new file
2491 // offset.  Update *PLOCAL_SYMCOUNT if necessary.
2492
2493 off_t
2494 Symbol_table::finalize(off_t off, off_t dynoff, size_t dyn_global_index,
2495                        size_t dyncount, Stringpool* pool,
2496                        unsigned int* plocal_symcount)
2497 {
2498   off_t ret;
2499
2500   gold_assert(*plocal_symcount != 0);
2501   this->first_global_index_ = *plocal_symcount;
2502
2503   this->dynamic_offset_ = dynoff;
2504   this->first_dynamic_global_index_ = dyn_global_index;
2505   this->dynamic_count_ = dyncount;
2506
2507   if (parameters->target().get_size() == 32)
2508     {
2509 #if defined(HAVE_TARGET_32_BIG) || defined(HAVE_TARGET_32_LITTLE)
2510       ret = this->sized_finalize<32>(off, pool, plocal_symcount);
2511 #else
2512       gold_unreachable();
2513 #endif
2514     }
2515   else if (parameters->target().get_size() == 64)
2516     {
2517 #if defined(HAVE_TARGET_64_BIG) || defined(HAVE_TARGET_64_LITTLE)
2518       ret = this->sized_finalize<64>(off, pool, plocal_symcount);
2519 #else
2520       gold_unreachable();
2521 #endif
2522     }
2523   else
2524     gold_unreachable();
2525
2526   // Now that we have the final symbol table, we can reliably note
2527   // which symbols should get warnings.
2528   this->warnings_.note_warnings(this);
2529
2530   return ret;
2531 }
2532
2533 // SYM is going into the symbol table at *PINDEX.  Add the name to
2534 // POOL, update *PINDEX and *POFF.
2535
2536 template<int size>
2537 void
2538 Symbol_table::add_to_final_symtab(Symbol* sym, Stringpool* pool,
2539                                   unsigned int* pindex, off_t* poff)
2540 {
2541   sym->set_symtab_index(*pindex);
2542   if (sym->version() == NULL || !parameters->options().relocatable())
2543     pool->add(sym->name(), false, NULL);
2544   else
2545     pool->add(sym->versioned_name(), true, NULL);
2546   ++*pindex;
2547   *poff += elfcpp::Elf_sizes<size>::sym_size;
2548 }
2549
2550 // Set the final value for all the symbols.  This is called after
2551 // Layout::finalize, so all the output sections have their final
2552 // address.
2553
2554 template<int size>
2555 off_t
2556 Symbol_table::sized_finalize(off_t off, Stringpool* pool,
2557                              unsigned int* plocal_symcount)
2558 {
2559   off = align_address(off, size >> 3);
2560   this->offset_ = off;
2561
2562   unsigned int index = *plocal_symcount;
2563   const unsigned int orig_index = index;
2564
2565   // First do all the symbols which have been forced to be local, as
2566   // they must appear before all global symbols.
2567   for (Forced_locals::iterator p = this->forced_locals_.begin();
2568        p != this->forced_locals_.end();
2569        ++p)
2570     {
2571       Symbol* sym = *p;
2572       gold_assert(sym->is_forced_local());
2573       if (this->sized_finalize_symbol<size>(sym))
2574         {
2575           this->add_to_final_symtab<size>(sym, pool, &index, &off);
2576           ++*plocal_symcount;
2577         }
2578     }
2579
2580   // Now do all the remaining symbols.
2581   for (Symbol_table_type::iterator p = this->table_.begin();
2582        p != this->table_.end();
2583        ++p)
2584     {
2585       Symbol* sym = p->second;
2586       if (this->sized_finalize_symbol<size>(sym))
2587         this->add_to_final_symtab<size>(sym, pool, &index, &off);
2588     }
2589
2590   this->output_count_ = index - orig_index;
2591
2592   return off;
2593 }
2594
2595 // Compute the final value of SYM and store status in location PSTATUS.
2596 // During relaxation, this may be called multiple times for a symbol to
2597 // compute its would-be final value in each relaxation pass.
2598
2599 template<int size>
2600 typename Sized_symbol<size>::Value_type
2601 Symbol_table::compute_final_value(
2602     const Sized_symbol<size>* sym,
2603     Compute_final_value_status* pstatus) const
2604 {
2605   typedef typename Sized_symbol<size>::Value_type Value_type;
2606   Value_type value;
2607
2608   switch (sym->source())
2609     {
2610     case Symbol::FROM_OBJECT:
2611       {
2612         bool is_ordinary;
2613         unsigned int shndx = sym->shndx(&is_ordinary);
2614
2615         if (!is_ordinary
2616             && shndx != elfcpp::SHN_ABS
2617             && !Symbol::is_common_shndx(shndx))
2618           {
2619             *pstatus = CFVS_UNSUPPORTED_SYMBOL_SECTION;
2620             return 0;
2621           }
2622
2623         Object* symobj = sym->object();
2624         if (symobj->is_dynamic())
2625           {
2626             value = 0;
2627             shndx = elfcpp::SHN_UNDEF;
2628           }
2629         else if (symobj->pluginobj() != NULL)
2630           {
2631             value = 0;
2632             shndx = elfcpp::SHN_UNDEF;
2633           }
2634         else if (shndx == elfcpp::SHN_UNDEF)
2635           value = 0;
2636         else if (!is_ordinary
2637                  && (shndx == elfcpp::SHN_ABS
2638                      || Symbol::is_common_shndx(shndx)))
2639           value = sym->value();
2640         else
2641           {
2642             Relobj* relobj = static_cast<Relobj*>(symobj);
2643             Output_section* os = relobj->output_section(shndx);
2644
2645             if (this->is_section_folded(relobj, shndx))
2646               {
2647                 gold_assert(os == NULL);
2648                 // Get the os of the section it is folded onto.
2649                 Section_id folded = this->icf_->get_folded_section(relobj,
2650                                                                    shndx);
2651                 gold_assert(folded.first != NULL);
2652                 Relobj* folded_obj = reinterpret_cast<Relobj*>(folded.first);
2653                 unsigned folded_shndx = folded.second;
2654
2655                 os = folded_obj->output_section(folded_shndx);
2656                 gold_assert(os != NULL);
2657
2658                 // Replace (relobj, shndx) with canonical ICF input section.
2659                 shndx = folded_shndx;
2660                 relobj = folded_obj;
2661               }
2662
2663             uint64_t secoff64 = relobj->output_section_offset(shndx);
2664             if (os == NULL)
2665               {
2666                 bool static_or_reloc = (parameters->doing_static_link() ||
2667                                         parameters->options().relocatable());
2668                 gold_assert(static_or_reloc || sym->dynsym_index() == -1U);
2669
2670                 *pstatus = CFVS_NO_OUTPUT_SECTION;
2671                 return 0;
2672               }
2673
2674             if (secoff64 == -1ULL)
2675               {
2676                 // The section needs special handling (e.g., a merge section).
2677
2678                 value = os->output_address(relobj, shndx, sym->value());
2679               }
2680             else
2681               {
2682                 Value_type secoff =
2683                   convert_types<Value_type, uint64_t>(secoff64);
2684                 if (sym->type() == elfcpp::STT_TLS)
2685                   value = sym->value() + os->tls_offset() + secoff;
2686                 else
2687                   value = sym->value() + os->address() + secoff;
2688               }
2689           }
2690       }
2691       break;
2692
2693     case Symbol::IN_OUTPUT_DATA:
2694       {
2695         Output_data* od = sym->output_data();
2696         value = sym->value();
2697         if (sym->type() != elfcpp::STT_TLS)
2698           value += od->address();
2699         else
2700           {
2701             Output_section* os = od->output_section();
2702             gold_assert(os != NULL);
2703             value += os->tls_offset() + (od->address() - os->address());
2704           }
2705         if (sym->offset_is_from_end())
2706           value += od->data_size();
2707       }
2708       break;
2709
2710     case Symbol::IN_OUTPUT_SEGMENT:
2711       {
2712         Output_segment* os = sym->output_segment();
2713         value = sym->value();
2714         if (sym->type() != elfcpp::STT_TLS)
2715           value += os->vaddr();
2716         switch (sym->offset_base())
2717           {
2718           case Symbol::SEGMENT_START:
2719             break;
2720           case Symbol::SEGMENT_END:
2721             value += os->memsz();
2722             break;
2723           case Symbol::SEGMENT_BSS:
2724             value += os->filesz();
2725             break;
2726           default:
2727             gold_unreachable();
2728           }
2729       }
2730       break;
2731
2732     case Symbol::IS_CONSTANT:
2733       value = sym->value();
2734       break;
2735
2736     case Symbol::IS_UNDEFINED:
2737       value = 0;
2738       break;
2739
2740     default:
2741       gold_unreachable();
2742     }
2743
2744   *pstatus = CFVS_OK;
2745   return value;
2746 }
2747
2748 // Finalize the symbol SYM.  This returns true if the symbol should be
2749 // added to the symbol table, false otherwise.
2750
2751 template<int size>
2752 bool
2753 Symbol_table::sized_finalize_symbol(Symbol* unsized_sym)
2754 {
2755   typedef typename Sized_symbol<size>::Value_type Value_type;
2756
2757   Sized_symbol<size>* sym = static_cast<Sized_symbol<size>*>(unsized_sym);
2758
2759   // The default version of a symbol may appear twice in the symbol
2760   // table.  We only need to finalize it once.
2761   if (sym->has_symtab_index())
2762     return false;
2763
2764   if (!sym->in_reg())
2765     {
2766       gold_assert(!sym->has_symtab_index());
2767       sym->set_symtab_index(-1U);
2768       gold_assert(sym->dynsym_index() == -1U);
2769       return false;
2770     }
2771
2772   // If the symbol is only present on plugin files, the plugin decided we
2773   // don't need it.
2774   if (!sym->in_real_elf())
2775     {
2776       gold_assert(!sym->has_symtab_index());
2777       sym->set_symtab_index(-1U);
2778       return false;
2779     }
2780
2781   // Compute final symbol value.
2782   Compute_final_value_status status;
2783   Value_type value = this->compute_final_value(sym, &status);
2784
2785   switch (status)
2786     {
2787     case CFVS_OK:
2788       break;
2789     case CFVS_UNSUPPORTED_SYMBOL_SECTION:
2790       {
2791         bool is_ordinary;
2792         unsigned int shndx = sym->shndx(&is_ordinary);
2793         gold_error(_("%s: unsupported symbol section 0x%x"),
2794                    sym->demangled_name().c_str(), shndx);
2795       }
2796       break;
2797     case CFVS_NO_OUTPUT_SECTION:
2798       sym->set_symtab_index(-1U);
2799       return false;
2800     default:
2801       gold_unreachable();
2802     }
2803
2804   sym->set_value(value);
2805
2806   if (parameters->options().strip_all()
2807       || !parameters->options().should_retain_symbol(sym->name()))
2808     {
2809       sym->set_symtab_index(-1U);
2810       return false;
2811     }
2812
2813   return true;
2814 }
2815
2816 // Write out the global symbols.
2817
2818 void
2819 Symbol_table::write_globals(const Stringpool* sympool,
2820                             const Stringpool* dynpool,
2821                             Output_symtab_xindex* symtab_xindex,
2822                             Output_symtab_xindex* dynsym_xindex,
2823                             Output_file* of) const
2824 {
2825   switch (parameters->size_and_endianness())
2826     {
2827 #ifdef HAVE_TARGET_32_LITTLE
2828     case Parameters::TARGET_32_LITTLE:
2829       this->sized_write_globals<32, false>(sympool, dynpool, symtab_xindex,
2830                                            dynsym_xindex, of);
2831       break;
2832 #endif
2833 #ifdef HAVE_TARGET_32_BIG
2834     case Parameters::TARGET_32_BIG:
2835       this->sized_write_globals<32, true>(sympool, dynpool, symtab_xindex,
2836                                           dynsym_xindex, of);
2837       break;
2838 #endif
2839 #ifdef HAVE_TARGET_64_LITTLE
2840     case Parameters::TARGET_64_LITTLE:
2841       this->sized_write_globals<64, false>(sympool, dynpool, symtab_xindex,
2842                                            dynsym_xindex, of);
2843       break;
2844 #endif
2845 #ifdef HAVE_TARGET_64_BIG
2846     case Parameters::TARGET_64_BIG:
2847       this->sized_write_globals<64, true>(sympool, dynpool, symtab_xindex,
2848                                           dynsym_xindex, of);
2849       break;
2850 #endif
2851     default:
2852       gold_unreachable();
2853     }
2854 }
2855
2856 // Write out the global symbols.
2857
2858 template<int size, bool big_endian>
2859 void
2860 Symbol_table::sized_write_globals(const Stringpool* sympool,
2861                                   const Stringpool* dynpool,
2862                                   Output_symtab_xindex* symtab_xindex,
2863                                   Output_symtab_xindex* dynsym_xindex,
2864                                   Output_file* of) const
2865 {
2866   const Target& target = parameters->target();
2867
2868   const int sym_size = elfcpp::Elf_sizes<size>::sym_size;
2869
2870   const unsigned int output_count = this->output_count_;
2871   const section_size_type oview_size = output_count * sym_size;
2872   const unsigned int first_global_index = this->first_global_index_;
2873   unsigned char* psyms;
2874   if (this->offset_ == 0 || output_count == 0)
2875     psyms = NULL;
2876   else
2877     psyms = of->get_output_view(this->offset_, oview_size);
2878
2879   const unsigned int dynamic_count = this->dynamic_count_;
2880   const section_size_type dynamic_size = dynamic_count * sym_size;
2881   const unsigned int first_dynamic_global_index =
2882     this->first_dynamic_global_index_;
2883   unsigned char* dynamic_view;
2884   if (this->dynamic_offset_ == 0 || dynamic_count == 0)
2885     dynamic_view = NULL;
2886   else
2887     dynamic_view = of->get_output_view(this->dynamic_offset_, dynamic_size);
2888
2889   for (Symbol_table_type::const_iterator p = this->table_.begin();
2890        p != this->table_.end();
2891        ++p)
2892     {
2893       Sized_symbol<size>* sym = static_cast<Sized_symbol<size>*>(p->second);
2894
2895       // Possibly warn about unresolved symbols in shared libraries.
2896       this->warn_about_undefined_dynobj_symbol(sym);
2897
2898       unsigned int sym_index = sym->symtab_index();
2899       unsigned int dynsym_index;
2900       if (dynamic_view == NULL)
2901         dynsym_index = -1U;
2902       else
2903         dynsym_index = sym->dynsym_index();
2904
2905       if (sym_index == -1U && dynsym_index == -1U)
2906         {
2907           // This symbol is not included in the output file.
2908           continue;
2909         }
2910
2911       unsigned int shndx;
2912       typename elfcpp::Elf_types<size>::Elf_Addr sym_value = sym->value();
2913       typename elfcpp::Elf_types<size>::Elf_Addr dynsym_value = sym_value;
2914       elfcpp::STB binding = sym->binding();
2915
2916       // If --no-gnu-unique is set, change STB_GNU_UNIQUE to STB_GLOBAL.
2917       if (binding == elfcpp::STB_GNU_UNIQUE
2918           && !parameters->options().gnu_unique())
2919         binding = elfcpp::STB_GLOBAL;
2920
2921       switch (sym->source())
2922         {
2923         case Symbol::FROM_OBJECT:
2924           {
2925             bool is_ordinary;
2926             unsigned int in_shndx = sym->shndx(&is_ordinary);
2927
2928             if (!is_ordinary
2929                 && in_shndx != elfcpp::SHN_ABS
2930                 && !Symbol::is_common_shndx(in_shndx))
2931               {
2932                 gold_error(_("%s: unsupported symbol section 0x%x"),
2933                            sym->demangled_name().c_str(), in_shndx);
2934                 shndx = in_shndx;
2935               }
2936             else
2937               {
2938                 Object* symobj = sym->object();
2939                 if (symobj->is_dynamic())
2940                   {
2941                     if (sym->needs_dynsym_value())
2942                       dynsym_value = target.dynsym_value(sym);
2943                     shndx = elfcpp::SHN_UNDEF;
2944                     if (sym->is_undef_binding_weak())
2945                       binding = elfcpp::STB_WEAK;
2946                     else
2947                       binding = elfcpp::STB_GLOBAL;
2948                   }
2949                 else if (symobj->pluginobj() != NULL)
2950                   shndx = elfcpp::SHN_UNDEF;
2951                 else if (in_shndx == elfcpp::SHN_UNDEF
2952                          || (!is_ordinary
2953                              && (in_shndx == elfcpp::SHN_ABS
2954                                  || Symbol::is_common_shndx(in_shndx))))
2955                   shndx = in_shndx;
2956                 else
2957                   {
2958                     Relobj* relobj = static_cast<Relobj*>(symobj);
2959                     Output_section* os = relobj->output_section(in_shndx);
2960                     if (this->is_section_folded(relobj, in_shndx))
2961                       {
2962                         // This global symbol must be written out even though
2963                         // it is folded.
2964                         // Get the os of the section it is folded onto.
2965                         Section_id folded =
2966                              this->icf_->get_folded_section(relobj, in_shndx);
2967                         gold_assert(folded.first !=NULL);
2968                         Relobj* folded_obj =
2969                           reinterpret_cast<Relobj*>(folded.first);
2970                         os = folded_obj->output_section(folded.second);
2971                         gold_assert(os != NULL);
2972                       }
2973                     gold_assert(os != NULL);
2974                     shndx = os->out_shndx();
2975
2976                     if (shndx >= elfcpp::SHN_LORESERVE)
2977                       {
2978                         if (sym_index != -1U)
2979                           symtab_xindex->add(sym_index, shndx);
2980                         if (dynsym_index != -1U)
2981                           dynsym_xindex->add(dynsym_index, shndx);
2982                         shndx = elfcpp::SHN_XINDEX;
2983                       }
2984
2985                     // In object files symbol values are section
2986                     // relative.
2987                     if (parameters->options().relocatable())
2988                       sym_value -= os->address();
2989                   }
2990               }
2991           }
2992           break;
2993
2994         case Symbol::IN_OUTPUT_DATA:
2995           {
2996             Output_data* od = sym->output_data();
2997
2998             shndx = od->out_shndx();
2999             if (shndx >= elfcpp::SHN_LORESERVE)
3000               {
3001                 if (sym_index != -1U)
3002                   symtab_xindex->add(sym_index, shndx);
3003                 if (dynsym_index != -1U)
3004                   dynsym_xindex->add(dynsym_index, shndx);
3005                 shndx = elfcpp::SHN_XINDEX;
3006               }
3007
3008             // In object files symbol values are section
3009             // relative.
3010             if (parameters->options().relocatable())
3011               sym_value -= od->address();
3012           }
3013           break;
3014
3015         case Symbol::IN_OUTPUT_SEGMENT:
3016           shndx = elfcpp::SHN_ABS;
3017           break;
3018
3019         case Symbol::IS_CONSTANT:
3020           shndx = elfcpp::SHN_ABS;
3021           break;
3022
3023         case Symbol::IS_UNDEFINED:
3024           shndx = elfcpp::SHN_UNDEF;
3025           break;
3026
3027         default:
3028           gold_unreachable();
3029         }
3030
3031       if (sym_index != -1U)
3032         {
3033           sym_index -= first_global_index;
3034           gold_assert(sym_index < output_count);
3035           unsigned char* ps = psyms + (sym_index * sym_size);
3036           this->sized_write_symbol<size, big_endian>(sym, sym_value, shndx,
3037                                                      binding, sympool, ps);
3038         }
3039
3040       if (dynsym_index != -1U)
3041         {
3042           dynsym_index -= first_dynamic_global_index;
3043           gold_assert(dynsym_index < dynamic_count);
3044           unsigned char* pd = dynamic_view + (dynsym_index * sym_size);
3045           this->sized_write_symbol<size, big_endian>(sym, dynsym_value, shndx,
3046                                                      binding, dynpool, pd);
3047           // Allow a target to adjust dynamic symbol value.
3048           parameters->target().adjust_dyn_symbol(sym, pd);
3049         }
3050     }
3051
3052   of->write_output_view(this->offset_, oview_size, psyms);
3053   if (dynamic_view != NULL)
3054     of->write_output_view(this->dynamic_offset_, dynamic_size, dynamic_view);
3055 }
3056
3057 // Write out the symbol SYM, in section SHNDX, to P.  POOL is the
3058 // strtab holding the name.
3059
3060 template<int size, bool big_endian>
3061 void
3062 Symbol_table::sized_write_symbol(
3063     Sized_symbol<size>* sym,
3064     typename elfcpp::Elf_types<size>::Elf_Addr value,
3065     unsigned int shndx,
3066     elfcpp::STB binding,
3067     const Stringpool* pool,
3068     unsigned char* p) const
3069 {
3070   elfcpp::Sym_write<size, big_endian> osym(p);
3071   if (sym->version() == NULL || !parameters->options().relocatable())
3072     osym.put_st_name(pool->get_offset(sym->name()));
3073   else
3074     osym.put_st_name(pool->get_offset(sym->versioned_name()));
3075   osym.put_st_value(value);
3076   // Use a symbol size of zero for undefined symbols from shared libraries.
3077   if (shndx == elfcpp::SHN_UNDEF && sym->is_from_dynobj())
3078     osym.put_st_size(0);
3079   else
3080     osym.put_st_size(sym->symsize());
3081   elfcpp::STT type = sym->type();
3082   // Turn IFUNC symbols from shared libraries into normal FUNC symbols.
3083   if (type == elfcpp::STT_GNU_IFUNC
3084       && sym->is_from_dynobj())
3085     type = elfcpp::STT_FUNC;
3086   // A version script may have overridden the default binding.
3087   if (sym->is_forced_local())
3088     osym.put_st_info(elfcpp::elf_st_info(elfcpp::STB_LOCAL, type));
3089   else
3090     osym.put_st_info(elfcpp::elf_st_info(binding, type));
3091   osym.put_st_other(elfcpp::elf_st_other(sym->visibility(), sym->nonvis()));
3092   osym.put_st_shndx(shndx);
3093 }
3094
3095 // Check for unresolved symbols in shared libraries.  This is
3096 // controlled by the --allow-shlib-undefined option.
3097
3098 // We only warn about libraries for which we have seen all the
3099 // DT_NEEDED entries.  We don't try to track down DT_NEEDED entries
3100 // which were not seen in this link.  If we didn't see a DT_NEEDED
3101 // entry, we aren't going to be able to reliably report whether the
3102 // symbol is undefined.
3103
3104 // We also don't warn about libraries found in a system library
3105 // directory (e.g., /lib or /usr/lib); we assume that those libraries
3106 // are OK.  This heuristic avoids problems on GNU/Linux, in which -ldl
3107 // can have undefined references satisfied by ld-linux.so.
3108
3109 inline void
3110 Symbol_table::warn_about_undefined_dynobj_symbol(Symbol* sym) const
3111 {
3112   bool dummy;
3113   if (sym->source() == Symbol::FROM_OBJECT
3114       && sym->object()->is_dynamic()
3115       && sym->shndx(&dummy) == elfcpp::SHN_UNDEF
3116       && sym->binding() != elfcpp::STB_WEAK
3117       && !parameters->options().allow_shlib_undefined()
3118       && !parameters->target().is_defined_by_abi(sym)
3119       && !sym->object()->is_in_system_directory())
3120     {
3121       // A very ugly cast.
3122       Dynobj* dynobj = static_cast<Dynobj*>(sym->object());
3123       if (!dynobj->has_unknown_needed_entries())
3124         gold_undefined_symbol(sym);
3125     }
3126 }
3127
3128 // Write out a section symbol.  Return the update offset.
3129
3130 void
3131 Symbol_table::write_section_symbol(const Output_section* os,
3132                                    Output_symtab_xindex* symtab_xindex,
3133                                    Output_file* of,
3134                                    off_t offset) const
3135 {
3136   switch (parameters->size_and_endianness())
3137     {
3138 #ifdef HAVE_TARGET_32_LITTLE
3139     case Parameters::TARGET_32_LITTLE:
3140       this->sized_write_section_symbol<32, false>(os, symtab_xindex, of,
3141                                                   offset);
3142       break;
3143 #endif
3144 #ifdef HAVE_TARGET_32_BIG
3145     case Parameters::TARGET_32_BIG:
3146       this->sized_write_section_symbol<32, true>(os, symtab_xindex, of,
3147                                                  offset);
3148       break;
3149 #endif
3150 #ifdef HAVE_TARGET_64_LITTLE
3151     case Parameters::TARGET_64_LITTLE:
3152       this->sized_write_section_symbol<64, false>(os, symtab_xindex, of,
3153                                                   offset);
3154       break;
3155 #endif
3156 #ifdef HAVE_TARGET_64_BIG
3157     case Parameters::TARGET_64_BIG:
3158       this->sized_write_section_symbol<64, true>(os, symtab_xindex, of,
3159                                                  offset);
3160       break;
3161 #endif
3162     default:
3163       gold_unreachable();
3164     }
3165 }
3166
3167 // Write out a section symbol, specialized for size and endianness.
3168
3169 template<int size, bool big_endian>
3170 void
3171 Symbol_table::sized_write_section_symbol(const Output_section* os,
3172                                          Output_symtab_xindex* symtab_xindex,
3173                                          Output_file* of,
3174                                          off_t offset) const
3175 {
3176   const int sym_size = elfcpp::Elf_sizes<size>::sym_size;
3177
3178   unsigned char* pov = of->get_output_view(offset, sym_size);
3179
3180   elfcpp::Sym_write<size, big_endian> osym(pov);
3181   osym.put_st_name(0);
3182   if (parameters->options().relocatable())
3183     osym.put_st_value(0);
3184   else
3185     osym.put_st_value(os->address());
3186   osym.put_st_size(0);
3187   osym.put_st_info(elfcpp::elf_st_info(elfcpp::STB_LOCAL,
3188                                        elfcpp::STT_SECTION));
3189   osym.put_st_other(elfcpp::elf_st_other(elfcpp::STV_DEFAULT, 0));
3190
3191   unsigned int shndx = os->out_shndx();
3192   if (shndx >= elfcpp::SHN_LORESERVE)
3193     {
3194       symtab_xindex->add(os->symtab_index(), shndx);
3195       shndx = elfcpp::SHN_XINDEX;
3196     }
3197   osym.put_st_shndx(shndx);
3198
3199   of->write_output_view(offset, sym_size, pov);
3200 }
3201
3202 // Print statistical information to stderr.  This is used for --stats.
3203
3204 void
3205 Symbol_table::print_stats() const
3206 {
3207 #if defined(HAVE_TR1_UNORDERED_MAP) || defined(HAVE_EXT_HASH_MAP)
3208   fprintf(stderr, _("%s: symbol table entries: %zu; buckets: %zu\n"),
3209           program_name, this->table_.size(), this->table_.bucket_count());
3210 #else
3211   fprintf(stderr, _("%s: symbol table entries: %zu\n"),
3212           program_name, this->table_.size());
3213 #endif
3214   this->namepool_.print_stats("symbol table stringpool");
3215 }
3216
3217 // We check for ODR violations by looking for symbols with the same
3218 // name for which the debugging information reports that they were
3219 // defined in disjoint source locations.  When comparing the source
3220 // location, we consider instances with the same base filename to be
3221 // the same.  This is because different object files/shared libraries
3222 // can include the same header file using different paths, and
3223 // different optimization settings can make the line number appear to
3224 // be a couple lines off, and we don't want to report an ODR violation
3225 // in those cases.
3226
3227 // This struct is used to compare line information, as returned by
3228 // Dwarf_line_info::one_addr2line.  It implements a < comparison
3229 // operator used with std::sort.
3230
3231 struct Odr_violation_compare
3232 {
3233   bool
3234   operator()(const std::string& s1, const std::string& s2) const
3235   {
3236     // Inputs should be of the form "dirname/filename:linenum" where
3237     // "dirname/" is optional.  We want to compare just the filename:linenum.
3238
3239     // Find the last '/' in each string.
3240     std::string::size_type s1begin = s1.rfind('/');
3241     std::string::size_type s2begin = s2.rfind('/');
3242     // If there was no '/' in a string, start at the beginning.
3243     if (s1begin == std::string::npos)
3244       s1begin = 0;
3245     if (s2begin == std::string::npos)
3246       s2begin = 0;
3247     return s1.compare(s1begin, std::string::npos,
3248                       s2, s2begin, std::string::npos) < 0;
3249   }
3250 };
3251
3252 // Returns all of the lines attached to LOC, not just the one the
3253 // instruction actually came from.
3254 std::vector<std::string>
3255 Symbol_table::linenos_from_loc(const Task* task,
3256                                const Symbol_location& loc)
3257 {
3258   // We need to lock the object in order to read it.  This
3259   // means that we have to run in a singleton Task.  If we
3260   // want to run this in a general Task for better
3261   // performance, we will need one Task for object, plus
3262   // appropriate locking to ensure that we don't conflict with
3263   // other uses of the object.  Also note, one_addr2line is not
3264   // currently thread-safe.
3265   Task_lock_obj<Object> tl(task, loc.object);
3266
3267   std::vector<std::string> result;
3268   Symbol_location code_loc = loc;
3269   parameters->target().function_location(&code_loc);
3270   // 16 is the size of the object-cache that one_addr2line should use.
3271   std::string canonical_result = Dwarf_line_info::one_addr2line(
3272       code_loc.object, code_loc.shndx, code_loc.offset, 16, &result);
3273   if (!canonical_result.empty())
3274     result.push_back(canonical_result);
3275   return result;
3276 }
3277
3278 // OutputIterator that records if it was ever assigned to.  This
3279 // allows it to be used with std::set_intersection() to check for
3280 // intersection rather than computing the intersection.
3281 struct Check_intersection
3282 {
3283   Check_intersection()
3284     : value_(false)
3285   {}
3286
3287   bool had_intersection() const
3288   { return this->value_; }
3289
3290   Check_intersection& operator++()
3291   { return *this; }
3292
3293   Check_intersection& operator*()
3294   { return *this; }
3295
3296   template<typename T>
3297   Check_intersection& operator=(const T&)
3298   {
3299     this->value_ = true;
3300     return *this;
3301   }
3302
3303  private:
3304   bool value_;
3305 };
3306
3307 // Check candidate_odr_violations_ to find symbols with the same name
3308 // but apparently different definitions (different source-file/line-no
3309 // for each line assigned to the first instruction).
3310
3311 void
3312 Symbol_table::detect_odr_violations(const Task* task,
3313                                     const char* output_file_name) const
3314 {
3315   for (Odr_map::const_iterator it = candidate_odr_violations_.begin();
3316        it != candidate_odr_violations_.end();
3317        ++it)
3318     {
3319       const char* const symbol_name = it->first;
3320
3321       std::string first_object_name;
3322       std::vector<std::string> first_object_linenos;
3323
3324       Unordered_set<Symbol_location, Symbol_location_hash>::const_iterator
3325           locs = it->second.begin();
3326       const Unordered_set<Symbol_location, Symbol_location_hash>::const_iterator
3327           locs_end = it->second.end();
3328       for (; locs != locs_end && first_object_linenos.empty(); ++locs)
3329         {
3330           // Save the line numbers from the first definition to
3331           // compare to the other definitions.  Ideally, we'd compare
3332           // every definition to every other, but we don't want to
3333           // take O(N^2) time to do this.  This shortcut may cause
3334           // false negatives that appear or disappear depending on the
3335           // link order, but it won't cause false positives.
3336           first_object_name = locs->object->name();
3337           first_object_linenos = this->linenos_from_loc(task, *locs);
3338         }
3339
3340       // Sort by Odr_violation_compare to make std::set_intersection work.
3341       std::sort(first_object_linenos.begin(), first_object_linenos.end(),
3342                 Odr_violation_compare());
3343
3344       for (; locs != locs_end; ++locs)
3345         {
3346           std::vector<std::string> linenos =
3347               this->linenos_from_loc(task, *locs);
3348           // linenos will be empty if we couldn't parse the debug info.
3349           if (linenos.empty())
3350             continue;
3351           // Sort by Odr_violation_compare to make std::set_intersection work.
3352           std::sort(linenos.begin(), linenos.end(), Odr_violation_compare());
3353
3354           Check_intersection intersection_result =
3355               std::set_intersection(first_object_linenos.begin(),
3356                                     first_object_linenos.end(),
3357                                     linenos.begin(),
3358                                     linenos.end(),
3359                                     Check_intersection(),
3360                                     Odr_violation_compare());
3361           if (!intersection_result.had_intersection())
3362             {
3363               gold_warning(_("while linking %s: symbol '%s' defined in "
3364                              "multiple places (possible ODR violation):"),
3365                            output_file_name, demangle(symbol_name).c_str());
3366               // This only prints one location from each definition,
3367               // which may not be the location we expect to intersect
3368               // with another definition.  We could print the whole
3369               // set of locations, but that seems too verbose.
3370               gold_assert(!first_object_linenos.empty());
3371               gold_assert(!linenos.empty());
3372               fprintf(stderr, _("  %s from %s\n"),
3373                       first_object_linenos[0].c_str(),
3374                       first_object_name.c_str());
3375               fprintf(stderr, _("  %s from %s\n"),
3376                       linenos[0].c_str(),
3377                       locs->object->name().c_str());
3378               // Only print one broken pair, to avoid needing to
3379               // compare against a list of the disjoint definition
3380               // locations we've found so far.  (If we kept comparing
3381               // against just the first one, we'd get a lot of
3382               // redundant complaints about the second definition
3383               // location.)
3384               break;
3385             }
3386         }
3387     }
3388   // We only call one_addr2line() in this function, so we can clear its cache.
3389   Dwarf_line_info::clear_addr2line_cache();
3390 }
3391
3392 // Warnings functions.
3393
3394 // Add a new warning.
3395
3396 void
3397 Warnings::add_warning(Symbol_table* symtab, const char* name, Object* obj,
3398                       const std::string& warning)
3399 {
3400   name = symtab->canonicalize_name(name);
3401   this->warnings_[name].set(obj, warning);
3402 }
3403
3404 // Look through the warnings and mark the symbols for which we should
3405 // warn.  This is called during Layout::finalize when we know the
3406 // sources for all the symbols.
3407
3408 void
3409 Warnings::note_warnings(Symbol_table* symtab)
3410 {
3411   for (Warning_table::iterator p = this->warnings_.begin();
3412        p != this->warnings_.end();
3413        ++p)
3414     {
3415       Symbol* sym = symtab->lookup(p->first, NULL);
3416       if (sym != NULL
3417           && sym->source() == Symbol::FROM_OBJECT
3418           && sym->object() == p->second.object)
3419         sym->set_has_warning();
3420     }
3421 }
3422
3423 // Issue a warning.  This is called when we see a relocation against a
3424 // symbol for which has a warning.
3425
3426 template<int size, bool big_endian>
3427 void
3428 Warnings::issue_warning(const Symbol* sym,
3429                         const Relocate_info<size, big_endian>* relinfo,
3430                         size_t relnum, off_t reloffset) const
3431 {
3432   gold_assert(sym->has_warning());
3433
3434   // We don't want to issue a warning for a relocation against the
3435   // symbol in the same object file in which the symbol is defined.
3436   if (sym->object() == relinfo->object)
3437     return;
3438
3439   Warning_table::const_iterator p = this->warnings_.find(sym->name());
3440   gold_assert(p != this->warnings_.end());
3441   gold_warning_at_location(relinfo, relnum, reloffset,
3442                            "%s", p->second.text.c_str());
3443 }
3444
3445 // Instantiate the templates we need.  We could use the configure
3446 // script to restrict this to only the ones needed for implemented
3447 // targets.
3448
3449 #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG)
3450 template
3451 void
3452 Sized_symbol<32>::allocate_common(Output_data*, Value_type);
3453 #endif
3454
3455 #if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG)
3456 template
3457 void
3458 Sized_symbol<64>::allocate_common(Output_data*, Value_type);
3459 #endif
3460
3461 #ifdef HAVE_TARGET_32_LITTLE
3462 template
3463 void
3464 Symbol_table::add_from_relobj<32, false>(
3465     Sized_relobj_file<32, false>* relobj,
3466     const unsigned char* syms,
3467     size_t count,
3468     size_t symndx_offset,
3469     const char* sym_names,
3470     size_t sym_name_size,
3471     Sized_relobj_file<32, false>::Symbols* sympointers,
3472     size_t* defined);
3473 #endif
3474
3475 #ifdef HAVE_TARGET_32_BIG
3476 template
3477 void
3478 Symbol_table::add_from_relobj<32, true>(
3479     Sized_relobj_file<32, true>* relobj,
3480     const unsigned char* syms,
3481     size_t count,
3482     size_t symndx_offset,
3483     const char* sym_names,
3484     size_t sym_name_size,
3485     Sized_relobj_file<32, true>::Symbols* sympointers,
3486     size_t* defined);
3487 #endif
3488
3489 #ifdef HAVE_TARGET_64_LITTLE
3490 template
3491 void
3492 Symbol_table::add_from_relobj<64, false>(
3493     Sized_relobj_file<64, false>* relobj,
3494     const unsigned char* syms,
3495     size_t count,
3496     size_t symndx_offset,
3497     const char* sym_names,
3498     size_t sym_name_size,
3499     Sized_relobj_file<64, false>::Symbols* sympointers,
3500     size_t* defined);
3501 #endif
3502
3503 #ifdef HAVE_TARGET_64_BIG
3504 template
3505 void
3506 Symbol_table::add_from_relobj<64, true>(
3507     Sized_relobj_file<64, true>* relobj,
3508     const unsigned char* syms,
3509     size_t count,
3510     size_t symndx_offset,
3511     const char* sym_names,
3512     size_t sym_name_size,
3513     Sized_relobj_file<64, true>::Symbols* sympointers,
3514     size_t* defined);
3515 #endif
3516
3517 #ifdef HAVE_TARGET_32_LITTLE
3518 template
3519 Symbol*
3520 Symbol_table::add_from_pluginobj<32, false>(
3521     Sized_pluginobj<32, false>* obj,
3522     const char* name,
3523     const char* ver,
3524     elfcpp::Sym<32, false>* sym);
3525 #endif
3526
3527 #ifdef HAVE_TARGET_32_BIG
3528 template
3529 Symbol*
3530 Symbol_table::add_from_pluginobj<32, true>(
3531     Sized_pluginobj<32, true>* obj,
3532     const char* name,
3533     const char* ver,
3534     elfcpp::Sym<32, true>* sym);
3535 #endif
3536
3537 #ifdef HAVE_TARGET_64_LITTLE
3538 template
3539 Symbol*
3540 Symbol_table::add_from_pluginobj<64, false>(
3541     Sized_pluginobj<64, false>* obj,
3542     const char* name,
3543     const char* ver,
3544     elfcpp::Sym<64, false>* sym);
3545 #endif
3546
3547 #ifdef HAVE_TARGET_64_BIG
3548 template
3549 Symbol*
3550 Symbol_table::add_from_pluginobj<64, true>(
3551     Sized_pluginobj<64, true>* obj,
3552     const char* name,
3553     const char* ver,
3554     elfcpp::Sym<64, true>* sym);
3555 #endif
3556
3557 #ifdef HAVE_TARGET_32_LITTLE
3558 template
3559 void
3560 Symbol_table::add_from_dynobj<32, false>(
3561     Sized_dynobj<32, false>* dynobj,
3562     const unsigned char* syms,
3563     size_t count,
3564     const char* sym_names,
3565     size_t sym_name_size,
3566     const unsigned char* versym,
3567     size_t versym_size,
3568     const std::vector<const char*>* version_map,
3569     Sized_relobj_file<32, false>::Symbols* sympointers,
3570     size_t* defined);
3571 #endif
3572
3573 #ifdef HAVE_TARGET_32_BIG
3574 template
3575 void
3576 Symbol_table::add_from_dynobj<32, true>(
3577     Sized_dynobj<32, true>* dynobj,
3578     const unsigned char* syms,
3579     size_t count,
3580     const char* sym_names,
3581     size_t sym_name_size,
3582     const unsigned char* versym,
3583     size_t versym_size,
3584     const std::vector<const char*>* version_map,
3585     Sized_relobj_file<32, true>::Symbols* sympointers,
3586     size_t* defined);
3587 #endif
3588
3589 #ifdef HAVE_TARGET_64_LITTLE
3590 template
3591 void
3592 Symbol_table::add_from_dynobj<64, false>(
3593     Sized_dynobj<64, false>* dynobj,
3594     const unsigned char* syms,
3595     size_t count,
3596     const char* sym_names,
3597     size_t sym_name_size,
3598     const unsigned char* versym,
3599     size_t versym_size,
3600     const std::vector<const char*>* version_map,
3601     Sized_relobj_file<64, false>::Symbols* sympointers,
3602     size_t* defined);
3603 #endif
3604
3605 #ifdef HAVE_TARGET_64_BIG
3606 template
3607 void
3608 Symbol_table::add_from_dynobj<64, true>(
3609     Sized_dynobj<64, true>* dynobj,
3610     const unsigned char* syms,
3611     size_t count,
3612     const char* sym_names,
3613     size_t sym_name_size,
3614     const unsigned char* versym,
3615     size_t versym_size,
3616     const std::vector<const char*>* version_map,
3617     Sized_relobj_file<64, true>::Symbols* sympointers,
3618     size_t* defined);
3619 #endif
3620
3621 #ifdef HAVE_TARGET_32_LITTLE
3622 template
3623 Sized_symbol<32>*
3624 Symbol_table::add_from_incrobj(
3625     Object* obj,
3626     const char* name,
3627     const char* ver,
3628     elfcpp::Sym<32, false>* sym);
3629 #endif
3630
3631 #ifdef HAVE_TARGET_32_BIG
3632 template
3633 Sized_symbol<32>*
3634 Symbol_table::add_from_incrobj(
3635     Object* obj,
3636     const char* name,
3637     const char* ver,
3638     elfcpp::Sym<32, true>* sym);
3639 #endif
3640
3641 #ifdef HAVE_TARGET_64_LITTLE
3642 template
3643 Sized_symbol<64>*
3644 Symbol_table::add_from_incrobj(
3645     Object* obj,
3646     const char* name,
3647     const char* ver,
3648     elfcpp::Sym<64, false>* sym);
3649 #endif
3650
3651 #ifdef HAVE_TARGET_64_BIG
3652 template
3653 Sized_symbol<64>*
3654 Symbol_table::add_from_incrobj(
3655     Object* obj,
3656     const char* name,
3657     const char* ver,
3658     elfcpp::Sym<64, true>* sym);
3659 #endif
3660
3661 #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG)
3662 template
3663 void
3664 Symbol_table::define_with_copy_reloc<32>(
3665     Sized_symbol<32>* sym,
3666     Output_data* posd,
3667     elfcpp::Elf_types<32>::Elf_Addr value);
3668 #endif
3669
3670 #if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG)
3671 template
3672 void
3673 Symbol_table::define_with_copy_reloc<64>(
3674     Sized_symbol<64>* sym,
3675     Output_data* posd,
3676     elfcpp::Elf_types<64>::Elf_Addr value);
3677 #endif
3678
3679 #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG)
3680 template
3681 void
3682 Sized_symbol<32>::init_output_data(const char* name, const char* version,
3683                                    Output_data* od, Value_type value,
3684                                    Size_type symsize, elfcpp::STT type,
3685                                    elfcpp::STB binding,
3686                                    elfcpp::STV visibility,
3687                                    unsigned char nonvis,
3688                                    bool offset_is_from_end,
3689                                    bool is_predefined);
3690 #endif
3691
3692 #if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG)
3693 template
3694 void
3695 Sized_symbol<64>::init_output_data(const char* name, const char* version,
3696                                    Output_data* od, Value_type value,
3697                                    Size_type symsize, elfcpp::STT type,
3698                                    elfcpp::STB binding,
3699                                    elfcpp::STV visibility,
3700                                    unsigned char nonvis,
3701                                    bool offset_is_from_end,
3702                                    bool is_predefined);
3703 #endif
3704
3705 #ifdef HAVE_TARGET_32_LITTLE
3706 template
3707 void
3708 Warnings::issue_warning<32, false>(const Symbol* sym,
3709                                    const Relocate_info<32, false>* relinfo,
3710                                    size_t relnum, off_t reloffset) const;
3711 #endif
3712
3713 #ifdef HAVE_TARGET_32_BIG
3714 template
3715 void
3716 Warnings::issue_warning<32, true>(const Symbol* sym,
3717                                   const Relocate_info<32, true>* relinfo,
3718                                   size_t relnum, off_t reloffset) const;
3719 #endif
3720
3721 #ifdef HAVE_TARGET_64_LITTLE
3722 template
3723 void
3724 Warnings::issue_warning<64, false>(const Symbol* sym,
3725                                    const Relocate_info<64, false>* relinfo,
3726                                    size_t relnum, off_t reloffset) const;
3727 #endif
3728
3729 #ifdef HAVE_TARGET_64_BIG
3730 template
3731 void
3732 Warnings::issue_warning<64, true>(const Symbol* sym,
3733                                   const Relocate_info<64, true>* relinfo,
3734                                   size_t relnum, off_t reloffset) const;
3735 #endif
3736
3737 } // End namespace gold.