1 // inremental.h -- incremental linking support for gold -*- C++ -*-
3 // Copyright 2009, 2010 Free Software Foundation, Inc.
4 // Written by Mikolaj Zalewski <mikolajz@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_INCREMENTAL_H
24 #define GOLD_INCREMENTAL_H
29 #include "elfcpp_file.h"
30 #include "stringpool.h"
31 #include "workqueue.h"
40 class Incremental_inputs_checker
;
41 class Incremental_script_entry
;
42 class Incremental_object_entry
;
43 class Incremental_archive_entry
;
44 class Incremental_inputs
;
47 // Incremental input type as stored in .gnu_incremental_inputs.
49 enum Incremental_input_type
51 INCREMENTAL_INPUT_OBJECT
= 1,
52 INCREMENTAL_INPUT_ARCHIVE_MEMBER
= 2,
53 INCREMENTAL_INPUT_ARCHIVE
= 3,
54 INCREMENTAL_INPUT_SHARED_LIBRARY
= 4,
55 INCREMENTAL_INPUT_SCRIPT
= 5
58 // An object representing the ELF file we edit during an incremental build.
59 // Similar to Object or Dynobj, but operates on Output_file and contains
60 // method specific to file edition (TBD). This is the abstract parent class
61 // implemented in Sized_incremental_binary<size, big_endian> for a specific
62 // endianness and size.
64 class Incremental_binary
67 Incremental_binary(Output_file
* output
, Target
* target
)
68 : output_(output
), target_(target
)
75 // Functions and types for the elfcpp::Elf_file interface. This
76 // permit us to use Incremental_binary as the File template parameter for
79 // The View class is returned by view. It must support a single
80 // method, data(). This is trivial, because Output_file::get_output_view
85 View(const unsigned char* p
)
94 const unsigned char* p_
;
99 view(off_t file_offset
, section_size_type data_size
)
100 { return View(this->output_
->get_input_view(file_offset
, data_size
)); }
102 // A location in the file.
108 Location(off_t fo
, section_size_type ds
)
109 : file_offset(fo
), data_size(ds
)
113 : file_offset(0), data_size(0)
117 // Get a View given a Location.
120 { return View(this->view(loc
.file_offset
, loc
.data_size
)); }
124 error(const char* format
, ...) const ATTRIBUTE_PRINTF_2
;
126 // Find the .gnu_incremental_inputs and related sections. It selects the
127 // first section of type SHT_GNU_INCREMENTAL_INPUTS,
128 // SHT_GNU_INCREMENTAL_SYMTAB, and SHT_GNU_INCREMENTAL_RELOCS.
129 // Returns false if the sections are not found.
131 find_incremental_inputs_sections(unsigned int* p_inputs_shndx
,
132 unsigned int* p_symtab_shndx
,
133 unsigned int* p_relocs_shndx
,
134 unsigned int* p_got_plt_shndx
,
135 unsigned int* p_strtab_shndx
)
137 return do_find_incremental_inputs_sections(p_inputs_shndx
, p_symtab_shndx
,
138 p_relocs_shndx
, p_got_plt_shndx
,
142 // Check the .gnu_incremental_inputs section to see whether an incremental
143 // build is possible.
144 // TODO: on success, should report what files needs to be rebuilt.
145 // INCREMENTAL_INPUTS is used to read the canonical form of the command line
146 // and read the input arguments. TODO: for items that don't need to be
147 // rebuilt, we should also copy the incremental input information.
149 check_inputs(Incremental_inputs
* incremental_inputs
)
150 { return do_check_inputs(incremental_inputs
); }
153 // Find incremental inputs section.
155 do_find_incremental_inputs_sections(unsigned int* p_inputs_shndx
,
156 unsigned int* p_symtab_shndx
,
157 unsigned int* p_relocs_shndx
,
158 unsigned int* p_got_plt_shndx
,
159 unsigned int* p_strtab_shndx
) = 0;
161 // Check the .gnu_incremental_inputs section to see whether an incremental
162 // build is possible.
164 do_check_inputs(Incremental_inputs
* incremental_inputs
) = 0;
167 // Edited output file object.
168 Output_file
* output_
;
169 // Target of the output file.
173 template<int size
, bool big_endian
>
174 class Sized_incremental_binary
: public Incremental_binary
177 Sized_incremental_binary(Output_file
* output
,
178 const elfcpp::Ehdr
<size
, big_endian
>& ehdr
,
180 : Incremental_binary(output
, target
), elf_file_(this, ehdr
)
185 do_find_incremental_inputs_sections(unsigned int* p_inputs_shndx
,
186 unsigned int* p_symtab_shndx
,
187 unsigned int* p_relocs_shndx
,
188 unsigned int* p_got_plt_shndx
,
189 unsigned int* p_strtab_shndx
);
192 do_check_inputs(Incremental_inputs
* incremental_inputs
);
195 // Output as an ELF file.
196 elfcpp::Elf_file
<size
, big_endian
, Incremental_binary
> elf_file_
;
199 // Create an Incremental_binary object for FILE. Returns NULL is this is not
200 // possible, e.g. FILE is not an ELF file or has an unsupported target.
203 open_incremental_binary(Output_file
* file
);
205 // Code invoked early during an incremental link that checks what files need
208 class Incremental_checker
211 // Check if the file named OUTPUT_NAME can be linked incrementally.
212 // INCREMENTAL_INPUTS must have the canonical form of the command line
213 // and input arguments filled - at this point of linking other fields are
214 // probably not filled yet. TODO: for inputs that don't need to be
215 // rebuilt, this function should fill the incremental input information.
216 Incremental_checker(const char* output_name
,
217 Incremental_inputs
* incremental_inputs
)
218 : output_name_(output_name
), incremental_inputs_(incremental_inputs
)
221 // Analyzes the output file to check if incremental linking is possible and
222 // what files needs to be relinked.
224 can_incrementally_link_output_file();
227 // Name of the output file to analyze.
228 const char* output_name_
;
230 // The Incremental_inputs object. At this stage of link, only the command
231 // line and inputs are filled.
232 Incremental_inputs
* incremental_inputs_
;
235 // Base class for recording each input file.
237 class Incremental_input_entry
240 Incremental_input_entry(Stringpool::Key filename_key
, Timespec mtime
)
241 : filename_key_(filename_key
), offset_(0), info_offset_(0), mtime_(mtime
)
245 ~Incremental_input_entry()
248 // Return the type of input file.
249 Incremental_input_type
251 { return this->do_type(); }
253 // Set the section offset of this input file entry.
255 set_offset(unsigned int offset
)
256 { this->offset_
= offset
; }
258 // Set the section offset of the supplemental information for this entry.
260 set_info_offset(unsigned int info_offset
)
261 { this->info_offset_
= info_offset
; }
263 // Get the section offset of this input file entry.
266 { return this->offset_
; }
268 // Get the section offset of the supplemental information for this entry.
270 get_info_offset() const
271 { return this->info_offset_
; }
273 // Get the stringpool key for the input filename.
275 get_filename_key() const
276 { return this->filename_key_
; }
278 // Get the modification time of the input file.
281 { return this->mtime_
; }
283 // Return a pointer to the derived Incremental_script_entry object.
284 // Return NULL for input entries that are not script files.
285 Incremental_script_entry
*
287 { return this->do_script_entry(); }
289 // Return a pointer to the derived Incremental_object_entry object.
290 // Return NULL for input entries that are not object files.
291 Incremental_object_entry
*
293 { return this->do_object_entry(); }
295 // Return a pointer to the derived Incremental_archive_entry object.
296 // Return NULL for input entries that are not archive files.
297 Incremental_archive_entry
*
299 { return this->do_archive_entry(); }
302 // Return the type of input file.
303 virtual Incremental_input_type
306 // Return a pointer to the derived Incremental_script_entry object.
307 // Return NULL for input entries that are not script files.
308 virtual Incremental_script_entry
*
312 // Return a pointer to the derived Incremental_object_entry object.
313 // Return NULL for input entries that are not object files.
314 virtual Incremental_object_entry
*
318 // Return a pointer to the derived Incremental_archive_entry object.
319 // Return NULL for input entries that are not archive files.
320 virtual Incremental_archive_entry
*
325 // Key of the filename string in the section stringtable.
326 Stringpool::Key filename_key_
;
328 // Offset of the entry in the output section.
329 unsigned int offset_
;
331 // Offset of the extra information in the output section.
332 unsigned int info_offset_
;
334 // Last modification time of the file.
338 // Class for recording input scripts.
340 class Incremental_script_entry
: public Incremental_input_entry
343 Incremental_script_entry(Stringpool::Key filename_key
, Script_info
* script
,
345 : Incremental_input_entry(filename_key
, mtime
), script_(script
)
349 virtual Incremental_input_type
351 { return INCREMENTAL_INPUT_SCRIPT
; }
353 // Return a pointer to the derived Incremental_script_entry object.
354 virtual Incremental_script_entry
*
359 // Information about the script file.
360 Script_info
* script_
;
363 // Class for recording input object files.
365 class Incremental_object_entry
: public Incremental_input_entry
368 Incremental_object_entry(Stringpool::Key filename_key
, Object
* obj
,
370 : Incremental_input_entry(filename_key
, mtime
), obj_(obj
),
371 is_member_(false), sections_()
373 if (!obj_
->is_dynamic())
374 this->sections_
.reserve(obj
->shnum());
380 { return this->obj_
; }
382 // Record that this object is an archive member.
385 { this->is_member_
= true; }
387 // Return true if this object is an archive member.
390 { return this->is_member_
; }
392 // Add an input section.
394 add_input_section(unsigned int shndx
, Stringpool::Key name_key
, off_t sh_size
)
396 if (shndx
>= this->sections_
.size())
397 this->sections_
.resize(shndx
+ 1);
398 this->sections_
[shndx
].name_key
= name_key
;
399 this->sections_
[shndx
].sh_size
= sh_size
;
402 // Return the number of input sections in this object.
404 get_input_section_count() const
405 { return this->sections_
.size(); }
407 // Return the stringpool key of the Nth input section.
409 get_input_section_name_key(unsigned int n
) const
410 { return this->sections_
[n
].name_key
; }
412 // Return the size of the Nth input section.
414 get_input_section_size(unsigned int n
) const
415 { return this->sections_
[n
].sh_size
; }
418 virtual Incremental_input_type
421 return (this->is_member_
422 ? INCREMENTAL_INPUT_ARCHIVE_MEMBER
423 : (this->obj_
->is_dynamic()
424 ? INCREMENTAL_INPUT_SHARED_LIBRARY
425 : INCREMENTAL_INPUT_OBJECT
));
428 // Return a pointer to the derived Incremental_object_entry object.
429 virtual Incremental_object_entry
*
434 // The object file itself.
437 // Whether this object is an archive member.
443 Stringpool::Key name_key
;
446 std::vector
<Input_section
> sections_
;
449 // Class for recording archive library input files.
451 class Incremental_archive_entry
: public Incremental_input_entry
454 Incremental_archive_entry(Stringpool::Key filename_key
, Timespec mtime
)
455 : Incremental_input_entry(filename_key
, mtime
), members_(), unused_syms_()
458 // Add a member object to the archive.
460 add_object(Incremental_object_entry
* obj_entry
)
462 this->members_
.push_back(obj_entry
);
463 obj_entry
->set_is_member();
466 // Add an unused global symbol to the archive.
468 add_unused_global_symbol(Stringpool::Key symbol_key
)
469 { this->unused_syms_
.push_back(symbol_key
); }
471 // Return the number of member objects included in the link.
474 { return this->members_
.size(); }
476 // Return the Nth member object.
477 Incremental_object_entry
*
478 get_member(unsigned int n
)
479 { return this->members_
[n
]; }
481 // Return the number of unused global symbols in this archive.
483 get_unused_global_symbol_count()
484 { return this->unused_syms_
.size(); }
486 // Return the Nth unused global symbol.
488 get_unused_global_symbol(unsigned int n
)
489 { return this->unused_syms_
[n
]; }
492 virtual Incremental_input_type
494 { return INCREMENTAL_INPUT_ARCHIVE
; }
496 // Return a pointer to the derived Incremental_archive_entry object.
497 virtual Incremental_archive_entry
*
502 // Members of the archive that have been included in the link.
503 std::vector
<Incremental_object_entry
*> members_
;
505 // Unused global symbols from this archive.
506 std::vector
<Stringpool::Key
> unused_syms_
;
509 // This class contains the information needed during an incremental
510 // build about the inputs necessary to build the .gnu_incremental_inputs.
512 class Incremental_inputs
515 typedef std::vector
<Incremental_input_entry
*> Input_list
;
518 : inputs_(), command_line_(), command_line_key_(0),
519 strtab_(new Stringpool()), current_object_(NULL
),
520 current_object_entry_(NULL
), inputs_section_(NULL
),
521 symtab_section_(NULL
), relocs_section_(NULL
),
525 ~Incremental_inputs() { delete this->strtab_
; }
527 // Record the command line.
529 report_command_line(int argc
, const char* const* argv
);
531 // Record the initial info for archive file ARCHIVE.
533 report_archive_begin(Library_base
* arch
);
535 // Record the final info for archive file ARCHIVE.
537 report_archive_end(Library_base
* arch
);
539 // Record the info for object file OBJ. If ARCH is not NULL,
540 // attach the object file to the archive.
542 report_object(Object
* obj
, Library_base
* arch
);
544 // Record an input section belonging to object file OBJ.
546 report_input_section(Object
* obj
, unsigned int shndx
, const char* name
,
549 // Record the info for input script SCRIPT.
551 report_script(const std::string
& filename
, Script_info
* script
,
554 // Return the running count of incremental relocations.
556 get_reloc_count() const
557 { return this->reloc_count_
; }
559 // Update the running count of incremental relocations.
561 set_reloc_count(unsigned int count
)
562 { this->reloc_count_
= count
; }
564 // Prepare for layout. Called from Layout::finalize.
568 // Create the .gnu_incremental_inputs and related sections.
570 create_data_sections(Symbol_table
* symtab
);
572 // Return the .gnu_incremental_inputs section.
574 inputs_section() const
575 { return this->inputs_section_
; }
577 // Return the .gnu_incremental_symtab section.
579 symtab_section() const
580 { return this->symtab_section_
; }
582 // Return the .gnu_incremental_relocs section.
584 relocs_section() const
585 { return this->relocs_section_
; }
587 // Return the .gnu_incremental_got_plt section.
589 got_plt_section() const
590 { return this->got_plt_section_
; }
592 // Return the .gnu_incremental_strtab stringpool.
594 get_stringpool() const
595 { return this->strtab_
; }
597 // Return the canonical form of the command line, as will be stored in
598 // .gnu_incremental_strtab.
601 { return this->command_line_
; }
603 // Return the stringpool key of the command line.
605 command_line_key() const
606 { return this->command_line_key_
; }
608 // Return the number of input files.
610 input_file_count() const
611 { return this->inputs_
.size(); }
613 // Return the input files.
616 { return this->inputs_
; }
618 // Return the sh_entsize value for the .gnu_incremental_relocs section.
620 relocs_entsize() const;
623 // The list of input files.
626 // Canonical form of the command line, as will be stored in
627 // .gnu_incremental_strtab.
628 std::string command_line_
;
630 // The key of the command line string in the string pool.
631 Stringpool::Key command_line_key_
;
633 // The .gnu_incremental_strtab string pool associated with the
634 // .gnu_incremental_inputs.
637 // Keep track of the object currently being processed.
638 Object
* current_object_
;
639 Incremental_object_entry
* current_object_entry_
;
641 // The .gnu_incremental_inputs section.
642 Output_section_data
* inputs_section_
;
644 // The .gnu_incremental_symtab section.
645 Output_data_space
* symtab_section_
;
647 // The .gnu_incremental_relocs section.
648 Output_data_space
* relocs_section_
;
650 // The .gnu_incremental_got_plt section.
651 Output_data_space
* got_plt_section_
;
653 // Total count of incremental relocations. Updated during Scan_relocs
654 // phase at the completion of each object file.
655 unsigned int reloc_count_
;
658 // Reader class for .gnu_incremental_inputs section.
660 template<int size
, bool big_endian
>
661 class Incremental_inputs_reader
664 typedef elfcpp::Swap
<size
, big_endian
> Swap
;
665 typedef elfcpp::Swap
<16, big_endian
> Swap16
;
666 typedef elfcpp::Swap
<32, big_endian
> Swap32
;
667 typedef elfcpp::Swap
<64, big_endian
> Swap64
;
670 Incremental_inputs_reader(const unsigned char* p
, elfcpp::Elf_strtab
& strtab
)
671 : p_(p
), strtab_(strtab
)
672 { this->input_file_count_
= Swap32::readval(this->p_
+ 4); }
674 // Return the version number.
677 { return Swap32::readval(this->p_
); }
679 // Return the count of input file entries.
681 input_file_count() const
682 { return this->input_file_count_
; }
684 // Return the command line.
688 unsigned int offset
= Swap32::readval(this->p_
+ 8);
689 return this->get_string(offset
);
692 // Reader class for an input file entry and its supplemental info.
693 class Incremental_input_entry_reader
696 Incremental_input_entry_reader(const Incremental_inputs_reader
* inputs
,
698 : inputs_(inputs
), offset_(offset
)
700 this->info_offset_
= Swap32::readval(inputs
->p_
+ offset
+ 4);
701 int type
= Swap16::readval(this->inputs_
->p_
+ offset
+ 20);
702 this->type_
= static_cast<Incremental_input_type
>(type
);
705 // Return the filename.
709 unsigned int offset
= Swap32::readval(this->inputs_
->p_
+ this->offset_
);
710 return this->inputs_
->get_string(offset
);
713 // Return the timestamp.
718 const unsigned char* p
= this->inputs_
->p_
+ this->offset_
+ 8;
719 t
.seconds
= Swap64::readval(p
);
720 t
.nanoseconds
= Swap32::readval(p
+8);
724 // Return the type of input file.
725 Incremental_input_type
727 { return this->type_
; }
729 // Return the input section count -- for objects only.
731 get_input_section_count() const
733 gold_assert(this->type_
== INCREMENTAL_INPUT_OBJECT
734 || this->type_
== INCREMENTAL_INPUT_ARCHIVE_MEMBER
);
735 return Swap32::readval(this->inputs_
->p_
+ this->info_offset_
);
738 // Return the offset of the supplemental info for symbol SYMNDX --
741 get_symbol_offset(unsigned int symndx
) const
743 gold_assert(this->type_
== INCREMENTAL_INPUT_OBJECT
744 || this->type_
== INCREMENTAL_INPUT_ARCHIVE_MEMBER
);
746 unsigned int section_count
= this->get_input_section_count();
747 return (this->info_offset_
+ 8
748 + section_count
* input_section_entry_size
752 // Return the global symbol count -- for objects & shared libraries only.
754 get_global_symbol_count() const
758 case INCREMENTAL_INPUT_OBJECT
:
759 case INCREMENTAL_INPUT_ARCHIVE_MEMBER
:
760 return Swap32::readval(this->inputs_
->p_
+ this->info_offset_
+ 4);
761 case INCREMENTAL_INPUT_SHARED_LIBRARY
:
762 return Swap32::readval(this->inputs_
->p_
+ this->info_offset_
);
768 // Return the member count -- for archives only.
770 get_member_count() const
772 gold_assert(this->type_
== INCREMENTAL_INPUT_ARCHIVE
);
773 return Swap32::readval(this->inputs_
->p_
+ this->info_offset_
);
776 // Return the unused symbol count -- for archives only.
778 get_unused_symbol_count() const
780 gold_assert(this->type_
== INCREMENTAL_INPUT_ARCHIVE
);
781 return Swap32::readval(this->inputs_
->p_
+ this->info_offset_
+ 4);
784 // Return the input file offset for archive member N -- for archives only.
786 get_member_offset(unsigned int n
) const
788 gold_assert(this->type_
== INCREMENTAL_INPUT_ARCHIVE
);
789 return Swap32::readval(this->inputs_
->p_
+ this->info_offset_
793 // Return the Nth unused global symbol -- for archives only.
795 get_unused_symbol(unsigned int n
) const
797 gold_assert(this->type_
== INCREMENTAL_INPUT_ARCHIVE
);
798 unsigned int member_count
= this->get_member_count();
799 unsigned int offset
= Swap32::readval(this->inputs_
->p_
800 + this->info_offset_
+ 8
803 return this->inputs_
->get_string(offset
);
806 // Information about an input section.
807 struct Input_section_info
810 unsigned int output_shndx
;
815 // Return info about the Nth input section -- for objects only.
817 get_input_section(unsigned int n
) const
819 Input_section_info info
;
820 const unsigned char* p
= (this->inputs_
->p_
821 + this->info_offset_
+ 8
822 + n
* input_section_entry_size
);
823 unsigned int name_offset
= Swap32::readval(p
);
824 info
.name
= this->inputs_
->get_string(name_offset
);
825 info
.output_shndx
= Swap32::readval(p
+ 4);
826 info
.sh_offset
= Swap::readval(p
+ 8);
827 info
.sh_size
= Swap::readval(p
+ 8 + size
/ 8);
831 // Information about a global symbol.
832 struct Global_symbol_info
834 unsigned int output_symndx
;
835 unsigned int next_offset
;
836 unsigned int reloc_count
;
837 unsigned int reloc_offset
;
840 // Return info about the Nth global symbol -- for objects only.
842 get_global_symbol_info(unsigned int n
) const
844 Global_symbol_info info
;
845 unsigned int section_count
= this->get_input_section_count();
846 const unsigned char* p
= (this->inputs_
->p_
847 + this->info_offset_
+ 8
848 + section_count
* input_section_entry_size
850 info
.output_symndx
= Swap32::readval(p
);
851 info
.next_offset
= Swap32::readval(p
+ 4);
852 info
.reloc_count
= Swap::readval(p
+ 8);
853 info
.reloc_offset
= Swap::readval(p
+ 12);
858 // Size of an input section entry.
859 static const unsigned int input_section_entry_size
= 8 + 2 * size
/ 8;
860 // The reader instance for the containing section.
861 const Incremental_inputs_reader
* inputs_
;
862 // The type of input file.
863 Incremental_input_type type_
;
864 // Section offset to the input file entry.
865 unsigned int offset_
;
866 // Section offset to the supplemental info for the input file.
867 unsigned int info_offset_
;
870 // Return a reader for the Nth input file entry.
871 Incremental_input_entry_reader
872 input_file(unsigned int n
) const
874 gold_assert(n
< this->input_file_count_
);
875 Incremental_input_entry_reader
input(this, 16 + n
* 24);
880 // Lookup a string in the ELF string table.
881 const char* get_string(unsigned int offset
) const
884 if (this->strtab_
.get_c_string(offset
, &s
))
889 // Base address of the .gnu_incremental_inputs section.
890 const unsigned char* p_
;
891 // The associated ELF string table.
892 elfcpp::Elf_strtab strtab_
;
893 // The number of input file entries in this section.
894 unsigned int input_file_count_
;
897 // Reader class for the .gnu_incremental_symtab section.
899 template<bool big_endian
>
900 class Incremental_symtab_reader
903 Incremental_symtab_reader(const unsigned char* p
) : p_(p
)
906 // Return the list head for symbol table entry N.
907 unsigned int get_list_head(unsigned int n
) const
908 { return elfcpp::Swap
<32, big_endian
>::readval(this->p_
+ 4 * n
); }
911 // Base address of the .gnu_incremental_relocs section.
912 const unsigned char* p_
;
915 // Reader class for the .gnu_incremental_relocs section.
917 template<int size
, bool big_endian
>
918 class Incremental_relocs_reader
921 // Size of each field.
922 static const unsigned int field_size
= size
/ 8;
925 typedef typename
elfcpp::Elf_types
<size
>::Elf_Addr Address
;
926 typedef typename
elfcpp::Elf_types
<size
>::Elf_Swxword Addend
;
928 // Size of each entry.
929 static const unsigned int reloc_size
= 8 + 2 * field_size
;
931 Incremental_relocs_reader(const unsigned char* p
) : p_(p
)
934 // Return the relocation type for relocation entry at offset OFF.
936 get_r_type(unsigned int off
) const
938 return elfcpp::Swap
<32, big_endian
>::readval(this->p_
+ off
);
941 // Return the output section index for relocation entry at offset OFF.
943 get_r_shndx(unsigned int off
) const
945 return elfcpp::Swap
<32, big_endian
>::readval(this->p_
+ off
+ 4);
948 // Return the output section offset for relocation entry at offset OFF.
950 get_r_offset(unsigned int off
) const
952 return elfcpp::Swap
<size
, big_endian
>::readval(this->p_
+ off
+ 8);
955 // Return the addend for relocation entry at offset OFF.
957 get_r_addend(unsigned int off
) const
959 return elfcpp::Swap
<size
, big_endian
>::readval(this->p_
+ off
+ 8
964 // Base address of the .gnu_incremental_relocs section.
965 const unsigned char* p_
;
968 // Reader class for the .gnu_incremental_got_plt section.
970 template<bool big_endian
>
971 class Incremental_got_plt_reader
974 Incremental_got_plt_reader(const unsigned char* p
) : p_(p
)
976 this->got_count_
= elfcpp::Swap
<32, big_endian
>::readval(p
);
977 this->got_desc_p_
= p
+ 8 + ((this->got_count_
+ 3) & ~3);
978 this->plt_desc_p_
= this->got_desc_p_
+ this->got_count_
* 4;
981 // Return the GOT entry count.
983 get_got_entry_count() const
985 return this->got_count_
;
988 // Return the PLT entry count.
990 get_plt_entry_count() const
992 return elfcpp::Swap
<32, big_endian
>::readval(this->p_
+ 4);
995 // Return the GOT type for GOT entry N.
997 get_got_type(unsigned int n
)
999 return this->p_
[8 + n
];
1002 // Return the GOT descriptor for GOT entry N.
1004 get_got_desc(unsigned int n
)
1006 return elfcpp::Swap
<32, big_endian
>::readval(this->got_desc_p_
+ n
* 4);
1009 // Return the PLT descriptor for PLT entry N.
1011 get_plt_desc(unsigned int n
)
1013 return elfcpp::Swap
<32, big_endian
>::readval(this->plt_desc_p_
+ n
* 4);
1017 // Base address of the .gnu_incremental_got_plt section.
1018 const unsigned char* p_
;
1020 unsigned int got_count_
;
1021 // Base address of the GOT descriptor array.
1022 const unsigned char* got_desc_p_
;
1023 // Base address of the PLT descriptor array.
1024 const unsigned char* plt_desc_p_
;
1027 } // End namespace gold.
1029 #endif // !defined(GOLD_INCREMENTAL_H)