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