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