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