gold/symtab.cc

   1 // symtab.cc -- the gold symbol table
   2
   3 // Copyright 2006, 2007 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 <stdint.h>
  26 #include <string>
  27 #include <utility>
  28
  29 #include "object.h"
  30 #include "dynobj.h"
  31 #include "output.h"
  32 #include "target.h"
  33 #include "workqueue.h"
  34 #include "symtab.h"
  35
  36 namespace gold
  37 {
  38
  39 // Class Symbol.
  40
  41 // Initialize fields in Symbol.  This initializes everything except u_
  42 // and source_.
  43
  44 void
  45 Symbol::init_fields(const char* name, const char* version,
  46                     elfcpp::STT type, elfcpp::STB binding,
  47                     elfcpp::STV visibility, unsigned char nonvis)
  48 {
  49   this->name_ = name;
  50   this->version_ = version;
  51   this->symtab_index_ = 0;
  52   this->dynsym_index_ = 0;
  53   this->got_offset_ = 0;
  54   this->plt_offset_ = 0;
  55   this->type_ = type;
  56   this->binding_ = binding;
  57   this->visibility_ = visibility;
  58   this->nonvis_ = nonvis;
  59   this->is_target_special_ = false;
  60   this->is_def_ = false;
  61   this->is_forwarder_ = false;
  62   this->has_alias_ = false;
  63   this->needs_dynsym_entry_ = false;
  64   this->in_reg_ = false;
  65   this->in_dyn_ = false;
  66   this->has_got_offset_ = false;
  67   this->has_plt_offset_ = false;
  68   this->has_warning_ = false;
  69   this->is_copied_from_dynobj_ = false;
  70   this->needs_value_in_got_ = false;
  71 }
  72
  73 // Initialize the fields in the base class Symbol for SYM in OBJECT.
  74
  75 template<int size, bool big_endian>
  76 void
  77 Symbol::init_base(const char* name, const char* version, Object* object,
  78                   const elfcpp::Sym<size, big_endian>& sym)
  79 {
  80   this->init_fields(name, version, sym.get_st_type(), sym.get_st_bind(),
  81                     sym.get_st_visibility(), sym.get_st_nonvis());
  82   this->u_.from_object.object = object;
  83   // FIXME: Handle SHN_XINDEX.
  84   this->u_.from_object.shndx = sym.get_st_shndx();
  85   this->source_ = FROM_OBJECT;
  86   this->in_reg_ = !object->is_dynamic();
  87   this->in_dyn_ = object->is_dynamic();
  88 }
  89
  90 // Initialize the fields in the base class Symbol for a symbol defined
  91 // in an Output_data.
  92
  93 void
  94 Symbol::init_base(const char* name, Output_data* od, elfcpp::STT type,
  95                   elfcpp::STB binding, elfcpp::STV visibility,
  96                   unsigned char nonvis, bool offset_is_from_end)
  97 {
  98   this->init_fields(name, NULL, type, binding, visibility, nonvis);
  99   this->u_.in_output_data.output_data = od;
 100   this->u_.in_output_data.offset_is_from_end = offset_is_from_end;
 101   this->source_ = IN_OUTPUT_DATA;
 102   this->in_reg_ = true;
 103 }
 104
 105 // Initialize the fields in the base class Symbol for a symbol defined
 106 // in an Output_segment.
 107
 108 void
 109 Symbol::init_base(const char* name, Output_segment* os, elfcpp::STT type,
 110                   elfcpp::STB binding, elfcpp::STV visibility,
 111                   unsigned char nonvis, Segment_offset_base offset_base)
 112 {
 113   this->init_fields(name, NULL, type, binding, visibility, nonvis);
 114   this->u_.in_output_segment.output_segment = os;
 115   this->u_.in_output_segment.offset_base = offset_base;
 116   this->source_ = IN_OUTPUT_SEGMENT;
 117   this->in_reg_ = true;
 118 }
 119
 120 // Initialize the fields in the base class Symbol for a symbol defined
 121 // as a constant.
 122
 123 void
 124 Symbol::init_base(const char* name, elfcpp::STT type,
 125                   elfcpp::STB binding, elfcpp::STV visibility,
 126                   unsigned char nonvis)
 127 {
 128   this->init_fields(name, NULL, type, binding, visibility, nonvis);
 129   this->source_ = CONSTANT;
 130   this->in_reg_ = true;
 131 }
 132
 133 // Initialize the fields in Sized_symbol for SYM in OBJECT.
 134
 135 template<int size>
 136 template<bool big_endian>
 137 void
 138 Sized_symbol<size>::init(const char* name, const char* version, Object* object,
 139                          const elfcpp::Sym<size, big_endian>& sym)
 140 {
 141   this->init_base(name, version, object, sym);
 142   this->value_ = sym.get_st_value();
 143   this->symsize_ = sym.get_st_size();
 144 }
 145
 146 // Initialize the fields in Sized_symbol for a symbol defined in an
 147 // Output_data.
 148
 149 template<int size>
 150 void
 151 Sized_symbol<size>::init(const char* name, Output_data* od,
 152                          Value_type value, Size_type symsize,
 153                          elfcpp::STT type, elfcpp::STB binding,
 154                          elfcpp::STV visibility, unsigned char nonvis,
 155                          bool offset_is_from_end)
 156 {
 157   this->init_base(name, od, type, binding, visibility, nonvis,
 158                   offset_is_from_end);
 159   this->value_ = value;
 160   this->symsize_ = symsize;
 161 }
 162
 163 // Initialize the fields in Sized_symbol for a symbol defined in an
 164 // Output_segment.
 165
 166 template<int size>
 167 void
 168 Sized_symbol<size>::init(const char* name, Output_segment* os,
 169                          Value_type value, Size_type symsize,
 170                          elfcpp::STT type, elfcpp::STB binding,
 171                          elfcpp::STV visibility, unsigned char nonvis,
 172                          Segment_offset_base offset_base)
 173 {
 174   this->init_base(name, os, type, binding, visibility, nonvis, offset_base);
 175   this->value_ = value;
 176   this->symsize_ = symsize;
 177 }
 178
 179 // Initialize the fields in Sized_symbol for a symbol defined as a
 180 // constant.
 181
 182 template<int size>
 183 void
 184 Sized_symbol<size>::init(const char* name, Value_type value, Size_type symsize,
 185                          elfcpp::STT type, elfcpp::STB binding,
 186                          elfcpp::STV visibility, unsigned char nonvis)
 187 {
 188   this->init_base(name, type, binding, visibility, nonvis);
 189   this->value_ = value;
 190   this->symsize_ = symsize;
 191 }
 192
 193 // Return true if this symbol should be added to the dynamic symbol
 194 // table.
 195
 196 inline bool
 197 Symbol::should_add_dynsym_entry() const
 198 {
 199   // If the symbol is used by a dynamic relocation, we need to add it.
 200   if (this->needs_dynsym_entry())
 201     return true;
 202
 203   // If exporting all symbols or building a shared library,
 204   // and the symbol is defined in a regular object and is
 205   // externally visible, we need to add it.
 206   if ((parameters->export_dynamic() || parameters->output_is_shared())
 207       && !this->is_from_dynobj()
 208       && this->is_externally_visible())
 209     return true;
 210
 211   return false;
 212 }
 213
 214 // Return true if the final value of this symbol is known at link
 215 // time.
 216
 217 bool
 218 Symbol::final_value_is_known() const
 219 {
 220   // If we are not generating an executable, then no final values are
 221   // known, since they will change at runtime.
 222   if (!parameters->output_is_executable())
 223     return false;
 224
 225   // If the symbol is not from an object file, then it is defined, and
 226   // known.
 227   if (this->source_ != FROM_OBJECT)
 228     return true;
 229
 230   // If the symbol is from a dynamic object, then the final value is
 231   // not known.
 232   if (this->object()->is_dynamic())
 233     return false;
 234
 235   // If the symbol is not undefined (it is defined or common), then
 236   // the final value is known.
 237   if (!this->is_undefined())
 238     return true;
 239
 240   // If the symbol is undefined, then whether the final value is known
 241   // depends on whether we are doing a static link.  If we are doing a
 242   // dynamic link, then the final value could be filled in at runtime.
 243   // This could reasonably be the case for a weak undefined symbol.
 244   return parameters->doing_static_link();
 245 }
 246
 247 // Class Symbol_table.
 248
 249 Symbol_table::Symbol_table()
 250   : saw_undefined_(0), offset_(0), table_(), namepool_(),
 251     forwarders_(), commons_(), warnings_()
 252 {
 253 }
 254
 255 Symbol_table::~Symbol_table()
 256 {
 257 }
 258
 259 // The hash function.  The key is always canonicalized, so we use a
 260 // simple combination of the pointers.
 261
 262 size_t
 263 Symbol_table::Symbol_table_hash::operator()(const Symbol_table_key& key) const
 264 {
 265   return key.first ^ key.second;
 266 }
 267
 268 // The symbol table key equality function.  This is only called with
 269 // canonicalized name and version strings, so we can use pointer
 270 // comparison.
 271
 272 bool
 273 Symbol_table::Symbol_table_eq::operator()(const Symbol_table_key& k1,
 274                                           const Symbol_table_key& k2) const
 275 {
 276   return k1.first == k2.first && k1.second == k2.second;
 277 }
 278
 279 // Make TO a symbol which forwards to FROM.
 280
 281 void
 282 Symbol_table::make_forwarder(Symbol* from, Symbol* to)
 283 {
 284   gold_assert(from != to);
 285   gold_assert(!from->is_forwarder() && !to->is_forwarder());
 286   this->forwarders_[from] = to;
 287   from->set_forwarder();
 288 }
 289
 290 // Resolve the forwards from FROM, returning the real symbol.
 291
 292 Symbol*
 293 Symbol_table::resolve_forwards(const Symbol* from) const
 294 {
 295   gold_assert(from->is_forwarder());
 296   Unordered_map<const Symbol*, Symbol*>::const_iterator p =
 297     this->forwarders_.find(from);
 298   gold_assert(p != this->forwarders_.end());
 299   return p->second;
 300 }
 301
 302 // Look up a symbol by name.
 303
 304 Symbol*
 305 Symbol_table::lookup(const char* name, const char* version) const
 306 {
 307   Stringpool::Key name_key;
 308   name = this->namepool_.find(name, &name_key);
 309   if (name == NULL)
 310     return NULL;
 311
 312   Stringpool::Key version_key = 0;
 313   if (version != NULL)
 314     {
 315       version = this->namepool_.find(version, &version_key);
 316       if (version == NULL)
 317         return NULL;
 318     }
 319
 320   Symbol_table_key key(name_key, version_key);
 321   Symbol_table::Symbol_table_type::const_iterator p = this->table_.find(key);
 322   if (p == this->table_.end())
 323     return NULL;
 324   return p->second;
 325 }
 326
 327 // Resolve a Symbol with another Symbol.  This is only used in the
 328 // unusual case where there are references to both an unversioned
 329 // symbol and a symbol with a version, and we then discover that that
 330 // version is the default version.  Because this is unusual, we do
 331 // this the slow way, by converting back to an ELF symbol.
 332
 333 template<int size, bool big_endian>
 334 void
 335 Symbol_table::resolve(Sized_symbol<size>* to, const Sized_symbol<size>* from,
 336                       const char* version ACCEPT_SIZE_ENDIAN)
 337 {
 338   unsigned char buf[elfcpp::Elf_sizes<size>::sym_size];
 339   elfcpp::Sym_write<size, big_endian> esym(buf);
 340   // We don't bother to set the st_name field.
 341   esym.put_st_value(from->value());
 342   esym.put_st_size(from->symsize());
 343   esym.put_st_info(from->binding(), from->type());
 344   esym.put_st_other(from->visibility(), from->nonvis());
 345   esym.put_st_shndx(from->shndx());
 346   this->resolve(to, esym.sym(), from->object(), version);
 347   if (from->in_reg())
 348     to->set_in_reg();
 349   if (from->in_dyn())
 350     to->set_in_dyn();
 351 }
 352
 353 // Add one symbol from OBJECT to the symbol table.  NAME is symbol
 354 // name and VERSION is the version; both are canonicalized.  DEF is
 355 // whether this is the default version.
 356
 357 // If DEF is true, then this is the definition of a default version of
 358 // a symbol.  That means that any lookup of NAME/NULL and any lookup
 359 // of NAME/VERSION should always return the same symbol.  This is
 360 // obvious for references, but in particular we want to do this for
 361 // definitions: overriding NAME/NULL should also override
 362 // NAME/VERSION.  If we don't do that, it would be very hard to
 363 // override functions in a shared library which uses versioning.
 364
 365 // We implement this by simply making both entries in the hash table
 366 // point to the same Symbol structure.  That is easy enough if this is
 367 // the first time we see NAME/NULL or NAME/VERSION, but it is possible
 368 // that we have seen both already, in which case they will both have
 369 // independent entries in the symbol table.  We can't simply change
 370 // the symbol table entry, because we have pointers to the entries
 371 // attached to the object files.  So we mark the entry attached to the
 372 // object file as a forwarder, and record it in the forwarders_ map.
 373 // Note that entries in the hash table will never be marked as
 374 // forwarders.
 375
 376 template<int size, bool big_endian>
 377 Sized_symbol<size>*
 378 Symbol_table::add_from_object(Object* object,
 379                               const char *name,
 380                               Stringpool::Key name_key,
 381                               const char *version,
 382                               Stringpool::Key version_key,
 383                               bool def,
 384                               const elfcpp::Sym<size, big_endian>& sym)
 385 {
 386   Symbol* const snull = NULL;
 387   std::pair<typename Symbol_table_type::iterator, bool> ins =
 388     this->table_.insert(std::make_pair(std::make_pair(name_key, version_key),
 389                                        snull));
 390
 391   std::pair<typename Symbol_table_type::iterator, bool> insdef =
 392     std::make_pair(this->table_.end(), false);
 393   if (def)
 394     {
 395       const Stringpool::Key vnull_key = 0;
 396       insdef = this->table_.insert(std::make_pair(std::make_pair(name_key,
 397                                                                  vnull_key),
 398                                                   snull));
 399     }
 400
 401   // ins.first: an iterator, which is a pointer to a pair.
 402   // ins.first->first: the key (a pair of name and version).
 403   // ins.first->second: the value (Symbol*).
 404   // ins.second: true if new entry was inserted, false if not.
 405
 406   Sized_symbol<size>* ret;
 407   bool was_undefined;
 408   bool was_common;
 409   if (!ins.second)
 410     {
 411       // We already have an entry for NAME/VERSION.
 412       ret = this->get_sized_symbol SELECT_SIZE_NAME(size) (ins.first->second
 413                                                            SELECT_SIZE(size));
 414       gold_assert(ret != NULL);
 415
 416       was_undefined = ret->is_undefined();
 417       was_common = ret->is_common();
 418
 419       this->resolve(ret, sym, object, version);
 420
 421       if (def)
 422         {
 423           if (insdef.second)
 424             {
 425               // This is the first time we have seen NAME/NULL.  Make
 426               // NAME/NULL point to NAME/VERSION.
 427               insdef.first->second = ret;
 428             }
 429           else if (insdef.first->second != ret)
 430             {
 431               // This is the unfortunate case where we already have
 432               // entries for both NAME/VERSION and NAME/NULL.
 433               const Sized_symbol<size>* sym2;
 434               sym2 = this->get_sized_symbol SELECT_SIZE_NAME(size) (
 435                 insdef.first->second
 436                 SELECT_SIZE(size));
 437               Symbol_table::resolve SELECT_SIZE_ENDIAN_NAME(size, big_endian) (
 438                 ret, sym2, version SELECT_SIZE_ENDIAN(size, big_endian));
 439               this->make_forwarder(insdef.first->second, ret);
 440               insdef.first->second = ret;
 441             }
 442         }
 443     }
 444   else
 445     {
 446       // This is the first time we have seen NAME/VERSION.
 447       gold_assert(ins.first->second == NULL);
 448
 449       was_undefined = false;
 450       was_common = false;
 451
 452       if (def && !insdef.second)
 453         {
 454           // We already have an entry for NAME/NULL.  If we override
 455           // it, then change it to NAME/VERSION.
 456           ret = this->get_sized_symbol SELECT_SIZE_NAME(size) (
 457               insdef.first->second
 458               SELECT_SIZE(size));
 459           this->resolve(ret, sym, object, version);
 460           ins.first->second = ret;
 461         }
 462       else
 463         {
 464           Sized_target<size, big_endian>* target =
 465             object->sized_target SELECT_SIZE_ENDIAN_NAME(size, big_endian) (
 466                 SELECT_SIZE_ENDIAN_ONLY(size, big_endian));
 467           if (!target->has_make_symbol())
 468             ret = new Sized_symbol<size>();
 469           else
 470             {
 471               ret = target->make_symbol();
 472               if (ret == NULL)
 473                 {
 474                   // This means that we don't want a symbol table
 475                   // entry after all.
 476                   if (!def)
 477                     this->table_.erase(ins.first);
 478                   else
 479                     {
 480                       this->table_.erase(insdef.first);
 481                       // Inserting insdef invalidated ins.
 482                       this->table_.erase(std::make_pair(name_key,
 483                                                         version_key));
 484                     }
 485                   return NULL;
 486                 }
 487             }
 488
 489           ret->init(name, version, object, sym);
 490
 491           ins.first->second = ret;
 492           if (def)
 493             {
 494               // This is the first time we have seen NAME/NULL.  Point
 495               // it at the new entry for NAME/VERSION.
 496               gold_assert(insdef.second);
 497               insdef.first->second = ret;
 498             }
 499         }
 500     }
 501
 502   // Record every time we see a new undefined symbol, to speed up
 503   // archive groups.
 504   if (!was_undefined && ret->is_undefined())
 505     ++this->saw_undefined_;
 506
 507   // Keep track of common symbols, to speed up common symbol
 508   // allocation.
 509   if (!was_common && ret->is_common())
 510     this->commons_.push_back(ret);
 511
 512   return ret;
 513 }
 514
 515 // Add all the symbols in a relocatable object to the hash table.
 516
 517 template<int size, bool big_endian>
 518 void
 519 Symbol_table::add_from_relobj(
 520     Sized_relobj<size, big_endian>* relobj,
 521     const unsigned char* syms,
 522     size_t count,
 523     const char* sym_names,
 524     size_t sym_name_size,
 525     typename Sized_relobj<size, big_endian>::Symbols* sympointers)
 526 {
 527   gold_assert(size == relobj->target()->get_size());
 528   gold_assert(size == parameters->get_size());
 529
 530   const int sym_size = elfcpp::Elf_sizes<size>::sym_size;
 531
 532   const unsigned char* p = syms;
 533   for (size_t i = 0; i < count; ++i, p += sym_size)
 534     {
 535       elfcpp::Sym<size, big_endian> sym(p);
 536       elfcpp::Sym<size, big_endian>* psym = &sym;
 537
 538       unsigned int st_name = psym->get_st_name();
 539       if (st_name >= sym_name_size)
 540         {
 541           relobj->error(_("bad global symbol name offset %u at %zu"),
 542                         st_name, i);
 543           continue;
 544         }
 545
 546       const char* name = sym_names + st_name;
 547
 548       // A symbol defined in a section which we are not including must
 549       // be treated as an undefined symbol.
 550       unsigned char symbuf[sym_size];
 551       elfcpp::Sym<size, big_endian> sym2(symbuf);
 552       unsigned int st_shndx = psym->get_st_shndx();
 553       if (st_shndx != elfcpp::SHN_UNDEF
 554           && st_shndx < elfcpp::SHN_LORESERVE
 555           && !relobj->is_section_included(st_shndx))
 556         {
 557           memcpy(symbuf, p, sym_size);
 558           elfcpp::Sym_write<size, big_endian> sw(symbuf);
 559           sw.put_st_shndx(elfcpp::SHN_UNDEF);
 560           psym = &sym2;
 561         }
 562
 563       // In an object file, an '@' in the name separates the symbol
 564       // name from the version name.  If there are two '@' characters,
 565       // this is the default version.
 566       const char* ver = strchr(name, '@');
 567
 568       Sized_symbol<size>* res;
 569       if (ver == NULL)
 570         {
 571           Stringpool::Key name_key;
 572           name = this->namepool_.add(name, true, &name_key);
 573           res = this->add_from_object(relobj, name, name_key, NULL, 0,
 574                                       false, *psym);
 575         }
 576       else
 577         {
 578           Stringpool::Key name_key;
 579           name = this->namepool_.add_prefix(name, ver - name, &name_key);
 580
 581           bool def = false;
 582           ++ver;
 583           if (*ver == '@')
 584             {
 585               def = true;
 586               ++ver;
 587             }
 588
 589           Stringpool::Key ver_key;
 590           ver = this->namepool_.add(ver, true, &ver_key);
 591
 592           res = this->add_from_object(relobj, name, name_key, ver, ver_key,
 593                                       def, *psym);
 594         }
 595
 596       (*sympointers)[i] = res;
 597     }
 598 }
 599
 600 // Add all the symbols in a dynamic object to the hash table.
 601
 602 template<int size, bool big_endian>
 603 void
 604 Symbol_table::add_from_dynobj(
 605     Sized_dynobj<size, big_endian>* dynobj,
 606     const unsigned char* syms,
 607     size_t count,
 608     const char* sym_names,
 609     size_t sym_name_size,
 610     const unsigned char* versym,
 611     size_t versym_size,
 612     const std::vector<const char*>* version_map)
 613 {
 614   gold_assert(size == dynobj->target()->get_size());
 615   gold_assert(size == parameters->get_size());
 616
 617   if (versym != NULL && versym_size / 2 < count)
 618     {
 619       dynobj->error(_("too few symbol versions"));
 620       return;
 621     }
 622
 623   const int sym_size = elfcpp::Elf_sizes<size>::sym_size;
 624
 625   // We keep a list of all STT_OBJECT symbols, so that we can resolve
 626   // weak aliases.  This is necessary because if the dynamic object
 627   // provides the same variable under two names, one of which is a
 628   // weak definition, and the regular object refers to the weak
 629   // definition, we have to put both the weak definition and the
 630   // strong definition into the dynamic symbol table.  Given a weak
 631   // definition, the only way that we can find the corresponding
 632   // strong definition, if any, is to search the symbol table.
 633   std::vector<Sized_symbol<size>*> object_symbols;
 634
 635   const unsigned char* p = syms;
 636   const unsigned char* vs = versym;
 637   for (size_t i = 0; i < count; ++i, p += sym_size, vs += 2)
 638     {
 639       elfcpp::Sym<size, big_endian> sym(p);
 640
 641       // Ignore symbols with local binding.
 642       if (sym.get_st_bind() == elfcpp::STB_LOCAL)
 643         continue;
 644
 645       unsigned int st_name = sym.get_st_name();
 646       if (st_name >= sym_name_size)
 647         {
 648           dynobj->error(_("bad symbol name offset %u at %zu"),
 649                         st_name, i);
 650           continue;
 651         }
 652
 653       const char* name = sym_names + st_name;
 654
 655       Sized_symbol<size>* res;
 656
 657       if (versym == NULL)
 658         {
 659           Stringpool::Key name_key;
 660           name = this->namepool_.add(name, true, &name_key);
 661           res = this->add_from_object(dynobj, name, name_key, NULL, 0,
 662                                       false, sym);
 663         }
 664       else
 665         {
 666           // Read the version information.
 667
 668           unsigned int v = elfcpp::Swap<16, big_endian>::readval(vs);
 669
 670           bool hidden = (v & elfcpp::VERSYM_HIDDEN) != 0;
 671           v &= elfcpp::VERSYM_VERSION;
 672
 673           // The Sun documentation says that V can be VER_NDX_LOCAL,
 674           // or VER_NDX_GLOBAL, or a version index.  The meaning of
 675           // VER_NDX_LOCAL is defined as "Symbol has local scope."
 676           // The old GNU linker will happily generate VER_NDX_LOCAL
 677           // for an undefined symbol.  I don't know what the Sun
 678           // linker will generate.
 679
 680           if (v == static_cast<unsigned int>(elfcpp::VER_NDX_LOCAL)
 681               && sym.get_st_shndx() != elfcpp::SHN_UNDEF)
 682             {
 683               // This symbol should not be visible outside the object.
 684               continue;
 685             }
 686
 687           // At this point we are definitely going to add this symbol.
 688           Stringpool::Key name_key;
 689           name = this->namepool_.add(name, true, &name_key);
 690
 691           if (v == static_cast<unsigned int>(elfcpp::VER_NDX_LOCAL)
 692               || v == static_cast<unsigned int>(elfcpp::VER_NDX_GLOBAL))
 693             {
 694               // This symbol does not have a version.
 695               res = this->add_from_object(dynobj, name, name_key, NULL, 0,
 696                                           false, sym);
 697             }
 698           else
 699             {
 700               if (v >= version_map->size())
 701                 {
 702                   dynobj->error(_("versym for symbol %zu out of range: %u"),
 703                                 i, v);
 704                   continue;
 705                 }
 706
 707               const char* version = (*version_map)[v];
 708               if (version == NULL)
 709                 {
 710                   dynobj->error(_("versym for symbol %zu has no name: %u"),
 711                                 i, v);
 712                   continue;
 713                 }
 714
 715               Stringpool::Key version_key;
 716               version = this->namepool_.add(version, true, &version_key);
 717
 718               // If this is an absolute symbol, and the version name
 719               // and symbol name are the same, then this is the
 720               // version definition symbol.  These symbols exist to
 721               // support using -u to pull in particular versions.  We
 722               // do not want to record a version for them.
 723               if (sym.get_st_shndx() == elfcpp::SHN_ABS
 724                   && name_key == version_key)
 725                 res = this->add_from_object(dynobj, name, name_key, NULL, 0,
 726                                             false, sym);
 727               else
 728                 {
 729                   const bool def = (!hidden
 730                                     && (sym.get_st_shndx()
 731                                         != elfcpp::SHN_UNDEF));
 732                   res = this->add_from_object(dynobj, name, name_key, version,
 733                                               version_key, def, sym);
 734                 }
 735             }
 736         }
 737
 738       if (sym.get_st_shndx() != elfcpp::SHN_UNDEF
 739           && sym.get_st_type() == elfcpp::STT_OBJECT)
 740         object_symbols.push_back(res);
 741     }
 742
 743   this->record_weak_aliases(&object_symbols);
 744 }
 745
 746 // This is used to sort weak aliases.  We sort them first by section
 747 // index, then by offset, then by weak ahead of strong.
 748
 749 template<int size>
 750 class Weak_alias_sorter
 751 {
 752  public:
 753   bool operator()(const Sized_symbol<size>*, const Sized_symbol<size>*) const;
 754 };
 755
 756 template<int size>
 757 bool
 758 Weak_alias_sorter<size>::operator()(const Sized_symbol<size>* s1,
 759                                     const Sized_symbol<size>* s2) const
 760 {
 761   if (s1->shndx() != s2->shndx())
 762     return s1->shndx() < s2->shndx();
 763   if (s1->value() != s2->value())
 764     return s1->value() < s2->value();
 765   if (s1->binding() != s2->binding())
 766     {
 767       if (s1->binding() == elfcpp::STB_WEAK)
 768         return true;
 769       if (s2->binding() == elfcpp::STB_WEAK)
 770         return false;
 771     }
 772   return std::string(s1->name()) < std::string(s2->name());
 773 }
 774
 775 // SYMBOLS is a list of object symbols from a dynamic object.  Look
 776 // for any weak aliases, and record them so that if we add the weak
 777 // alias to the dynamic symbol table, we also add the corresponding
 778 // strong symbol.
 779
 780 template<int size>
 781 void
 782 Symbol_table::record_weak_aliases(std::vector<Sized_symbol<size>*>* symbols)
 783 {
 784   // Sort the vector by section index, then by offset, then by weak
 785   // ahead of strong.
 786   std::sort(symbols->begin(), symbols->end(), Weak_alias_sorter<size>());
 787
 788   // Walk through the vector.  For each weak definition, record
 789   // aliases.
 790   for (typename std::vector<Sized_symbol<size>*>::const_iterator p =
 791          symbols->begin();
 792        p != symbols->end();
 793        ++p)
 794     {
 795       if ((*p)->binding() != elfcpp::STB_WEAK)
 796         continue;
 797
 798       // Build a circular list of weak aliases.  Each symbol points to
 799       // the next one in the circular list.
 800
 801       Sized_symbol<size>* from_sym = *p;
 802       typename std::vector<Sized_symbol<size>*>::const_iterator q;
 803       for (q = p + 1; q != symbols->end(); ++q)
 804         {
 805           if ((*q)->shndx() != from_sym->shndx()
 806               || (*q)->value() != from_sym->value())
 807             break;
 808
 809           this->weak_aliases_[from_sym] = *q;
 810           from_sym->set_has_alias();
 811           from_sym = *q;
 812         }
 813
 814       if (from_sym != *p)
 815         {
 816           this->weak_aliases_[from_sym] = *p;
 817           from_sym->set_has_alias();
 818         }
 819
 820       p = q - 1;
 821     }
 822 }
 823
 824 // Create and return a specially defined symbol.  If ONLY_IF_REF is
 825 // true, then only create the symbol if there is a reference to it.
 826 // If this does not return NULL, it sets *POLDSYM to the existing
 827 // symbol if there is one.  This canonicalizes *PNAME and *PVERSION.
 828
 829 template<int size, bool big_endian>
 830 Sized_symbol<size>*
 831 Symbol_table::define_special_symbol(const Target* target, const char** pname,
 832                                     const char** pversion, bool only_if_ref,
 833                                     Sized_symbol<size>** poldsym
 834                                     ACCEPT_SIZE_ENDIAN)
 835 {
 836   Symbol* oldsym;
 837   Sized_symbol<size>* sym;
 838   bool add_to_table = false;
 839   typename Symbol_table_type::iterator add_loc = this->table_.end();
 840
 841   if (only_if_ref)
 842     {
 843       oldsym = this->lookup(*pname, *pversion);
 844       if (oldsym == NULL || !oldsym->is_undefined())
 845         return NULL;
 846
 847       *pname = oldsym->name();
 848       *pversion = oldsym->version();
 849     }
 850   else
 851     {
 852       // Canonicalize NAME and VERSION.
 853       Stringpool::Key name_key;
 854       *pname = this->namepool_.add(*pname, true, &name_key);
 855
 856       Stringpool::Key version_key = 0;
 857       if (*pversion != NULL)
 858         *pversion = this->namepool_.add(*pversion, true, &version_key);
 859
 860       Symbol* const snull = NULL;
 861       std::pair<typename Symbol_table_type::iterator, bool> ins =
 862         this->table_.insert(std::make_pair(std::make_pair(name_key,
 863                                                           version_key),
 864                                            snull));
 865
 866       if (!ins.second)
 867         {
 868           // We already have a symbol table entry for NAME/VERSION.
 869           oldsym = ins.first->second;
 870           gold_assert(oldsym != NULL);
 871         }
 872       else
 873         {
 874           // We haven't seen this symbol before.
 875           gold_assert(ins.first->second == NULL);
 876           add_to_table = true;
 877           add_loc = ins.first;
 878           oldsym = NULL;
 879         }
 880     }
 881
 882   if (!target->has_make_symbol())
 883     sym = new Sized_symbol<size>();
 884   else
 885     {
 886       gold_assert(target->get_size() == size);
 887       gold_assert(target->is_big_endian() ? big_endian : !big_endian);
 888       typedef Sized_target<size, big_endian> My_target;
 889       const My_target* sized_target =
 890           static_cast<const My_target*>(target);
 891       sym = sized_target->make_symbol();
 892       if (sym == NULL)
 893         return NULL;
 894     }
 895
 896   if (add_to_table)
 897     add_loc->second = sym;
 898   else
 899     gold_assert(oldsym != NULL);
 900
 901   *poldsym = this->get_sized_symbol SELECT_SIZE_NAME(size) (oldsym
 902                                                             SELECT_SIZE(size));
 903
 904   return sym;
 905 }
 906
 907 // Define a symbol based on an Output_data.
 908
 909 Symbol*
 910 Symbol_table::define_in_output_data(const Target* target, const char* name,
 911                                     const char* version, Output_data* od,
 912                                     uint64_t value, uint64_t symsize,
 913                                     elfcpp::STT type, elfcpp::STB binding,
 914                                     elfcpp::STV visibility,
 915                                     unsigned char nonvis,
 916                                     bool offset_is_from_end,
 917                                     bool only_if_ref)
 918 {
 919   if (parameters->get_size() == 32)
 920     {
 921 #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG)
 922       return this->do_define_in_output_data<32>(target, name, version, od,
 923                                                 value, symsize, type, binding,
 924                                                 visibility, nonvis,
 925                                                 offset_is_from_end,
 926                                                 only_if_ref);
 927 #else
 928       gold_unreachable();
 929 #endif
 930     }
 931   else if (parameters->get_size() == 64)
 932     {
 933 #if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG)
 934       return this->do_define_in_output_data<64>(target, name, version, od,
 935                                                 value, symsize, type, binding,
 936                                                 visibility, nonvis,
 937                                                 offset_is_from_end,
 938                                                 only_if_ref);
 939 #else
 940       gold_unreachable();
 941 #endif
 942     }
 943   else
 944     gold_unreachable();
 945 }
 946
 947 // Define a symbol in an Output_data, sized version.
 948
 949 template<int size>
 950 Sized_symbol<size>*
 951 Symbol_table::do_define_in_output_data(
 952     const Target* target,
 953     const char* name,
 954     const char* version,
 955     Output_data* od,
 956     typename elfcpp::Elf_types<size>::Elf_Addr value,
 957     typename elfcpp::Elf_types<size>::Elf_WXword symsize,
 958     elfcpp::STT type,
 959     elfcpp::STB binding,
 960     elfcpp::STV visibility,
 961     unsigned char nonvis,
 962     bool offset_is_from_end,
 963     bool only_if_ref)
 964 {
 965   Sized_symbol<size>* sym;
 966   Sized_symbol<size>* oldsym;
 967
 968   if (parameters->is_big_endian())
 969     {
 970 #if defined(HAVE_TARGET_32_BIG) || defined(HAVE_TARGET_64_BIG)
 971       sym = this->define_special_symbol SELECT_SIZE_ENDIAN_NAME(size, true) (
 972           target, &name, &version, only_if_ref, &oldsym
 973           SELECT_SIZE_ENDIAN(size, true));
 974 #else
 975       gold_unreachable();
 976 #endif
 977     }
 978   else
 979     {
 980 #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_64_LITTLE)
 981       sym = this->define_special_symbol SELECT_SIZE_ENDIAN_NAME(size, false) (
 982           target, &name, &version, only_if_ref, &oldsym
 983           SELECT_SIZE_ENDIAN(size, false));
 984 #else
 985       gold_unreachable();
 986 #endif
 987     }
 988
 989   if (sym == NULL)
 990     return NULL;
 991
 992   gold_assert(version == NULL || oldsym != NULL);
 993   sym->init(name, od, value, symsize, type, binding, visibility, nonvis,
 994             offset_is_from_end);
 995
 996   if (oldsym != NULL
 997       && Symbol_table::should_override_with_special(oldsym))
 998     this->override_with_special(oldsym, sym);
 999
1000   return sym;
1001 }
1002
1003 // Define a symbol based on an Output_segment.
1004
1005 Symbol*
1006 Symbol_table::define_in_output_segment(const Target* target, const char* name,
1007                                        const char* version, Output_segment* os,
1008                                        uint64_t value, uint64_t symsize,
1009                                        elfcpp::STT type, elfcpp::STB binding,
1010                                        elfcpp::STV visibility,
1011                                        unsigned char nonvis,
1012                                        Symbol::Segment_offset_base offset_base,
1013                                        bool only_if_ref)
1014 {
1015   if (parameters->get_size() == 32)
1016     {
1017 #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG)
1018       return this->do_define_in_output_segment<32>(target, name, version, os,
1019                                                    value, symsize, type,
1020                                                    binding, visibility, nonvis,
1021                                                    offset_base, only_if_ref);
1022 #else
1023       gold_unreachable();
1024 #endif
1025     }
1026   else if (parameters->get_size() == 64)
1027     {
1028 #if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG)
1029       return this->do_define_in_output_segment<64>(target, name, version, os,
1030                                                    value, symsize, type,
1031                                                    binding, visibility, nonvis,
1032                                                    offset_base, only_if_ref);
1033 #else
1034       gold_unreachable();
1035 #endif
1036     }
1037   else
1038     gold_unreachable();
1039 }
1040
1041 // Define a symbol in an Output_segment, sized version.
1042
1043 template<int size>
1044 Sized_symbol<size>*
1045 Symbol_table::do_define_in_output_segment(
1046     const Target* target,
1047     const char* name,
1048     const char* version,
1049     Output_segment* os,
1050     typename elfcpp::Elf_types<size>::Elf_Addr value,
1051     typename elfcpp::Elf_types<size>::Elf_WXword symsize,
1052     elfcpp::STT type,
1053     elfcpp::STB binding,
1054     elfcpp::STV visibility,
1055     unsigned char nonvis,
1056     Symbol::Segment_offset_base offset_base,
1057     bool only_if_ref)
1058 {
1059   Sized_symbol<size>* sym;
1060   Sized_symbol<size>* oldsym;
1061
1062   if (parameters->is_big_endian())
1063     {
1064 #if defined(HAVE_TARGET_32_BIG) || defined(HAVE_TARGET_64_BIG)
1065       sym = this->define_special_symbol SELECT_SIZE_ENDIAN_NAME(size, true) (
1066           target, &name, &version, only_if_ref, &oldsym
1067           SELECT_SIZE_ENDIAN(size, true));
1068 #else
1069       gold_unreachable();
1070 #endif
1071     }
1072   else
1073     {
1074 #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_64_LITTLE)
1075       sym = this->define_special_symbol SELECT_SIZE_ENDIAN_NAME(size, false) (
1076           target, &name, &version, only_if_ref, &oldsym
1077           SELECT_SIZE_ENDIAN(size, false));
1078 #else
1079       gold_unreachable();
1080 #endif
1081     }
1082
1083   if (sym == NULL)
1084     return NULL;
1085
1086   gold_assert(version == NULL || oldsym != NULL);
1087   sym->init(name, os, value, symsize, type, binding, visibility, nonvis,
1088             offset_base);
1089
1090   if (oldsym != NULL
1091       && Symbol_table::should_override_with_special(oldsym))
1092     this->override_with_special(oldsym, sym);
1093
1094   return sym;
1095 }
1096
1097 // Define a special symbol with a constant value.  It is a multiple
1098 // definition error if this symbol is already defined.
1099
1100 Symbol*
1101 Symbol_table::define_as_constant(const Target* target, const char* name,
1102                                  const char* version, uint64_t value,
1103                                  uint64_t symsize, elfcpp::STT type,
1104                                  elfcpp::STB binding, elfcpp::STV visibility,
1105                                  unsigned char nonvis, bool only_if_ref)
1106 {
1107   if (parameters->get_size() == 32)
1108     {
1109 #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG)
1110       return this->do_define_as_constant<32>(target, name, version, value,
1111                                              symsize, type, binding,
1112                                              visibility, nonvis, only_if_ref);
1113 #else
1114       gold_unreachable();
1115 #endif
1116     }
1117   else if (parameters->get_size() == 64)
1118     {
1119 #if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG)
1120       return this->do_define_as_constant<64>(target, name, version, value,
1121                                              symsize, type, binding,
1122                                              visibility, nonvis, only_if_ref);
1123 #else
1124       gold_unreachable();
1125 #endif
1126     }
1127   else
1128     gold_unreachable();
1129 }
1130
1131 // Define a symbol as a constant, sized version.
1132
1133 template<int size>
1134 Sized_symbol<size>*
1135 Symbol_table::do_define_as_constant(
1136     const Target* target,
1137     const char* name,
1138     const char* version,
1139     typename elfcpp::Elf_types<size>::Elf_Addr value,
1140     typename elfcpp::Elf_types<size>::Elf_WXword symsize,
1141     elfcpp::STT type,
1142     elfcpp::STB binding,
1143     elfcpp::STV visibility,
1144     unsigned char nonvis,
1145     bool only_if_ref)
1146 {
1147   Sized_symbol<size>* sym;
1148   Sized_symbol<size>* oldsym;
1149
1150   if (parameters->is_big_endian())
1151     {
1152 #if defined(HAVE_TARGET_32_BIG) || defined(HAVE_TARGET_64_BIG)
1153       sym = this->define_special_symbol SELECT_SIZE_ENDIAN_NAME(size, true) (
1154           target, &name, &version, only_if_ref, &oldsym
1155           SELECT_SIZE_ENDIAN(size, true));
1156 #else
1157       gold_unreachable();
1158 #endif
1159     }
1160   else
1161     {
1162 #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_64_LITTLE)
1163       sym = this->define_special_symbol SELECT_SIZE_ENDIAN_NAME(size, false) (
1164           target, &name, &version, only_if_ref, &oldsym
1165           SELECT_SIZE_ENDIAN(size, false));
1166 #else
1167       gold_unreachable();
1168 #endif
1169     }
1170
1171   if (sym == NULL)
1172     return NULL;
1173
1174   gold_assert(version == NULL || oldsym != NULL);
1175   sym->init(name, value, symsize, type, binding, visibility, nonvis);
1176
1177   if (oldsym != NULL
1178       && Symbol_table::should_override_with_special(oldsym))
1179     this->override_with_special(oldsym, sym);
1180
1181   return sym;
1182 }
1183
1184 // Define a set of symbols in output sections.
1185
1186 void
1187 Symbol_table::define_symbols(const Layout* layout, const Target* target,
1188                              int count, const Define_symbol_in_section* p)
1189 {
1190   for (int i = 0; i < count; ++i, ++p)
1191     {
1192       Output_section* os = layout->find_output_section(p->output_section);
1193       if (os != NULL)
1194         this->define_in_output_data(target, p->name, NULL, os, p->value,
1195                                     p->size, p->type, p->binding,
1196                                     p->visibility, p->nonvis,
1197                                     p->offset_is_from_end, p->only_if_ref);
1198       else
1199         this->define_as_constant(target, p->name, NULL, 0, p->size, p->type,
1200                                  p->binding, p->visibility, p->nonvis,
1201                                  p->only_if_ref);
1202     }
1203 }
1204
1205 // Define a set of symbols in output segments.
1206
1207 void
1208 Symbol_table::define_symbols(const Layout* layout, const Target* target,
1209                              int count, const Define_symbol_in_segment* p)
1210 {
1211   for (int i = 0; i < count; ++i, ++p)
1212     {
1213       Output_segment* os = layout->find_output_segment(p->segment_type,
1214                                                        p->segment_flags_set,
1215                                                        p->segment_flags_clear);
1216       if (os != NULL)
1217         this->define_in_output_segment(target, p->name, NULL, os, p->value,
1218                                        p->size, p->type, p->binding,
1219                                        p->visibility, p->nonvis,
1220                                        p->offset_base, p->only_if_ref);
1221       else
1222         this->define_as_constant(target, p->name, NULL, 0, p->size, p->type,
1223                                  p->binding, p->visibility, p->nonvis,
1224                                  p->only_if_ref);
1225     }
1226 }
1227
1228 // Define CSYM using a COPY reloc.  POSD is the Output_data where the
1229 // symbol should be defined--typically a .dyn.bss section.  VALUE is
1230 // the offset within POSD.
1231
1232 template<int size>
1233 void
1234 Symbol_table::define_with_copy_reloc(const Target* target,
1235                                      Sized_symbol<size>* csym,
1236                                      Output_data* posd, uint64_t value)
1237 {
1238   gold_assert(csym->is_from_dynobj());
1239   gold_assert(!csym->is_copied_from_dynobj());
1240   Object* object = csym->object();
1241   gold_assert(object->is_dynamic());
1242   Dynobj* dynobj = static_cast<Dynobj*>(object);
1243
1244   // Our copied variable has to override any variable in a shared
1245   // library.
1246   elfcpp::STB binding = csym->binding();
1247   if (binding == elfcpp::STB_WEAK)
1248     binding = elfcpp::STB_GLOBAL;
1249
1250   this->define_in_output_data(target, csym->name(), csym->version(),
1251                               posd, value, csym->symsize(),
1252                               csym->type(), binding,
1253                               csym->visibility(), csym->nonvis(),
1254                               false, false);
1255
1256   csym->set_is_copied_from_dynobj();
1257   csym->set_needs_dynsym_entry();
1258
1259   this->copied_symbol_dynobjs_[csym] = dynobj;
1260
1261   // We have now defined all aliases, but we have not entered them all
1262   // in the copied_symbol_dynobjs_ map.
1263   if (csym->has_alias())
1264     {
1265       Symbol* sym = csym;
1266       while (true)
1267         {
1268           sym = this->weak_aliases_[sym];
1269           if (sym == csym)
1270             break;
1271           gold_assert(sym->output_data() == posd);
1272
1273           sym->set_is_copied_from_dynobj();
1274           this->copied_symbol_dynobjs_[sym] = dynobj;
1275         }
1276     }
1277 }
1278
1279 // SYM is defined using a COPY reloc.  Return the dynamic object where
1280 // the original definition was found.
1281
1282 Dynobj*
1283 Symbol_table::get_copy_source(const Symbol* sym) const
1284 {
1285   gold_assert(sym->is_copied_from_dynobj());
1286   Copied_symbol_dynobjs::const_iterator p =
1287     this->copied_symbol_dynobjs_.find(sym);
1288   gold_assert(p != this->copied_symbol_dynobjs_.end());
1289   return p->second;
1290 }
1291
1292 // Set the dynamic symbol indexes.  INDEX is the index of the first
1293 // global dynamic symbol.  Pointers to the symbols are stored into the
1294 // vector SYMS.  The names are added to DYNPOOL.  This returns an
1295 // updated dynamic symbol index.
1296
1297 unsigned int
1298 Symbol_table::set_dynsym_indexes(const Target* target,
1299                                  unsigned int index,
1300                                  std::vector<Symbol*>* syms,
1301                                  Stringpool* dynpool,
1302                                  Versions* versions)
1303 {
1304   for (Symbol_table_type::iterator p = this->table_.begin();
1305        p != this->table_.end();
1306        ++p)
1307     {
1308       Symbol* sym = p->second;
1309
1310       // Note that SYM may already have a dynamic symbol index, since
1311       // some symbols appear more than once in the symbol table, with
1312       // and without a version.
1313
1314       if (!sym->should_add_dynsym_entry())
1315         sym->set_dynsym_index(-1U);
1316       else if (!sym->has_dynsym_index())
1317         {
1318           sym->set_dynsym_index(index);
1319           ++index;
1320           syms->push_back(sym);
1321           dynpool->add(sym->name(), false, NULL);
1322
1323           // Record any version information.
1324           if (sym->version() != NULL)
1325             versions->record_version(this, dynpool, sym);
1326         }
1327     }
1328
1329   // Finish up the versions.  In some cases this may add new dynamic
1330   // symbols.
1331   index = versions->finalize(target, this, index, syms);
1332
1333   return index;
1334 }
1335
1336 // Set the final values for all the symbols.  The index of the first
1337 // global symbol in the output file is INDEX.  Record the file offset
1338 // OFF.  Add their names to POOL.  Return the new file offset.
1339
1340 off_t
1341 Symbol_table::finalize(unsigned int index, off_t off, off_t dynoff,
1342                        size_t dyn_global_index, size_t dyncount,
1343                        Stringpool* pool)
1344 {
1345   off_t ret;
1346
1347   gold_assert(index != 0);
1348   this->first_global_index_ = index;
1349
1350   this->dynamic_offset_ = dynoff;
1351   this->first_dynamic_global_index_ = dyn_global_index;
1352   this->dynamic_count_ = dyncount;
1353
1354   if (parameters->get_size() == 32)
1355     {
1356 #if defined(HAVE_TARGET_32_BIG) || defined(HAVE_TARGET_32_LITTLE)
1357       ret = this->sized_finalize<32>(index, off, pool);
1358 #else
1359       gold_unreachable();
1360 #endif
1361     }
1362   else if (parameters->get_size() == 64)
1363     {
1364 #if defined(HAVE_TARGET_64_BIG) || defined(HAVE_TARGET_64_LITTLE)
1365       ret = this->sized_finalize<64>(index, off, pool);
1366 #else
1367       gold_unreachable();
1368 #endif
1369     }
1370   else
1371     gold_unreachable();
1372
1373   // Now that we have the final symbol table, we can reliably note
1374   // which symbols should get warnings.
1375   this->warnings_.note_warnings(this);
1376
1377   return ret;
1378 }
1379
1380 // Set the final value for all the symbols.  This is called after
1381 // Layout::finalize, so all the output sections have their final
1382 // address.
1383
1384 template<int size>
1385 off_t
1386 Symbol_table::sized_finalize(unsigned index, off_t off, Stringpool* pool)
1387 {
1388   off = align_address(off, size >> 3);
1389   this->offset_ = off;
1390
1391   size_t orig_index = index;
1392
1393   const int sym_size = elfcpp::Elf_sizes<size>::sym_size;
1394   for (Symbol_table_type::iterator p = this->table_.begin();
1395        p != this->table_.end();
1396        ++p)
1397     {
1398       Sized_symbol<size>* sym = static_cast<Sized_symbol<size>*>(p->second);
1399
1400       // FIXME: Here we need to decide which symbols should go into
1401       // the output file, based on --strip.
1402
1403       // The default version of a symbol may appear twice in the
1404       // symbol table.  We only need to finalize it once.
1405       if (sym->has_symtab_index())
1406         continue;
1407
1408       if (!sym->in_reg())
1409         {
1410           gold_assert(!sym->has_symtab_index());
1411           sym->set_symtab_index(-1U);
1412           gold_assert(sym->dynsym_index() == -1U);
1413           continue;
1414         }
1415
1416       typename Sized_symbol<size>::Value_type value;
1417
1418       switch (sym->source())
1419         {
1420         case Symbol::FROM_OBJECT:
1421           {
1422             unsigned int shndx = sym->shndx();
1423
1424             // FIXME: We need some target specific support here.
1425             if (shndx >= elfcpp::SHN_LORESERVE
1426                 && shndx != elfcpp::SHN_ABS)
1427               {
1428                 gold_error(_("%s: unsupported symbol section 0x%x"),
1429                            sym->name(), shndx);
1430                 shndx = elfcpp::SHN_UNDEF;
1431               }
1432
1433             Object* symobj = sym->object();
1434             if (symobj->is_dynamic())
1435               {
1436                 value = 0;
1437                 shndx = elfcpp::SHN_UNDEF;
1438               }
1439             else if (shndx == elfcpp::SHN_UNDEF)
1440               value = 0;
1441             else if (shndx == elfcpp::SHN_ABS)
1442               value = sym->value();
1443             else
1444               {
1445                 Relobj* relobj = static_cast<Relobj*>(symobj);
1446                 off_t secoff;
1447                 Output_section* os = relobj->output_section(shndx, &secoff);
1448
1449                 if (os == NULL)
1450                   {
1451                     sym->set_symtab_index(-1U);
1452                     gold_assert(sym->dynsym_index() == -1U);
1453                     continue;
1454                   }
1455
1456                 value = sym->value() + os->address() + secoff;
1457               }
1458           }
1459           break;
1460
1461         case Symbol::IN_OUTPUT_DATA:
1462           {
1463             Output_data* od = sym->output_data();
1464             value = sym->value() + od->address();
1465             if (sym->offset_is_from_end())
1466               value += od->data_size();
1467           }
1468           break;
1469
1470         case Symbol::IN_OUTPUT_SEGMENT:
1471           {
1472             Output_segment* os = sym->output_segment();
1473             value = sym->value() + os->vaddr();
1474             switch (sym->offset_base())
1475               {
1476               case Symbol::SEGMENT_START:
1477                 break;
1478               case Symbol::SEGMENT_END:
1479                 value += os->memsz();
1480                 break;
1481               case Symbol::SEGMENT_BSS:
1482                 value += os->filesz();
1483                 break;
1484               default:
1485                 gold_unreachable();
1486               }
1487           }
1488           break;
1489
1490         case Symbol::CONSTANT:
1491           value = sym->value();
1492           break;
1493
1494         default:
1495           gold_unreachable();
1496         }
1497
1498       sym->set_value(value);
1499
1500       if (parameters->strip_all())
1501         sym->set_symtab_index(-1U);
1502       else
1503         {
1504           sym->set_symtab_index(index);
1505           pool->add(sym->name(), false, NULL);
1506           ++index;
1507           off += sym_size;
1508         }
1509     }
1510
1511   this->output_count_ = index - orig_index;
1512
1513   return off;
1514 }
1515
1516 // Write out the global symbols.
1517
1518 void
1519 Symbol_table::write_globals(const Target* target, const Stringpool* sympool,
1520                             const Stringpool* dynpool, Output_file* of) const
1521 {
1522   if (parameters->get_size() == 32)
1523     {
1524       if (parameters->is_big_endian())
1525         {
1526 #ifdef HAVE_TARGET_32_BIG
1527           this->sized_write_globals<32, true>(target, sympool, dynpool, of);
1528 #else
1529           gold_unreachable();
1530 #endif
1531         }
1532       else
1533         {
1534 #ifdef HAVE_TARGET_32_LITTLE
1535           this->sized_write_globals<32, false>(target, sympool, dynpool, of);
1536 #else
1537           gold_unreachable();
1538 #endif
1539         }
1540     }
1541   else if (parameters->get_size() == 64)
1542     {
1543       if (parameters->is_big_endian())
1544         {
1545 #ifdef HAVE_TARGET_64_BIG
1546           this->sized_write_globals<64, true>(target, sympool, dynpool, of);
1547 #else
1548           gold_unreachable();
1549 #endif
1550         }
1551       else
1552         {
1553 #ifdef HAVE_TARGET_64_LITTLE
1554           this->sized_write_globals<64, false>(target, sympool, dynpool, of);
1555 #else
1556           gold_unreachable();
1557 #endif
1558         }
1559     }
1560   else
1561     gold_unreachable();
1562 }
1563
1564 // Write out the global symbols.
1565
1566 template<int size, bool big_endian>
1567 void
1568 Symbol_table::sized_write_globals(const Target* target,
1569                                   const Stringpool* sympool,
1570                                   const Stringpool* dynpool,
1571                                   Output_file* of) const
1572 {
1573   const int sym_size = elfcpp::Elf_sizes<size>::sym_size;
1574   unsigned int index = this->first_global_index_;
1575   const off_t oview_size = this->output_count_ * sym_size;
1576   unsigned char* const psyms = of->get_output_view(this->offset_, oview_size);
1577
1578   unsigned int dynamic_count = this->dynamic_count_;
1579   off_t dynamic_size = dynamic_count * sym_size;
1580   unsigned int first_dynamic_global_index = this->first_dynamic_global_index_;
1581   unsigned char* dynamic_view;
1582   if (this->dynamic_offset_ == 0)
1583     dynamic_view = NULL;
1584   else
1585     dynamic_view = of->get_output_view(this->dynamic_offset_, dynamic_size);
1586
1587   unsigned char* ps = psyms;
1588   for (Symbol_table_type::const_iterator p = this->table_.begin();
1589        p != this->table_.end();
1590        ++p)
1591     {
1592       Sized_symbol<size>* sym = static_cast<Sized_symbol<size>*>(p->second);
1593
1594       unsigned int sym_index = sym->symtab_index();
1595       unsigned int dynsym_index;
1596       if (dynamic_view == NULL)
1597         dynsym_index = -1U;
1598       else
1599         dynsym_index = sym->dynsym_index();
1600
1601       if (sym_index == -1U && dynsym_index == -1U)
1602         {
1603           // This symbol is not included in the output file.
1604           continue;
1605         }
1606
1607       if (sym_index == index)
1608         ++index;
1609       else if (sym_index != -1U)
1610         {
1611           // We have already seen this symbol, because it has a
1612           // default version.
1613           gold_assert(sym_index < index);
1614           if (dynsym_index == -1U)
1615             continue;
1616           sym_index = -1U;
1617         }
1618
1619       unsigned int shndx;
1620       typename elfcpp::Elf_types<32>::Elf_Addr value = sym->value();
1621       switch (sym->source())
1622         {
1623         case Symbol::FROM_OBJECT:
1624           {
1625             unsigned int in_shndx = sym->shndx();
1626
1627             // FIXME: We need some target specific support here.
1628             if (in_shndx >= elfcpp::SHN_LORESERVE
1629                 && in_shndx != elfcpp::SHN_ABS)
1630               {
1631                 gold_error(_("%s: unsupported symbol section 0x%x"),
1632                            sym->name(), in_shndx);
1633                 shndx = in_shndx;
1634               }
1635             else
1636               {
1637                 Object* symobj = sym->object();
1638                 if (symobj->is_dynamic())
1639                   {
1640                     if (sym->needs_dynsym_value())
1641                       value = target->dynsym_value(sym);
1642                     shndx = elfcpp::SHN_UNDEF;
1643                   }
1644                 else if (in_shndx == elfcpp::SHN_UNDEF
1645                          || in_shndx == elfcpp::SHN_ABS)
1646                   shndx = in_shndx;
1647                 else
1648                   {
1649                     Relobj* relobj = static_cast<Relobj*>(symobj);
1650                     off_t secoff;
1651                     Output_section* os = relobj->output_section(in_shndx,
1652                                                                 &secoff);
1653                     gold_assert(os != NULL);
1654                     shndx = os->out_shndx();
1655                   }
1656               }
1657           }
1658           break;
1659
1660         case Symbol::IN_OUTPUT_DATA:
1661           shndx = sym->output_data()->out_shndx();
1662           break;
1663
1664         case Symbol::IN_OUTPUT_SEGMENT:
1665           shndx = elfcpp::SHN_ABS;
1666           break;
1667
1668         case Symbol::CONSTANT:
1669           shndx = elfcpp::SHN_ABS;
1670           break;
1671
1672         default:
1673           gold_unreachable();
1674         }
1675
1676       if (sym_index != -1U)
1677         {
1678           this->sized_write_symbol SELECT_SIZE_ENDIAN_NAME(size, big_endian) (
1679               sym, sym->value(), shndx, sympool, ps
1680               SELECT_SIZE_ENDIAN(size, big_endian));
1681           ps += sym_size;
1682         }
1683
1684       if (dynsym_index != -1U)
1685         {
1686           dynsym_index -= first_dynamic_global_index;
1687           gold_assert(dynsym_index < dynamic_count);
1688           unsigned char* pd = dynamic_view + (dynsym_index * sym_size);
1689           this->sized_write_symbol SELECT_SIZE_ENDIAN_NAME(size, big_endian) (
1690               sym, value, shndx, dynpool, pd
1691               SELECT_SIZE_ENDIAN(size, big_endian));
1692         }
1693     }
1694
1695   gold_assert(ps - psyms == oview_size);
1696
1697   of->write_output_view(this->offset_, oview_size, psyms);
1698   if (dynamic_view != NULL)
1699     of->write_output_view(this->dynamic_offset_, dynamic_size, dynamic_view);
1700 }
1701
1702 // Write out the symbol SYM, in section SHNDX, to P.  POOL is the
1703 // strtab holding the name.
1704
1705 template<int size, bool big_endian>
1706 void
1707 Symbol_table::sized_write_symbol(
1708     Sized_symbol<size>* sym,
1709     typename elfcpp::Elf_types<size>::Elf_Addr value,
1710     unsigned int shndx,
1711     const Stringpool* pool,
1712     unsigned char* p
1713     ACCEPT_SIZE_ENDIAN) const
1714 {
1715   elfcpp::Sym_write<size, big_endian> osym(p);
1716   osym.put_st_name(pool->get_offset(sym->name()));
1717   osym.put_st_value(value);
1718   osym.put_st_size(sym->symsize());
1719   osym.put_st_info(elfcpp::elf_st_info(sym->binding(), sym->type()));
1720   osym.put_st_other(elfcpp::elf_st_other(sym->visibility(), sym->nonvis()));
1721   osym.put_st_shndx(shndx);
1722 }
1723
1724 // Write out a section symbol.  Return the update offset.
1725
1726 void
1727 Symbol_table::write_section_symbol(const Output_section *os,
1728                                    Output_file* of,
1729                                    off_t offset) const
1730 {
1731   if (parameters->get_size() == 32)
1732     {
1733       if (parameters->is_big_endian())
1734         {
1735 #ifdef HAVE_TARGET_32_BIG
1736           this->sized_write_section_symbol<32, true>(os, of, offset);
1737 #else
1738           gold_unreachable();
1739 #endif
1740         }
1741       else
1742         {
1743 #ifdef HAVE_TARGET_32_LITTLE
1744           this->sized_write_section_symbol<32, false>(os, of, offset);
1745 #else
1746           gold_unreachable();
1747 #endif
1748         }
1749     }
1750   else if (parameters->get_size() == 64)
1751     {
1752       if (parameters->is_big_endian())
1753         {
1754 #ifdef HAVE_TARGET_64_BIG
1755           this->sized_write_section_symbol<64, true>(os, of, offset);
1756 #else
1757           gold_unreachable();
1758 #endif
1759         }
1760       else
1761         {
1762 #ifdef HAVE_TARGET_64_LITTLE
1763           this->sized_write_section_symbol<64, false>(os, of, offset);
1764 #else
1765           gold_unreachable();
1766 #endif
1767         }
1768     }
1769   else
1770     gold_unreachable();
1771 }
1772
1773 // Write out a section symbol, specialized for size and endianness.
1774
1775 template<int size, bool big_endian>
1776 void
1777 Symbol_table::sized_write_section_symbol(const Output_section* os,
1778                                          Output_file* of,
1779                                          off_t offset) const
1780 {
1781   const int sym_size = elfcpp::Elf_sizes<size>::sym_size;
1782
1783   unsigned char* pov = of->get_output_view(offset, sym_size);
1784
1785   elfcpp::Sym_write<size, big_endian> osym(pov);
1786   osym.put_st_name(0);
1787   osym.put_st_value(os->address());
1788   osym.put_st_size(0);
1789   osym.put_st_info(elfcpp::elf_st_info(elfcpp::STB_LOCAL,
1790                                        elfcpp::STT_SECTION));
1791   osym.put_st_other(elfcpp::elf_st_other(elfcpp::STV_DEFAULT, 0));
1792   osym.put_st_shndx(os->out_shndx());
1793
1794   of->write_output_view(offset, sym_size, pov);
1795 }
1796
1797 // Warnings functions.
1798
1799 // Add a new warning.
1800
1801 void
1802 Warnings::add_warning(Symbol_table* symtab, const char* name, Object* obj,
1803                       unsigned int shndx)
1804 {
1805   name = symtab->canonicalize_name(name);
1806   this->warnings_[name].set(obj, shndx);
1807 }
1808
1809 // Look through the warnings and mark the symbols for which we should
1810 // warn.  This is called during Layout::finalize when we know the
1811 // sources for all the symbols.
1812
1813 void
1814 Warnings::note_warnings(Symbol_table* symtab)
1815 {
1816   for (Warning_table::iterator p = this->warnings_.begin();
1817        p != this->warnings_.end();
1818        ++p)
1819     {
1820       Symbol* sym = symtab->lookup(p->first, NULL);
1821       if (sym != NULL
1822           && sym->source() == Symbol::FROM_OBJECT
1823           && sym->object() == p->second.object)
1824         {
1825           sym->set_has_warning();
1826
1827           // Read the section contents to get the warning text.  It
1828           // would be nicer if we only did this if we have to actually
1829           // issue a warning.  Unfortunately, warnings are issued as
1830           // we relocate sections.  That means that we can not lock
1831           // the object then, as we might try to issue the same
1832           // warning multiple times simultaneously.
1833           {
1834             Task_locker_obj<Object> tl(*p->second.object);
1835             const unsigned char* c;
1836             off_t len;
1837             c = p->second.object->section_contents(p->second.shndx, &len,
1838                                                    false);
1839             p->second.set_text(reinterpret_cast<const char*>(c), len);
1840           }
1841         }
1842     }
1843 }
1844
1845 // Issue a warning.  This is called when we see a relocation against a
1846 // symbol for which has a warning.
1847
1848 template<int size, bool big_endian>
1849 void
1850 Warnings::issue_warning(const Symbol* sym,
1851                         const Relocate_info<size, big_endian>* relinfo,
1852                         size_t relnum, off_t reloffset) const
1853 {
1854   gold_assert(sym->has_warning());
1855   Warning_table::const_iterator p = this->warnings_.find(sym->name());
1856   gold_assert(p != this->warnings_.end());
1857   gold_warning_at_location(relinfo, relnum, reloffset,
1858                            "%s", p->second.text.c_str());
1859 }
1860
1861 // Instantiate the templates we need.  We could use the configure
1862 // script to restrict this to only the ones needed for implemented
1863 // targets.
1864
1865 #ifdef HAVE_TARGET_32_LITTLE
1866 template
1867 void
1868 Symbol_table::add_from_relobj<32, false>(
1869     Sized_relobj<32, false>* relobj,
1870     const unsigned char* syms,
1871     size_t count,
1872     const char* sym_names,
1873     size_t sym_name_size,
1874     Sized_relobj<32, true>::Symbols* sympointers);
1875 #endif
1876
1877 #ifdef HAVE_TARGET_32_BIG
1878 template
1879 void
1880 Symbol_table::add_from_relobj<32, true>(
1881     Sized_relobj<32, true>* relobj,
1882     const unsigned char* syms,
1883     size_t count,
1884     const char* sym_names,
1885     size_t sym_name_size,
1886     Sized_relobj<32, false>::Symbols* sympointers);
1887 #endif
1888
1889 #ifdef HAVE_TARGET_64_LITTLE
1890 template
1891 void
1892 Symbol_table::add_from_relobj<64, false>(
1893     Sized_relobj<64, false>* relobj,
1894     const unsigned char* syms,
1895     size_t count,
1896     const char* sym_names,
1897     size_t sym_name_size,
1898     Sized_relobj<64, true>::Symbols* sympointers);
1899 #endif
1900
1901 #ifdef HAVE_TARGET_64_BIG
1902 template
1903 void
1904 Symbol_table::add_from_relobj<64, true>(
1905     Sized_relobj<64, true>* relobj,
1906     const unsigned char* syms,
1907     size_t count,
1908     const char* sym_names,
1909     size_t sym_name_size,
1910     Sized_relobj<64, false>::Symbols* sympointers);
1911 #endif
1912
1913 #ifdef HAVE_TARGET_32_LITTLE
1914 template
1915 void
1916 Symbol_table::add_from_dynobj<32, false>(
1917     Sized_dynobj<32, false>* dynobj,
1918     const unsigned char* syms,
1919     size_t count,
1920     const char* sym_names,
1921     size_t sym_name_size,
1922     const unsigned char* versym,
1923     size_t versym_size,
1924     const std::vector<const char*>* version_map);
1925 #endif
1926
1927 #ifdef HAVE_TARGET_32_BIG
1928 template
1929 void
1930 Symbol_table::add_from_dynobj<32, true>(
1931     Sized_dynobj<32, true>* dynobj,
1932     const unsigned char* syms,
1933     size_t count,
1934     const char* sym_names,
1935     size_t sym_name_size,
1936     const unsigned char* versym,
1937     size_t versym_size,
1938     const std::vector<const char*>* version_map);
1939 #endif
1940
1941 #ifdef HAVE_TARGET_64_LITTLE
1942 template
1943 void
1944 Symbol_table::add_from_dynobj<64, false>(
1945     Sized_dynobj<64, false>* dynobj,
1946     const unsigned char* syms,
1947     size_t count,
1948     const char* sym_names,
1949     size_t sym_name_size,
1950     const unsigned char* versym,
1951     size_t versym_size,
1952     const std::vector<const char*>* version_map);
1953 #endif
1954
1955 #ifdef HAVE_TARGET_64_BIG
1956 template
1957 void
1958 Symbol_table::add_from_dynobj<64, true>(
1959     Sized_dynobj<64, true>* dynobj,
1960     const unsigned char* syms,
1961     size_t count,
1962     const char* sym_names,
1963     size_t sym_name_size,
1964     const unsigned char* versym,
1965     size_t versym_size,
1966     const std::vector<const char*>* version_map);
1967 #endif
1968
1969 #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG)
1970 template
1971 void
1972 Symbol_table::define_with_copy_reloc<32>(const Target* target,
1973                                          Sized_symbol<32>* sym,
1974                                          Output_data* posd, uint64_t value);
1975 #endif
1976
1977 #if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG)
1978 template
1979 void
1980 Symbol_table::define_with_copy_reloc<64>(const Target* target,
1981                                          Sized_symbol<64>* sym,
1982                                          Output_data* posd, uint64_t value);
1983 #endif
1984
1985 #ifdef HAVE_TARGET_32_LITTLE
1986 template
1987 void
1988 Warnings::issue_warning<32, false>(const Symbol* sym,
1989                                    const Relocate_info<32, false>* relinfo,
1990                                    size_t relnum, off_t reloffset) const;
1991 #endif
1992
1993 #ifdef HAVE_TARGET_32_BIG
1994 template
1995 void
1996 Warnings::issue_warning<32, true>(const Symbol* sym,
1997                                   const Relocate_info<32, true>* relinfo,
1998                                   size_t relnum, off_t reloffset) const;
1999 #endif
2000
2001 #ifdef HAVE_TARGET_64_LITTLE
2002 template
2003 void
2004 Warnings::issue_warning<64, false>(const Symbol* sym,
2005                                    const Relocate_info<64, false>* relinfo,
2006                                    size_t relnum, off_t reloffset) const;
2007 #endif
2008
2009 #ifdef HAVE_TARGET_64_BIG
2010 template
2011 void
2012 Warnings::issue_warning<64, true>(const Symbol* sym,
2013                                   const Relocate_info<64, true>* relinfo,
2014                                   size_t relnum, off_t reloffset) const;
2015 #endif
2016
2017 } // End namespace gold.