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