af272100b947166e6177ea4de3daffc3f7561422
[external/binutils.git] / gold / symtab.cc
1 // symtab.cc -- the gold symbol table
2
3 // Copyright 2006, 2007, 2008, 2009 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 #include "gold.h"
24
25 #include <cstring>
26 #include <stdint.h>
27 #include <algorithm>
28 #include <set>
29 #include <string>
30 #include <utility>
31 #include "demangle.h"
32
33 #include "gc.h"
34 #include "object.h"
35 #include "dwarf_reader.h"
36 #include "dynobj.h"
37 #include "output.h"
38 #include "target.h"
39 #include "workqueue.h"
40 #include "symtab.h"
41 #include "demangle.h"   // needed for --dynamic-list-cpp-new
42 #include "plugin.h"
43
44 namespace gold
45 {
46
47 // Class Symbol.
48
49 // Initialize fields in Symbol.  This initializes everything except u_
50 // and source_.
51
52 void
53 Symbol::init_fields(const char* name, const char* version,
54                     elfcpp::STT type, elfcpp::STB binding,
55                     elfcpp::STV visibility, unsigned char nonvis)
56 {
57   this->name_ = name;
58   this->version_ = version;
59   this->symtab_index_ = 0;
60   this->dynsym_index_ = 0;
61   this->got_offsets_.init();
62   this->plt_offset_ = 0;
63   this->type_ = type;
64   this->binding_ = binding;
65   this->visibility_ = visibility;
66   this->nonvis_ = nonvis;
67   this->is_target_special_ = false;
68   this->is_def_ = false;
69   this->is_forwarder_ = false;
70   this->has_alias_ = false;
71   this->needs_dynsym_entry_ = false;
72   this->in_reg_ = false;
73   this->in_dyn_ = false;
74   this->has_plt_offset_ = false;
75   this->has_warning_ = false;
76   this->is_copied_from_dynobj_ = false;
77   this->is_forced_local_ = false;
78   this->is_ordinary_shndx_ = false;
79   this->in_real_elf_ = false;
80 }
81
82 // Return the demangled version of the symbol's name, but only
83 // if the --demangle flag was set.
84
85 static std::string
86 demangle(const char* name)
87 {
88   if (!parameters->options().do_demangle())
89     return name;
90
91   // cplus_demangle allocates memory for the result it returns,
92   // and returns NULL if the name is already demangled.
93   char* demangled_name = cplus_demangle(name, DMGL_ANSI | DMGL_PARAMS);
94   if (demangled_name == NULL)
95     return name;
96
97   std::string retval(demangled_name);
98   free(demangled_name);
99   return retval;
100 }
101
102 std::string
103 Symbol::demangled_name() const
104 {
105   return demangle(this->name());
106 }
107
108 // Initialize the fields in the base class Symbol for SYM in OBJECT.
109
110 template<int size, bool big_endian>
111 void
112 Symbol::init_base_object(const char* name, const char* version, Object* object,
113                          const elfcpp::Sym<size, big_endian>& sym,
114                          unsigned int st_shndx, bool is_ordinary)
115 {
116   this->init_fields(name, version, sym.get_st_type(), sym.get_st_bind(),
117                     sym.get_st_visibility(), sym.get_st_nonvis());
118   this->u_.from_object.object = object;
119   this->u_.from_object.shndx = st_shndx;
120   this->is_ordinary_shndx_ = is_ordinary;
121   this->source_ = FROM_OBJECT;
122   this->in_reg_ = !object->is_dynamic();
123   this->in_dyn_ = object->is_dynamic();
124   this->in_real_elf_ = object->pluginobj() == NULL;
125 }
126
127 // Initialize the fields in the base class Symbol for a symbol defined
128 // in an Output_data.
129
130 void
131 Symbol::init_base_output_data(const char* name, const char* version,
132                               Output_data* od, elfcpp::STT type,
133                               elfcpp::STB binding, elfcpp::STV visibility,
134                               unsigned char nonvis, bool offset_is_from_end)
135 {
136   this->init_fields(name, version, type, binding, visibility, nonvis);
137   this->u_.in_output_data.output_data = od;
138   this->u_.in_output_data.offset_is_from_end = offset_is_from_end;
139   this->source_ = IN_OUTPUT_DATA;
140   this->in_reg_ = true;
141   this->in_real_elf_ = true;
142 }
143
144 // Initialize the fields in the base class Symbol for a symbol defined
145 // in an Output_segment.
146
147 void
148 Symbol::init_base_output_segment(const char* name, const char* version,
149                                  Output_segment* os, elfcpp::STT type,
150                                  elfcpp::STB binding, elfcpp::STV visibility,
151                                  unsigned char nonvis,
152                                  Segment_offset_base offset_base)
153 {
154   this->init_fields(name, version, type, binding, visibility, nonvis);
155   this->u_.in_output_segment.output_segment = os;
156   this->u_.in_output_segment.offset_base = offset_base;
157   this->source_ = IN_OUTPUT_SEGMENT;
158   this->in_reg_ = true;
159   this->in_real_elf_ = true;
160 }
161
162 // Initialize the fields in the base class Symbol for a symbol defined
163 // as a constant.
164
165 void
166 Symbol::init_base_constant(const char* name, const char* version,
167                            elfcpp::STT type, elfcpp::STB binding,
168                            elfcpp::STV visibility, unsigned char nonvis)
169 {
170   this->init_fields(name, version, type, binding, visibility, nonvis);
171   this->source_ = IS_CONSTANT;
172   this->in_reg_ = true;
173   this->in_real_elf_ = true;
174 }
175
176 // Initialize the fields in the base class Symbol for an undefined
177 // symbol.
178
179 void
180 Symbol::init_base_undefined(const char* name, const char* version,
181                             elfcpp::STT type, elfcpp::STB binding,
182                             elfcpp::STV visibility, unsigned char nonvis)
183 {
184   this->init_fields(name, version, type, binding, visibility, nonvis);
185   this->dynsym_index_ = -1U;
186   this->source_ = IS_UNDEFINED;
187   this->in_reg_ = true;
188   this->in_real_elf_ = true;
189 }
190
191 // Allocate a common symbol in the base.
192
193 void
194 Symbol::allocate_base_common(Output_data* od)
195 {
196   gold_assert(this->is_common());
197   this->source_ = IN_OUTPUT_DATA;
198   this->u_.in_output_data.output_data = od;
199   this->u_.in_output_data.offset_is_from_end = false;
200 }
201
202 // Initialize the fields in Sized_symbol for SYM in OBJECT.
203
204 template<int size>
205 template<bool big_endian>
206 void
207 Sized_symbol<size>::init_object(const char* name, const char* version,
208                                 Object* object,
209                                 const elfcpp::Sym<size, big_endian>& sym,
210                                 unsigned int st_shndx, bool is_ordinary)
211 {
212   this->init_base_object(name, version, object, sym, st_shndx, is_ordinary);
213   this->value_ = sym.get_st_value();
214   this->symsize_ = sym.get_st_size();
215 }
216
217 // Initialize the fields in Sized_symbol for a symbol defined in an
218 // Output_data.
219
220 template<int size>
221 void
222 Sized_symbol<size>::init_output_data(const char* name, const char* version,
223                                      Output_data* od, Value_type value,
224                                      Size_type symsize, elfcpp::STT type,
225                                      elfcpp::STB binding,
226                                      elfcpp::STV visibility,
227                                      unsigned char nonvis,
228                                      bool offset_is_from_end)
229 {
230   this->init_base_output_data(name, version, od, type, binding, visibility,
231                               nonvis, offset_is_from_end);
232   this->value_ = value;
233   this->symsize_ = symsize;
234 }
235
236 // Initialize the fields in Sized_symbol for a symbol defined in an
237 // Output_segment.
238
239 template<int size>
240 void
241 Sized_symbol<size>::init_output_segment(const char* name, const char* version,
242                                         Output_segment* os, Value_type value,
243                                         Size_type symsize, elfcpp::STT type,
244                                         elfcpp::STB binding,
245                                         elfcpp::STV visibility,
246                                         unsigned char nonvis,
247                                         Segment_offset_base offset_base)
248 {
249   this->init_base_output_segment(name, version, os, type, binding, visibility,
250                                  nonvis, offset_base);
251   this->value_ = value;
252   this->symsize_ = symsize;
253 }
254
255 // Initialize the fields in Sized_symbol for a symbol defined as a
256 // constant.
257
258 template<int size>
259 void
260 Sized_symbol<size>::init_constant(const char* name, const char* version,
261                                   Value_type value, Size_type symsize,
262                                   elfcpp::STT type, elfcpp::STB binding,
263                                   elfcpp::STV visibility, unsigned char nonvis)
264 {
265   this->init_base_constant(name, version, type, binding, visibility, nonvis);
266   this->value_ = value;
267   this->symsize_ = symsize;
268 }
269
270 // Initialize the fields in Sized_symbol for an undefined symbol.
271
272 template<int size>
273 void
274 Sized_symbol<size>::init_undefined(const char* name, const char* version,
275                                    elfcpp::STT type, elfcpp::STB binding,
276                                    elfcpp::STV visibility, unsigned char nonvis)
277 {
278   this->init_base_undefined(name, version, type, binding, visibility, nonvis);
279   this->value_ = 0;
280   this->symsize_ = 0;
281 }
282
283 // Return true if SHNDX represents a common symbol.
284
285 bool
286 Symbol::is_common_shndx(unsigned int shndx)
287 {
288   return (shndx == elfcpp::SHN_COMMON
289           || shndx == parameters->target().small_common_shndx()
290           || shndx == parameters->target().large_common_shndx());
291 }
292
293 // Allocate a common symbol.
294
295 template<int size>
296 void
297 Sized_symbol<size>::allocate_common(Output_data* od, Value_type value)
298 {
299   this->allocate_base_common(od);
300   this->value_ = value;
301 }
302
303 // The ""'s around str ensure str is a string literal, so sizeof works.
304 #define strprefix(var, str)   (strncmp(var, str, sizeof("" str "") - 1) == 0)
305
306 // Return true if this symbol should be added to the dynamic symbol
307 // table.
308
309 inline bool
310 Symbol::should_add_dynsym_entry() const
311 {
312   // If the symbol is used by a dynamic relocation, we need to add it.
313   if (this->needs_dynsym_entry())
314     return true;
315
316   // If this symbol's section is not added, the symbol need not be added. 
317   // The section may have been GCed.  Note that export_dynamic is being 
318   // overridden here.  This should not be done for shared objects.
319   if (parameters->options().gc_sections() 
320       && !parameters->options().shared()
321       && this->source() == Symbol::FROM_OBJECT
322       && !this->object()->is_dynamic())
323     {
324       Relobj* relobj = static_cast<Relobj*>(this->object());
325       bool is_ordinary;
326       unsigned int shndx = this->shndx(&is_ordinary);
327       if (is_ordinary && shndx != elfcpp::SHN_UNDEF
328           && !relobj->is_section_included(shndx))
329         return false;
330     }
331
332   // If the symbol was forced local in a version script, do not add it.
333   if (this->is_forced_local())
334     return false;
335
336   // If the symbol was forced dynamic in a --dynamic-list file, add it.
337   if (parameters->options().in_dynamic_list(this->name()))
338     return true;
339
340   // If dynamic-list-data was specified, add any STT_OBJECT.
341   if (parameters->options().dynamic_list_data()
342       && !this->is_from_dynobj()
343       && this->type() == elfcpp::STT_OBJECT)
344     return true;
345
346   // If --dynamic-list-cpp-new was specified, add any new/delete symbol.
347   // If --dynamic-list-cpp-typeinfo was specified, add any typeinfo symbols.
348   if ((parameters->options().dynamic_list_cpp_new()
349        || parameters->options().dynamic_list_cpp_typeinfo())
350       && !this->is_from_dynobj())
351     {
352       // TODO(csilvers): We could probably figure out if we're an operator
353       //                 new/delete or typeinfo without the need to demangle.
354       char* demangled_name = cplus_demangle(this->name(),
355                                             DMGL_ANSI | DMGL_PARAMS);
356       if (demangled_name == NULL)
357         {
358           // Not a C++ symbol, so it can't satisfy these flags
359         }
360       else if (parameters->options().dynamic_list_cpp_new()
361                && (strprefix(demangled_name, "operator new")
362                    || strprefix(demangled_name, "operator delete")))
363         {
364           free(demangled_name);
365           return true;
366         }
367       else if (parameters->options().dynamic_list_cpp_typeinfo()
368                && (strprefix(demangled_name, "typeinfo name for")
369                    || strprefix(demangled_name, "typeinfo for")))
370         {
371           free(demangled_name);
372           return true;
373         }
374       else
375         free(demangled_name);
376     }
377
378   // If exporting all symbols or building a shared library,
379   // and the symbol is defined in a regular object and is
380   // externally visible, we need to add it.
381   if ((parameters->options().export_dynamic() || parameters->options().shared())
382       && !this->is_from_dynobj()
383       && this->is_externally_visible())
384     return true;
385
386   return false;
387 }
388
389 // Return true if the final value of this symbol is known at link
390 // time.
391
392 bool
393 Symbol::final_value_is_known() const
394 {
395   // If we are not generating an executable, then no final values are
396   // known, since they will change at runtime.
397   if (parameters->options().output_is_position_independent()
398       || parameters->options().relocatable())
399     return false;
400
401   // If the symbol is not from an object file, and is not undefined,
402   // then it is defined, and known.
403   if (this->source_ != FROM_OBJECT)
404     {
405       if (this->source_ != IS_UNDEFINED)
406         return true;
407     }
408   else
409     {
410       // If the symbol is from a dynamic object, then the final value
411       // is not known.
412       if (this->object()->is_dynamic())
413         return false;
414
415       // If the symbol is not undefined (it is defined or common),
416       // then the final value is known.
417       if (!this->is_undefined())
418         return true;
419     }
420
421   // If the symbol is undefined, then whether the final value is known
422   // depends on whether we are doing a static link.  If we are doing a
423   // dynamic link, then the final value could be filled in at runtime.
424   // This could reasonably be the case for a weak undefined symbol.
425   return parameters->doing_static_link();
426 }
427
428 // Return the output section where this symbol is defined.
429
430 Output_section*
431 Symbol::output_section() const
432 {
433   switch (this->source_)
434     {
435     case FROM_OBJECT:
436       {
437         unsigned int shndx = this->u_.from_object.shndx;
438         if (shndx != elfcpp::SHN_UNDEF && this->is_ordinary_shndx_)
439           {
440             gold_assert(!this->u_.from_object.object->is_dynamic());
441             gold_assert(this->u_.from_object.object->pluginobj() == NULL);
442             Relobj* relobj = static_cast<Relobj*>(this->u_.from_object.object);
443             return relobj->output_section(shndx);
444           }
445         return NULL;
446       }
447
448     case IN_OUTPUT_DATA:
449       return this->u_.in_output_data.output_data->output_section();
450
451     case IN_OUTPUT_SEGMENT:
452     case IS_CONSTANT:
453     case IS_UNDEFINED:
454       return NULL;
455
456     default:
457       gold_unreachable();
458     }
459 }
460
461 // Set the symbol's output section.  This is used for symbols defined
462 // in scripts.  This should only be called after the symbol table has
463 // been finalized.
464
465 void
466 Symbol::set_output_section(Output_section* os)
467 {
468   switch (this->source_)
469     {
470     case FROM_OBJECT:
471     case IN_OUTPUT_DATA:
472       gold_assert(this->output_section() == os);
473       break;
474     case IS_CONSTANT:
475       this->source_ = IN_OUTPUT_DATA;
476       this->u_.in_output_data.output_data = os;
477       this->u_.in_output_data.offset_is_from_end = false;
478       break;
479     case IN_OUTPUT_SEGMENT:
480     case IS_UNDEFINED:
481     default:
482       gold_unreachable();
483     }
484 }
485
486 // Class Symbol_table.
487
488 Symbol_table::Symbol_table(unsigned int count,
489                            const Version_script_info& version_script)
490   : saw_undefined_(0), offset_(0), table_(count), namepool_(),
491     forwarders_(), commons_(), tls_commons_(), small_commons_(),
492     large_commons_(), forced_locals_(), warnings_(),
493     version_script_(version_script), gc_(NULL), icf_(NULL)
494 {
495   namepool_.reserve(count);
496 }
497
498 Symbol_table::~Symbol_table()
499 {
500 }
501
502 // The hash function.  The key values are Stringpool keys.
503
504 inline size_t
505 Symbol_table::Symbol_table_hash::operator()(const Symbol_table_key& key) const
506 {
507   return key.first ^ key.second;
508 }
509
510 // The symbol table key equality function.  This is called with
511 // Stringpool keys.
512
513 inline bool
514 Symbol_table::Symbol_table_eq::operator()(const Symbol_table_key& k1,
515                                           const Symbol_table_key& k2) const
516 {
517   return k1.first == k2.first && k1.second == k2.second;
518 }
519
520 bool
521 Symbol_table::is_section_folded(Object* obj, unsigned int shndx) const
522 {
523   return (parameters->options().icf_enabled()
524           && this->icf_->is_section_folded(obj, shndx));
525 }
526
527 // For symbols that have been listed with -u option, add them to the
528 // work list to avoid gc'ing them.
529
530 void 
531 Symbol_table::gc_mark_undef_symbols()
532 {
533   for (options::String_set::const_iterator p =
534          parameters->options().undefined_begin();
535        p != parameters->options().undefined_end();
536        ++p)
537     {
538       const char* name = p->c_str();
539       Symbol* sym = this->lookup(name);
540       gold_assert (sym != NULL);
541       if (sym->source() == Symbol::FROM_OBJECT 
542           && !sym->object()->is_dynamic())
543         {
544           Relobj* obj = static_cast<Relobj*>(sym->object());
545           bool is_ordinary;
546           unsigned int shndx = sym->shndx(&is_ordinary);
547           if (is_ordinary)
548             {
549               gold_assert(this->gc_ != NULL);
550               this->gc_->worklist().push(Section_id(obj, shndx));
551             }
552         }
553     }
554 }
555
556 void
557 Symbol_table::gc_mark_symbol_for_shlib(Symbol* sym)
558 {
559   if (!sym->is_from_dynobj() 
560       && sym->is_externally_visible())
561     {
562       //Add the object and section to the work list.
563       Relobj* obj = static_cast<Relobj*>(sym->object());
564       bool is_ordinary;
565       unsigned int shndx = sym->shndx(&is_ordinary);
566       if (is_ordinary && shndx != elfcpp::SHN_UNDEF)
567         {
568           gold_assert(this->gc_!= NULL);
569           this->gc_->worklist().push(Section_id(obj, shndx));
570         }
571     }
572 }
573
574 // When doing garbage collection, keep symbols that have been seen in
575 // dynamic objects.
576 inline void 
577 Symbol_table::gc_mark_dyn_syms(Symbol* sym)
578 {
579   if (sym->in_dyn() && sym->source() == Symbol::FROM_OBJECT
580       && !sym->object()->is_dynamic())
581     {
582       Relobj *obj = static_cast<Relobj*>(sym->object()); 
583       bool is_ordinary;
584       unsigned int shndx = sym->shndx(&is_ordinary);
585       if (is_ordinary && shndx != elfcpp::SHN_UNDEF)
586         {
587           gold_assert(this->gc_ != NULL);
588           this->gc_->worklist().push(Section_id(obj, shndx));
589         }
590     }
591 }
592
593 // Make TO a symbol which forwards to FROM.
594
595 void
596 Symbol_table::make_forwarder(Symbol* from, Symbol* to)
597 {
598   gold_assert(from != to);
599   gold_assert(!from->is_forwarder() && !to->is_forwarder());
600   this->forwarders_[from] = to;
601   from->set_forwarder();
602 }
603
604 // Resolve the forwards from FROM, returning the real symbol.
605
606 Symbol*
607 Symbol_table::resolve_forwards(const Symbol* from) const
608 {
609   gold_assert(from->is_forwarder());
610   Unordered_map<const Symbol*, Symbol*>::const_iterator p =
611     this->forwarders_.find(from);
612   gold_assert(p != this->forwarders_.end());
613   return p->second;
614 }
615
616 // Look up a symbol by name.
617
618 Symbol*
619 Symbol_table::lookup(const char* name, const char* version) const
620 {
621   Stringpool::Key name_key;
622   name = this->namepool_.find(name, &name_key);
623   if (name == NULL)
624     return NULL;
625
626   Stringpool::Key version_key = 0;
627   if (version != NULL)
628     {
629       version = this->namepool_.find(version, &version_key);
630       if (version == NULL)
631         return NULL;
632     }
633
634   Symbol_table_key key(name_key, version_key);
635   Symbol_table::Symbol_table_type::const_iterator p = this->table_.find(key);
636   if (p == this->table_.end())
637     return NULL;
638   return p->second;
639 }
640
641 // Resolve a Symbol with another Symbol.  This is only used in the
642 // unusual case where there are references to both an unversioned
643 // symbol and a symbol with a version, and we then discover that that
644 // version is the default version.  Because this is unusual, we do
645 // this the slow way, by converting back to an ELF symbol.
646
647 template<int size, bool big_endian>
648 void
649 Symbol_table::resolve(Sized_symbol<size>* to, const Sized_symbol<size>* from)
650 {
651   unsigned char buf[elfcpp::Elf_sizes<size>::sym_size];
652   elfcpp::Sym_write<size, big_endian> esym(buf);
653   // We don't bother to set the st_name or the st_shndx field.
654   esym.put_st_value(from->value());
655   esym.put_st_size(from->symsize());
656   esym.put_st_info(from->binding(), from->type());
657   esym.put_st_other(from->visibility(), from->nonvis());
658   bool is_ordinary;
659   unsigned int shndx = from->shndx(&is_ordinary);
660   this->resolve(to, esym.sym(), shndx, is_ordinary, shndx, from->object(),
661                 from->version());
662   if (from->in_reg())
663     to->set_in_reg();
664   if (from->in_dyn())
665     to->set_in_dyn();
666   if (parameters->options().gc_sections())
667     this->gc_mark_dyn_syms(to);
668 }
669
670 // Record that a symbol is forced to be local by a version script or
671 // by visibility.
672
673 void
674 Symbol_table::force_local(Symbol* sym)
675 {
676   if (!sym->is_defined() && !sym->is_common())
677     return;
678   if (sym->is_forced_local())
679     {
680       // We already got this one.
681       return;
682     }
683   sym->set_is_forced_local();
684   this->forced_locals_.push_back(sym);
685 }
686
687 // Adjust NAME for wrapping, and update *NAME_KEY if necessary.  This
688 // is only called for undefined symbols, when at least one --wrap
689 // option was used.
690
691 const char*
692 Symbol_table::wrap_symbol(const char* name, Stringpool::Key* name_key)
693 {
694   // For some targets, we need to ignore a specific character when
695   // wrapping, and add it back later.
696   char prefix = '\0';
697   if (name[0] == parameters->target().wrap_char())
698     {
699       prefix = name[0];
700       ++name;
701     }
702
703   if (parameters->options().is_wrap(name))
704     {
705       // Turn NAME into __wrap_NAME.
706       std::string s;
707       if (prefix != '\0')
708         s += prefix;
709       s += "__wrap_";
710       s += name;
711
712       // This will give us both the old and new name in NAMEPOOL_, but
713       // that is OK.  Only the versions we need will wind up in the
714       // real string table in the output file.
715       return this->namepool_.add(s.c_str(), true, name_key);
716     }
717
718   const char* const real_prefix = "__real_";
719   const size_t real_prefix_length = strlen(real_prefix);
720   if (strncmp(name, real_prefix, real_prefix_length) == 0
721       && parameters->options().is_wrap(name + real_prefix_length))
722     {
723       // Turn __real_NAME into NAME.
724       std::string s;
725       if (prefix != '\0')
726         s += prefix;
727       s += name + real_prefix_length;
728       return this->namepool_.add(s.c_str(), true, name_key);
729     }
730
731   return name;
732 }
733
734 // This is called when we see a symbol NAME/VERSION, and the symbol
735 // already exists in the symbol table, and VERSION is marked as being
736 // the default version.  SYM is the NAME/VERSION symbol we just added.
737 // DEFAULT_IS_NEW is true if this is the first time we have seen the
738 // symbol NAME/NULL.  PDEF points to the entry for NAME/NULL.
739
740 template<int size, bool big_endian>
741 void
742 Symbol_table::define_default_version(Sized_symbol<size>* sym,
743                                      bool default_is_new,
744                                      Symbol_table_type::iterator pdef)
745 {
746   if (default_is_new)
747     {
748       // This is the first time we have seen NAME/NULL.  Make
749       // NAME/NULL point to NAME/VERSION, and mark SYM as the default
750       // version.
751       pdef->second = sym;
752       sym->set_is_default();
753     }
754   else if (pdef->second == sym)
755     {
756       // NAME/NULL already points to NAME/VERSION.  Don't mark the
757       // symbol as the default if it is not already the default.
758     }
759   else
760     {
761       // This is the unfortunate case where we already have entries
762       // for both NAME/VERSION and NAME/NULL.  We now see a symbol
763       // NAME/VERSION where VERSION is the default version.  We have
764       // already resolved this new symbol with the existing
765       // NAME/VERSION symbol.
766
767       // It's possible that NAME/NULL and NAME/VERSION are both
768       // defined in regular objects.  This can only happen if one
769       // object file defines foo and another defines foo@@ver.  This
770       // is somewhat obscure, but we call it a multiple definition
771       // error.
772
773       // It's possible that NAME/NULL actually has a version, in which
774       // case it won't be the same as VERSION.  This happens with
775       // ver_test_7.so in the testsuite for the symbol t2_2.  We see
776       // t2_2@@VER2, so we define both t2_2/VER2 and t2_2/NULL.  We
777       // then see an unadorned t2_2 in an object file and give it
778       // version VER1 from the version script.  This looks like a
779       // default definition for VER1, so it looks like we should merge
780       // t2_2/NULL with t2_2/VER1.  That doesn't make sense, but it's
781       // not obvious that this is an error, either.  So we just punt.
782
783       // If one of the symbols has non-default visibility, and the
784       // other is defined in a shared object, then they are different
785       // symbols.
786
787       // Otherwise, we just resolve the symbols as though they were
788       // the same.
789
790       if (pdef->second->version() != NULL)
791         gold_assert(pdef->second->version() != sym->version());
792       else if (sym->visibility() != elfcpp::STV_DEFAULT
793                && pdef->second->is_from_dynobj())
794         ;
795       else if (pdef->second->visibility() != elfcpp::STV_DEFAULT
796                && sym->is_from_dynobj())
797         ;
798       else
799         {
800           const Sized_symbol<size>* symdef;
801           symdef = this->get_sized_symbol<size>(pdef->second);
802           Symbol_table::resolve<size, big_endian>(sym, symdef);
803           this->make_forwarder(pdef->second, sym);
804           pdef->second = sym;
805           sym->set_is_default();
806         }
807     }
808 }
809
810 // Add one symbol from OBJECT to the symbol table.  NAME is symbol
811 // name and VERSION is the version; both are canonicalized.  DEF is
812 // whether this is the default version.  ST_SHNDX is the symbol's
813 // section index; IS_ORDINARY is whether this is a normal section
814 // rather than a special code.
815
816 // If DEF is true, then this is the definition of a default version of
817 // a symbol.  That means that any lookup of NAME/NULL and any lookup
818 // of NAME/VERSION should always return the same symbol.  This is
819 // obvious for references, but in particular we want to do this for
820 // definitions: overriding NAME/NULL should also override
821 // NAME/VERSION.  If we don't do that, it would be very hard to
822 // override functions in a shared library which uses versioning.
823
824 // We implement this by simply making both entries in the hash table
825 // point to the same Symbol structure.  That is easy enough if this is
826 // the first time we see NAME/NULL or NAME/VERSION, but it is possible
827 // that we have seen both already, in which case they will both have
828 // independent entries in the symbol table.  We can't simply change
829 // the symbol table entry, because we have pointers to the entries
830 // attached to the object files.  So we mark the entry attached to the
831 // object file as a forwarder, and record it in the forwarders_ map.
832 // Note that entries in the hash table will never be marked as
833 // forwarders.
834 //
835 // ORIG_ST_SHNDX and ST_SHNDX are almost always the same.
836 // ORIG_ST_SHNDX is the section index in the input file, or SHN_UNDEF
837 // for a special section code.  ST_SHNDX may be modified if the symbol
838 // is defined in a section being discarded.
839
840 template<int size, bool big_endian>
841 Sized_symbol<size>*
842 Symbol_table::add_from_object(Object* object,
843                               const char *name,
844                               Stringpool::Key name_key,
845                               const char *version,
846                               Stringpool::Key version_key,
847                               bool def,
848                               const elfcpp::Sym<size, big_endian>& sym,
849                               unsigned int st_shndx,
850                               bool is_ordinary,
851                               unsigned int orig_st_shndx)
852 {
853   // Print a message if this symbol is being traced.
854   if (parameters->options().is_trace_symbol(name))
855     {
856       if (orig_st_shndx == elfcpp::SHN_UNDEF)
857         gold_info(_("%s: reference to %s"), object->name().c_str(), name);
858       else
859         gold_info(_("%s: definition of %s"), object->name().c_str(), name);
860     }
861
862   // For an undefined symbol, we may need to adjust the name using
863   // --wrap.
864   if (orig_st_shndx == elfcpp::SHN_UNDEF
865       && parameters->options().any_wrap())
866     {
867       const char* wrap_name = this->wrap_symbol(name, &name_key);
868       if (wrap_name != name)
869         {
870           // If we see a reference to malloc with version GLIBC_2.0,
871           // and we turn it into a reference to __wrap_malloc, then we
872           // discard the version number.  Otherwise the user would be
873           // required to specify the correct version for
874           // __wrap_malloc.
875           version = NULL;
876           version_key = 0;
877           name = wrap_name;
878         }
879     }
880
881   Symbol* const snull = NULL;
882   std::pair<typename Symbol_table_type::iterator, bool> ins =
883     this->table_.insert(std::make_pair(std::make_pair(name_key, version_key),
884                                        snull));
885
886   std::pair<typename Symbol_table_type::iterator, bool> insdef =
887     std::make_pair(this->table_.end(), false);
888   if (def)
889     {
890       const Stringpool::Key vnull_key = 0;
891       insdef = this->table_.insert(std::make_pair(std::make_pair(name_key,
892                                                                  vnull_key),
893                                                   snull));
894     }
895
896   // ins.first: an iterator, which is a pointer to a pair.
897   // ins.first->first: the key (a pair of name and version).
898   // ins.first->second: the value (Symbol*).
899   // ins.second: true if new entry was inserted, false if not.
900
901   Sized_symbol<size>* ret;
902   bool was_undefined;
903   bool was_common;
904   if (!ins.second)
905     {
906       // We already have an entry for NAME/VERSION.
907       ret = this->get_sized_symbol<size>(ins.first->second);
908       gold_assert(ret != NULL);
909
910       was_undefined = ret->is_undefined();
911       was_common = ret->is_common();
912
913       this->resolve(ret, sym, st_shndx, is_ordinary, orig_st_shndx, object,
914                     version);
915       if (parameters->options().gc_sections())
916         this->gc_mark_dyn_syms(ret);
917
918       if (def)
919         this->define_default_version<size, big_endian>(ret, insdef.second,
920                                                        insdef.first);
921     }
922   else
923     {
924       // This is the first time we have seen NAME/VERSION.
925       gold_assert(ins.first->second == NULL);
926
927       if (def && !insdef.second)
928         {
929           // We already have an entry for NAME/NULL.  If we override
930           // it, then change it to NAME/VERSION.
931           ret = this->get_sized_symbol<size>(insdef.first->second);
932
933           was_undefined = ret->is_undefined();
934           was_common = ret->is_common();
935
936           this->resolve(ret, sym, st_shndx, is_ordinary, orig_st_shndx, object,
937                         version);
938           if (parameters->options().gc_sections())
939             this->gc_mark_dyn_syms(ret);
940           ins.first->second = ret;
941         }
942       else
943         {
944           was_undefined = false;
945           was_common = false;
946
947           Sized_target<size, big_endian>* target =
948             parameters->sized_target<size, big_endian>();
949           if (!target->has_make_symbol())
950             ret = new Sized_symbol<size>();
951           else
952             {
953               ret = target->make_symbol();
954               if (ret == NULL)
955                 {
956                   // This means that we don't want a symbol table
957                   // entry after all.
958                   if (!def)
959                     this->table_.erase(ins.first);
960                   else
961                     {
962                       this->table_.erase(insdef.first);
963                       // Inserting insdef invalidated ins.
964                       this->table_.erase(std::make_pair(name_key,
965                                                         version_key));
966                     }
967                   return NULL;
968                 }
969             }
970
971           ret->init_object(name, version, object, sym, st_shndx, is_ordinary);
972
973           ins.first->second = ret;
974           if (def)
975             {
976               // This is the first time we have seen NAME/NULL.  Point
977               // it at the new entry for NAME/VERSION.
978               gold_assert(insdef.second);
979               insdef.first->second = ret;
980             }
981         }
982
983       if (def)
984         ret->set_is_default();
985     }
986
987   // Record every time we see a new undefined symbol, to speed up
988   // archive groups.
989   if (!was_undefined && ret->is_undefined())
990     ++this->saw_undefined_;
991
992   // Keep track of common symbols, to speed up common symbol
993   // allocation.
994   if (!was_common && ret->is_common())
995     {
996       if (ret->type() == elfcpp::STT_TLS)
997         this->tls_commons_.push_back(ret);
998       else if (!is_ordinary
999                && st_shndx == parameters->target().small_common_shndx())
1000         this->small_commons_.push_back(ret);
1001       else if (!is_ordinary
1002                && st_shndx == parameters->target().large_common_shndx())
1003         this->large_commons_.push_back(ret);
1004       else
1005         this->commons_.push_back(ret);
1006     }
1007
1008   // If we're not doing a relocatable link, then any symbol with
1009   // hidden or internal visibility is local.
1010   if ((ret->visibility() == elfcpp::STV_HIDDEN
1011        || ret->visibility() == elfcpp::STV_INTERNAL)
1012       && (ret->binding() == elfcpp::STB_GLOBAL
1013           || ret->binding() == elfcpp::STB_WEAK)
1014       && !parameters->options().relocatable())
1015     this->force_local(ret);
1016
1017   return ret;
1018 }
1019
1020 // Add all the symbols in a relocatable object to the hash table.
1021
1022 template<int size, bool big_endian>
1023 void
1024 Symbol_table::add_from_relobj(
1025     Sized_relobj<size, big_endian>* relobj,
1026     const unsigned char* syms,
1027     size_t count,
1028     size_t symndx_offset,
1029     const char* sym_names,
1030     size_t sym_name_size,
1031     typename Sized_relobj<size, big_endian>::Symbols* sympointers,
1032     size_t *defined)
1033 {
1034   *defined = 0;
1035
1036   gold_assert(size == parameters->target().get_size());
1037
1038   const int sym_size = elfcpp::Elf_sizes<size>::sym_size;
1039
1040   const bool just_symbols = relobj->just_symbols();
1041
1042   const unsigned char* p = syms;
1043   for (size_t i = 0; i < count; ++i, p += sym_size)
1044     {
1045       (*sympointers)[i] = NULL;
1046
1047       elfcpp::Sym<size, big_endian> sym(p);
1048
1049       unsigned int st_name = sym.get_st_name();
1050       if (st_name >= sym_name_size)
1051         {
1052           relobj->error(_("bad global symbol name offset %u at %zu"),
1053                         st_name, i);
1054           continue;
1055         }
1056
1057       const char* name = sym_names + st_name;
1058
1059       bool is_ordinary;
1060       unsigned int st_shndx = relobj->adjust_sym_shndx(i + symndx_offset,
1061                                                        sym.get_st_shndx(),
1062                                                        &is_ordinary);
1063       unsigned int orig_st_shndx = st_shndx;
1064       if (!is_ordinary)
1065         orig_st_shndx = elfcpp::SHN_UNDEF;
1066
1067       if (st_shndx != elfcpp::SHN_UNDEF)
1068         ++*defined;
1069
1070       // A symbol defined in a section which we are not including must
1071       // be treated as an undefined symbol.
1072       if (st_shndx != elfcpp::SHN_UNDEF
1073           && is_ordinary
1074           && !relobj->is_section_included(st_shndx))
1075         st_shndx = elfcpp::SHN_UNDEF;
1076
1077       // In an object file, an '@' in the name separates the symbol
1078       // name from the version name.  If there are two '@' characters,
1079       // this is the default version.
1080       const char* ver = strchr(name, '@');
1081       Stringpool::Key ver_key = 0;
1082       int namelen = 0;
1083       // DEF: is the version default?  LOCAL: is the symbol forced local?
1084       bool def = false;
1085       bool local = false;
1086
1087       if (ver != NULL)
1088         {
1089           // The symbol name is of the form foo@VERSION or foo@@VERSION
1090           namelen = ver - name;
1091           ++ver;
1092           if (*ver == '@')
1093             {
1094               def = true;
1095               ++ver;
1096             }
1097           ver = this->namepool_.add(ver, true, &ver_key);
1098         }
1099       // We don't want to assign a version to an undefined symbol,
1100       // even if it is listed in the version script.  FIXME: What
1101       // about a common symbol?
1102       else
1103         {
1104           namelen = strlen(name);
1105           if (!this->version_script_.empty()
1106               && st_shndx != elfcpp::SHN_UNDEF)
1107             {
1108               // The symbol name did not have a version, but the
1109               // version script may assign a version anyway.
1110               std::string version;
1111               if (this->version_script_.get_symbol_version(name, &version))
1112                 {
1113                   // The version can be empty if the version script is
1114                   // only used to force some symbols to be local.
1115                   if (!version.empty())
1116                     {
1117                       ver = this->namepool_.add_with_length(version.c_str(),
1118                                                             version.length(),
1119                                                             true,
1120                                                             &ver_key);
1121                       def = true;
1122                     }
1123                 }
1124               else if (this->version_script_.symbol_is_local(name))
1125                 local = true;
1126             }
1127         }
1128
1129       elfcpp::Sym<size, big_endian>* psym = &sym;
1130       unsigned char symbuf[sym_size];
1131       elfcpp::Sym<size, big_endian> sym2(symbuf);
1132       if (just_symbols)
1133         {
1134           memcpy(symbuf, p, sym_size);
1135           elfcpp::Sym_write<size, big_endian> sw(symbuf);
1136           if (orig_st_shndx != elfcpp::SHN_UNDEF && is_ordinary)
1137             {
1138               // Symbol values in object files are section relative.
1139               // This is normally what we want, but since here we are
1140               // converting the symbol to absolute we need to add the
1141               // section address.  The section address in an object
1142               // file is normally zero, but people can use a linker
1143               // script to change it.
1144               sw.put_st_value(sym.get_st_value()
1145                               + relobj->section_address(orig_st_shndx));
1146             }
1147           st_shndx = elfcpp::SHN_ABS;
1148           is_ordinary = false;
1149           psym = &sym2;
1150         }
1151
1152       // Fix up visibility if object has no-export set.
1153       if (relobj->no_export())
1154         {
1155           // We may have copied symbol already above.
1156           if (psym != &sym2)
1157             {
1158               memcpy(symbuf, p, sym_size);
1159               psym = &sym2;
1160             }
1161
1162           elfcpp::STV visibility = sym2.get_st_visibility();
1163           if (visibility == elfcpp::STV_DEFAULT
1164               || visibility == elfcpp::STV_PROTECTED)
1165             {
1166               elfcpp::Sym_write<size, big_endian> sw(symbuf);
1167               unsigned char nonvis = sym2.get_st_nonvis();
1168               sw.put_st_other(elfcpp::STV_HIDDEN, nonvis);
1169             }
1170         }
1171
1172       Stringpool::Key name_key;
1173       name = this->namepool_.add_with_length(name, namelen, true,
1174                                              &name_key);
1175
1176       Sized_symbol<size>* res;
1177       res = this->add_from_object(relobj, name, name_key, ver, ver_key,
1178                                   def, *psym, st_shndx, is_ordinary,
1179                                   orig_st_shndx);
1180       
1181       // If building a shared library using garbage collection, do not 
1182       // treat externally visible symbols as garbage.
1183       if (parameters->options().gc_sections() 
1184           && parameters->options().shared())
1185         this->gc_mark_symbol_for_shlib(res);
1186
1187       if (local)
1188         this->force_local(res);
1189
1190       (*sympointers)[i] = res;
1191     }
1192 }
1193
1194 // Add a symbol from a plugin-claimed file.
1195
1196 template<int size, bool big_endian>
1197 Symbol*
1198 Symbol_table::add_from_pluginobj(
1199     Sized_pluginobj<size, big_endian>* obj,
1200     const char* name,
1201     const char* ver,
1202     elfcpp::Sym<size, big_endian>* sym)
1203 {
1204   unsigned int st_shndx = sym->get_st_shndx();
1205   bool is_ordinary = st_shndx < elfcpp::SHN_LORESERVE;
1206
1207   Stringpool::Key ver_key = 0;
1208   bool def = false;
1209   bool local = false;
1210
1211   if (ver != NULL)
1212     {
1213       ver = this->namepool_.add(ver, true, &ver_key);
1214     }
1215   // We don't want to assign a version to an undefined symbol,
1216   // even if it is listed in the version script.  FIXME: What
1217   // about a common symbol?
1218   else
1219     {
1220       if (!this->version_script_.empty()
1221           && st_shndx != elfcpp::SHN_UNDEF)
1222         {
1223           // The symbol name did not have a version, but the
1224           // version script may assign a version anyway.
1225           std::string version;
1226           if (this->version_script_.get_symbol_version(name, &version))
1227             {
1228               // The version can be empty if the version script is
1229               // only used to force some symbols to be local.
1230               if (!version.empty())
1231                 {
1232                   ver = this->namepool_.add_with_length(version.c_str(),
1233                                                         version.length(),
1234                                                         true,
1235                                                         &ver_key);
1236                   def = true;
1237                 }
1238             }
1239           else if (this->version_script_.symbol_is_local(name))
1240             local = true;
1241         }
1242     }
1243
1244   Stringpool::Key name_key;
1245   name = this->namepool_.add(name, true, &name_key);
1246
1247   Sized_symbol<size>* res;
1248   res = this->add_from_object(obj, name, name_key, ver, ver_key,
1249                               def, *sym, st_shndx, is_ordinary, st_shndx);
1250
1251   if (local)
1252     this->force_local(res);
1253
1254   return res;
1255 }
1256
1257 // Add all the symbols in a dynamic object to the hash table.
1258
1259 template<int size, bool big_endian>
1260 void
1261 Symbol_table::add_from_dynobj(
1262     Sized_dynobj<size, big_endian>* dynobj,
1263     const unsigned char* syms,
1264     size_t count,
1265     const char* sym_names,
1266     size_t sym_name_size,
1267     const unsigned char* versym,
1268     size_t versym_size,
1269     const std::vector<const char*>* version_map,
1270     typename Sized_relobj<size, big_endian>::Symbols* sympointers,
1271     size_t* defined)
1272 {
1273   *defined = 0;
1274
1275   gold_assert(size == parameters->target().get_size());
1276
1277   if (dynobj->just_symbols())
1278     {
1279       gold_error(_("--just-symbols does not make sense with a shared object"));
1280       return;
1281     }
1282
1283   if (versym != NULL && versym_size / 2 < count)
1284     {
1285       dynobj->error(_("too few symbol versions"));
1286       return;
1287     }
1288
1289   const int sym_size = elfcpp::Elf_sizes<size>::sym_size;
1290
1291   // We keep a list of all STT_OBJECT symbols, so that we can resolve
1292   // weak aliases.  This is necessary because if the dynamic object
1293   // provides the same variable under two names, one of which is a
1294   // weak definition, and the regular object refers to the weak
1295   // definition, we have to put both the weak definition and the
1296   // strong definition into the dynamic symbol table.  Given a weak
1297   // definition, the only way that we can find the corresponding
1298   // strong definition, if any, is to search the symbol table.
1299   std::vector<Sized_symbol<size>*> object_symbols;
1300
1301   const unsigned char* p = syms;
1302   const unsigned char* vs = versym;
1303   for (size_t i = 0; i < count; ++i, p += sym_size, vs += 2)
1304     {
1305       elfcpp::Sym<size, big_endian> sym(p);
1306
1307       if (sympointers != NULL)
1308         (*sympointers)[i] = NULL;
1309
1310       // Ignore symbols with local binding or that have
1311       // internal or hidden visibility.
1312       if (sym.get_st_bind() == elfcpp::STB_LOCAL
1313           || sym.get_st_visibility() == elfcpp::STV_INTERNAL
1314           || sym.get_st_visibility() == elfcpp::STV_HIDDEN)
1315         continue;
1316
1317       // A protected symbol in a shared library must be treated as a
1318       // normal symbol when viewed from outside the shared library.
1319       // Implement this by overriding the visibility here.
1320       elfcpp::Sym<size, big_endian>* psym = &sym;
1321       unsigned char symbuf[sym_size];
1322       elfcpp::Sym<size, big_endian> sym2(symbuf);
1323       if (sym.get_st_visibility() == elfcpp::STV_PROTECTED)
1324         {
1325           memcpy(symbuf, p, sym_size);
1326           elfcpp::Sym_write<size, big_endian> sw(symbuf);
1327           sw.put_st_other(elfcpp::STV_DEFAULT, sym.get_st_nonvis());
1328           psym = &sym2;
1329         }
1330
1331       unsigned int st_name = psym->get_st_name();
1332       if (st_name >= sym_name_size)
1333         {
1334           dynobj->error(_("bad symbol name offset %u at %zu"),
1335                         st_name, i);
1336           continue;
1337         }
1338
1339       const char* name = sym_names + st_name;
1340
1341       bool is_ordinary;
1342       unsigned int st_shndx = dynobj->adjust_sym_shndx(i, psym->get_st_shndx(),
1343                                                        &is_ordinary);
1344
1345       if (st_shndx != elfcpp::SHN_UNDEF)
1346         ++*defined;
1347
1348       Sized_symbol<size>* res;
1349
1350       if (versym == NULL)
1351         {
1352           Stringpool::Key name_key;
1353           name = this->namepool_.add(name, true, &name_key);
1354           res = this->add_from_object(dynobj, name, name_key, NULL, 0,
1355                                       false, *psym, st_shndx, is_ordinary,
1356                                       st_shndx);
1357         }
1358       else
1359         {
1360           // Read the version information.
1361
1362           unsigned int v = elfcpp::Swap<16, big_endian>::readval(vs);
1363
1364           bool hidden = (v & elfcpp::VERSYM_HIDDEN) != 0;
1365           v &= elfcpp::VERSYM_VERSION;
1366
1367           // The Sun documentation says that V can be VER_NDX_LOCAL,
1368           // or VER_NDX_GLOBAL, or a version index.  The meaning of
1369           // VER_NDX_LOCAL is defined as "Symbol has local scope."
1370           // The old GNU linker will happily generate VER_NDX_LOCAL
1371           // for an undefined symbol.  I don't know what the Sun
1372           // linker will generate.
1373
1374           if (v == static_cast<unsigned int>(elfcpp::VER_NDX_LOCAL)
1375               && st_shndx != elfcpp::SHN_UNDEF)
1376             {
1377               // This symbol should not be visible outside the object.
1378               continue;
1379             }
1380
1381           // At this point we are definitely going to add this symbol.
1382           Stringpool::Key name_key;
1383           name = this->namepool_.add(name, true, &name_key);
1384
1385           if (v == static_cast<unsigned int>(elfcpp::VER_NDX_LOCAL)
1386               || v == static_cast<unsigned int>(elfcpp::VER_NDX_GLOBAL))
1387             {
1388               // This symbol does not have a version.
1389               res = this->add_from_object(dynobj, name, name_key, NULL, 0,
1390                                           false, *psym, st_shndx, is_ordinary,
1391                                           st_shndx);
1392             }
1393           else
1394             {
1395               if (v >= version_map->size())
1396                 {
1397                   dynobj->error(_("versym for symbol %zu out of range: %u"),
1398                                 i, v);
1399                   continue;
1400                 }
1401
1402               const char* version = (*version_map)[v];
1403               if (version == NULL)
1404                 {
1405                   dynobj->error(_("versym for symbol %zu has no name: %u"),
1406                                 i, v);
1407                   continue;
1408                 }
1409
1410               Stringpool::Key version_key;
1411               version = this->namepool_.add(version, true, &version_key);
1412
1413               // If this is an absolute symbol, and the version name
1414               // and symbol name are the same, then this is the
1415               // version definition symbol.  These symbols exist to
1416               // support using -u to pull in particular versions.  We
1417               // do not want to record a version for them.
1418               if (st_shndx == elfcpp::SHN_ABS
1419                   && !is_ordinary
1420                   && name_key == version_key)
1421                 res = this->add_from_object(dynobj, name, name_key, NULL, 0,
1422                                             false, *psym, st_shndx, is_ordinary,
1423                                             st_shndx);
1424               else
1425                 {
1426                   const bool def = (!hidden
1427                                     && st_shndx != elfcpp::SHN_UNDEF);
1428                   res = this->add_from_object(dynobj, name, name_key, version,
1429                                               version_key, def, *psym, st_shndx,
1430                                               is_ordinary, st_shndx);
1431                 }
1432             }
1433         }
1434
1435       // Note that it is possible that RES was overridden by an
1436       // earlier object, in which case it can't be aliased here.
1437       if (st_shndx != elfcpp::SHN_UNDEF
1438           && is_ordinary
1439           && psym->get_st_type() == elfcpp::STT_OBJECT
1440           && res->source() == Symbol::FROM_OBJECT
1441           && res->object() == dynobj)
1442         object_symbols.push_back(res);
1443
1444       if (sympointers != NULL)
1445         (*sympointers)[i] = res;
1446     }
1447
1448   this->record_weak_aliases(&object_symbols);
1449 }
1450
1451 // This is used to sort weak aliases.  We sort them first by section
1452 // index, then by offset, then by weak ahead of strong.
1453
1454 template<int size>
1455 class Weak_alias_sorter
1456 {
1457  public:
1458   bool operator()(const Sized_symbol<size>*, const Sized_symbol<size>*) const;
1459 };
1460
1461 template<int size>
1462 bool
1463 Weak_alias_sorter<size>::operator()(const Sized_symbol<size>* s1,
1464                                     const Sized_symbol<size>* s2) const
1465 {
1466   bool is_ordinary;
1467   unsigned int s1_shndx = s1->shndx(&is_ordinary);
1468   gold_assert(is_ordinary);
1469   unsigned int s2_shndx = s2->shndx(&is_ordinary);
1470   gold_assert(is_ordinary);
1471   if (s1_shndx != s2_shndx)
1472     return s1_shndx < s2_shndx;
1473
1474   if (s1->value() != s2->value())
1475     return s1->value() < s2->value();
1476   if (s1->binding() != s2->binding())
1477     {
1478       if (s1->binding() == elfcpp::STB_WEAK)
1479         return true;
1480       if (s2->binding() == elfcpp::STB_WEAK)
1481         return false;
1482     }
1483   return std::string(s1->name()) < std::string(s2->name());
1484 }
1485
1486 // SYMBOLS is a list of object symbols from a dynamic object.  Look
1487 // for any weak aliases, and record them so that if we add the weak
1488 // alias to the dynamic symbol table, we also add the corresponding
1489 // strong symbol.
1490
1491 template<int size>
1492 void
1493 Symbol_table::record_weak_aliases(std::vector<Sized_symbol<size>*>* symbols)
1494 {
1495   // Sort the vector by section index, then by offset, then by weak
1496   // ahead of strong.
1497   std::sort(symbols->begin(), symbols->end(), Weak_alias_sorter<size>());
1498
1499   // Walk through the vector.  For each weak definition, record
1500   // aliases.
1501   for (typename std::vector<Sized_symbol<size>*>::const_iterator p =
1502          symbols->begin();
1503        p != symbols->end();
1504        ++p)
1505     {
1506       if ((*p)->binding() != elfcpp::STB_WEAK)
1507         continue;
1508
1509       // Build a circular list of weak aliases.  Each symbol points to
1510       // the next one in the circular list.
1511
1512       Sized_symbol<size>* from_sym = *p;
1513       typename std::vector<Sized_symbol<size>*>::const_iterator q;
1514       for (q = p + 1; q != symbols->end(); ++q)
1515         {
1516           bool dummy;
1517           if ((*q)->shndx(&dummy) != from_sym->shndx(&dummy)
1518               || (*q)->value() != from_sym->value())
1519             break;
1520
1521           this->weak_aliases_[from_sym] = *q;
1522           from_sym->set_has_alias();
1523           from_sym = *q;
1524         }
1525
1526       if (from_sym != *p)
1527         {
1528           this->weak_aliases_[from_sym] = *p;
1529           from_sym->set_has_alias();
1530         }
1531
1532       p = q - 1;
1533     }
1534 }
1535
1536 // Create and return a specially defined symbol.  If ONLY_IF_REF is
1537 // true, then only create the symbol if there is a reference to it.
1538 // If this does not return NULL, it sets *POLDSYM to the existing
1539 // symbol if there is one.  This sets *RESOLVE_OLDSYM if we should
1540 // resolve the newly created symbol to the old one.  This
1541 // canonicalizes *PNAME and *PVERSION.
1542
1543 template<int size, bool big_endian>
1544 Sized_symbol<size>*
1545 Symbol_table::define_special_symbol(const char** pname, const char** pversion,
1546                                     bool only_if_ref,
1547                                     Sized_symbol<size>** poldsym,
1548                                     bool *resolve_oldsym)
1549 {
1550   *resolve_oldsym = false;
1551
1552   // If the caller didn't give us a version, see if we get one from
1553   // the version script.
1554   std::string v;
1555   bool is_default_version = false;
1556   if (*pversion == NULL)
1557     {
1558       if (this->version_script_.get_symbol_version(*pname, &v))
1559         {
1560           if (!v.empty())
1561             *pversion = v.c_str();
1562
1563           // If we get the version from a version script, then we are
1564           // also the default version.
1565           is_default_version = true;
1566         }
1567     }
1568
1569   Symbol* oldsym;
1570   Sized_symbol<size>* sym;
1571
1572   bool add_to_table = false;
1573   typename Symbol_table_type::iterator add_loc = this->table_.end();
1574   bool add_def_to_table = false;
1575   typename Symbol_table_type::iterator add_def_loc = this->table_.end();
1576
1577   if (only_if_ref)
1578     {
1579       oldsym = this->lookup(*pname, *pversion);
1580       if (oldsym == NULL && is_default_version)
1581         oldsym = this->lookup(*pname, NULL);
1582       if (oldsym == NULL || !oldsym->is_undefined())
1583         return NULL;
1584
1585       *pname = oldsym->name();
1586       if (!is_default_version)
1587         *pversion = oldsym->version();
1588     }
1589   else
1590     {
1591       // Canonicalize NAME and VERSION.
1592       Stringpool::Key name_key;
1593       *pname = this->namepool_.add(*pname, true, &name_key);
1594
1595       Stringpool::Key version_key = 0;
1596       if (*pversion != NULL)
1597         *pversion = this->namepool_.add(*pversion, true, &version_key);
1598
1599       Symbol* const snull = NULL;
1600       std::pair<typename Symbol_table_type::iterator, bool> ins =
1601         this->table_.insert(std::make_pair(std::make_pair(name_key,
1602                                                           version_key),
1603                                            snull));
1604
1605       std::pair<typename Symbol_table_type::iterator, bool> insdef =
1606         std::make_pair(this->table_.end(), false);
1607       if (is_default_version)
1608         {
1609           const Stringpool::Key vnull = 0;
1610           insdef = this->table_.insert(std::make_pair(std::make_pair(name_key,
1611                                                                      vnull),
1612                                                       snull));
1613         }
1614
1615       if (!ins.second)
1616         {
1617           // We already have a symbol table entry for NAME/VERSION.
1618           oldsym = ins.first->second;
1619           gold_assert(oldsym != NULL);
1620
1621           if (is_default_version)
1622             {
1623               Sized_symbol<size>* soldsym =
1624                 this->get_sized_symbol<size>(oldsym);
1625               this->define_default_version<size, big_endian>(soldsym,
1626                                                              insdef.second,
1627                                                              insdef.first);
1628             }
1629         }
1630       else
1631         {
1632           // We haven't seen this symbol before.
1633           gold_assert(ins.first->second == NULL);
1634
1635           add_to_table = true;
1636           add_loc = ins.first;
1637
1638           if (is_default_version && !insdef.second)
1639             {
1640               // We are adding NAME/VERSION, and it is the default
1641               // version.  We already have an entry for NAME/NULL.
1642               oldsym = insdef.first->second;
1643               *resolve_oldsym = true;
1644             }
1645           else
1646             {
1647               oldsym = NULL;
1648
1649               if (is_default_version)
1650                 {
1651                   add_def_to_table = true;
1652                   add_def_loc = insdef.first;
1653                 }
1654             }
1655         }
1656     }
1657
1658   const Target& target = parameters->target();
1659   if (!target.has_make_symbol())
1660     sym = new Sized_symbol<size>();
1661   else
1662     {
1663       Sized_target<size, big_endian>* sized_target =
1664         parameters->sized_target<size, big_endian>();
1665       sym = sized_target->make_symbol();
1666       if (sym == NULL)
1667         return NULL;
1668     }
1669
1670   if (add_to_table)
1671     add_loc->second = sym;
1672   else
1673     gold_assert(oldsym != NULL);
1674
1675   if (add_def_to_table)
1676     add_def_loc->second = sym;
1677
1678   *poldsym = this->get_sized_symbol<size>(oldsym);
1679
1680   return sym;
1681 }
1682
1683 // Define a symbol based on an Output_data.
1684
1685 Symbol*
1686 Symbol_table::define_in_output_data(const char* name,
1687                                     const char* version,
1688                                     Output_data* od,
1689                                     uint64_t value,
1690                                     uint64_t symsize,
1691                                     elfcpp::STT type,
1692                                     elfcpp::STB binding,
1693                                     elfcpp::STV visibility,
1694                                     unsigned char nonvis,
1695                                     bool offset_is_from_end,
1696                                     bool only_if_ref)
1697 {
1698   if (parameters->target().get_size() == 32)
1699     {
1700 #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG)
1701       return this->do_define_in_output_data<32>(name, version, od,
1702                                                 value, symsize, type, binding,
1703                                                 visibility, nonvis,
1704                                                 offset_is_from_end,
1705                                                 only_if_ref);
1706 #else
1707       gold_unreachable();
1708 #endif
1709     }
1710   else if (parameters->target().get_size() == 64)
1711     {
1712 #if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG)
1713       return this->do_define_in_output_data<64>(name, version, od,
1714                                                 value, symsize, type, binding,
1715                                                 visibility, nonvis,
1716                                                 offset_is_from_end,
1717                                                 only_if_ref);
1718 #else
1719       gold_unreachable();
1720 #endif
1721     }
1722   else
1723     gold_unreachable();
1724 }
1725
1726 // Define a symbol in an Output_data, sized version.
1727
1728 template<int size>
1729 Sized_symbol<size>*
1730 Symbol_table::do_define_in_output_data(
1731     const char* name,
1732     const char* version,
1733     Output_data* od,
1734     typename elfcpp::Elf_types<size>::Elf_Addr value,
1735     typename elfcpp::Elf_types<size>::Elf_WXword symsize,
1736     elfcpp::STT type,
1737     elfcpp::STB binding,
1738     elfcpp::STV visibility,
1739     unsigned char nonvis,
1740     bool offset_is_from_end,
1741     bool only_if_ref)
1742 {
1743   Sized_symbol<size>* sym;
1744   Sized_symbol<size>* oldsym;
1745   bool resolve_oldsym;
1746
1747   if (parameters->target().is_big_endian())
1748     {
1749 #if defined(HAVE_TARGET_32_BIG) || defined(HAVE_TARGET_64_BIG)
1750       sym = this->define_special_symbol<size, true>(&name, &version,
1751                                                     only_if_ref, &oldsym,
1752                                                     &resolve_oldsym);
1753 #else
1754       gold_unreachable();
1755 #endif
1756     }
1757   else
1758     {
1759 #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_64_LITTLE)
1760       sym = this->define_special_symbol<size, false>(&name, &version,
1761                                                      only_if_ref, &oldsym,
1762                                                      &resolve_oldsym);
1763 #else
1764       gold_unreachable();
1765 #endif
1766     }
1767
1768   if (sym == NULL)
1769     return NULL;
1770
1771   sym->init_output_data(name, version, od, value, symsize, type, binding,
1772                         visibility, nonvis, offset_is_from_end);
1773
1774   if (oldsym == NULL)
1775     {
1776       if (binding == elfcpp::STB_LOCAL
1777           || this->version_script_.symbol_is_local(name))
1778         this->force_local(sym);
1779       else if (version != NULL)
1780         sym->set_is_default();
1781       return sym;
1782     }
1783
1784   if (Symbol_table::should_override_with_special(oldsym))
1785     this->override_with_special(oldsym, sym);
1786
1787   if (resolve_oldsym)
1788     return sym;
1789   else
1790     {
1791       delete sym;
1792       return oldsym;
1793     }
1794 }
1795
1796 // Define a symbol based on an Output_segment.
1797
1798 Symbol*
1799 Symbol_table::define_in_output_segment(const char* name,
1800                                        const char* version, Output_segment* os,
1801                                        uint64_t value,
1802                                        uint64_t symsize,
1803                                        elfcpp::STT type,
1804                                        elfcpp::STB binding,
1805                                        elfcpp::STV visibility,
1806                                        unsigned char nonvis,
1807                                        Symbol::Segment_offset_base offset_base,
1808                                        bool only_if_ref)
1809 {
1810   if (parameters->target().get_size() == 32)
1811     {
1812 #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG)
1813       return this->do_define_in_output_segment<32>(name, version, os,
1814                                                    value, symsize, type,
1815                                                    binding, visibility, nonvis,
1816                                                    offset_base, only_if_ref);
1817 #else
1818       gold_unreachable();
1819 #endif
1820     }
1821   else if (parameters->target().get_size() == 64)
1822     {
1823 #if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG)
1824       return this->do_define_in_output_segment<64>(name, version, os,
1825                                                    value, symsize, type,
1826                                                    binding, visibility, nonvis,
1827                                                    offset_base, only_if_ref);
1828 #else
1829       gold_unreachable();
1830 #endif
1831     }
1832   else
1833     gold_unreachable();
1834 }
1835
1836 // Define a symbol in an Output_segment, sized version.
1837
1838 template<int size>
1839 Sized_symbol<size>*
1840 Symbol_table::do_define_in_output_segment(
1841     const char* name,
1842     const char* version,
1843     Output_segment* os,
1844     typename elfcpp::Elf_types<size>::Elf_Addr value,
1845     typename elfcpp::Elf_types<size>::Elf_WXword symsize,
1846     elfcpp::STT type,
1847     elfcpp::STB binding,
1848     elfcpp::STV visibility,
1849     unsigned char nonvis,
1850     Symbol::Segment_offset_base offset_base,
1851     bool only_if_ref)
1852 {
1853   Sized_symbol<size>* sym;
1854   Sized_symbol<size>* oldsym;
1855   bool resolve_oldsym;
1856
1857   if (parameters->target().is_big_endian())
1858     {
1859 #if defined(HAVE_TARGET_32_BIG) || defined(HAVE_TARGET_64_BIG)
1860       sym = this->define_special_symbol<size, true>(&name, &version,
1861                                                     only_if_ref, &oldsym,
1862                                                     &resolve_oldsym);
1863 #else
1864       gold_unreachable();
1865 #endif
1866     }
1867   else
1868     {
1869 #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_64_LITTLE)
1870       sym = this->define_special_symbol<size, false>(&name, &version,
1871                                                      only_if_ref, &oldsym,
1872                                                      &resolve_oldsym);
1873 #else
1874       gold_unreachable();
1875 #endif
1876     }
1877
1878   if (sym == NULL)
1879     return NULL;
1880
1881   sym->init_output_segment(name, version, os, value, symsize, type, binding,
1882                            visibility, nonvis, offset_base);
1883
1884   if (oldsym == NULL)
1885     {
1886       if (binding == elfcpp::STB_LOCAL
1887           || this->version_script_.symbol_is_local(name))
1888         this->force_local(sym);
1889       else if (version != NULL)
1890         sym->set_is_default();
1891       return sym;
1892     }
1893
1894   if (Symbol_table::should_override_with_special(oldsym))
1895     this->override_with_special(oldsym, sym);
1896
1897   if (resolve_oldsym)
1898     return sym;
1899   else
1900     {
1901       delete sym;
1902       return oldsym;
1903     }
1904 }
1905
1906 // Define a special symbol with a constant value.  It is a multiple
1907 // definition error if this symbol is already defined.
1908
1909 Symbol*
1910 Symbol_table::define_as_constant(const char* name,
1911                                  const char* version,
1912                                  uint64_t value,
1913                                  uint64_t symsize,
1914                                  elfcpp::STT type,
1915                                  elfcpp::STB binding,
1916                                  elfcpp::STV visibility,
1917                                  unsigned char nonvis,
1918                                  bool only_if_ref,
1919                                  bool force_override)
1920 {
1921   if (parameters->target().get_size() == 32)
1922     {
1923 #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG)
1924       return this->do_define_as_constant<32>(name, version, value,
1925                                              symsize, type, binding,
1926                                              visibility, nonvis, only_if_ref,
1927                                              force_override);
1928 #else
1929       gold_unreachable();
1930 #endif
1931     }
1932   else if (parameters->target().get_size() == 64)
1933     {
1934 #if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG)
1935       return this->do_define_as_constant<64>(name, version, value,
1936                                              symsize, type, binding,
1937                                              visibility, nonvis, only_if_ref,
1938                                              force_override);
1939 #else
1940       gold_unreachable();
1941 #endif
1942     }
1943   else
1944     gold_unreachable();
1945 }
1946
1947 // Define a symbol as a constant, sized version.
1948
1949 template<int size>
1950 Sized_symbol<size>*
1951 Symbol_table::do_define_as_constant(
1952     const char* name,
1953     const char* version,
1954     typename elfcpp::Elf_types<size>::Elf_Addr value,
1955     typename elfcpp::Elf_types<size>::Elf_WXword symsize,
1956     elfcpp::STT type,
1957     elfcpp::STB binding,
1958     elfcpp::STV visibility,
1959     unsigned char nonvis,
1960     bool only_if_ref,
1961     bool force_override)
1962 {
1963   Sized_symbol<size>* sym;
1964   Sized_symbol<size>* oldsym;
1965   bool resolve_oldsym;
1966
1967   if (parameters->target().is_big_endian())
1968     {
1969 #if defined(HAVE_TARGET_32_BIG) || defined(HAVE_TARGET_64_BIG)
1970       sym = this->define_special_symbol<size, true>(&name, &version,
1971                                                     only_if_ref, &oldsym,
1972                                                     &resolve_oldsym);
1973 #else
1974       gold_unreachable();
1975 #endif
1976     }
1977   else
1978     {
1979 #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_64_LITTLE)
1980       sym = this->define_special_symbol<size, false>(&name, &version,
1981                                                      only_if_ref, &oldsym,
1982                                                      &resolve_oldsym);
1983 #else
1984       gold_unreachable();
1985 #endif
1986     }
1987
1988   if (sym == NULL)
1989     return NULL;
1990
1991   sym->init_constant(name, version, value, symsize, type, binding, visibility,
1992                      nonvis);
1993
1994   if (oldsym == NULL)
1995     {
1996       // Version symbols are absolute symbols with name == version.
1997       // We don't want to force them to be local.
1998       if ((version == NULL
1999            || name != version
2000            || value != 0)
2001           && (binding == elfcpp::STB_LOCAL
2002               || this->version_script_.symbol_is_local(name)))
2003         this->force_local(sym);
2004       else if (version != NULL
2005                && (name != version || value != 0))
2006         sym->set_is_default();
2007       return sym;
2008     }
2009
2010   if (force_override || Symbol_table::should_override_with_special(oldsym))
2011     this->override_with_special(oldsym, sym);
2012
2013   if (resolve_oldsym)
2014     return sym;
2015   else
2016     {
2017       delete sym;
2018       return oldsym;
2019     }
2020 }
2021
2022 // Define a set of symbols in output sections.
2023
2024 void
2025 Symbol_table::define_symbols(const Layout* layout, int count,
2026                              const Define_symbol_in_section* p,
2027                              bool only_if_ref)
2028 {
2029   for (int i = 0; i < count; ++i, ++p)
2030     {
2031       Output_section* os = layout->find_output_section(p->output_section);
2032       if (os != NULL)
2033         this->define_in_output_data(p->name, NULL, os, p->value,
2034                                     p->size, p->type, p->binding,
2035                                     p->visibility, p->nonvis,
2036                                     p->offset_is_from_end,
2037                                     only_if_ref || p->only_if_ref);
2038       else
2039         this->define_as_constant(p->name, NULL, 0, p->size, p->type,
2040                                  p->binding, p->visibility, p->nonvis,
2041                                  only_if_ref || p->only_if_ref,
2042                                  false);
2043     }
2044 }
2045
2046 // Define a set of symbols in output segments.
2047
2048 void
2049 Symbol_table::define_symbols(const Layout* layout, int count,
2050                              const Define_symbol_in_segment* p,
2051                              bool only_if_ref)
2052 {
2053   for (int i = 0; i < count; ++i, ++p)
2054     {
2055       Output_segment* os = layout->find_output_segment(p->segment_type,
2056                                                        p->segment_flags_set,
2057                                                        p->segment_flags_clear);
2058       if (os != NULL)
2059         this->define_in_output_segment(p->name, NULL, os, p->value,
2060                                        p->size, p->type, p->binding,
2061                                        p->visibility, p->nonvis,
2062                                        p->offset_base,
2063                                        only_if_ref || p->only_if_ref);
2064       else
2065         this->define_as_constant(p->name, NULL, 0, p->size, p->type,
2066                                  p->binding, p->visibility, p->nonvis,
2067                                  only_if_ref || p->only_if_ref,
2068                                  false);
2069     }
2070 }
2071
2072 // Define CSYM using a COPY reloc.  POSD is the Output_data where the
2073 // symbol should be defined--typically a .dyn.bss section.  VALUE is
2074 // the offset within POSD.
2075
2076 template<int size>
2077 void
2078 Symbol_table::define_with_copy_reloc(
2079     Sized_symbol<size>* csym,
2080     Output_data* posd,
2081     typename elfcpp::Elf_types<size>::Elf_Addr value)
2082 {
2083   gold_assert(csym->is_from_dynobj());
2084   gold_assert(!csym->is_copied_from_dynobj());
2085   Object* object = csym->object();
2086   gold_assert(object->is_dynamic());
2087   Dynobj* dynobj = static_cast<Dynobj*>(object);
2088
2089   // Our copied variable has to override any variable in a shared
2090   // library.
2091   elfcpp::STB binding = csym->binding();
2092   if (binding == elfcpp::STB_WEAK)
2093     binding = elfcpp::STB_GLOBAL;
2094
2095   this->define_in_output_data(csym->name(), csym->version(),
2096                               posd, value, csym->symsize(),
2097                               csym->type(), binding,
2098                               csym->visibility(), csym->nonvis(),
2099                               false, false);
2100
2101   csym->set_is_copied_from_dynobj();
2102   csym->set_needs_dynsym_entry();
2103
2104   this->copied_symbol_dynobjs_[csym] = dynobj;
2105
2106   // We have now defined all aliases, but we have not entered them all
2107   // in the copied_symbol_dynobjs_ map.
2108   if (csym->has_alias())
2109     {
2110       Symbol* sym = csym;
2111       while (true)
2112         {
2113           sym = this->weak_aliases_[sym];
2114           if (sym == csym)
2115             break;
2116           gold_assert(sym->output_data() == posd);
2117
2118           sym->set_is_copied_from_dynobj();
2119           this->copied_symbol_dynobjs_[sym] = dynobj;
2120         }
2121     }
2122 }
2123
2124 // SYM is defined using a COPY reloc.  Return the dynamic object where
2125 // the original definition was found.
2126
2127 Dynobj*
2128 Symbol_table::get_copy_source(const Symbol* sym) const
2129 {
2130   gold_assert(sym->is_copied_from_dynobj());
2131   Copied_symbol_dynobjs::const_iterator p =
2132     this->copied_symbol_dynobjs_.find(sym);
2133   gold_assert(p != this->copied_symbol_dynobjs_.end());
2134   return p->second;
2135 }
2136
2137 // Add any undefined symbols named on the command line.
2138
2139 void
2140 Symbol_table::add_undefined_symbols_from_command_line()
2141 {
2142   if (parameters->options().any_undefined())
2143     {
2144       if (parameters->target().get_size() == 32)
2145         {
2146 #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG)
2147           this->do_add_undefined_symbols_from_command_line<32>();
2148 #else
2149           gold_unreachable();
2150 #endif
2151         }
2152       else if (parameters->target().get_size() == 64)
2153         {
2154 #if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG)
2155           this->do_add_undefined_symbols_from_command_line<64>();
2156 #else
2157           gold_unreachable();
2158 #endif
2159         }
2160       else
2161         gold_unreachable();
2162     }
2163 }
2164
2165 template<int size>
2166 void
2167 Symbol_table::do_add_undefined_symbols_from_command_line()
2168 {
2169   for (options::String_set::const_iterator p =
2170          parameters->options().undefined_begin();
2171        p != parameters->options().undefined_end();
2172        ++p)
2173     {
2174       const char* name = p->c_str();
2175
2176       if (this->lookup(name) != NULL)
2177         continue;
2178
2179       const char* version = NULL;
2180
2181       Sized_symbol<size>* sym;
2182       Sized_symbol<size>* oldsym;
2183       bool resolve_oldsym;
2184       if (parameters->target().is_big_endian())
2185         {
2186 #if defined(HAVE_TARGET_32_BIG) || defined(HAVE_TARGET_64_BIG)
2187           sym = this->define_special_symbol<size, true>(&name, &version,
2188                                                         false, &oldsym,
2189                                                         &resolve_oldsym);
2190 #else
2191           gold_unreachable();
2192 #endif
2193         }
2194       else
2195         {
2196 #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_64_LITTLE)
2197           sym = this->define_special_symbol<size, false>(&name, &version,
2198                                                          false, &oldsym,
2199                                                          &resolve_oldsym);
2200 #else
2201           gold_unreachable();
2202 #endif
2203         }
2204
2205       gold_assert(oldsym == NULL);
2206
2207       sym->init_undefined(name, version, elfcpp::STT_NOTYPE, elfcpp::STB_GLOBAL,
2208                           elfcpp::STV_DEFAULT, 0);
2209       ++this->saw_undefined_;
2210     }
2211 }
2212
2213 // Set the dynamic symbol indexes.  INDEX is the index of the first
2214 // global dynamic symbol.  Pointers to the symbols are stored into the
2215 // vector SYMS.  The names are added to DYNPOOL.  This returns an
2216 // updated dynamic symbol index.
2217
2218 unsigned int
2219 Symbol_table::set_dynsym_indexes(unsigned int index,
2220                                  std::vector<Symbol*>* syms,
2221                                  Stringpool* dynpool,
2222                                  Versions* versions)
2223 {
2224   for (Symbol_table_type::iterator p = this->table_.begin();
2225        p != this->table_.end();
2226        ++p)
2227     {
2228       Symbol* sym = p->second;
2229
2230       // Note that SYM may already have a dynamic symbol index, since
2231       // some symbols appear more than once in the symbol table, with
2232       // and without a version.
2233
2234       if (!sym->should_add_dynsym_entry())
2235         sym->set_dynsym_index(-1U);
2236       else if (!sym->has_dynsym_index())
2237         {
2238           sym->set_dynsym_index(index);
2239           ++index;
2240           syms->push_back(sym);
2241           dynpool->add(sym->name(), false, NULL);
2242
2243           // Record any version information.
2244           if (sym->version() != NULL)
2245             versions->record_version(this, dynpool, sym);
2246         }
2247     }
2248
2249   // Finish up the versions.  In some cases this may add new dynamic
2250   // symbols.
2251   index = versions->finalize(this, index, syms);
2252
2253   return index;
2254 }
2255
2256 // Set the final values for all the symbols.  The index of the first
2257 // global symbol in the output file is *PLOCAL_SYMCOUNT.  Record the
2258 // file offset OFF.  Add their names to POOL.  Return the new file
2259 // offset.  Update *PLOCAL_SYMCOUNT if necessary.
2260
2261 off_t
2262 Symbol_table::finalize(off_t off, off_t dynoff, size_t dyn_global_index,
2263                        size_t dyncount, Stringpool* pool,
2264                        unsigned int *plocal_symcount)
2265 {
2266   off_t ret;
2267
2268   gold_assert(*plocal_symcount != 0);
2269   this->first_global_index_ = *plocal_symcount;
2270
2271   this->dynamic_offset_ = dynoff;
2272   this->first_dynamic_global_index_ = dyn_global_index;
2273   this->dynamic_count_ = dyncount;
2274
2275   if (parameters->target().get_size() == 32)
2276     {
2277 #if defined(HAVE_TARGET_32_BIG) || defined(HAVE_TARGET_32_LITTLE)
2278       ret = this->sized_finalize<32>(off, pool, plocal_symcount);
2279 #else
2280       gold_unreachable();
2281 #endif
2282     }
2283   else if (parameters->target().get_size() == 64)
2284     {
2285 #if defined(HAVE_TARGET_64_BIG) || defined(HAVE_TARGET_64_LITTLE)
2286       ret = this->sized_finalize<64>(off, pool, plocal_symcount);
2287 #else
2288       gold_unreachable();
2289 #endif
2290     }
2291   else
2292     gold_unreachable();
2293
2294   // Now that we have the final symbol table, we can reliably note
2295   // which symbols should get warnings.
2296   this->warnings_.note_warnings(this);
2297
2298   return ret;
2299 }
2300
2301 // SYM is going into the symbol table at *PINDEX.  Add the name to
2302 // POOL, update *PINDEX and *POFF.
2303
2304 template<int size>
2305 void
2306 Symbol_table::add_to_final_symtab(Symbol* sym, Stringpool* pool,
2307                                   unsigned int* pindex, off_t* poff)
2308 {
2309   sym->set_symtab_index(*pindex);
2310   pool->add(sym->name(), false, NULL);
2311   ++*pindex;
2312   *poff += elfcpp::Elf_sizes<size>::sym_size;
2313 }
2314
2315 // Set the final value for all the symbols.  This is called after
2316 // Layout::finalize, so all the output sections have their final
2317 // address.
2318
2319 template<int size>
2320 off_t
2321 Symbol_table::sized_finalize(off_t off, Stringpool* pool,
2322                              unsigned int* plocal_symcount)
2323 {
2324   off = align_address(off, size >> 3);
2325   this->offset_ = off;
2326
2327   unsigned int index = *plocal_symcount;
2328   const unsigned int orig_index = index;
2329
2330   // First do all the symbols which have been forced to be local, as
2331   // they must appear before all global symbols.
2332   for (Forced_locals::iterator p = this->forced_locals_.begin();
2333        p != this->forced_locals_.end();
2334        ++p)
2335     {
2336       Symbol* sym = *p;
2337       gold_assert(sym->is_forced_local());
2338       if (this->sized_finalize_symbol<size>(sym))
2339         {
2340           this->add_to_final_symtab<size>(sym, pool, &index, &off);
2341           ++*plocal_symcount;
2342         }
2343     }
2344
2345   // Now do all the remaining symbols.
2346   for (Symbol_table_type::iterator p = this->table_.begin();
2347        p != this->table_.end();
2348        ++p)
2349     {
2350       Symbol* sym = p->second;
2351       if (this->sized_finalize_symbol<size>(sym))
2352         this->add_to_final_symtab<size>(sym, pool, &index, &off);
2353     }
2354
2355   this->output_count_ = index - orig_index;
2356
2357   return off;
2358 }
2359
2360 // Compute the final value of SYM and store status in location PSTATUS.
2361 // During relaxation, this may be called multiple times for a symbol to
2362 // compute its would-be final value in each relaxation pass.
2363
2364 template<int size>
2365 typename Sized_symbol<size>::Value_type
2366 Symbol_table::compute_final_value(
2367     const Sized_symbol<size>* sym,
2368     Compute_final_value_status* pstatus) const
2369 {
2370   typedef typename Sized_symbol<size>::Value_type Value_type;
2371   Value_type value;
2372
2373   switch (sym->source())
2374     {
2375     case Symbol::FROM_OBJECT:
2376       {
2377         bool is_ordinary;
2378         unsigned int shndx = sym->shndx(&is_ordinary);
2379
2380         if (!is_ordinary
2381             && shndx != elfcpp::SHN_ABS
2382             && !Symbol::is_common_shndx(shndx))
2383           {
2384             *pstatus = CFVS_UNSUPPORTED_SYMBOL_SECTION;
2385             return 0;
2386           }
2387
2388         Object* symobj = sym->object();
2389         if (symobj->is_dynamic())
2390           {
2391             value = 0;
2392             shndx = elfcpp::SHN_UNDEF;
2393           }
2394         else if (symobj->pluginobj() != NULL)
2395           {
2396             value = 0;
2397             shndx = elfcpp::SHN_UNDEF;
2398           }
2399         else if (shndx == elfcpp::SHN_UNDEF)
2400           value = 0;
2401         else if (!is_ordinary
2402                  && (shndx == elfcpp::SHN_ABS
2403                      || Symbol::is_common_shndx(shndx)))
2404           value = sym->value();
2405         else
2406           {
2407             Relobj* relobj = static_cast<Relobj*>(symobj);
2408             Output_section* os = relobj->output_section(shndx);
2409             uint64_t secoff64 = relobj->output_section_offset(shndx);
2410
2411             if (this->is_section_folded(relobj, shndx))
2412               {
2413                 gold_assert(os == NULL);
2414                 // Get the os of the section it is folded onto.
2415                 Section_id folded = this->icf_->get_folded_section(relobj,
2416                                                                    shndx);
2417                 gold_assert(folded.first != NULL);
2418                 Relobj* folded_obj = reinterpret_cast<Relobj*>(folded.first);
2419                 os = folded_obj->output_section(folded.second);  
2420                 gold_assert(os != NULL);
2421                 secoff64 = folded_obj->output_section_offset(folded.second);
2422               }
2423
2424             if (os == NULL)
2425               {
2426                 bool static_or_reloc = (parameters->doing_static_link() ||
2427                                         parameters->options().relocatable());
2428                 gold_assert(static_or_reloc || sym->dynsym_index() == -1U);
2429
2430                 *pstatus = CFVS_NO_OUTPUT_SECTION;
2431                 return 0;
2432               }
2433
2434             if (secoff64 == -1ULL)
2435               {
2436                 // The section needs special handling (e.g., a merge section).
2437
2438                 value = os->output_address(relobj, shndx, sym->value());
2439               }
2440             else
2441               {
2442                 Value_type secoff =
2443                   convert_types<Value_type, uint64_t>(secoff64);
2444                 if (sym->type() == elfcpp::STT_TLS)
2445                   value = sym->value() + os->tls_offset() + secoff;
2446                 else
2447                   value = sym->value() + os->address() + secoff;
2448               }
2449           }
2450       }
2451       break;
2452
2453     case Symbol::IN_OUTPUT_DATA:
2454       {
2455         Output_data* od = sym->output_data();
2456         value = sym->value();
2457         if (sym->type() != elfcpp::STT_TLS)
2458           value += od->address();
2459         else
2460           {
2461             Output_section* os = od->output_section();
2462             gold_assert(os != NULL);
2463             value += os->tls_offset() + (od->address() - os->address());
2464           }
2465         if (sym->offset_is_from_end())
2466           value += od->data_size();
2467       }
2468       break;
2469
2470     case Symbol::IN_OUTPUT_SEGMENT:
2471       {
2472         Output_segment* os = sym->output_segment();
2473         value = sym->value();
2474         if (sym->type() != elfcpp::STT_TLS)
2475           value += os->vaddr();
2476         switch (sym->offset_base())
2477           {
2478           case Symbol::SEGMENT_START:
2479             break;
2480           case Symbol::SEGMENT_END:
2481             value += os->memsz();
2482             break;
2483           case Symbol::SEGMENT_BSS:
2484             value += os->filesz();
2485             break;
2486           default:
2487             gold_unreachable();
2488           }
2489       }
2490       break;
2491
2492     case Symbol::IS_CONSTANT:
2493       value = sym->value();
2494       break;
2495
2496     case Symbol::IS_UNDEFINED:
2497       value = 0;
2498       break;
2499
2500     default:
2501       gold_unreachable();
2502     }
2503
2504   *pstatus = CFVS_OK;
2505   return value;
2506 }
2507
2508 // Finalize the symbol SYM.  This returns true if the symbol should be
2509 // added to the symbol table, false otherwise.
2510
2511 template<int size>
2512 bool
2513 Symbol_table::sized_finalize_symbol(Symbol* unsized_sym)
2514 {
2515   typedef typename Sized_symbol<size>::Value_type Value_type;
2516
2517   Sized_symbol<size>* sym = static_cast<Sized_symbol<size>*>(unsized_sym);
2518
2519   // The default version of a symbol may appear twice in the symbol
2520   // table.  We only need to finalize it once.
2521   if (sym->has_symtab_index())
2522     return false;
2523
2524   if (!sym->in_reg())
2525     {
2526       gold_assert(!sym->has_symtab_index());
2527       sym->set_symtab_index(-1U);
2528       gold_assert(sym->dynsym_index() == -1U);
2529       return false;
2530     }
2531
2532   // Compute final symbol value.
2533   Compute_final_value_status status;
2534   Value_type value = this->compute_final_value(sym, &status);
2535
2536   switch (status)
2537     {
2538     case CFVS_OK:
2539       break;
2540     case CFVS_UNSUPPORTED_SYMBOL_SECTION:
2541       {
2542         bool is_ordinary;
2543         unsigned int shndx = sym->shndx(&is_ordinary);
2544         gold_error(_("%s: unsupported symbol section 0x%x"),
2545                    sym->demangled_name().c_str(), shndx);
2546       }
2547       break;
2548     case CFVS_NO_OUTPUT_SECTION:
2549       sym->set_symtab_index(-1U);
2550       return false;
2551     default:
2552       gold_unreachable();
2553     }
2554
2555   sym->set_value(value);
2556
2557   if (parameters->options().strip_all()
2558       || !parameters->options().should_retain_symbol(sym->name()))
2559     {
2560       sym->set_symtab_index(-1U);
2561       return false;
2562     }
2563
2564   return true;
2565 }
2566
2567 // Write out the global symbols.
2568
2569 void
2570 Symbol_table::write_globals(const Stringpool* sympool,
2571                             const Stringpool* dynpool,
2572                             Output_symtab_xindex* symtab_xindex,
2573                             Output_symtab_xindex* dynsym_xindex,
2574                             Output_file* of) const
2575 {
2576   switch (parameters->size_and_endianness())
2577     {
2578 #ifdef HAVE_TARGET_32_LITTLE
2579     case Parameters::TARGET_32_LITTLE:
2580       this->sized_write_globals<32, false>(sympool, dynpool, symtab_xindex,
2581                                            dynsym_xindex, of);
2582       break;
2583 #endif
2584 #ifdef HAVE_TARGET_32_BIG
2585     case Parameters::TARGET_32_BIG:
2586       this->sized_write_globals<32, true>(sympool, dynpool, symtab_xindex,
2587                                           dynsym_xindex, of);
2588       break;
2589 #endif
2590 #ifdef HAVE_TARGET_64_LITTLE
2591     case Parameters::TARGET_64_LITTLE:
2592       this->sized_write_globals<64, false>(sympool, dynpool, symtab_xindex,
2593                                            dynsym_xindex, of);
2594       break;
2595 #endif
2596 #ifdef HAVE_TARGET_64_BIG
2597     case Parameters::TARGET_64_BIG:
2598       this->sized_write_globals<64, true>(sympool, dynpool, symtab_xindex,
2599                                           dynsym_xindex, of);
2600       break;
2601 #endif
2602     default:
2603       gold_unreachable();
2604     }
2605 }
2606
2607 // Write out the global symbols.
2608
2609 template<int size, bool big_endian>
2610 void
2611 Symbol_table::sized_write_globals(const Stringpool* sympool,
2612                                   const Stringpool* dynpool,
2613                                   Output_symtab_xindex* symtab_xindex,
2614                                   Output_symtab_xindex* dynsym_xindex,
2615                                   Output_file* of) const
2616 {
2617   const Target& target = parameters->target();
2618
2619   const int sym_size = elfcpp::Elf_sizes<size>::sym_size;
2620
2621   const unsigned int output_count = this->output_count_;
2622   const section_size_type oview_size = output_count * sym_size;
2623   const unsigned int first_global_index = this->first_global_index_;
2624   unsigned char* psyms;
2625   if (this->offset_ == 0 || output_count == 0)
2626     psyms = NULL;
2627   else
2628     psyms = of->get_output_view(this->offset_, oview_size);
2629
2630   const unsigned int dynamic_count = this->dynamic_count_;
2631   const section_size_type dynamic_size = dynamic_count * sym_size;
2632   const unsigned int first_dynamic_global_index =
2633     this->first_dynamic_global_index_;
2634   unsigned char* dynamic_view;
2635   if (this->dynamic_offset_ == 0 || dynamic_count == 0)
2636     dynamic_view = NULL;
2637   else
2638     dynamic_view = of->get_output_view(this->dynamic_offset_, dynamic_size);
2639
2640   for (Symbol_table_type::const_iterator p = this->table_.begin();
2641        p != this->table_.end();
2642        ++p)
2643     {
2644       Sized_symbol<size>* sym = static_cast<Sized_symbol<size>*>(p->second);
2645
2646       // Possibly warn about unresolved symbols in shared libraries.
2647       this->warn_about_undefined_dynobj_symbol(sym);
2648
2649       unsigned int sym_index = sym->symtab_index();
2650       unsigned int dynsym_index;
2651       if (dynamic_view == NULL)
2652         dynsym_index = -1U;
2653       else
2654         dynsym_index = sym->dynsym_index();
2655
2656       if (sym_index == -1U && dynsym_index == -1U)
2657         {
2658           // This symbol is not included in the output file.
2659           continue;
2660         }
2661
2662       unsigned int shndx;
2663       typename elfcpp::Elf_types<size>::Elf_Addr sym_value = sym->value();
2664       typename elfcpp::Elf_types<size>::Elf_Addr dynsym_value = sym_value;
2665       switch (sym->source())
2666         {
2667         case Symbol::FROM_OBJECT:
2668           {
2669             bool is_ordinary;
2670             unsigned int in_shndx = sym->shndx(&is_ordinary);
2671
2672             if (!is_ordinary
2673                 && in_shndx != elfcpp::SHN_ABS
2674                 && !Symbol::is_common_shndx(in_shndx))
2675               {
2676                 gold_error(_("%s: unsupported symbol section 0x%x"),
2677                            sym->demangled_name().c_str(), in_shndx);
2678                 shndx = in_shndx;
2679               }
2680             else
2681               {
2682                 Object* symobj = sym->object();
2683                 if (symobj->is_dynamic())
2684                   {
2685                     if (sym->needs_dynsym_value())
2686                       dynsym_value = target.dynsym_value(sym);
2687                     shndx = elfcpp::SHN_UNDEF;
2688                   }
2689                 else if (symobj->pluginobj() != NULL)
2690                   shndx = elfcpp::SHN_UNDEF;
2691                 else if (in_shndx == elfcpp::SHN_UNDEF
2692                          || (!is_ordinary
2693                              && (in_shndx == elfcpp::SHN_ABS
2694                                  || Symbol::is_common_shndx(in_shndx))))
2695                   shndx = in_shndx;
2696                 else
2697                   {
2698                     Relobj* relobj = static_cast<Relobj*>(symobj);
2699                     Output_section* os = relobj->output_section(in_shndx);
2700                     if (this->is_section_folded(relobj, in_shndx))
2701                       {
2702                         // This global symbol must be written out even though
2703                         // it is folded.
2704                         // Get the os of the section it is folded onto.
2705                         Section_id folded =
2706                              this->icf_->get_folded_section(relobj, in_shndx);
2707                         gold_assert(folded.first !=NULL);
2708                         Relobj* folded_obj = 
2709                           reinterpret_cast<Relobj*>(folded.first);
2710                         os = folded_obj->output_section(folded.second);  
2711                         gold_assert(os != NULL);
2712                       }
2713                     gold_assert(os != NULL);
2714                     shndx = os->out_shndx();
2715
2716                     if (shndx >= elfcpp::SHN_LORESERVE)
2717                       {
2718                         if (sym_index != -1U)
2719                           symtab_xindex->add(sym_index, shndx);
2720                         if (dynsym_index != -1U)
2721                           dynsym_xindex->add(dynsym_index, shndx);
2722                         shndx = elfcpp::SHN_XINDEX;
2723                       }
2724
2725                     // In object files symbol values are section
2726                     // relative.
2727                     if (parameters->options().relocatable())
2728                       sym_value -= os->address();
2729                   }
2730               }
2731           }
2732           break;
2733
2734         case Symbol::IN_OUTPUT_DATA:
2735           shndx = sym->output_data()->out_shndx();
2736           if (shndx >= elfcpp::SHN_LORESERVE)
2737             {
2738               if (sym_index != -1U)
2739                 symtab_xindex->add(sym_index, shndx);
2740               if (dynsym_index != -1U)
2741                 dynsym_xindex->add(dynsym_index, shndx);
2742               shndx = elfcpp::SHN_XINDEX;
2743             }
2744           break;
2745
2746         case Symbol::IN_OUTPUT_SEGMENT:
2747           shndx = elfcpp::SHN_ABS;
2748           break;
2749
2750         case Symbol::IS_CONSTANT:
2751           shndx = elfcpp::SHN_ABS;
2752           break;
2753
2754         case Symbol::IS_UNDEFINED:
2755           shndx = elfcpp::SHN_UNDEF;
2756           break;
2757
2758         default:
2759           gold_unreachable();
2760         }
2761
2762       if (sym_index != -1U)
2763         {
2764           sym_index -= first_global_index;
2765           gold_assert(sym_index < output_count);
2766           unsigned char* ps = psyms + (sym_index * sym_size);
2767           this->sized_write_symbol<size, big_endian>(sym, sym_value, shndx,
2768                                                      sympool, ps);
2769         }
2770
2771       if (dynsym_index != -1U)
2772         {
2773           dynsym_index -= first_dynamic_global_index;
2774           gold_assert(dynsym_index < dynamic_count);
2775           unsigned char* pd = dynamic_view + (dynsym_index * sym_size);
2776           this->sized_write_symbol<size, big_endian>(sym, dynsym_value, shndx,
2777                                                      dynpool, pd);
2778         }
2779     }
2780
2781   of->write_output_view(this->offset_, oview_size, psyms);
2782   if (dynamic_view != NULL)
2783     of->write_output_view(this->dynamic_offset_, dynamic_size, dynamic_view);
2784 }
2785
2786 // Write out the symbol SYM, in section SHNDX, to P.  POOL is the
2787 // strtab holding the name.
2788
2789 template<int size, bool big_endian>
2790 void
2791 Symbol_table::sized_write_symbol(
2792     Sized_symbol<size>* sym,
2793     typename elfcpp::Elf_types<size>::Elf_Addr value,
2794     unsigned int shndx,
2795     const Stringpool* pool,
2796     unsigned char* p) const
2797 {
2798   elfcpp::Sym_write<size, big_endian> osym(p);
2799   osym.put_st_name(pool->get_offset(sym->name()));
2800   osym.put_st_value(value);
2801   // Use a symbol size of zero for undefined symbols from shared libraries.
2802   if (shndx == elfcpp::SHN_UNDEF && sym->is_from_dynobj())
2803     osym.put_st_size(0);
2804   else
2805     osym.put_st_size(sym->symsize());
2806   // A version script may have overridden the default binding.
2807   if (sym->is_forced_local())
2808     osym.put_st_info(elfcpp::elf_st_info(elfcpp::STB_LOCAL, sym->type()));
2809   else
2810     osym.put_st_info(elfcpp::elf_st_info(sym->binding(), sym->type()));
2811   osym.put_st_other(elfcpp::elf_st_other(sym->visibility(), sym->nonvis()));
2812   osym.put_st_shndx(shndx);
2813 }
2814
2815 // Check for unresolved symbols in shared libraries.  This is
2816 // controlled by the --allow-shlib-undefined option.
2817
2818 // We only warn about libraries for which we have seen all the
2819 // DT_NEEDED entries.  We don't try to track down DT_NEEDED entries
2820 // which were not seen in this link.  If we didn't see a DT_NEEDED
2821 // entry, we aren't going to be able to reliably report whether the
2822 // symbol is undefined.
2823
2824 // We also don't warn about libraries found in a system library
2825 // directory (e.g., /lib or /usr/lib); we assume that those libraries
2826 // are OK.  This heuristic avoids problems on GNU/Linux, in which -ldl
2827 // can have undefined references satisfied by ld-linux.so.
2828
2829 inline void
2830 Symbol_table::warn_about_undefined_dynobj_symbol(Symbol* sym) const
2831 {
2832   bool dummy;
2833   if (sym->source() == Symbol::FROM_OBJECT
2834       && sym->object()->is_dynamic()
2835       && sym->shndx(&dummy) == elfcpp::SHN_UNDEF
2836       && sym->binding() != elfcpp::STB_WEAK
2837       && !parameters->options().allow_shlib_undefined()
2838       && !parameters->target().is_defined_by_abi(sym)
2839       && !sym->object()->is_in_system_directory())
2840     {
2841       // A very ugly cast.
2842       Dynobj* dynobj = static_cast<Dynobj*>(sym->object());
2843       if (!dynobj->has_unknown_needed_entries())
2844         gold_undefined_symbol(sym);
2845     }
2846 }
2847
2848 // Write out a section symbol.  Return the update offset.
2849
2850 void
2851 Symbol_table::write_section_symbol(const Output_section *os,
2852                                    Output_symtab_xindex* symtab_xindex,
2853                                    Output_file* of,
2854                                    off_t offset) const
2855 {
2856   switch (parameters->size_and_endianness())
2857     {
2858 #ifdef HAVE_TARGET_32_LITTLE
2859     case Parameters::TARGET_32_LITTLE:
2860       this->sized_write_section_symbol<32, false>(os, symtab_xindex, of,
2861                                                   offset);
2862       break;
2863 #endif
2864 #ifdef HAVE_TARGET_32_BIG
2865     case Parameters::TARGET_32_BIG:
2866       this->sized_write_section_symbol<32, true>(os, symtab_xindex, of,
2867                                                  offset);
2868       break;
2869 #endif
2870 #ifdef HAVE_TARGET_64_LITTLE
2871     case Parameters::TARGET_64_LITTLE:
2872       this->sized_write_section_symbol<64, false>(os, symtab_xindex, of,
2873                                                   offset);
2874       break;
2875 #endif
2876 #ifdef HAVE_TARGET_64_BIG
2877     case Parameters::TARGET_64_BIG:
2878       this->sized_write_section_symbol<64, true>(os, symtab_xindex, of,
2879                                                  offset);
2880       break;
2881 #endif
2882     default:
2883       gold_unreachable();
2884     }
2885 }
2886
2887 // Write out a section symbol, specialized for size and endianness.
2888
2889 template<int size, bool big_endian>
2890 void
2891 Symbol_table::sized_write_section_symbol(const Output_section* os,
2892                                          Output_symtab_xindex* symtab_xindex,
2893                                          Output_file* of,
2894                                          off_t offset) const
2895 {
2896   const int sym_size = elfcpp::Elf_sizes<size>::sym_size;
2897
2898   unsigned char* pov = of->get_output_view(offset, sym_size);
2899
2900   elfcpp::Sym_write<size, big_endian> osym(pov);
2901   osym.put_st_name(0);
2902   if (parameters->options().relocatable())
2903     osym.put_st_value(0);
2904   else
2905     osym.put_st_value(os->address());
2906   osym.put_st_size(0);
2907   osym.put_st_info(elfcpp::elf_st_info(elfcpp::STB_LOCAL,
2908                                        elfcpp::STT_SECTION));
2909   osym.put_st_other(elfcpp::elf_st_other(elfcpp::STV_DEFAULT, 0));
2910
2911   unsigned int shndx = os->out_shndx();
2912   if (shndx >= elfcpp::SHN_LORESERVE)
2913     {
2914       symtab_xindex->add(os->symtab_index(), shndx);
2915       shndx = elfcpp::SHN_XINDEX;
2916     }
2917   osym.put_st_shndx(shndx);
2918
2919   of->write_output_view(offset, sym_size, pov);
2920 }
2921
2922 // Print statistical information to stderr.  This is used for --stats.
2923
2924 void
2925 Symbol_table::print_stats() const
2926 {
2927 #if defined(HAVE_TR1_UNORDERED_MAP) || defined(HAVE_EXT_HASH_MAP)
2928   fprintf(stderr, _("%s: symbol table entries: %zu; buckets: %zu\n"),
2929           program_name, this->table_.size(), this->table_.bucket_count());
2930 #else
2931   fprintf(stderr, _("%s: symbol table entries: %zu\n"),
2932           program_name, this->table_.size());
2933 #endif
2934   this->namepool_.print_stats("symbol table stringpool");
2935 }
2936
2937 // We check for ODR violations by looking for symbols with the same
2938 // name for which the debugging information reports that they were
2939 // defined in different source locations.  When comparing the source
2940 // location, we consider instances with the same base filename and
2941 // line number to be the same.  This is because different object
2942 // files/shared libraries can include the same header file using
2943 // different paths, and we don't want to report an ODR violation in
2944 // that case.
2945
2946 // This struct is used to compare line information, as returned by
2947 // Dwarf_line_info::one_addr2line.  It implements a < comparison
2948 // operator used with std::set.
2949
2950 struct Odr_violation_compare
2951 {
2952   bool
2953   operator()(const std::string& s1, const std::string& s2) const
2954   {
2955     std::string::size_type pos1 = s1.rfind('/');
2956     std::string::size_type pos2 = s2.rfind('/');
2957     if (pos1 == std::string::npos
2958         || pos2 == std::string::npos)
2959       return s1 < s2;
2960     return s1.compare(pos1, std::string::npos,
2961                       s2, pos2, std::string::npos) < 0;
2962   }
2963 };
2964
2965 // Check candidate_odr_violations_ to find symbols with the same name
2966 // but apparently different definitions (different source-file/line-no).
2967
2968 void
2969 Symbol_table::detect_odr_violations(const Task* task,
2970                                     const char* output_file_name) const
2971 {
2972   for (Odr_map::const_iterator it = candidate_odr_violations_.begin();
2973        it != candidate_odr_violations_.end();
2974        ++it)
2975     {
2976       const char* symbol_name = it->first;
2977       // We use a sorted set so the output is deterministic.
2978       std::set<std::string, Odr_violation_compare> line_nums;
2979
2980       for (Unordered_set<Symbol_location, Symbol_location_hash>::const_iterator
2981                locs = it->second.begin();
2982            locs != it->second.end();
2983            ++locs)
2984         {
2985           // We need to lock the object in order to read it.  This
2986           // means that we have to run in a singleton Task.  If we
2987           // want to run this in a general Task for better
2988           // performance, we will need one Task for object, plus
2989           // appropriate locking to ensure that we don't conflict with
2990           // other uses of the object.  Also note, one_addr2line is not
2991           // currently thread-safe.
2992           Task_lock_obj<Object> tl(task, locs->object);
2993           // 16 is the size of the object-cache that one_addr2line should use.
2994           std::string lineno = Dwarf_line_info::one_addr2line(
2995               locs->object, locs->shndx, locs->offset, 16);
2996           if (!lineno.empty())
2997             line_nums.insert(lineno);
2998         }
2999
3000       if (line_nums.size() > 1)
3001         {
3002           gold_warning(_("while linking %s: symbol '%s' defined in multiple "
3003                          "places (possible ODR violation):"),
3004                        output_file_name, demangle(symbol_name).c_str());
3005           for (std::set<std::string>::const_iterator it2 = line_nums.begin();
3006                it2 != line_nums.end();
3007                ++it2)
3008             fprintf(stderr, "  %s\n", it2->c_str());
3009         }
3010     }
3011   // We only call one_addr2line() in this function, so we can clear its cache.
3012   Dwarf_line_info::clear_addr2line_cache();
3013 }
3014
3015 // Warnings functions.
3016
3017 // Add a new warning.
3018
3019 void
3020 Warnings::add_warning(Symbol_table* symtab, const char* name, Object* obj,
3021                       const std::string& warning)
3022 {
3023   name = symtab->canonicalize_name(name);
3024   this->warnings_[name].set(obj, warning);
3025 }
3026
3027 // Look through the warnings and mark the symbols for which we should
3028 // warn.  This is called during Layout::finalize when we know the
3029 // sources for all the symbols.
3030
3031 void
3032 Warnings::note_warnings(Symbol_table* symtab)
3033 {
3034   for (Warning_table::iterator p = this->warnings_.begin();
3035        p != this->warnings_.end();
3036        ++p)
3037     {
3038       Symbol* sym = symtab->lookup(p->first, NULL);
3039       if (sym != NULL
3040           && sym->source() == Symbol::FROM_OBJECT
3041           && sym->object() == p->second.object)
3042         sym->set_has_warning();
3043     }
3044 }
3045
3046 // Issue a warning.  This is called when we see a relocation against a
3047 // symbol for which has a warning.
3048
3049 template<int size, bool big_endian>
3050 void
3051 Warnings::issue_warning(const Symbol* sym,
3052                         const Relocate_info<size, big_endian>* relinfo,
3053                         size_t relnum, off_t reloffset) const
3054 {
3055   gold_assert(sym->has_warning());
3056   Warning_table::const_iterator p = this->warnings_.find(sym->name());
3057   gold_assert(p != this->warnings_.end());
3058   gold_warning_at_location(relinfo, relnum, reloffset,
3059                            "%s", p->second.text.c_str());
3060 }
3061
3062 // Instantiate the templates we need.  We could use the configure
3063 // script to restrict this to only the ones needed for implemented
3064 // targets.
3065
3066 #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG)
3067 template
3068 void
3069 Sized_symbol<32>::allocate_common(Output_data*, Value_type);
3070 #endif
3071
3072 #if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG)
3073 template
3074 void
3075 Sized_symbol<64>::allocate_common(Output_data*, Value_type);
3076 #endif
3077
3078 #ifdef HAVE_TARGET_32_LITTLE
3079 template
3080 void
3081 Symbol_table::add_from_relobj<32, false>(
3082     Sized_relobj<32, false>* relobj,
3083     const unsigned char* syms,
3084     size_t count,
3085     size_t symndx_offset,
3086     const char* sym_names,
3087     size_t sym_name_size,
3088     Sized_relobj<32, false>::Symbols* sympointers,
3089     size_t* defined);
3090 #endif
3091
3092 #ifdef HAVE_TARGET_32_BIG
3093 template
3094 void
3095 Symbol_table::add_from_relobj<32, true>(
3096     Sized_relobj<32, true>* relobj,
3097     const unsigned char* syms,
3098     size_t count,
3099     size_t symndx_offset,
3100     const char* sym_names,
3101     size_t sym_name_size,
3102     Sized_relobj<32, true>::Symbols* sympointers,
3103     size_t* defined);
3104 #endif
3105
3106 #ifdef HAVE_TARGET_64_LITTLE
3107 template
3108 void
3109 Symbol_table::add_from_relobj<64, false>(
3110     Sized_relobj<64, false>* relobj,
3111     const unsigned char* syms,
3112     size_t count,
3113     size_t symndx_offset,
3114     const char* sym_names,
3115     size_t sym_name_size,
3116     Sized_relobj<64, false>::Symbols* sympointers,
3117     size_t* defined);
3118 #endif
3119
3120 #ifdef HAVE_TARGET_64_BIG
3121 template
3122 void
3123 Symbol_table::add_from_relobj<64, true>(
3124     Sized_relobj<64, true>* relobj,
3125     const unsigned char* syms,
3126     size_t count,
3127     size_t symndx_offset,
3128     const char* sym_names,
3129     size_t sym_name_size,
3130     Sized_relobj<64, true>::Symbols* sympointers,
3131     size_t* defined);
3132 #endif
3133
3134 #ifdef HAVE_TARGET_32_LITTLE
3135 template
3136 Symbol*
3137 Symbol_table::add_from_pluginobj<32, false>(
3138     Sized_pluginobj<32, false>* obj,
3139     const char* name,
3140     const char* ver,
3141     elfcpp::Sym<32, false>* sym);
3142 #endif
3143
3144 #ifdef HAVE_TARGET_32_BIG
3145 template
3146 Symbol*
3147 Symbol_table::add_from_pluginobj<32, true>(
3148     Sized_pluginobj<32, true>* obj,
3149     const char* name,
3150     const char* ver,
3151     elfcpp::Sym<32, true>* sym);
3152 #endif
3153
3154 #ifdef HAVE_TARGET_64_LITTLE
3155 template
3156 Symbol*
3157 Symbol_table::add_from_pluginobj<64, false>(
3158     Sized_pluginobj<64, false>* obj,
3159     const char* name,
3160     const char* ver,
3161     elfcpp::Sym<64, false>* sym);
3162 #endif
3163
3164 #ifdef HAVE_TARGET_64_BIG
3165 template
3166 Symbol*
3167 Symbol_table::add_from_pluginobj<64, true>(
3168     Sized_pluginobj<64, true>* obj,
3169     const char* name,
3170     const char* ver,
3171     elfcpp::Sym<64, true>* sym);
3172 #endif
3173
3174 #ifdef HAVE_TARGET_32_LITTLE
3175 template
3176 void
3177 Symbol_table::add_from_dynobj<32, false>(
3178     Sized_dynobj<32, false>* dynobj,
3179     const unsigned char* syms,
3180     size_t count,
3181     const char* sym_names,
3182     size_t sym_name_size,
3183     const unsigned char* versym,
3184     size_t versym_size,
3185     const std::vector<const char*>* version_map,
3186     Sized_relobj<32, false>::Symbols* sympointers,
3187     size_t* defined);
3188 #endif
3189
3190 #ifdef HAVE_TARGET_32_BIG
3191 template
3192 void
3193 Symbol_table::add_from_dynobj<32, true>(
3194     Sized_dynobj<32, true>* dynobj,
3195     const unsigned char* syms,
3196     size_t count,
3197     const char* sym_names,
3198     size_t sym_name_size,
3199     const unsigned char* versym,
3200     size_t versym_size,
3201     const std::vector<const char*>* version_map,
3202     Sized_relobj<32, true>::Symbols* sympointers,
3203     size_t* defined);
3204 #endif
3205
3206 #ifdef HAVE_TARGET_64_LITTLE
3207 template
3208 void
3209 Symbol_table::add_from_dynobj<64, false>(
3210     Sized_dynobj<64, false>* dynobj,
3211     const unsigned char* syms,
3212     size_t count,
3213     const char* sym_names,
3214     size_t sym_name_size,
3215     const unsigned char* versym,
3216     size_t versym_size,
3217     const std::vector<const char*>* version_map,
3218     Sized_relobj<64, false>::Symbols* sympointers,
3219     size_t* defined);
3220 #endif
3221
3222 #ifdef HAVE_TARGET_64_BIG
3223 template
3224 void
3225 Symbol_table::add_from_dynobj<64, true>(
3226     Sized_dynobj<64, true>* dynobj,
3227     const unsigned char* syms,
3228     size_t count,
3229     const char* sym_names,
3230     size_t sym_name_size,
3231     const unsigned char* versym,
3232     size_t versym_size,
3233     const std::vector<const char*>* version_map,
3234     Sized_relobj<64, true>::Symbols* sympointers,
3235     size_t* defined);
3236 #endif
3237
3238 #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG)
3239 template
3240 void
3241 Symbol_table::define_with_copy_reloc<32>(
3242     Sized_symbol<32>* sym,
3243     Output_data* posd,
3244     elfcpp::Elf_types<32>::Elf_Addr value);
3245 #endif
3246
3247 #if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG)
3248 template
3249 void
3250 Symbol_table::define_with_copy_reloc<64>(
3251     Sized_symbol<64>* sym,
3252     Output_data* posd,
3253     elfcpp::Elf_types<64>::Elf_Addr value);
3254 #endif
3255
3256 #ifdef HAVE_TARGET_32_LITTLE
3257 template
3258 void
3259 Warnings::issue_warning<32, false>(const Symbol* sym,
3260                                    const Relocate_info<32, false>* relinfo,
3261                                    size_t relnum, off_t reloffset) const;
3262 #endif
3263
3264 #ifdef HAVE_TARGET_32_BIG
3265 template
3266 void
3267 Warnings::issue_warning<32, true>(const Symbol* sym,
3268                                   const Relocate_info<32, true>* relinfo,
3269                                   size_t relnum, off_t reloffset) const;
3270 #endif
3271
3272 #ifdef HAVE_TARGET_64_LITTLE
3273 template
3274 void
3275 Warnings::issue_warning<64, false>(const Symbol* sym,
3276                                    const Relocate_info<64, false>* relinfo,
3277                                    size_t relnum, off_t reloffset) const;
3278 #endif
3279
3280 #ifdef HAVE_TARGET_64_BIG
3281 template
3282 void
3283 Warnings::issue_warning<64, true>(const Symbol* sym,
3284                                   const Relocate_info<64, true>* relinfo,
3285                                   size_t relnum, off_t reloffset) const;
3286 #endif
3287
3288 } // End namespace gold.