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