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