1 // symtab.cc -- the gold symbol table 2 3 // Copyright (C) 2006-2016 Free Software Foundation, Inc. 4 // Written by Ian Lance Taylor <iant (at) 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 45 namespace gold 46 { 47 48 // Class Symbol. 49 50 // Initialize fields in Symbol. This initializes everything except u_ 51 // and source_. 52 53 void 54 Symbol::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 89 static std::string 90 demangle(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 106 std::string 107 Symbol::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 114 template<int size, bool big_endian> 115 void 116 Symbol::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 134 void 135 Symbol::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 153 void 154 Symbol::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 173 void 174 Symbol::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 189 void 190 Symbol::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 203 void 204 Symbol::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 214 template<int size> 215 template<bool big_endian> 216 void 217 Sized_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 230 template<int size> 231 void 232 Sized_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 250 template<int size> 251 void 252 Sized_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 270 template<int size> 271 void 272 Sized_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 286 template<int size> 287 void 288 Sized_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 301 std::string 302 Symbol::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 315 bool 316 Symbol::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 325 template<int size> 326 void 327 Sized_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 339 bool 340 Symbol::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 442 bool 443 Symbol::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 483 Output_section* 484 Symbol::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 518 void 519 Symbol::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 543 void 544 Symbol::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 556 void 557 Symbol::set_undefined() 558 { 559 this->source_ = IS_UNDEFINED; 560 this->is_predefined_ = false; 561 } 562 563 // Class Symbol_table. 564 565 Symbol_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 576 Symbol_table::~Symbol_table() 577 { 578 } 579 580 // The symbol table key equality function. This is called with 581 // Stringpool keys. 582 583 inline bool 584 Symbol_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 590 bool 591 Symbol_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 600 void 601 Symbol_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 650 void 651 Symbol_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. 667 inline void 668 Symbol_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 677 void 678 Symbol_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 688 Symbol* 689 Symbol_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 700 Symbol* 701 Symbol_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 729 template<int size, bool big_endian> 730 void 731 Symbol_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 755 void 756 Symbol_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 773 const char* 774 Symbol_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 822 template<int size, bool big_endian> 823 void 824 Symbol_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 930 template<int size, bool big_endian> 931 Sized_symbol<size>* 932 Symbol_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 1149 template<int size, bool big_endian> 1150 void 1151 Symbol_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 1357 template<int size, bool big_endian> 1358 Symbol* 1359 Symbol_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 1424 template<int size, bool big_endian> 1425 void 1426 Symbol_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 1640 template<int size, bool big_endian> 1641 Sized_symbol<size>* 1642 Symbol_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 1668 template<int size> 1669 class Weak_alias_sorter 1670 { 1671 public: 1672 bool operator()(const Sized_symbol<size>*, const Sized_symbol<size>*) const; 1673 }; 1674 1675 template<int size> 1676 bool 1677 Weak_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 1705 template<int size> 1706 void 1707 Symbol_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 1757 template<int size, bool big_endian> 1758 Sized_symbol<size>* 1759 Symbol_table::define_special_symbol(const char** pname, const char** pversion, 1760 bool only_if_ref, 1761 Sized_symbol<size>** poldsym, 1762 bool* resolve_oldsym) 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 (*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 1906 Symbol* 1907 Symbol_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 1950 template<int size> 1951 Sized_symbol<size>* 1952 Symbol_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 1970 if (parameters->target().is_big_endian()) 1971 { 1972 #if defined(HAVE_TARGET_32_BIG) || defined(HAVE_TARGET_64_BIG) 1973 sym = this->define_special_symbol<size, true>(&name, &version, 1974 only_if_ref, &oldsym, 1975 &resolve_oldsym); 1976 #else 1977 gold_unreachable(); 1978 #endif 1979 } 1980 else 1981 { 1982 #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_64_LITTLE) 1983 sym = this->define_special_symbol<size, false>(&name, &version, 1984 only_if_ref, &oldsym, 1985 &resolve_oldsym); 1986 #else 1987 gold_unreachable(); 1988 #endif 1989 } 1990 1991 if (sym == NULL) 1992 return NULL; 1993 1994 sym->init_output_data(name, version, od, value, symsize, type, binding, 1995 visibility, nonvis, offset_is_from_end, 1996 defined == PREDEFINED); 1997 1998 if (oldsym == NULL) 1999 { 2000 if (binding == elfcpp::STB_LOCAL 2001 || this->version_script_.symbol_is_local(name)) 2002 this->force_local(sym); 2003 else if (version != NULL) 2004 sym->set_is_default(); 2005 return sym; 2006 } 2007 2008 if (Symbol_table::should_override_with_special(oldsym, type, defined)) 2009 this->override_with_special(oldsym, sym); 2010 2011 if (resolve_oldsym) 2012 return sym; 2013 else 2014 { 2015 if (defined == PREDEFINED 2016 && (binding == elfcpp::STB_LOCAL 2017 || this->version_script_.symbol_is_local(name))) 2018 this->force_local(oldsym); 2019 delete sym; 2020 return oldsym; 2021 } 2022 } 2023 2024 // Define a symbol based on an Output_segment. 2025 2026 Symbol* 2027 Symbol_table::define_in_output_segment(const char* name, 2028 const char* version, 2029 Defined defined, 2030 Output_segment* os, 2031 uint64_t value, 2032 uint64_t symsize, 2033 elfcpp::STT type, 2034 elfcpp::STB binding, 2035 elfcpp::STV visibility, 2036 unsigned char nonvis, 2037 Symbol::Segment_offset_base offset_base, 2038 bool only_if_ref) 2039 { 2040 if (parameters->target().get_size() == 32) 2041 { 2042 #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG) 2043 return this->do_define_in_output_segment<32>(name, version, defined, os, 2044 value, symsize, type, 2045 binding, visibility, nonvis, 2046 offset_base, only_if_ref); 2047 #else 2048 gold_unreachable(); 2049 #endif 2050 } 2051 else if (parameters->target().get_size() == 64) 2052 { 2053 #if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG) 2054 return this->do_define_in_output_segment<64>(name, version, defined, os, 2055 value, symsize, type, 2056 binding, visibility, nonvis, 2057 offset_base, only_if_ref); 2058 #else 2059 gold_unreachable(); 2060 #endif 2061 } 2062 else 2063 gold_unreachable(); 2064 } 2065 2066 // Define a symbol in an Output_segment, sized version. 2067 2068 template<int size> 2069 Sized_symbol<size>* 2070 Symbol_table::do_define_in_output_segment( 2071 const char* name, 2072 const char* version, 2073 Defined defined, 2074 Output_segment* os, 2075 typename elfcpp::Elf_types<size>::Elf_Addr value, 2076 typename elfcpp::Elf_types<size>::Elf_WXword symsize, 2077 elfcpp::STT type, 2078 elfcpp::STB binding, 2079 elfcpp::STV visibility, 2080 unsigned char nonvis, 2081 Symbol::Segment_offset_base offset_base, 2082 bool only_if_ref) 2083 { 2084 Sized_symbol<size>* sym; 2085 Sized_symbol<size>* oldsym; 2086 bool resolve_oldsym; 2087 2088 if (parameters->target().is_big_endian()) 2089 { 2090 #if defined(HAVE_TARGET_32_BIG) || defined(HAVE_TARGET_64_BIG) 2091 sym = this->define_special_symbol<size, true>(&name, &version, 2092 only_if_ref, &oldsym, 2093 &resolve_oldsym); 2094 #else 2095 gold_unreachable(); 2096 #endif 2097 } 2098 else 2099 { 2100 #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_64_LITTLE) 2101 sym = this->define_special_symbol<size, false>(&name, &version, 2102 only_if_ref, &oldsym, 2103 &resolve_oldsym); 2104 #else 2105 gold_unreachable(); 2106 #endif 2107 } 2108 2109 if (sym == NULL) 2110 return NULL; 2111 2112 sym->init_output_segment(name, version, os, value, symsize, type, binding, 2113 visibility, nonvis, offset_base, 2114 defined == PREDEFINED); 2115 2116 if (oldsym == NULL) 2117 { 2118 if (binding == elfcpp::STB_LOCAL 2119 || this->version_script_.symbol_is_local(name)) 2120 this->force_local(sym); 2121 else if (version != NULL) 2122 sym->set_is_default(); 2123 return sym; 2124 } 2125 2126 if (Symbol_table::should_override_with_special(oldsym, type, defined)) 2127 this->override_with_special(oldsym, sym); 2128 2129 if (resolve_oldsym) 2130 return sym; 2131 else 2132 { 2133 if (binding == elfcpp::STB_LOCAL 2134 || this->version_script_.symbol_is_local(name)) 2135 this->force_local(oldsym); 2136 delete sym; 2137 return oldsym; 2138 } 2139 } 2140 2141 // Define a special symbol with a constant value. It is a multiple 2142 // definition error if this symbol is already defined. 2143 2144 Symbol* 2145 Symbol_table::define_as_constant(const char* name, 2146 const char* version, 2147 Defined defined, 2148 uint64_t value, 2149 uint64_t symsize, 2150 elfcpp::STT type, 2151 elfcpp::STB binding, 2152 elfcpp::STV visibility, 2153 unsigned char nonvis, 2154 bool only_if_ref, 2155 bool force_override) 2156 { 2157 if (parameters->target().get_size() == 32) 2158 { 2159 #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG) 2160 return this->do_define_as_constant<32>(name, version, defined, value, 2161 symsize, type, binding, 2162 visibility, nonvis, only_if_ref, 2163 force_override); 2164 #else 2165 gold_unreachable(); 2166 #endif 2167 } 2168 else if (parameters->target().get_size() == 64) 2169 { 2170 #if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG) 2171 return this->do_define_as_constant<64>(name, version, defined, value, 2172 symsize, type, binding, 2173 visibility, nonvis, only_if_ref, 2174 force_override); 2175 #else 2176 gold_unreachable(); 2177 #endif 2178 } 2179 else 2180 gold_unreachable(); 2181 } 2182 2183 // Define a symbol as a constant, sized version. 2184 2185 template<int size> 2186 Sized_symbol<size>* 2187 Symbol_table::do_define_as_constant( 2188 const char* name, 2189 const char* version, 2190 Defined defined, 2191 typename elfcpp::Elf_types<size>::Elf_Addr value, 2192 typename elfcpp::Elf_types<size>::Elf_WXword symsize, 2193 elfcpp::STT type, 2194 elfcpp::STB binding, 2195 elfcpp::STV visibility, 2196 unsigned char nonvis, 2197 bool only_if_ref, 2198 bool force_override) 2199 { 2200 Sized_symbol<size>* sym; 2201 Sized_symbol<size>* oldsym; 2202 bool resolve_oldsym; 2203 2204 if (parameters->target().is_big_endian()) 2205 { 2206 #if defined(HAVE_TARGET_32_BIG) || defined(HAVE_TARGET_64_BIG) 2207 sym = this->define_special_symbol<size, true>(&name, &version, 2208 only_if_ref, &oldsym, 2209 &resolve_oldsym); 2210 #else 2211 gold_unreachable(); 2212 #endif 2213 } 2214 else 2215 { 2216 #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_64_LITTLE) 2217 sym = this->define_special_symbol<size, false>(&name, &version, 2218 only_if_ref, &oldsym, 2219 &resolve_oldsym); 2220 #else 2221 gold_unreachable(); 2222 #endif 2223 } 2224 2225 if (sym == NULL) 2226 return NULL; 2227 2228 sym->init_constant(name, version, value, symsize, type, binding, visibility, 2229 nonvis, defined == PREDEFINED); 2230 2231 if (oldsym == NULL) 2232 { 2233 // Version symbols are absolute symbols with name == version. 2234 // We don't want to force them to be local. 2235 if ((version == NULL 2236 || name != version 2237 || value != 0) 2238 && (binding == elfcpp::STB_LOCAL 2239 || this->version_script_.symbol_is_local(name))) 2240 this->force_local(sym); 2241 else if (version != NULL 2242 && (name != version || value != 0)) 2243 sym->set_is_default(); 2244 return sym; 2245 } 2246 2247 if (force_override 2248 || Symbol_table::should_override_with_special(oldsym, type, defined)) 2249 this->override_with_special(oldsym, sym); 2250 2251 if (resolve_oldsym) 2252 return sym; 2253 else 2254 { 2255 if (binding == elfcpp::STB_LOCAL 2256 || this->version_script_.symbol_is_local(name)) 2257 this->force_local(oldsym); 2258 delete sym; 2259 return oldsym; 2260 } 2261 } 2262 2263 // Define a set of symbols in output sections. 2264 2265 void 2266 Symbol_table::define_symbols(const Layout* layout, int count, 2267 const Define_symbol_in_section* p, 2268 bool only_if_ref) 2269 { 2270 for (int i = 0; i < count; ++i, ++p) 2271 { 2272 Output_section* os = layout->find_output_section(p->output_section); 2273 if (os != NULL) 2274 this->define_in_output_data(p->name, NULL, PREDEFINED, os, p->value, 2275 p->size, p->type, p->binding, 2276 p->visibility, p->nonvis, 2277 p->offset_is_from_end, 2278 only_if_ref || p->only_if_ref); 2279 else 2280 this->define_as_constant(p->name, NULL, PREDEFINED, 0, p->size, 2281 p->type, p->binding, p->visibility, p->nonvis, 2282 only_if_ref || p->only_if_ref, 2283 false); 2284 } 2285 } 2286 2287 // Define a set of symbols in output segments. 2288 2289 void 2290 Symbol_table::define_symbols(const Layout* layout, int count, 2291 const Define_symbol_in_segment* p, 2292 bool only_if_ref) 2293 { 2294 for (int i = 0; i < count; ++i, ++p) 2295 { 2296 Output_segment* os = layout->find_output_segment(p->segment_type, 2297 p->segment_flags_set, 2298 p->segment_flags_clear); 2299 if (os != NULL) 2300 this->define_in_output_segment(p->name, NULL, PREDEFINED, os, p->value, 2301 p->size, p->type, p->binding, 2302 p->visibility, p->nonvis, 2303 p->offset_base, 2304 only_if_ref || p->only_if_ref); 2305 else 2306 this->define_as_constant(p->name, NULL, PREDEFINED, 0, p->size, 2307 p->type, p->binding, p->visibility, p->nonvis, 2308 only_if_ref || p->only_if_ref, 2309 false); 2310 } 2311 } 2312 2313 // Define CSYM using a COPY reloc. POSD is the Output_data where the 2314 // symbol should be defined--typically a .dyn.bss section. VALUE is 2315 // the offset within POSD. 2316 2317 template<int size> 2318 void 2319 Symbol_table::define_with_copy_reloc( 2320 Sized_symbol<size>* csym, 2321 Output_data* posd, 2322 typename elfcpp::Elf_types<size>::Elf_Addr value) 2323 { 2324 gold_assert(csym->is_from_dynobj()); 2325 gold_assert(!csym->is_copied_from_dynobj()); 2326 Object* object = csym->object(); 2327 gold_assert(object->is_dynamic()); 2328 Dynobj* dynobj = static_cast<Dynobj*>(object); 2329 2330 // Our copied variable has to override any variable in a shared 2331 // library. 2332 elfcpp::STB binding = csym->binding(); 2333 if (binding == elfcpp::STB_WEAK) 2334 binding = elfcpp::STB_GLOBAL; 2335 2336 this->define_in_output_data(csym->name(), csym->version(), COPY, 2337 posd, value, csym->symsize(), 2338 csym->type(), binding, 2339 csym->visibility(), csym->nonvis(), 2340 false, false); 2341 2342 csym->set_is_copied_from_dynobj(); 2343 csym->set_needs_dynsym_entry(); 2344 2345 this->copied_symbol_dynobjs_[csym] = dynobj; 2346 2347 // We have now defined all aliases, but we have not entered them all 2348 // in the copied_symbol_dynobjs_ map. 2349 if (csym->has_alias()) 2350 { 2351 Symbol* sym = csym; 2352 while (true) 2353 { 2354 sym = this->weak_aliases_[sym]; 2355 if (sym == csym) 2356 break; 2357 gold_assert(sym->output_data() == posd); 2358 2359 sym->set_is_copied_from_dynobj(); 2360 this->copied_symbol_dynobjs_[sym] = dynobj; 2361 } 2362 } 2363 } 2364 2365 // SYM is defined using a COPY reloc. Return the dynamic object where 2366 // the original definition was found. 2367 2368 Dynobj* 2369 Symbol_table::get_copy_source(const Symbol* sym) const 2370 { 2371 gold_assert(sym->is_copied_from_dynobj()); 2372 Copied_symbol_dynobjs::const_iterator p = 2373 this->copied_symbol_dynobjs_.find(sym); 2374 gold_assert(p != this->copied_symbol_dynobjs_.end()); 2375 return p->second; 2376 } 2377 2378 // Add any undefined symbols named on the command line. 2379 2380 void 2381 Symbol_table::add_undefined_symbols_from_command_line(Layout* layout) 2382 { 2383 if (parameters->options().any_undefined() 2384 || layout->script_options()->any_unreferenced()) 2385 { 2386 if (parameters->target().get_size() == 32) 2387 { 2388 #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG) 2389 this->do_add_undefined_symbols_from_command_line<32>(layout); 2390 #else 2391 gold_unreachable(); 2392 #endif 2393 } 2394 else if (parameters->target().get_size() == 64) 2395 { 2396 #if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG) 2397 this->do_add_undefined_symbols_from_command_line<64>(layout); 2398 #else 2399 gold_unreachable(); 2400 #endif 2401 } 2402 else 2403 gold_unreachable(); 2404 } 2405 } 2406 2407 template<int size> 2408 void 2409 Symbol_table::do_add_undefined_symbols_from_command_line(Layout* layout) 2410 { 2411 for (options::String_set::const_iterator p = 2412 parameters->options().undefined_begin(); 2413 p != parameters->options().undefined_end(); 2414 ++p) 2415 this->add_undefined_symbol_from_command_line<size>(p->c_str()); 2416 2417 for (options::String_set::const_iterator p = 2418 parameters->options().export_dynamic_symbol_begin(); 2419 p != parameters->options().export_dynamic_symbol_end(); 2420 ++p) 2421 this->add_undefined_symbol_from_command_line<size>(p->c_str()); 2422 2423 for (Script_options::referenced_const_iterator p = 2424 layout->script_options()->referenced_begin(); 2425 p != layout->script_options()->referenced_end(); 2426 ++p) 2427 this->add_undefined_symbol_from_command_line<size>(p->c_str()); 2428 } 2429 2430 template<int size> 2431 void 2432 Symbol_table::add_undefined_symbol_from_command_line(const char* name) 2433 { 2434 if (this->lookup(name) != NULL) 2435 return; 2436 2437 const char* version = NULL; 2438 2439 Sized_symbol<size>* sym; 2440 Sized_symbol<size>* oldsym; 2441 bool resolve_oldsym; 2442 if (parameters->target().is_big_endian()) 2443 { 2444 #if defined(HAVE_TARGET_32_BIG) || defined(HAVE_TARGET_64_BIG) 2445 sym = this->define_special_symbol<size, true>(&name, &version, 2446 false, &oldsym, 2447 &resolve_oldsym); 2448 #else 2449 gold_unreachable(); 2450 #endif 2451 } 2452 else 2453 { 2454 #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_64_LITTLE) 2455 sym = this->define_special_symbol<size, false>(&name, &version, 2456 false, &oldsym, 2457 &resolve_oldsym); 2458 #else 2459 gold_unreachable(); 2460 #endif 2461 } 2462 2463 gold_assert(oldsym == NULL); 2464 2465 sym->init_undefined(name, version, 0, elfcpp::STT_NOTYPE, elfcpp::STB_GLOBAL, 2466 elfcpp::STV_DEFAULT, 0); 2467 ++this->saw_undefined_; 2468 } 2469 2470 // Set the dynamic symbol indexes. INDEX is the index of the first 2471 // global dynamic symbol. Pointers to the symbols are stored into the 2472 // vector SYMS. The names are added to DYNPOOL. This returns an 2473 // updated dynamic symbol index. 2474 2475 unsigned int 2476 Symbol_table::set_dynsym_indexes(unsigned int index, 2477 std::vector<Symbol*>* syms, 2478 Stringpool* dynpool, 2479 Versions* versions) 2480 { 2481 std::vector<Symbol*> as_needed_sym; 2482 2483 // Allow a target to set dynsym indexes. 2484 if (parameters->target().has_custom_set_dynsym_indexes()) 2485 { 2486 std::vector<Symbol*> dyn_symbols; 2487 for (Symbol_table_type::iterator p = this->table_.begin(); 2488 p != this->table_.end(); 2489 ++p) 2490 { 2491 Symbol* sym = p->second; 2492 if (!sym->should_add_dynsym_entry(this)) 2493 sym->set_dynsym_index(-1U); 2494 else 2495 dyn_symbols.push_back(sym); 2496 } 2497 2498 return parameters->target().set_dynsym_indexes(&dyn_symbols, index, syms, 2499 dynpool, versions, this); 2500 } 2501 2502 for (Symbol_table_type::iterator p = this->table_.begin(); 2503 p != this->table_.end(); 2504 ++p) 2505 { 2506 Symbol* sym = p->second; 2507 2508 // Note that SYM may already have a dynamic symbol index, since 2509 // some symbols appear more than once in the symbol table, with 2510 // and without a version. 2511 2512 if (!sym->should_add_dynsym_entry(this)) 2513 sym->set_dynsym_index(-1U); 2514 else if (!sym->has_dynsym_index()) 2515 { 2516 sym->set_dynsym_index(index); 2517 ++index; 2518 syms->push_back(sym); 2519 dynpool->add(sym->name(), false, NULL); 2520 2521 // If the symbol is defined in a dynamic object and is 2522 // referenced strongly in a regular object, then mark the 2523 // dynamic object as needed. This is used to implement 2524 // --as-needed. 2525 if (sym->is_from_dynobj() 2526 && sym->in_reg() 2527 && !sym->is_undef_binding_weak()) 2528 sym->object()->set_is_needed(); 2529 2530 // Record any version information, except those from 2531 // as-needed libraries not seen to be needed. Note that the 2532 // is_needed state for such libraries can change in this loop. 2533 if (sym->version() != NULL) 2534 { 2535 if (!sym->is_from_dynobj() 2536 || !sym->object()->as_needed() 2537 || sym->object()->is_needed()) 2538 versions->record_version(this, dynpool, sym); 2539 else 2540 as_needed_sym.push_back(sym); 2541 } 2542 } 2543 } 2544 2545 // Process version information for symbols from as-needed libraries. 2546 for (std::vector<Symbol*>::iterator p = as_needed_sym.begin(); 2547 p != as_needed_sym.end(); 2548 ++p) 2549 { 2550 Symbol* sym = *p; 2551 2552 if (sym->object()->is_needed()) 2553 versions->record_version(this, dynpool, sym); 2554 else 2555 sym->clear_version(); 2556 } 2557 2558 // Finish up the versions. In some cases this may add new dynamic 2559 // symbols. 2560 index = versions->finalize(this, index, syms); 2561 2562 // Process target-specific symbols. 2563 for (std::vector<Symbol*>::iterator p = this->target_symbols_.begin(); 2564 p != this->target_symbols_.end(); 2565 ++p) 2566 { 2567 (*p)->set_dynsym_index(index); 2568 ++index; 2569 syms->push_back(*p); 2570 dynpool->add((*p)->name(), false, NULL); 2571 } 2572 2573 return index; 2574 } 2575 2576 // Set the final values for all the symbols. The index of the first 2577 // global symbol in the output file is *PLOCAL_SYMCOUNT. Record the 2578 // file offset OFF. Add their names to POOL. Return the new file 2579 // offset. Update *PLOCAL_SYMCOUNT if necessary. 2580 2581 off_t 2582 Symbol_table::finalize(off_t off, off_t dynoff, size_t dyn_global_index, 2583 size_t dyncount, Stringpool* pool, 2584 unsigned int* plocal_symcount) 2585 { 2586 off_t ret; 2587 2588 gold_assert(*plocal_symcount != 0); 2589 this->first_global_index_ = *plocal_symcount; 2590 2591 this->dynamic_offset_ = dynoff; 2592 this->first_dynamic_global_index_ = dyn_global_index; 2593 this->dynamic_count_ = dyncount; 2594 2595 if (parameters->target().get_size() == 32) 2596 { 2597 #if defined(HAVE_TARGET_32_BIG) || defined(HAVE_TARGET_32_LITTLE) 2598 ret = this->sized_finalize<32>(off, pool, plocal_symcount); 2599 #else 2600 gold_unreachable(); 2601 #endif 2602 } 2603 else if (parameters->target().get_size() == 64) 2604 { 2605 #if defined(HAVE_TARGET_64_BIG) || defined(HAVE_TARGET_64_LITTLE) 2606 ret = this->sized_finalize<64>(off, pool, plocal_symcount); 2607 #else 2608 gold_unreachable(); 2609 #endif 2610 } 2611 else 2612 gold_unreachable(); 2613 2614 // Now that we have the final symbol table, we can reliably note 2615 // which symbols should get warnings. 2616 this->warnings_.note_warnings(this); 2617 2618 return ret; 2619 } 2620 2621 // SYM is going into the symbol table at *PINDEX. Add the name to 2622 // POOL, update *PINDEX and *POFF. 2623 2624 template<int size> 2625 void 2626 Symbol_table::add_to_final_symtab(Symbol* sym, Stringpool* pool, 2627 unsigned int* pindex, off_t* poff) 2628 { 2629 sym->set_symtab_index(*pindex); 2630 if (sym->version() == NULL || !parameters->options().relocatable()) 2631 pool->add(sym->name(), false, NULL); 2632 else 2633 pool->add(sym->versioned_name(), true, NULL); 2634 ++*pindex; 2635 *poff += elfcpp::Elf_sizes<size>::sym_size; 2636 } 2637 2638 // Set the final value for all the symbols. This is called after 2639 // Layout::finalize, so all the output sections have their final 2640 // address. 2641 2642 template<int size> 2643 off_t 2644 Symbol_table::sized_finalize(off_t off, Stringpool* pool, 2645 unsigned int* plocal_symcount) 2646 { 2647 off = align_address(off, size >> 3); 2648 this->offset_ = off; 2649 2650 unsigned int index = *plocal_symcount; 2651 const unsigned int orig_index = index; 2652 2653 // First do all the symbols which have been forced to be local, as 2654 // they must appear before all global symbols. 2655 for (Forced_locals::iterator p = this->forced_locals_.begin(); 2656 p != this->forced_locals_.end(); 2657 ++p) 2658 { 2659 Symbol* sym = *p; 2660 gold_assert(sym->is_forced_local()); 2661 if (this->sized_finalize_symbol<size>(sym)) 2662 { 2663 this->add_to_final_symtab<size>(sym, pool, &index, &off); 2664 ++*plocal_symcount; 2665 } 2666 } 2667 2668 // Now do all the remaining symbols. 2669 for (Symbol_table_type::iterator p = this->table_.begin(); 2670 p != this->table_.end(); 2671 ++p) 2672 { 2673 Symbol* sym = p->second; 2674 if (this->sized_finalize_symbol<size>(sym)) 2675 this->add_to_final_symtab<size>(sym, pool, &index, &off); 2676 } 2677 2678 // Now do target-specific symbols. 2679 for (std::vector<Symbol*>::iterator p = this->target_symbols_.begin(); 2680 p != this->target_symbols_.end(); 2681 ++p) 2682 { 2683 this->add_to_final_symtab<size>(*p, pool, &index, &off); 2684 } 2685 2686 this->output_count_ = index - orig_index; 2687 2688 return off; 2689 } 2690 2691 // Compute the final value of SYM and store status in location PSTATUS. 2692 // During relaxation, this may be called multiple times for a symbol to 2693 // compute its would-be final value in each relaxation pass. 2694 2695 template<int size> 2696 typename Sized_symbol<size>::Value_type 2697 Symbol_table::compute_final_value( 2698 const Sized_symbol<size>* sym, 2699 Compute_final_value_status* pstatus) const 2700 { 2701 typedef typename Sized_symbol<size>::Value_type Value_type; 2702 Value_type value; 2703 2704 switch (sym->source()) 2705 { 2706 case Symbol::FROM_OBJECT: 2707 { 2708 bool is_ordinary; 2709 unsigned int shndx = sym->shndx(&is_ordinary); 2710 2711 if (!is_ordinary 2712 && shndx != elfcpp::SHN_ABS 2713 && !Symbol::is_common_shndx(shndx)) 2714 { 2715 *pstatus = CFVS_UNSUPPORTED_SYMBOL_SECTION; 2716 return 0; 2717 } 2718 2719 Object* symobj = sym->object(); 2720 if (symobj->is_dynamic()) 2721 { 2722 value = 0; 2723 shndx = elfcpp::SHN_UNDEF; 2724 } 2725 else if (symobj->pluginobj() != NULL) 2726 { 2727 value = 0; 2728 shndx = elfcpp::SHN_UNDEF; 2729 } 2730 else if (shndx == elfcpp::SHN_UNDEF) 2731 value = 0; 2732 else if (!is_ordinary 2733 && (shndx == elfcpp::SHN_ABS 2734 || Symbol::is_common_shndx(shndx))) 2735 value = sym->value(); 2736 else 2737 { 2738 Relobj* relobj = static_cast<Relobj*>(symobj); 2739 Output_section* os = relobj->output_section(shndx); 2740 2741 if (this->is_section_folded(relobj, shndx)) 2742 { 2743 gold_assert(os == NULL); 2744 // Get the os of the section it is folded onto. 2745 Section_id folded = this->icf_->get_folded_section(relobj, 2746 shndx); 2747 gold_assert(folded.first != NULL); 2748 Relobj* folded_obj = reinterpret_cast<Relobj*>(folded.first); 2749 unsigned folded_shndx = folded.second; 2750 2751 os = folded_obj->output_section(folded_shndx); 2752 gold_assert(os != NULL); 2753 2754 // Replace (relobj, shndx) with canonical ICF input section. 2755 shndx = folded_shndx; 2756 relobj = folded_obj; 2757 } 2758 2759 uint64_t secoff64 = relobj->output_section_offset(shndx); 2760 if (os == NULL) 2761 { 2762 bool static_or_reloc = (parameters->doing_static_link() || 2763 parameters->options().relocatable()); 2764 gold_assert(static_or_reloc || sym->dynsym_index() == -1U); 2765 2766 *pstatus = CFVS_NO_OUTPUT_SECTION; 2767 return 0; 2768 } 2769 2770 if (secoff64 == -1ULL) 2771 { 2772 // The section needs special handling (e.g., a merge section). 2773 2774 value = os->output_address(relobj, shndx, sym->value()); 2775 } 2776 else 2777 { 2778 Value_type secoff = 2779 convert_types<Value_type, uint64_t>(secoff64); 2780 if (sym->type() == elfcpp::STT_TLS) 2781 value = sym->value() + os->tls_offset() + secoff; 2782 else 2783 value = sym->value() + os->address() + secoff; 2784 } 2785 } 2786 } 2787 break; 2788 2789 case Symbol::IN_OUTPUT_DATA: 2790 { 2791 Output_data* od = sym->output_data(); 2792 value = sym->value(); 2793 if (sym->type() != elfcpp::STT_TLS) 2794 value += od->address(); 2795 else 2796 { 2797 Output_section* os = od->output_section(); 2798 gold_assert(os != NULL); 2799 value += os->tls_offset() + (od->address() - os->address()); 2800 } 2801 if (sym->offset_is_from_end()) 2802 value += od->data_size(); 2803 } 2804 break; 2805 2806 case Symbol::IN_OUTPUT_SEGMENT: 2807 { 2808 Output_segment* os = sym->output_segment(); 2809 value = sym->value(); 2810 if (sym->type() != elfcpp::STT_TLS) 2811 value += os->vaddr(); 2812 switch (sym->offset_base()) 2813 { 2814 case Symbol::SEGMENT_START: 2815 break; 2816 case Symbol::SEGMENT_END: 2817 value += os->memsz(); 2818 break; 2819 case Symbol::SEGMENT_BSS: 2820 value += os->filesz(); 2821 break; 2822 default: 2823 gold_unreachable(); 2824 } 2825 } 2826 break; 2827 2828 case Symbol::IS_CONSTANT: 2829 value = sym->value(); 2830 break; 2831 2832 case Symbol::IS_UNDEFINED: 2833 value = 0; 2834 break; 2835 2836 default: 2837 gold_unreachable(); 2838 } 2839 2840 *pstatus = CFVS_OK; 2841 return value; 2842 } 2843 2844 // Finalize the symbol SYM. This returns true if the symbol should be 2845 // added to the symbol table, false otherwise. 2846 2847 template<int size> 2848 bool 2849 Symbol_table::sized_finalize_symbol(Symbol* unsized_sym) 2850 { 2851 typedef typename Sized_symbol<size>::Value_type Value_type; 2852 2853 Sized_symbol<size>* sym = static_cast<Sized_symbol<size>*>(unsized_sym); 2854 2855 // The default version of a symbol may appear twice in the symbol 2856 // table. We only need to finalize it once. 2857 if (sym->has_symtab_index()) 2858 return false; 2859 2860 if (!sym->in_reg()) 2861 { 2862 gold_assert(!sym->has_symtab_index()); 2863 sym->set_symtab_index(-1U); 2864 gold_assert(sym->dynsym_index() == -1U); 2865 return false; 2866 } 2867 2868 // If the symbol is only present on plugin files, the plugin decided we 2869 // don't need it. 2870 if (!sym->in_real_elf()) 2871 { 2872 gold_assert(!sym->has_symtab_index()); 2873 sym->set_symtab_index(-1U); 2874 return false; 2875 } 2876 2877 // Compute final symbol value. 2878 Compute_final_value_status status; 2879 Value_type value = this->compute_final_value(sym, &status); 2880 2881 switch (status) 2882 { 2883 case CFVS_OK: 2884 break; 2885 case CFVS_UNSUPPORTED_SYMBOL_SECTION: 2886 { 2887 bool is_ordinary; 2888 unsigned int shndx = sym->shndx(&is_ordinary); 2889 gold_error(_("%s: unsupported symbol section 0x%x"), 2890 sym->demangled_name().c_str(), shndx); 2891 } 2892 break; 2893 case CFVS_NO_OUTPUT_SECTION: 2894 sym->set_symtab_index(-1U); 2895 return false; 2896 default: 2897 gold_unreachable(); 2898 } 2899 2900 sym->set_value(value); 2901 2902 if (parameters->options().strip_all() 2903 || !parameters->options().should_retain_symbol(sym->name())) 2904 { 2905 sym->set_symtab_index(-1U); 2906 return false; 2907 } 2908 2909 return true; 2910 } 2911 2912 // Write out the global symbols. 2913 2914 void 2915 Symbol_table::write_globals(const Stringpool* sympool, 2916 const Stringpool* dynpool, 2917 Output_symtab_xindex* symtab_xindex, 2918 Output_symtab_xindex* dynsym_xindex, 2919 Output_file* of) const 2920 { 2921 switch (parameters->size_and_endianness()) 2922 { 2923 #ifdef HAVE_TARGET_32_LITTLE 2924 case Parameters::TARGET_32_LITTLE: 2925 this->sized_write_globals<32, false>(sympool, dynpool, symtab_xindex, 2926 dynsym_xindex, of); 2927 break; 2928 #endif 2929 #ifdef HAVE_TARGET_32_BIG 2930 case Parameters::TARGET_32_BIG: 2931 this->sized_write_globals<32, true>(sympool, dynpool, symtab_xindex, 2932 dynsym_xindex, of); 2933 break; 2934 #endif 2935 #ifdef HAVE_TARGET_64_LITTLE 2936 case Parameters::TARGET_64_LITTLE: 2937 this->sized_write_globals<64, false>(sympool, dynpool, symtab_xindex, 2938 dynsym_xindex, of); 2939 break; 2940 #endif 2941 #ifdef HAVE_TARGET_64_BIG 2942 case Parameters::TARGET_64_BIG: 2943 this->sized_write_globals<64, true>(sympool, dynpool, symtab_xindex, 2944 dynsym_xindex, of); 2945 break; 2946 #endif 2947 default: 2948 gold_unreachable(); 2949 } 2950 } 2951 2952 // Write out the global symbols. 2953 2954 template<int size, bool big_endian> 2955 void 2956 Symbol_table::sized_write_globals(const Stringpool* sympool, 2957 const Stringpool* dynpool, 2958 Output_symtab_xindex* symtab_xindex, 2959 Output_symtab_xindex* dynsym_xindex, 2960 Output_file* of) const 2961 { 2962 const Target& target = parameters->target(); 2963 2964 const int sym_size = elfcpp::Elf_sizes<size>::sym_size; 2965 2966 const unsigned int output_count = this->output_count_; 2967 const section_size_type oview_size = output_count * sym_size; 2968 const unsigned int first_global_index = this->first_global_index_; 2969 unsigned char* psyms; 2970 if (this->offset_ == 0 || output_count == 0) 2971 psyms = NULL; 2972 else 2973 psyms = of->get_output_view(this->offset_, oview_size); 2974 2975 const unsigned int dynamic_count = this->dynamic_count_; 2976 const section_size_type dynamic_size = dynamic_count * sym_size; 2977 const unsigned int first_dynamic_global_index = 2978 this->first_dynamic_global_index_; 2979 unsigned char* dynamic_view; 2980 if (this->dynamic_offset_ == 0 || dynamic_count == 0) 2981 dynamic_view = NULL; 2982 else 2983 dynamic_view = of->get_output_view(this->dynamic_offset_, dynamic_size); 2984 2985 for (Symbol_table_type::const_iterator p = this->table_.begin(); 2986 p != this->table_.end(); 2987 ++p) 2988 { 2989 Sized_symbol<size>* sym = static_cast<Sized_symbol<size>*>(p->second); 2990 2991 // Possibly warn about unresolved symbols in shared libraries. 2992 this->warn_about_undefined_dynobj_symbol(sym); 2993 2994 unsigned int sym_index = sym->symtab_index(); 2995 unsigned int dynsym_index; 2996 if (dynamic_view == NULL) 2997 dynsym_index = -1U; 2998 else 2999 dynsym_index = sym->dynsym_index(); 3000 3001 if (sym_index == -1U && dynsym_index == -1U) 3002 { 3003 // This symbol is not included in the output file. 3004 continue; 3005 } 3006 3007 unsigned int shndx; 3008 typename elfcpp::Elf_types<size>::Elf_Addr sym_value = sym->value(); 3009 typename elfcpp::Elf_types<size>::Elf_Addr dynsym_value = sym_value; 3010 elfcpp::STB binding = sym->binding(); 3011 3012 // If --weak-unresolved-symbols is set, change binding of unresolved 3013 // global symbols to STB_WEAK. 3014 if (parameters->options().weak_unresolved_symbols() 3015 && binding == elfcpp::STB_GLOBAL 3016 && sym->is_undefined()) 3017 binding = elfcpp::STB_WEAK; 3018 3019 // If --no-gnu-unique is set, change STB_GNU_UNIQUE to STB_GLOBAL. 3020 if (binding == elfcpp::STB_GNU_UNIQUE 3021 && !parameters->options().gnu_unique()) 3022 binding = elfcpp::STB_GLOBAL; 3023 3024 switch (sym->source()) 3025 { 3026 case Symbol::FROM_OBJECT: 3027 { 3028 bool is_ordinary; 3029 unsigned int in_shndx = sym->shndx(&is_ordinary); 3030 3031 if (!is_ordinary 3032 && in_shndx != elfcpp::SHN_ABS 3033 && !Symbol::is_common_shndx(in_shndx)) 3034 { 3035 gold_error(_("%s: unsupported symbol section 0x%x"), 3036 sym->demangled_name().c_str(), in_shndx); 3037 shndx = in_shndx; 3038 } 3039 else 3040 { 3041 Object* symobj = sym->object(); 3042 if (symobj->is_dynamic()) 3043 { 3044 if (sym->needs_dynsym_value()) 3045 dynsym_value = target.dynsym_value(sym); 3046 shndx = elfcpp::SHN_UNDEF; 3047 if (sym->is_undef_binding_weak()) 3048 binding = elfcpp::STB_WEAK; 3049 else 3050 binding = elfcpp::STB_GLOBAL; 3051 } 3052 else if (symobj->pluginobj() != NULL) 3053 shndx = elfcpp::SHN_UNDEF; 3054 else if (in_shndx == elfcpp::SHN_UNDEF 3055 || (!is_ordinary 3056 && (in_shndx == elfcpp::SHN_ABS 3057 || Symbol::is_common_shndx(in_shndx)))) 3058 shndx = in_shndx; 3059 else 3060 { 3061 Relobj* relobj = static_cast<Relobj*>(symobj); 3062 Output_section* os = relobj->output_section(in_shndx); 3063 if (this->is_section_folded(relobj, in_shndx)) 3064 { 3065 // This global symbol must be written out even though 3066 // it is folded. 3067 // Get the os of the section it is folded onto. 3068 Section_id folded = 3069 this->icf_->get_folded_section(relobj, in_shndx); 3070 gold_assert(folded.first !=NULL); 3071 Relobj* folded_obj = 3072 reinterpret_cast<Relobj*>(folded.first); 3073 os = folded_obj->output_section(folded.second); 3074 gold_assert(os != NULL); 3075 } 3076 gold_assert(os != NULL); 3077 shndx = os->out_shndx(); 3078 3079 if (shndx >= elfcpp::SHN_LORESERVE) 3080 { 3081 if (sym_index != -1U) 3082 symtab_xindex->add(sym_index, shndx); 3083 if (dynsym_index != -1U) 3084 dynsym_xindex->add(dynsym_index, shndx); 3085 shndx = elfcpp::SHN_XINDEX; 3086 } 3087 3088 // In object files symbol values are section 3089 // relative. 3090 if (parameters->options().relocatable()) 3091 sym_value -= os->address(); 3092 } 3093 } 3094 } 3095 break; 3096 3097 case Symbol::IN_OUTPUT_DATA: 3098 { 3099 Output_data* od = sym->output_data(); 3100 3101 shndx = od->out_shndx(); 3102 if (shndx >= elfcpp::SHN_LORESERVE) 3103 { 3104 if (sym_index != -1U) 3105 symtab_xindex->add(sym_index, shndx); 3106 if (dynsym_index != -1U) 3107 dynsym_xindex->add(dynsym_index, shndx); 3108 shndx = elfcpp::SHN_XINDEX; 3109 } 3110 3111 // In object files symbol values are section 3112 // relative. 3113 if (parameters->options().relocatable()) 3114 sym_value -= od->address(); 3115 } 3116 break; 3117 3118 case Symbol::IN_OUTPUT_SEGMENT: 3119 shndx = elfcpp::SHN_ABS; 3120 break; 3121 3122 case Symbol::IS_CONSTANT: 3123 shndx = elfcpp::SHN_ABS; 3124 break; 3125 3126 case Symbol::IS_UNDEFINED: 3127 shndx = elfcpp::SHN_UNDEF; 3128 break; 3129 3130 default: 3131 gold_unreachable(); 3132 } 3133 3134 if (sym_index != -1U) 3135 { 3136 sym_index -= first_global_index; 3137 gold_assert(sym_index < output_count); 3138 unsigned char* ps = psyms + (sym_index * sym_size); 3139 this->sized_write_symbol<size, big_endian>(sym, sym_value, shndx, 3140 binding, sympool, ps); 3141 } 3142 3143 if (dynsym_index != -1U) 3144 { 3145 dynsym_index -= first_dynamic_global_index; 3146 gold_assert(dynsym_index < dynamic_count); 3147 unsigned char* pd = dynamic_view + (dynsym_index * sym_size); 3148 this->sized_write_symbol<size, big_endian>(sym, dynsym_value, shndx, 3149 binding, dynpool, pd); 3150 // Allow a target to adjust dynamic symbol value. 3151 parameters->target().adjust_dyn_symbol(sym, pd); 3152 } 3153 } 3154 3155 // Write the target-specific symbols. 3156 for (std::vector<Symbol*>::const_iterator p = this->target_symbols_.begin(); 3157 p != this->target_symbols_.end(); 3158 ++p) 3159 { 3160 Sized_symbol<size>* sym = static_cast<Sized_symbol<size>*>(*p); 3161 3162 unsigned int sym_index = sym->symtab_index(); 3163 unsigned int dynsym_index; 3164 if (dynamic_view == NULL) 3165 dynsym_index = -1U; 3166 else 3167 dynsym_index = sym->dynsym_index(); 3168 3169 unsigned int shndx; 3170 switch (sym->source()) 3171 { 3172 case Symbol::IS_CONSTANT: 3173 shndx = elfcpp::SHN_ABS; 3174 break; 3175 case Symbol::IS_UNDEFINED: 3176 shndx = elfcpp::SHN_UNDEF; 3177 break; 3178 default: 3179 gold_unreachable(); 3180 } 3181 3182 if (sym_index != -1U) 3183 { 3184 sym_index -= first_global_index; 3185 gold_assert(sym_index < output_count); 3186 unsigned char* ps = psyms + (sym_index * sym_size); 3187 this->sized_write_symbol<size, big_endian>(sym, sym->value(), shndx, 3188 sym->binding(), sympool, 3189 ps); 3190 } 3191 3192 if (dynsym_index != -1U) 3193 { 3194 dynsym_index -= first_dynamic_global_index; 3195 gold_assert(dynsym_index < dynamic_count); 3196 unsigned char* pd = dynamic_view + (dynsym_index * sym_size); 3197 this->sized_write_symbol<size, big_endian>(sym, sym->value(), shndx, 3198 sym->binding(), dynpool, 3199 pd); 3200 } 3201 } 3202 3203 of->write_output_view(this->offset_, oview_size, psyms); 3204 if (dynamic_view != NULL) 3205 of->write_output_view(this->dynamic_offset_, dynamic_size, dynamic_view); 3206 } 3207 3208 // Write out the symbol SYM, in section SHNDX, to P. POOL is the 3209 // strtab holding the name. 3210 3211 template<int size, bool big_endian> 3212 void 3213 Symbol_table::sized_write_symbol( 3214 Sized_symbol<size>* sym, 3215 typename elfcpp::Elf_types<size>::Elf_Addr value, 3216 unsigned int shndx, 3217 elfcpp::STB binding, 3218 const Stringpool* pool, 3219 unsigned char* p) const 3220 { 3221 elfcpp::Sym_write<size, big_endian> osym(p); 3222 if (sym->version() == NULL || !parameters->options().relocatable()) 3223 osym.put_st_name(pool->get_offset(sym->name())); 3224 else 3225 osym.put_st_name(pool->get_offset(sym->versioned_name())); 3226 osym.put_st_value(value); 3227 // Use a symbol size of zero for undefined symbols from shared libraries. 3228 if (shndx == elfcpp::SHN_UNDEF && sym->is_from_dynobj()) 3229 osym.put_st_size(0); 3230 else 3231 osym.put_st_size(sym->symsize()); 3232 elfcpp::STT type = sym->type(); 3233 gold_assert(type != elfcpp::STT_GNU_IFUNC || !sym->is_from_dynobj()); 3234 // A version script may have overridden the default binding. 3235 if (sym->is_forced_local()) 3236 osym.put_st_info(elfcpp::elf_st_info(elfcpp::STB_LOCAL, type)); 3237 else 3238 osym.put_st_info(elfcpp::elf_st_info(binding, type)); 3239 osym.put_st_other(elfcpp::elf_st_other(sym->visibility(), sym->nonvis())); 3240 osym.put_st_shndx(shndx); 3241 } 3242 3243 // Check for unresolved symbols in shared libraries. This is 3244 // controlled by the --allow-shlib-undefined option. 3245 3246 // We only warn about libraries for which we have seen all the 3247 // DT_NEEDED entries. We don't try to track down DT_NEEDED entries 3248 // which were not seen in this link. If we didn't see a DT_NEEDED 3249 // entry, we aren't going to be able to reliably report whether the 3250 // symbol is undefined. 3251 3252 // We also don't warn about libraries found in a system library 3253 // directory (e.g., /lib or /usr/lib); we assume that those libraries 3254 // are OK. This heuristic avoids problems on GNU/Linux, in which -ldl 3255 // can have undefined references satisfied by ld-linux.so. 3256 3257 inline void 3258 Symbol_table::warn_about_undefined_dynobj_symbol(Symbol* sym) const 3259 { 3260 bool dummy; 3261 if (sym->source() == Symbol::FROM_OBJECT 3262 && sym->object()->is_dynamic() 3263 && sym->shndx(&dummy) == elfcpp::SHN_UNDEF 3264 && sym->binding() != elfcpp::STB_WEAK 3265 && !parameters->options().allow_shlib_undefined() 3266 && !parameters->target().is_defined_by_abi(sym) 3267 && !sym->object()->is_in_system_directory()) 3268 { 3269 // A very ugly cast. 3270 Dynobj* dynobj = static_cast<Dynobj*>(sym->object()); 3271 if (!dynobj->has_unknown_needed_entries()) 3272 gold_undefined_symbol(sym); 3273 } 3274 } 3275 3276 // Write out a section symbol. Return the update offset. 3277 3278 void 3279 Symbol_table::write_section_symbol(const Output_section* os, 3280 Output_symtab_xindex* symtab_xindex, 3281 Output_file* of, 3282 off_t offset) const 3283 { 3284 switch (parameters->size_and_endianness()) 3285 { 3286 #ifdef HAVE_TARGET_32_LITTLE 3287 case Parameters::TARGET_32_LITTLE: 3288 this->sized_write_section_symbol<32, false>(os, symtab_xindex, of, 3289 offset); 3290 break; 3291 #endif 3292 #ifdef HAVE_TARGET_32_BIG 3293 case Parameters::TARGET_32_BIG: 3294 this->sized_write_section_symbol<32, true>(os, symtab_xindex, of, 3295 offset); 3296 break; 3297 #endif 3298 #ifdef HAVE_TARGET_64_LITTLE 3299 case Parameters::TARGET_64_LITTLE: 3300 this->sized_write_section_symbol<64, false>(os, symtab_xindex, of, 3301 offset); 3302 break; 3303 #endif 3304 #ifdef HAVE_TARGET_64_BIG 3305 case Parameters::TARGET_64_BIG: 3306 this->sized_write_section_symbol<64, true>(os, symtab_xindex, of, 3307 offset); 3308 break; 3309 #endif 3310 default: 3311 gold_unreachable(); 3312 } 3313 } 3314 3315 // Write out a section symbol, specialized for size and endianness. 3316 3317 template<int size, bool big_endian> 3318 void 3319 Symbol_table::sized_write_section_symbol(const Output_section* os, 3320 Output_symtab_xindex* symtab_xindex, 3321 Output_file* of, 3322 off_t offset) const 3323 { 3324 const int sym_size = elfcpp::Elf_sizes<size>::sym_size; 3325 3326 unsigned char* pov = of->get_output_view(offset, sym_size); 3327 3328 elfcpp::Sym_write<size, big_endian> osym(pov); 3329 osym.put_st_name(0); 3330 if (parameters->options().relocatable()) 3331 osym.put_st_value(0); 3332 else 3333 osym.put_st_value(os->address()); 3334 osym.put_st_size(0); 3335 osym.put_st_info(elfcpp::elf_st_info(elfcpp::STB_LOCAL, 3336 elfcpp::STT_SECTION)); 3337 osym.put_st_other(elfcpp::elf_st_other(elfcpp::STV_DEFAULT, 0)); 3338 3339 unsigned int shndx = os->out_shndx(); 3340 if (shndx >= elfcpp::SHN_LORESERVE) 3341 { 3342 symtab_xindex->add(os->symtab_index(), shndx); 3343 shndx = elfcpp::SHN_XINDEX; 3344 } 3345 osym.put_st_shndx(shndx); 3346 3347 of->write_output_view(offset, sym_size, pov); 3348 } 3349 3350 // Print statistical information to stderr. This is used for --stats. 3351 3352 void 3353 Symbol_table::print_stats() const 3354 { 3355 #if defined(HAVE_TR1_UNORDERED_MAP) || defined(HAVE_EXT_HASH_MAP) 3356 fprintf(stderr, _("%s: symbol table entries: %zu; buckets: %zu\n"), 3357 program_name, this->table_.size(), this->table_.bucket_count()); 3358 #else 3359 fprintf(stderr, _("%s: symbol table entries: %zu\n"), 3360 program_name, this->table_.size()); 3361 #endif 3362 this->namepool_.print_stats("symbol table stringpool"); 3363 } 3364 3365 // We check for ODR violations by looking for symbols with the same 3366 // name for which the debugging information reports that they were 3367 // defined in disjoint source locations. When comparing the source 3368 // location, we consider instances with the same base filename to be 3369 // the same. This is because different object files/shared libraries 3370 // can include the same header file using different paths, and 3371 // different optimization settings can make the line number appear to 3372 // be a couple lines off, and we don't want to report an ODR violation 3373 // in those cases. 3374 3375 // This struct is used to compare line information, as returned by 3376 // Dwarf_line_info::one_addr2line. It implements a < comparison 3377 // operator used with std::sort. 3378 3379 struct Odr_violation_compare 3380 { 3381 bool 3382 operator()(const std::string& s1, const std::string& s2) const 3383 { 3384 // Inputs should be of the form "dirname/filename:linenum" where 3385 // "dirname/" is optional. We want to compare just the filename:linenum. 3386 3387 // Find the last '/' in each string. 3388 std::string::size_type s1begin = s1.rfind('/'); 3389 std::string::size_type s2begin = s2.rfind('/'); 3390 // If there was no '/' in a string, start at the beginning. 3391 if (s1begin == std::string::npos) 3392 s1begin = 0; 3393 if (s2begin == std::string::npos) 3394 s2begin = 0; 3395 return s1.compare(s1begin, std::string::npos, 3396 s2, s2begin, std::string::npos) < 0; 3397 } 3398 }; 3399 3400 // Returns all of the lines attached to LOC, not just the one the 3401 // instruction actually came from. 3402 std::vector<std::string> 3403 Symbol_table::linenos_from_loc(const Task* task, 3404 const Symbol_location& loc) 3405 { 3406 // We need to lock the object in order to read it. This 3407 // means that we have to run in a singleton Task. If we 3408 // want to run this in a general Task for better 3409 // performance, we will need one Task for object, plus 3410 // appropriate locking to ensure that we don't conflict with 3411 // other uses of the object. Also note, one_addr2line is not 3412 // currently thread-safe. 3413 Task_lock_obj<Object> tl(task, loc.object); 3414 3415 std::vector<std::string> result; 3416 Symbol_location code_loc = loc; 3417 parameters->target().function_location(&code_loc); 3418 // 16 is the size of the object-cache that one_addr2line should use. 3419 std::string canonical_result = Dwarf_line_info::one_addr2line( 3420 code_loc.object, code_loc.shndx, code_loc.offset, 16, &result); 3421 if (!canonical_result.empty()) 3422 result.push_back(canonical_result); 3423 return result; 3424 } 3425 3426 // OutputIterator that records if it was ever assigned to. This 3427 // allows it to be used with std::set_intersection() to check for 3428 // intersection rather than computing the intersection. 3429 struct Check_intersection 3430 { 3431 Check_intersection() 3432 : value_(false) 3433 {} 3434 3435 bool had_intersection() const 3436 { return this->value_; } 3437 3438 Check_intersection& operator++() 3439 { return *this; } 3440 3441 Check_intersection& operator*() 3442 { return *this; } 3443 3444 template<typename T> 3445 Check_intersection& operator=(const T&) 3446 { 3447 this->value_ = true; 3448 return *this; 3449 } 3450 3451 private: 3452 bool value_; 3453 }; 3454 3455 // Check candidate_odr_violations_ to find symbols with the same name 3456 // but apparently different definitions (different source-file/line-no 3457 // for each line assigned to the first instruction). 3458 3459 void 3460 Symbol_table::detect_odr_violations(const Task* task, 3461 const char* output_file_name) const 3462 { 3463 for (Odr_map::const_iterator it = candidate_odr_violations_.begin(); 3464 it != candidate_odr_violations_.end(); 3465 ++it) 3466 { 3467 const char* const symbol_name = it->first; 3468 3469 std::string first_object_name; 3470 std::vector<std::string> first_object_linenos; 3471 3472 Unordered_set<Symbol_location, Symbol_location_hash>::const_iterator 3473 locs = it->second.begin(); 3474 const Unordered_set<Symbol_location, Symbol_location_hash>::const_iterator 3475 locs_end = it->second.end(); 3476 for (; locs != locs_end && first_object_linenos.empty(); ++locs) 3477 { 3478 // Save the line numbers from the first definition to 3479 // compare to the other definitions. Ideally, we'd compare 3480 // every definition to every other, but we don't want to 3481 // take O(N^2) time to do this. This shortcut may cause 3482 // false negatives that appear or disappear depending on the 3483 // link order, but it won't cause false positives. 3484 first_object_name = locs->object->name(); 3485 first_object_linenos = this->linenos_from_loc(task, *locs); 3486 } 3487 if (first_object_linenos.empty()) 3488 continue; 3489 3490 // Sort by Odr_violation_compare to make std::set_intersection work. 3491 std::string first_object_canonical_result = first_object_linenos.back(); 3492 std::sort(first_object_linenos.begin(), first_object_linenos.end(), 3493 Odr_violation_compare()); 3494 3495 for (; locs != locs_end; ++locs) 3496 { 3497 std::vector<std::string> linenos = 3498 this->linenos_from_loc(task, *locs); 3499 // linenos will be empty if we couldn't parse the debug info. 3500 if (linenos.empty()) 3501 continue; 3502 // Sort by Odr_violation_compare to make std::set_intersection work. 3503 gold_assert(!linenos.empty()); 3504 std::string second_object_canonical_result = linenos.back(); 3505 std::sort(linenos.begin(), linenos.end(), Odr_violation_compare()); 3506 3507 Check_intersection intersection_result = 3508 std::set_intersection(first_object_linenos.begin(), 3509 first_object_linenos.end(), 3510 linenos.begin(), 3511 linenos.end(), 3512 Check_intersection(), 3513 Odr_violation_compare()); 3514 if (!intersection_result.had_intersection()) 3515 { 3516 gold_warning(_("while linking %s: symbol '%s' defined in " 3517 "multiple places (possible ODR violation):"), 3518 output_file_name, demangle(symbol_name).c_str()); 3519 // This only prints one location from each definition, 3520 // which may not be the location we expect to intersect 3521 // with another definition. We could print the whole 3522 // set of locations, but that seems too verbose. 3523 fprintf(stderr, _(" %s from %s\n"), 3524 first_object_canonical_result.c_str(), 3525 first_object_name.c_str()); 3526 fprintf(stderr, _(" %s from %s\n"), 3527 second_object_canonical_result.c_str(), 3528 locs->object->name().c_str()); 3529 // Only print one broken pair, to avoid needing to 3530 // compare against a list of the disjoint definition 3531 // locations we've found so far. (If we kept comparing 3532 // against just the first one, we'd get a lot of 3533 // redundant complaints about the second definition 3534 // location.) 3535 break; 3536 } 3537 } 3538 } 3539 // We only call one_addr2line() in this function, so we can clear its cache. 3540 Dwarf_line_info::clear_addr2line_cache(); 3541 } 3542 3543 // Warnings functions. 3544 3545 // Add a new warning. 3546 3547 void 3548 Warnings::add_warning(Symbol_table* symtab, const char* name, Object* obj, 3549 const std::string& warning) 3550 { 3551 name = symtab->canonicalize_name(name); 3552 this->warnings_[name].set(obj, warning); 3553 } 3554 3555 // Look through the warnings and mark the symbols for which we should 3556 // warn. This is called during Layout::finalize when we know the 3557 // sources for all the symbols. 3558 3559 void 3560 Warnings::note_warnings(Symbol_table* symtab) 3561 { 3562 for (Warning_table::iterator p = this->warnings_.begin(); 3563 p != this->warnings_.end(); 3564 ++p) 3565 { 3566 Symbol* sym = symtab->lookup(p->first, NULL); 3567 if (sym != NULL 3568 && sym->source() == Symbol::FROM_OBJECT 3569 && sym->object() == p->second.object) 3570 sym->set_has_warning(); 3571 } 3572 } 3573 3574 // Issue a warning. This is called when we see a relocation against a 3575 // symbol for which has a warning. 3576 3577 template<int size, bool big_endian> 3578 void 3579 Warnings::issue_warning(const Symbol* sym, 3580 const Relocate_info<size, big_endian>* relinfo, 3581 size_t relnum, off_t reloffset) const 3582 { 3583 gold_assert(sym->has_warning()); 3584 3585 // We don't want to issue a warning for a relocation against the 3586 // symbol in the same object file in which the symbol is defined. 3587 if (sym->object() == relinfo->object) 3588 return; 3589 3590 Warning_table::const_iterator p = this->warnings_.find(sym->name()); 3591 gold_assert(p != this->warnings_.end()); 3592 gold_warning_at_location(relinfo, relnum, reloffset, 3593 "%s", p->second.text.c_str()); 3594 } 3595 3596 // Instantiate the templates we need. We could use the configure 3597 // script to restrict this to only the ones needed for implemented 3598 // targets. 3599 3600 #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG) 3601 template 3602 void 3603 Sized_symbol<32>::allocate_common(Output_data*, Value_type); 3604 #endif 3605 3606 #if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG) 3607 template 3608 void 3609 Sized_symbol<64>::allocate_common(Output_data*, Value_type); 3610 #endif 3611 3612 #ifdef HAVE_TARGET_32_LITTLE 3613 template 3614 void 3615 Symbol_table::add_from_relobj<32, false>( 3616 Sized_relobj_file<32, false>* relobj, 3617 const unsigned char* syms, 3618 size_t count, 3619 size_t symndx_offset, 3620 const char* sym_names, 3621 size_t sym_name_size, 3622 Sized_relobj_file<32, false>::Symbols* sympointers, 3623 size_t* defined); 3624 #endif 3625 3626 #ifdef HAVE_TARGET_32_BIG 3627 template 3628 void 3629 Symbol_table::add_from_relobj<32, true>( 3630 Sized_relobj_file<32, true>* relobj, 3631 const unsigned char* syms, 3632 size_t count, 3633 size_t symndx_offset, 3634 const char* sym_names, 3635 size_t sym_name_size, 3636 Sized_relobj_file<32, true>::Symbols* sympointers, 3637 size_t* defined); 3638 #endif 3639 3640 #ifdef HAVE_TARGET_64_LITTLE 3641 template 3642 void 3643 Symbol_table::add_from_relobj<64, false>( 3644 Sized_relobj_file<64, false>* relobj, 3645 const unsigned char* syms, 3646 size_t count, 3647 size_t symndx_offset, 3648 const char* sym_names, 3649 size_t sym_name_size, 3650 Sized_relobj_file<64, false>::Symbols* sympointers, 3651 size_t* defined); 3652 #endif 3653 3654 #ifdef HAVE_TARGET_64_BIG 3655 template 3656 void 3657 Symbol_table::add_from_relobj<64, true>( 3658 Sized_relobj_file<64, true>* relobj, 3659 const unsigned char* syms, 3660 size_t count, 3661 size_t symndx_offset, 3662 const char* sym_names, 3663 size_t sym_name_size, 3664 Sized_relobj_file<64, true>::Symbols* sympointers, 3665 size_t* defined); 3666 #endif 3667 3668 #ifdef HAVE_TARGET_32_LITTLE 3669 template 3670 Symbol* 3671 Symbol_table::add_from_pluginobj<32, false>( 3672 Sized_pluginobj<32, false>* obj, 3673 const char* name, 3674 const char* ver, 3675 elfcpp::Sym<32, false>* sym); 3676 #endif 3677 3678 #ifdef HAVE_TARGET_32_BIG 3679 template 3680 Symbol* 3681 Symbol_table::add_from_pluginobj<32, true>( 3682 Sized_pluginobj<32, true>* obj, 3683 const char* name, 3684 const char* ver, 3685 elfcpp::Sym<32, true>* sym); 3686 #endif 3687 3688 #ifdef HAVE_TARGET_64_LITTLE 3689 template 3690 Symbol* 3691 Symbol_table::add_from_pluginobj<64, false>( 3692 Sized_pluginobj<64, false>* obj, 3693 const char* name, 3694 const char* ver, 3695 elfcpp::Sym<64, false>* sym); 3696 #endif 3697 3698 #ifdef HAVE_TARGET_64_BIG 3699 template 3700 Symbol* 3701 Symbol_table::add_from_pluginobj<64, true>( 3702 Sized_pluginobj<64, true>* obj, 3703 const char* name, 3704 const char* ver, 3705 elfcpp::Sym<64, true>* sym); 3706 #endif 3707 3708 #ifdef HAVE_TARGET_32_LITTLE 3709 template 3710 void 3711 Symbol_table::add_from_dynobj<32, false>( 3712 Sized_dynobj<32, false>* dynobj, 3713 const unsigned char* syms, 3714 size_t count, 3715 const char* sym_names, 3716 size_t sym_name_size, 3717 const unsigned char* versym, 3718 size_t versym_size, 3719 const std::vector<const char*>* version_map, 3720 Sized_relobj_file<32, false>::Symbols* sympointers, 3721 size_t* defined); 3722 #endif 3723 3724 #ifdef HAVE_TARGET_32_BIG 3725 template 3726 void 3727 Symbol_table::add_from_dynobj<32, true>( 3728 Sized_dynobj<32, true>* dynobj, 3729 const unsigned char* syms, 3730 size_t count, 3731 const char* sym_names, 3732 size_t sym_name_size, 3733 const unsigned char* versym, 3734 size_t versym_size, 3735 const std::vector<const char*>* version_map, 3736 Sized_relobj_file<32, true>::Symbols* sympointers, 3737 size_t* defined); 3738 #endif 3739 3740 #ifdef HAVE_TARGET_64_LITTLE 3741 template 3742 void 3743 Symbol_table::add_from_dynobj<64, false>( 3744 Sized_dynobj<64, false>* dynobj, 3745 const unsigned char* syms, 3746 size_t count, 3747 const char* sym_names, 3748 size_t sym_name_size, 3749 const unsigned char* versym, 3750 size_t versym_size, 3751 const std::vector<const char*>* version_map, 3752 Sized_relobj_file<64, false>::Symbols* sympointers, 3753 size_t* defined); 3754 #endif 3755 3756 #ifdef HAVE_TARGET_64_BIG 3757 template 3758 void 3759 Symbol_table::add_from_dynobj<64, true>( 3760 Sized_dynobj<64, true>* dynobj, 3761 const unsigned char* syms, 3762 size_t count, 3763 const char* sym_names, 3764 size_t sym_name_size, 3765 const unsigned char* versym, 3766 size_t versym_size, 3767 const std::vector<const char*>* version_map, 3768 Sized_relobj_file<64, true>::Symbols* sympointers, 3769 size_t* defined); 3770 #endif 3771 3772 #ifdef HAVE_TARGET_32_LITTLE 3773 template 3774 Sized_symbol<32>* 3775 Symbol_table::add_from_incrobj( 3776 Object* obj, 3777 const char* name, 3778 const char* ver, 3779 elfcpp::Sym<32, false>* sym); 3780 #endif 3781 3782 #ifdef HAVE_TARGET_32_BIG 3783 template 3784 Sized_symbol<32>* 3785 Symbol_table::add_from_incrobj( 3786 Object* obj, 3787 const char* name, 3788 const char* ver, 3789 elfcpp::Sym<32, true>* sym); 3790 #endif 3791 3792 #ifdef HAVE_TARGET_64_LITTLE 3793 template 3794 Sized_symbol<64>* 3795 Symbol_table::add_from_incrobj( 3796 Object* obj, 3797 const char* name, 3798 const char* ver, 3799 elfcpp::Sym<64, false>* sym); 3800 #endif 3801 3802 #ifdef HAVE_TARGET_64_BIG 3803 template 3804 Sized_symbol<64>* 3805 Symbol_table::add_from_incrobj( 3806 Object* obj, 3807 const char* name, 3808 const char* ver, 3809 elfcpp::Sym<64, true>* sym); 3810 #endif 3811 3812 #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG) 3813 template 3814 void 3815 Symbol_table::define_with_copy_reloc<32>( 3816 Sized_symbol<32>* sym, 3817 Output_data* posd, 3818 elfcpp::Elf_types<32>::Elf_Addr value); 3819 #endif 3820 3821 #if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG) 3822 template 3823 void 3824 Symbol_table::define_with_copy_reloc<64>( 3825 Sized_symbol<64>* sym, 3826 Output_data* posd, 3827 elfcpp::Elf_types<64>::Elf_Addr value); 3828 #endif 3829 3830 #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG) 3831 template 3832 void 3833 Sized_symbol<32>::init_output_data(const char* name, const char* version, 3834 Output_data* od, Value_type value, 3835 Size_type symsize, elfcpp::STT type, 3836 elfcpp::STB binding, 3837 elfcpp::STV visibility, 3838 unsigned char nonvis, 3839 bool offset_is_from_end, 3840 bool is_predefined); 3841 3842 template 3843 void 3844 Sized_symbol<32>::init_constant(const char* name, const char* version, 3845 Value_type value, Size_type symsize, 3846 elfcpp::STT type, elfcpp::STB binding, 3847 elfcpp::STV visibility, unsigned char nonvis, 3848 bool is_predefined); 3849 3850 template 3851 void 3852 Sized_symbol<32>::init_undefined(const char* name, const char* version, 3853 Value_type value, elfcpp::STT type, 3854 elfcpp::STB binding, elfcpp::STV visibility, 3855 unsigned char nonvis); 3856 #endif 3857 3858 #if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG) 3859 template 3860 void 3861 Sized_symbol<64>::init_output_data(const char* name, const char* version, 3862 Output_data* od, Value_type value, 3863 Size_type symsize, elfcpp::STT type, 3864 elfcpp::STB binding, 3865 elfcpp::STV visibility, 3866 unsigned char nonvis, 3867 bool offset_is_from_end, 3868 bool is_predefined); 3869 3870 template 3871 void 3872 Sized_symbol<64>::init_constant(const char* name, const char* version, 3873 Value_type value, Size_type symsize, 3874 elfcpp::STT type, elfcpp::STB binding, 3875 elfcpp::STV visibility, unsigned char nonvis, 3876 bool is_predefined); 3877 3878 template 3879 void 3880 Sized_symbol<64>::init_undefined(const char* name, const char* version, 3881 Value_type value, elfcpp::STT type, 3882 elfcpp::STB binding, elfcpp::STV visibility, 3883 unsigned char nonvis); 3884 #endif 3885 3886 #ifdef HAVE_TARGET_32_LITTLE 3887 template 3888 void 3889 Warnings::issue_warning<32, false>(const Symbol* sym, 3890 const Relocate_info<32, false>* relinfo, 3891 size_t relnum, off_t reloffset) const; 3892 #endif 3893 3894 #ifdef HAVE_TARGET_32_BIG 3895 template 3896 void 3897 Warnings::issue_warning<32, true>(const Symbol* sym, 3898 const Relocate_info<32, true>* relinfo, 3899 size_t relnum, off_t reloffset) const; 3900 #endif 3901 3902 #ifdef HAVE_TARGET_64_LITTLE 3903 template 3904 void 3905 Warnings::issue_warning<64, false>(const Symbol* sym, 3906 const Relocate_info<64, false>* relinfo, 3907 size_t relnum, off_t reloffset) const; 3908 #endif 3909 3910 #ifdef HAVE_TARGET_64_BIG 3911 template 3912 void 3913 Warnings::issue_warning<64, true>(const Symbol* sym, 3914 const Relocate_info<64, true>* relinfo, 3915 size_t relnum, off_t reloffset) const; 3916 #endif 3917 3918 } // End namespace gold. 3919