Automatic date update in version.in
[binutils-gdb.git] / gold / object.h
bloba9b8e2c5808ac7c84e16fd95dd64632534ec0187
1 // object.h -- support for an object file for linking in gold -*- C++ -*-
3 // Copyright (C) 2006-2022 Free Software Foundation, Inc.
4 // Written by Ian Lance Taylor <iant@google.com>.
6 // This file is part of gold.
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.
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.
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.
23 #ifndef GOLD_OBJECT_H
24 #define GOLD_OBJECT_H
26 #include <string>
27 #include <vector>
29 #include "elfcpp.h"
30 #include "elfcpp_file.h"
31 #include "fileread.h"
32 #include "target.h"
33 #include "archive.h"
35 namespace gold
38 class General_options;
39 class Task;
40 class Cref;
41 class Layout;
42 class Kept_section;
43 class Output_data;
44 class Output_section;
45 class Output_section_data;
46 class Output_file;
47 class Output_symtab_xindex;
48 class Pluginobj;
49 class Dynobj;
50 class Object_merge_map;
51 class Relocatable_relocs;
52 struct Symbols_data;
54 template<typename Stringpool_char>
55 class Stringpool_template;
57 // Data to pass from read_symbols() to add_symbols().
59 struct Read_symbols_data
61 Read_symbols_data()
62 : section_headers(NULL), section_names(NULL), symbols(NULL),
63 symbol_names(NULL), versym(NULL), verdef(NULL), verneed(NULL)
64 { }
66 ~Read_symbols_data();
68 // Section headers.
69 File_view* section_headers;
70 // Section names.
71 File_view* section_names;
72 // Size of section name data in bytes.
73 section_size_type section_names_size;
74 // Symbol data.
75 File_view* symbols;
76 // Size of symbol data in bytes.
77 section_size_type symbols_size;
78 // Offset of external symbols within symbol data. This structure
79 // sometimes contains only external symbols, in which case this will
80 // be zero. Sometimes it contains all symbols.
81 section_offset_type external_symbols_offset;
82 // Symbol names.
83 File_view* symbol_names;
84 // Size of symbol name data in bytes.
85 section_size_type symbol_names_size;
87 // Version information. This is only used on dynamic objects.
88 // Version symbol data (from SHT_GNU_versym section).
89 File_view* versym;
90 section_size_type versym_size;
91 // Version definition data (from SHT_GNU_verdef section).
92 File_view* verdef;
93 section_size_type verdef_size;
94 unsigned int verdef_info;
95 // Needed version data (from SHT_GNU_verneed section).
96 File_view* verneed;
97 section_size_type verneed_size;
98 unsigned int verneed_info;
101 // Information used to print error messages.
103 struct Symbol_location_info
105 std::string source_file;
106 std::string enclosing_symbol_name;
107 elfcpp::STT enclosing_symbol_type;
110 // Data about a single relocation section. This is read in
111 // read_relocs and processed in scan_relocs.
113 struct Section_relocs
115 Section_relocs()
116 : contents(NULL)
119 ~Section_relocs()
120 { delete this->contents; }
122 // Index of reloc section.
123 unsigned int reloc_shndx;
124 // Index of section that relocs apply to.
125 unsigned int data_shndx;
126 // Contents of reloc section.
127 File_view* contents;
128 // Reloc section type.
129 unsigned int sh_type;
130 // Number of reloc entries.
131 size_t reloc_count;
132 // Output section.
133 Output_section* output_section;
134 // Whether this section has special handling for offsets.
135 bool needs_special_offset_handling;
136 // Whether the data section is allocated (has the SHF_ALLOC flag set).
137 bool is_data_section_allocated;
140 // Relocations in an object file. This is read in read_relocs and
141 // processed in scan_relocs.
143 struct Read_relocs_data
145 Read_relocs_data()
146 : local_symbols(NULL)
149 ~Read_relocs_data()
150 { delete this->local_symbols; }
152 typedef std::vector<Section_relocs> Relocs_list;
153 // The relocations.
154 Relocs_list relocs;
155 // The local symbols.
156 File_view* local_symbols;
159 // The Xindex class manages section indexes for objects with more than
160 // 0xff00 sections.
162 class Xindex
164 public:
165 Xindex(int large_shndx_offset)
166 : large_shndx_offset_(large_shndx_offset), symtab_xindex_()
169 // Initialize the symtab_xindex_ array, given the object and the
170 // section index of the symbol table to use.
171 template<int size, bool big_endian>
172 void
173 initialize_symtab_xindex(Object*, unsigned int symtab_shndx);
175 // Read in the symtab_xindex_ array, given its section index.
176 // PSHDRS may optionally point to the section headers.
177 template<int size, bool big_endian>
178 void
179 read_symtab_xindex(Object*, unsigned int xindex_shndx,
180 const unsigned char* pshdrs);
182 // Symbol SYMNDX in OBJECT has a section of SHN_XINDEX; return the
183 // real section index.
184 unsigned int
185 sym_xindex_to_shndx(Object* object, unsigned int symndx);
187 private:
188 // The type of the array giving the real section index for symbols
189 // whose st_shndx field holds SHN_XINDEX.
190 typedef std::vector<unsigned int> Symtab_xindex;
192 // Adjust a section index if necessary. This should only be called
193 // for ordinary section indexes.
194 unsigned int
195 adjust_shndx(unsigned int shndx)
197 if (shndx >= elfcpp::SHN_LORESERVE)
198 shndx += this->large_shndx_offset_;
199 return shndx;
202 // Adjust to apply to large section indexes.
203 int large_shndx_offset_;
204 // The data from the SHT_SYMTAB_SHNDX section.
205 Symtab_xindex symtab_xindex_;
208 // A GOT offset list. A symbol may have more than one GOT offset
209 // (e.g., when mixing modules compiled with two different TLS models),
210 // but will usually have at most one. GOT_TYPE identifies the type of
211 // GOT entry; its values are specific to each target.
213 class Got_offset_list
215 public:
216 Got_offset_list()
217 : got_type_(-1U), got_offset_(0), addend_(0), got_next_(NULL)
220 Got_offset_list(unsigned int got_type, unsigned int got_offset,
221 uint64_t addend)
222 : got_type_(got_type), got_offset_(got_offset), addend_(addend),
223 got_next_(NULL)
226 ~Got_offset_list()
228 if (this->got_next_ != NULL)
230 delete this->got_next_;
231 this->got_next_ = NULL;
235 // Initialize the fields to their default values.
236 void
237 init()
239 this->got_type_ = -1U;
240 this->got_offset_ = 0;
241 this->addend_ = 0;
242 this->got_next_ = NULL;
245 // Set the offset for the GOT entry of type GOT_TYPE.
246 void
247 set_offset(unsigned int got_type, unsigned int got_offset, uint64_t addend)
249 if (this->got_type_ == -1U)
251 this->got_type_ = got_type;
252 this->got_offset_ = got_offset;
253 this->addend_ = addend;
255 else
257 for (Got_offset_list* g = this; g != NULL; g = g->got_next_)
259 if (g->got_type_ == got_type && g->addend_ == addend)
261 g->got_offset_ = got_offset;
262 return;
265 Got_offset_list* g = new Got_offset_list(got_type, got_offset, addend);
266 g->got_next_ = this->got_next_;
267 this->got_next_ = g;
271 // Return the offset for a GOT entry of type GOT_TYPE.
272 unsigned int
273 get_offset(unsigned int got_type, uint64_t addend) const
275 for (const Got_offset_list* g = this; g != NULL; g = g->got_next_)
277 if (g->got_type_ == got_type && g->addend_ == addend)
278 return g->got_offset_;
280 return -1U;
283 // Return a pointer to the list, or NULL if the list is empty.
284 const Got_offset_list*
285 get_list() const
287 if (this->got_type_ == -1U)
288 return NULL;
289 return this;
292 // Abstract visitor class for iterating over GOT offsets.
293 class Visitor
295 public:
296 Visitor()
299 virtual
300 ~Visitor()
303 virtual void
304 visit(unsigned int, unsigned int, uint64_t) = 0;
307 // Loop over all GOT offset entries, calling a visitor class V for each.
308 void
309 for_all_got_offsets(Visitor* v) const
311 if (this->got_type_ == -1U)
312 return;
313 for (const Got_offset_list* g = this; g != NULL; g = g->got_next_)
314 v->visit(g->got_type_, g->got_offset_, g->addend_);
317 private:
318 unsigned int got_type_;
319 unsigned int got_offset_;
320 uint64_t addend_;
321 Got_offset_list* got_next_;
324 // The Local_got_entry_key used to index the GOT offsets for local
325 // non-TLS symbols, and tp-relative offsets for TLS symbols.
327 class Local_got_entry_key
329 public:
330 Local_got_entry_key(unsigned int symndx)
331 : symndx_(symndx)
334 // Whether this equals to another Local_got_entry_key.
335 bool
336 eq(const Local_got_entry_key& key) const
338 return this->symndx_ == key.symndx_;
341 // Compute a hash value for this using 64-bit FNV-1a hash.
342 size_t
343 hash_value() const
345 uint64_t h = 14695981039346656037ULL; // FNV offset basis.
346 uint64_t prime = 1099511628211ULL;
347 h = (h ^ static_cast<uint64_t>(this->symndx_)) * prime;
348 return h;
351 // Functors for associative containers.
352 struct equal_to
354 bool
355 operator()(const Local_got_entry_key& key1,
356 const Local_got_entry_key& key2) const
357 { return key1.eq(key2); }
360 struct hash
362 size_t
363 operator()(const Local_got_entry_key& key) const
364 { return key.hash_value(); }
367 private:
368 // The local symbol index.
369 unsigned int symndx_;
372 // Type for mapping section index to uncompressed size and contents.
374 struct Compressed_section_info
376 section_size_type size;
377 elfcpp::Elf_Xword flag;
378 uint64_t addralign;
379 const unsigned char* contents;
381 typedef std::map<unsigned int, Compressed_section_info> Compressed_section_map;
383 template<int size, bool big_endian>
384 Compressed_section_map*
385 build_compressed_section_map(const unsigned char* pshdrs, unsigned int shnum,
386 const char* names, section_size_type names_size,
387 Object* obj, bool decompress_if_needed);
389 // Osabi represents the EI_OSABI field from the ELF header.
391 class Osabi
393 public:
394 Osabi(unsigned char ei_osabi)
395 : ei_osabi_(static_cast<elfcpp::ELFOSABI>(ei_osabi))
398 bool
399 has_shf_retain(elfcpp::Elf_Xword sh_flags) const
401 switch (this->ei_osabi_)
403 case elfcpp::ELFOSABI_GNU:
404 case elfcpp::ELFOSABI_FREEBSD:
405 return (sh_flags & elfcpp::SHF_GNU_RETAIN) != 0;
406 default:
407 break;
409 return false;
412 elfcpp::Elf_Xword
413 ignored_sh_flags() const
415 switch (this->ei_osabi_)
417 case elfcpp::ELFOSABI_GNU:
418 case elfcpp::ELFOSABI_FREEBSD:
419 return elfcpp::SHF_GNU_RETAIN;
420 default:
421 break;
423 return 0;
426 private:
427 elfcpp::ELFOSABI ei_osabi_;
430 // Object is an abstract base class which represents either a 32-bit
431 // or a 64-bit input object. This can be a regular object file
432 // (ET_REL) or a shared object (ET_DYN).
434 class Object
436 public:
437 typedef std::vector<Symbol*> Symbols;
439 // NAME is the name of the object as we would report it to the user
440 // (e.g., libfoo.a(bar.o) if this is in an archive. INPUT_FILE is
441 // used to read the file. OFFSET is the offset within the input
442 // file--0 for a .o or .so file, something else for a .a file.
443 Object(const std::string& name, Input_file* input_file, bool is_dynamic,
444 off_t offset = 0)
445 : name_(name), input_file_(input_file), offset_(offset), shnum_(-1U),
446 is_dynamic_(is_dynamic), is_needed_(false), uses_split_stack_(false),
447 has_no_split_stack_(false), no_export_(false),
448 is_in_system_directory_(false), as_needed_(false), xindex_(NULL),
449 compressed_sections_(NULL)
451 if (input_file != NULL)
453 input_file->file().add_object();
454 this->is_in_system_directory_ = input_file->is_in_system_directory();
455 this->as_needed_ = input_file->options().as_needed();
459 virtual ~Object()
461 if (this->input_file_ != NULL)
462 this->input_file_->file().remove_object();
465 // Return the name of the object as we would report it to the user.
466 const std::string&
467 name() const
468 { return this->name_; }
470 // Get the offset into the file.
471 off_t
472 offset() const
473 { return this->offset_; }
475 // Return whether this is a dynamic object.
476 bool
477 is_dynamic() const
478 { return this->is_dynamic_; }
480 // Return the word size of the object file.
481 virtual int elfsize() const = 0;
483 // Return TRUE if this is a big-endian object file.
484 virtual bool is_big_endian() const = 0;
486 // Return whether this object is needed--true if it is a dynamic
487 // object which defines some symbol referenced by a regular object.
488 // We keep the flag here rather than in Dynobj for convenience when
489 // setting it.
490 bool
491 is_needed() const
492 { return this->is_needed_; }
494 // Record that this object is needed.
495 void
496 set_is_needed()
497 { this->is_needed_ = true; }
499 // Return whether this object was compiled with -fsplit-stack.
500 bool
501 uses_split_stack() const
502 { return this->uses_split_stack_; }
504 // Return whether this object contains any functions compiled with
505 // the no_split_stack attribute.
506 bool
507 has_no_split_stack() const
508 { return this->has_no_split_stack_; }
510 // Returns NULL for Objects that are not dynamic objects. This method
511 // is overridden in the Dynobj class.
512 Dynobj*
513 dynobj()
514 { return this->do_dynobj(); }
516 // Returns NULL for Objects that are not plugin objects. This method
517 // is overridden in the Pluginobj class.
518 Pluginobj*
519 pluginobj()
520 { return this->do_pluginobj(); }
522 // Get the file. We pass on const-ness.
523 Input_file*
524 input_file()
526 gold_assert(this->input_file_ != NULL);
527 return this->input_file_;
530 const Input_file*
531 input_file() const
533 gold_assert(this->input_file_ != NULL);
534 return this->input_file_;
537 // Lock the underlying file.
538 void
539 lock(const Task* t)
541 if (this->input_file_ != NULL)
542 this->input_file_->file().lock(t);
545 // Unlock the underlying file.
546 void
547 unlock(const Task* t)
549 if (this->input_file_ != NULL)
550 this->input_file()->file().unlock(t);
553 // Return whether the underlying file is locked.
554 bool
555 is_locked() const
556 { return this->input_file_ != NULL && this->input_file_->file().is_locked(); }
558 // Return the token, so that the task can be queued.
559 Task_token*
560 token()
562 if (this->input_file_ == NULL)
563 return NULL;
564 return this->input_file()->file().token();
567 // Release the underlying file.
568 void
569 release()
571 if (this->input_file_ != NULL)
572 this->input_file()->file().release();
575 // Return whether we should just read symbols from this file.
576 bool
577 just_symbols() const
578 { return this->input_file()->just_symbols(); }
580 // Return whether this is an incremental object.
581 bool
582 is_incremental() const
583 { return this->do_is_incremental(); }
585 // Return the last modified time of the file.
586 Timespec
587 get_mtime()
588 { return this->do_get_mtime(); }
590 // Get the number of sections.
591 unsigned int
592 shnum() const
593 { return this->shnum_; }
595 // Return a view of the contents of a section. Set *PLEN to the
596 // size. CACHE is a hint as in File_read::get_view.
597 const unsigned char*
598 section_contents(unsigned int shndx, section_size_type* plen, bool cache);
600 // Adjust a symbol's section index as needed. SYMNDX is the index
601 // of the symbol and SHNDX is the symbol's section from
602 // get_st_shndx. This returns the section index. It sets
603 // *IS_ORDINARY to indicate whether this is a normal section index,
604 // rather than a special code between SHN_LORESERVE and
605 // SHN_HIRESERVE.
606 unsigned int
607 adjust_sym_shndx(unsigned int symndx, unsigned int shndx, bool* is_ordinary)
609 if (shndx < elfcpp::SHN_LORESERVE)
610 *is_ordinary = true;
611 else if (shndx == elfcpp::SHN_XINDEX)
613 if (this->xindex_ == NULL)
614 this->xindex_ = this->do_initialize_xindex();
615 shndx = this->xindex_->sym_xindex_to_shndx(this, symndx);
616 *is_ordinary = true;
618 else
619 *is_ordinary = false;
620 return shndx;
623 // Return the size of a section given a section index.
624 uint64_t
625 section_size(unsigned int shndx)
626 { return this->do_section_size(shndx); }
628 // Return the name of a section given a section index.
629 std::string
630 section_name(unsigned int shndx) const
631 { return this->do_section_name(shndx); }
633 // Return the section flags given a section index.
634 uint64_t
635 section_flags(unsigned int shndx)
636 { return this->do_section_flags(shndx); }
638 // Return the section entsize given a section index.
639 uint64_t
640 section_entsize(unsigned int shndx)
641 { return this->do_section_entsize(shndx); }
643 // Return the section address given a section index.
644 uint64_t
645 section_address(unsigned int shndx)
646 { return this->do_section_address(shndx); }
648 // Return the section type given a section index.
649 unsigned int
650 section_type(unsigned int shndx)
651 { return this->do_section_type(shndx); }
653 // Return the section link field given a section index.
654 unsigned int
655 section_link(unsigned int shndx)
656 { return this->do_section_link(shndx); }
658 // Return the section info field given a section index.
659 unsigned int
660 section_info(unsigned int shndx)
661 { return this->do_section_info(shndx); }
663 // Return the required section alignment given a section index.
664 uint64_t
665 section_addralign(unsigned int shndx)
666 { return this->do_section_addralign(shndx); }
668 // Return the output section given a section index.
669 Output_section*
670 output_section(unsigned int shndx) const
671 { return this->do_output_section(shndx); }
673 // Given a section index, return its address.
674 // The return value will be -1U if the section is specially mapped,
675 // such as a merge section.
676 uint64_t
677 output_section_address(unsigned int shndx)
678 { return this->do_output_section_address(shndx); }
680 // Given a section index, return the offset in the Output_section.
681 // The return value will be -1U if the section is specially mapped,
682 // such as a merge section.
683 uint64_t
684 output_section_offset(unsigned int shndx) const
685 { return this->do_output_section_offset(shndx); }
687 // Read the symbol information.
688 void
689 read_symbols(Read_symbols_data* sd)
690 { return this->do_read_symbols(sd); }
692 // Pass sections which should be included in the link to the Layout
693 // object, and record where the sections go in the output file.
694 void
695 layout(Symbol_table* symtab, Layout* layout, Read_symbols_data* sd)
696 { this->do_layout(symtab, layout, sd); }
698 // Add symbol information to the global symbol table.
699 void
700 add_symbols(Symbol_table* symtab, Read_symbols_data* sd, Layout *layout)
701 { this->do_add_symbols(symtab, sd, layout); }
703 // Add symbol information to the global symbol table.
704 Archive::Should_include
705 should_include_member(Symbol_table* symtab, Layout* layout,
706 Read_symbols_data* sd, std::string* why)
707 { return this->do_should_include_member(symtab, layout, sd, why); }
709 // Iterate over global symbols, calling a visitor class V for each.
710 void
711 for_all_global_symbols(Read_symbols_data* sd,
712 Library_base::Symbol_visitor_base* v)
713 { return this->do_for_all_global_symbols(sd, v); }
715 // Iterate over local symbols, calling a visitor class V for each GOT offset
716 // associated with a local symbol.
717 void
718 for_all_local_got_entries(Got_offset_list::Visitor* v) const
719 { this->do_for_all_local_got_entries(v); }
721 // Functions and types for the elfcpp::Elf_file interface. This
722 // permit us to use Object as the File template parameter for
723 // elfcpp::Elf_file.
725 // The View class is returned by view. It must support a single
726 // method, data(). This is trivial, because get_view does what we
727 // need.
728 class View
730 public:
731 View(const unsigned char* p)
732 : p_(p)
735 const unsigned char*
736 data() const
737 { return this->p_; }
739 private:
740 const unsigned char* p_;
743 // Return a View.
744 View
745 view(off_t file_offset, section_size_type data_size)
746 { return View(this->get_view(file_offset, data_size, true, true)); }
748 // Report an error.
749 void
750 error(const char* format, ...) const ATTRIBUTE_PRINTF_2;
752 // A location in the file.
753 struct Location
755 off_t file_offset;
756 off_t data_size;
758 Location(off_t fo, section_size_type ds)
759 : file_offset(fo), data_size(ds)
763 // Get a View given a Location.
764 View view(Location loc)
765 { return View(this->get_view(loc.file_offset, loc.data_size, true, true)); }
767 // Get a view into the underlying file.
768 const unsigned char*
769 get_view(off_t start, section_size_type size, bool aligned, bool cache)
771 return this->input_file()->file().get_view(this->offset_, start, size,
772 aligned, cache);
775 // Get a lasting view into the underlying file.
776 File_view*
777 get_lasting_view(off_t start, section_size_type size, bool aligned,
778 bool cache)
780 return this->input_file()->file().get_lasting_view(this->offset_, start,
781 size, aligned, cache);
784 // Read data from the underlying file.
785 void
786 read(off_t start, section_size_type size, void* p)
787 { this->input_file()->file().read(start + this->offset_, size, p); }
789 // Read multiple data from the underlying file.
790 void
791 read_multiple(const File_read::Read_multiple& rm)
792 { this->input_file()->file().read_multiple(this->offset_, rm); }
794 // Stop caching views in the underlying file.
795 void
796 clear_view_cache_marks()
798 if (this->input_file_ != NULL)
799 this->input_file_->file().clear_view_cache_marks();
802 // Get the number of global symbols defined by this object, and the
803 // number of the symbols whose final definition came from this
804 // object.
805 void
806 get_global_symbol_counts(const Symbol_table* symtab, size_t* defined,
807 size_t* used) const
808 { this->do_get_global_symbol_counts(symtab, defined, used); }
810 // Get the symbols defined in this object.
811 const Symbols*
812 get_global_symbols() const
813 { return this->do_get_global_symbols(); }
815 // Set flag that this object was found in a system directory.
816 void
817 set_is_in_system_directory()
818 { this->is_in_system_directory_ = true; }
820 // Return whether this object was found in a system directory.
821 bool
822 is_in_system_directory() const
823 { return this->is_in_system_directory_; }
825 // Set flag that this object was linked with --as-needed.
826 void
827 set_as_needed()
828 { this->as_needed_ = true; }
830 // Clear flag that this object was linked with --as-needed.
831 void
832 clear_as_needed()
833 { this->as_needed_ = false; }
835 // Return whether this object was linked with --as-needed.
836 bool
837 as_needed() const
838 { return this->as_needed_; }
840 // Return whether we found this object by searching a directory.
841 bool
842 searched_for() const
843 { return this->input_file()->will_search_for(); }
845 bool
846 no_export() const
847 { return this->no_export_; }
849 void
850 set_no_export(bool value)
851 { this->no_export_ = value; }
853 bool
854 section_is_compressed(unsigned int shndx,
855 section_size_type* uncompressed_size,
856 elfcpp::Elf_Xword* palign = NULL) const
858 if (this->compressed_sections_ == NULL)
859 return false;
860 Compressed_section_map::const_iterator p =
861 this->compressed_sections_->find(shndx);
862 if (p != this->compressed_sections_->end())
864 if (uncompressed_size != NULL)
865 *uncompressed_size = p->second.size;
866 if (palign != NULL)
867 *palign = p->second.addralign;
868 return true;
870 return false;
873 // Return a view of the decompressed contents of a section. Set *PLEN
874 // to the size. Set *IS_NEW to true if the contents need to be freed
875 // by the caller.
876 const unsigned char*
877 decompressed_section_contents(unsigned int shndx, section_size_type* plen,
878 bool* is_cached, uint64_t* palign = NULL);
880 // Discard any buffers of decompressed sections. This is done
881 // at the end of the Add_symbols task.
882 void
883 discard_decompressed_sections();
885 // Return the index of the first incremental relocation for symbol SYMNDX.
886 unsigned int
887 get_incremental_reloc_base(unsigned int symndx) const
888 { return this->do_get_incremental_reloc_base(symndx); }
890 // Return the number of incremental relocations for symbol SYMNDX.
891 unsigned int
892 get_incremental_reloc_count(unsigned int symndx) const
893 { return this->do_get_incremental_reloc_count(symndx); }
895 // Return the output view for section SHNDX.
896 unsigned char*
897 get_output_view(unsigned int shndx, section_size_type* plen) const
898 { return this->do_get_output_view(shndx, plen); }
900 protected:
901 // Returns NULL for Objects that are not dynamic objects. This method
902 // is overridden in the Dynobj class.
903 virtual Dynobj*
904 do_dynobj()
905 { return NULL; }
907 // Returns NULL for Objects that are not plugin objects. This method
908 // is overridden in the Pluginobj class.
909 virtual Pluginobj*
910 do_pluginobj()
911 { return NULL; }
913 // Return TRUE if this is an incremental (unchanged) input file.
914 // We return FALSE by default; the incremental object classes
915 // override this method.
916 virtual bool
917 do_is_incremental() const
918 { return false; }
920 // Return the last modified time of the file. This method may be
921 // overridden for subclasses that don't use an actual file (e.g.,
922 // Incremental objects).
923 virtual Timespec
924 do_get_mtime()
925 { return this->input_file()->file().get_mtime(); }
927 // Read the symbols--implemented by child class.
928 virtual void
929 do_read_symbols(Read_symbols_data*) = 0;
931 // Lay out sections--implemented by child class.
932 virtual void
933 do_layout(Symbol_table*, Layout*, Read_symbols_data*) = 0;
935 // Add symbol information to the global symbol table--implemented by
936 // child class.
937 virtual void
938 do_add_symbols(Symbol_table*, Read_symbols_data*, Layout*) = 0;
940 virtual Archive::Should_include
941 do_should_include_member(Symbol_table* symtab, Layout*, Read_symbols_data*,
942 std::string* why) = 0;
944 // Iterate over global symbols, calling a visitor class V for each.
945 virtual void
946 do_for_all_global_symbols(Read_symbols_data* sd,
947 Library_base::Symbol_visitor_base* v) = 0;
949 // Iterate over local symbols, calling a visitor class V for each GOT offset
950 // associated with a local symbol.
951 virtual void
952 do_for_all_local_got_entries(Got_offset_list::Visitor* v) const = 0;
954 // Return the location of the contents of a section. Implemented by
955 // child class.
956 virtual const unsigned char*
957 do_section_contents(unsigned int shndx, section_size_type* plen,
958 bool cache) = 0;
960 // Get the size of a section--implemented by child class.
961 virtual uint64_t
962 do_section_size(unsigned int shndx) = 0;
964 // Get the name of a section--implemented by child class.
965 virtual std::string
966 do_section_name(unsigned int shndx) const = 0;
968 // Get section flags--implemented by child class.
969 virtual uint64_t
970 do_section_flags(unsigned int shndx) = 0;
972 // Get section entsize--implemented by child class.
973 virtual uint64_t
974 do_section_entsize(unsigned int shndx) = 0;
976 // Get section address--implemented by child class.
977 virtual uint64_t
978 do_section_address(unsigned int shndx) = 0;
980 // Get section type--implemented by child class.
981 virtual unsigned int
982 do_section_type(unsigned int shndx) = 0;
984 // Get section link field--implemented by child class.
985 virtual unsigned int
986 do_section_link(unsigned int shndx) = 0;
988 // Get section info field--implemented by child class.
989 virtual unsigned int
990 do_section_info(unsigned int shndx) = 0;
992 // Get section alignment--implemented by child class.
993 virtual uint64_t
994 do_section_addralign(unsigned int shndx) = 0;
996 // Return the output section given a section index--implemented
997 // by child class.
998 virtual Output_section*
999 do_output_section(unsigned int) const
1000 { gold_unreachable(); }
1002 // Get the address of a section--implemented by child class.
1003 virtual uint64_t
1004 do_output_section_address(unsigned int)
1005 { gold_unreachable(); }
1007 // Get the offset of a section--implemented by child class.
1008 virtual uint64_t
1009 do_output_section_offset(unsigned int) const
1010 { gold_unreachable(); }
1012 // Return the Xindex structure to use.
1013 virtual Xindex*
1014 do_initialize_xindex() = 0;
1016 // Implement get_global_symbol_counts--implemented by child class.
1017 virtual void
1018 do_get_global_symbol_counts(const Symbol_table*, size_t*, size_t*) const = 0;
1020 virtual const Symbols*
1021 do_get_global_symbols() const = 0;
1023 // Set the number of sections.
1024 void
1025 set_shnum(int shnum)
1026 { this->shnum_ = shnum; }
1028 // Functions used by both Sized_relobj_file and Sized_dynobj.
1030 // Read the section data into a Read_symbols_data object.
1031 template<int size, bool big_endian>
1032 void
1033 read_section_data(elfcpp::Elf_file<size, big_endian, Object>*,
1034 Read_symbols_data*);
1036 // Find the section header with the given NAME. If HDR is non-NULL
1037 // then it is a section header returned from a previous call to this
1038 // function and the next section header with the same name will be
1039 // returned.
1040 template<int size, bool big_endian>
1041 const unsigned char*
1042 find_shdr(const unsigned char* pshdrs, const char* name,
1043 const char* names, section_size_type names_size,
1044 const unsigned char* hdr) const;
1046 // Let the child class initialize the xindex object directly.
1047 void
1048 set_xindex(Xindex* xindex)
1050 gold_assert(this->xindex_ == NULL);
1051 this->xindex_ = xindex;
1054 // If NAME is the name of a special .gnu.warning section, arrange
1055 // for the warning to be issued. SHNDX is the section index.
1056 // Return whether it is a warning section.
1057 bool
1058 handle_gnu_warning_section(const char* name, unsigned int shndx,
1059 Symbol_table*);
1061 // If NAME is the name of the special section which indicates that
1062 // this object was compiled with -fsplit-stack, mark it accordingly,
1063 // and return true. Otherwise return false.
1064 bool
1065 handle_split_stack_section(const char* name);
1067 // Discard any buffers of decompressed sections. This is done
1068 // at the end of the Add_symbols task.
1069 virtual void
1070 do_discard_decompressed_sections()
1073 // Return the index of the first incremental relocation for symbol SYMNDX--
1074 // implemented by child class.
1075 virtual unsigned int
1076 do_get_incremental_reloc_base(unsigned int) const
1077 { gold_unreachable(); }
1079 // Return the number of incremental relocations for symbol SYMNDX--
1080 // implemented by child class.
1081 virtual unsigned int
1082 do_get_incremental_reloc_count(unsigned int) const
1083 { gold_unreachable(); }
1085 // Return the output view for a section.
1086 virtual unsigned char*
1087 do_get_output_view(unsigned int, section_size_type*) const
1088 { gold_unreachable(); }
1090 void
1091 set_compressed_sections(Compressed_section_map* compressed_sections)
1092 { this->compressed_sections_ = compressed_sections; }
1094 Compressed_section_map*
1095 compressed_sections()
1096 { return this->compressed_sections_; }
1098 private:
1099 // This class may not be copied.
1100 Object(const Object&);
1101 Object& operator=(const Object&);
1103 // Name of object as printed to user.
1104 std::string name_;
1105 // For reading the file.
1106 Input_file* input_file_;
1107 // Offset within the file--0 for an object file, non-0 for an
1108 // archive.
1109 off_t offset_;
1110 // Number of input sections.
1111 unsigned int shnum_;
1112 // Whether this is a dynamic object.
1113 bool is_dynamic_ : 1;
1114 // Whether this object is needed. This is only set for dynamic
1115 // objects, and means that the object defined a symbol which was
1116 // used by a reference from a regular object.
1117 bool is_needed_ : 1;
1118 // Whether this object was compiled with -fsplit-stack.
1119 bool uses_split_stack_ : 1;
1120 // Whether this object contains any functions compiled with the
1121 // no_split_stack attribute.
1122 bool has_no_split_stack_ : 1;
1123 // True if exclude this object from automatic symbol export.
1124 // This is used only for archive objects.
1125 bool no_export_ : 1;
1126 // True if the object was found in a system directory.
1127 bool is_in_system_directory_ : 1;
1128 // True if the object was linked with --as-needed.
1129 bool as_needed_ : 1;
1130 // Many sections for objects with more than SHN_LORESERVE sections.
1131 Xindex* xindex_;
1132 // For compressed debug sections, map section index to uncompressed size
1133 // and contents.
1134 Compressed_section_map* compressed_sections_;
1137 // A regular object (ET_REL). This is an abstract base class itself.
1138 // The implementation is the template class Sized_relobj_file.
1140 class Relobj : public Object
1142 public:
1143 Relobj(const std::string& name, Input_file* input_file, off_t offset = 0)
1144 : Object(name, input_file, false, offset),
1145 output_sections_(),
1146 map_to_relocatable_relocs_(NULL),
1147 object_merge_map_(NULL),
1148 relocs_must_follow_section_writes_(false),
1149 sd_(NULL),
1150 reloc_counts_(NULL),
1151 reloc_bases_(NULL),
1152 first_dyn_reloc_(0),
1153 dyn_reloc_count_(0)
1156 // During garbage collection, the Read_symbols_data pass for
1157 // each object is stored as layout needs to be done after
1158 // reloc processing.
1159 Symbols_data*
1160 get_symbols_data()
1161 { return this->sd_; }
1163 // Decides which section names have to be included in the worklist
1164 // as roots.
1165 bool
1166 is_section_name_included(const char* name);
1168 void
1169 copy_symbols_data(Symbols_data* gc_sd, Read_symbols_data* sd,
1170 unsigned int section_header_size);
1172 void
1173 set_symbols_data(Symbols_data* sd)
1174 { this->sd_ = sd; }
1176 // During garbage collection, the Read_relocs pass for all objects
1177 // is done before scanning the relocs. In that case, this->rd_ is
1178 // used to store the information from Read_relocs for each object.
1179 // This data is also used to compute the list of relevant sections.
1180 Read_relocs_data*
1181 get_relocs_data()
1182 { return this->rd_; }
1184 void
1185 set_relocs_data(Read_relocs_data* rd)
1186 { this->rd_ = rd; }
1188 virtual bool
1189 is_output_section_offset_invalid(unsigned int shndx) const = 0;
1191 // Read the relocs.
1192 void
1193 read_relocs(Read_relocs_data* rd)
1194 { return this->do_read_relocs(rd); }
1196 // Process the relocs, during garbage collection only.
1197 void
1198 gc_process_relocs(Symbol_table* symtab, Layout* layout, Read_relocs_data* rd)
1199 { return this->do_gc_process_relocs(symtab, layout, rd); }
1201 // Scan the relocs and adjust the symbol table.
1202 void
1203 scan_relocs(Symbol_table* symtab, Layout* layout, Read_relocs_data* rd)
1204 { return this->do_scan_relocs(symtab, layout, rd); }
1206 // Return the value of the local symbol whose index is SYMNDX, plus
1207 // ADDEND. ADDEND is passed in so that we can correctly handle the
1208 // section symbol for a merge section.
1209 uint64_t
1210 local_symbol_value(unsigned int symndx, uint64_t addend) const
1211 { return this->do_local_symbol_value(symndx, addend); }
1213 // Return the PLT offset for a local symbol. It is an error to call
1214 // this if it doesn't have one.
1215 unsigned int
1216 local_plt_offset(unsigned int symndx) const
1217 { return this->do_local_plt_offset(symndx); }
1219 // Return whether there is a GOT entry of type GOT_TYPE for the
1220 // local symbol SYMNDX with given ADDEND.
1221 bool
1222 local_has_got_offset(unsigned int symndx, unsigned int got_type,
1223 uint64_t addend = 0) const
1224 { return this->do_local_has_got_offset(symndx, got_type, addend); }
1226 // Return the GOT offset of the GOT entry with type GOT_TYPE for the
1227 // local symbol SYMNDX with given ADDEND. It is an error to call
1228 // this function if the symbol does not have such a GOT entry.
1229 unsigned int
1230 local_got_offset(unsigned int symndx, unsigned int got_type,
1231 uint64_t addend = 0) const
1232 { return this->do_local_got_offset(symndx, got_type, addend); }
1234 // Set the GOT offset for a GOT entry with type GOT_TYPE for the
1235 // local symbol SYMNDX with ADDEND to GOT_OFFSET. Create such an
1236 // entry if none exists.
1237 void
1238 set_local_got_offset(unsigned int symndx, unsigned int got_type,
1239 unsigned int got_offset, uint64_t addend = 0)
1240 { this->do_set_local_got_offset(symndx, got_type, got_offset, addend); }
1242 // Return whether the local symbol SYMNDX is a TLS symbol.
1243 bool
1244 local_is_tls(unsigned int symndx) const
1245 { return this->do_local_is_tls(symndx); }
1247 // The number of local symbols in the input symbol table.
1248 virtual unsigned int
1249 local_symbol_count() const
1250 { return this->do_local_symbol_count(); }
1252 // The number of local symbols in the output symbol table.
1253 virtual unsigned int
1254 output_local_symbol_count() const
1255 { return this->do_output_local_symbol_count(); }
1257 // The file offset for local symbols in the output symbol table.
1258 virtual off_t
1259 local_symbol_offset() const
1260 { return this->do_local_symbol_offset(); }
1262 // Initial local symbol processing: count the number of local symbols
1263 // in the output symbol table and dynamic symbol table; add local symbol
1264 // names to *POOL and *DYNPOOL.
1265 void
1266 count_local_symbols(Stringpool_template<char>* pool,
1267 Stringpool_template<char>* dynpool)
1268 { return this->do_count_local_symbols(pool, dynpool); }
1270 // Set the values of the local symbols, set the output symbol table
1271 // indexes for the local variables, and set the offset where local
1272 // symbol information will be stored. Returns the new local symbol index.
1273 unsigned int
1274 finalize_local_symbols(unsigned int index, off_t off, Symbol_table* symtab)
1275 { return this->do_finalize_local_symbols(index, off, symtab); }
1277 // Set the output dynamic symbol table indexes for the local variables.
1278 unsigned int
1279 set_local_dynsym_indexes(unsigned int index)
1280 { return this->do_set_local_dynsym_indexes(index); }
1282 // Set the offset where local dynamic symbol information will be stored.
1283 unsigned int
1284 set_local_dynsym_offset(off_t off)
1285 { return this->do_set_local_dynsym_offset(off); }
1287 // Record a dynamic relocation against an input section from this object.
1288 void
1289 add_dyn_reloc(unsigned int index)
1291 if (this->dyn_reloc_count_ == 0)
1292 this->first_dyn_reloc_ = index;
1293 ++this->dyn_reloc_count_;
1296 // Return the index of the first dynamic relocation.
1297 unsigned int
1298 first_dyn_reloc() const
1299 { return this->first_dyn_reloc_; }
1301 // Return the count of dynamic relocations.
1302 unsigned int
1303 dyn_reloc_count() const
1304 { return this->dyn_reloc_count_; }
1306 // Relocate the input sections and write out the local symbols.
1307 void
1308 relocate(const Symbol_table* symtab, const Layout* layout, Output_file* of)
1309 { return this->do_relocate(symtab, layout, of); }
1311 // Return whether an input section is being included in the link.
1312 bool
1313 is_section_included(unsigned int shndx) const
1315 gold_assert(shndx < this->output_sections_.size());
1316 return this->output_sections_[shndx] != NULL;
1319 // The output section of the input section with index SHNDX.
1320 // This is only used currently to remove a section from the link in
1321 // relaxation.
1322 void
1323 set_output_section(unsigned int shndx, Output_section* os)
1325 gold_assert(shndx < this->output_sections_.size());
1326 this->output_sections_[shndx] = os;
1329 // Set the offset of an input section within its output section.
1330 void
1331 set_section_offset(unsigned int shndx, uint64_t off)
1332 { this->do_set_section_offset(shndx, off); }
1334 // Return true if we need to wait for output sections to be written
1335 // before we can apply relocations. This is true if the object has
1336 // any relocations for sections which require special handling, such
1337 // as the exception frame section.
1338 bool
1339 relocs_must_follow_section_writes() const
1340 { return this->relocs_must_follow_section_writes_; }
1342 Object_merge_map*
1343 get_or_create_merge_map();
1345 template<int size>
1346 void
1347 initialize_input_to_output_map(unsigned int shndx,
1348 typename elfcpp::Elf_types<size>::Elf_Addr starting_address,
1349 Unordered_map<section_offset_type,
1350 typename elfcpp::Elf_types<size>::Elf_Addr>* output_address) const;
1352 void
1353 add_merge_mapping(Output_section_data *output_data,
1354 unsigned int shndx, section_offset_type offset,
1355 section_size_type length,
1356 section_offset_type output_offset);
1358 bool
1359 merge_output_offset(unsigned int shndx, section_offset_type offset,
1360 section_offset_type *poutput) const;
1362 const Output_section_data*
1363 find_merge_section(unsigned int shndx) const;
1365 // Record the relocatable reloc info for an input reloc section.
1366 void
1367 set_relocatable_relocs(unsigned int reloc_shndx, Relocatable_relocs* rr)
1369 gold_assert(reloc_shndx < this->shnum());
1370 (*this->map_to_relocatable_relocs_)[reloc_shndx] = rr;
1373 // Get the relocatable reloc info for an input reloc section.
1374 Relocatable_relocs*
1375 relocatable_relocs(unsigned int reloc_shndx)
1377 gold_assert(reloc_shndx < this->shnum());
1378 return (*this->map_to_relocatable_relocs_)[reloc_shndx];
1381 // Layout sections whose layout was deferred while waiting for
1382 // input files from a plugin.
1383 void
1384 layout_deferred_sections(Layout* layout)
1385 { this->do_layout_deferred_sections(layout); }
1387 // Return the index of the first incremental relocation for symbol SYMNDX.
1388 virtual unsigned int
1389 do_get_incremental_reloc_base(unsigned int symndx) const
1390 { return this->reloc_bases_[symndx]; }
1392 // Return the number of incremental relocations for symbol SYMNDX.
1393 virtual unsigned int
1394 do_get_incremental_reloc_count(unsigned int symndx) const
1395 { return this->reloc_counts_[symndx]; }
1397 // Return the word size of the object file.
1399 elfsize() const
1400 { return this->do_elfsize(); }
1402 // Return TRUE if this is a big-endian object file.
1403 bool
1404 is_big_endian() const
1405 { return this->do_is_big_endian(); }
1407 protected:
1408 // The output section to be used for each input section, indexed by
1409 // the input section number. The output section is NULL if the
1410 // input section is to be discarded.
1411 typedef std::vector<Output_section*> Output_sections;
1413 // Read the relocs--implemented by child class.
1414 virtual void
1415 do_read_relocs(Read_relocs_data*) = 0;
1417 // Process the relocs--implemented by child class.
1418 virtual void
1419 do_gc_process_relocs(Symbol_table*, Layout*, Read_relocs_data*) = 0;
1421 // Scan the relocs--implemented by child class.
1422 virtual void
1423 do_scan_relocs(Symbol_table*, Layout*, Read_relocs_data*) = 0;
1425 // Return the value of a local symbol.
1426 virtual uint64_t
1427 do_local_symbol_value(unsigned int symndx, uint64_t addend) const = 0;
1429 // Return the PLT offset of a local symbol.
1430 virtual unsigned int
1431 do_local_plt_offset(unsigned int symndx) const = 0;
1433 // Return whether a local symbol plus addend has a GOT offset
1434 // of a given type.
1435 virtual bool
1436 do_local_has_got_offset(unsigned int symndx,
1437 unsigned int got_type, uint64_t addend) const = 0;
1439 // Return the GOT offset of a given type of a local symbol plus addend.
1440 virtual unsigned int
1441 do_local_got_offset(unsigned int symndx, unsigned int got_type,
1442 uint64_t addend) const = 0;
1444 // Set the GOT offset with a given type for a local symbol plus addend.
1445 virtual void
1446 do_set_local_got_offset(unsigned int symndx, unsigned int got_type,
1447 unsigned int got_offset, uint64_t addend) = 0;
1449 // Return whether local symbol SYMNDX is a TLS symbol.
1450 virtual bool
1451 do_local_is_tls(unsigned int symndx) const = 0;
1453 // Return the number of local symbols--implemented by child class.
1454 virtual unsigned int
1455 do_local_symbol_count() const = 0;
1457 // Return the number of output local symbols--implemented by child class.
1458 virtual unsigned int
1459 do_output_local_symbol_count() const = 0;
1461 // Return the file offset for local symbols--implemented by child class.
1462 virtual off_t
1463 do_local_symbol_offset() const = 0;
1465 // Count local symbols--implemented by child class.
1466 virtual void
1467 do_count_local_symbols(Stringpool_template<char>*,
1468 Stringpool_template<char>*) = 0;
1470 // Finalize the local symbols. Set the output symbol table indexes
1471 // for the local variables, and set the offset where local symbol
1472 // information will be stored.
1473 virtual unsigned int
1474 do_finalize_local_symbols(unsigned int, off_t, Symbol_table*) = 0;
1476 // Set the output dynamic symbol table indexes for the local variables.
1477 virtual unsigned int
1478 do_set_local_dynsym_indexes(unsigned int) = 0;
1480 // Set the offset where local dynamic symbol information will be stored.
1481 virtual unsigned int
1482 do_set_local_dynsym_offset(off_t) = 0;
1484 // Relocate the input sections and write out the local
1485 // symbols--implemented by child class.
1486 virtual void
1487 do_relocate(const Symbol_table* symtab, const Layout*, Output_file* of) = 0;
1489 // Set the offset of a section--implemented by child class.
1490 virtual void
1491 do_set_section_offset(unsigned int shndx, uint64_t off) = 0;
1493 // Layout sections whose layout was deferred while waiting for
1494 // input files from a plugin--implemented by child class.
1495 virtual void
1496 do_layout_deferred_sections(Layout*) = 0;
1498 // Given a section index, return the corresponding Output_section.
1499 // The return value will be NULL if the section is not included in
1500 // the link.
1501 Output_section*
1502 do_output_section(unsigned int shndx) const
1504 gold_assert(shndx < this->output_sections_.size());
1505 return this->output_sections_[shndx];
1508 // Return the vector mapping input sections to output sections.
1509 Output_sections&
1510 output_sections()
1511 { return this->output_sections_; }
1513 const Output_sections&
1514 output_sections() const
1515 { return this->output_sections_; }
1517 // Set the size of the relocatable relocs array.
1518 void
1519 size_relocatable_relocs()
1521 this->map_to_relocatable_relocs_ =
1522 new std::vector<Relocatable_relocs*>(this->shnum());
1525 // Record that we must wait for the output sections to be written
1526 // before applying relocations.
1527 void
1528 set_relocs_must_follow_section_writes()
1529 { this->relocs_must_follow_section_writes_ = true; }
1531 // Allocate the array for counting incremental relocations.
1532 void
1533 allocate_incremental_reloc_counts()
1535 unsigned int nsyms = this->do_get_global_symbols()->size();
1536 this->reloc_counts_ = new unsigned int[nsyms];
1537 gold_assert(this->reloc_counts_ != NULL);
1538 memset(this->reloc_counts_, 0, nsyms * sizeof(unsigned int));
1541 // Record a relocation in this object referencing global symbol SYMNDX.
1542 // Used for tracking incremental link information.
1543 void
1544 count_incremental_reloc(unsigned int symndx)
1546 unsigned int nsyms = this->do_get_global_symbols()->size();
1547 gold_assert(symndx < nsyms);
1548 gold_assert(this->reloc_counts_ != NULL);
1549 ++this->reloc_counts_[symndx];
1552 // Finalize the incremental relocation information.
1553 void
1554 finalize_incremental_relocs(Layout* layout, bool clear_counts);
1556 // Return the index of the next relocation to be written for global symbol
1557 // SYMNDX. Only valid after finalize_incremental_relocs() has been called.
1558 unsigned int
1559 next_incremental_reloc_index(unsigned int symndx)
1561 unsigned int nsyms = this->do_get_global_symbols()->size();
1563 gold_assert(this->reloc_counts_ != NULL);
1564 gold_assert(this->reloc_bases_ != NULL);
1565 gold_assert(symndx < nsyms);
1567 unsigned int counter = this->reloc_counts_[symndx]++;
1568 return this->reloc_bases_[symndx] + counter;
1571 // Return the word size of the object file--
1572 // implemented by child class.
1573 virtual int
1574 do_elfsize() const = 0;
1576 // Return TRUE if this is a big-endian object file--
1577 // implemented by child class.
1578 virtual bool
1579 do_is_big_endian() const = 0;
1581 private:
1582 // Mapping from input sections to output section.
1583 Output_sections output_sections_;
1584 // Mapping from input section index to the information recorded for
1585 // the relocations. This is only used for a relocatable link.
1586 std::vector<Relocatable_relocs*>* map_to_relocatable_relocs_;
1587 // Mappings for merge sections. This is managed by the code in the
1588 // Merge_map class.
1589 Object_merge_map* object_merge_map_;
1590 // Whether we need to wait for output sections to be written before
1591 // we can apply relocations.
1592 bool relocs_must_follow_section_writes_;
1593 // Used to store the relocs data computed by the Read_relocs pass.
1594 // Used during garbage collection of unused sections.
1595 Read_relocs_data* rd_;
1596 // Used to store the symbols data computed by the Read_symbols pass.
1597 // Again used during garbage collection when laying out referenced
1598 // sections.
1599 gold::Symbols_data* sd_;
1600 // Per-symbol counts of relocations, for incremental links.
1601 unsigned int* reloc_counts_;
1602 // Per-symbol base indexes of relocations, for incremental links.
1603 unsigned int* reloc_bases_;
1604 // Index of the first dynamic relocation for this object.
1605 unsigned int first_dyn_reloc_;
1606 // Count of dynamic relocations for this object.
1607 unsigned int dyn_reloc_count_;
1610 // This class is used to handle relocations against a section symbol
1611 // in an SHF_MERGE section. For such a symbol, we need to know the
1612 // addend of the relocation before we can determine the final value.
1613 // The addend gives us the location in the input section, and we can
1614 // determine how it is mapped to the output section. For a
1615 // non-section symbol, we apply the addend to the final value of the
1616 // symbol; that is done in finalize_local_symbols, and does not use
1617 // this class.
1619 template<int size>
1620 class Merged_symbol_value
1622 public:
1623 typedef typename elfcpp::Elf_types<size>::Elf_Addr Value;
1625 // We use a hash table to map offsets in the input section to output
1626 // addresses.
1627 typedef Unordered_map<section_offset_type, Value> Output_addresses;
1629 Merged_symbol_value(Value input_value, Value output_start_address)
1630 : input_value_(input_value), output_start_address_(output_start_address),
1631 output_addresses_()
1634 // Initialize the hash table.
1635 void
1636 initialize_input_to_output_map(const Relobj*, unsigned int input_shndx);
1638 // Release the hash table to save space.
1639 void
1640 free_input_to_output_map()
1641 { this->output_addresses_.clear(); }
1643 // Get the output value corresponding to an addend. The object and
1644 // input section index are passed in because the caller will have
1645 // them; otherwise we could store them here.
1646 Value
1647 value(const Relobj* object, unsigned int input_shndx, Value addend) const
1649 // This is a relocation against a section symbol. ADDEND is the
1650 // offset in the section. The result should be the start of some
1651 // merge area. If the object file wants something else, it should
1652 // use a regular symbol rather than a section symbol.
1653 // Unfortunately, PR 6658 shows a case in which the object file
1654 // refers to the section symbol, but uses a negative ADDEND to
1655 // compensate for a PC relative reloc. We can't handle the
1656 // general case. However, we can handle the special case of a
1657 // negative addend, by assuming that it refers to the start of the
1658 // section. Of course, that means that we have to guess when
1659 // ADDEND is negative. It is normal to see a 32-bit value here
1660 // even when the template parameter size is 64, as 64-bit object
1661 // file formats have 32-bit relocations. We know this is a merge
1662 // section, so we know it has to fit into memory. So we assume
1663 // that we won't see a value larger than a large 32-bit unsigned
1664 // value. This will break objects with very very large merge
1665 // sections; they probably break in other ways anyhow.
1666 Value input_offset = this->input_value_;
1667 if (addend < 0xffffff00)
1669 input_offset += addend;
1670 addend = 0;
1672 typename Output_addresses::const_iterator p =
1673 this->output_addresses_.find(input_offset);
1674 if (p != this->output_addresses_.end())
1675 return p->second + addend;
1677 return (this->value_from_output_section(object, input_shndx, input_offset)
1678 + addend);
1681 private:
1682 // Get the output value for an input offset if we couldn't find it
1683 // in the hash table.
1684 Value
1685 value_from_output_section(const Relobj*, unsigned int input_shndx,
1686 Value input_offset) const;
1688 // The value of the section symbol in the input file. This is
1689 // normally zero, but could in principle be something else.
1690 Value input_value_;
1691 // The start address of this merged section in the output file.
1692 Value output_start_address_;
1693 // A hash table which maps offsets in the input section to output
1694 // addresses. This only maps specific offsets, not all offsets.
1695 Output_addresses output_addresses_;
1698 // This POD class is holds the value of a symbol. This is used for
1699 // local symbols, and for all symbols during relocation processing.
1700 // For special sections, such as SHF_MERGE sections, this calls a
1701 // function to get the final symbol value.
1703 template<int size>
1704 class Symbol_value
1706 public:
1707 typedef typename elfcpp::Elf_types<size>::Elf_Addr Value;
1709 Symbol_value()
1710 : output_symtab_index_(0), output_dynsym_index_(-1U), input_shndx_(0),
1711 is_ordinary_shndx_(false), is_section_symbol_(false),
1712 is_tls_symbol_(false), is_ifunc_symbol_(false), has_output_value_(true)
1713 { this->u_.value = 0; }
1715 ~Symbol_value()
1717 if (!this->has_output_value_)
1718 delete this->u_.merged_symbol_value;
1721 // Get the value of this symbol. OBJECT is the object in which this
1722 // symbol is defined, and ADDEND is an addend to add to the value.
1723 template<bool big_endian>
1724 Value
1725 value(const Sized_relobj_file<size, big_endian>* object, Value addend) const
1727 if (this->has_output_value_)
1728 return this->u_.value + addend;
1729 else
1731 gold_assert(this->is_ordinary_shndx_);
1732 return this->u_.merged_symbol_value->value(object, this->input_shndx_,
1733 addend);
1737 // Set the value of this symbol in the output symbol table.
1738 void
1739 set_output_value(Value value)
1740 { this->u_.value = value; }
1742 // For a section symbol in a merged section, we need more
1743 // information.
1744 void
1745 set_merged_symbol_value(Merged_symbol_value<size>* msv)
1747 gold_assert(this->is_section_symbol_);
1748 this->has_output_value_ = false;
1749 this->u_.merged_symbol_value = msv;
1752 // Initialize the input to output map for a section symbol in a
1753 // merged section. We also initialize the value of a non-section
1754 // symbol in a merged section.
1755 void
1756 initialize_input_to_output_map(const Relobj* object)
1758 if (!this->has_output_value_)
1760 gold_assert(this->is_section_symbol_ && this->is_ordinary_shndx_);
1761 Merged_symbol_value<size>* msv = this->u_.merged_symbol_value;
1762 msv->initialize_input_to_output_map(object, this->input_shndx_);
1766 // Free the input to output map for a section symbol in a merged
1767 // section.
1768 void
1769 free_input_to_output_map()
1771 if (!this->has_output_value_)
1772 this->u_.merged_symbol_value->free_input_to_output_map();
1775 // Set the value of the symbol from the input file. This is only
1776 // called by count_local_symbols, to communicate the value to
1777 // finalize_local_symbols.
1778 void
1779 set_input_value(Value value)
1780 { this->u_.value = value; }
1782 // Return the input value. This is only called by
1783 // finalize_local_symbols and (in special cases) relocate_section.
1784 Value
1785 input_value() const
1786 { return this->u_.value; }
1788 // Return whether we have set the index in the output symbol table
1789 // yet.
1790 bool
1791 is_output_symtab_index_set() const
1793 return (this->output_symtab_index_ != 0
1794 && this->output_symtab_index_ != -2U);
1797 // Return whether this symbol may be discarded from the normal
1798 // symbol table.
1799 bool
1800 may_be_discarded_from_output_symtab() const
1802 gold_assert(!this->is_output_symtab_index_set());
1803 return this->output_symtab_index_ != -2U;
1806 // Return whether this symbol has an entry in the output symbol
1807 // table.
1808 bool
1809 has_output_symtab_entry() const
1811 gold_assert(this->is_output_symtab_index_set());
1812 return this->output_symtab_index_ != -1U;
1815 // Return the index in the output symbol table.
1816 unsigned int
1817 output_symtab_index() const
1819 gold_assert(this->is_output_symtab_index_set()
1820 && this->output_symtab_index_ != -1U);
1821 return this->output_symtab_index_;
1824 // Set the index in the output symbol table.
1825 void
1826 set_output_symtab_index(unsigned int i)
1828 gold_assert(!this->is_output_symtab_index_set());
1829 gold_assert(i != 0 && i != -1U && i != -2U);
1830 this->output_symtab_index_ = i;
1833 // Record that this symbol should not go into the output symbol
1834 // table.
1835 void
1836 set_no_output_symtab_entry()
1838 gold_assert(this->output_symtab_index_ == 0);
1839 this->output_symtab_index_ = -1U;
1842 // Record that this symbol must go into the output symbol table,
1843 // because it there is a relocation that uses it.
1844 void
1845 set_must_have_output_symtab_entry()
1847 gold_assert(!this->is_output_symtab_index_set());
1848 this->output_symtab_index_ = -2U;
1851 // Set the index in the output dynamic symbol table.
1852 void
1853 set_needs_output_dynsym_entry()
1855 gold_assert(!this->is_section_symbol());
1856 this->output_dynsym_index_ = 0;
1859 // Return whether this symbol should go into the dynamic symbol
1860 // table.
1861 bool
1862 needs_output_dynsym_entry() const
1864 return this->output_dynsym_index_ != -1U;
1867 // Return whether this symbol has an entry in the dynamic symbol
1868 // table.
1869 bool
1870 has_output_dynsym_entry() const
1872 gold_assert(this->output_dynsym_index_ != 0);
1873 return this->output_dynsym_index_ != -1U;
1876 // Record that this symbol should go into the dynamic symbol table.
1877 void
1878 set_output_dynsym_index(unsigned int i)
1880 gold_assert(this->output_dynsym_index_ == 0);
1881 gold_assert(i != 0 && i != -1U);
1882 this->output_dynsym_index_ = i;
1885 // Return the index in the output dynamic symbol table.
1886 unsigned int
1887 output_dynsym_index() const
1889 gold_assert(this->output_dynsym_index_ != 0
1890 && this->output_dynsym_index_ != -1U);
1891 return this->output_dynsym_index_;
1894 // Set the index of the input section in the input file.
1895 void
1896 set_input_shndx(unsigned int i, bool is_ordinary)
1898 this->input_shndx_ = i;
1899 // input_shndx_ field is a bitfield, so make sure that the value
1900 // fits.
1901 gold_assert(this->input_shndx_ == i);
1902 this->is_ordinary_shndx_ = is_ordinary;
1905 // Return the index of the input section in the input file.
1906 unsigned int
1907 input_shndx(bool* is_ordinary) const
1909 *is_ordinary = this->is_ordinary_shndx_;
1910 return this->input_shndx_;
1913 // Whether this is a section symbol.
1914 bool
1915 is_section_symbol() const
1916 { return this->is_section_symbol_; }
1918 // Record that this is a section symbol.
1919 void
1920 set_is_section_symbol()
1922 gold_assert(!this->needs_output_dynsym_entry());
1923 this->is_section_symbol_ = true;
1926 // Record that this is a TLS symbol.
1927 void
1928 set_is_tls_symbol()
1929 { this->is_tls_symbol_ = true; }
1931 // Return true if this is a TLS symbol.
1932 bool
1933 is_tls_symbol() const
1934 { return this->is_tls_symbol_; }
1936 // Record that this is an IFUNC symbol.
1937 void
1938 set_is_ifunc_symbol()
1939 { this->is_ifunc_symbol_ = true; }
1941 // Return true if this is an IFUNC symbol.
1942 bool
1943 is_ifunc_symbol() const
1944 { return this->is_ifunc_symbol_; }
1946 // Return true if this has output value.
1947 bool
1948 has_output_value() const
1949 { return this->has_output_value_; }
1951 private:
1952 // The index of this local symbol in the output symbol table. This
1953 // will be 0 if no value has been assigned yet, and the symbol may
1954 // be omitted. This will be -1U if the symbol should not go into
1955 // the symbol table. This will be -2U if the symbol must go into
1956 // the symbol table, but no index has been assigned yet.
1957 unsigned int output_symtab_index_;
1958 // The index of this local symbol in the dynamic symbol table. This
1959 // will be -1U if the symbol should not go into the symbol table.
1960 unsigned int output_dynsym_index_;
1961 // The section index in the input file in which this symbol is
1962 // defined.
1963 unsigned int input_shndx_ : 27;
1964 // Whether the section index is an ordinary index, not a special
1965 // value.
1966 bool is_ordinary_shndx_ : 1;
1967 // Whether this is a STT_SECTION symbol.
1968 bool is_section_symbol_ : 1;
1969 // Whether this is a STT_TLS symbol.
1970 bool is_tls_symbol_ : 1;
1971 // Whether this is a STT_GNU_IFUNC symbol.
1972 bool is_ifunc_symbol_ : 1;
1973 // Whether this symbol has a value for the output file. This is
1974 // normally set to true during Layout::finalize, by
1975 // finalize_local_symbols. It will be false for a section symbol in
1976 // a merge section, as for such symbols we can not determine the
1977 // value to use in a relocation until we see the addend.
1978 bool has_output_value_ : 1;
1979 union
1981 // This is used if has_output_value_ is true. Between
1982 // count_local_symbols and finalize_local_symbols, this is the
1983 // value in the input file. After finalize_local_symbols, it is
1984 // the value in the output file.
1985 Value value;
1986 // This is used if has_output_value_ is false. It points to the
1987 // information we need to get the value for a merge section.
1988 Merged_symbol_value<size>* merged_symbol_value;
1989 } u_;
1992 // This type is used to modify relocations for -fsplit-stack. It is
1993 // indexed by relocation index, and means that the relocation at that
1994 // index should use the symbol from the vector, rather than the one
1995 // indicated by the relocation.
1997 class Reloc_symbol_changes
1999 public:
2000 Reloc_symbol_changes(size_t count)
2001 : vec_(count, NULL)
2004 void
2005 set(size_t i, Symbol* sym)
2006 { this->vec_[i] = sym; }
2008 const Symbol*
2009 operator[](size_t i) const
2010 { return this->vec_[i]; }
2012 private:
2013 std::vector<Symbol*> vec_;
2016 // Abstract base class for a regular object file, either a real object file
2017 // or an incremental (unchanged) object. This is size and endian specific.
2019 template<int size, bool big_endian>
2020 class Sized_relobj : public Relobj
2022 public:
2023 typedef typename elfcpp::Elf_types<size>::Elf_Addr Address;
2024 typedef Relobj::Symbols Symbols;
2026 static const Address invalid_address = static_cast<Address>(0) - 1;
2028 Sized_relobj(const std::string& name, Input_file* input_file)
2029 : Relobj(name, input_file), local_got_offsets_(), section_offsets_()
2032 Sized_relobj(const std::string& name, Input_file* input_file,
2033 off_t offset)
2034 : Relobj(name, input_file, offset), local_got_offsets_(), section_offsets_()
2037 ~Sized_relobj()
2040 // If this is a regular object, return a pointer to the Sized_relobj_file
2041 // object. Otherwise, return NULL.
2042 virtual Sized_relobj_file<size, big_endian>*
2043 sized_relobj()
2044 { return NULL; }
2046 const virtual Sized_relobj_file<size, big_endian>*
2047 sized_relobj() const
2048 { return NULL; }
2050 // Checks if the offset of input section SHNDX within its output
2051 // section is invalid.
2052 bool
2053 is_output_section_offset_invalid(unsigned int shndx) const
2054 { return this->get_output_section_offset(shndx) == invalid_address; }
2056 // Get the offset of input section SHNDX within its output section.
2057 // This is -1 if the input section requires a special mapping, such
2058 // as a merge section. The output section can be found in the
2059 // output_sections_ field of the parent class Relobj.
2060 Address
2061 get_output_section_offset(unsigned int shndx) const
2063 gold_assert(shndx < this->section_offsets_.size());
2064 return this->section_offsets_[shndx];
2067 // Iterate over local symbols, calling a visitor class V for each GOT offset
2068 // associated with a local symbol.
2069 void
2070 do_for_all_local_got_entries(Got_offset_list::Visitor* v) const;
2072 protected:
2073 typedef Relobj::Output_sections Output_sections;
2075 // Clear the local symbol information.
2076 void
2077 clear_got_offsets()
2078 { this->local_got_offsets_.clear(); }
2080 // Return the vector of section offsets.
2081 std::vector<Address>&
2082 section_offsets()
2083 { return this->section_offsets_; }
2085 // Get the address of an output section.
2086 uint64_t
2087 do_output_section_address(unsigned int shndx);
2089 // Get the offset of a section.
2090 uint64_t
2091 do_output_section_offset(unsigned int shndx) const
2093 Address off = this->get_output_section_offset(shndx);
2094 if (off == invalid_address)
2095 return -1ULL;
2096 return off;
2099 // Set the offset of a section.
2100 void
2101 do_set_section_offset(unsigned int shndx, uint64_t off)
2103 gold_assert(shndx < this->section_offsets_.size());
2104 this->section_offsets_[shndx] =
2105 (off == static_cast<uint64_t>(-1)
2106 ? invalid_address
2107 : convert_types<Address, uint64_t>(off));
2110 // Return whether the local symbol SYMNDX plus ADDEND has a GOT offset
2111 // of type GOT_TYPE.
2112 bool
2113 do_local_has_got_offset(unsigned int symndx, unsigned int got_type,
2114 uint64_t addend) const
2116 Local_got_entry_key key(symndx);
2117 Local_got_offsets::const_iterator p =
2118 this->local_got_offsets_.find(key);
2119 return (p != this->local_got_offsets_.end()
2120 && p->second->get_offset(got_type, addend) != -1U);
2123 // Return the GOT offset of type GOT_TYPE of the local symbol
2124 // SYMNDX plus ADDEND.
2125 unsigned int
2126 do_local_got_offset(unsigned int symndx, unsigned int got_type,
2127 uint64_t addend) const
2129 Local_got_entry_key key(symndx);
2130 Local_got_offsets::const_iterator p =
2131 this->local_got_offsets_.find(key);
2132 gold_assert(p != this->local_got_offsets_.end());
2133 unsigned int off = p->second->get_offset(got_type, addend);
2134 gold_assert(off != -1U);
2135 return off;
2138 // Set the GOT offset with type GOT_TYPE of the local symbol SYMNDX
2139 // plus ADDEND to GOT_OFFSET.
2140 void
2141 do_set_local_got_offset(unsigned int symndx, unsigned int got_type,
2142 unsigned int got_offset, uint64_t addend)
2144 Local_got_entry_key key(symndx);
2145 Local_got_offsets::const_iterator p =
2146 this->local_got_offsets_.find(key);
2147 if (p != this->local_got_offsets_.end())
2148 p->second->set_offset(got_type, got_offset, addend);
2149 else
2151 Got_offset_list* g = new Got_offset_list(got_type, got_offset, addend);
2152 std::pair<Local_got_offsets::iterator, bool> ins =
2153 this->local_got_offsets_.insert(std::make_pair(key, g));
2154 gold_assert(ins.second);
2158 // Return the word size of the object file.
2159 virtual int
2160 do_elfsize() const
2161 { return size; }
2163 // Return TRUE if this is a big-endian object file.
2164 virtual bool
2165 do_is_big_endian() const
2166 { return big_endian; }
2168 private:
2169 // The GOT offsets of local symbols. This map also stores GOT offsets
2170 // for tp-relative offsets for TLS symbols.
2171 typedef Unordered_map<Local_got_entry_key, Got_offset_list*,
2172 Local_got_entry_key::hash,
2173 Local_got_entry_key::equal_to> Local_got_offsets;
2175 // GOT offsets for local non-TLS symbols, and tp-relative offsets
2176 // for TLS symbols, indexed by local got entry key class.
2177 Local_got_offsets local_got_offsets_;
2178 // For each input section, the offset of the input section in its
2179 // output section. This is INVALID_ADDRESS if the input section requires a
2180 // special mapping.
2181 std::vector<Address> section_offsets_;
2184 // A regular object file. This is size and endian specific.
2186 template<int size, bool big_endian>
2187 class Sized_relobj_file : public Sized_relobj<size, big_endian>
2189 public:
2190 typedef typename elfcpp::Elf_types<size>::Elf_Addr Address;
2191 typedef typename Sized_relobj<size, big_endian>::Symbols Symbols;
2192 typedef std::vector<Symbol_value<size> > Local_values;
2194 static const Address invalid_address = static_cast<Address>(0) - 1;
2196 enum Compute_final_local_value_status
2198 // No error.
2199 CFLV_OK,
2200 // An error occurred.
2201 CFLV_ERROR,
2202 // The local symbol has no output section.
2203 CFLV_DISCARDED
2206 Sized_relobj_file(const std::string& name,
2207 Input_file* input_file,
2208 off_t offset,
2209 const typename elfcpp::Ehdr<size, big_endian>&);
2211 ~Sized_relobj_file();
2213 // Set up the object file based on TARGET.
2214 void
2215 setup()
2216 { this->do_setup(); }
2218 // Return a pointer to the Sized_relobj_file object.
2219 Sized_relobj_file<size, big_endian>*
2220 sized_relobj()
2221 { return this; }
2223 const Sized_relobj_file<size, big_endian>*
2224 sized_relobj() const
2225 { return this; }
2227 // Return the ELF file type.
2229 e_type() const
2230 { return this->e_type_; }
2232 // Return the EI_OSABI.
2233 const Osabi&
2234 osabi() const
2235 { return this->osabi_; }
2237 // Return the number of symbols. This is only valid after
2238 // Object::add_symbols has been called.
2239 unsigned int
2240 symbol_count() const
2241 { return this->local_symbol_count_ + this->symbols_.size(); }
2243 // If SYM is the index of a global symbol in the object file's
2244 // symbol table, return the Symbol object. Otherwise, return NULL.
2245 Symbol*
2246 global_symbol(unsigned int sym) const
2248 if (sym >= this->local_symbol_count_)
2250 gold_assert(sym - this->local_symbol_count_ < this->symbols_.size());
2251 return this->symbols_[sym - this->local_symbol_count_];
2253 return NULL;
2256 // Return the section index of symbol SYM. Set *VALUE to its value
2257 // in the object file. Set *IS_ORDINARY if this is an ordinary
2258 // section index, not a special code between SHN_LORESERVE and
2259 // SHN_HIRESERVE. Note that for a symbol which is not defined in
2260 // this object file, this will set *VALUE to 0 and return SHN_UNDEF;
2261 // it will not return the final value of the symbol in the link.
2262 unsigned int
2263 symbol_section_and_value(unsigned int sym, Address* value, bool* is_ordinary);
2265 // Return a pointer to the Symbol_value structure which holds the
2266 // value of a local symbol.
2267 const Symbol_value<size>*
2268 local_symbol(unsigned int sym) const
2270 gold_assert(sym < this->local_values_.size());
2271 return &this->local_values_[sym];
2274 // Return the index of local symbol SYM in the ordinary symbol
2275 // table. A value of -1U means that the symbol is not being output.
2276 unsigned int
2277 symtab_index(unsigned int sym) const
2279 gold_assert(sym < this->local_values_.size());
2280 return this->local_values_[sym].output_symtab_index();
2283 // Return the index of local symbol SYM in the dynamic symbol
2284 // table. A value of -1U means that the symbol is not being output.
2285 unsigned int
2286 dynsym_index(unsigned int sym) const
2288 gold_assert(sym < this->local_values_.size());
2289 return this->local_values_[sym].output_dynsym_index();
2292 // Return the input section index of local symbol SYM.
2293 unsigned int
2294 local_symbol_input_shndx(unsigned int sym, bool* is_ordinary) const
2296 gold_assert(sym < this->local_values_.size());
2297 return this->local_values_[sym].input_shndx(is_ordinary);
2300 // Record that local symbol SYM must be in the output symbol table.
2301 void
2302 set_must_have_output_symtab_entry(unsigned int sym)
2304 gold_assert(sym < this->local_values_.size());
2305 this->local_values_[sym].set_must_have_output_symtab_entry();
2308 // Record that local symbol SYM needs a dynamic symbol entry.
2309 void
2310 set_needs_output_dynsym_entry(unsigned int sym)
2312 gold_assert(sym < this->local_values_.size());
2313 this->local_values_[sym].set_needs_output_dynsym_entry();
2316 // Return whether the local symbol SYMNDX has a PLT offset.
2317 bool
2318 local_has_plt_offset(unsigned int symndx) const;
2320 // Set the PLT offset of the local symbol SYMNDX.
2321 void
2322 set_local_plt_offset(unsigned int symndx, unsigned int plt_offset);
2324 // Adjust this local symbol value. Return false if the symbol
2325 // should be discarded from the output file.
2326 bool
2327 adjust_local_symbol(Symbol_value<size>* lv) const
2328 { return this->do_adjust_local_symbol(lv); }
2330 // Return the name of the symbol that spans the given offset in the
2331 // specified section in this object. This is used only for error
2332 // messages and is not particularly efficient.
2333 bool
2334 get_symbol_location_info(unsigned int shndx, off_t offset,
2335 Symbol_location_info* info);
2337 // Look for a kept section corresponding to the given discarded section,
2338 // and return its output address. This is used only for relocations in
2339 // debugging sections.
2340 Address
2341 map_to_kept_section(unsigned int shndx, std::string& section_name,
2342 bool* found) const;
2344 // Look for a kept section corresponding to the given discarded section,
2345 // and return its object file.
2346 Relobj*
2347 find_kept_section_object(unsigned int shndx, unsigned int* symndx_p) const;
2349 // Return the name of symbol SYMNDX.
2350 const char*
2351 get_symbol_name(unsigned int symndx);
2353 // Compute final local symbol value. R_SYM is the local symbol index.
2354 // LV_IN points to a local symbol value containing the input value.
2355 // LV_OUT points to a local symbol value storing the final output value,
2356 // which must not be a merged symbol value since before calling this
2357 // method to avoid memory leak. SYMTAB points to a symbol table.
2359 // The method returns a status code at return. If the return status is
2360 // CFLV_OK, *LV_OUT contains the final value. If the return status is
2361 // CFLV_ERROR, *LV_OUT is 0. If the return status is CFLV_DISCARDED,
2362 // *LV_OUT is not modified.
2363 Compute_final_local_value_status
2364 compute_final_local_value(unsigned int r_sym,
2365 const Symbol_value<size>* lv_in,
2366 Symbol_value<size>* lv_out,
2367 const Symbol_table* symtab);
2369 // Return true if the layout for this object was deferred.
2370 bool is_deferred_layout() const
2371 { return this->is_deferred_layout_; }
2373 protected:
2374 typedef typename Sized_relobj<size, big_endian>::Output_sections
2375 Output_sections;
2377 // Set up.
2378 virtual void
2379 do_setup();
2381 // Read the symbols.
2382 void
2383 do_read_symbols(Read_symbols_data*);
2385 // Read the symbols. This is common code for all target-specific
2386 // overrides of do_read_symbols.
2387 void
2388 base_read_symbols(Read_symbols_data*);
2390 // Return the value of a local symbol.
2391 uint64_t
2392 do_local_symbol_value(unsigned int symndx, uint64_t addend) const
2394 const Symbol_value<size>* symval = this->local_symbol(symndx);
2395 return symval->value(this, addend);
2398 // Return the PLT offset for a local symbol. It is an error to call
2399 // this if it doesn't have one.
2400 unsigned int
2401 do_local_plt_offset(unsigned int symndx) const;
2403 // Return whether local symbol SYMNDX is a TLS symbol.
2404 bool
2405 do_local_is_tls(unsigned int symndx) const
2406 { return this->local_symbol(symndx)->is_tls_symbol(); }
2408 // Return the number of local symbols.
2409 unsigned int
2410 do_local_symbol_count() const
2411 { return this->local_symbol_count_; }
2413 // Return the number of local symbols in the output symbol table.
2414 unsigned int
2415 do_output_local_symbol_count() const
2416 { return this->output_local_symbol_count_; }
2418 // Return the number of local symbols in the output symbol table.
2419 off_t
2420 do_local_symbol_offset() const
2421 { return this->local_symbol_offset_; }
2423 // Lay out the input sections.
2424 void
2425 do_layout(Symbol_table*, Layout*, Read_symbols_data*);
2427 // Layout sections whose layout was deferred while waiting for
2428 // input files from a plugin.
2429 void
2430 do_layout_deferred_sections(Layout*);
2432 // Add the symbols to the symbol table.
2433 void
2434 do_add_symbols(Symbol_table*, Read_symbols_data*, Layout*);
2436 Archive::Should_include
2437 do_should_include_member(Symbol_table* symtab, Layout*, Read_symbols_data*,
2438 std::string* why);
2440 // Iterate over global symbols, calling a visitor class V for each.
2441 void
2442 do_for_all_global_symbols(Read_symbols_data* sd,
2443 Library_base::Symbol_visitor_base* v);
2445 // Read the relocs.
2446 void
2447 do_read_relocs(Read_relocs_data*);
2449 // Process the relocs to find list of referenced sections. Used only
2450 // during garbage collection.
2451 void
2452 do_gc_process_relocs(Symbol_table*, Layout*, Read_relocs_data*);
2454 // Scan the relocs and adjust the symbol table.
2455 void
2456 do_scan_relocs(Symbol_table*, Layout*, Read_relocs_data*);
2458 // Count the local symbols.
2459 void
2460 do_count_local_symbols(Stringpool_template<char>*,
2461 Stringpool_template<char>*);
2463 // Finalize the local symbols.
2464 unsigned int
2465 do_finalize_local_symbols(unsigned int, off_t, Symbol_table*);
2467 // Set the offset where local dynamic symbol information will be stored.
2468 unsigned int
2469 do_set_local_dynsym_indexes(unsigned int);
2471 // Set the offset where local dynamic symbol information will be stored.
2472 unsigned int
2473 do_set_local_dynsym_offset(off_t);
2475 // Relocate the input sections and write out the local symbols.
2476 void
2477 do_relocate(const Symbol_table* symtab, const Layout*, Output_file* of);
2479 // Get the size of a section.
2480 uint64_t
2481 do_section_size(unsigned int shndx)
2482 { return this->elf_file_.section_size(shndx); }
2484 // Get the name of a section.
2485 std::string
2486 do_section_name(unsigned int shndx) const
2487 { return this->elf_file_.section_name(shndx); }
2489 // Return the location of the contents of a section.
2490 const unsigned char*
2491 do_section_contents(unsigned int shndx, section_size_type* plen,
2492 bool cache)
2494 Object::Location loc(this->elf_file_.section_contents(shndx));
2495 *plen = convert_to_section_size_type(loc.data_size);
2496 if (*plen == 0)
2498 static const unsigned char empty[1] = { '\0' };
2499 return empty;
2501 return this->get_view(loc.file_offset, *plen, true, cache);
2504 // Return section flags.
2505 uint64_t
2506 do_section_flags(unsigned int shndx);
2508 // Return section entsize.
2509 uint64_t
2510 do_section_entsize(unsigned int shndx);
2512 // Return section address.
2513 uint64_t
2514 do_section_address(unsigned int shndx)
2515 { return this->elf_file_.section_addr(shndx); }
2517 // Return section type.
2518 unsigned int
2519 do_section_type(unsigned int shndx)
2520 { return this->elf_file_.section_type(shndx); }
2522 // Return the section link field.
2523 unsigned int
2524 do_section_link(unsigned int shndx)
2525 { return this->elf_file_.section_link(shndx); }
2527 // Return the section info field.
2528 unsigned int
2529 do_section_info(unsigned int shndx)
2530 { return this->elf_file_.section_info(shndx); }
2532 // Return the section alignment.
2533 uint64_t
2534 do_section_addralign(unsigned int shndx)
2535 { return this->elf_file_.section_addralign(shndx); }
2537 // Return the Xindex structure to use.
2538 Xindex*
2539 do_initialize_xindex();
2541 // Get symbol counts.
2542 void
2543 do_get_global_symbol_counts(const Symbol_table*, size_t*, size_t*) const;
2545 // Get the global symbols.
2546 const Symbols*
2547 do_get_global_symbols() const
2548 { return &this->symbols_; }
2550 // Adjust a section index if necessary.
2551 unsigned int
2552 adjust_shndx(unsigned int shndx)
2554 if (shndx >= elfcpp::SHN_LORESERVE)
2555 shndx += this->elf_file_.large_shndx_offset();
2556 return shndx;
2559 // Initialize input to output maps for section symbols in merged
2560 // sections.
2561 void
2562 initialize_input_to_output_maps();
2564 // Free the input to output maps for section symbols in merged
2565 // sections.
2566 void
2567 free_input_to_output_maps();
2569 // Return symbol table section index.
2570 unsigned int
2571 symtab_shndx() const
2572 { return this->symtab_shndx_; }
2574 // Allow a child class to access the ELF file.
2575 elfcpp::Elf_file<size, big_endian, Object>*
2576 elf_file()
2577 { return &this->elf_file_; }
2579 // Allow a child class to access the local values.
2580 Local_values*
2581 local_values()
2582 { return &this->local_values_; }
2584 // Views and sizes when relocating.
2585 struct View_size
2587 unsigned char* view;
2588 typename elfcpp::Elf_types<size>::Elf_Addr address;
2589 off_t offset;
2590 section_size_type view_size;
2591 bool is_input_output_view;
2592 bool is_postprocessing_view;
2593 bool is_ctors_reverse_view;
2596 typedef std::vector<View_size> Views;
2598 // Stash away info for a number of special sections.
2599 // Return true if any of the sections found require local symbols to be read.
2600 virtual bool
2601 do_find_special_sections(Read_symbols_data* sd);
2603 // This may be overriden by a child class.
2604 virtual void
2605 do_relocate_sections(const Symbol_table* symtab, const Layout* layout,
2606 const unsigned char* pshdrs, Output_file* of,
2607 Views* pviews);
2609 // Relocate section data for a range of sections.
2610 void
2611 relocate_section_range(const Symbol_table* symtab, const Layout* layout,
2612 const unsigned char* pshdrs, Output_file* of,
2613 Views* pviews, unsigned int start_shndx,
2614 unsigned int end_shndx);
2616 // Adjust this local symbol value. Return false if the symbol
2617 // should be discarded from the output file.
2618 virtual bool
2619 do_adjust_local_symbol(Symbol_value<size>*) const
2620 { return true; }
2622 // Allow a child to set output local symbol count.
2623 void
2624 set_output_local_symbol_count(unsigned int value)
2625 { this->output_local_symbol_count_ = value; }
2627 // Return the output view for a section.
2628 unsigned char*
2629 do_get_output_view(unsigned int, section_size_type*) const;
2631 private:
2632 // For convenience.
2633 typedef Sized_relobj_file<size, big_endian> This;
2634 static const int ehdr_size = elfcpp::Elf_sizes<size>::ehdr_size;
2635 static const int shdr_size = elfcpp::Elf_sizes<size>::shdr_size;
2636 static const int sym_size = elfcpp::Elf_sizes<size>::sym_size;
2637 typedef elfcpp::Shdr<size, big_endian> Shdr;
2638 typedef elfcpp::Shdr_write<size, big_endian> Shdr_write;
2640 // To keep track of discarded comdat sections, we need to map a member
2641 // section index to the object and section index of the corresponding
2642 // kept section.
2643 struct Kept_comdat_section
2645 Kept_comdat_section(uint64_t a_sh_size, Kept_section* a_kept_section,
2646 unsigned int a_symndx, bool a_is_comdat)
2647 : sh_size(a_sh_size), kept_section(a_kept_section),
2648 symndx (a_symndx), is_comdat(a_is_comdat)
2650 uint64_t sh_size; // Section size
2651 Kept_section* kept_section; // Kept section info
2652 unsigned int symndx; // Index of key symbol
2653 bool is_comdat; // True if comdat group, false if linkonce
2655 typedef std::map<unsigned int, Kept_comdat_section>
2656 Kept_comdat_section_table;
2658 // Find the SHT_SYMTAB section, given the section headers.
2659 void
2660 find_symtab(const unsigned char* pshdrs);
2662 // Return whether SHDR has the right flags for a GNU style exception
2663 // frame section.
2664 bool
2665 check_eh_frame_flags(const elfcpp::Shdr<size, big_endian>* shdr) const;
2667 // Return whether there is a section named .eh_frame which might be
2668 // a GNU style exception frame section.
2669 bool
2670 find_eh_frame(const unsigned char* pshdrs, const char* names,
2671 section_size_type names_size) const;
2673 // Whether to include a section group in the link.
2674 bool
2675 include_section_group(Symbol_table*, Layout*, unsigned int, const char*,
2676 const unsigned char*, const char*, section_size_type,
2677 std::vector<bool>*);
2679 // Whether to include a linkonce section in the link.
2680 bool
2681 include_linkonce_section(Layout*, unsigned int, const char*,
2682 const elfcpp::Shdr<size, big_endian>&);
2684 // Layout an input section.
2685 void
2686 layout_section(Layout* layout, unsigned int shndx, const char* name,
2687 const typename This::Shdr& shdr, unsigned int sh_type,
2688 unsigned int reloc_shndx, unsigned int reloc_type);
2690 // Layout an input .eh_frame section.
2691 void
2692 layout_eh_frame_section(Layout* layout, const unsigned char* symbols_data,
2693 section_size_type symbols_size,
2694 const unsigned char* symbol_names_data,
2695 section_size_type symbol_names_size,
2696 unsigned int shndx, const typename This::Shdr&,
2697 unsigned int reloc_shndx, unsigned int reloc_type);
2699 // Layout an input .note.gnu.property section.
2700 void
2701 layout_gnu_property_section(Layout* layout, unsigned int shndx);
2703 // Write section data to the output file. Record the views and
2704 // sizes in VIEWS for use when relocating.
2705 void
2706 write_sections(const Layout*, const unsigned char* pshdrs, Output_file*,
2707 Views*);
2709 // Relocate the sections in the output file.
2710 void
2711 relocate_sections(const Symbol_table* symtab, const Layout* layout,
2712 const unsigned char* pshdrs, Output_file* of,
2713 Views* pviews)
2714 { this->do_relocate_sections(symtab, layout, pshdrs, of, pviews); }
2716 // Reverse the words in a section. Used for .ctors sections mapped
2717 // to .init_array sections.
2718 void
2719 reverse_words(unsigned char*, section_size_type);
2721 // Scan the input relocations for --emit-relocs.
2722 void
2723 emit_relocs_scan(Symbol_table*, Layout*, const unsigned char* plocal_syms,
2724 const Read_relocs_data::Relocs_list::iterator&);
2726 // Scan the input relocations for --emit-relocs, templatized on the
2727 // type of the relocation section.
2728 template<int sh_type>
2729 void
2730 emit_relocs_scan_reltype(Symbol_table*, Layout*,
2731 const unsigned char* plocal_syms,
2732 const Read_relocs_data::Relocs_list::iterator&,
2733 Relocatable_relocs*);
2735 // Scan the input relocations for --incremental.
2736 void
2737 incremental_relocs_scan(const Read_relocs_data::Relocs_list::iterator&);
2739 // Scan the input relocations for --incremental, templatized on the
2740 // type of the relocation section.
2741 template<int sh_type>
2742 void
2743 incremental_relocs_scan_reltype(
2744 const Read_relocs_data::Relocs_list::iterator&);
2746 void
2747 incremental_relocs_write(const Relocate_info<size, big_endian>*,
2748 unsigned int sh_type,
2749 const unsigned char* prelocs,
2750 size_t reloc_count,
2751 Output_section*,
2752 Address output_offset,
2753 Output_file*);
2755 template<int sh_type>
2756 void
2757 incremental_relocs_write_reltype(const Relocate_info<size, big_endian>*,
2758 const unsigned char* prelocs,
2759 size_t reloc_count,
2760 Output_section*,
2761 Address output_offset,
2762 Output_file*);
2764 // A type shared by split_stack_adjust_reltype and find_functions.
2765 typedef std::map<section_offset_type, section_size_type> Function_offsets;
2767 // Check for -fsplit-stack routines calling non-split-stack routines.
2768 void
2769 split_stack_adjust(const Symbol_table*, const unsigned char* pshdrs,
2770 unsigned int sh_type, unsigned int shndx,
2771 const unsigned char* prelocs, size_t reloc_count,
2772 unsigned char* view, section_size_type view_size,
2773 Reloc_symbol_changes** reloc_map,
2774 const Sized_target<size, big_endian>* target);
2776 template<int sh_type>
2777 void
2778 split_stack_adjust_reltype(const Symbol_table*, const unsigned char* pshdrs,
2779 unsigned int shndx, const unsigned char* prelocs,
2780 size_t reloc_count, unsigned char* view,
2781 section_size_type view_size,
2782 Reloc_symbol_changes** reloc_map,
2783 const Sized_target<size, big_endian>* target);
2785 // Find all functions in a section.
2786 void
2787 find_functions(const unsigned char* pshdrs, unsigned int shndx,
2788 Function_offsets*);
2790 // Write out the local symbols.
2791 void
2792 write_local_symbols(Output_file*,
2793 const Stringpool_template<char>*,
2794 const Stringpool_template<char>*,
2795 Output_symtab_xindex*,
2796 Output_symtab_xindex*,
2797 off_t);
2799 // Record a mapping from discarded section SHNDX to the corresponding
2800 // kept section.
2801 void
2802 set_kept_comdat_section(unsigned int shndx, bool is_comdat,
2803 unsigned int symndx, uint64_t sh_size,
2804 Kept_section* kept_section)
2806 Kept_comdat_section kept(sh_size, kept_section, symndx, is_comdat);
2807 this->kept_comdat_sections_.insert(std::make_pair(shndx, kept));
2810 // Find the kept section corresponding to the discarded section
2811 // SHNDX. Return true if found.
2812 bool
2813 get_kept_comdat_section(unsigned int shndx, bool* is_comdat,
2814 unsigned int *symndx, uint64_t* sh_size,
2815 Kept_section** kept_section) const
2817 typename Kept_comdat_section_table::const_iterator p =
2818 this->kept_comdat_sections_.find(shndx);
2819 if (p == this->kept_comdat_sections_.end())
2820 return false;
2821 *is_comdat = p->second.is_comdat;
2822 *symndx = p->second.symndx;
2823 *sh_size = p->second.sh_size;
2824 *kept_section = p->second.kept_section;
2825 return true;
2828 // Compute final local symbol value. R_SYM is the local symbol index.
2829 // LV_IN points to a local symbol value containing the input value.
2830 // LV_OUT points to a local symbol value storing the final output value,
2831 // which must not be a merged symbol value since before calling this
2832 // method to avoid memory leak. RELOCATABLE indicates whether we are
2833 // linking a relocatable output. OUT_SECTIONS is an array of output
2834 // sections. OUT_OFFSETS is an array of offsets of the sections. SYMTAB
2835 // points to a symbol table.
2837 // The method returns a status code at return. If the return status is
2838 // CFLV_OK, *LV_OUT contains the final value. If the return status is
2839 // CFLV_ERROR, *LV_OUT is 0. If the return status is CFLV_DISCARDED,
2840 // *LV_OUT is not modified.
2841 inline Compute_final_local_value_status
2842 compute_final_local_value_internal(unsigned int r_sym,
2843 const Symbol_value<size>* lv_in,
2844 Symbol_value<size>* lv_out,
2845 bool relocatable,
2846 const Output_sections& out_sections,
2847 const std::vector<Address>& out_offsets,
2848 const Symbol_table* symtab);
2850 // The PLT offsets of local symbols.
2851 typedef Unordered_map<unsigned int, unsigned int> Local_plt_offsets;
2853 // Saved information for sections whose layout was deferred.
2854 struct Deferred_layout
2856 static const int shdr_size = elfcpp::Elf_sizes<size>::shdr_size;
2857 Deferred_layout(unsigned int shndx, const char* name,
2858 unsigned int sh_type,
2859 const unsigned char* pshdr,
2860 unsigned int reloc_shndx, unsigned int reloc_type)
2861 : name_(name), shndx_(shndx), reloc_shndx_(reloc_shndx),
2862 reloc_type_(reloc_type)
2864 typename This::Shdr_write shdr(this->shdr_data_);
2865 memcpy(this->shdr_data_, pshdr, shdr_size);
2866 shdr.put_sh_type(sh_type);
2868 std::string name_;
2869 unsigned int shndx_;
2870 unsigned int reloc_shndx_;
2871 unsigned int reloc_type_;
2872 unsigned char shdr_data_[shdr_size];
2875 // General access to the ELF file.
2876 elfcpp::Elf_file<size, big_endian, Object> elf_file_;
2877 // The EI_OSABI.
2878 const Osabi osabi_;
2879 // Type of ELF file (ET_REL or ET_EXEC). ET_EXEC files are allowed
2880 // as input files only for the --just-symbols option.
2881 int e_type_;
2882 // Index of SHT_SYMTAB section.
2883 unsigned int symtab_shndx_;
2884 // The number of local symbols.
2885 unsigned int local_symbol_count_;
2886 // The number of local symbols which go into the output file.
2887 unsigned int output_local_symbol_count_;
2888 // The number of local symbols which go into the output file's dynamic
2889 // symbol table.
2890 unsigned int output_local_dynsym_count_;
2891 // The entries in the symbol table for the external symbols.
2892 Symbols symbols_;
2893 // Number of symbols defined in object file itself.
2894 size_t defined_count_;
2895 // File offset for local symbols (relative to start of symbol table).
2896 off_t local_symbol_offset_;
2897 // File offset for local dynamic symbols (absolute).
2898 off_t local_dynsym_offset_;
2899 // Values of local symbols.
2900 Local_values local_values_;
2901 // PLT offsets for local symbols.
2902 Local_plt_offsets local_plt_offsets_;
2903 // Table mapping discarded comdat sections to corresponding kept sections.
2904 Kept_comdat_section_table kept_comdat_sections_;
2905 // Whether this object has a GNU style .eh_frame section.
2906 bool has_eh_frame_;
2907 // True if the layout of this object was deferred, waiting for plugin
2908 // replacement files.
2909 bool is_deferred_layout_;
2910 // The list of sections whose layout was deferred.
2911 std::vector<Deferred_layout> deferred_layout_;
2912 // The list of relocation sections whose layout was deferred.
2913 std::vector<Deferred_layout> deferred_layout_relocs_;
2914 // Pointer to the list of output views; valid only during do_relocate().
2915 const Views* output_views_;
2918 // A class to manage the list of all objects.
2920 class Input_objects
2922 public:
2923 Input_objects()
2924 : relobj_list_(), dynobj_list_(), sonames_(), cref_(NULL)
2927 // The type of the list of input relocateable objects.
2928 typedef std::vector<Relobj*> Relobj_list;
2929 typedef Relobj_list::const_iterator Relobj_iterator;
2931 // The type of the list of input dynamic objects.
2932 typedef std::vector<Dynobj*> Dynobj_list;
2933 typedef Dynobj_list::const_iterator Dynobj_iterator;
2935 // Add an object to the list. Return true if all is well, or false
2936 // if this object should be ignored.
2937 bool
2938 add_object(Object*);
2940 // Start processing an archive.
2941 void
2942 archive_start(Archive*);
2944 // Stop processing an archive.
2945 void
2946 archive_stop(Archive*);
2948 // For each dynamic object, check whether we've seen all of its
2949 // explicit dependencies.
2950 void
2951 check_dynamic_dependencies() const;
2953 // Return whether an object was found in the system library
2954 // directory.
2955 bool
2956 found_in_system_library_directory(const Object*) const;
2958 // Print symbol counts.
2959 void
2960 print_symbol_counts(const Symbol_table*) const;
2962 // Print a cross reference table.
2963 void
2964 print_cref(const Symbol_table*, FILE*) const;
2966 // Iterate over all regular objects.
2968 Relobj_iterator
2969 relobj_begin() const
2970 { return this->relobj_list_.begin(); }
2972 Relobj_iterator
2973 relobj_end() const
2974 { return this->relobj_list_.end(); }
2976 // Iterate over all dynamic objects.
2978 Dynobj_iterator
2979 dynobj_begin() const
2980 { return this->dynobj_list_.begin(); }
2982 Dynobj_iterator
2983 dynobj_end() const
2984 { return this->dynobj_list_.end(); }
2986 // Return whether we have seen any dynamic objects.
2987 bool
2988 any_dynamic() const
2989 { return !this->dynobj_list_.empty(); }
2991 // Return the number of non dynamic objects.
2993 number_of_relobjs() const
2994 { return this->relobj_list_.size(); }
2996 // Return the number of input objects.
2998 number_of_input_objects() const
2999 { return this->relobj_list_.size() + this->dynobj_list_.size(); }
3001 private:
3002 Input_objects(const Input_objects&);
3003 Input_objects& operator=(const Input_objects&);
3005 // The list of ordinary objects included in the link.
3006 Relobj_list relobj_list_;
3007 // The list of dynamic objects included in the link.
3008 Dynobj_list dynobj_list_;
3009 // SONAMEs that we have seen.
3010 Unordered_map<std::string, Object*> sonames_;
3011 // Manage cross-references if requested.
3012 Cref* cref_;
3015 // Some of the information we pass to the relocation routines. We
3016 // group this together to avoid passing a dozen different arguments.
3018 template<int size, bool big_endian>
3019 struct Relocate_info
3021 // Symbol table.
3022 const Symbol_table* symtab;
3023 // Layout.
3024 const Layout* layout;
3025 // Object being relocated.
3026 Sized_relobj_file<size, big_endian>* object;
3027 // Section index of relocation section.
3028 unsigned int reloc_shndx;
3029 // Section header of relocation section.
3030 const unsigned char* reloc_shdr;
3031 // Info about how relocs should be handled
3032 Relocatable_relocs* rr;
3033 // Section index of section being relocated.
3034 unsigned int data_shndx;
3035 // Section header of data section.
3036 const unsigned char* data_shdr;
3038 // Return a string showing the location of a relocation. This is
3039 // only used for error messages.
3040 std::string
3041 location(size_t relnum, off_t reloffset) const;
3044 // This is used to represent a section in an object and is used as the
3045 // key type for various section maps.
3046 typedef std::pair<Relobj*, unsigned int> Section_id;
3048 // This is similar to Section_id but is used when the section
3049 // pointers are const.
3050 typedef std::pair<const Relobj*, unsigned int> Const_section_id;
3052 // The hash value is based on the address of an object in memory during
3053 // linking. It is okay to use this for looking up sections but never use
3054 // this in an unordered container that we want to traverse in a repeatable
3055 // manner.
3057 struct Section_id_hash
3059 size_t operator()(const Section_id& loc) const
3060 { return reinterpret_cast<uintptr_t>(loc.first) ^ loc.second; }
3063 struct Const_section_id_hash
3065 size_t operator()(const Const_section_id& loc) const
3066 { return reinterpret_cast<uintptr_t>(loc.first) ^ loc.second; }
3069 // Return whether INPUT_FILE contains an ELF object start at file
3070 // offset OFFSET. This sets *START to point to a view of the start of
3071 // the file. It sets *READ_SIZE to the number of bytes in the view.
3073 extern bool
3074 is_elf_object(Input_file* input_file, off_t offset,
3075 const unsigned char** start, int* read_size);
3077 // Return an Object appropriate for the input file. P is BYTES long,
3078 // and holds the ELF header. If PUNCONFIGURED is not NULL, then if
3079 // this sees an object the linker is not configured to support, it
3080 // sets *PUNCONFIGURED to true and returns NULL without giving an
3081 // error message.
3083 extern Object*
3084 make_elf_object(const std::string& name, Input_file*,
3085 off_t offset, const unsigned char* p,
3086 section_offset_type bytes, bool* punconfigured);
3088 } // end namespace gold
3090 #endif // !defined(GOLD_OBJECT_H)