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