1// object.h -- support for an object file for linking in gold -*- C++ -*- 2 3// Copyright 2006, 2007, 2008, 2009, 2010, 2011 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#ifndef GOLD_OBJECT_H 24#define GOLD_OBJECT_H 25 26#include <string> 27#include <vector> 28 29#include "elfcpp.h" 30#include "elfcpp_file.h" 31#include "fileread.h" 32#include "target.h" 33#include "archive.h" 34 35namespace gold 36{ 37 38class General_options; 39class Task; 40class Cref; 41class Layout; 42class Output_data; 43class Output_section; 44class Output_file; 45class Output_symtab_xindex; 46class Pluginobj; 47class Dynobj; 48class Object_merge_map; 49class Relocatable_relocs; 50class Symbols_data; 51 52template<typename Stringpool_char> 53class Stringpool_template; 54 55// Data to pass from read_symbols() to add_symbols(). 56 57struct Read_symbols_data 58{ 59 Read_symbols_data() 60 : section_headers(NULL), section_names(NULL), symbols(NULL), 61 symbol_names(NULL), versym(NULL), verdef(NULL), verneed(NULL) 62 { } 63 64 ~Read_symbols_data(); 65 66 // Section headers. 67 File_view* section_headers; 68 // Section names. 69 File_view* section_names; 70 // Size of section name data in bytes. 71 section_size_type section_names_size; 72 // Symbol data. 73 File_view* symbols; 74 // Size of symbol data in bytes. 75 section_size_type symbols_size; 76 // Offset of external symbols within symbol data. This structure 77 // sometimes contains only external symbols, in which case this will 78 // be zero. Sometimes it contains all symbols. 79 section_offset_type external_symbols_offset; 80 // Symbol names. 81 File_view* symbol_names; 82 // Size of symbol name data in bytes. 83 section_size_type symbol_names_size; 84 85 // Version information. This is only used on dynamic objects. 86 // Version symbol data (from SHT_GNU_versym section). 87 File_view* versym; 88 section_size_type versym_size; 89 // Version definition data (from SHT_GNU_verdef section). 90 File_view* verdef; 91 section_size_type verdef_size; 92 unsigned int verdef_info; 93 // Needed version data (from SHT_GNU_verneed section). 94 File_view* verneed; 95 section_size_type verneed_size; 96 unsigned int verneed_info; 97}; 98 99// Information used to print error messages. 100 101struct Symbol_location_info 102{ 103 std::string source_file; 104 std::string enclosing_symbol_name; 105 int line_number; 106}; 107 108// Data about a single relocation section. This is read in 109// read_relocs and processed in scan_relocs. 110 111struct Section_relocs 112{ 113 Section_relocs() 114 : contents(NULL) 115 { } 116 117 ~Section_relocs() 118 { delete this->contents; } 119 120 // Index of reloc section. 121 unsigned int reloc_shndx; 122 // Index of section that relocs apply to. 123 unsigned int data_shndx; 124 // Contents of reloc section. 125 File_view* contents; 126 // Reloc section type. 127 unsigned int sh_type; 128 // Number of reloc entries. 129 size_t reloc_count; 130 // Output section. 131 Output_section* output_section; 132 // Whether this section has special handling for offsets. 133 bool needs_special_offset_handling; 134 // Whether the data section is allocated (has the SHF_ALLOC flag set). 135 bool is_data_section_allocated; 136}; 137 138// Relocations in an object file. This is read in read_relocs and 139// processed in scan_relocs. 140 141struct Read_relocs_data 142{ 143 Read_relocs_data() 144 : local_symbols(NULL) 145 { } 146 147 ~Read_relocs_data() 148 { delete this->local_symbols; } 149 150 typedef std::vector<Section_relocs> Relocs_list; 151 // The relocations. 152 Relocs_list relocs; 153 // The local symbols. 154 File_view* local_symbols; 155}; 156 157// The Xindex class manages section indexes for objects with more than 158// 0xff00 sections. 159 160class Xindex 161{ 162 public: 163 Xindex(int large_shndx_offset) 164 : large_shndx_offset_(large_shndx_offset), symtab_xindex_() 165 { } 166 167 // Initialize the symtab_xindex_ array, given the object and the 168 // section index of the symbol table to use. 169 template<int size, bool big_endian> 170 void 171 initialize_symtab_xindex(Object*, unsigned int symtab_shndx); 172 173 // Read in the symtab_xindex_ array, given its section index. 174 // PSHDRS may optionally point to the section headers. 175 template<int size, bool big_endian> 176 void 177 read_symtab_xindex(Object*, unsigned int xindex_shndx, 178 const unsigned char* pshdrs); 179 180 // Symbol SYMNDX in OBJECT has a section of SHN_XINDEX; return the 181 // real section index. 182 unsigned int 183 sym_xindex_to_shndx(Object* object, unsigned int symndx); 184 185 private: 186 // The type of the array giving the real section index for symbols 187 // whose st_shndx field holds SHN_XINDEX. 188 typedef std::vector<unsigned int> Symtab_xindex; 189 190 // Adjust a section index if necessary. This should only be called 191 // for ordinary section indexes. 192 unsigned int 193 adjust_shndx(unsigned int shndx) 194 { 195 if (shndx >= elfcpp::SHN_LORESERVE) 196 shndx += this->large_shndx_offset_; 197 return shndx; 198 } 199 200 // Adjust to apply to large section indexes. 201 int large_shndx_offset_; 202 // The data from the SHT_SYMTAB_SHNDX section. 203 Symtab_xindex symtab_xindex_; 204}; 205 206// Object is an abstract base class which represents either a 32-bit 207// or a 64-bit input object. This can be a regular object file 208// (ET_REL) or a shared object (ET_DYN). 209 210class Object 211{ 212 public: 213 typedef std::vector<Symbol*> Symbols; 214 215 // NAME is the name of the object as we would report it to the user 216 // (e.g., libfoo.a(bar.o) if this is in an archive. INPUT_FILE is 217 // used to read the file. OFFSET is the offset within the input 218 // file--0 for a .o or .so file, something else for a .a file. 219 Object(const std::string& name, Input_file* input_file, bool is_dynamic, 220 off_t offset = 0) 221 : name_(name), input_file_(input_file), offset_(offset), shnum_(-1U), 222 is_dynamic_(is_dynamic), is_needed_(false), uses_split_stack_(false), 223 has_no_split_stack_(false), no_export_(false), xindex_(NULL) 224 { input_file->file().add_object(); } 225 226 virtual ~Object() 227 { this->input_file_->file().remove_object(); } 228 229 // Return the name of the object as we would report it to the tuser. 230 const std::string& 231 name() const 232 { return this->name_; } 233 234 // Get the offset into the file. 235 off_t 236 offset() const 237 { return this->offset_; } 238 239 // Return whether this is a dynamic object. 240 bool 241 is_dynamic() const 242 { return this->is_dynamic_; } 243 244 // Return whether this object is needed--true if it is a dynamic 245 // object which defines some symbol referenced by a regular object. 246 // We keep the flag here rather than in Dynobj for convenience when 247 // setting it. 248 bool 249 is_needed() const 250 { return this->is_needed_; } 251 252 // Record that this object is needed. 253 void 254 set_is_needed() 255 { this->is_needed_ = true; } 256 257 // Return whether this object was compiled with -fsplit-stack. 258 bool 259 uses_split_stack() const 260 { return this->uses_split_stack_; } 261 262 // Return whether this object contains any functions compiled with 263 // the no_split_stack attribute. 264 bool 265 has_no_split_stack() const 266 { return this->has_no_split_stack_; } 267 268 // Returns NULL for Objects that are not plugin objects. This method 269 // is overridden in the Pluginobj class. 270 Pluginobj* 271 pluginobj() 272 { return this->do_pluginobj(); } 273 274 // Get the file. We pass on const-ness. 275 Input_file* 276 input_file() 277 { return this->input_file_; } 278 279 const Input_file* 280 input_file() const 281 { return this->input_file_; } 282 283 // Lock the underlying file. 284 void 285 lock(const Task* t) 286 { this->input_file()->file().lock(t); } 287 288 // Unlock the underlying file. 289 void 290 unlock(const Task* t) 291 { this->input_file()->file().unlock(t); } 292 293 // Return whether the underlying file is locked. 294 bool 295 is_locked() const 296 { return this->input_file()->file().is_locked(); } 297 298 // Return the token, so that the task can be queued. 299 Task_token* 300 token() 301 { return this->input_file()->file().token(); } 302 303 // Release the underlying file. 304 void 305 release() 306 { this->input_file_->file().release(); } 307 308 // Return whether we should just read symbols from this file. 309 bool 310 just_symbols() const 311 { return this->input_file()->just_symbols(); } 312 313 // Get the number of sections. 314 unsigned int 315 shnum() const 316 { return this->shnum_; } 317 318 // Return a view of the contents of a section. Set *PLEN to the 319 // size. CACHE is a hint as in File_read::get_view. 320 const unsigned char* 321 section_contents(unsigned int shndx, section_size_type* plen, bool cache); 322 323 // Adjust a symbol's section index as needed. SYMNDX is the index 324 // of the symbol and SHNDX is the symbol's section from 325 // get_st_shndx. This returns the section index. It sets 326 // *IS_ORDINARY to indicate whether this is a normal section index, 327 // rather than a special code between SHN_LORESERVE and 328 // SHN_HIRESERVE. 329 unsigned int 330 adjust_sym_shndx(unsigned int symndx, unsigned int shndx, bool* is_ordinary) 331 { 332 if (shndx < elfcpp::SHN_LORESERVE) 333 *is_ordinary = true; 334 else if (shndx == elfcpp::SHN_XINDEX) 335 { 336 if (this->xindex_ == NULL) 337 this->xindex_ = this->do_initialize_xindex(); 338 shndx = this->xindex_->sym_xindex_to_shndx(this, symndx); 339 *is_ordinary = true; 340 } 341 else 342 *is_ordinary = false; 343 return shndx; 344 } 345 346 // Return the size of a section given a section index. 347 uint64_t 348 section_size(unsigned int shndx) 349 { return this->do_section_size(shndx); } 350 351 // Return the name of a section given a section index. 352 std::string 353 section_name(unsigned int shndx) 354 { return this->do_section_name(shndx); } 355 356 // Return the section flags given a section index. 357 uint64_t 358 section_flags(unsigned int shndx) 359 { return this->do_section_flags(shndx); } 360 361 // Return the section entsize given a section index. 362 uint64_t 363 section_entsize(unsigned int shndx) 364 { return this->do_section_entsize(shndx); } 365 366 // Return the section address given a section index. 367 uint64_t 368 section_address(unsigned int shndx) 369 { return this->do_section_address(shndx); } 370 371 // Return the section type given a section index. 372 unsigned int 373 section_type(unsigned int shndx) 374 { return this->do_section_type(shndx); } 375 376 // Return the section link field given a section index. 377 unsigned int 378 section_link(unsigned int shndx) 379 { return this->do_section_link(shndx); } 380 381 // Return the section info field given a section index. 382 unsigned int 383 section_info(unsigned int shndx) 384 { return this->do_section_info(shndx); } 385 386 // Return the required section alignment given a section index. 387 uint64_t 388 section_addralign(unsigned int shndx) 389 { return this->do_section_addralign(shndx); } 390 391 // Return the output section given a section index. 392 Output_section* 393 output_section(unsigned int shndx) const 394 { return this->do_output_section(shndx); } 395 396 // Given a section index, return the offset in the Output_section. 397 // The return value will be -1U if the section is specially mapped, 398 // such as a merge section. 399 uint64_t 400 output_section_offset(unsigned int shndx) const 401 { return this->do_output_section_offset(shndx); } 402 403 // Read the symbol information. 404 void 405 read_symbols(Read_symbols_data* sd) 406 { return this->do_read_symbols(sd); } 407 408 // Pass sections which should be included in the link to the Layout 409 // object, and record where the sections go in the output file. 410 void 411 layout(Symbol_table* symtab, Layout* layout, Read_symbols_data* sd) 412 { this->do_layout(symtab, layout, sd); } 413 414 // Add symbol information to the global symbol table. 415 void 416 add_symbols(Symbol_table* symtab, Read_symbols_data* sd, Layout *layout) 417 { this->do_add_symbols(symtab, sd, layout); } 418 419 // Add symbol information to the global symbol table. 420 Archive::Should_include 421 should_include_member(Symbol_table* symtab, Layout* layout, 422 Read_symbols_data* sd, std::string* why) 423 { return this->do_should_include_member(symtab, layout, sd, why); } 424 425 // Functions and types for the elfcpp::Elf_file interface. This 426 // permit us to use Object as the File template parameter for 427 // elfcpp::Elf_file. 428 429 // The View class is returned by view. It must support a single 430 // method, data(). This is trivial, because get_view does what we 431 // need. 432 class View 433 { 434 public: 435 View(const unsigned char* p) 436 : p_(p) 437 { } 438 439 const unsigned char* 440 data() const 441 { return this->p_; } 442 443 private: 444 const unsigned char* p_; 445 }; 446 447 // Return a View. 448 View 449 view(off_t file_offset, section_size_type data_size) 450 { return View(this->get_view(file_offset, data_size, true, true)); } 451 452 // Report an error. 453 void 454 error(const char* format, ...) const ATTRIBUTE_PRINTF_2; 455 456 // A location in the file. 457 struct Location 458 { 459 off_t file_offset; 460 off_t data_size; 461 462 Location(off_t fo, section_size_type ds) 463 : file_offset(fo), data_size(ds) 464 { } 465 }; 466 467 // Get a View given a Location. 468 View view(Location loc) 469 { return View(this->get_view(loc.file_offset, loc.data_size, true, true)); } 470 471 // Get a view into the underlying file. 472 const unsigned char* 473 get_view(off_t start, section_size_type size, bool aligned, bool cache) 474 { 475 return this->input_file()->file().get_view(this->offset_, start, size, 476 aligned, cache); 477 } 478 479 // Get a lasting view into the underlying file. 480 File_view* 481 get_lasting_view(off_t start, section_size_type size, bool aligned, 482 bool cache) 483 { 484 return this->input_file()->file().get_lasting_view(this->offset_, start, 485 size, aligned, cache); 486 } 487 488 // Read data from the underlying file. 489 void 490 read(off_t start, section_size_type size, void* p) 491 { this->input_file()->file().read(start + this->offset_, size, p); } 492 493 // Read multiple data from the underlying file. 494 void 495 read_multiple(const File_read::Read_multiple& rm) 496 { this->input_file()->file().read_multiple(this->offset_, rm); } 497 498 // Stop caching views in the underlying file. 499 void 500 clear_view_cache_marks() 501 { this->input_file()->file().clear_view_cache_marks(); } 502 503 // Get the number of global symbols defined by this object, and the 504 // number of the symbols whose final definition came from this 505 // object. 506 void 507 get_global_symbol_counts(const Symbol_table* symtab, size_t* defined, 508 size_t* used) const 509 { this->do_get_global_symbol_counts(symtab, defined, used); } 510 511 // Get the symbols defined in this object. 512 const Symbols* 513 get_global_symbols() const 514 { return this->do_get_global_symbols(); } 515 516 // Return whether this object was found in a system directory. 517 bool 518 is_in_system_directory() const 519 { return this->input_file()->is_in_system_directory(); } 520 521 // Return whether we found this object by searching a directory. 522 bool 523 searched_for() const 524 { return this->input_file()->will_search_for(); } 525 526 bool 527 no_export() const 528 { return this->no_export_; } 529 530 void 531 set_no_export(bool value) 532 { this->no_export_ = value; } 533 534 // Return TRUE if the section is a compressed debug section, and set 535 // *UNCOMPRESSED_SIZE to the size of the uncompressed data. 536 bool 537 section_is_compressed(unsigned int shndx, 538 section_size_type* uncompressed_size) const 539 { return this->do_section_is_compressed(shndx, uncompressed_size); } 540 541 // Return the index of the first incremental relocation for symbol SYMNDX. 542 unsigned int 543 get_incremental_reloc_base(unsigned int symndx) const 544 { return this->do_get_incremental_reloc_base(symndx); } 545 546 // Return the number of incremental relocations for symbol SYMNDX. 547 unsigned int 548 get_incremental_reloc_count(unsigned int symndx) const 549 { return this->do_get_incremental_reloc_count(symndx); } 550 551 protected: 552 // Returns NULL for Objects that are not plugin objects. This method 553 // is overridden in the Pluginobj class. 554 virtual Pluginobj* 555 do_pluginobj() 556 { return NULL; } 557 558 // Read the symbols--implemented by child class. 559 virtual void 560 do_read_symbols(Read_symbols_data*) = 0; 561 562 // Lay out sections--implemented by child class. 563 virtual void 564 do_layout(Symbol_table*, Layout*, Read_symbols_data*) = 0; 565 566 // Add symbol information to the global symbol table--implemented by 567 // child class. 568 virtual void 569 do_add_symbols(Symbol_table*, Read_symbols_data*, Layout*) = 0; 570 571 virtual Archive::Should_include 572 do_should_include_member(Symbol_table* symtab, Layout*, Read_symbols_data*, 573 std::string* why) = 0; 574 575 // Return the location of the contents of a section. Implemented by 576 // child class. 577 virtual Location 578 do_section_contents(unsigned int shndx) = 0; 579 580 // Get the size of a section--implemented by child class. 581 virtual uint64_t 582 do_section_size(unsigned int shndx) = 0; 583 584 // Get the name of a section--implemented by child class. 585 virtual std::string 586 do_section_name(unsigned int shndx) = 0; 587 588 // Get section flags--implemented by child class. 589 virtual uint64_t 590 do_section_flags(unsigned int shndx) = 0; 591 592 // Get section entsize--implemented by child class. 593 virtual uint64_t 594 do_section_entsize(unsigned int shndx) = 0; 595 596 // Get section address--implemented by child class. 597 virtual uint64_t 598 do_section_address(unsigned int shndx) = 0; 599 600 // Get section type--implemented by child class. 601 virtual unsigned int 602 do_section_type(unsigned int shndx) = 0; 603 604 // Get section link field--implemented by child class. 605 virtual unsigned int 606 do_section_link(unsigned int shndx) = 0; 607 608 // Get section info field--implemented by child class. 609 virtual unsigned int 610 do_section_info(unsigned int shndx) = 0; 611 612 // Get section alignment--implemented by child class. 613 virtual uint64_t 614 do_section_addralign(unsigned int shndx) = 0; 615 616 // Return the output section given a section index--implemented 617 // by child class. 618 virtual Output_section* 619 do_output_section(unsigned int) const 620 { gold_unreachable(); } 621 622 // Get the offset of a section--implemented by child class. 623 virtual uint64_t 624 do_output_section_offset(unsigned int) const 625 { gold_unreachable(); } 626 627 // Return the Xindex structure to use. 628 virtual Xindex* 629 do_initialize_xindex() = 0; 630 631 // Implement get_global_symbol_counts--implemented by child class. 632 virtual void 633 do_get_global_symbol_counts(const Symbol_table*, size_t*, size_t*) const = 0; 634 635 virtual const Symbols* 636 do_get_global_symbols() const = 0; 637 638 // Set the number of sections. 639 void 640 set_shnum(int shnum) 641 { this->shnum_ = shnum; } 642 643 // Functions used by both Sized_relobj and Sized_dynobj. 644 645 // Read the section data into a Read_symbols_data object. 646 template<int size, bool big_endian> 647 void 648 read_section_data(elfcpp::Elf_file<size, big_endian, Object>*, 649 Read_symbols_data*); 650 651 // Let the child class initialize the xindex object directly. 652 void 653 set_xindex(Xindex* xindex) 654 { 655 gold_assert(this->xindex_ == NULL); 656 this->xindex_ = xindex; 657 } 658 659 // If NAME is the name of a special .gnu.warning section, arrange 660 // for the warning to be issued. SHNDX is the section index. 661 // Return whether it is a warning section. 662 bool 663 handle_gnu_warning_section(const char* name, unsigned int shndx, 664 Symbol_table*); 665 666 // If NAME is the name of the special section which indicates that 667 // this object was compiled with -fstack-split, mark it accordingly, 668 // and return true. Otherwise return false. 669 bool 670 handle_split_stack_section(const char* name); 671 672 // Return TRUE if the section is a compressed debug section, and set 673 // *UNCOMPRESSED_SIZE to the size of the uncompressed data. 674 virtual bool 675 do_section_is_compressed(unsigned int, section_size_type*) const 676 { return false; } 677 678 // Return the index of the first incremental relocation for symbol SYMNDX-- 679 // implemented by child class. 680 virtual unsigned int 681 do_get_incremental_reloc_base(unsigned int) const 682 { gold_unreachable(); } 683 684 // Return the number of incremental relocations for symbol SYMNDX-- 685 // implemented by child class. 686 virtual unsigned int 687 do_get_incremental_reloc_count(unsigned int) const 688 { gold_unreachable(); } 689 690 private: 691 // This class may not be copied. 692 Object(const Object&); 693 Object& operator=(const Object&); 694 695 // Name of object as printed to user. 696 std::string name_; 697 // For reading the file. 698 Input_file* input_file_; 699 // Offset within the file--0 for an object file, non-0 for an 700 // archive. 701 off_t offset_; 702 // Number of input sections. 703 unsigned int shnum_; 704 // Whether this is a dynamic object. 705 bool is_dynamic_ : 1; 706 // Whether this object is needed. This is only set for dynamic 707 // objects, and means that the object defined a symbol which was 708 // used by a reference from a regular object. 709 bool is_needed_ : 1; 710 // Whether this object was compiled with -fsplit-stack. 711 bool uses_split_stack_ : 1; 712 // Whether this object contains any functions compiled with the 713 // no_split_stack attribute. 714 bool has_no_split_stack_ : 1; 715 // True if exclude this object from automatic symbol export. 716 // This is used only for archive objects. 717 bool no_export_ : 1; 718 // Many sections for objects with more than SHN_LORESERVE sections. 719 Xindex* xindex_; 720}; 721 722// A regular object (ET_REL). This is an abstract base class itself. 723// The implementation is the template class Sized_relobj. 724 725class Relobj : public Object 726{ 727 public: 728 Relobj(const std::string& name, Input_file* input_file, off_t offset = 0) 729 : Object(name, input_file, false, offset), 730 output_sections_(), 731 map_to_relocatable_relocs_(NULL), 732 object_merge_map_(NULL), 733 relocs_must_follow_section_writes_(false), 734 sd_(NULL), 735 reloc_counts_(NULL), 736 reloc_bases_(NULL) 737 { } 738 739 // During garbage collection, the Read_symbols_data pass for 740 // each object is stored as layout needs to be done after 741 // reloc processing. 742 Symbols_data* 743 get_symbols_data() 744 { return this->sd_; } 745 746 // Decides which section names have to be included in the worklist 747 // as roots. 748 bool 749 is_section_name_included(const char* name); 750 751 void 752 copy_symbols_data(Symbols_data* gc_sd, Read_symbols_data* sd, 753 unsigned int section_header_size); 754 755 void 756 set_symbols_data(Symbols_data* sd) 757 { this->sd_ = sd; } 758 759 // During garbage collection, the Read_relocs pass for all objects 760 // is done before scanning the relocs. In that case, this->rd_ is 761 // used to store the information from Read_relocs for each object. 762 // This data is also used to compute the list of relevant sections. 763 Read_relocs_data* 764 get_relocs_data() 765 { return this->rd_; } 766 767 void 768 set_relocs_data(Read_relocs_data* rd) 769 { this->rd_ = rd; } 770 771 virtual bool 772 is_output_section_offset_invalid(unsigned int shndx) const = 0; 773 774 // Read the relocs. 775 void 776 read_relocs(Read_relocs_data* rd) 777 { return this->do_read_relocs(rd); } 778 779 // Process the relocs, during garbage collection only. 780 void 781 gc_process_relocs(Symbol_table* symtab, Layout* layout, Read_relocs_data* rd) 782 { return this->do_gc_process_relocs(symtab, layout, rd); } 783 784 // Scan the relocs and adjust the symbol table. 785 void 786 scan_relocs(Symbol_table* symtab, Layout* layout, Read_relocs_data* rd) 787 { return this->do_scan_relocs(symtab, layout, rd); } 788 789 // The number of local symbols in the input symbol table. 790 virtual unsigned int 791 local_symbol_count() const 792 { return this->do_local_symbol_count(); } 793 794 // Initial local symbol processing: count the number of local symbols 795 // in the output symbol table and dynamic symbol table; add local symbol 796 // names to *POOL and *DYNPOOL. 797 void 798 count_local_symbols(Stringpool_template<char>* pool, 799 Stringpool_template<char>* dynpool) 800 { return this->do_count_local_symbols(pool, dynpool); } 801 802 // Set the values of the local symbols, set the output symbol table 803 // indexes for the local variables, and set the offset where local 804 // symbol information will be stored. Returns the new local symbol index. 805 unsigned int 806 finalize_local_symbols(unsigned int index, off_t off, Symbol_table* symtab) 807 { return this->do_finalize_local_symbols(index, off, symtab); } 808 809 // Set the output dynamic symbol table indexes for the local variables. 810 unsigned int 811 set_local_dynsym_indexes(unsigned int index) 812 { return this->do_set_local_dynsym_indexes(index); } 813 814 // Set the offset where local dynamic symbol information will be stored. 815 unsigned int 816 set_local_dynsym_offset(off_t off) 817 { return this->do_set_local_dynsym_offset(off); } 818 819 // Relocate the input sections and write out the local symbols. 820 void 821 relocate(const Symbol_table* symtab, const Layout* layout, Output_file* of) 822 { return this->do_relocate(symtab, layout, of); } 823 824 // Return whether an input section is being included in the link. 825 bool 826 is_section_included(unsigned int shndx) const 827 { 828 gold_assert(shndx < this->output_sections_.size()); 829 return this->output_sections_[shndx] != NULL; 830 } 831 832 // The the output section of the input section with index SHNDX. 833 // This is only used currently to remove a section from the link in 834 // relaxation. 835 void 836 set_output_section(unsigned int shndx, Output_section* os) 837 { 838 gold_assert(shndx < this->output_sections_.size()); 839 this->output_sections_[shndx] = os; 840 } 841 842 // Set the offset of an input section within its output section. 843 void 844 set_section_offset(unsigned int shndx, uint64_t off) 845 { this->do_set_section_offset(shndx, off); } 846 847 // Return true if we need to wait for output sections to be written 848 // before we can apply relocations. This is true if the object has 849 // any relocations for sections which require special handling, such 850 // as the exception frame section. 851 bool 852 relocs_must_follow_section_writes() const 853 { return this->relocs_must_follow_section_writes_; } 854 855 // Return the object merge map. 856 Object_merge_map* 857 merge_map() const 858 { return this->object_merge_map_; } 859 860 // Set the object merge map. 861 void 862 set_merge_map(Object_merge_map* object_merge_map) 863 { 864 gold_assert(this->object_merge_map_ == NULL); 865 this->object_merge_map_ = object_merge_map; 866 } 867 868 // Record the relocatable reloc info for an input reloc section. 869 void 870 set_relocatable_relocs(unsigned int reloc_shndx, Relocatable_relocs* rr) 871 { 872 gold_assert(reloc_shndx < this->shnum()); 873 (*this->map_to_relocatable_relocs_)[reloc_shndx] = rr; 874 } 875 876 // Get the relocatable reloc info for an input reloc section. 877 Relocatable_relocs* 878 relocatable_relocs(unsigned int reloc_shndx) 879 { 880 gold_assert(reloc_shndx < this->shnum()); 881 return (*this->map_to_relocatable_relocs_)[reloc_shndx]; 882 } 883 884 // Layout sections whose layout was deferred while waiting for 885 // input files from a plugin. 886 void 887 layout_deferred_sections(Layout* layout) 888 { this->do_layout_deferred_sections(layout); } 889 890 // Return the index of the first incremental relocation for symbol SYMNDX. 891 virtual unsigned int 892 do_get_incremental_reloc_base(unsigned int symndx) const 893 { return this->reloc_bases_[symndx]; } 894 895 // Return the number of incremental relocations for symbol SYMNDX. 896 virtual unsigned int 897 do_get_incremental_reloc_count(unsigned int symndx) const 898 { return this->reloc_counts_[symndx]; } 899 900 protected: 901 // The output section to be used for each input section, indexed by 902 // the input section number. The output section is NULL if the 903 // input section is to be discarded. 904 typedef std::vector<Output_section*> Output_sections; 905 906 // Read the relocs--implemented by child class. 907 virtual void 908 do_read_relocs(Read_relocs_data*) = 0; 909 910 // Process the relocs--implemented by child class. 911 virtual void 912 do_gc_process_relocs(Symbol_table*, Layout*, Read_relocs_data*) = 0; 913 914 // Scan the relocs--implemented by child class. 915 virtual void 916 do_scan_relocs(Symbol_table*, Layout*, Read_relocs_data*) = 0; 917 918 // Return the number of local symbols--implemented by child class. 919 virtual unsigned int 920 do_local_symbol_count() const = 0; 921 922 // Count local symbols--implemented by child class. 923 virtual void 924 do_count_local_symbols(Stringpool_template<char>*, 925 Stringpool_template<char>*) = 0; 926 927 // Finalize the local symbols. Set the output symbol table indexes 928 // for the local variables, and set the offset where local symbol 929 // information will be stored. 930 virtual unsigned int 931 do_finalize_local_symbols(unsigned int, off_t, Symbol_table*) = 0; 932 933 // Set the output dynamic symbol table indexes for the local variables. 934 virtual unsigned int 935 do_set_local_dynsym_indexes(unsigned int) = 0; 936 937 // Set the offset where local dynamic symbol information will be stored. 938 virtual unsigned int 939 do_set_local_dynsym_offset(off_t) = 0; 940 941 // Relocate the input sections and write out the local 942 // symbols--implemented by child class. 943 virtual void 944 do_relocate(const Symbol_table* symtab, const Layout*, Output_file* of) = 0; 945 946 // Set the offset of a section--implemented by child class. 947 virtual void 948 do_set_section_offset(unsigned int shndx, uint64_t off) = 0; 949 950 // Layout sections whose layout was deferred while waiting for 951 // input files from a plugin--implemented by child class. 952 virtual void 953 do_layout_deferred_sections(Layout*) = 0; 954 955 // Given a section index, return the corresponding Output_section. 956 // The return value will be NULL if the section is not included in 957 // the link. 958 Output_section* 959 do_output_section(unsigned int shndx) const 960 { 961 gold_assert(shndx < this->output_sections_.size()); 962 return this->output_sections_[shndx]; 963 } 964 965 // Return the vector mapping input sections to output sections. 966 Output_sections& 967 output_sections() 968 { return this->output_sections_; } 969 970 const Output_sections& 971 output_sections() const 972 { return this->output_sections_; } 973 974 // Set the size of the relocatable relocs array. 975 void 976 size_relocatable_relocs() 977 { 978 this->map_to_relocatable_relocs_ = 979 new std::vector<Relocatable_relocs*>(this->shnum()); 980 } 981 982 // Record that we must wait for the output sections to be written 983 // before applying relocations. 984 void 985 set_relocs_must_follow_section_writes() 986 { this->relocs_must_follow_section_writes_ = true; } 987 988 // Allocate the array for counting incremental relocations. 989 void 990 allocate_incremental_reloc_counts() 991 { 992 unsigned int nsyms = this->do_get_global_symbols()->size(); 993 this->reloc_counts_ = new unsigned int[nsyms]; 994 gold_assert(this->reloc_counts_ != NULL); 995 memset(this->reloc_counts_, 0, nsyms * sizeof(unsigned int)); 996 } 997 998 // Record a relocation in this object referencing global symbol SYMNDX. 999 // Used for tracking incremental link information. 1000 void 1001 count_incremental_reloc(unsigned int symndx) 1002 { 1003 unsigned int nsyms = this->do_get_global_symbols()->size(); 1004 gold_assert(symndx < nsyms); 1005 gold_assert(this->reloc_counts_ != NULL); 1006 ++this->reloc_counts_[symndx]; 1007 } 1008 1009 // Finalize the incremental relocation information. 1010 void 1011 finalize_incremental_relocs(Layout* layout); 1012 1013 // Return the index of the next relocation to be written for global symbol 1014 // SYMNDX. Only valid after finalize_incremental_relocs() has been called. 1015 unsigned int 1016 next_incremental_reloc_index(unsigned int symndx) 1017 { 1018 unsigned int nsyms = this->do_get_global_symbols()->size(); 1019 1020 gold_assert(this->reloc_counts_ != NULL); 1021 gold_assert(this->reloc_bases_ != NULL); 1022 gold_assert(symndx < nsyms); 1023 1024 unsigned int counter = this->reloc_counts_[symndx]++; 1025 return this->reloc_bases_[symndx] + counter; 1026 } 1027 1028 private: 1029 // Mapping from input sections to output section. 1030 Output_sections output_sections_; 1031 // Mapping from input section index to the information recorded for 1032 // the relocations. This is only used for a relocatable link. 1033 std::vector<Relocatable_relocs*>* map_to_relocatable_relocs_; 1034 // Mappings for merge sections. This is managed by the code in the 1035 // Merge_map class. 1036 Object_merge_map* object_merge_map_; 1037 // Whether we need to wait for output sections to be written before 1038 // we can apply relocations. 1039 bool relocs_must_follow_section_writes_; 1040 // Used to store the relocs data computed by the Read_relocs pass. 1041 // Used during garbage collection of unused sections. 1042 Read_relocs_data* rd_; 1043 // Used to store the symbols data computed by the Read_symbols pass. 1044 // Again used during garbage collection when laying out referenced 1045 // sections. 1046 gold::Symbols_data* sd_; 1047 // Per-symbol counts of relocations, for incremental links. 1048 unsigned int* reloc_counts_; 1049 // Per-symbol base indexes of relocations, for incremental links. 1050 unsigned int* reloc_bases_; 1051}; 1052 1053// This class is used to handle relocations against a section symbol 1054// in an SHF_MERGE section. For such a symbol, we need to know the 1055// addend of the relocation before we can determine the final value. 1056// The addend gives us the location in the input section, and we can 1057// determine how it is mapped to the output section. For a 1058// non-section symbol, we apply the addend to the final value of the 1059// symbol; that is done in finalize_local_symbols, and does not use 1060// this class. 1061 1062template<int size> 1063class Merged_symbol_value 1064{ 1065 public: 1066 typedef typename elfcpp::Elf_types<size>::Elf_Addr Value; 1067 1068 // We use a hash table to map offsets in the input section to output 1069 // addresses. 1070 typedef Unordered_map<section_offset_type, Value> Output_addresses; 1071 1072 Merged_symbol_value(Value input_value, Value output_start_address) 1073 : input_value_(input_value), output_start_address_(output_start_address), 1074 output_addresses_() 1075 { } 1076 1077 // Initialize the hash table. 1078 void 1079 initialize_input_to_output_map(const Relobj*, unsigned int input_shndx); 1080 1081 // Release the hash table to save space. 1082 void 1083 free_input_to_output_map() 1084 { this->output_addresses_.clear(); } 1085 1086 // Get the output value corresponding to an addend. The object and 1087 // input section index are passed in because the caller will have 1088 // them; otherwise we could store them here. 1089 Value 1090 value(const Relobj* object, unsigned int input_shndx, Value addend) const 1091 { 1092 // This is a relocation against a section symbol. ADDEND is the 1093 // offset in the section. The result should be the start of some 1094 // merge area. If the object file wants something else, it should 1095 // use a regular symbol rather than a section symbol. 1096 // Unfortunately, PR 6658 shows a case in which the object file 1097 // refers to the section symbol, but uses a negative ADDEND to 1098 // compensate for a PC relative reloc. We can't handle the 1099 // general case. However, we can handle the special case of a 1100 // negative addend, by assuming that it refers to the start of the 1101 // section. Of course, that means that we have to guess when 1102 // ADDEND is negative. It is normal to see a 32-bit value here 1103 // even when the template parameter size is 64, as 64-bit object 1104 // file formats have 32-bit relocations. We know this is a merge 1105 // section, so we know it has to fit into memory. So we assume 1106 // that we won't see a value larger than a large 32-bit unsigned 1107 // value. This will break objects with very very large merge 1108 // sections; they probably break in other ways anyhow. 1109 Value input_offset = this->input_value_; 1110 if (addend < 0xffffff00) 1111 { 1112 input_offset += addend; 1113 addend = 0; 1114 } 1115 typename Output_addresses::const_iterator p = 1116 this->output_addresses_.find(input_offset); 1117 if (p != this->output_addresses_.end()) 1118 return p->second + addend; 1119 1120 return (this->value_from_output_section(object, input_shndx, input_offset) 1121 + addend); 1122 } 1123 1124 private: 1125 // Get the output value for an input offset if we couldn't find it 1126 // in the hash table. 1127 Value 1128 value_from_output_section(const Relobj*, unsigned int input_shndx, 1129 Value input_offset) const; 1130 1131 // The value of the section symbol in the input file. This is 1132 // normally zero, but could in principle be something else. 1133 Value input_value_; 1134 // The start address of this merged section in the output file. 1135 Value output_start_address_; 1136 // A hash table which maps offsets in the input section to output 1137 // addresses. This only maps specific offsets, not all offsets. 1138 Output_addresses output_addresses_; 1139}; 1140 1141// This POD class is holds the value of a symbol. This is used for 1142// local symbols, and for all symbols during relocation processing. 1143// For special sections, such as SHF_MERGE sections, this calls a 1144// function to get the final symbol value. 1145 1146template<int size> 1147class Symbol_value 1148{ 1149 public: 1150 typedef typename elfcpp::Elf_types<size>::Elf_Addr Value; 1151 1152 Symbol_value() 1153 : output_symtab_index_(0), output_dynsym_index_(-1U), input_shndx_(0), 1154 is_ordinary_shndx_(false), is_section_symbol_(false), 1155 is_tls_symbol_(false), is_ifunc_symbol_(false), has_output_value_(true) 1156 { this->u_.value = 0; } 1157 1158 ~Symbol_value() 1159 { 1160 if (!this->has_output_value_) 1161 delete this->u_.merged_symbol_value; 1162 } 1163 1164 // Get the value of this symbol. OBJECT is the object in which this 1165 // symbol is defined, and ADDEND is an addend to add to the value. 1166 template<bool big_endian> 1167 Value 1168 value(const Sized_relobj<size, big_endian>* object, Value addend) const 1169 { 1170 if (this->has_output_value_) 1171 return this->u_.value + addend; 1172 else 1173 { 1174 gold_assert(this->is_ordinary_shndx_); 1175 return this->u_.merged_symbol_value->value(object, this->input_shndx_, 1176 addend); 1177 } 1178 } 1179 1180 // Set the value of this symbol in the output symbol table. 1181 void 1182 set_output_value(Value value) 1183 { this->u_.value = value; } 1184 1185 // For a section symbol in a merged section, we need more 1186 // information. 1187 void 1188 set_merged_symbol_value(Merged_symbol_value<size>* msv) 1189 { 1190 gold_assert(this->is_section_symbol_); 1191 this->has_output_value_ = false; 1192 this->u_.merged_symbol_value = msv; 1193 } 1194 1195 // Initialize the input to output map for a section symbol in a 1196 // merged section. We also initialize the value of a non-section 1197 // symbol in a merged section. 1198 void 1199 initialize_input_to_output_map(const Relobj* object) 1200 { 1201 if (!this->has_output_value_) 1202 { 1203 gold_assert(this->is_section_symbol_ && this->is_ordinary_shndx_); 1204 Merged_symbol_value<size>* msv = this->u_.merged_symbol_value; 1205 msv->initialize_input_to_output_map(object, this->input_shndx_); 1206 } 1207 } 1208 1209 // Free the input to output map for a section symbol in a merged 1210 // section. 1211 void 1212 free_input_to_output_map() 1213 { 1214 if (!this->has_output_value_) 1215 this->u_.merged_symbol_value->free_input_to_output_map(); 1216 } 1217 1218 // Set the value of the symbol from the input file. This is only 1219 // called by count_local_symbols, to communicate the value to 1220 // finalize_local_symbols. 1221 void 1222 set_input_value(Value value) 1223 { this->u_.value = value; } 1224 1225 // Return the input value. This is only called by 1226 // finalize_local_symbols and (in special cases) relocate_section. 1227 Value 1228 input_value() const 1229 { return this->u_.value; } 1230 1231 // Return whether we have set the index in the output symbol table 1232 // yet. 1233 bool 1234 is_output_symtab_index_set() const 1235 { 1236 return (this->output_symtab_index_ != 0 1237 && this->output_symtab_index_ != -2U); 1238 } 1239 1240 // Return whether this symbol may be discarded from the normal 1241 // symbol table. 1242 bool 1243 may_be_discarded_from_output_symtab() const 1244 { 1245 gold_assert(!this->is_output_symtab_index_set()); 1246 return this->output_symtab_index_ != -2U; 1247 } 1248 1249 // Return whether this symbol has an entry in the output symbol 1250 // table. 1251 bool 1252 has_output_symtab_entry() const 1253 { 1254 gold_assert(this->is_output_symtab_index_set()); 1255 return this->output_symtab_index_ != -1U; 1256 } 1257 1258 // Return the index in the output symbol table. 1259 unsigned int 1260 output_symtab_index() const 1261 { 1262 gold_assert(this->is_output_symtab_index_set() 1263 && this->output_symtab_index_ != -1U); 1264 return this->output_symtab_index_; 1265 } 1266 1267 // Set the index in the output symbol table. 1268 void 1269 set_output_symtab_index(unsigned int i) 1270 { 1271 gold_assert(!this->is_output_symtab_index_set()); 1272 gold_assert(i != 0 && i != -1U && i != -2U); 1273 this->output_symtab_index_ = i; 1274 } 1275 1276 // Record that this symbol should not go into the output symbol 1277 // table. 1278 void 1279 set_no_output_symtab_entry() 1280 { 1281 gold_assert(this->output_symtab_index_ == 0); 1282 this->output_symtab_index_ = -1U; 1283 } 1284 1285 // Record that this symbol must go into the output symbol table, 1286 // because it there is a relocation that uses it. 1287 void 1288 set_must_have_output_symtab_entry() 1289 { 1290 gold_assert(!this->is_output_symtab_index_set()); 1291 this->output_symtab_index_ = -2U; 1292 } 1293 1294 // Set the index in the output dynamic symbol table. 1295 void 1296 set_needs_output_dynsym_entry() 1297 { 1298 gold_assert(!this->is_section_symbol()); 1299 this->output_dynsym_index_ = 0; 1300 } 1301 1302 // Return whether this symbol should go into the dynamic symbol 1303 // table. 1304 bool 1305 needs_output_dynsym_entry() const 1306 { 1307 return this->output_dynsym_index_ != -1U; 1308 } 1309 1310 // Return whether this symbol has an entry in the dynamic symbol 1311 // table. 1312 bool 1313 has_output_dynsym_entry() const 1314 { 1315 gold_assert(this->output_dynsym_index_ != 0); 1316 return this->output_dynsym_index_ != -1U; 1317 } 1318 1319 // Record that this symbol should go into the dynamic symbol table. 1320 void 1321 set_output_dynsym_index(unsigned int i) 1322 { 1323 gold_assert(this->output_dynsym_index_ == 0); 1324 gold_assert(i != 0 && i != -1U); 1325 this->output_dynsym_index_ = i; 1326 } 1327 1328 // Return the index in the output dynamic symbol table. 1329 unsigned int 1330 output_dynsym_index() const 1331 { 1332 gold_assert(this->output_dynsym_index_ != 0 1333 && this->output_dynsym_index_ != -1U); 1334 return this->output_dynsym_index_; 1335 } 1336 1337 // Set the index of the input section in the input file. 1338 void 1339 set_input_shndx(unsigned int i, bool is_ordinary) 1340 { 1341 this->input_shndx_ = i; 1342 // input_shndx_ field is a bitfield, so make sure that the value 1343 // fits. 1344 gold_assert(this->input_shndx_ == i); 1345 this->is_ordinary_shndx_ = is_ordinary; 1346 } 1347 1348 // Return the index of the input section in the input file. 1349 unsigned int 1350 input_shndx(bool* is_ordinary) const 1351 { 1352 *is_ordinary = this->is_ordinary_shndx_; 1353 return this->input_shndx_; 1354 } 1355 1356 // Whether this is a section symbol. 1357 bool 1358 is_section_symbol() const 1359 { return this->is_section_symbol_; } 1360 1361 // Record that this is a section symbol. 1362 void 1363 set_is_section_symbol() 1364 { 1365 gold_assert(!this->needs_output_dynsym_entry()); 1366 this->is_section_symbol_ = true; 1367 } 1368 1369 // Record that this is a TLS symbol. 1370 void 1371 set_is_tls_symbol() 1372 { this->is_tls_symbol_ = true; } 1373 1374 // Return true if this is a TLS symbol. 1375 bool 1376 is_tls_symbol() const 1377 { return this->is_tls_symbol_; } 1378 1379 // Record that this is an IFUNC symbol. 1380 void 1381 set_is_ifunc_symbol() 1382 { this->is_ifunc_symbol_ = true; } 1383 1384 // Return true if this is an IFUNC symbol. 1385 bool 1386 is_ifunc_symbol() const 1387 { return this->is_ifunc_symbol_; } 1388 1389 // Return true if this has output value. 1390 bool 1391 has_output_value() const 1392 { return this->has_output_value_; } 1393 1394 private: 1395 // The index of this local symbol in the output symbol table. This 1396 // will be 0 if no value has been assigned yet, and the symbol may 1397 // be omitted. This will be -1U if the symbol should not go into 1398 // the symbol table. This will be -2U if the symbol must go into 1399 // the symbol table, but no index has been assigned yet. 1400 unsigned int output_symtab_index_; 1401 // The index of this local symbol in the dynamic symbol table. This 1402 // will be -1U if the symbol should not go into the symbol table. 1403 unsigned int output_dynsym_index_; 1404 // The section index in the input file in which this symbol is 1405 // defined. 1406 unsigned int input_shndx_ : 27; 1407 // Whether the section index is an ordinary index, not a special 1408 // value. 1409 bool is_ordinary_shndx_ : 1; 1410 // Whether this is a STT_SECTION symbol. 1411 bool is_section_symbol_ : 1; 1412 // Whether this is a STT_TLS symbol. 1413 bool is_tls_symbol_ : 1; 1414 // Whether this is a STT_GNU_IFUNC symbol. 1415 bool is_ifunc_symbol_ : 1; 1416 // Whether this symbol has a value for the output file. This is 1417 // normally set to true during Layout::finalize, by 1418 // finalize_local_symbols. It will be false for a section symbol in 1419 // a merge section, as for such symbols we can not determine the 1420 // value to use in a relocation until we see the addend. 1421 bool has_output_value_ : 1; 1422 union 1423 { 1424 // This is used if has_output_value_ is true. Between 1425 // count_local_symbols and finalize_local_symbols, this is the 1426 // value in the input file. After finalize_local_symbols, it is 1427 // the value in the output file. 1428 Value value; 1429 // This is used if has_output_value_ is false. It points to the 1430 // information we need to get the value for a merge section. 1431 Merged_symbol_value<size>* merged_symbol_value; 1432 } u_; 1433}; 1434 1435// A GOT offset list. A symbol may have more than one GOT offset 1436// (e.g., when mixing modules compiled with two different TLS models), 1437// but will usually have at most one. GOT_TYPE identifies the type of 1438// GOT entry; its values are specific to each target. 1439 1440class Got_offset_list 1441{ 1442 public: 1443 Got_offset_list() 1444 : got_type_(-1U), got_offset_(0), got_next_(NULL) 1445 { } 1446 1447 Got_offset_list(unsigned int got_type, unsigned int got_offset) 1448 : got_type_(got_type), got_offset_(got_offset), got_next_(NULL) 1449 { } 1450 1451 ~Got_offset_list() 1452 { 1453 if (this->got_next_ != NULL) 1454 { 1455 delete this->got_next_; 1456 this->got_next_ = NULL; 1457 } 1458 } 1459 1460 // Initialize the fields to their default values. 1461 void 1462 init() 1463 { 1464 this->got_type_ = -1U; 1465 this->got_offset_ = 0; 1466 this->got_next_ = NULL; 1467 } 1468 1469 // Set the offset for the GOT entry of type GOT_TYPE. 1470 void 1471 set_offset(unsigned int got_type, unsigned int got_offset) 1472 { 1473 if (this->got_type_ == -1U) 1474 { 1475 this->got_type_ = got_type; 1476 this->got_offset_ = got_offset; 1477 } 1478 else 1479 { 1480 for (Got_offset_list* g = this; g != NULL; g = g->got_next_) 1481 { 1482 if (g->got_type_ == got_type) 1483 { 1484 g->got_offset_ = got_offset; 1485 return; 1486 } 1487 } 1488 Got_offset_list* g = new Got_offset_list(got_type, got_offset); 1489 g->got_next_ = this->got_next_; 1490 this->got_next_ = g; 1491 } 1492 } 1493 1494 // Return the offset for a GOT entry of type GOT_TYPE. 1495 unsigned int 1496 get_offset(unsigned int got_type) const 1497 { 1498 for (const Got_offset_list* g = this; g != NULL; g = g->got_next_) 1499 { 1500 if (g->got_type_ == got_type) 1501 return g->got_offset_; 1502 } 1503 return -1U; 1504 } 1505 1506 // Return a pointer to the list, or NULL if the list is empty. 1507 const Got_offset_list* 1508 get_list() const 1509 { 1510 if (this->got_type_ == -1U) 1511 return NULL; 1512 return this; 1513 } 1514 1515 // Loop over all GOT offset entries, applying the function F to each. 1516 template<typename F> 1517 void 1518 for_all_got_offsets(F f) const 1519 { 1520 if (this->got_type_ == -1U) 1521 return; 1522 for (const Got_offset_list* g = this; g != NULL; g = g->got_next_) 1523 f(g->got_type_, g->got_offset_); 1524 } 1525 1526 private: 1527 unsigned int got_type_; 1528 unsigned int got_offset_; 1529 Got_offset_list* got_next_; 1530}; 1531 1532// This type is used to modify relocations for -fsplit-stack. It is 1533// indexed by relocation index, and means that the relocation at that 1534// index should use the symbol from the vector, rather than the one 1535// indicated by the relocation. 1536 1537class Reloc_symbol_changes 1538{ 1539 public: 1540 Reloc_symbol_changes(size_t count) 1541 : vec_(count, NULL) 1542 { } 1543 1544 void 1545 set(size_t i, Symbol* sym) 1546 { this->vec_[i] = sym; } 1547 1548 const Symbol* 1549 operator[](size_t i) const 1550 { return this->vec_[i]; } 1551 1552 private: 1553 std::vector<Symbol*> vec_; 1554}; 1555 1556// Type for mapping section index to uncompressed size. 1557 1558typedef std::map<unsigned int, section_size_type> Compressed_section_map; 1559 1560// A regular object file. This is size and endian specific. 1561 1562template<int size, bool big_endian> 1563class Sized_relobj : public Relobj 1564{ 1565 public: 1566 typedef typename elfcpp::Elf_types<size>::Elf_Addr Address; 1567 typedef std::vector<Symbol*> Symbols; 1568 typedef std::vector<Symbol_value<size> > Local_values; 1569 1570 static const Address invalid_address = static_cast<Address>(0) - 1; 1571 1572 enum Compute_final_local_value_status 1573 { 1574 // No error. 1575 CFLV_OK, 1576 // An error occurred. 1577 CFLV_ERROR, 1578 // The local symbol has no output section. 1579 CFLV_DISCARDED 1580 }; 1581 1582 Sized_relobj(const std::string& name, Input_file* input_file, off_t offset, 1583 const typename elfcpp::Ehdr<size, big_endian>&); 1584 1585 ~Sized_relobj(); 1586 1587 // Checks if the offset of input section SHNDX within its output 1588 // section is invalid. 1589 bool 1590 is_output_section_offset_invalid(unsigned int shndx) const 1591 { return this->get_output_section_offset(shndx) == invalid_address; } 1592 1593 // Set up the object file based on TARGET. 1594 void 1595 setup() 1596 { this->do_setup(); } 1597 1598 // Return the number of symbols. This is only valid after 1599 // Object::add_symbols has been called. 1600 unsigned int 1601 symbol_count() const 1602 { return this->local_symbol_count_ + this->symbols_.size(); } 1603 1604 // If SYM is the index of a global symbol in the object file's 1605 // symbol table, return the Symbol object. Otherwise, return NULL. 1606 Symbol* 1607 global_symbol(unsigned int sym) const 1608 { 1609 if (sym >= this->local_symbol_count_) 1610 { 1611 gold_assert(sym - this->local_symbol_count_ < this->symbols_.size()); 1612 return this->symbols_[sym - this->local_symbol_count_]; 1613 } 1614 return NULL; 1615 } 1616 1617 // Return the section index of symbol SYM. Set *VALUE to its value 1618 // in the object file. Set *IS_ORDINARY if this is an ordinary 1619 // section index, not a special code between SHN_LORESERVE and 1620 // SHN_HIRESERVE. Note that for a symbol which is not defined in 1621 // this object file, this will set *VALUE to 0 and return SHN_UNDEF; 1622 // it will not return the final value of the symbol in the link. 1623 unsigned int 1624 symbol_section_and_value(unsigned int sym, Address* value, bool* is_ordinary); 1625 1626 // Return a pointer to the Symbol_value structure which holds the 1627 // value of a local symbol. 1628 const Symbol_value<size>* 1629 local_symbol(unsigned int sym) const 1630 { 1631 gold_assert(sym < this->local_values_.size()); 1632 return &this->local_values_[sym]; 1633 } 1634 1635 // Return the index of local symbol SYM in the ordinary symbol 1636 // table. A value of -1U means that the symbol is not being output. 1637 unsigned int 1638 symtab_index(unsigned int sym) const 1639 { 1640 gold_assert(sym < this->local_values_.size()); 1641 return this->local_values_[sym].output_symtab_index(); 1642 } 1643 1644 // Return the index of local symbol SYM in the dynamic symbol 1645 // table. A value of -1U means that the symbol is not being output. 1646 unsigned int 1647 dynsym_index(unsigned int sym) const 1648 { 1649 gold_assert(sym < this->local_values_.size()); 1650 return this->local_values_[sym].output_dynsym_index(); 1651 } 1652 1653 // Return the input section index of local symbol SYM. 1654 unsigned int 1655 local_symbol_input_shndx(unsigned int sym, bool* is_ordinary) const 1656 { 1657 gold_assert(sym < this->local_values_.size()); 1658 return this->local_values_[sym].input_shndx(is_ordinary); 1659 } 1660 1661 // Record that local symbol SYM must be in the output symbol table. 1662 void 1663 set_must_have_output_symtab_entry(unsigned int sym) 1664 { 1665 gold_assert(sym < this->local_values_.size()); 1666 this->local_values_[sym].set_must_have_output_symtab_entry(); 1667 } 1668 1669 // Record that local symbol SYM needs a dynamic symbol entry. 1670 void 1671 set_needs_output_dynsym_entry(unsigned int sym) 1672 { 1673 gold_assert(sym < this->local_values_.size()); 1674 this->local_values_[sym].set_needs_output_dynsym_entry(); 1675 } 1676 1677 // Return whether the local symbol SYMNDX has a GOT offset. 1678 // For TLS symbols, the GOT entry will hold its tp-relative offset. 1679 bool 1680 local_has_got_offset(unsigned int symndx, unsigned int got_type) const 1681 { 1682 Local_got_offsets::const_iterator p = 1683 this->local_got_offsets_.find(symndx); 1684 return (p != this->local_got_offsets_.end() 1685 && p->second->get_offset(got_type) != -1U); 1686 } 1687 1688 // Return the GOT offset of the local symbol SYMNDX. 1689 unsigned int 1690 local_got_offset(unsigned int symndx, unsigned int got_type) const 1691 { 1692 Local_got_offsets::const_iterator p = 1693 this->local_got_offsets_.find(symndx); 1694 gold_assert(p != this->local_got_offsets_.end()); 1695 unsigned int off = p->second->get_offset(got_type); 1696 gold_assert(off != -1U); 1697 return off; 1698 } 1699 1700 // Set the GOT offset of the local symbol SYMNDX to GOT_OFFSET. 1701 void 1702 set_local_got_offset(unsigned int symndx, unsigned int got_type, 1703 unsigned int got_offset) 1704 { 1705 Local_got_offsets::const_iterator p = 1706 this->local_got_offsets_.find(symndx); 1707 if (p != this->local_got_offsets_.end()) 1708 p->second->set_offset(got_type, got_offset); 1709 else 1710 { 1711 Got_offset_list* g = new Got_offset_list(got_type, got_offset); 1712 std::pair<Local_got_offsets::iterator, bool> ins = 1713 this->local_got_offsets_.insert(std::make_pair(symndx, g)); 1714 gold_assert(ins.second); 1715 } 1716 } 1717 1718 // Return the GOT offset list for the local symbol SYMNDX. 1719 const Got_offset_list* 1720 local_got_offset_list(unsigned int symndx) const 1721 { 1722 Local_got_offsets::const_iterator p = 1723 this->local_got_offsets_.find(symndx); 1724 if (p == this->local_got_offsets_.end()) 1725 return NULL; 1726 return p->second; 1727 } 1728 1729 // Return whether the local symbol SYMNDX has a PLT offset. 1730 bool 1731 local_has_plt_offset(unsigned int symndx) const; 1732 1733 // Return the PLT offset for a local symbol. It is an error to call 1734 // this if it doesn't have one. 1735 unsigned int 1736 local_plt_offset(unsigned int symndx) const; 1737 1738 // Set the PLT offset of the local symbol SYMNDX. 1739 void 1740 set_local_plt_offset(unsigned int symndx, unsigned int plt_offset); 1741 1742 // Get the offset of input section SHNDX within its output section. 1743 // This is -1 if the input section requires a special mapping, such 1744 // as a merge section. The output section can be found in the 1745 // output_sections_ field of the parent class Relobj. 1746 Address 1747 get_output_section_offset(unsigned int shndx) const 1748 { 1749 gold_assert(shndx < this->section_offsets_.size()); 1750 return this->section_offsets_[shndx]; 1751 } 1752 1753 // Return the name of the symbol that spans the given offset in the 1754 // specified section in this object. This is used only for error 1755 // messages and is not particularly efficient. 1756 bool 1757 get_symbol_location_info(unsigned int shndx, off_t offset, 1758 Symbol_location_info* info); 1759 1760 // Look for a kept section corresponding to the given discarded section, 1761 // and return its output address. This is used only for relocations in 1762 // debugging sections. 1763 Address 1764 map_to_kept_section(unsigned int shndx, bool* found) const; 1765 1766 // Compute final local symbol value. R_SYM is the local symbol index. 1767 // LV_IN points to a local symbol value containing the input value. 1768 // LV_OUT points to a local symbol value storing the final output value, 1769 // which must not be a merged symbol value since before calling this 1770 // method to avoid memory leak. SYMTAB points to a symbol table. 1771 // 1772 // The method returns a status code at return. If the return status is 1773 // CFLV_OK, *LV_OUT contains the final value. If the return status is 1774 // CFLV_ERROR, *LV_OUT is 0. If the return status is CFLV_DISCARDED, 1775 // *LV_OUT is not modified. 1776 Compute_final_local_value_status 1777 compute_final_local_value(unsigned int r_sym, 1778 const Symbol_value<size>* lv_in, 1779 Symbol_value<size>* lv_out, 1780 const Symbol_table* symtab); 1781 1782 protected: 1783 // Set up. 1784 virtual void 1785 do_setup(); 1786 1787 // Read the symbols. 1788 void 1789 do_read_symbols(Read_symbols_data*); 1790 1791 // Return the number of local symbols. 1792 unsigned int 1793 do_local_symbol_count() const 1794 { return this->local_symbol_count_; } 1795 1796 // Lay out the input sections. 1797 void 1798 do_layout(Symbol_table*, Layout*, Read_symbols_data*); 1799 1800 // Layout sections whose layout was deferred while waiting for 1801 // input files from a plugin. 1802 void 1803 do_layout_deferred_sections(Layout*); 1804 1805 // Add the symbols to the symbol table. 1806 void 1807 do_add_symbols(Symbol_table*, Read_symbols_data*, Layout*); 1808 1809 Archive::Should_include 1810 do_should_include_member(Symbol_table* symtab, Layout*, Read_symbols_data*, 1811 std::string* why); 1812 1813 // Read the relocs. 1814 void 1815 do_read_relocs(Read_relocs_data*); 1816 1817 // Process the relocs to find list of referenced sections. Used only 1818 // during garbage collection. 1819 void 1820 do_gc_process_relocs(Symbol_table*, Layout*, Read_relocs_data*); 1821 1822 // Scan the relocs and adjust the symbol table. 1823 void 1824 do_scan_relocs(Symbol_table*, Layout*, Read_relocs_data*); 1825 1826 // Count the local symbols. 1827 void 1828 do_count_local_symbols(Stringpool_template<char>*, 1829 Stringpool_template<char>*); 1830 1831 // Finalize the local symbols. 1832 unsigned int 1833 do_finalize_local_symbols(unsigned int, off_t, Symbol_table*); 1834 1835 // Set the offset where local dynamic symbol information will be stored. 1836 unsigned int 1837 do_set_local_dynsym_indexes(unsigned int); 1838 1839 // Set the offset where local dynamic symbol information will be stored. 1840 unsigned int 1841 do_set_local_dynsym_offset(off_t); 1842 1843 // Relocate the input sections and write out the local symbols. 1844 void 1845 do_relocate(const Symbol_table* symtab, const Layout*, Output_file* of); 1846 1847 // Get the size of a section. 1848 uint64_t 1849 do_section_size(unsigned int shndx) 1850 { return this->elf_file_.section_size(shndx); } 1851 1852 // Get the name of a section. 1853 std::string 1854 do_section_name(unsigned int shndx) 1855 { return this->elf_file_.section_name(shndx); } 1856 1857 // Return the location of the contents of a section. 1858 Object::Location 1859 do_section_contents(unsigned int shndx) 1860 { return this->elf_file_.section_contents(shndx); } 1861 1862 // Return section flags. 1863 uint64_t 1864 do_section_flags(unsigned int shndx); 1865 1866 // Return section entsize. 1867 uint64_t 1868 do_section_entsize(unsigned int shndx); 1869 1870 // Return section address. 1871 uint64_t 1872 do_section_address(unsigned int shndx) 1873 { return this->elf_file_.section_addr(shndx); } 1874 1875 // Return section type. 1876 unsigned int 1877 do_section_type(unsigned int shndx) 1878 { return this->elf_file_.section_type(shndx); } 1879 1880 // Return the section link field. 1881 unsigned int 1882 do_section_link(unsigned int shndx) 1883 { return this->elf_file_.section_link(shndx); } 1884 1885 // Return the section info field. 1886 unsigned int 1887 do_section_info(unsigned int shndx) 1888 { return this->elf_file_.section_info(shndx); } 1889 1890 // Return the section alignment. 1891 uint64_t 1892 do_section_addralign(unsigned int shndx) 1893 { return this->elf_file_.section_addralign(shndx); } 1894 1895 // Return the Xindex structure to use. 1896 Xindex* 1897 do_initialize_xindex(); 1898 1899 // Get symbol counts. 1900 void 1901 do_get_global_symbol_counts(const Symbol_table*, size_t*, size_t*) const; 1902 1903 // Get the global symbols. 1904 const Symbols* 1905 do_get_global_symbols() const 1906 { return &this->symbols_; } 1907 1908 // Get the offset of a section. 1909 uint64_t 1910 do_output_section_offset(unsigned int shndx) const 1911 { 1912 Address off = this->get_output_section_offset(shndx); 1913 if (off == invalid_address) 1914 return -1ULL; 1915 return off; 1916 } 1917 1918 // Set the offset of a section. 1919 void 1920 do_set_section_offset(unsigned int shndx, uint64_t off) 1921 { 1922 gold_assert(shndx < this->section_offsets_.size()); 1923 this->section_offsets_[shndx] = 1924 (off == static_cast<uint64_t>(-1) 1925 ? invalid_address 1926 : convert_types<Address, uint64_t>(off)); 1927 } 1928 1929 // Adjust a section index if necessary. 1930 unsigned int 1931 adjust_shndx(unsigned int shndx) 1932 { 1933 if (shndx >= elfcpp::SHN_LORESERVE) 1934 shndx += this->elf_file_.large_shndx_offset(); 1935 return shndx; 1936 } 1937 1938 // Initialize input to output maps for section symbols in merged 1939 // sections. 1940 void 1941 initialize_input_to_output_maps(); 1942 1943 // Free the input to output maps for section symbols in merged 1944 // sections. 1945 void 1946 free_input_to_output_maps(); 1947 1948 // Return symbol table section index. 1949 unsigned int 1950 symtab_shndx() const 1951 { return this->symtab_shndx_; } 1952 1953 // Allow a child class to access the ELF file. 1954 elfcpp::Elf_file<size, big_endian, Object>* 1955 elf_file() 1956 { return &this->elf_file_; } 1957 1958 // Allow a child class to access the local values. 1959 Local_values* 1960 local_values() 1961 { return &this->local_values_; } 1962 1963 // Views and sizes when relocating. 1964 struct View_size 1965 { 1966 unsigned char* view; 1967 typename elfcpp::Elf_types<size>::Elf_Addr address; 1968 off_t offset; 1969 section_size_type view_size; 1970 bool is_input_output_view; 1971 bool is_postprocessing_view; 1972 }; 1973 1974 typedef std::vector<View_size> Views; 1975 1976 // This may be overriden by a child class. 1977 virtual void 1978 do_relocate_sections(const Symbol_table* symtab, const Layout* layout, 1979 const unsigned char* pshdrs, Output_file* of, 1980 Views* pviews); 1981 1982 // Allow a child to set output local symbol count. 1983 void 1984 set_output_local_symbol_count(unsigned int value) 1985 { this->output_local_symbol_count_ = value; } 1986 1987 // Return TRUE if the section is a compressed debug section, and set 1988 // *UNCOMPRESSED_SIZE to the size of the uncompressed data. 1989 bool 1990 do_section_is_compressed(unsigned int shndx, 1991 section_size_type* uncompressed_size) const 1992 { 1993 if (this->compressed_sections_ == NULL) 1994 return false; 1995 Compressed_section_map::const_iterator p = 1996 this->compressed_sections_->find(shndx); 1997 if (p != this->compressed_sections_->end()) 1998 { 1999 if (uncompressed_size != NULL) 2000 *uncompressed_size = p->second; 2001 return true; 2002 } 2003 return false; 2004 } 2005 2006 private: 2007 // For convenience. 2008 typedef Sized_relobj<size, big_endian> This; 2009 static const int ehdr_size = elfcpp::Elf_sizes<size>::ehdr_size; 2010 static const int shdr_size = elfcpp::Elf_sizes<size>::shdr_size; 2011 static const int sym_size = elfcpp::Elf_sizes<size>::sym_size; 2012 typedef elfcpp::Shdr<size, big_endian> Shdr; 2013 2014 // To keep track of discarded comdat sections, we need to map a member 2015 // section index to the object and section index of the corresponding 2016 // kept section. 2017 struct Kept_comdat_section 2018 { 2019 Kept_comdat_section(Relobj* a_object, unsigned int a_shndx) 2020 : object(a_object), shndx(a_shndx) 2021 { } 2022 Relobj* object; 2023 unsigned int shndx; 2024 }; 2025 typedef std::map<unsigned int, Kept_comdat_section> 2026 Kept_comdat_section_table; 2027 2028 // Find the SHT_SYMTAB section, given the section headers. 2029 void 2030 find_symtab(const unsigned char* pshdrs); 2031 2032 // Return whether SHDR has the right flags for a GNU style exception 2033 // frame section. 2034 bool 2035 check_eh_frame_flags(const elfcpp::Shdr<size, big_endian>* shdr) const; 2036 2037 // Return whether there is a section named .eh_frame which might be 2038 // a GNU style exception frame section. 2039 bool 2040 find_eh_frame(const unsigned char* pshdrs, const char* names, 2041 section_size_type names_size) const; 2042 2043 // Whether to include a section group in the link. 2044 bool 2045 include_section_group(Symbol_table*, Layout*, unsigned int, const char*, 2046 const unsigned char*, const char*, section_size_type, 2047 std::vector<bool>*); 2048 2049 // Whether to include a linkonce section in the link. 2050 bool 2051 include_linkonce_section(Layout*, unsigned int, const char*, 2052 const elfcpp::Shdr<size, big_endian>&); 2053 2054 // Layout an input section. 2055 void 2056 layout_section(Layout* layout, unsigned int shndx, const char* name, 2057 typename This::Shdr& shdr, unsigned int reloc_shndx, 2058 unsigned int reloc_type); 2059 2060 // Write section data to the output file. Record the views and 2061 // sizes in VIEWS for use when relocating. 2062 void 2063 write_sections(const unsigned char* pshdrs, Output_file*, Views*); 2064 2065 // Relocate the sections in the output file. 2066 void 2067 relocate_sections(const Symbol_table* symtab, const Layout* layout, 2068 const unsigned char* pshdrs, Output_file* of, 2069 Views* pviews) 2070 { this->do_relocate_sections(symtab, layout, pshdrs, of, pviews); } 2071 2072 // Scan the input relocations for --emit-relocs. 2073 void 2074 emit_relocs_scan(Symbol_table*, Layout*, const unsigned char* plocal_syms, 2075 const Read_relocs_data::Relocs_list::iterator&); 2076 2077 // Scan the input relocations for --emit-relocs, templatized on the 2078 // type of the relocation section. 2079 template<int sh_type> 2080 void 2081 emit_relocs_scan_reltype(Symbol_table*, Layout*, 2082 const unsigned char* plocal_syms, 2083 const Read_relocs_data::Relocs_list::iterator&, 2084 Relocatable_relocs*); 2085 2086 // Emit the relocs for --emit-relocs. 2087 void 2088 emit_relocs(const Relocate_info<size, big_endian>*, unsigned int, 2089 unsigned int sh_type, const unsigned char* prelocs, 2090 size_t reloc_count, Output_section*, Address output_offset, 2091 unsigned char* view, Address address, 2092 section_size_type view_size, 2093 unsigned char* reloc_view, section_size_type reloc_view_size); 2094 2095 // Emit the relocs for --emit-relocs, templatized on the type of the 2096 // relocation section. 2097 template<int sh_type> 2098 void 2099 emit_relocs_reltype(const Relocate_info<size, big_endian>*, unsigned int, 2100 const unsigned char* prelocs, size_t reloc_count, 2101 Output_section*, Address output_offset, 2102 unsigned char* view, Address address, 2103 section_size_type view_size, 2104 unsigned char* reloc_view, 2105 section_size_type reloc_view_size); 2106 2107 // Scan the input relocations for --incremental. 2108 void 2109 incremental_relocs_scan(const Read_relocs_data::Relocs_list::iterator&); 2110 2111 // Scan the input relocations for --incremental, templatized on the 2112 // type of the relocation section. 2113 template<int sh_type> 2114 void 2115 incremental_relocs_scan_reltype( 2116 const Read_relocs_data::Relocs_list::iterator&); 2117 2118 void 2119 incremental_relocs_write(const Relocate_info<size, big_endian>*, 2120 unsigned int sh_type, 2121 const unsigned char* prelocs, 2122 size_t reloc_count, 2123 Output_section*, 2124 Address output_offset, 2125 Output_file*); 2126 2127 template<int sh_type> 2128 void 2129 incremental_relocs_write_reltype(const Relocate_info<size, big_endian>*, 2130 const unsigned char* prelocs, 2131 size_t reloc_count, 2132 Output_section*, 2133 Address output_offset, 2134 Output_file*); 2135 2136 // A type shared by split_stack_adjust_reltype and find_functions. 2137 typedef std::map<section_offset_type, section_size_type> Function_offsets; 2138 2139 // Check for -fsplit-stack routines calling non-split-stack routines. 2140 void 2141 split_stack_adjust(const Symbol_table*, const unsigned char* pshdrs, 2142 unsigned int sh_type, unsigned int shndx, 2143 const unsigned char* prelocs, size_t reloc_count, 2144 unsigned char* view, section_size_type view_size, 2145 Reloc_symbol_changes** reloc_map); 2146 2147 template<int sh_type> 2148 void 2149 split_stack_adjust_reltype(const Symbol_table*, const unsigned char* pshdrs, 2150 unsigned int shndx, const unsigned char* prelocs, 2151 size_t reloc_count, unsigned char* view, 2152 section_size_type view_size, 2153 Reloc_symbol_changes** reloc_map); 2154 2155 // Find all functions in a section. 2156 void 2157 find_functions(const unsigned char* pshdrs, unsigned int shndx, 2158 Function_offsets*); 2159 2160 // Write out the local symbols. 2161 void 2162 write_local_symbols(Output_file*, 2163 const Stringpool_template<char>*, 2164 const Stringpool_template<char>*, 2165 Output_symtab_xindex*, 2166 Output_symtab_xindex*); 2167 2168 // Record a mapping from discarded section SHNDX to the corresponding 2169 // kept section. 2170 void 2171 set_kept_comdat_section(unsigned int shndx, Relobj* kept_object, 2172 unsigned int kept_shndx) 2173 { 2174 Kept_comdat_section kept(kept_object, kept_shndx); 2175 this->kept_comdat_sections_.insert(std::make_pair(shndx, kept)); 2176 } 2177 2178 // Find the kept section corresponding to the discarded section 2179 // SHNDX. Return true if found. 2180 bool 2181 get_kept_comdat_section(unsigned int shndx, Relobj** kept_object, 2182 unsigned int* kept_shndx) const 2183 { 2184 typename Kept_comdat_section_table::const_iterator p = 2185 this->kept_comdat_sections_.find(shndx); 2186 if (p == this->kept_comdat_sections_.end()) 2187 return false; 2188 *kept_object = p->second.object; 2189 *kept_shndx = p->second.shndx; 2190 return true; 2191 } 2192 2193 // Compute final local symbol value. R_SYM is the local symbol index. 2194 // LV_IN points to a local symbol value containing the input value. 2195 // LV_OUT points to a local symbol value storing the final output value, 2196 // which must not be a merged symbol value since before calling this 2197 // method to avoid memory leak. RELOCATABLE indicates whether we are 2198 // linking a relocatable output. OUT_SECTIONS is an array of output 2199 // sections. OUT_OFFSETS is an array of offsets of the sections. SYMTAB 2200 // points to a symbol table. 2201 // 2202 // The method returns a status code at return. If the return status is 2203 // CFLV_OK, *LV_OUT contains the final value. If the return status is 2204 // CFLV_ERROR, *LV_OUT is 0. If the return status is CFLV_DISCARDED, 2205 // *LV_OUT is not modified. 2206 inline Compute_final_local_value_status 2207 compute_final_local_value_internal(unsigned int r_sym, 2208 const Symbol_value<size>* lv_in, 2209 Symbol_value<size>* lv_out, 2210 bool relocatable, 2211 const Output_sections& out_sections, 2212 const std::vector<Address>& out_offsets, 2213 const Symbol_table* symtab); 2214 2215 // The GOT offsets of local symbols. This map also stores GOT offsets 2216 // for tp-relative offsets for TLS symbols. 2217 typedef Unordered_map<unsigned int, Got_offset_list*> Local_got_offsets; 2218 2219 // The PLT offsets of local symbols. 2220 typedef Unordered_map<unsigned int, unsigned int> Local_plt_offsets; 2221 2222 // Saved information for sections whose layout was deferred. 2223 struct Deferred_layout 2224 { 2225 static const int shdr_size = elfcpp::Elf_sizes<size>::shdr_size; 2226 Deferred_layout(unsigned int shndx, const char* name, 2227 const unsigned char* pshdr, 2228 unsigned int reloc_shndx, unsigned int reloc_type) 2229 : shndx_(shndx), name_(name), reloc_shndx_(reloc_shndx), 2230 reloc_type_(reloc_type) 2231 { 2232 memcpy(this->shdr_data_, pshdr, shdr_size); 2233 } 2234 unsigned int shndx_; 2235 std::string name_; 2236 unsigned int reloc_shndx_; 2237 unsigned int reloc_type_; 2238 unsigned char shdr_data_[shdr_size]; 2239 }; 2240 2241 // General access to the ELF file. 2242 elfcpp::Elf_file<size, big_endian, Object> elf_file_; 2243 // Index of SHT_SYMTAB section. 2244 unsigned int symtab_shndx_; 2245 // The number of local symbols. 2246 unsigned int local_symbol_count_; 2247 // The number of local symbols which go into the output file. 2248 unsigned int output_local_symbol_count_; 2249 // The number of local symbols which go into the output file's dynamic 2250 // symbol table. 2251 unsigned int output_local_dynsym_count_; 2252 // The entries in the symbol table for the external symbols. 2253 Symbols symbols_; 2254 // Number of symbols defined in object file itself. 2255 size_t defined_count_; 2256 // File offset for local symbols. 2257 off_t local_symbol_offset_; 2258 // File offset for local dynamic symbols. 2259 off_t local_dynsym_offset_; 2260 // Values of local symbols. 2261 Local_values local_values_; 2262 // GOT offsets for local non-TLS symbols, and tp-relative offsets 2263 // for TLS symbols, indexed by symbol number. 2264 Local_got_offsets local_got_offsets_; 2265 // PLT offsets for local symbols. 2266 Local_plt_offsets local_plt_offsets_; 2267 // For each input section, the offset of the input section in its 2268 // output section. This is INVALID_ADDRESS if the input section requires a 2269 // special mapping. 2270 std::vector<Address> section_offsets_; 2271 // Table mapping discarded comdat sections to corresponding kept sections. 2272 Kept_comdat_section_table kept_comdat_sections_; 2273 // Whether this object has a GNU style .eh_frame section. 2274 bool has_eh_frame_; 2275 // If this object has a GNU style .eh_frame section that is discarded in 2276 // output, record the index here. Otherwise it is -1U. 2277 unsigned int discarded_eh_frame_shndx_; 2278 // The list of sections whose layout was deferred. 2279 std::vector<Deferred_layout> deferred_layout_; 2280 // The list of relocation sections whose layout was deferred. 2281 std::vector<Deferred_layout> deferred_layout_relocs_; 2282 // For compressed debug sections, map section index to uncompressed size. 2283 Compressed_section_map* compressed_sections_; 2284}; 2285 2286// A class to manage the list of all objects. 2287 2288class Input_objects 2289{ 2290 public: 2291 Input_objects() 2292 : relobj_list_(), dynobj_list_(), sonames_(), cref_(NULL) 2293 { } 2294 2295 // The type of the list of input relocateable objects. 2296 typedef std::vector<Relobj*> Relobj_list; 2297 typedef Relobj_list::const_iterator Relobj_iterator; 2298 2299 // The type of the list of input dynamic objects. 2300 typedef std::vector<Dynobj*> Dynobj_list; 2301 typedef Dynobj_list::const_iterator Dynobj_iterator; 2302 2303 // Add an object to the list. Return true if all is well, or false 2304 // if this object should be ignored. 2305 bool 2306 add_object(Object*); 2307 2308 // Start processing an archive. 2309 void 2310 archive_start(Archive*); 2311 2312 // Stop processing an archive. 2313 void 2314 archive_stop(Archive*); 2315 2316 // For each dynamic object, check whether we've seen all of its 2317 // explicit dependencies. 2318 void 2319 check_dynamic_dependencies() const; 2320 2321 // Return whether an object was found in the system library 2322 // directory. 2323 bool 2324 found_in_system_library_directory(const Object*) const; 2325 2326 // Print symbol counts. 2327 void 2328 print_symbol_counts(const Symbol_table*) const; 2329 2330 // Print a cross reference table. 2331 void 2332 print_cref(const Symbol_table*, FILE*) const; 2333 2334 // Iterate over all regular objects. 2335 2336 Relobj_iterator 2337 relobj_begin() const 2338 { return this->relobj_list_.begin(); } 2339 2340 Relobj_iterator 2341 relobj_end() const 2342 { return this->relobj_list_.end(); } 2343 2344 // Iterate over all dynamic objects. 2345 2346 Dynobj_iterator 2347 dynobj_begin() const 2348 { return this->dynobj_list_.begin(); } 2349 2350 Dynobj_iterator 2351 dynobj_end() const 2352 { return this->dynobj_list_.end(); } 2353 2354 // Return whether we have seen any dynamic objects. 2355 bool 2356 any_dynamic() const 2357 { return !this->dynobj_list_.empty(); } 2358 2359 // Return the number of non dynamic objects. 2360 int 2361 number_of_relobjs() const 2362 { return this->relobj_list_.size(); } 2363 2364 // Return the number of input objects. 2365 int 2366 number_of_input_objects() const 2367 { return this->relobj_list_.size() + this->dynobj_list_.size(); } 2368 2369 private: 2370 Input_objects(const Input_objects&); 2371 Input_objects& operator=(const Input_objects&); 2372 2373 // The list of ordinary objects included in the link. 2374 Relobj_list relobj_list_; 2375 // The list of dynamic objects included in the link. 2376 Dynobj_list dynobj_list_; 2377 // SONAMEs that we have seen. 2378 Unordered_set<std::string> sonames_; 2379 // Manage cross-references if requested. 2380 Cref* cref_; 2381}; 2382 2383// Some of the information we pass to the relocation routines. We 2384// group this together to avoid passing a dozen different arguments. 2385 2386template<int size, bool big_endian> 2387struct Relocate_info 2388{ 2389 // Symbol table. 2390 const Symbol_table* symtab; 2391 // Layout. 2392 const Layout* layout; 2393 // Object being relocated. 2394 Sized_relobj<size, big_endian>* object; 2395 // Section index of relocation section. 2396 unsigned int reloc_shndx; 2397 // Section header of relocation section. 2398 const unsigned char* reloc_shdr; 2399 // Section index of section being relocated. 2400 unsigned int data_shndx; 2401 // Section header of data section. 2402 const unsigned char* data_shdr; 2403 2404 // Return a string showing the location of a relocation. This is 2405 // only used for error messages. 2406 std::string 2407 location(size_t relnum, off_t reloffset) const; 2408}; 2409 2410// This is used to represent a section in an object and is used as the 2411// key type for various section maps. 2412typedef std::pair<Object*, unsigned int> Section_id; 2413 2414// This is similar to Section_id but is used when the section 2415// pointers are const. 2416typedef std::pair<const Object*, unsigned int> Const_section_id; 2417 2418// The hash value is based on the address of an object in memory during 2419// linking. It is okay to use this for looking up sections but never use 2420// this in an unordered container that we want to traverse in a repeatable 2421// manner. 2422 2423struct Section_id_hash 2424{ 2425 size_t operator()(const Section_id& loc) const 2426 { return reinterpret_cast<uintptr_t>(loc.first) ^ loc.second; } 2427}; 2428 2429struct Const_section_id_hash 2430{ 2431 size_t operator()(const Const_section_id& loc) const 2432 { return reinterpret_cast<uintptr_t>(loc.first) ^ loc.second; } 2433}; 2434 2435// Return whether INPUT_FILE contains an ELF object start at file 2436// offset OFFSET. This sets *START to point to a view of the start of 2437// the file. It sets *READ_SIZE to the number of bytes in the view. 2438 2439extern bool 2440is_elf_object(Input_file* input_file, off_t offset, 2441 const unsigned char** start, int* read_size); 2442 2443// Return an Object appropriate for the input file. P is BYTES long, 2444// and holds the ELF header. If PUNCONFIGURED is not NULL, then if 2445// this sees an object the linker is not configured to support, it 2446// sets *PUNCONFIGURED to true and returns NULL without giving an 2447// error message. 2448 2449extern Object* 2450make_elf_object(const std::string& name, Input_file*, 2451 off_t offset, const unsigned char* p, 2452 section_offset_type bytes, bool* punconfigured); 2453 2454} // end namespace gold 2455 2456#endif // !defined(GOLD_OBJECT_H) 2457