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