1 // symtab.h -- the gold symbol table -*- C++ -*- 2 3 // Copyright (C) 2006-2020 Free Software Foundation, Inc. 4 // Written by Ian Lance Taylor <iant@google.com>. 5 6 // This file is part of gold. 7 8 // This program is free software; you can redistribute it and/or modify 9 // it under the terms of the GNU General Public License as published by 10 // the Free Software Foundation; either version 3 of the License, or 11 // (at your option) any later version. 12 13 // This program is distributed in the hope that it will be useful, 14 // but WITHOUT ANY WARRANTY; without even the implied warranty of 15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 // GNU General Public License for more details. 17 18 // You should have received a copy of the GNU General Public License 19 // along with this program; if not, write to the Free Software 20 // Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 21 // MA 02110-1301, USA. 22 23 // Symbol_table 24 // The symbol table. 25 26 #ifndef GOLD_SYMTAB_H 27 #define GOLD_SYMTAB_H 28 29 #include <string> 30 #include <utility> 31 #include <vector> 32 33 #include "elfcpp.h" 34 #include "parameters.h" 35 #include "stringpool.h" 36 #include "object.h" 37 38 namespace gold 39 { 40 41 class Mapfile; 42 class Object; 43 class Relobj; 44 template<int size, bool big_endian> 45 class Sized_relobj_file; 46 template<int size, bool big_endian> 47 class Sized_pluginobj; 48 class Dynobj; 49 template<int size, bool big_endian> 50 class Sized_dynobj; 51 template<int size, bool big_endian> 52 class Sized_incrobj; 53 class Versions; 54 class Version_script_info; 55 class Input_objects; 56 class Output_data; 57 class Output_section; 58 class Output_segment; 59 class Output_file; 60 class Output_symtab_xindex; 61 class Garbage_collection; 62 class Icf; 63 64 // The base class of an entry in the symbol table. The symbol table 65 // can have a lot of entries, so we don't want this class too big. 66 // Size dependent fields can be found in the template class 67 // Sized_symbol. Targets may support their own derived classes. 68 69 class Symbol 70 { 71 public: 72 // Because we want the class to be small, we don't use any virtual 73 // functions. But because symbols can be defined in different 74 // places, we need to classify them. This enum is the different 75 // sources of symbols we support. 76 enum Source 77 { 78 // Symbol defined in a relocatable or dynamic input file--this is 79 // the most common case. 80 FROM_OBJECT, 81 // Symbol defined in an Output_data, a special section created by 82 // the target. 83 IN_OUTPUT_DATA, 84 // Symbol defined in an Output_segment, with no associated 85 // section. 86 IN_OUTPUT_SEGMENT, 87 // Symbol value is constant. 88 IS_CONSTANT, 89 // Symbol is undefined. 90 IS_UNDEFINED 91 }; 92 93 // When the source is IN_OUTPUT_SEGMENT, we need to describe what 94 // the offset means. 95 enum Segment_offset_base 96 { 97 // From the start of the segment. 98 SEGMENT_START, 99 // From the end of the segment. 100 SEGMENT_END, 101 // From the filesz of the segment--i.e., after the loaded bytes 102 // but before the bytes which are allocated but zeroed. 103 SEGMENT_BSS 104 }; 105 106 // Return the symbol name. 107 const char* 108 name() const 109 { return this->name_; } 110 111 // Return the (ANSI) demangled version of the name, if 112 // parameters.demangle() is true. Otherwise, return the name. This 113 // is intended to be used only for logging errors, so it's not 114 // super-efficient. 115 std::string 116 demangled_name() const; 117 118 // Return the symbol version. This will return NULL for an 119 // unversioned symbol. 120 const char* 121 version() const 122 { return this->version_; } 123 124 void 125 clear_version() 126 { this->version_ = NULL; } 127 128 // Return whether this version is the default for this symbol name 129 // (eg, "foo@@V2" is a default version; "foo@V1" is not). Only 130 // meaningful for versioned symbols. 131 bool 132 is_default() const 133 { 134 gold_assert(this->version_ != NULL); 135 return this->is_def_; 136 } 137 138 // Set that this version is the default for this symbol name. 139 void 140 set_is_default() 141 { this->is_def_ = true; } 142 143 // Set that this version is not the default for this symbol name. 144 void 145 set_is_not_default() 146 { this->is_def_ = false; } 147 148 // Return the symbol's name as name@version (or name@@version). 149 std::string 150 versioned_name() const; 151 152 // Return the symbol source. 153 Source 154 source() const 155 { return this->source_; } 156 157 // Return the object with which this symbol is associated. 158 Object* 159 object() const 160 { 161 gold_assert(this->source_ == FROM_OBJECT); 162 return this->u1_.object; 163 } 164 165 // Return the index of the section in the input relocatable or 166 // dynamic object file. 167 unsigned int 168 shndx(bool* is_ordinary) const 169 { 170 gold_assert(this->source_ == FROM_OBJECT); 171 *is_ordinary = this->is_ordinary_shndx_; 172 return this->u2_.shndx; 173 } 174 175 // Return the output data section with which this symbol is 176 // associated, if the symbol was specially defined with respect to 177 // an output data section. 178 Output_data* 179 output_data() const 180 { 181 gold_assert(this->source_ == IN_OUTPUT_DATA); 182 return this->u1_.output_data; 183 } 184 185 // If this symbol was defined with respect to an output data 186 // section, return whether the value is an offset from end. 187 bool 188 offset_is_from_end() const 189 { 190 gold_assert(this->source_ == IN_OUTPUT_DATA); 191 return this->u2_.offset_is_from_end; 192 } 193 194 // Return the output segment with which this symbol is associated, 195 // if the symbol was specially defined with respect to an output 196 // segment. 197 Output_segment* 198 output_segment() const 199 { 200 gold_assert(this->source_ == IN_OUTPUT_SEGMENT); 201 return this->u1_.output_segment; 202 } 203 204 // If this symbol was defined with respect to an output segment, 205 // return the offset base. 206 Segment_offset_base 207 offset_base() const 208 { 209 gold_assert(this->source_ == IN_OUTPUT_SEGMENT); 210 return this->u2_.offset_base; 211 } 212 213 // Return the symbol binding. 214 elfcpp::STB 215 binding() const 216 { return this->binding_; } 217 218 // Return the symbol type. 219 elfcpp::STT 220 type() const 221 { return this->type_; } 222 223 // Set the symbol type. 224 void 225 set_type(elfcpp::STT type) 226 { this->type_ = type; } 227 228 // Return true for function symbol. 229 bool 230 is_func() const 231 { 232 return (this->type_ == elfcpp::STT_FUNC 233 || this->type_ == elfcpp::STT_GNU_IFUNC); 234 } 235 236 // Return the symbol visibility. 237 elfcpp::STV 238 visibility() const 239 { return this->visibility_; } 240 241 // Set the visibility. 242 void 243 set_visibility(elfcpp::STV visibility) 244 { this->visibility_ = visibility; } 245 246 // Override symbol visibility. 247 void 248 override_visibility(elfcpp::STV); 249 250 // Set whether the symbol was originally a weak undef or a regular undef 251 // when resolved by a dynamic def or by a special symbol. 252 inline void 253 set_undef_binding(elfcpp::STB bind) 254 { 255 if (!this->undef_binding_set_ || this->undef_binding_weak_) 256 { 257 this->undef_binding_weak_ = bind == elfcpp::STB_WEAK; 258 this->undef_binding_set_ = true; 259 } 260 } 261 262 // Return TRUE if a weak undef was resolved by a dynamic def or 263 // by a special symbol. 264 inline bool 265 is_undef_binding_weak() const 266 { return this->undef_binding_weak_; } 267 268 // Return the non-visibility part of the st_other field. 269 unsigned char 270 nonvis() const 271 { return this->nonvis_; } 272 273 // Set the non-visibility part of the st_other field. 274 void 275 set_nonvis(unsigned int nonvis) 276 { this->nonvis_ = nonvis; } 277 278 // Return whether this symbol is a forwarder. This will never be 279 // true of a symbol found in the hash table, but may be true of 280 // symbol pointers attached to object files. 281 bool 282 is_forwarder() const 283 { return this->is_forwarder_; } 284 285 // Mark this symbol as a forwarder. 286 void 287 set_forwarder() 288 { this->is_forwarder_ = true; } 289 290 // Return whether this symbol has an alias in the weak aliases table 291 // in Symbol_table. 292 bool 293 has_alias() const 294 { return this->has_alias_; } 295 296 // Mark this symbol as having an alias. 297 void 298 set_has_alias() 299 { this->has_alias_ = true; } 300 301 // Return whether this symbol needs an entry in the dynamic symbol 302 // table. 303 bool 304 needs_dynsym_entry() const 305 { 306 return (this->needs_dynsym_entry_ 307 || (this->in_reg() 308 && this->in_dyn() 309 && this->is_externally_visible())); 310 } 311 312 // Mark this symbol as needing an entry in the dynamic symbol table. 313 void 314 set_needs_dynsym_entry() 315 { this->needs_dynsym_entry_ = true; } 316 317 // Return whether this symbol should be added to the dynamic symbol 318 // table. 319 bool 320 should_add_dynsym_entry(Symbol_table*) const; 321 322 // Return whether this symbol has been seen in a regular object. 323 bool 324 in_reg() const 325 { return this->in_reg_; } 326 327 // Mark this symbol as having been seen in a regular object. 328 void 329 set_in_reg() 330 { this->in_reg_ = true; } 331 332 // Forget this symbol was seen in a regular object. 333 void 334 clear_in_reg() 335 { this->in_reg_ = false; } 336 337 // Return whether this symbol has been seen in a dynamic object. 338 bool 339 in_dyn() const 340 { return this->in_dyn_; } 341 342 // Mark this symbol as having been seen in a dynamic object. 343 void 344 set_in_dyn() 345 { this->in_dyn_ = true; } 346 347 // Return whether this symbol is defined in a dynamic object. 348 bool 349 from_dyn() const 350 { return this->source_ == FROM_OBJECT && this->object()->is_dynamic(); } 351 352 // Return whether this symbol has been seen in a real ELF object. 353 // (IN_REG will return TRUE if the symbol has been seen in either 354 // a real ELF object or an object claimed by a plugin.) 355 bool 356 in_real_elf() const 357 { return this->in_real_elf_; } 358 359 // Mark this symbol as having been seen in a real ELF object. 360 void 361 set_in_real_elf() 362 { this->in_real_elf_ = true; } 363 364 // Return whether this symbol was defined in a section that was 365 // discarded from the link. This is used to control some error 366 // reporting. 367 bool 368 is_defined_in_discarded_section() const 369 { return this->is_defined_in_discarded_section_; } 370 371 // Mark this symbol as having been defined in a discarded section. 372 void 373 set_is_defined_in_discarded_section() 374 { this->is_defined_in_discarded_section_ = true; } 375 376 // Return the index of this symbol in the output file symbol table. 377 // A value of -1U means that this symbol is not going into the 378 // output file. This starts out as zero, and is set to a non-zero 379 // value by Symbol_table::finalize. It is an error to ask for the 380 // symbol table index before it has been set. 381 unsigned int 382 symtab_index() const 383 { 384 gold_assert(this->symtab_index_ != 0); 385 return this->symtab_index_; 386 } 387 388 // Set the index of the symbol in the output file symbol table. 389 void 390 set_symtab_index(unsigned int index) 391 { 392 gold_assert(index != 0); 393 this->symtab_index_ = index; 394 } 395 396 // Return whether this symbol already has an index in the output 397 // file symbol table. 398 bool 399 has_symtab_index() const 400 { return this->symtab_index_ != 0; } 401 402 // Return the index of this symbol in the dynamic symbol table. A 403 // value of -1U means that this symbol is not going into the dynamic 404 // symbol table. This starts out as zero, and is set to a non-zero 405 // during Layout::finalize. It is an error to ask for the dynamic 406 // symbol table index before it has been set. 407 unsigned int 408 dynsym_index() const 409 { 410 gold_assert(this->dynsym_index_ != 0); 411 return this->dynsym_index_; 412 } 413 414 // Set the index of the symbol in the dynamic symbol table. 415 void 416 set_dynsym_index(unsigned int index) 417 { 418 gold_assert(index != 0); 419 this->dynsym_index_ = index; 420 } 421 422 // Return whether this symbol already has an index in the dynamic 423 // symbol table. 424 bool 425 has_dynsym_index() const 426 { return this->dynsym_index_ != 0; } 427 428 // Return whether this symbol has an entry in the GOT section. 429 // For a TLS symbol, this GOT entry will hold its tp-relative offset. 430 bool 431 has_got_offset(unsigned int got_type) const 432 { return this->got_offsets_.get_offset(got_type) != -1U; } 433 434 // Return the offset into the GOT section of this symbol. 435 unsigned int 436 got_offset(unsigned int got_type) const 437 { 438 unsigned int got_offset = this->got_offsets_.get_offset(got_type); 439 gold_assert(got_offset != -1U); 440 return got_offset; 441 } 442 443 // Set the GOT offset of this symbol. 444 void 445 set_got_offset(unsigned int got_type, unsigned int got_offset) 446 { this->got_offsets_.set_offset(got_type, got_offset); } 447 448 // Return the GOT offset list. 449 const Got_offset_list* 450 got_offset_list() const 451 { return this->got_offsets_.get_list(); } 452 453 // Return whether this symbol has an entry in the PLT section. 454 bool 455 has_plt_offset() const 456 { return this->plt_offset_ != -1U; } 457 458 // Return the offset into the PLT section of this symbol. 459 unsigned int 460 plt_offset() const 461 { 462 gold_assert(this->has_plt_offset()); 463 return this->plt_offset_; 464 } 465 466 // Set the PLT offset of this symbol. 467 void 468 set_plt_offset(unsigned int plt_offset) 469 { 470 gold_assert(plt_offset != -1U); 471 this->plt_offset_ = plt_offset; 472 } 473 474 // Return whether this dynamic symbol needs a special value in the 475 // dynamic symbol table. 476 bool 477 needs_dynsym_value() const 478 { return this->needs_dynsym_value_; } 479 480 // Set that this dynamic symbol needs a special value in the dynamic 481 // symbol table. 482 void 483 set_needs_dynsym_value() 484 { 485 gold_assert(this->object()->is_dynamic()); 486 this->needs_dynsym_value_ = true; 487 } 488 489 // Return true if the final value of this symbol is known at link 490 // time. 491 bool 492 final_value_is_known() const; 493 494 // Return true if SHNDX represents a common symbol. This depends on 495 // the target. 496 static bool 497 is_common_shndx(unsigned int shndx); 498 499 // Return whether this is a defined symbol (not undefined or 500 // common). 501 bool 502 is_defined() const 503 { 504 bool is_ordinary; 505 if (this->source_ != FROM_OBJECT) 506 return this->source_ != IS_UNDEFINED; 507 unsigned int shndx = this->shndx(&is_ordinary); 508 return (is_ordinary 509 ? shndx != elfcpp::SHN_UNDEF 510 : !Symbol::is_common_shndx(shndx)); 511 } 512 513 // Return true if this symbol is from a dynamic object. 514 bool 515 is_from_dynobj() const 516 { 517 return this->source_ == FROM_OBJECT && this->object()->is_dynamic(); 518 } 519 520 // Return whether this is a placeholder symbol from a plugin object. 521 bool 522 is_placeholder() const 523 { 524 return this->source_ == FROM_OBJECT && this->object()->pluginobj() != NULL; 525 } 526 527 // Return whether this is an undefined symbol. 528 bool 529 is_undefined() const 530 { 531 bool is_ordinary; 532 return ((this->source_ == FROM_OBJECT 533 && this->shndx(&is_ordinary) == elfcpp::SHN_UNDEF 534 && is_ordinary) 535 || this->source_ == IS_UNDEFINED); 536 } 537 538 // Return whether this is a weak undefined symbol. 539 bool 540 is_weak_undefined() const 541 { 542 return (this->is_undefined() 543 && (this->binding() == elfcpp::STB_WEAK 544 || this->is_undef_binding_weak() 545 || parameters->options().weak_unresolved_symbols())); 546 } 547 548 // Return whether this is a strong undefined symbol. 549 bool 550 is_strong_undefined() const 551 { 552 return (this->is_undefined() 553 && this->binding() != elfcpp::STB_WEAK 554 && !this->is_undef_binding_weak() 555 && !parameters->options().weak_unresolved_symbols()); 556 } 557 558 // Return whether this is an absolute symbol. 559 bool 560 is_absolute() const 561 { 562 bool is_ordinary; 563 return ((this->source_ == FROM_OBJECT 564 && this->shndx(&is_ordinary) == elfcpp::SHN_ABS 565 && !is_ordinary) 566 || this->source_ == IS_CONSTANT); 567 } 568 569 // Return whether this is a common symbol. 570 bool 571 is_common() const 572 { 573 if (this->source_ != FROM_OBJECT) 574 return false; 575 bool is_ordinary; 576 unsigned int shndx = this->shndx(&is_ordinary); 577 return !is_ordinary && Symbol::is_common_shndx(shndx); 578 } 579 580 // Return whether this symbol can be seen outside this object. 581 bool 582 is_externally_visible() const 583 { 584 return ((this->visibility_ == elfcpp::STV_DEFAULT 585 || this->visibility_ == elfcpp::STV_PROTECTED) 586 && !this->is_forced_local_); 587 } 588 589 // Return true if this symbol can be preempted by a definition in 590 // another link unit. 591 bool 592 is_preemptible() const 593 { 594 // It doesn't make sense to ask whether a symbol defined in 595 // another object is preemptible. 596 gold_assert(!this->is_from_dynobj()); 597 598 // It doesn't make sense to ask whether an undefined symbol 599 // is preemptible. 600 gold_assert(!this->is_undefined()); 601 602 // If a symbol does not have default visibility, it can not be 603 // seen outside this link unit and therefore is not preemptible. 604 if (this->visibility_ != elfcpp::STV_DEFAULT) 605 return false; 606 607 // If this symbol has been forced to be a local symbol by a 608 // version script, then it is not visible outside this link unit 609 // and is not preemptible. 610 if (this->is_forced_local_) 611 return false; 612 613 // If we are not producing a shared library, then nothing is 614 // preemptible. 615 if (!parameters->options().shared()) 616 return false; 617 618 // If the symbol was named in a --dynamic-list script, it is preemptible. 619 if (parameters->options().in_dynamic_list(this->name())) 620 return true; 621 622 // If the user used -Bsymbolic, then nothing (else) is preemptible. 623 if (parameters->options().Bsymbolic()) 624 return false; 625 626 // If the user used -Bsymbolic-functions, then functions are not 627 // preemptible. We explicitly check for not being STT_OBJECT, 628 // rather than for being STT_FUNC, because that is what the GNU 629 // linker does. 630 if (this->type() != elfcpp::STT_OBJECT 631 && parameters->options().Bsymbolic_functions()) 632 return false; 633 634 // Otherwise the symbol is preemptible. 635 return true; 636 } 637 638 // Return true if this symbol is a function that needs a PLT entry. 639 bool 640 needs_plt_entry() const 641 { 642 // An undefined symbol from an executable does not need a PLT entry. 643 if (this->is_undefined() && !parameters->options().shared()) 644 return false; 645 646 // An STT_GNU_IFUNC symbol always needs a PLT entry, even when 647 // doing a static link. 648 if (this->type() == elfcpp::STT_GNU_IFUNC) 649 return true; 650 651 // We only need a PLT entry for a function. 652 if (!this->is_func()) 653 return false; 654 655 // If we're doing a static link or a -pie link, we don't create 656 // PLT entries. 657 if (parameters->doing_static_link() 658 || parameters->options().pie()) 659 return false; 660 661 // We need a PLT entry if the function is defined in a dynamic 662 // object, or is undefined when building a shared object, or if it 663 // is subject to pre-emption. 664 return (this->is_from_dynobj() 665 || this->is_undefined() 666 || this->is_preemptible()); 667 } 668 669 // When determining whether a reference to a symbol needs a dynamic 670 // relocation, we need to know several things about the reference. 671 // These flags may be or'ed together. 0 means that the symbol 672 // isn't referenced at all. 673 enum Reference_flags 674 { 675 // A reference to the symbol's absolute address. This includes 676 // references that cause an absolute address to be stored in the GOT. 677 ABSOLUTE_REF = 1, 678 // A reference that calculates the offset of the symbol from some 679 // anchor point, such as the PC or GOT. 680 RELATIVE_REF = 2, 681 // A TLS-related reference. 682 TLS_REF = 4, 683 // A reference that can always be treated as a function call. 684 FUNCTION_CALL = 8, 685 // When set, says that dynamic relocations are needed even if a 686 // symbol has a plt entry. 687 FUNC_DESC_ABI = 16, 688 }; 689 690 // Given a direct absolute or pc-relative static relocation against 691 // the global symbol, this function returns whether a dynamic relocation 692 // is needed. 693 694 bool 695 needs_dynamic_reloc(int flags) const 696 { 697 // No dynamic relocations in a static link! 698 if (parameters->doing_static_link()) 699 return false; 700 701 // A reference to an undefined symbol from an executable should be 702 // statically resolved to 0, and does not need a dynamic relocation. 703 // This matches gnu ld behavior. 704 if (this->is_undefined() && !parameters->options().shared()) 705 return false; 706 707 // A reference to an absolute symbol does not need a dynamic relocation. 708 if (this->is_absolute()) 709 return false; 710 711 // An absolute reference within a position-independent output file 712 // will need a dynamic relocation. 713 if ((flags & ABSOLUTE_REF) 714 && parameters->options().output_is_position_independent()) 715 return true; 716 717 // A function call that can branch to a local PLT entry does not need 718 // a dynamic relocation. 719 if ((flags & FUNCTION_CALL) && this->has_plt_offset()) 720 return false; 721 722 // A reference to any PLT entry in a non-position-independent executable 723 // does not need a dynamic relocation. 724 if (!(flags & FUNC_DESC_ABI) 725 && !parameters->options().output_is_position_independent() 726 && this->has_plt_offset()) 727 return false; 728 729 // A reference to a symbol defined in a dynamic object or to a 730 // symbol that is preemptible will need a dynamic relocation. 731 if (this->is_from_dynobj() 732 || this->is_undefined() 733 || this->is_preemptible()) 734 return true; 735 736 // For all other cases, return FALSE. 737 return false; 738 } 739 740 // Whether we should use the PLT offset associated with a symbol for 741 // a relocation. FLAGS is a set of Reference_flags. 742 743 bool 744 use_plt_offset(int flags) const 745 { 746 // If the symbol doesn't have a PLT offset, then naturally we 747 // don't want to use it. 748 if (!this->has_plt_offset()) 749 return false; 750 751 // For a STT_GNU_IFUNC symbol we always have to use the PLT entry. 752 if (this->type() == elfcpp::STT_GNU_IFUNC) 753 return true; 754 755 // If we are going to generate a dynamic relocation, then we will 756 // wind up using that, so no need to use the PLT entry. 757 if (this->needs_dynamic_reloc(flags)) 758 return false; 759 760 // If the symbol is from a dynamic object, we need to use the PLT 761 // entry. 762 if (this->is_from_dynobj()) 763 return true; 764 765 // If we are generating a shared object, and this symbol is 766 // undefined or preemptible, we need to use the PLT entry. 767 if (parameters->options().shared() 768 && (this->is_undefined() || this->is_preemptible())) 769 return true; 770 771 // If this is a call to a weak undefined symbol, we need to use 772 // the PLT entry; the symbol may be defined by a library loaded 773 // at runtime. 774 if ((flags & FUNCTION_CALL) && this->is_weak_undefined()) 775 return true; 776 777 // Otherwise we can use the regular definition. 778 return false; 779 } 780 781 // Given a direct absolute static relocation against 782 // the global symbol, where a dynamic relocation is needed, this 783 // function returns whether a relative dynamic relocation can be used. 784 // The caller must determine separately whether the static relocation 785 // is compatible with a relative relocation. 786 787 bool 788 can_use_relative_reloc(bool is_function_call) const 789 { 790 // A function call that can branch to a local PLT entry can 791 // use a RELATIVE relocation. 792 if (is_function_call && this->has_plt_offset()) 793 return true; 794 795 // A reference to a symbol defined in a dynamic object or to a 796 // symbol that is preemptible can not use a RELATIVE relocation. 797 if (this->is_from_dynobj() 798 || this->is_undefined() 799 || this->is_preemptible()) 800 return false; 801 802 // For all other cases, return TRUE. 803 return true; 804 } 805 806 // Return the output section where this symbol is defined. Return 807 // NULL if the symbol has an absolute value. 808 Output_section* 809 output_section() const; 810 811 // Set the symbol's output section. This is used for symbols 812 // defined in scripts. This should only be called after the symbol 813 // table has been finalized. 814 void 815 set_output_section(Output_section*); 816 817 // Set the symbol's output segment. This is used for pre-defined 818 // symbols whose segments aren't known until after layout is done 819 // (e.g., __ehdr_start). 820 void 821 set_output_segment(Output_segment*, Segment_offset_base); 822 823 // Set the symbol to undefined. This is used for pre-defined 824 // symbols whose segments aren't known until after layout is done 825 // (e.g., __ehdr_start). 826 void 827 set_undefined(); 828 829 // Return whether there should be a warning for references to this 830 // symbol. 831 bool 832 has_warning() const 833 { return this->has_warning_; } 834 835 // Mark this symbol as having a warning. 836 void 837 set_has_warning() 838 { this->has_warning_ = true; } 839 840 // Return whether this symbol is defined by a COPY reloc from a 841 // dynamic object. 842 bool 843 is_copied_from_dynobj() const 844 { return this->is_copied_from_dynobj_; } 845 846 // Mark this symbol as defined by a COPY reloc. 847 void 848 set_is_copied_from_dynobj() 849 { this->is_copied_from_dynobj_ = true; } 850 851 // Return whether this symbol is forced to visibility STB_LOCAL 852 // by a "local:" entry in a version script. 853 bool 854 is_forced_local() const 855 { return this->is_forced_local_; } 856 857 // Mark this symbol as forced to STB_LOCAL visibility. 858 void 859 set_is_forced_local() 860 { this->is_forced_local_ = true; } 861 862 // Return true if this may need a COPY relocation. 863 // References from an executable object to non-function symbols 864 // defined in a dynamic object may need a COPY relocation. 865 bool 866 may_need_copy_reloc() const 867 { 868 return (parameters->options().copyreloc() 869 && this->is_from_dynobj() 870 && !this->is_func()); 871 } 872 873 // Return true if this symbol was predefined by the linker. 874 bool 875 is_predefined() const 876 { return this->is_predefined_; } 877 878 // Return true if this is a C++ vtable symbol. 879 bool 880 is_cxx_vtable() const 881 { return is_prefix_of("_ZTV", this->name_); } 882 883 // Return true if this symbol is protected in a shared object. 884 // This is not the same as checking if visibility() == elfcpp::STV_PROTECTED, 885 // because the visibility_ field reflects the symbol's visibility from 886 // outside the shared object. 887 bool 888 is_protected() const 889 { return this->is_protected_; } 890 891 // Mark this symbol as protected in a shared object. 892 void 893 set_is_protected() 894 { this->is_protected_ = true; } 895 896 // Return state of PowerPC64 ELFv2 specific flag. 897 bool 898 non_zero_localentry() const 899 { return this->non_zero_localentry_; } 900 901 // Set PowerPC64 ELFv2 specific flag. 902 void 903 set_non_zero_localentry() 904 { this->non_zero_localentry_ = true; } 905 906 // Completely override existing symbol. Everything bar name_, 907 // version_, and is_forced_local_ flag are copied. version_ is 908 // cleared if from->version_ is clear. Returns true if this symbol 909 // should be forced local. 910 bool 911 clone(const Symbol* from); 912 913 protected: 914 // Instances of this class should always be created at a specific 915 // size. 916 Symbol() 917 { memset(static_cast<void*>(this), 0, sizeof *this); } 918 919 // Initialize the general fields. 920 void 921 init_fields(const char* name, const char* version, 922 elfcpp::STT type, elfcpp::STB binding, 923 elfcpp::STV visibility, unsigned char nonvis); 924 925 // Initialize fields from an ELF symbol in OBJECT. ST_SHNDX is the 926 // section index, IS_ORDINARY is whether it is a normal section 927 // index rather than a special code. 928 template<int size, bool big_endian> 929 void 930 init_base_object(const char* name, const char* version, Object* object, 931 const elfcpp::Sym<size, big_endian>&, unsigned int st_shndx, 932 bool is_ordinary); 933 934 // Initialize fields for an Output_data. 935 void 936 init_base_output_data(const char* name, const char* version, Output_data*, 937 elfcpp::STT, elfcpp::STB, elfcpp::STV, 938 unsigned char nonvis, bool offset_is_from_end, 939 bool is_predefined); 940 941 // Initialize fields for an Output_segment. 942 void 943 init_base_output_segment(const char* name, const char* version, 944 Output_segment* os, elfcpp::STT type, 945 elfcpp::STB binding, elfcpp::STV visibility, 946 unsigned char nonvis, 947 Segment_offset_base offset_base, 948 bool is_predefined); 949 950 // Initialize fields for a constant. 951 void 952 init_base_constant(const char* name, const char* version, elfcpp::STT type, 953 elfcpp::STB binding, elfcpp::STV visibility, 954 unsigned char nonvis, bool is_predefined); 955 956 // Initialize fields for an undefined symbol. 957 void 958 init_base_undefined(const char* name, const char* version, elfcpp::STT type, 959 elfcpp::STB binding, elfcpp::STV visibility, 960 unsigned char nonvis); 961 962 // Override existing symbol. 963 template<int size, bool big_endian> 964 void 965 override_base(const elfcpp::Sym<size, big_endian>&, unsigned int st_shndx, 966 bool is_ordinary, Object* object, const char* version); 967 968 // Override existing symbol with a special symbol. 969 void 970 override_base_with_special(const Symbol* from); 971 972 // Override symbol version. 973 void 974 override_version(const char* version); 975 976 // Allocate a common symbol by giving it a location in the output 977 // file. 978 void 979 allocate_base_common(Output_data*); 980 981 private: 982 Symbol(const Symbol&); 983 Symbol& operator=(const Symbol&); 984 985 // Symbol name (expected to point into a Stringpool). 986 const char* name_; 987 // Symbol version (expected to point into a Stringpool). This may 988 // be NULL. 989 const char* version_; 990 991 union 992 { 993 // This is used if SOURCE_ == FROM_OBJECT. 994 // Object in which symbol is defined, or in which it was first 995 // seen. 996 Object* object; 997 998 // This is used if SOURCE_ == IN_OUTPUT_DATA. 999 // Output_data in which symbol is defined. Before 1000 // Layout::finalize the symbol's value is an offset within the 1001 // Output_data. 1002 Output_data* output_data; 1003 1004 // This is used if SOURCE_ == IN_OUTPUT_SEGMENT. 1005 // Output_segment in which the symbol is defined. Before 1006 // Layout::finalize the symbol's value is an offset. 1007 Output_segment* output_segment; 1008 } u1_; 1009 1010 union 1011 { 1012 // This is used if SOURCE_ == FROM_OBJECT. 1013 // Section number in object in which symbol is defined. 1014 unsigned int shndx; 1015 1016 // This is used if SOURCE_ == IN_OUTPUT_DATA. 1017 // True if the offset is from the end, false if the offset is 1018 // from the beginning. 1019 bool offset_is_from_end; 1020 1021 // This is used if SOURCE_ == IN_OUTPUT_SEGMENT. 1022 // The base to use for the offset before Layout::finalize. 1023 Segment_offset_base offset_base; 1024 } u2_; 1025 1026 // The index of this symbol in the output file. If the symbol is 1027 // not going into the output file, this value is -1U. This field 1028 // starts as always holding zero. It is set to a non-zero value by 1029 // Symbol_table::finalize. 1030 unsigned int symtab_index_; 1031 1032 // The index of this symbol in the dynamic symbol table. If the 1033 // symbol is not going into the dynamic symbol table, this value is 1034 // -1U. This field starts as always holding zero. It is set to a 1035 // non-zero value during Layout::finalize. 1036 unsigned int dynsym_index_; 1037 1038 // If this symbol has an entry in the PLT section, then this is the 1039 // offset from the start of the PLT section. This is -1U if there 1040 // is no PLT entry. 1041 unsigned int plt_offset_; 1042 1043 // The GOT section entries for this symbol. A symbol may have more 1044 // than one GOT offset (e.g., when mixing modules compiled with two 1045 // different TLS models), but will usually have at most one. 1046 Got_offset_list got_offsets_; 1047 1048 // Symbol type (bits 0 to 3). 1049 elfcpp::STT type_ : 4; 1050 // Symbol binding (bits 4 to 7). 1051 elfcpp::STB binding_ : 4; 1052 // Symbol visibility (bits 8 to 9). 1053 elfcpp::STV visibility_ : 2; 1054 // Rest of symbol st_other field (bits 10 to 15). 1055 unsigned int nonvis_ : 6; 1056 // The type of symbol (bits 16 to 18). 1057 Source source_ : 3; 1058 // True if this is the default version of the symbol (bit 19). 1059 bool is_def_ : 1; 1060 // True if this symbol really forwards to another symbol. This is 1061 // used when we discover after the fact that two different entries 1062 // in the hash table really refer to the same symbol. This will 1063 // never be set for a symbol found in the hash table, but may be set 1064 // for a symbol found in the list of symbols attached to an Object. 1065 // It forwards to the symbol found in the forwarders_ map of 1066 // Symbol_table (bit 20). 1067 bool is_forwarder_ : 1; 1068 // True if the symbol has an alias in the weak_aliases table in 1069 // Symbol_table (bit 21). 1070 bool has_alias_ : 1; 1071 // True if this symbol needs to be in the dynamic symbol table (bit 1072 // 22). 1073 bool needs_dynsym_entry_ : 1; 1074 // True if we've seen this symbol in a regular object (bit 23). 1075 bool in_reg_ : 1; 1076 // True if we've seen this symbol in a dynamic object (bit 24). 1077 bool in_dyn_ : 1; 1078 // True if this is a dynamic symbol which needs a special value in 1079 // the dynamic symbol table (bit 25). 1080 bool needs_dynsym_value_ : 1; 1081 // True if there is a warning for this symbol (bit 26). 1082 bool has_warning_ : 1; 1083 // True if we are using a COPY reloc for this symbol, so that the 1084 // real definition lives in a dynamic object (bit 27). 1085 bool is_copied_from_dynobj_ : 1; 1086 // True if this symbol was forced to local visibility by a version 1087 // script (bit 28). 1088 bool is_forced_local_ : 1; 1089 // True if the field u2_.shndx is an ordinary section 1090 // index, not one of the special codes from SHN_LORESERVE to 1091 // SHN_HIRESERVE (bit 29). 1092 bool is_ordinary_shndx_ : 1; 1093 // True if we've seen this symbol in a "real" ELF object (bit 30). 1094 // If the symbol has been seen in a relocatable, non-IR, object file, 1095 // it's known to be referenced from outside the IR. A reference from 1096 // a dynamic object doesn't count as a "real" ELF, and we'll simply 1097 // mark the symbol as "visible" from outside the IR. The compiler 1098 // can use this distinction to guide its handling of COMDAT symbols. 1099 bool in_real_elf_ : 1; 1100 // True if this symbol is defined in a section which was discarded 1101 // (bit 31). 1102 bool is_defined_in_discarded_section_ : 1; 1103 // True if UNDEF_BINDING_WEAK_ has been set (bit 32). 1104 bool undef_binding_set_ : 1; 1105 // True if this symbol was a weak undef resolved by a dynamic def 1106 // or by a special symbol (bit 33). 1107 bool undef_binding_weak_ : 1; 1108 // True if this symbol is a predefined linker symbol (bit 34). 1109 bool is_predefined_ : 1; 1110 // True if this symbol has protected visibility in a shared object (bit 35). 1111 // The visibility_ field will be STV_DEFAULT in this case because we 1112 // must treat it as such from outside the shared object. 1113 bool is_protected_ : 1; 1114 // Used by PowerPC64 ELFv2 to track st_other localentry (bit 36). 1115 bool non_zero_localentry_ : 1; 1116 }; 1117 1118 // The parts of a symbol which are size specific. Using a template 1119 // derived class like this helps us use less space on a 32-bit system. 1120 1121 template<int size> 1122 class Sized_symbol : public Symbol 1123 { 1124 public: 1125 typedef typename elfcpp::Elf_types<size>::Elf_Addr Value_type; 1126 typedef typename elfcpp::Elf_types<size>::Elf_WXword Size_type; 1127 1128 Sized_symbol() 1129 { } 1130 1131 // Initialize fields from an ELF symbol in OBJECT. ST_SHNDX is the 1132 // section index, IS_ORDINARY is whether it is a normal section 1133 // index rather than a special code. 1134 template<bool big_endian> 1135 void 1136 init_object(const char* name, const char* version, Object* object, 1137 const elfcpp::Sym<size, big_endian>&, unsigned int st_shndx, 1138 bool is_ordinary); 1139 1140 // Initialize fields for an Output_data. 1141 void 1142 init_output_data(const char* name, const char* version, Output_data*, 1143 Value_type value, Size_type symsize, elfcpp::STT, 1144 elfcpp::STB, elfcpp::STV, unsigned char nonvis, 1145 bool offset_is_from_end, bool is_predefined); 1146 1147 // Initialize fields for an Output_segment. 1148 void 1149 init_output_segment(const char* name, const char* version, Output_segment*, 1150 Value_type value, Size_type symsize, elfcpp::STT, 1151 elfcpp::STB, elfcpp::STV, unsigned char nonvis, 1152 Segment_offset_base offset_base, bool is_predefined); 1153 1154 // Initialize fields for a constant. 1155 void 1156 init_constant(const char* name, const char* version, Value_type value, 1157 Size_type symsize, elfcpp::STT, elfcpp::STB, elfcpp::STV, 1158 unsigned char nonvis, bool is_predefined); 1159 1160 // Initialize fields for an undefined symbol. 1161 void 1162 init_undefined(const char* name, const char* version, Value_type value, 1163 elfcpp::STT, elfcpp::STB, elfcpp::STV, unsigned char nonvis); 1164 1165 // Override existing symbol. 1166 template<bool big_endian> 1167 void 1168 override(const elfcpp::Sym<size, big_endian>&, unsigned int st_shndx, 1169 bool is_ordinary, Object* object, const char* version); 1170 1171 // Override existing symbol with a special symbol. 1172 void 1173 override_with_special(const Sized_symbol<size>*); 1174 1175 // Return the symbol's value. 1176 Value_type 1177 value() const 1178 { return this->value_; } 1179 1180 // Return the symbol's size (we can't call this 'size' because that 1181 // is a template parameter). 1182 Size_type 1183 symsize() const 1184 { return this->symsize_; } 1185 1186 // Set the symbol size. This is used when resolving common symbols. 1187 void 1188 set_symsize(Size_type symsize) 1189 { this->symsize_ = symsize; } 1190 1191 // Set the symbol value. This is called when we store the final 1192 // values of the symbols into the symbol table. 1193 void 1194 set_value(Value_type value) 1195 { this->value_ = value; } 1196 1197 // Allocate a common symbol by giving it a location in the output 1198 // file. 1199 void 1200 allocate_common(Output_data*, Value_type value); 1201 1202 // Completely override existing symbol. Everything bar name_, 1203 // version_, and is_forced_local_ flag are copied. version_ is 1204 // cleared if from->version_ is clear. Returns true if this symbol 1205 // should be forced local. 1206 bool 1207 clone(const Sized_symbol<size>* from); 1208 1209 private: 1210 Sized_symbol(const Sized_symbol&); 1211 Sized_symbol& operator=(const Sized_symbol&); 1212 1213 // Symbol value. Before Layout::finalize this is the offset in the 1214 // input section. This is set to the final value during 1215 // Layout::finalize. 1216 Value_type value_; 1217 // Symbol size. 1218 Size_type symsize_; 1219 }; 1220 1221 // A struct describing a symbol defined by the linker, where the value 1222 // of the symbol is defined based on an output section. This is used 1223 // for symbols defined by the linker, like "_init_array_start". 1224 1225 struct Define_symbol_in_section 1226 { 1227 // The symbol name. 1228 const char* name; 1229 // The name of the output section with which this symbol should be 1230 // associated. If there is no output section with that name, the 1231 // symbol will be defined as zero. 1232 const char* output_section; 1233 // The offset of the symbol within the output section. This is an 1234 // offset from the start of the output section, unless start_at_end 1235 // is true, in which case this is an offset from the end of the 1236 // output section. 1237 uint64_t value; 1238 // The size of the symbol. 1239 uint64_t size; 1240 // The symbol type. 1241 elfcpp::STT type; 1242 // The symbol binding. 1243 elfcpp::STB binding; 1244 // The symbol visibility. 1245 elfcpp::STV visibility; 1246 // The rest of the st_other field. 1247 unsigned char nonvis; 1248 // If true, the value field is an offset from the end of the output 1249 // section. 1250 bool offset_is_from_end; 1251 // If true, this symbol is defined only if we see a reference to it. 1252 bool only_if_ref; 1253 }; 1254 1255 // A struct describing a symbol defined by the linker, where the value 1256 // of the symbol is defined based on a segment. This is used for 1257 // symbols defined by the linker, like "_end". We describe the 1258 // segment with which the symbol should be associated by its 1259 // characteristics. If no segment meets these characteristics, the 1260 // symbol will be defined as zero. If there is more than one segment 1261 // which meets these characteristics, we will use the first one. 1262 1263 struct Define_symbol_in_segment 1264 { 1265 // The symbol name. 1266 const char* name; 1267 // The segment type where the symbol should be defined, typically 1268 // PT_LOAD. 1269 elfcpp::PT segment_type; 1270 // Bitmask of segment flags which must be set. 1271 elfcpp::PF segment_flags_set; 1272 // Bitmask of segment flags which must be clear. 1273 elfcpp::PF segment_flags_clear; 1274 // The offset of the symbol within the segment. The offset is 1275 // calculated from the position set by offset_base. 1276 uint64_t value; 1277 // The size of the symbol. 1278 uint64_t size; 1279 // The symbol type. 1280 elfcpp::STT type; 1281 // The symbol binding. 1282 elfcpp::STB binding; 1283 // The symbol visibility. 1284 elfcpp::STV visibility; 1285 // The rest of the st_other field. 1286 unsigned char nonvis; 1287 // The base from which we compute the offset. 1288 Symbol::Segment_offset_base offset_base; 1289 // If true, this symbol is defined only if we see a reference to it. 1290 bool only_if_ref; 1291 }; 1292 1293 // Specify an object/section/offset location. Used by ODR code. 1294 1295 struct Symbol_location 1296 { 1297 // Object where the symbol is defined. 1298 Object* object; 1299 // Section-in-object where the symbol is defined. 1300 unsigned int shndx; 1301 // For relocatable objects, offset-in-section where the symbol is defined. 1302 // For dynamic objects, address where the symbol is defined. 1303 off_t offset; 1304 bool operator==(const Symbol_location& that) const 1305 { 1306 return (this->object == that.object 1307 && this->shndx == that.shndx 1308 && this->offset == that.offset); 1309 } 1310 }; 1311 1312 // A map from symbol name (as a pointer into the namepool) to all 1313 // the locations the symbols is (weakly) defined (and certain other 1314 // conditions are met). This map will be used later to detect 1315 // possible One Definition Rule (ODR) violations. 1316 struct Symbol_location_hash 1317 { 1318 size_t operator()(const Symbol_location& loc) const 1319 { return reinterpret_cast<uintptr_t>(loc.object) ^ loc.offset ^ loc.shndx; } 1320 }; 1321 1322 // This class manages warnings. Warnings are a GNU extension. When 1323 // we see a section named .gnu.warning.SYM in an object file, and if 1324 // we wind using the definition of SYM from that object file, then we 1325 // will issue a warning for any relocation against SYM from a 1326 // different object file. The text of the warning is the contents of 1327 // the section. This is not precisely the definition used by the old 1328 // GNU linker; the old GNU linker treated an occurrence of 1329 // .gnu.warning.SYM as defining a warning symbol. A warning symbol 1330 // would trigger a warning on any reference. However, it was 1331 // inconsistent in that a warning in a dynamic object only triggered 1332 // if there was no definition in a regular object. This linker is 1333 // different in that we only issue a warning if we use the symbol 1334 // definition from the same object file as the warning section. 1335 1336 class Warnings 1337 { 1338 public: 1339 Warnings() 1340 : warnings_() 1341 { } 1342 1343 // Add a warning for symbol NAME in object OBJ. WARNING is the text 1344 // of the warning. 1345 void 1346 add_warning(Symbol_table* symtab, const char* name, Object* obj, 1347 const std::string& warning); 1348 1349 // For each symbol for which we should give a warning, make a note 1350 // on the symbol. 1351 void 1352 note_warnings(Symbol_table* symtab); 1353 1354 // Issue a warning for a reference to SYM at RELINFO's location. 1355 template<int size, bool big_endian> 1356 void 1357 issue_warning(const Symbol* sym, const Relocate_info<size, big_endian>*, 1358 size_t relnum, off_t reloffset) const; 1359 1360 private: 1361 Warnings(const Warnings&); 1362 Warnings& operator=(const Warnings&); 1363 1364 // What we need to know to get the warning text. 1365 struct Warning_location 1366 { 1367 // The object the warning is in. 1368 Object* object; 1369 // The warning text. 1370 std::string text; 1371 1372 Warning_location() 1373 : object(NULL), text() 1374 { } 1375 1376 void 1377 set(Object* o, const std::string& t) 1378 { 1379 this->object = o; 1380 this->text = t; 1381 } 1382 }; 1383 1384 // A mapping from warning symbol names (canonicalized in 1385 // Symbol_table's namepool_ field) to warning information. 1386 typedef Unordered_map<const char*, Warning_location> Warning_table; 1387 1388 Warning_table warnings_; 1389 }; 1390 1391 // The main linker symbol table. 1392 1393 class Symbol_table 1394 { 1395 public: 1396 // The different places where a symbol definition can come from. 1397 enum Defined 1398 { 1399 // Defined in an object file--the normal case. 1400 OBJECT, 1401 // Defined for a COPY reloc. 1402 COPY, 1403 // Defined on the command line using --defsym. 1404 DEFSYM, 1405 // Defined (so to speak) on the command line using -u. 1406 UNDEFINED, 1407 // Defined in a linker script. 1408 SCRIPT, 1409 // Predefined by the linker. 1410 PREDEFINED, 1411 // Defined by the linker during an incremental base link, but not 1412 // a predefined symbol (e.g., common, defined in script). 1413 INCREMENTAL_BASE, 1414 }; 1415 1416 // The order in which we sort common symbols. 1417 enum Sort_commons_order 1418 { 1419 SORT_COMMONS_BY_SIZE_DESCENDING, 1420 SORT_COMMONS_BY_ALIGNMENT_DESCENDING, 1421 SORT_COMMONS_BY_ALIGNMENT_ASCENDING 1422 }; 1423 1424 // COUNT is an estimate of how many symbols will be inserted in the 1425 // symbol table. It's ok to put 0 if you don't know; a correct 1426 // guess will just save some CPU by reducing hashtable resizes. 1427 Symbol_table(unsigned int count, const Version_script_info& version_script); 1428 1429 ~Symbol_table(); 1430 1431 void 1432 set_icf(Icf* icf) 1433 { this->icf_ = icf;} 1434 1435 Icf* 1436 icf() const 1437 { return this->icf_; } 1438 1439 // Returns true if ICF determined that this is a duplicate section. 1440 bool 1441 is_section_folded(Relobj* obj, unsigned int shndx) const; 1442 1443 void 1444 set_gc(Garbage_collection* gc) 1445 { this->gc_ = gc; } 1446 1447 Garbage_collection* 1448 gc() const 1449 { return this->gc_; } 1450 1451 // During garbage collection, this keeps undefined symbols. 1452 void 1453 gc_mark_undef_symbols(Layout*); 1454 1455 // This tells garbage collection that this symbol is referenced. 1456 void 1457 gc_mark_symbol(Symbol* sym); 1458 1459 // During garbage collection, this keeps sections that correspond to 1460 // symbols seen in dynamic objects. 1461 inline void 1462 gc_mark_dyn_syms(Symbol* sym); 1463 1464 // Add COUNT external symbols from the relocatable object RELOBJ to 1465 // the symbol table. SYMS is the symbols, SYMNDX_OFFSET is the 1466 // offset in the symbol table of the first symbol, SYM_NAMES is 1467 // their names, SYM_NAME_SIZE is the size of SYM_NAMES. This sets 1468 // SYMPOINTERS to point to the symbols in the symbol table. It sets 1469 // *DEFINED to the number of defined symbols. 1470 template<int size, bool big_endian> 1471 void 1472 add_from_relobj(Sized_relobj_file<size, big_endian>* relobj, 1473 const unsigned char* syms, size_t count, 1474 size_t symndx_offset, const char* sym_names, 1475 size_t sym_name_size, 1476 typename Sized_relobj_file<size, big_endian>::Symbols*, 1477 size_t* defined); 1478 1479 // Add one external symbol from the plugin object OBJ to the symbol table. 1480 // Returns a pointer to the resolved symbol in the symbol table. 1481 template<int size, bool big_endian> 1482 Symbol* 1483 add_from_pluginobj(Sized_pluginobj<size, big_endian>* obj, 1484 const char* name, const char* ver, 1485 elfcpp::Sym<size, big_endian>* sym); 1486 1487 // Add COUNT dynamic symbols from the dynamic object DYNOBJ to the 1488 // symbol table. SYMS is the symbols. SYM_NAMES is their names. 1489 // SYM_NAME_SIZE is the size of SYM_NAMES. The other parameters are 1490 // symbol version data. 1491 template<int size, bool big_endian> 1492 void 1493 add_from_dynobj(Sized_dynobj<size, big_endian>* dynobj, 1494 const unsigned char* syms, size_t count, 1495 const char* sym_names, size_t sym_name_size, 1496 const unsigned char* versym, size_t versym_size, 1497 const std::vector<const char*>*, 1498 typename Sized_relobj_file<size, big_endian>::Symbols*, 1499 size_t* defined); 1500 1501 // Add one external symbol from the incremental object OBJ to the symbol 1502 // table. Returns a pointer to the resolved symbol in the symbol table. 1503 template<int size, bool big_endian> 1504 Sized_symbol<size>* 1505 add_from_incrobj(Object* obj, const char* name, 1506 const char* ver, elfcpp::Sym<size, big_endian>* sym); 1507 1508 // Define a special symbol based on an Output_data. It is a 1509 // multiple definition error if this symbol is already defined. 1510 Symbol* 1511 define_in_output_data(const char* name, const char* version, Defined, 1512 Output_data*, uint64_t value, uint64_t symsize, 1513 elfcpp::STT type, elfcpp::STB binding, 1514 elfcpp::STV visibility, unsigned char nonvis, 1515 bool offset_is_from_end, bool only_if_ref); 1516 1517 // Define a special symbol based on an Output_segment. It is a 1518 // multiple definition error if this symbol is already defined. 1519 Symbol* 1520 define_in_output_segment(const char* name, const char* version, Defined, 1521 Output_segment*, uint64_t value, uint64_t symsize, 1522 elfcpp::STT type, elfcpp::STB binding, 1523 elfcpp::STV visibility, unsigned char nonvis, 1524 Symbol::Segment_offset_base, bool only_if_ref); 1525 1526 // Define a special symbol with a constant value. It is a multiple 1527 // definition error if this symbol is already defined. 1528 Symbol* 1529 define_as_constant(const char* name, const char* version, Defined, 1530 uint64_t value, uint64_t symsize, elfcpp::STT type, 1531 elfcpp::STB binding, elfcpp::STV visibility, 1532 unsigned char nonvis, bool only_if_ref, 1533 bool force_override); 1534 1535 // Define a set of symbols in output sections. If ONLY_IF_REF is 1536 // true, only define them if they are referenced. 1537 void 1538 define_symbols(const Layout*, int count, const Define_symbol_in_section*, 1539 bool only_if_ref); 1540 1541 // Define a set of symbols in output segments. If ONLY_IF_REF is 1542 // true, only defined them if they are referenced. 1543 void 1544 define_symbols(const Layout*, int count, const Define_symbol_in_segment*, 1545 bool only_if_ref); 1546 1547 // Add a target-specific global symbol. 1548 // (Used by SPARC backend to add STT_SPARC_REGISTER symbols.) 1549 void 1550 add_target_global_symbol(Symbol* sym) 1551 { this->target_symbols_.push_back(sym); } 1552 1553 // Define SYM using a COPY reloc. POSD is the Output_data where the 1554 // symbol should be defined--typically a .dyn.bss section. VALUE is 1555 // the offset within POSD. 1556 template<int size> 1557 void 1558 define_with_copy_reloc(Sized_symbol<size>* sym, Output_data* posd, 1559 typename elfcpp::Elf_types<size>::Elf_Addr); 1560 1561 // Look up a symbol. 1562 Symbol* 1563 lookup(const char*, const char* version = NULL) const; 1564 1565 // Return the real symbol associated with the forwarder symbol FROM. 1566 Symbol* 1567 resolve_forwards(const Symbol* from) const; 1568 1569 // Return the sized version of a symbol in this table. 1570 template<int size> 1571 Sized_symbol<size>* 1572 get_sized_symbol(Symbol*) const; 1573 1574 template<int size> 1575 const Sized_symbol<size>* 1576 get_sized_symbol(const Symbol*) const; 1577 1578 // Return the count of undefined symbols seen. 1579 size_t 1580 saw_undefined() const 1581 { return this->saw_undefined_; } 1582 1583 void 1584 set_has_gnu_output() 1585 { this->has_gnu_output_ = true; } 1586 1587 // Allocate the common symbols 1588 void 1589 allocate_commons(Layout*, Mapfile*); 1590 1591 // Add a warning for symbol NAME in object OBJ. WARNING is the text 1592 // of the warning. 1593 void 1594 add_warning(const char* name, Object* obj, const std::string& warning) 1595 { this->warnings_.add_warning(this, name, obj, warning); } 1596 1597 // Canonicalize a symbol name for use in the hash table. 1598 const char* 1599 canonicalize_name(const char* name) 1600 { return this->namepool_.add(name, true, NULL); } 1601 1602 // Possibly issue a warning for a reference to SYM at LOCATION which 1603 // is in OBJ. 1604 template<int size, bool big_endian> 1605 void 1606 issue_warning(const Symbol* sym, 1607 const Relocate_info<size, big_endian>* relinfo, 1608 size_t relnum, off_t reloffset) const 1609 { this->warnings_.issue_warning(sym, relinfo, relnum, reloffset); } 1610 1611 // Check candidate_odr_violations_ to find symbols with the same name 1612 // but apparently different definitions (different source-file/line-no). 1613 void 1614 detect_odr_violations(const Task*, const char* output_file_name) const; 1615 1616 // Add any undefined symbols named on the command line to the symbol 1617 // table. 1618 void 1619 add_undefined_symbols_from_command_line(Layout*); 1620 1621 // SYM is defined using a COPY reloc. Return the dynamic object 1622 // where the original definition was found. 1623 Dynobj* 1624 get_copy_source(const Symbol* sym) const; 1625 1626 // Set the dynamic symbol indexes. INDEX is the index of the first 1627 // global dynamic symbol. Return the count of forced-local symbols in 1628 // *PFORCED_LOCAL_COUNT. Pointers to the symbols are stored into 1629 // the vector. The names are stored into the Stringpool. This 1630 // returns an updated dynamic symbol index. 1631 unsigned int 1632 set_dynsym_indexes(unsigned int index, unsigned int* pforced_local_count, 1633 std::vector<Symbol*>*, Stringpool*, Versions*); 1634 1635 // Finalize the symbol table after we have set the final addresses 1636 // of all the input sections. This sets the final symbol indexes, 1637 // values and adds the names to *POOL. *PLOCAL_SYMCOUNT is the 1638 // index of the first global symbol. OFF is the file offset of the 1639 // global symbol table, DYNOFF is the offset of the globals in the 1640 // dynamic symbol table, DYN_GLOBAL_INDEX is the index of the first 1641 // global dynamic symbol, and DYNCOUNT is the number of global 1642 // dynamic symbols. This records the parameters, and returns the 1643 // new file offset. It updates *PLOCAL_SYMCOUNT if it created any 1644 // local symbols. 1645 off_t 1646 finalize(off_t off, off_t dynoff, size_t dyn_global_index, size_t dyncount, 1647 Stringpool* pool, unsigned int* plocal_symcount); 1648 1649 // Set the final file offset of the symbol table. 1650 void 1651 set_file_offset(off_t off) 1652 { this->offset_ = off; } 1653 1654 // Status code of Symbol_table::compute_final_value. 1655 enum Compute_final_value_status 1656 { 1657 // No error. 1658 CFVS_OK, 1659 // Unsupported symbol section. 1660 CFVS_UNSUPPORTED_SYMBOL_SECTION, 1661 // No output section. 1662 CFVS_NO_OUTPUT_SECTION 1663 }; 1664 1665 // Compute the final value of SYM and store status in location PSTATUS. 1666 // During relaxation, this may be called multiple times for a symbol to 1667 // compute its would-be final value in each relaxation pass. 1668 1669 template<int size> 1670 typename Sized_symbol<size>::Value_type 1671 compute_final_value(const Sized_symbol<size>* sym, 1672 Compute_final_value_status* pstatus) const; 1673 1674 // Return the index of the first global symbol. 1675 unsigned int 1676 first_global_index() const 1677 { return this->first_global_index_; } 1678 1679 // Return the total number of symbols in the symbol table. 1680 unsigned int 1681 output_count() const 1682 { return this->output_count_; } 1683 1684 // Write out the global symbols. 1685 void 1686 write_globals(const Stringpool*, const Stringpool*, 1687 Output_symtab_xindex*, Output_symtab_xindex*, 1688 Output_file*) const; 1689 1690 // Write out a section symbol. Return the updated offset. 1691 void 1692 write_section_symbol(const Output_section*, Output_symtab_xindex*, 1693 Output_file*, off_t) const; 1694 1695 // Loop over all symbols, applying the function F to each. 1696 template<int size, typename F> 1697 void 1698 for_all_symbols(F f) const 1699 { 1700 for (Symbol_table_type::const_iterator p = this->table_.begin(); 1701 p != this->table_.end(); 1702 ++p) 1703 { 1704 Sized_symbol<size>* sym = static_cast<Sized_symbol<size>*>(p->second); 1705 f(sym); 1706 } 1707 } 1708 1709 // Dump statistical information to stderr. 1710 void 1711 print_stats() const; 1712 1713 // Return the version script information. 1714 const Version_script_info& 1715 version_script() const 1716 { return version_script_; } 1717 1718 // Completely override existing symbol. 1719 template<int size> 1720 void 1721 clone(Sized_symbol<size>* to, const Sized_symbol<size>* from) 1722 { 1723 if (to->clone(from)) 1724 this->force_local(to); 1725 } 1726 1727 private: 1728 Symbol_table(const Symbol_table&); 1729 Symbol_table& operator=(const Symbol_table&); 1730 1731 // The type of the list of common symbols. 1732 typedef std::vector<Symbol*> Commons_type; 1733 1734 // The type of the symbol hash table. 1735 1736 typedef std::pair<Stringpool::Key, Stringpool::Key> Symbol_table_key; 1737 1738 // The hash function. The key values are Stringpool keys. 1739 struct Symbol_table_hash 1740 { 1741 inline size_t 1742 operator()(const Symbol_table_key& key) const 1743 { 1744 return key.first ^ key.second; 1745 } 1746 }; 1747 1748 struct Symbol_table_eq 1749 { 1750 bool 1751 operator()(const Symbol_table_key&, const Symbol_table_key&) const; 1752 }; 1753 1754 typedef Unordered_map<Symbol_table_key, Symbol*, Symbol_table_hash, 1755 Symbol_table_eq> Symbol_table_type; 1756 1757 typedef Unordered_map<const char*, 1758 Unordered_set<Symbol_location, Symbol_location_hash> > 1759 Odr_map; 1760 1761 // Make FROM a forwarder symbol to TO. 1762 void 1763 make_forwarder(Symbol* from, Symbol* to); 1764 1765 // Add a symbol. 1766 template<int size, bool big_endian> 1767 Sized_symbol<size>* 1768 add_from_object(Object*, const char* name, Stringpool::Key name_key, 1769 const char* version, Stringpool::Key version_key, 1770 bool def, const elfcpp::Sym<size, big_endian>& sym, 1771 unsigned int st_shndx, bool is_ordinary, 1772 unsigned int orig_st_shndx); 1773 1774 // Define a default symbol. 1775 template<int size, bool big_endian> 1776 void 1777 define_default_version(Sized_symbol<size>*, bool, 1778 Symbol_table_type::iterator); 1779 1780 // Resolve symbols. 1781 template<int size, bool big_endian> 1782 void 1783 resolve(Sized_symbol<size>* to, 1784 const elfcpp::Sym<size, big_endian>& sym, 1785 unsigned int st_shndx, bool is_ordinary, 1786 unsigned int orig_st_shndx, 1787 Object*, const char* version, 1788 bool is_default_version); 1789 1790 template<int size, bool big_endian> 1791 void 1792 resolve(Sized_symbol<size>* to, const Sized_symbol<size>* from); 1793 1794 // Record that a symbol is forced to be local by a version script or 1795 // by visibility. 1796 void 1797 force_local(Symbol*); 1798 1799 // Adjust NAME and *NAME_KEY for wrapping. 1800 const char* 1801 wrap_symbol(const char* name, Stringpool::Key* name_key); 1802 1803 // Whether we should override a symbol, based on flags in 1804 // resolve.cc. 1805 static bool 1806 should_override(const Symbol*, unsigned int, elfcpp::STT, Defined, 1807 Object*, bool*, bool*, bool); 1808 1809 // Report a problem in symbol resolution. 1810 static void 1811 report_resolve_problem(bool is_error, const char* msg, const Symbol* to, 1812 Defined, Object* object); 1813 1814 // Override a symbol. 1815 template<int size, bool big_endian> 1816 void 1817 override(Sized_symbol<size>* tosym, 1818 const elfcpp::Sym<size, big_endian>& fromsym, 1819 unsigned int st_shndx, bool is_ordinary, 1820 Object* object, const char* version); 1821 1822 // Whether we should override a symbol with a special symbol which 1823 // is automatically defined by the linker. 1824 static bool 1825 should_override_with_special(const Symbol*, elfcpp::STT, Defined); 1826 1827 // Override a symbol with a special symbol. 1828 template<int size> 1829 void 1830 override_with_special(Sized_symbol<size>* tosym, 1831 const Sized_symbol<size>* fromsym); 1832 1833 // Record all weak alias sets for a dynamic object. 1834 template<int size> 1835 void 1836 record_weak_aliases(std::vector<Sized_symbol<size>*>*); 1837 1838 // Define a special symbol. 1839 template<int size, bool big_endian> 1840 Sized_symbol<size>* 1841 define_special_symbol(const char** pname, const char** pversion, 1842 bool only_if_ref, elfcpp::STV visibility, 1843 Sized_symbol<size>** poldsym, 1844 bool* resolve_oldsym, bool is_forced_local); 1845 1846 // Define a symbol in an Output_data, sized version. 1847 template<int size> 1848 Sized_symbol<size>* 1849 do_define_in_output_data(const char* name, const char* version, Defined, 1850 Output_data*, 1851 typename elfcpp::Elf_types<size>::Elf_Addr value, 1852 typename elfcpp::Elf_types<size>::Elf_WXword ssize, 1853 elfcpp::STT type, elfcpp::STB binding, 1854 elfcpp::STV visibility, unsigned char nonvis, 1855 bool offset_is_from_end, bool only_if_ref); 1856 1857 // Define a symbol in an Output_segment, sized version. 1858 template<int size> 1859 Sized_symbol<size>* 1860 do_define_in_output_segment( 1861 const char* name, const char* version, Defined, Output_segment* os, 1862 typename elfcpp::Elf_types<size>::Elf_Addr value, 1863 typename elfcpp::Elf_types<size>::Elf_WXword ssize, 1864 elfcpp::STT type, elfcpp::STB binding, 1865 elfcpp::STV visibility, unsigned char nonvis, 1866 Symbol::Segment_offset_base offset_base, bool only_if_ref); 1867 1868 // Define a symbol as a constant, sized version. 1869 template<int size> 1870 Sized_symbol<size>* 1871 do_define_as_constant( 1872 const char* name, const char* version, Defined, 1873 typename elfcpp::Elf_types<size>::Elf_Addr value, 1874 typename elfcpp::Elf_types<size>::Elf_WXword ssize, 1875 elfcpp::STT type, elfcpp::STB binding, 1876 elfcpp::STV visibility, unsigned char nonvis, 1877 bool only_if_ref, bool force_override); 1878 1879 // Add any undefined symbols named on the command line to the symbol 1880 // table, sized version. 1881 template<int size> 1882 void 1883 do_add_undefined_symbols_from_command_line(Layout*); 1884 1885 // Add one undefined symbol. 1886 template<int size> 1887 void 1888 add_undefined_symbol_from_command_line(const char* name); 1889 1890 // Types of common symbols. 1891 1892 enum Commons_section_type 1893 { 1894 COMMONS_NORMAL, 1895 COMMONS_TLS, 1896 COMMONS_SMALL, 1897 COMMONS_LARGE 1898 }; 1899 1900 // Allocate the common symbols, sized version. 1901 template<int size> 1902 void 1903 do_allocate_commons(Layout*, Mapfile*, Sort_commons_order); 1904 1905 // Allocate the common symbols from one list. 1906 template<int size> 1907 void 1908 do_allocate_commons_list(Layout*, Commons_section_type, Commons_type*, 1909 Mapfile*, Sort_commons_order); 1910 1911 // Returns all of the lines attached to LOC, not just the one the 1912 // instruction actually came from. This helps the ODR checker avoid 1913 // false positives. 1914 static std::vector<std::string> 1915 linenos_from_loc(const Task* task, const Symbol_location& loc); 1916 1917 // Implement detect_odr_violations. 1918 template<int size, bool big_endian> 1919 void 1920 sized_detect_odr_violations() const; 1921 1922 // Finalize symbols specialized for size. 1923 template<int size> 1924 off_t 1925 sized_finalize(off_t, Stringpool*, unsigned int*); 1926 1927 // Finalize a symbol. Return whether it should be added to the 1928 // symbol table. 1929 template<int size> 1930 bool 1931 sized_finalize_symbol(Symbol*); 1932 1933 // Add a symbol the final symtab by setting its index. 1934 template<int size> 1935 void 1936 add_to_final_symtab(Symbol*, Stringpool*, unsigned int* pindex, off_t* poff); 1937 1938 // Write globals specialized for size and endianness. 1939 template<int size, bool big_endian> 1940 void 1941 sized_write_globals(const Stringpool*, const Stringpool*, 1942 Output_symtab_xindex*, Output_symtab_xindex*, 1943 Output_file*) const; 1944 1945 // Write out a symbol to P. 1946 template<int size, bool big_endian> 1947 void 1948 sized_write_symbol(Sized_symbol<size>*, 1949 typename elfcpp::Elf_types<size>::Elf_Addr value, 1950 unsigned int shndx, elfcpp::STB, 1951 const Stringpool*, unsigned char* p) const; 1952 1953 // Possibly warn about an undefined symbol from a dynamic object. 1954 void 1955 warn_about_undefined_dynobj_symbol(Symbol*) const; 1956 1957 // Write out a section symbol, specialized for size and endianness. 1958 template<int size, bool big_endian> 1959 void 1960 sized_write_section_symbol(const Output_section*, Output_symtab_xindex*, 1961 Output_file*, off_t) const; 1962 1963 // The type of the list of symbols which have been forced local. 1964 typedef std::vector<Symbol*> Forced_locals; 1965 1966 // A map from symbols with COPY relocs to the dynamic objects where 1967 // they are defined. 1968 typedef Unordered_map<const Symbol*, Dynobj*> Copied_symbol_dynobjs; 1969 1970 // We increment this every time we see a new undefined symbol, for 1971 // use in archive groups. 1972 size_t saw_undefined_; 1973 // The index of the first global symbol in the output file. 1974 unsigned int first_global_index_; 1975 // The file offset within the output symtab section where we should 1976 // write the table. 1977 off_t offset_; 1978 // The number of global symbols we want to write out. 1979 unsigned int output_count_; 1980 // The file offset of the global dynamic symbols, or 0 if none. 1981 off_t dynamic_offset_; 1982 // The index of the first global dynamic symbol (including 1983 // forced-local symbols). 1984 unsigned int first_dynamic_global_index_; 1985 // The number of global dynamic symbols (including forced-local symbols), 1986 // or 0 if none. 1987 unsigned int dynamic_count_; 1988 // Set if a STT_GNU_IFUNC or STB_GNU_UNIQUE symbol will be output. 1989 bool has_gnu_output_; 1990 // The symbol hash table. 1991 Symbol_table_type table_; 1992 // A pool of symbol names. This is used for all global symbols. 1993 // Entries in the hash table point into this pool. 1994 Stringpool namepool_; 1995 // Forwarding symbols. 1996 Unordered_map<const Symbol*, Symbol*> forwarders_; 1997 // Weak aliases. A symbol in this list points to the next alias. 1998 // The aliases point to each other in a circular list. 1999 Unordered_map<Symbol*, Symbol*> weak_aliases_; 2000 // We don't expect there to be very many common symbols, so we keep 2001 // a list of them. When we find a common symbol we add it to this 2002 // list. It is possible that by the time we process the list the 2003 // symbol is no longer a common symbol. It may also have become a 2004 // forwarder. 2005 Commons_type commons_; 2006 // This is like the commons_ field, except that it holds TLS common 2007 // symbols. 2008 Commons_type tls_commons_; 2009 // This is for small common symbols. 2010 Commons_type small_commons_; 2011 // This is for large common symbols. 2012 Commons_type large_commons_; 2013 // A list of symbols which have been forced to be local. We don't 2014 // expect there to be very many of them, so we keep a list of them 2015 // rather than walking the whole table to find them. 2016 Forced_locals forced_locals_; 2017 // Manage symbol warnings. 2018 Warnings warnings_; 2019 // Manage potential One Definition Rule (ODR) violations. 2020 Odr_map candidate_odr_violations_; 2021 2022 // When we emit a COPY reloc for a symbol, we define it in an 2023 // Output_data. When it's time to emit version information for it, 2024 // we need to know the dynamic object in which we found the original 2025 // definition. This maps symbols with COPY relocs to the dynamic 2026 // object where they were defined. 2027 Copied_symbol_dynobjs copied_symbol_dynobjs_; 2028 // Information parsed from the version script, if any. 2029 const Version_script_info& version_script_; 2030 Garbage_collection* gc_; 2031 Icf* icf_; 2032 // Target-specific symbols, if any. 2033 std::vector<Symbol*> target_symbols_; 2034 }; 2035 2036 // We inline get_sized_symbol for efficiency. 2037 2038 template<int size> 2039 Sized_symbol<size>* 2040 Symbol_table::get_sized_symbol(Symbol* sym) const 2041 { 2042 gold_assert(size == parameters->target().get_size()); 2043 return static_cast<Sized_symbol<size>*>(sym); 2044 } 2045 2046 template<int size> 2047 const Sized_symbol<size>* 2048 Symbol_table::get_sized_symbol(const Symbol* sym) const 2049 { 2050 gold_assert(size == parameters->target().get_size()); 2051 return static_cast<const Sized_symbol<size>*>(sym); 2052 } 2053 2054 } // End namespace gold. 2055 2056 #endif // !defined(GOLD_SYMTAB_H) 2057