Home | History | Annotate | Download | only in gold
      1 // symtab.h -- the gold symbol table   -*- C++ -*-
      2 
      3 // Copyright (C) 2006-2014 Free Software Foundation, Inc.
      4 // Written by Ian Lance Taylor <iant (at) 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 // Symbol_table
     24 //   The symbol table.
     25 
     26 #ifndef GOLD_SYMTAB_H
     27 #define GOLD_SYMTAB_H
     28 
     29 #include <string>
     30 #include <utility>
     31 #include <vector>
     32 
     33 #include "elfcpp.h"
     34 #include "parameters.h"
     35 #include "stringpool.h"
     36 #include "object.h"
     37 
     38 namespace gold
     39 {
     40 
     41 class Mapfile;
     42 class Object;
     43 class Relobj;
     44 template<int size, bool big_endian>
     45 class Sized_relobj_file;
     46 template<int size, bool big_endian>
     47 class Sized_pluginobj;
     48 class Dynobj;
     49 template<int size, bool big_endian>
     50 class Sized_dynobj;
     51 template<int size, bool big_endian>
     52 class Sized_incrobj;
     53 class Versions;
     54 class Version_script_info;
     55 class Input_objects;
     56 class Output_data;
     57 class Output_section;
     58 class Output_segment;
     59 class Output_file;
     60 class Output_symtab_xindex;
     61 class Garbage_collection;
     62 class Icf;
     63 
     64 // The base class of an entry in the symbol table.  The symbol table
     65 // can have a lot of entries, so we don't want this class too big.
     66 // Size dependent fields can be found in the template class
     67 // Sized_symbol.  Targets may support their own derived classes.
     68 
     69 class Symbol
     70 {
     71  public:
     72   // Because we want the class to be small, we don't use any virtual
     73   // functions.  But because symbols can be defined in different
     74   // places, we need to classify them.  This enum is the different
     75   // sources of symbols we support.
     76   enum Source
     77   {
     78     // Symbol defined in a relocatable or dynamic input file--this is
     79     // the most common case.
     80     FROM_OBJECT,
     81     // Symbol defined in an Output_data, a special section created by
     82     // the target.
     83     IN_OUTPUT_DATA,
     84     // Symbol defined in an Output_segment, with no associated
     85     // section.
     86     IN_OUTPUT_SEGMENT,
     87     // Symbol value is constant.
     88     IS_CONSTANT,
     89     // Symbol is undefined.
     90     IS_UNDEFINED
     91   };
     92 
     93   // When the source is IN_OUTPUT_SEGMENT, we need to describe what
     94   // the offset means.
     95   enum Segment_offset_base
     96   {
     97     // From the start of the segment.
     98     SEGMENT_START,
     99     // From the end of the segment.
    100     SEGMENT_END,
    101     // From the filesz of the segment--i.e., after the loaded bytes
    102     // but before the bytes which are allocated but zeroed.
    103     SEGMENT_BSS
    104   };
    105 
    106   // Return the symbol name.
    107   const char*
    108   name() const
    109   { return this->name_; }
    110 
    111   // Return the (ANSI) demangled version of the name, if
    112   // parameters.demangle() is true.  Otherwise, return the name.  This
    113   // is intended to be used only for logging errors, so it's not
    114   // super-efficient.
    115   std::string
    116   demangled_name() const;
    117 
    118   // Return the symbol version.  This will return NULL for an
    119   // unversioned symbol.
    120   const char*
    121   version() const
    122   { return this->version_; }
    123 
    124   void
    125   clear_version()
    126   { this->version_ = NULL; }
    127 
    128   // Return whether this version is the default for this symbol name
    129   // (eg, "foo@@V2" is a default version; "foo@V1" is not).  Only
    130   // meaningful for versioned symbols.
    131   bool
    132   is_default() const
    133   {
    134     gold_assert(this->version_ != NULL);
    135     return this->is_def_;
    136   }
    137 
    138   // Set that this version is the default for this symbol name.
    139   void
    140   set_is_default()
    141   { this->is_def_ = true; }
    142 
    143   // Return the symbol's name as name@version (or name@@version).
    144   std::string
    145   versioned_name() const;
    146 
    147   // Return the symbol source.
    148   Source
    149   source() const
    150   { return this->source_; }
    151 
    152   // Return the object with which this symbol is associated.
    153   Object*
    154   object() const
    155   {
    156     gold_assert(this->source_ == FROM_OBJECT);
    157     return this->u_.from_object.object;
    158   }
    159 
    160   // Return the index of the section in the input relocatable or
    161   // dynamic object file.
    162   unsigned int
    163   shndx(bool* is_ordinary) const
    164   {
    165     gold_assert(this->source_ == FROM_OBJECT);
    166     *is_ordinary = this->is_ordinary_shndx_;
    167     return this->u_.from_object.shndx;
    168   }
    169 
    170   // Return the output data section with which this symbol is
    171   // associated, if the symbol was specially defined with respect to
    172   // an output data section.
    173   Output_data*
    174   output_data() const
    175   {
    176     gold_assert(this->source_ == IN_OUTPUT_DATA);
    177     return this->u_.in_output_data.output_data;
    178   }
    179 
    180   // If this symbol was defined with respect to an output data
    181   // section, return whether the value is an offset from end.
    182   bool
    183   offset_is_from_end() const
    184   {
    185     gold_assert(this->source_ == IN_OUTPUT_DATA);
    186     return this->u_.in_output_data.offset_is_from_end;
    187   }
    188 
    189   // Return the output segment with which this symbol is associated,
    190   // if the symbol was specially defined with respect to an output
    191   // segment.
    192   Output_segment*
    193   output_segment() const
    194   {
    195     gold_assert(this->source_ == IN_OUTPUT_SEGMENT);
    196     return this->u_.in_output_segment.output_segment;
    197   }
    198 
    199   // If this symbol was defined with respect to an output segment,
    200   // return the offset base.
    201   Segment_offset_base
    202   offset_base() const
    203   {
    204     gold_assert(this->source_ == IN_OUTPUT_SEGMENT);
    205     return this->u_.in_output_segment.offset_base;
    206   }
    207 
    208   // Return the symbol binding.
    209   elfcpp::STB
    210   binding() const
    211   { return this->binding_; }
    212 
    213   // Return the symbol type.
    214   elfcpp::STT
    215   type() const
    216   { return this->type_; }
    217 
    218   // Set the symbol type.
    219   void
    220   set_type(elfcpp::STT type)
    221   { this->type_ = type; }
    222 
    223   // Return true for function symbol.
    224   bool
    225   is_func() const
    226   {
    227     return (this->type_ == elfcpp::STT_FUNC
    228 	    || this->type_ == elfcpp::STT_GNU_IFUNC);
    229   }
    230 
    231   // Return the symbol visibility.
    232   elfcpp::STV
    233   visibility() const
    234   { return this->visibility_; }
    235 
    236   // Set the visibility.
    237   void
    238   set_visibility(elfcpp::STV visibility)
    239   { this->visibility_ = visibility; }
    240 
    241   // Override symbol visibility.
    242   void
    243   override_visibility(elfcpp::STV);
    244 
    245   // Set whether the symbol was originally a weak undef or a regular undef
    246   // when resolved by a dynamic def or by a special symbol.
    247   inline void
    248   set_undef_binding(elfcpp::STB bind)
    249   {
    250     if (!this->undef_binding_set_ || this->undef_binding_weak_)
    251       {
    252         this->undef_binding_weak_ = bind == elfcpp::STB_WEAK;
    253         this->undef_binding_set_ = true;
    254       }
    255   }
    256 
    257   // Return TRUE if a weak undef was resolved by a dynamic def or
    258   // by a special symbol.
    259   inline bool
    260   is_undef_binding_weak() const
    261   { return this->undef_binding_weak_; }
    262 
    263   // Return the non-visibility part of the st_other field.
    264   unsigned char
    265   nonvis() const
    266   { return this->nonvis_; }
    267 
    268   // Set the non-visibility part of the st_other field.
    269   void
    270   set_nonvis(unsigned int nonvis)
    271   { this->nonvis_ = nonvis; }
    272 
    273   // Return whether this symbol is a forwarder.  This will never be
    274   // true of a symbol found in the hash table, but may be true of
    275   // symbol pointers attached to object files.
    276   bool
    277   is_forwarder() const
    278   { return this->is_forwarder_; }
    279 
    280   // Mark this symbol as a forwarder.
    281   void
    282   set_forwarder()
    283   { this->is_forwarder_ = true; }
    284 
    285   // Return whether this symbol has an alias in the weak aliases table
    286   // in Symbol_table.
    287   bool
    288   has_alias() const
    289   { return this->has_alias_; }
    290 
    291   // Mark this symbol as having an alias.
    292   void
    293   set_has_alias()
    294   { this->has_alias_ = true; }
    295 
    296   // Return whether this symbol needs an entry in the dynamic symbol
    297   // table.
    298   bool
    299   needs_dynsym_entry() const
    300   {
    301     return (this->needs_dynsym_entry_
    302             || (this->in_reg()
    303 		&& this->in_dyn()
    304 		&& this->is_externally_visible()));
    305   }
    306 
    307   // Mark this symbol as needing an entry in the dynamic symbol table.
    308   void
    309   set_needs_dynsym_entry()
    310   { this->needs_dynsym_entry_ = true; }
    311 
    312   // Return whether this symbol should be added to the dynamic symbol
    313   // table.
    314   bool
    315   should_add_dynsym_entry(Symbol_table*) const;
    316 
    317   // Return whether this symbol has been seen in a regular object.
    318   bool
    319   in_reg() const
    320   { return this->in_reg_; }
    321 
    322   // Mark this symbol as having been seen in a regular object.
    323   void
    324   set_in_reg()
    325   { this->in_reg_ = true; }
    326 
    327   // Return whether this symbol has been seen in a dynamic object.
    328   bool
    329   in_dyn() const
    330   { return this->in_dyn_; }
    331 
    332   // Mark this symbol as having been seen in a dynamic object.
    333   void
    334   set_in_dyn()
    335   { this->in_dyn_ = true; }
    336 
    337   // Return whether this symbol has been seen in a real ELF object.
    338   // (IN_REG will return TRUE if the symbol has been seen in either
    339   // a real ELF object or an object claimed by a plugin.)
    340   bool
    341   in_real_elf() const
    342   { return this->in_real_elf_; }
    343 
    344   // Mark this symbol as having been seen in a real ELF object.
    345   void
    346   set_in_real_elf()
    347   { this->in_real_elf_ = true; }
    348 
    349   // Return whether this symbol was defined in a section that was
    350   // discarded from the link.  This is used to control some error
    351   // reporting.
    352   bool
    353   is_defined_in_discarded_section() const
    354   { return this->is_defined_in_discarded_section_; }
    355 
    356   // Mark this symbol as having been defined in a discarded section.
    357   void
    358   set_is_defined_in_discarded_section()
    359   { this->is_defined_in_discarded_section_ = true; }
    360 
    361   // Return the index of this symbol in the output file symbol table.
    362   // A value of -1U means that this symbol is not going into the
    363   // output file.  This starts out as zero, and is set to a non-zero
    364   // value by Symbol_table::finalize.  It is an error to ask for the
    365   // symbol table index before it has been set.
    366   unsigned int
    367   symtab_index() const
    368   {
    369     gold_assert(this->symtab_index_ != 0);
    370     return this->symtab_index_;
    371   }
    372 
    373   // Set the index of the symbol in the output file symbol table.
    374   void
    375   set_symtab_index(unsigned int index)
    376   {
    377     gold_assert(index != 0);
    378     this->symtab_index_ = index;
    379   }
    380 
    381   // Return whether this symbol already has an index in the output
    382   // file symbol table.
    383   bool
    384   has_symtab_index() const
    385   { return this->symtab_index_ != 0; }
    386 
    387   // Return the index of this symbol in the dynamic symbol table.  A
    388   // value of -1U means that this symbol is not going into the dynamic
    389   // symbol table.  This starts out as zero, and is set to a non-zero
    390   // during Layout::finalize.  It is an error to ask for the dynamic
    391   // symbol table index before it has been set.
    392   unsigned int
    393   dynsym_index() const
    394   {
    395     gold_assert(this->dynsym_index_ != 0);
    396     return this->dynsym_index_;
    397   }
    398 
    399   // Set the index of the symbol in the dynamic symbol table.
    400   void
    401   set_dynsym_index(unsigned int index)
    402   {
    403     gold_assert(index != 0);
    404     this->dynsym_index_ = index;
    405   }
    406 
    407   // Return whether this symbol already has an index in the dynamic
    408   // symbol table.
    409   bool
    410   has_dynsym_index() const
    411   { return this->dynsym_index_ != 0; }
    412 
    413   // Return whether this symbol has an entry in the GOT section.
    414   // For a TLS symbol, this GOT entry will hold its tp-relative offset.
    415   bool
    416   has_got_offset(unsigned int got_type) const
    417   { return this->got_offsets_.get_offset(got_type) != -1U; }
    418 
    419   // Return the offset into the GOT section of this symbol.
    420   unsigned int
    421   got_offset(unsigned int got_type) const
    422   {
    423     unsigned int got_offset = this->got_offsets_.get_offset(got_type);
    424     gold_assert(got_offset != -1U);
    425     return got_offset;
    426   }
    427 
    428   // Set the GOT offset of this symbol.
    429   void
    430   set_got_offset(unsigned int got_type, unsigned int got_offset)
    431   { this->got_offsets_.set_offset(got_type, got_offset); }
    432 
    433   // Return the GOT offset list.
    434   const Got_offset_list*
    435   got_offset_list() const
    436   { return this->got_offsets_.get_list(); }
    437 
    438   // Return whether this symbol has an entry in the PLT section.
    439   bool
    440   has_plt_offset() const
    441   { return this->plt_offset_ != -1U; }
    442 
    443   // Return the offset into the PLT section of this symbol.
    444   unsigned int
    445   plt_offset() const
    446   {
    447     gold_assert(this->has_plt_offset());
    448     return this->plt_offset_;
    449   }
    450 
    451   // Set the PLT offset of this symbol.
    452   void
    453   set_plt_offset(unsigned int plt_offset)
    454   {
    455     gold_assert(plt_offset != -1U);
    456     this->plt_offset_ = plt_offset;
    457   }
    458 
    459   // Return whether this dynamic symbol needs a special value in the
    460   // dynamic symbol table.
    461   bool
    462   needs_dynsym_value() const
    463   { return this->needs_dynsym_value_; }
    464 
    465   // Set that this dynamic symbol needs a special value in the dynamic
    466   // symbol table.
    467   void
    468   set_needs_dynsym_value()
    469   {
    470     gold_assert(this->object()->is_dynamic());
    471     this->needs_dynsym_value_ = true;
    472   }
    473 
    474   // Return true if the final value of this symbol is known at link
    475   // time.
    476   bool
    477   final_value_is_known() const;
    478 
    479   // Return true if SHNDX represents a common symbol.  This depends on
    480   // the target.
    481   static bool
    482   is_common_shndx(unsigned int shndx);
    483 
    484   // Return whether this is a defined symbol (not undefined or
    485   // common).
    486   bool
    487   is_defined() const
    488   {
    489     bool is_ordinary;
    490     if (this->source_ != FROM_OBJECT)
    491       return this->source_ != IS_UNDEFINED;
    492     unsigned int shndx = this->shndx(&is_ordinary);
    493     return (is_ordinary
    494 	    ? shndx != elfcpp::SHN_UNDEF
    495 	    : !Symbol::is_common_shndx(shndx));
    496   }
    497 
    498   // Return true if this symbol is from a dynamic object.
    499   bool
    500   is_from_dynobj() const
    501   {
    502     return this->source_ == FROM_OBJECT && this->object()->is_dynamic();
    503   }
    504 
    505   // Return whether this is a placeholder symbol from a plugin object.
    506   bool
    507   is_placeholder() const
    508   {
    509     return this->source_ == FROM_OBJECT && this->object()->pluginobj() != NULL;
    510   }
    511 
    512   // Return whether this is an undefined symbol.
    513   bool
    514   is_undefined() const
    515   {
    516     bool is_ordinary;
    517     return ((this->source_ == FROM_OBJECT
    518 	     && this->shndx(&is_ordinary) == elfcpp::SHN_UNDEF
    519 	     && is_ordinary)
    520 	    || this->source_ == IS_UNDEFINED);
    521   }
    522 
    523   // Return whether this is a weak undefined symbol.
    524   bool
    525   is_weak_undefined() const
    526   {
    527     return (this->is_undefined()
    528 	    && (this->binding() == elfcpp::STB_WEAK
    529 		|| this->is_undef_binding_weak()
    530 		|| parameters->options().weak_unresolved_symbols()));
    531   }
    532 
    533   // Return whether this is a strong undefined symbol.
    534   bool
    535   is_strong_undefined() const
    536   {
    537     return (this->is_undefined()
    538 	    && this->binding() != elfcpp::STB_WEAK
    539 	    && !this->is_undef_binding_weak()
    540 	    && !parameters->options().weak_unresolved_symbols());
    541   }
    542 
    543   // Return whether this is an absolute symbol.
    544   bool
    545   is_absolute() const
    546   {
    547     bool is_ordinary;
    548     return ((this->source_ == FROM_OBJECT
    549 	     && this->shndx(&is_ordinary) == elfcpp::SHN_ABS
    550 	     && !is_ordinary)
    551 	    || this->source_ == IS_CONSTANT);
    552   }
    553 
    554   // Return whether this is a common symbol.
    555   bool
    556   is_common() const
    557   {
    558     if (this->source_ != FROM_OBJECT)
    559       return false;
    560     if (this->type_ == elfcpp::STT_COMMON)
    561       return true;
    562     bool is_ordinary;
    563     unsigned int shndx = this->shndx(&is_ordinary);
    564     return !is_ordinary && Symbol::is_common_shndx(shndx);
    565   }
    566 
    567   // Return whether this symbol can be seen outside this object.
    568   bool
    569   is_externally_visible() const
    570   {
    571     return ((this->visibility_ == elfcpp::STV_DEFAULT
    572              || this->visibility_ == elfcpp::STV_PROTECTED)
    573 	    && !this->is_forced_local_);
    574   }
    575 
    576   // Return true if this symbol can be preempted by a definition in
    577   // another link unit.
    578   bool
    579   is_preemptible() const
    580   {
    581     // It doesn't make sense to ask whether a symbol defined in
    582     // another object is preemptible.
    583     gold_assert(!this->is_from_dynobj());
    584 
    585     // It doesn't make sense to ask whether an undefined symbol
    586     // is preemptible.
    587     gold_assert(!this->is_undefined());
    588 
    589     // If a symbol does not have default visibility, it can not be
    590     // seen outside this link unit and therefore is not preemptible.
    591     if (this->visibility_ != elfcpp::STV_DEFAULT)
    592       return false;
    593 
    594     // If this symbol has been forced to be a local symbol by a
    595     // version script, then it is not visible outside this link unit
    596     // and is not preemptible.
    597     if (this->is_forced_local_)
    598       return false;
    599 
    600     // If we are not producing a shared library, then nothing is
    601     // preemptible.
    602     if (!parameters->options().shared())
    603       return false;
    604 
    605     // If the symbol was named in a --dynamic-list script, it is preemptible.
    606     if (parameters->options().in_dynamic_list(this->name()))
    607       return true;
    608 
    609     // If the user used -Bsymbolic, then nothing (else) is preemptible.
    610     if (parameters->options().Bsymbolic())
    611       return false;
    612 
    613     // If the user used -Bsymbolic-functions, then functions are not
    614     // preemptible.  We explicitly check for not being STT_OBJECT,
    615     // rather than for being STT_FUNC, because that is what the GNU
    616     // linker does.
    617     if (this->type() != elfcpp::STT_OBJECT
    618 	&& parameters->options().Bsymbolic_functions())
    619       return false;
    620 
    621     // Otherwise the symbol is preemptible.
    622     return true;
    623   }
    624 
    625   // Return true if this symbol is a function that needs a PLT entry.
    626   bool
    627   needs_plt_entry() const
    628   {
    629     // An undefined symbol from an executable does not need a PLT entry.
    630     if (this->is_undefined() && !parameters->options().shared())
    631       return false;
    632 
    633     // An STT_GNU_IFUNC symbol always needs a PLT entry, even when
    634     // doing a static link.
    635     if (this->type() == elfcpp::STT_GNU_IFUNC)
    636       return true;
    637 
    638     // We only need a PLT entry for a function.
    639     if (!this->is_func())
    640       return false;
    641 
    642     // If we're doing a static link or a -pie link, we don't create
    643     // PLT entries.
    644     if (parameters->doing_static_link()
    645 	|| parameters->options().pie())
    646       return false;
    647 
    648     // We need a PLT entry if the function is defined in a dynamic
    649     // object, or is undefined when building a shared object, or if it
    650     // is subject to pre-emption.
    651     return (this->is_from_dynobj()
    652 	    || this->is_undefined()
    653 	    || this->is_preemptible());
    654   }
    655 
    656   // When determining whether a reference to a symbol needs a dynamic
    657   // relocation, we need to know several things about the reference.
    658   // These flags may be or'ed together.  0 means that the symbol
    659   // isn't referenced at all.
    660   enum Reference_flags
    661   {
    662     // A reference to the symbol's absolute address.  This includes
    663     // references that cause an absolute address to be stored in the GOT.
    664     ABSOLUTE_REF = 1,
    665     // A reference that calculates the offset of the symbol from some
    666     // anchor point, such as the PC or GOT.
    667     RELATIVE_REF = 2,
    668     // A TLS-related reference.
    669     TLS_REF = 4,
    670     // A reference that can always be treated as a function call.
    671     FUNCTION_CALL = 8,
    672     // When set, says that dynamic relocations are needed even if a
    673     // symbol has a plt entry.
    674     FUNC_DESC_ABI = 16,
    675   };
    676 
    677   // Given a direct absolute or pc-relative static relocation against
    678   // the global symbol, this function returns whether a dynamic relocation
    679   // is needed.
    680 
    681   bool
    682   needs_dynamic_reloc(int flags) const
    683   {
    684     // No dynamic relocations in a static link!
    685     if (parameters->doing_static_link())
    686       return false;
    687 
    688     // A reference to an undefined symbol from an executable should be
    689     // statically resolved to 0, and does not need a dynamic relocation.
    690     // This matches gnu ld behavior.
    691     if (this->is_undefined() && !parameters->options().shared())
    692       return false;
    693 
    694     // A reference to an absolute symbol does not need a dynamic relocation.
    695     if (this->is_absolute())
    696       return false;
    697 
    698     // An absolute reference within a position-independent output file
    699     // will need a dynamic relocation.
    700     if ((flags & ABSOLUTE_REF)
    701         && parameters->options().output_is_position_independent())
    702       return true;
    703 
    704     // A function call that can branch to a local PLT entry does not need
    705     // a dynamic relocation.
    706     if ((flags & FUNCTION_CALL) && this->has_plt_offset())
    707       return false;
    708 
    709     // A reference to any PLT entry in a non-position-independent executable
    710     // does not need a dynamic relocation.
    711     if (!(flags & FUNC_DESC_ABI)
    712 	&& !parameters->options().output_is_position_independent()
    713         && this->has_plt_offset())
    714       return false;
    715 
    716     // A reference to a symbol defined in a dynamic object or to a
    717     // symbol that is preemptible will need a dynamic relocation.
    718     if (this->is_from_dynobj()
    719         || this->is_undefined()
    720         || this->is_preemptible())
    721       return true;
    722 
    723     // For all other cases, return FALSE.
    724     return false;
    725   }
    726 
    727   // Whether we should use the PLT offset associated with a symbol for
    728   // a relocation.  FLAGS is a set of Reference_flags.
    729 
    730   bool
    731   use_plt_offset(int flags) const
    732   {
    733     // If the symbol doesn't have a PLT offset, then naturally we
    734     // don't want to use it.
    735     if (!this->has_plt_offset())
    736       return false;
    737 
    738     // For a STT_GNU_IFUNC symbol we always have to use the PLT entry.
    739     if (this->type() == elfcpp::STT_GNU_IFUNC)
    740       return true;
    741 
    742     // If we are going to generate a dynamic relocation, then we will
    743     // wind up using that, so no need to use the PLT entry.
    744     if (this->needs_dynamic_reloc(flags))
    745       return false;
    746 
    747     // If the symbol is from a dynamic object, we need to use the PLT
    748     // entry.
    749     if (this->is_from_dynobj())
    750       return true;
    751 
    752     // If we are generating a shared object, and this symbol is
    753     // undefined or preemptible, we need to use the PLT entry.
    754     if (parameters->options().shared()
    755 	&& (this->is_undefined() || this->is_preemptible()))
    756       return true;
    757 
    758     // If this is a call to a weak undefined symbol, we need to use
    759     // the PLT entry; the symbol may be defined by a library loaded
    760     // at runtime.
    761     if ((flags & FUNCTION_CALL) && this->is_weak_undefined())
    762       return true;
    763 
    764     // Otherwise we can use the regular definition.
    765     return false;
    766   }
    767 
    768   // Given a direct absolute static relocation against
    769   // the global symbol, where a dynamic relocation is needed, this
    770   // function returns whether a relative dynamic relocation can be used.
    771   // The caller must determine separately whether the static relocation
    772   // is compatible with a relative relocation.
    773 
    774   bool
    775   can_use_relative_reloc(bool is_function_call) const
    776   {
    777     // A function call that can branch to a local PLT entry can
    778     // use a RELATIVE relocation.
    779     if (is_function_call && this->has_plt_offset())
    780       return true;
    781 
    782     // A reference to a symbol defined in a dynamic object or to a
    783     // symbol that is preemptible can not use a RELATIVE relocation.
    784     if (this->is_from_dynobj()
    785         || this->is_undefined()
    786         || this->is_preemptible())
    787       return false;
    788 
    789     // For all other cases, return TRUE.
    790     return true;
    791   }
    792 
    793   // Return the output section where this symbol is defined.  Return
    794   // NULL if the symbol has an absolute value.
    795   Output_section*
    796   output_section() const;
    797 
    798   // Set the symbol's output section.  This is used for symbols
    799   // defined in scripts.  This should only be called after the symbol
    800   // table has been finalized.
    801   void
    802   set_output_section(Output_section*);
    803 
    804   // Set the symbol's output segment.  This is used for pre-defined
    805   // symbols whose segments aren't known until after layout is done
    806   // (e.g., __ehdr_start).
    807   void
    808   set_output_segment(Output_segment*, Segment_offset_base);
    809 
    810   // Set the symbol to undefined.  This is used for pre-defined
    811   // symbols whose segments aren't known until after layout is done
    812   // (e.g., __ehdr_start).
    813   void
    814   set_undefined();
    815 
    816   // Return whether there should be a warning for references to this
    817   // symbol.
    818   bool
    819   has_warning() const
    820   { return this->has_warning_; }
    821 
    822   // Mark this symbol as having a warning.
    823   void
    824   set_has_warning()
    825   { this->has_warning_ = true; }
    826 
    827   // Return whether this symbol is defined by a COPY reloc from a
    828   // dynamic object.
    829   bool
    830   is_copied_from_dynobj() const
    831   { return this->is_copied_from_dynobj_; }
    832 
    833   // Mark this symbol as defined by a COPY reloc.
    834   void
    835   set_is_copied_from_dynobj()
    836   { this->is_copied_from_dynobj_ = true; }
    837 
    838   // Return whether this symbol is forced to visibility STB_LOCAL
    839   // by a "local:" entry in a version script.
    840   bool
    841   is_forced_local() const
    842   { return this->is_forced_local_; }
    843 
    844   // Mark this symbol as forced to STB_LOCAL visibility.
    845   void
    846   set_is_forced_local()
    847   { this->is_forced_local_ = true; }
    848 
    849   // Return true if this may need a COPY relocation.
    850   // References from an executable object to non-function symbols
    851   // defined in a dynamic object may need a COPY relocation.
    852   bool
    853   may_need_copy_reloc() const
    854   {
    855     return (parameters->options().copyreloc()
    856 	    && this->is_from_dynobj()
    857 	    && !this->is_func());
    858   }
    859 
    860   // Return true if this symbol was predefined by the linker.
    861   bool
    862   is_predefined() const
    863   { return this->is_predefined_; }
    864 
    865   // Return true if this is a C++ vtable symbol.
    866   bool
    867   is_cxx_vtable() const
    868   { return is_prefix_of("_ZTV", this->name_); }
    869 
    870  protected:
    871   // Instances of this class should always be created at a specific
    872   // size.
    873   Symbol()
    874   { memset(this, 0, sizeof *this); }
    875 
    876   // Initialize the general fields.
    877   void
    878   init_fields(const char* name, const char* version,
    879 	      elfcpp::STT type, elfcpp::STB binding,
    880 	      elfcpp::STV visibility, unsigned char nonvis);
    881 
    882   // Initialize fields from an ELF symbol in OBJECT.  ST_SHNDX is the
    883   // section index, IS_ORDINARY is whether it is a normal section
    884   // index rather than a special code.
    885   template<int size, bool big_endian>
    886   void
    887   init_base_object(const char* name, const char* version, Object* object,
    888 		   const elfcpp::Sym<size, big_endian>&, unsigned int st_shndx,
    889 		   bool is_ordinary);
    890 
    891   // Initialize fields for an Output_data.
    892   void
    893   init_base_output_data(const char* name, const char* version, Output_data*,
    894 			elfcpp::STT, elfcpp::STB, elfcpp::STV,
    895 			unsigned char nonvis, bool offset_is_from_end,
    896 			bool is_predefined);
    897 
    898   // Initialize fields for an Output_segment.
    899   void
    900   init_base_output_segment(const char* name, const char* version,
    901 			   Output_segment* os, elfcpp::STT type,
    902 			   elfcpp::STB binding, elfcpp::STV visibility,
    903 			   unsigned char nonvis,
    904 			   Segment_offset_base offset_base,
    905 			   bool is_predefined);
    906 
    907   // Initialize fields for a constant.
    908   void
    909   init_base_constant(const char* name, const char* version, elfcpp::STT type,
    910 		     elfcpp::STB binding, elfcpp::STV visibility,
    911 		     unsigned char nonvis, bool is_predefined);
    912 
    913   // Initialize fields for an undefined symbol.
    914   void
    915   init_base_undefined(const char* name, const char* version, elfcpp::STT type,
    916 		      elfcpp::STB binding, elfcpp::STV visibility,
    917 		      unsigned char nonvis);
    918 
    919   // Override existing symbol.
    920   template<int size, bool big_endian>
    921   void
    922   override_base(const elfcpp::Sym<size, big_endian>&, unsigned int st_shndx,
    923 		bool is_ordinary, Object* object, const char* version);
    924 
    925   // Override existing symbol with a special symbol.
    926   void
    927   override_base_with_special(const Symbol* from);
    928 
    929   // Override symbol version.
    930   void
    931   override_version(const char* version);
    932 
    933   // Allocate a common symbol by giving it a location in the output
    934   // file.
    935   void
    936   allocate_base_common(Output_data*);
    937 
    938  private:
    939   Symbol(const Symbol&);
    940   Symbol& operator=(const Symbol&);
    941 
    942   // Symbol name (expected to point into a Stringpool).
    943   const char* name_;
    944   // Symbol version (expected to point into a Stringpool).  This may
    945   // be NULL.
    946   const char* version_;
    947 
    948   union
    949   {
    950     // This struct is used if SOURCE_ == FROM_OBJECT.
    951     struct
    952     {
    953       // Object in which symbol is defined, or in which it was first
    954       // seen.
    955       Object* object;
    956       // Section number in object_ in which symbol is defined.
    957       unsigned int shndx;
    958     } from_object;
    959 
    960     // This struct is used if SOURCE_ == IN_OUTPUT_DATA.
    961     struct
    962     {
    963       // Output_data in which symbol is defined.  Before
    964       // Layout::finalize the symbol's value is an offset within the
    965       // Output_data.
    966       Output_data* output_data;
    967       // True if the offset is from the end, false if the offset is
    968       // from the beginning.
    969       bool offset_is_from_end;
    970     } in_output_data;
    971 
    972     // This struct is used if SOURCE_ == IN_OUTPUT_SEGMENT.
    973     struct
    974     {
    975       // Output_segment in which the symbol is defined.  Before
    976       // Layout::finalize the symbol's value is an offset.
    977       Output_segment* output_segment;
    978       // The base to use for the offset before Layout::finalize.
    979       Segment_offset_base offset_base;
    980     } in_output_segment;
    981   } u_;
    982 
    983   // The index of this symbol in the output file.  If the symbol is
    984   // not going into the output file, this value is -1U.  This field
    985   // starts as always holding zero.  It is set to a non-zero value by
    986   // Symbol_table::finalize.
    987   unsigned int symtab_index_;
    988 
    989   // The index of this symbol in the dynamic symbol table.  If the
    990   // symbol is not going into the dynamic symbol table, this value is
    991   // -1U.  This field starts as always holding zero.  It is set to a
    992   // non-zero value during Layout::finalize.
    993   unsigned int dynsym_index_;
    994 
    995   // The GOT section entries for this symbol.  A symbol may have more
    996   // than one GOT offset (e.g., when mixing modules compiled with two
    997   // different TLS models), but will usually have at most one.
    998   Got_offset_list got_offsets_;
    999 
   1000   // If this symbol has an entry in the PLT section, then this is the
   1001   // offset from the start of the PLT section.  This is -1U if there
   1002   // is no PLT entry.
   1003   unsigned int plt_offset_;
   1004 
   1005   // Symbol type (bits 0 to 3).
   1006   elfcpp::STT type_ : 4;
   1007   // Symbol binding (bits 4 to 7).
   1008   elfcpp::STB binding_ : 4;
   1009   // Symbol visibility (bits 8 to 9).
   1010   elfcpp::STV visibility_ : 2;
   1011   // Rest of symbol st_other field (bits 10 to 15).
   1012   unsigned int nonvis_ : 6;
   1013   // The type of symbol (bits 16 to 18).
   1014   Source source_ : 3;
   1015   // True if this is the default version of the symbol (bit 19).
   1016   bool is_def_ : 1;
   1017   // True if this symbol really forwards to another symbol.  This is
   1018   // used when we discover after the fact that two different entries
   1019   // in the hash table really refer to the same symbol.  This will
   1020   // never be set for a symbol found in the hash table, but may be set
   1021   // for a symbol found in the list of symbols attached to an Object.
   1022   // It forwards to the symbol found in the forwarders_ map of
   1023   // Symbol_table (bit 20).
   1024   bool is_forwarder_ : 1;
   1025   // True if the symbol has an alias in the weak_aliases table in
   1026   // Symbol_table (bit 21).
   1027   bool has_alias_ : 1;
   1028   // True if this symbol needs to be in the dynamic symbol table (bit
   1029   // 22).
   1030   bool needs_dynsym_entry_ : 1;
   1031   // True if we've seen this symbol in a regular object (bit 23).
   1032   bool in_reg_ : 1;
   1033   // True if we've seen this symbol in a dynamic object (bit 24).
   1034   bool in_dyn_ : 1;
   1035   // True if this is a dynamic symbol which needs a special value in
   1036   // the dynamic symbol table (bit 25).
   1037   bool needs_dynsym_value_ : 1;
   1038   // True if there is a warning for this symbol (bit 26).
   1039   bool has_warning_ : 1;
   1040   // True if we are using a COPY reloc for this symbol, so that the
   1041   // real definition lives in a dynamic object (bit 27).
   1042   bool is_copied_from_dynobj_ : 1;
   1043   // True if this symbol was forced to local visibility by a version
   1044   // script (bit 28).
   1045   bool is_forced_local_ : 1;
   1046   // True if the field u_.from_object.shndx is an ordinary section
   1047   // index, not one of the special codes from SHN_LORESERVE to
   1048   // SHN_HIRESERVE (bit 29).
   1049   bool is_ordinary_shndx_ : 1;
   1050   // True if we've seen this symbol in a "real" ELF object (bit 30).
   1051   // If the symbol has been seen in a relocatable, non-IR, object file,
   1052   // it's known to be referenced from outside the IR.  A reference from
   1053   // a dynamic object doesn't count as a "real" ELF, and we'll simply
   1054   // mark the symbol as "visible" from outside the IR.  The compiler
   1055   // can use this distinction to guide its handling of COMDAT symbols.
   1056   bool in_real_elf_ : 1;
   1057   // True if this symbol is defined in a section which was discarded
   1058   // (bit 31).
   1059   bool is_defined_in_discarded_section_ : 1;
   1060   // True if UNDEF_BINDING_WEAK_ has been set (bit 32).
   1061   bool undef_binding_set_ : 1;
   1062   // True if this symbol was a weak undef resolved by a dynamic def
   1063   // or by a special symbol (bit 33).
   1064   bool undef_binding_weak_ : 1;
   1065   // True if this symbol is a predefined linker symbol (bit 34).
   1066   bool is_predefined_ : 1;
   1067 };
   1068 
   1069 // The parts of a symbol which are size specific.  Using a template
   1070 // derived class like this helps us use less space on a 32-bit system.
   1071 
   1072 template<int size>
   1073 class Sized_symbol : public Symbol
   1074 {
   1075  public:
   1076   typedef typename elfcpp::Elf_types<size>::Elf_Addr Value_type;
   1077   typedef typename elfcpp::Elf_types<size>::Elf_WXword Size_type;
   1078 
   1079   Sized_symbol()
   1080   { }
   1081 
   1082   // Initialize fields from an ELF symbol in OBJECT.  ST_SHNDX is the
   1083   // section index, IS_ORDINARY is whether it is a normal section
   1084   // index rather than a special code.
   1085   template<bool big_endian>
   1086   void
   1087   init_object(const char* name, const char* version, Object* object,
   1088 	      const elfcpp::Sym<size, big_endian>&, unsigned int st_shndx,
   1089 	      bool is_ordinary);
   1090 
   1091   // Initialize fields for an Output_data.
   1092   void
   1093   init_output_data(const char* name, const char* version, Output_data*,
   1094 		   Value_type value, Size_type symsize, elfcpp::STT,
   1095 		   elfcpp::STB, elfcpp::STV, unsigned char nonvis,
   1096 		   bool offset_is_from_end, bool is_predefined);
   1097 
   1098   // Initialize fields for an Output_segment.
   1099   void
   1100   init_output_segment(const char* name, const char* version, Output_segment*,
   1101 		      Value_type value, Size_type symsize, elfcpp::STT,
   1102 		      elfcpp::STB, elfcpp::STV, unsigned char nonvis,
   1103 		      Segment_offset_base offset_base, bool is_predefined);
   1104 
   1105   // Initialize fields for a constant.
   1106   void
   1107   init_constant(const char* name, const char* version, Value_type value,
   1108 		Size_type symsize, elfcpp::STT, elfcpp::STB, elfcpp::STV,
   1109 		unsigned char nonvis, bool is_predefined);
   1110 
   1111   // Initialize fields for an undefined symbol.
   1112   void
   1113   init_undefined(const char* name, const char* version, elfcpp::STT,
   1114 		 elfcpp::STB, elfcpp::STV, unsigned char nonvis);
   1115 
   1116   // Override existing symbol.
   1117   template<bool big_endian>
   1118   void
   1119   override(const elfcpp::Sym<size, big_endian>&, unsigned int st_shndx,
   1120 	   bool is_ordinary, Object* object, const char* version);
   1121 
   1122   // Override existing symbol with a special symbol.
   1123   void
   1124   override_with_special(const Sized_symbol<size>*);
   1125 
   1126   // Return the symbol's value.
   1127   Value_type
   1128   value() const
   1129   { return this->value_; }
   1130 
   1131   // Return the symbol's size (we can't call this 'size' because that
   1132   // is a template parameter).
   1133   Size_type
   1134   symsize() const
   1135   { return this->symsize_; }
   1136 
   1137   // Set the symbol size.  This is used when resolving common symbols.
   1138   void
   1139   set_symsize(Size_type symsize)
   1140   { this->symsize_ = symsize; }
   1141 
   1142   // Set the symbol value.  This is called when we store the final
   1143   // values of the symbols into the symbol table.
   1144   void
   1145   set_value(Value_type value)
   1146   { this->value_ = value; }
   1147 
   1148   // Allocate a common symbol by giving it a location in the output
   1149   // file.
   1150   void
   1151   allocate_common(Output_data*, Value_type value);
   1152 
   1153  private:
   1154   Sized_symbol(const Sized_symbol&);
   1155   Sized_symbol& operator=(const Sized_symbol&);
   1156 
   1157   // Symbol value.  Before Layout::finalize this is the offset in the
   1158   // input section.  This is set to the final value during
   1159   // Layout::finalize.
   1160   Value_type value_;
   1161   // Symbol size.
   1162   Size_type symsize_;
   1163 };
   1164 
   1165 // A struct describing a symbol defined by the linker, where the value
   1166 // of the symbol is defined based on an output section.  This is used
   1167 // for symbols defined by the linker, like "_init_array_start".
   1168 
   1169 struct Define_symbol_in_section
   1170 {
   1171   // The symbol name.
   1172   const char* name;
   1173   // The name of the output section with which this symbol should be
   1174   // associated.  If there is no output section with that name, the
   1175   // symbol will be defined as zero.
   1176   const char* output_section;
   1177   // The offset of the symbol within the output section.  This is an
   1178   // offset from the start of the output section, unless start_at_end
   1179   // is true, in which case this is an offset from the end of the
   1180   // output section.
   1181   uint64_t value;
   1182   // The size of the symbol.
   1183   uint64_t size;
   1184   // The symbol type.
   1185   elfcpp::STT type;
   1186   // The symbol binding.
   1187   elfcpp::STB binding;
   1188   // The symbol visibility.
   1189   elfcpp::STV visibility;
   1190   // The rest of the st_other field.
   1191   unsigned char nonvis;
   1192   // If true, the value field is an offset from the end of the output
   1193   // section.
   1194   bool offset_is_from_end;
   1195   // If true, this symbol is defined only if we see a reference to it.
   1196   bool only_if_ref;
   1197 };
   1198 
   1199 // A struct describing a symbol defined by the linker, where the value
   1200 // of the symbol is defined based on a segment.  This is used for
   1201 // symbols defined by the linker, like "_end".  We describe the
   1202 // segment with which the symbol should be associated by its
   1203 // characteristics.  If no segment meets these characteristics, the
   1204 // symbol will be defined as zero.  If there is more than one segment
   1205 // which meets these characteristics, we will use the first one.
   1206 
   1207 struct Define_symbol_in_segment
   1208 {
   1209   // The symbol name.
   1210   const char* name;
   1211   // The segment type where the symbol should be defined, typically
   1212   // PT_LOAD.
   1213   elfcpp::PT segment_type;
   1214   // Bitmask of segment flags which must be set.
   1215   elfcpp::PF segment_flags_set;
   1216   // Bitmask of segment flags which must be clear.
   1217   elfcpp::PF segment_flags_clear;
   1218   // The offset of the symbol within the segment.  The offset is
   1219   // calculated from the position set by offset_base.
   1220   uint64_t value;
   1221   // The size of the symbol.
   1222   uint64_t size;
   1223   // The symbol type.
   1224   elfcpp::STT type;
   1225   // The symbol binding.
   1226   elfcpp::STB binding;
   1227   // The symbol visibility.
   1228   elfcpp::STV visibility;
   1229   // The rest of the st_other field.
   1230   unsigned char nonvis;
   1231   // The base from which we compute the offset.
   1232   Symbol::Segment_offset_base offset_base;
   1233   // If true, this symbol is defined only if we see a reference to it.
   1234   bool only_if_ref;
   1235 };
   1236 
   1237 // Specify an object/section/offset location.  Used by ODR code.
   1238 
   1239 struct Symbol_location
   1240 {
   1241   // Object where the symbol is defined.
   1242   Object* object;
   1243   // Section-in-object where the symbol is defined.
   1244   unsigned int shndx;
   1245   // For relocatable objects, offset-in-section where the symbol is defined.
   1246   // For dynamic objects, address where the symbol is defined.
   1247   off_t offset;
   1248   bool operator==(const Symbol_location& that) const
   1249   {
   1250     return (this->object == that.object
   1251 	    && this->shndx == that.shndx
   1252 	    && this->offset == that.offset);
   1253   }
   1254 };
   1255 
   1256 // This class manages warnings.  Warnings are a GNU extension.  When
   1257 // we see a section named .gnu.warning.SYM in an object file, and if
   1258 // we wind using the definition of SYM from that object file, then we
   1259 // will issue a warning for any relocation against SYM from a
   1260 // different object file.  The text of the warning is the contents of
   1261 // the section.  This is not precisely the definition used by the old
   1262 // GNU linker; the old GNU linker treated an occurrence of
   1263 // .gnu.warning.SYM as defining a warning symbol.  A warning symbol
   1264 // would trigger a warning on any reference.  However, it was
   1265 // inconsistent in that a warning in a dynamic object only triggered
   1266 // if there was no definition in a regular object.  This linker is
   1267 // different in that we only issue a warning if we use the symbol
   1268 // definition from the same object file as the warning section.
   1269 
   1270 class Warnings
   1271 {
   1272  public:
   1273   Warnings()
   1274     : warnings_()
   1275   { }
   1276 
   1277   // Add a warning for symbol NAME in object OBJ.  WARNING is the text
   1278   // of the warning.
   1279   void
   1280   add_warning(Symbol_table* symtab, const char* name, Object* obj,
   1281 	      const std::string& warning);
   1282 
   1283   // For each symbol for which we should give a warning, make a note
   1284   // on the symbol.
   1285   void
   1286   note_warnings(Symbol_table* symtab);
   1287 
   1288   // Issue a warning for a reference to SYM at RELINFO's location.
   1289   template<int size, bool big_endian>
   1290   void
   1291   issue_warning(const Symbol* sym, const Relocate_info<size, big_endian>*,
   1292 		size_t relnum, off_t reloffset) const;
   1293 
   1294  private:
   1295   Warnings(const Warnings&);
   1296   Warnings& operator=(const Warnings&);
   1297 
   1298   // What we need to know to get the warning text.
   1299   struct Warning_location
   1300   {
   1301     // The object the warning is in.
   1302     Object* object;
   1303     // The warning text.
   1304     std::string text;
   1305 
   1306     Warning_location()
   1307       : object(NULL), text()
   1308     { }
   1309 
   1310     void
   1311     set(Object* o, const std::string& t)
   1312     {
   1313       this->object = o;
   1314       this->text = t;
   1315     }
   1316   };
   1317 
   1318   // A mapping from warning symbol names (canonicalized in
   1319   // Symbol_table's namepool_ field) to warning information.
   1320   typedef Unordered_map<const char*, Warning_location> Warning_table;
   1321 
   1322   Warning_table warnings_;
   1323 };
   1324 
   1325 // The main linker symbol table.
   1326 
   1327 class Symbol_table
   1328 {
   1329  public:
   1330   // The different places where a symbol definition can come from.
   1331   enum Defined
   1332   {
   1333     // Defined in an object file--the normal case.
   1334     OBJECT,
   1335     // Defined for a COPY reloc.
   1336     COPY,
   1337     // Defined on the command line using --defsym.
   1338     DEFSYM,
   1339     // Defined (so to speak) on the command line using -u.
   1340     UNDEFINED,
   1341     // Defined in a linker script.
   1342     SCRIPT,
   1343     // Predefined by the linker.
   1344     PREDEFINED,
   1345     // Defined by the linker during an incremental base link, but not
   1346     // a predefined symbol (e.g., common, defined in script).
   1347     INCREMENTAL_BASE,
   1348   };
   1349 
   1350   // The order in which we sort common symbols.
   1351   enum Sort_commons_order
   1352   {
   1353     SORT_COMMONS_BY_SIZE_DESCENDING,
   1354     SORT_COMMONS_BY_ALIGNMENT_DESCENDING,
   1355     SORT_COMMONS_BY_ALIGNMENT_ASCENDING
   1356   };
   1357 
   1358   // COUNT is an estimate of how many symbols will be inserted in the
   1359   // symbol table.  It's ok to put 0 if you don't know; a correct
   1360   // guess will just save some CPU by reducing hashtable resizes.
   1361   Symbol_table(unsigned int count, const Version_script_info& version_script);
   1362 
   1363   ~Symbol_table();
   1364 
   1365   void
   1366   set_icf(Icf* icf)
   1367   { this->icf_ = icf;}
   1368 
   1369   Icf*
   1370   icf() const
   1371   { return this->icf_; }
   1372 
   1373   // Returns true if ICF determined that this is a duplicate section.
   1374   bool
   1375   is_section_folded(Object* obj, unsigned int shndx) const;
   1376 
   1377   void
   1378   set_gc(Garbage_collection* gc)
   1379   { this->gc_ = gc; }
   1380 
   1381   Garbage_collection*
   1382   gc() const
   1383   { return this->gc_; }
   1384 
   1385   // During garbage collection, this keeps undefined symbols.
   1386   void
   1387   gc_mark_undef_symbols(Layout*);
   1388 
   1389   // This tells garbage collection that this symbol is referenced.
   1390   void
   1391   gc_mark_symbol(Symbol* sym);
   1392 
   1393   // During garbage collection, this keeps sections that correspond to
   1394   // symbols seen in dynamic objects.
   1395   inline void
   1396   gc_mark_dyn_syms(Symbol* sym);
   1397 
   1398   // Add COUNT external symbols from the relocatable object RELOBJ to
   1399   // the symbol table.  SYMS is the symbols, SYMNDX_OFFSET is the
   1400   // offset in the symbol table of the first symbol, SYM_NAMES is
   1401   // their names, SYM_NAME_SIZE is the size of SYM_NAMES.  This sets
   1402   // SYMPOINTERS to point to the symbols in the symbol table.  It sets
   1403   // *DEFINED to the number of defined symbols.
   1404   template<int size, bool big_endian>
   1405   void
   1406   add_from_relobj(Sized_relobj_file<size, big_endian>* relobj,
   1407 		  const unsigned char* syms, size_t count,
   1408 		  size_t symndx_offset, const char* sym_names,
   1409 		  size_t sym_name_size,
   1410 		  typename Sized_relobj_file<size, big_endian>::Symbols*,
   1411 		  size_t* defined);
   1412 
   1413   // Add one external symbol from the plugin object OBJ to the symbol table.
   1414   // Returns a pointer to the resolved symbol in the symbol table.
   1415   template<int size, bool big_endian>
   1416   Symbol*
   1417   add_from_pluginobj(Sized_pluginobj<size, big_endian>* obj,
   1418                      const char* name, const char* ver,
   1419                      elfcpp::Sym<size, big_endian>* sym);
   1420 
   1421   // Add COUNT dynamic symbols from the dynamic object DYNOBJ to the
   1422   // symbol table.  SYMS is the symbols.  SYM_NAMES is their names.
   1423   // SYM_NAME_SIZE is the size of SYM_NAMES.  The other parameters are
   1424   // symbol version data.
   1425   template<int size, bool big_endian>
   1426   void
   1427   add_from_dynobj(Sized_dynobj<size, big_endian>* dynobj,
   1428 		  const unsigned char* syms, size_t count,
   1429 		  const char* sym_names, size_t sym_name_size,
   1430 		  const unsigned char* versym, size_t versym_size,
   1431 		  const std::vector<const char*>*,
   1432 		  typename Sized_relobj_file<size, big_endian>::Symbols*,
   1433 		  size_t* defined);
   1434 
   1435   // Add one external symbol from the incremental object OBJ to the symbol
   1436   // table.  Returns a pointer to the resolved symbol in the symbol table.
   1437   template<int size, bool big_endian>
   1438   Sized_symbol<size>*
   1439   add_from_incrobj(Object* obj, const char* name,
   1440 		   const char* ver, elfcpp::Sym<size, big_endian>* sym);
   1441 
   1442   // Define a special symbol based on an Output_data.  It is a
   1443   // multiple definition error if this symbol is already defined.
   1444   Symbol*
   1445   define_in_output_data(const char* name, const char* version, Defined,
   1446 			Output_data*, uint64_t value, uint64_t symsize,
   1447 			elfcpp::STT type, elfcpp::STB binding,
   1448 			elfcpp::STV visibility, unsigned char nonvis,
   1449 			bool offset_is_from_end, bool only_if_ref);
   1450 
   1451   // Define a special symbol based on an Output_segment.  It is a
   1452   // multiple definition error if this symbol is already defined.
   1453   Symbol*
   1454   define_in_output_segment(const char* name, const char* version, Defined,
   1455 			   Output_segment*, uint64_t value, uint64_t symsize,
   1456 			   elfcpp::STT type, elfcpp::STB binding,
   1457 			   elfcpp::STV visibility, unsigned char nonvis,
   1458 			   Symbol::Segment_offset_base, bool only_if_ref);
   1459 
   1460   // Define a special symbol with a constant value.  It is a multiple
   1461   // definition error if this symbol is already defined.
   1462   Symbol*
   1463   define_as_constant(const char* name, const char* version, Defined,
   1464 		     uint64_t value, uint64_t symsize, elfcpp::STT type,
   1465 		     elfcpp::STB binding, elfcpp::STV visibility,
   1466 		     unsigned char nonvis, bool only_if_ref,
   1467                      bool force_override);
   1468 
   1469   // Define a set of symbols in output sections.  If ONLY_IF_REF is
   1470   // true, only define them if they are referenced.
   1471   void
   1472   define_symbols(const Layout*, int count, const Define_symbol_in_section*,
   1473 		 bool only_if_ref);
   1474 
   1475   // Define a set of symbols in output segments.  If ONLY_IF_REF is
   1476   // true, only defined them if they are referenced.
   1477   void
   1478   define_symbols(const Layout*, int count, const Define_symbol_in_segment*,
   1479 		 bool only_if_ref);
   1480 
   1481   // Define SYM using a COPY reloc.  POSD is the Output_data where the
   1482   // symbol should be defined--typically a .dyn.bss section.  VALUE is
   1483   // the offset within POSD.
   1484   template<int size>
   1485   void
   1486   define_with_copy_reloc(Sized_symbol<size>* sym, Output_data* posd,
   1487 			 typename elfcpp::Elf_types<size>::Elf_Addr);
   1488 
   1489   // Look up a symbol.
   1490   Symbol*
   1491   lookup(const char*, const char* version = NULL) const;
   1492 
   1493   // Return the real symbol associated with the forwarder symbol FROM.
   1494   Symbol*
   1495   resolve_forwards(const Symbol* from) const;
   1496 
   1497   // Return the sized version of a symbol in this table.
   1498   template<int size>
   1499   Sized_symbol<size>*
   1500   get_sized_symbol(Symbol*) const;
   1501 
   1502   template<int size>
   1503   const Sized_symbol<size>*
   1504   get_sized_symbol(const Symbol*) const;
   1505 
   1506   // Return the count of undefined symbols seen.
   1507   size_t
   1508   saw_undefined() const
   1509   { return this->saw_undefined_; }
   1510 
   1511   // Allocate the common symbols
   1512   void
   1513   allocate_commons(Layout*, Mapfile*);
   1514 
   1515   // Add a warning for symbol NAME in object OBJ.  WARNING is the text
   1516   // of the warning.
   1517   void
   1518   add_warning(const char* name, Object* obj, const std::string& warning)
   1519   { this->warnings_.add_warning(this, name, obj, warning); }
   1520 
   1521   // Canonicalize a symbol name for use in the hash table.
   1522   const char*
   1523   canonicalize_name(const char* name)
   1524   { return this->namepool_.add(name, true, NULL); }
   1525 
   1526   // Possibly issue a warning for a reference to SYM at LOCATION which
   1527   // is in OBJ.
   1528   template<int size, bool big_endian>
   1529   void
   1530   issue_warning(const Symbol* sym,
   1531 		const Relocate_info<size, big_endian>* relinfo,
   1532 		size_t relnum, off_t reloffset) const
   1533   { this->warnings_.issue_warning(sym, relinfo, relnum, reloffset); }
   1534 
   1535   // Check candidate_odr_violations_ to find symbols with the same name
   1536   // but apparently different definitions (different source-file/line-no).
   1537   void
   1538   detect_odr_violations(const Task*, const char* output_file_name) const;
   1539 
   1540   // Add any undefined symbols named on the command line to the symbol
   1541   // table.
   1542   void
   1543   add_undefined_symbols_from_command_line(Layout*);
   1544 
   1545   // SYM is defined using a COPY reloc.  Return the dynamic object
   1546   // where the original definition was found.
   1547   Dynobj*
   1548   get_copy_source(const Symbol* sym) const;
   1549 
   1550   // Set the dynamic symbol indexes.  INDEX is the index of the first
   1551   // global dynamic symbol.  Pointers to the symbols are stored into
   1552   // the vector.  The names are stored into the Stringpool.  This
   1553   // returns an updated dynamic symbol index.
   1554   unsigned int
   1555   set_dynsym_indexes(unsigned int index, std::vector<Symbol*>*,
   1556 		     Stringpool*, Versions*);
   1557 
   1558   // Finalize the symbol table after we have set the final addresses
   1559   // of all the input sections.  This sets the final symbol indexes,
   1560   // values and adds the names to *POOL.  *PLOCAL_SYMCOUNT is the
   1561   // index of the first global symbol.  OFF is the file offset of the
   1562   // global symbol table, DYNOFF is the offset of the globals in the
   1563   // dynamic symbol table, DYN_GLOBAL_INDEX is the index of the first
   1564   // global dynamic symbol, and DYNCOUNT is the number of global
   1565   // dynamic symbols.  This records the parameters, and returns the
   1566   // new file offset.  It updates *PLOCAL_SYMCOUNT if it created any
   1567   // local symbols.
   1568   off_t
   1569   finalize(off_t off, off_t dynoff, size_t dyn_global_index, size_t dyncount,
   1570 	   Stringpool* pool, unsigned int* plocal_symcount);
   1571 
   1572   // Set the final file offset of the symbol table.
   1573   void
   1574   set_file_offset(off_t off)
   1575   { this->offset_ = off; }
   1576 
   1577   // Status code of Symbol_table::compute_final_value.
   1578   enum Compute_final_value_status
   1579   {
   1580     // No error.
   1581     CFVS_OK,
   1582     // Unsupported symbol section.
   1583     CFVS_UNSUPPORTED_SYMBOL_SECTION,
   1584     // No output section.
   1585     CFVS_NO_OUTPUT_SECTION
   1586   };
   1587 
   1588   // Compute the final value of SYM and store status in location PSTATUS.
   1589   // During relaxation, this may be called multiple times for a symbol to
   1590   // compute its would-be final value in each relaxation pass.
   1591 
   1592   template<int size>
   1593   typename Sized_symbol<size>::Value_type
   1594   compute_final_value(const Sized_symbol<size>* sym,
   1595 		      Compute_final_value_status* pstatus) const;
   1596 
   1597   // Return the index of the first global symbol.
   1598   unsigned int
   1599   first_global_index() const
   1600   { return this->first_global_index_; }
   1601 
   1602   // Return the total number of symbols in the symbol table.
   1603   unsigned int
   1604   output_count() const
   1605   { return this->output_count_; }
   1606 
   1607   // Write out the global symbols.
   1608   void
   1609   write_globals(const Stringpool*, const Stringpool*,
   1610 		Output_symtab_xindex*, Output_symtab_xindex*,
   1611 		Output_file*) const;
   1612 
   1613   // Write out a section symbol.  Return the updated offset.
   1614   void
   1615   write_section_symbol(const Output_section*, Output_symtab_xindex*,
   1616 		       Output_file*, off_t) const;
   1617 
   1618   // Loop over all symbols, applying the function F to each.
   1619   template<int size, typename F>
   1620   void
   1621   for_all_symbols(F f) const
   1622   {
   1623     for (Symbol_table_type::const_iterator p = this->table_.begin();
   1624          p != this->table_.end();
   1625          ++p)
   1626       {
   1627 	Sized_symbol<size>* sym = static_cast<Sized_symbol<size>*>(p->second);
   1628 	f(sym);
   1629       }
   1630   }
   1631 
   1632   // Dump statistical information to stderr.
   1633   void
   1634   print_stats() const;
   1635 
   1636   // Return the version script information.
   1637   const Version_script_info&
   1638   version_script() const
   1639   { return version_script_; }
   1640 
   1641  private:
   1642   Symbol_table(const Symbol_table&);
   1643   Symbol_table& operator=(const Symbol_table&);
   1644 
   1645   // The type of the list of common symbols.
   1646   typedef std::vector<Symbol*> Commons_type;
   1647 
   1648   // The type of the symbol hash table.
   1649 
   1650   typedef std::pair<Stringpool::Key, Stringpool::Key> Symbol_table_key;
   1651 
   1652   // The hash function.  The key values are Stringpool keys.
   1653   struct Symbol_table_hash
   1654   {
   1655     inline size_t
   1656     operator()(const Symbol_table_key& key) const
   1657     {
   1658       return key.first ^ key.second;
   1659     }
   1660   };
   1661 
   1662   struct Symbol_table_eq
   1663   {
   1664     bool
   1665     operator()(const Symbol_table_key&, const Symbol_table_key&) const;
   1666   };
   1667 
   1668   typedef Unordered_map<Symbol_table_key, Symbol*, Symbol_table_hash,
   1669 			Symbol_table_eq> Symbol_table_type;
   1670 
   1671   // A map from symbol name (as a pointer into the namepool) to all
   1672   // the locations the symbols is (weakly) defined (and certain other
   1673   // conditions are met).  This map will be used later to detect
   1674   // possible One Definition Rule (ODR) violations.
   1675   struct Symbol_location_hash
   1676   {
   1677     size_t operator()(const Symbol_location& loc) const
   1678     { return reinterpret_cast<uintptr_t>(loc.object) ^ loc.offset ^ loc.shndx; }
   1679   };
   1680 
   1681   typedef Unordered_map<const char*,
   1682                         Unordered_set<Symbol_location, Symbol_location_hash> >
   1683   Odr_map;
   1684 
   1685   // Make FROM a forwarder symbol to TO.
   1686   void
   1687   make_forwarder(Symbol* from, Symbol* to);
   1688 
   1689   // Add a symbol.
   1690   template<int size, bool big_endian>
   1691   Sized_symbol<size>*
   1692   add_from_object(Object*, const char* name, Stringpool::Key name_key,
   1693 		  const char* version, Stringpool::Key version_key,
   1694 		  bool def, const elfcpp::Sym<size, big_endian>& sym,
   1695 		  unsigned int st_shndx, bool is_ordinary,
   1696 		  unsigned int orig_st_shndx);
   1697 
   1698   // Define a default symbol.
   1699   template<int size, bool big_endian>
   1700   void
   1701   define_default_version(Sized_symbol<size>*, bool,
   1702 			 Symbol_table_type::iterator);
   1703 
   1704   // Resolve symbols.
   1705   template<int size, bool big_endian>
   1706   void
   1707   resolve(Sized_symbol<size>* to,
   1708 	  const elfcpp::Sym<size, big_endian>& sym,
   1709 	  unsigned int st_shndx, bool is_ordinary,
   1710 	  unsigned int orig_st_shndx,
   1711 	  Object*, const char* version);
   1712 
   1713   template<int size, bool big_endian>
   1714   void
   1715   resolve(Sized_symbol<size>* to, const Sized_symbol<size>* from);
   1716 
   1717   // Record that a symbol is forced to be local by a version script or
   1718   // by visibility.
   1719   void
   1720   force_local(Symbol*);
   1721 
   1722   // Adjust NAME and *NAME_KEY for wrapping.
   1723   const char*
   1724   wrap_symbol(const char* name, Stringpool::Key* name_key);
   1725 
   1726   // Whether we should override a symbol, based on flags in
   1727   // resolve.cc.
   1728   static bool
   1729   should_override(const Symbol*, unsigned int, elfcpp::STT, Defined,
   1730 		  Object*, bool*, bool*);
   1731 
   1732   // Report a problem in symbol resolution.
   1733   static void
   1734   report_resolve_problem(bool is_error, const char* msg, const Symbol* to,
   1735 			 Defined, Object* object);
   1736 
   1737   // Override a symbol.
   1738   template<int size, bool big_endian>
   1739   void
   1740   override(Sized_symbol<size>* tosym,
   1741 	   const elfcpp::Sym<size, big_endian>& fromsym,
   1742 	   unsigned int st_shndx, bool is_ordinary,
   1743 	   Object* object, const char* version);
   1744 
   1745   // Whether we should override a symbol with a special symbol which
   1746   // is automatically defined by the linker.
   1747   static bool
   1748   should_override_with_special(const Symbol*, elfcpp::STT, Defined);
   1749 
   1750   // Override a symbol with a special symbol.
   1751   template<int size>
   1752   void
   1753   override_with_special(Sized_symbol<size>* tosym,
   1754 			const Sized_symbol<size>* fromsym);
   1755 
   1756   // Record all weak alias sets for a dynamic object.
   1757   template<int size>
   1758   void
   1759   record_weak_aliases(std::vector<Sized_symbol<size>*>*);
   1760 
   1761   // Define a special symbol.
   1762   template<int size, bool big_endian>
   1763   Sized_symbol<size>*
   1764   define_special_symbol(const char** pname, const char** pversion,
   1765 			bool only_if_ref, Sized_symbol<size>** poldsym,
   1766 			bool* resolve_oldsym);
   1767 
   1768   // Define a symbol in an Output_data, sized version.
   1769   template<int size>
   1770   Sized_symbol<size>*
   1771   do_define_in_output_data(const char* name, const char* version, Defined,
   1772 			   Output_data*,
   1773 			   typename elfcpp::Elf_types<size>::Elf_Addr value,
   1774 			   typename elfcpp::Elf_types<size>::Elf_WXword ssize,
   1775 			   elfcpp::STT type, elfcpp::STB binding,
   1776 			   elfcpp::STV visibility, unsigned char nonvis,
   1777 			   bool offset_is_from_end, bool only_if_ref);
   1778 
   1779   // Define a symbol in an Output_segment, sized version.
   1780   template<int size>
   1781   Sized_symbol<size>*
   1782   do_define_in_output_segment(
   1783     const char* name, const char* version, Defined, Output_segment* os,
   1784     typename elfcpp::Elf_types<size>::Elf_Addr value,
   1785     typename elfcpp::Elf_types<size>::Elf_WXword ssize,
   1786     elfcpp::STT type, elfcpp::STB binding,
   1787     elfcpp::STV visibility, unsigned char nonvis,
   1788     Symbol::Segment_offset_base offset_base, bool only_if_ref);
   1789 
   1790   // Define a symbol as a constant, sized version.
   1791   template<int size>
   1792   Sized_symbol<size>*
   1793   do_define_as_constant(
   1794     const char* name, const char* version, Defined,
   1795     typename elfcpp::Elf_types<size>::Elf_Addr value,
   1796     typename elfcpp::Elf_types<size>::Elf_WXword ssize,
   1797     elfcpp::STT type, elfcpp::STB binding,
   1798     elfcpp::STV visibility, unsigned char nonvis,
   1799     bool only_if_ref, bool force_override);
   1800 
   1801   // Add any undefined symbols named on the command line to the symbol
   1802   // table, sized version.
   1803   template<int size>
   1804   void
   1805   do_add_undefined_symbols_from_command_line(Layout*);
   1806 
   1807   // Add one undefined symbol.
   1808   template<int size>
   1809   void
   1810   add_undefined_symbol_from_command_line(const char* name);
   1811 
   1812   // Types of common symbols.
   1813 
   1814   enum Commons_section_type
   1815   {
   1816     COMMONS_NORMAL,
   1817     COMMONS_TLS,
   1818     COMMONS_SMALL,
   1819     COMMONS_LARGE
   1820   };
   1821 
   1822   // Allocate the common symbols, sized version.
   1823   template<int size>
   1824   void
   1825   do_allocate_commons(Layout*, Mapfile*, Sort_commons_order);
   1826 
   1827   // Allocate the common symbols from one list.
   1828   template<int size>
   1829   void
   1830   do_allocate_commons_list(Layout*, Commons_section_type, Commons_type*,
   1831 			   Mapfile*, Sort_commons_order);
   1832 
   1833   // Returns all of the lines attached to LOC, not just the one the
   1834   // instruction actually came from.  This helps the ODR checker avoid
   1835   // false positives.
   1836   static std::vector<std::string>
   1837   linenos_from_loc(const Task* task, const Symbol_location& loc);
   1838 
   1839   // Implement detect_odr_violations.
   1840   template<int size, bool big_endian>
   1841   void
   1842   sized_detect_odr_violations() const;
   1843 
   1844   // Finalize symbols specialized for size.
   1845   template<int size>
   1846   off_t
   1847   sized_finalize(off_t, Stringpool*, unsigned int*);
   1848 
   1849   // Finalize a symbol.  Return whether it should be added to the
   1850   // symbol table.
   1851   template<int size>
   1852   bool
   1853   sized_finalize_symbol(Symbol*);
   1854 
   1855   // Add a symbol the final symtab by setting its index.
   1856   template<int size>
   1857   void
   1858   add_to_final_symtab(Symbol*, Stringpool*, unsigned int* pindex, off_t* poff);
   1859 
   1860   // Write globals specialized for size and endianness.
   1861   template<int size, bool big_endian>
   1862   void
   1863   sized_write_globals(const Stringpool*, const Stringpool*,
   1864 		      Output_symtab_xindex*, Output_symtab_xindex*,
   1865 		      Output_file*) const;
   1866 
   1867   // Write out a symbol to P.
   1868   template<int size, bool big_endian>
   1869   void
   1870   sized_write_symbol(Sized_symbol<size>*,
   1871 		     typename elfcpp::Elf_types<size>::Elf_Addr value,
   1872 		     unsigned int shndx, elfcpp::STB,
   1873 		     const Stringpool*, unsigned char* p) const;
   1874 
   1875   // Possibly warn about an undefined symbol from a dynamic object.
   1876   void
   1877   warn_about_undefined_dynobj_symbol(Symbol*) const;
   1878 
   1879   // Write out a section symbol, specialized for size and endianness.
   1880   template<int size, bool big_endian>
   1881   void
   1882   sized_write_section_symbol(const Output_section*, Output_symtab_xindex*,
   1883 			     Output_file*, off_t) const;
   1884 
   1885   // The type of the list of symbols which have been forced local.
   1886   typedef std::vector<Symbol*> Forced_locals;
   1887 
   1888   // A map from symbols with COPY relocs to the dynamic objects where
   1889   // they are defined.
   1890   typedef Unordered_map<const Symbol*, Dynobj*> Copied_symbol_dynobjs;
   1891 
   1892   // We increment this every time we see a new undefined symbol, for
   1893   // use in archive groups.
   1894   size_t saw_undefined_;
   1895   // The index of the first global symbol in the output file.
   1896   unsigned int first_global_index_;
   1897   // The file offset within the output symtab section where we should
   1898   // write the table.
   1899   off_t offset_;
   1900   // The number of global symbols we want to write out.
   1901   unsigned int output_count_;
   1902   // The file offset of the global dynamic symbols, or 0 if none.
   1903   off_t dynamic_offset_;
   1904   // The index of the first global dynamic symbol.
   1905   unsigned int first_dynamic_global_index_;
   1906   // The number of global dynamic symbols, or 0 if none.
   1907   unsigned int dynamic_count_;
   1908   // The symbol hash table.
   1909   Symbol_table_type table_;
   1910   // A pool of symbol names.  This is used for all global symbols.
   1911   // Entries in the hash table point into this pool.
   1912   Stringpool namepool_;
   1913   // Forwarding symbols.
   1914   Unordered_map<const Symbol*, Symbol*> forwarders_;
   1915   // Weak aliases.  A symbol in this list points to the next alias.
   1916   // The aliases point to each other in a circular list.
   1917   Unordered_map<Symbol*, Symbol*> weak_aliases_;
   1918   // We don't expect there to be very many common symbols, so we keep
   1919   // a list of them.  When we find a common symbol we add it to this
   1920   // list.  It is possible that by the time we process the list the
   1921   // symbol is no longer a common symbol.  It may also have become a
   1922   // forwarder.
   1923   Commons_type commons_;
   1924   // This is like the commons_ field, except that it holds TLS common
   1925   // symbols.
   1926   Commons_type tls_commons_;
   1927   // This is for small common symbols.
   1928   Commons_type small_commons_;
   1929   // This is for large common symbols.
   1930   Commons_type large_commons_;
   1931   // A list of symbols which have been forced to be local.  We don't
   1932   // expect there to be very many of them, so we keep a list of them
   1933   // rather than walking the whole table to find them.
   1934   Forced_locals forced_locals_;
   1935   // Manage symbol warnings.
   1936   Warnings warnings_;
   1937   // Manage potential One Definition Rule (ODR) violations.
   1938   Odr_map candidate_odr_violations_;
   1939 
   1940   // When we emit a COPY reloc for a symbol, we define it in an
   1941   // Output_data.  When it's time to emit version information for it,
   1942   // we need to know the dynamic object in which we found the original
   1943   // definition.  This maps symbols with COPY relocs to the dynamic
   1944   // object where they were defined.
   1945   Copied_symbol_dynobjs copied_symbol_dynobjs_;
   1946   // Information parsed from the version script, if any.
   1947   const Version_script_info& version_script_;
   1948   Garbage_collection* gc_;
   1949   Icf* icf_;
   1950 };
   1951 
   1952 // We inline get_sized_symbol for efficiency.
   1953 
   1954 template<int size>
   1955 Sized_symbol<size>*
   1956 Symbol_table::get_sized_symbol(Symbol* sym) const
   1957 {
   1958   gold_assert(size == parameters->target().get_size());
   1959   return static_cast<Sized_symbol<size>*>(sym);
   1960 }
   1961 
   1962 template<int size>
   1963 const Sized_symbol<size>*
   1964 Symbol_table::get_sized_symbol(const Symbol* sym) const
   1965 {
   1966   gold_assert(size == parameters->target().get_size());
   1967   return static_cast<const Sized_symbol<size>*>(sym);
   1968 }
   1969 
   1970 } // End namespace gold.
   1971 
   1972 #endif // !defined(GOLD_SYMTAB_H)
   1973