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