1 // inremental.cc -- incremental linking support for gold
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.
26 #include "libiberty.h"
32 #include "incremental.h"
36 #include "target-select.h"
43 // Version information. Will change frequently during the development, later
44 // we could think about backward (and forward?) compatibility.
45 const unsigned int INCREMENTAL_LINK_VERSION = 1;
47 // This class manages the .gnu_incremental_inputs section, which holds
48 // the header information, a directory of input files, and separate
49 // entries for each input file.
51 template<int size, bool big_endian>
52 class Output_section_incremental_inputs : public Output_section_data
55 Output_section_incremental_inputs(const Incremental_inputs* inputs,
56 const Symbol_table* symtab)
57 : Output_section_data(size / 8), inputs_(inputs), symtab_(symtab)
61 // This is called to update the section size prior to assigning
62 // the address and file offset.
65 { this->set_final_data_size(); }
67 // Set the final data size.
69 set_final_data_size();
71 // Write the data to the file.
73 do_write(Output_file*);
75 // Write to a map file.
77 do_print_to_mapfile(Mapfile* mapfile) const
78 { mapfile->print_output_data(this, _("** incremental_inputs")); }
81 // Write the section header.
83 write_header(unsigned char* pov, unsigned int input_file_count,
84 section_offset_type command_line_offset);
86 // Write the input file entries.
88 write_input_files(unsigned char* oview, unsigned char* pov,
91 // Write the supplemental information blocks.
93 write_info_blocks(unsigned char* oview, unsigned char* pov,
94 Stringpool* strtab, unsigned int* global_syms,
95 unsigned int global_sym_count);
97 // Write the contents of the .gnu_incremental_symtab section.
99 write_symtab(unsigned char* pov, unsigned int* global_syms,
100 unsigned int global_sym_count);
102 // Write the contents of the .gnu_incremental_got_plt section.
104 write_got_plt(unsigned char* pov, off_t view_size);
106 // Typedefs for writing the data to the output sections.
107 typedef elfcpp::Swap<size, big_endian> Swap;
108 typedef elfcpp::Swap<16, big_endian> Swap16;
109 typedef elfcpp::Swap<32, big_endian> Swap32;
110 typedef elfcpp::Swap<64, big_endian> Swap64;
112 // Sizes of various structures.
113 static const int sizeof_addr = size / 8;
114 static const int header_size = 16;
115 static const int input_entry_size = 24;
117 // The Incremental_inputs object.
118 const Incremental_inputs* inputs_;
121 const Symbol_table* symtab_;
124 // Inform the user why we don't do an incremental link. Not called in
125 // the obvious case of missing output file. TODO: Is this helpful?
128 vexplain_no_incremental(const char* format, va_list args)
131 if (vasprintf(&buf, format, args) < 0)
133 gold_info(_("the link might take longer: "
134 "cannot perform incremental link: %s"), buf);
139 explain_no_incremental(const char* format, ...)
142 va_start(args, format);
143 vexplain_no_incremental(format, args);
150 Incremental_binary::error(const char* format, ...) const
153 va_start(args, format);
154 // Current code only checks if the file can be used for incremental linking,
155 // so errors shouldn't fail the build, but only result in a fallback to a
157 // TODO: when we implement incremental editing of the file, we may need a
158 // flag that will cause errors to be treated seriously.
159 vexplain_no_incremental(format, args);
163 // Find the .gnu_incremental_inputs section and related sections.
165 template<int size, bool big_endian>
167 Sized_incremental_binary<size, big_endian>::find_incremental_inputs_sections(
168 unsigned int* p_inputs_shndx,
169 unsigned int* p_symtab_shndx,
170 unsigned int* p_relocs_shndx,
171 unsigned int* p_got_plt_shndx,
172 unsigned int* p_strtab_shndx)
174 unsigned int inputs_shndx =
175 this->elf_file_.find_section_by_type(elfcpp::SHT_GNU_INCREMENTAL_INPUTS);
176 if (inputs_shndx == elfcpp::SHN_UNDEF) // Not found.
179 unsigned int symtab_shndx =
180 this->elf_file_.find_section_by_type(elfcpp::SHT_GNU_INCREMENTAL_SYMTAB);
181 if (symtab_shndx == elfcpp::SHN_UNDEF) // Not found.
183 if (this->elf_file_.section_link(symtab_shndx) != inputs_shndx)
186 unsigned int relocs_shndx =
187 this->elf_file_.find_section_by_type(elfcpp::SHT_GNU_INCREMENTAL_RELOCS);
188 if (relocs_shndx == elfcpp::SHN_UNDEF) // Not found.
190 if (this->elf_file_.section_link(relocs_shndx) != inputs_shndx)
193 unsigned int got_plt_shndx =
194 this->elf_file_.find_section_by_type(elfcpp::SHT_GNU_INCREMENTAL_GOT_PLT);
195 if (got_plt_shndx == elfcpp::SHN_UNDEF) // Not found.
197 if (this->elf_file_.section_link(got_plt_shndx) != inputs_shndx)
200 unsigned int strtab_shndx = this->elf_file_.section_link(inputs_shndx);
201 if (strtab_shndx == elfcpp::SHN_UNDEF
202 || strtab_shndx > this->elf_file_.shnum()
203 || this->elf_file_.section_type(strtab_shndx) != elfcpp::SHT_STRTAB)
206 if (p_inputs_shndx != NULL)
207 *p_inputs_shndx = inputs_shndx;
208 if (p_symtab_shndx != NULL)
209 *p_symtab_shndx = symtab_shndx;
210 if (p_relocs_shndx != NULL)
211 *p_relocs_shndx = relocs_shndx;
212 if (p_got_plt_shndx != NULL)
213 *p_got_plt_shndx = got_plt_shndx;
214 if (p_strtab_shndx != NULL)
215 *p_strtab_shndx = strtab_shndx;
219 // Set up the readers into the incremental info sections.
221 template<int size, bool big_endian>
223 Sized_incremental_binary<size, big_endian>::setup_readers()
225 unsigned int inputs_shndx;
226 unsigned int symtab_shndx;
227 unsigned int relocs_shndx;
228 unsigned int got_plt_shndx;
229 unsigned int strtab_shndx;
231 if (!this->find_incremental_inputs_sections(&inputs_shndx, &symtab_shndx,
232 &relocs_shndx, &got_plt_shndx,
236 Location inputs_location(this->elf_file_.section_contents(inputs_shndx));
237 Location symtab_location(this->elf_file_.section_contents(symtab_shndx));
238 Location relocs_location(this->elf_file_.section_contents(relocs_shndx));
239 Location got_plt_location(this->elf_file_.section_contents(got_plt_shndx));
240 Location strtab_location(this->elf_file_.section_contents(strtab_shndx));
242 View inputs_view = this->view(inputs_location);
243 View symtab_view = this->view(symtab_location);
244 View relocs_view = this->view(relocs_location);
245 View got_plt_view = this->view(got_plt_location);
246 View strtab_view = this->view(strtab_location);
248 elfcpp::Elf_strtab strtab(strtab_view.data(), strtab_location.data_size);
250 this->inputs_reader_ =
251 Incremental_inputs_reader<size, big_endian>(inputs_view.data(), strtab);
252 this->symtab_reader_ =
253 Incremental_symtab_reader<big_endian>(symtab_view.data(),
254 symtab_location.data_size);
255 this->relocs_reader_ =
256 Incremental_relocs_reader<size, big_endian>(relocs_view.data(),
257 relocs_location.data_size);
258 this->got_plt_reader_ =
259 Incremental_got_plt_reader<big_endian>(got_plt_view.data());
261 // Find the main symbol table.
262 unsigned int main_symtab_shndx =
263 this->elf_file_.find_section_by_type(elfcpp::SHT_SYMTAB);
264 gold_assert(main_symtab_shndx != elfcpp::SHN_UNDEF);
265 this->main_symtab_loc_ = this->elf_file_.section_contents(main_symtab_shndx);
267 // Find the main symbol string table.
268 unsigned int main_strtab_shndx =
269 this->elf_file_.section_link(main_symtab_shndx);
270 gold_assert(main_strtab_shndx != elfcpp::SHN_UNDEF
271 && main_strtab_shndx < this->elf_file_.shnum());
272 this->main_strtab_loc_ = this->elf_file_.section_contents(main_strtab_shndx);
274 // Walk the list of input files (a) to setup an Input_reader for each
275 // input file, and (b) to record maps of files added from archive
276 // libraries and scripts.
277 Incremental_inputs_reader<size, big_endian>& inputs = this->inputs_reader_;
278 unsigned int count = inputs.input_file_count();
279 this->input_objects_.resize(count);
280 this->input_entry_readers_.reserve(count);
281 this->library_map_.resize(count);
282 this->script_map_.resize(count);
283 for (unsigned int i = 0; i < count; i++)
285 Input_entry_reader input_file = inputs.input_file(i);
286 this->input_entry_readers_.push_back(Sized_input_reader(input_file));
287 switch (input_file.type())
289 case INCREMENTAL_INPUT_OBJECT:
290 case INCREMENTAL_INPUT_ARCHIVE_MEMBER:
291 case INCREMENTAL_INPUT_SHARED_LIBRARY:
292 // No special treatment necessary.
294 case INCREMENTAL_INPUT_ARCHIVE:
296 Incremental_library* lib =
297 new Incremental_library(input_file.filename(), i,
298 &this->input_entry_readers_[i]);
299 this->library_map_[i] = lib;
300 unsigned int member_count = input_file.get_member_count();
301 for (unsigned int j = 0; j < member_count; j++)
303 int member_offset = input_file.get_member_offset(j);
304 int member_index = inputs.input_file_index(member_offset);
305 this->library_map_[member_index] = lib;
309 case INCREMENTAL_INPUT_SCRIPT:
311 Script_info* script = new Script_info(input_file.filename());
312 this->script_map_[i] = script;
313 unsigned int object_count = input_file.get_object_count();
314 for (unsigned int j = 0; j < object_count; j++)
316 int object_offset = input_file.get_object_offset(j);
317 int object_index = inputs.input_file_index(object_offset);
318 this->script_map_[object_index] = script;
327 // Initialize the map of global symbols.
328 unsigned int nglobals = this->symtab_reader_.symbol_count();
329 this->symbol_map_.resize(nglobals);
331 this->has_incremental_info_ = true;
334 // Walk the list of input files given on the command line, and build
335 // a direct map of file index to the corresponding input argument.
338 check_input_args(std::vector<const Input_argument*>& input_args_map,
339 Input_arguments::const_iterator begin,
340 Input_arguments::const_iterator end)
342 for (Input_arguments::const_iterator p = begin;
348 const Input_file_group* group = p->group();
349 check_input_args(input_args_map, group->begin(), group->end());
351 else if (p->is_lib())
353 const Input_file_lib* lib = p->lib();
354 check_input_args(input_args_map, lib->begin(), lib->end());
358 gold_assert(p->is_file());
359 unsigned int arg_serial = p->file().arg_serial();
362 gold_assert(arg_serial <= input_args_map.size());
363 gold_assert(input_args_map[arg_serial - 1] == 0);
364 input_args_map[arg_serial - 1] = &*p;
370 // Determine whether an incremental link based on the existing output file
373 template<int size, bool big_endian>
375 Sized_incremental_binary<size, big_endian>::do_check_inputs(
376 const Command_line& cmdline,
377 Incremental_inputs* incremental_inputs)
379 Incremental_inputs_reader<size, big_endian>& inputs = this->inputs_reader_;
381 if (!this->has_incremental_info_)
383 explain_no_incremental(_("no incremental data from previous build"));
387 if (inputs.version() != INCREMENTAL_LINK_VERSION)
389 explain_no_incremental(_("different version of incremental build data"));
393 if (incremental_inputs->command_line() != inputs.command_line())
395 explain_no_incremental(_("command line changed"));
399 // Walk the list of input files given on the command line, and build
400 // a direct map of argument serial numbers to the corresponding input
402 this->input_args_map_.resize(cmdline.number_of_input_files());
403 check_input_args(this->input_args_map_, cmdline.begin(), cmdline.end());
405 // Walk the list of input files to check for conditions that prevent
406 // an incremental update link.
407 unsigned int count = inputs.input_file_count();
408 for (unsigned int i = 0; i < count; i++)
410 Input_entry_reader input_file = inputs.input_file(i);
411 switch (input_file.type())
413 case INCREMENTAL_INPUT_OBJECT:
414 case INCREMENTAL_INPUT_ARCHIVE_MEMBER:
415 case INCREMENTAL_INPUT_SHARED_LIBRARY:
416 case INCREMENTAL_INPUT_ARCHIVE:
417 // No special treatment necessary.
419 case INCREMENTAL_INPUT_SCRIPT:
420 if (this->do_file_has_changed(i))
422 explain_no_incremental(_("%s: script file changed"),
423 input_file.filename());
435 // Return TRUE if input file N has changed since the last incremental link.
437 template<int size, bool big_endian>
439 Sized_incremental_binary<size, big_endian>::do_file_has_changed(
440 unsigned int n) const
442 Input_entry_reader input_file = this->inputs_reader_.input_file(n);
443 Incremental_disposition disp = INCREMENTAL_CHECK;
444 const Input_argument* input_argument = this->get_input_argument(n);
445 if (input_argument != NULL)
446 disp = input_argument->file().options().incremental_disposition();
448 if (disp != INCREMENTAL_CHECK)
449 return disp == INCREMENTAL_CHANGED;
451 const char* filename = input_file.filename();
452 Timespec old_mtime = input_file.get_mtime();
454 if (!get_mtime(filename, &new_mtime))
456 // If we can't open get the current modification time, assume it has
457 // changed. If the file doesn't exist, we'll issue an error when we
458 // try to open it later.
462 if (new_mtime.seconds > old_mtime.seconds)
464 if (new_mtime.seconds == old_mtime.seconds
465 && new_mtime.nanoseconds > old_mtime.nanoseconds)
470 // Initialize the layout of the output file based on the existing
473 template<int size, bool big_endian>
475 Sized_incremental_binary<size, big_endian>::do_init_layout(Layout* layout)
477 typedef elfcpp::Shdr<size, big_endian> Shdr;
478 const int shdr_size = elfcpp::Elf_sizes<size>::shdr_size;
480 // Get views of the section headers and the section string table.
481 const off_t shoff = this->elf_file_.shoff();
482 const unsigned int shnum = this->elf_file_.shnum();
483 const unsigned int shstrndx = this->elf_file_.shstrndx();
484 Location shdrs_location(shoff, shnum * shdr_size);
485 Location shstrndx_location(this->elf_file_.section_contents(shstrndx));
486 View shdrs_view = this->view(shdrs_location);
487 View shstrndx_view = this->view(shstrndx_location);
488 elfcpp::Elf_strtab shstrtab(shstrndx_view.data(),
489 shstrndx_location.data_size);
491 layout->set_incremental_base(this);
493 // Initialize the layout.
494 this->section_map_.resize(shnum);
495 const unsigned char* pshdr = shdrs_view.data() + shdr_size;
496 for (unsigned int i = 1; i < shnum; i++)
500 if (!shstrtab.get_c_string(shdr.get_sh_name(), &name))
502 gold_debug(DEBUG_INCREMENTAL,
503 "Output section: %2d %08lx %08lx %08lx %3d %s",
505 static_cast<long>(shdr.get_sh_addr()),
506 static_cast<long>(shdr.get_sh_offset()),
507 static_cast<long>(shdr.get_sh_size()),
508 shdr.get_sh_type(), name ? name : "<null>");
509 this->section_map_[i] = layout->init_fixed_output_section(name, shdr);
514 // Mark regions of the input file that must be kept unchanged.
516 template<int size, bool big_endian>
518 Sized_incremental_binary<size, big_endian>::do_reserve_layout(
519 unsigned int input_file_index)
521 Input_entry_reader input_file =
522 this->inputs_reader_.input_file(input_file_index);
524 if (input_file.type() == INCREMENTAL_INPUT_SHARED_LIBRARY)
527 unsigned int shnum = input_file.get_input_section_count();
528 for (unsigned int i = 0; i < shnum; i++)
530 typename Input_entry_reader::Input_section_info sect =
531 input_file.get_input_section(i);
532 if (sect.output_shndx == 0 || sect.sh_offset == -1)
534 Output_section* os = this->section_map_[sect.output_shndx];
535 gold_assert(os != NULL);
536 os->reserve(sect.sh_offset, sect.sh_size);
540 // Process the GOT and PLT entries from the existing output file.
542 template<int size, bool big_endian>
544 Sized_incremental_binary<size, big_endian>::do_process_got_plt(
545 Symbol_table* symtab,
548 Incremental_got_plt_reader<big_endian> got_plt_reader(this->got_plt_reader());
549 Sized_target<size, big_endian>* target =
550 parameters->sized_target<size, big_endian>();
552 // Get the number of symbols in the main symbol table and in the
553 // incremental symbol table. The difference between the two counts
554 // is the index of the first forced-local or global symbol in the
555 // main symbol table.
556 unsigned int symtab_count =
557 this->main_symtab_loc_.data_size / elfcpp::Elf_sizes<size>::sym_size;
558 unsigned int isym_count = this->symtab_reader_.symbol_count();
559 unsigned int first_global = symtab_count - isym_count;
561 // Tell the target how big the GOT and PLT sections are.
562 unsigned int got_count = got_plt_reader.get_got_entry_count();
563 unsigned int plt_count = got_plt_reader.get_plt_entry_count();
564 Output_data_got<size, big_endian>* got =
565 target->init_got_plt_for_update(symtab, layout, got_count, plt_count);
567 // Read the GOT entries from the base file and build the outgoing GOT.
568 for (unsigned int i = 0; i < got_count; ++i)
570 unsigned int got_type = got_plt_reader.get_got_type(i);
571 if ((got_type & 0x7f) == 0x7f)
573 // This is the second entry of a pair.
574 got->reserve_slot(i);
577 unsigned int symndx = got_plt_reader.get_got_symndx(i);
580 // This is an entry for a local symbol. Ignore this entry if
581 // the object file was replaced.
582 unsigned int input_index = got_plt_reader.get_got_input_index(i);
583 gold_debug(DEBUG_INCREMENTAL,
584 "GOT entry %d, type %02x: (local symbol)",
586 Sized_relobj_incr<size, big_endian>* obj =
587 this->input_object(input_index);
589 target->reserve_local_got_entry(i, obj, symndx, got_type & 0x7f);
593 // This is an entry for a global symbol. GOT_DESC is the symbol
595 // FIXME: This should really be a fatal error (corrupt input).
596 gold_assert(symndx >= first_global && symndx < symtab_count);
597 Symbol* sym = this->global_symbol(symndx - first_global);
598 gold_debug(DEBUG_INCREMENTAL,
599 "GOT entry %d, type %02x: %s",
600 i, got_type, sym->name());
601 target->reserve_global_got_entry(i, sym, got_type);
605 // Read the PLT entries from the base file and pass each to the target.
606 for (unsigned int i = 0; i < plt_count; ++i)
608 unsigned int plt_desc = got_plt_reader.get_plt_desc(i);
609 // FIXME: This should really be a fatal error (corrupt input).
610 gold_assert(plt_desc >= first_global && plt_desc < symtab_count);
611 Symbol* sym = this->global_symbol(plt_desc - first_global);
612 gold_debug(DEBUG_INCREMENTAL,
615 target->register_global_plt_entry(i, sym);
619 // Apply incremental relocations for symbols whose values have changed.
621 template<int size, bool big_endian>
623 Sized_incremental_binary<size, big_endian>::do_apply_incremental_relocs(
624 const Symbol_table* symtab,
628 typedef typename elfcpp::Elf_types<size>::Elf_Addr Address;
629 typedef typename elfcpp::Elf_types<size>::Elf_Swxword Addend;
630 Incremental_symtab_reader<big_endian> isymtab(this->symtab_reader());
631 Incremental_relocs_reader<size, big_endian> irelocs(this->relocs_reader());
632 unsigned int nglobals = isymtab.symbol_count();
633 const unsigned int incr_reloc_size = irelocs.reloc_size;
635 Relocate_info<size, big_endian> relinfo;
636 relinfo.symtab = symtab;
637 relinfo.layout = layout;
638 relinfo.object = NULL;
639 relinfo.reloc_shndx = 0;
640 relinfo.reloc_shdr = NULL;
641 relinfo.data_shndx = 0;
642 relinfo.data_shdr = NULL;
644 Sized_target<size, big_endian>* target =
645 parameters->sized_target<size, big_endian>();
647 for (unsigned int i = 0; i < nglobals; i++)
649 const Symbol* gsym = this->global_symbol(i);
651 // If the symbol is not referenced from any unchanged input files,
652 // we do not need to reapply any of its relocations.
656 // If the symbol is defined in an unchanged file, we do not need to
657 // reapply any of its relocations.
658 if (gsym->source() == Symbol::FROM_OBJECT
659 && gsym->object()->is_incremental())
662 gold_debug(DEBUG_INCREMENTAL,
663 "Applying incremental relocations for global symbol %s [%d]",
666 // Follow the linked list of input symbol table entries for this symbol.
667 // We don't bother to figure out whether the symbol table entry belongs
668 // to a changed or unchanged file because it's easier just to apply all
669 // the relocations -- although we might scribble over an area that has
670 // been reallocated, we do this before copying any new data into the
672 unsigned int offset = isymtab.get_list_head(i);
675 Incremental_global_symbol_reader<big_endian> sym_info =
676 this->inputs_reader().global_symbol_reader_at_offset(offset);
677 unsigned int r_base = sym_info.reloc_offset();
678 unsigned int r_count = sym_info.reloc_count();
680 // Apply each relocation for this symbol table entry.
681 for (unsigned int j = 0; j < r_count;
682 ++j, r_base += incr_reloc_size)
684 unsigned int r_type = irelocs.get_r_type(r_base);
685 unsigned int r_shndx = irelocs.get_r_shndx(r_base);
686 Address r_offset = irelocs.get_r_offset(r_base);
687 Addend r_addend = irelocs.get_r_addend(r_base);
688 Output_section* os = this->output_section(r_shndx);
689 Address address = os->address();
690 off_t section_offset = os->offset();
691 size_t view_size = os->data_size();
692 unsigned char* const view = of->get_output_view(section_offset,
695 gold_debug(DEBUG_INCREMENTAL,
696 " %08lx: %s + %d: type %d addend %ld",
697 (long)(section_offset + r_offset),
703 target->apply_relocation(&relinfo, r_offset, r_type, r_addend,
704 gsym, view, address, view_size);
706 // FIXME: Do something more efficient if write_output_view
707 // ever becomes more than a no-op.
708 of->write_output_view(section_offset, view_size, view);
710 offset = sym_info.next_offset();
715 // Get a view of the main symbol table and the symbol string table.
717 template<int size, bool big_endian>
719 Sized_incremental_binary<size, big_endian>::get_symtab_view(
722 elfcpp::Elf_strtab* strtab)
724 *symtab_view = this->view(this->main_symtab_loc_);
725 *nsyms = this->main_symtab_loc_.data_size / elfcpp::Elf_sizes<size>::sym_size;
727 View strtab_view(this->view(this->main_strtab_loc_));
728 *strtab = elfcpp::Elf_strtab(strtab_view.data(),
729 this->main_strtab_loc_.data_size);
735 // Create a Sized_incremental_binary object of the specified size and
736 // endianness. Fails if the target architecture is not supported.
738 template<int size, bool big_endian>
740 make_sized_incremental_binary(Output_file* file,
741 const elfcpp::Ehdr<size, big_endian>& ehdr)
743 Target* target = select_target(ehdr.get_e_machine(), size, big_endian,
744 ehdr.get_e_ident()[elfcpp::EI_OSABI],
745 ehdr.get_e_ident()[elfcpp::EI_ABIVERSION]);
748 explain_no_incremental(_("unsupported ELF machine number %d"),
749 ehdr.get_e_machine());
753 if (!parameters->target_valid())
754 set_parameters_target(target);
755 else if (target != ¶meters->target())
756 gold_error(_("%s: incompatible target"), file->filename());
758 return new Sized_incremental_binary<size, big_endian>(file, ehdr, target);
761 } // End of anonymous namespace.
763 // Create an Incremental_binary object for FILE. Returns NULL is this is not
764 // possible, e.g. FILE is not an ELF file or has an unsupported target. FILE
768 open_incremental_binary(Output_file* file)
770 off_t filesize = file->filesize();
771 int want = elfcpp::Elf_recognizer::max_header_size;
775 const unsigned char* p = file->get_input_view(0, want);
776 if (!elfcpp::Elf_recognizer::is_elf_file(p, want))
778 explain_no_incremental(_("output is not an ELF file."));
783 bool big_endian = false;
785 if (!elfcpp::Elf_recognizer::is_valid_header(p, want, &size, &big_endian,
788 explain_no_incremental(error.c_str());
792 Incremental_binary* result = NULL;
797 #ifdef HAVE_TARGET_32_BIG
798 result = make_sized_incremental_binary<32, true>(
799 file, elfcpp::Ehdr<32, true>(p));
801 explain_no_incremental(_("unsupported file: 32-bit, big-endian"));
806 #ifdef HAVE_TARGET_32_LITTLE
807 result = make_sized_incremental_binary<32, false>(
808 file, elfcpp::Ehdr<32, false>(p));
810 explain_no_incremental(_("unsupported file: 32-bit, little-endian"));
818 #ifdef HAVE_TARGET_64_BIG
819 result = make_sized_incremental_binary<64, true>(
820 file, elfcpp::Ehdr<64, true>(p));
822 explain_no_incremental(_("unsupported file: 64-bit, big-endian"));
827 #ifdef HAVE_TARGET_64_LITTLE
828 result = make_sized_incremental_binary<64, false>(
829 file, elfcpp::Ehdr<64, false>(p));
831 explain_no_incremental(_("unsupported file: 64-bit, little-endian"));
841 // Class Incremental_inputs.
843 // Add the command line to the string table, setting
844 // command_line_key_. In incremental builds, the command line is
845 // stored in .gnu_incremental_inputs so that the next linker run can
846 // check if the command line options didn't change.
849 Incremental_inputs::report_command_line(int argc, const char* const* argv)
851 // Always store 'gold' as argv[0] to avoid a full relink if the user used a
852 // different path to the linker.
853 std::string args("gold");
854 // Copied from collect_argv in main.cc.
855 for (int i = 1; i < argc; ++i)
857 // Adding/removing these options should not result in a full relink.
858 if (strcmp(argv[i], "--incremental") == 0
859 || strcmp(argv[i], "--incremental-full") == 0
860 || strcmp(argv[i], "--incremental-update") == 0
861 || strcmp(argv[i], "--incremental-changed") == 0
862 || strcmp(argv[i], "--incremental-unchanged") == 0
863 || strcmp(argv[i], "--incremental-unknown") == 0
864 || is_prefix_of("--debug=", argv[i]))
868 // Now append argv[i], but with all single-quotes escaped
869 const char* argpos = argv[i];
872 const int len = strcspn(argpos, "'");
873 args.append(argpos, len);
874 if (argpos[len] == '\0')
876 args.append("'\"'\"'");
882 this->command_line_ = args;
883 this->strtab_->add(this->command_line_.c_str(), false,
884 &this->command_line_key_);
887 // Record the input archive file ARCHIVE. This is called by the
888 // Add_archive_symbols task before determining which archive members
889 // to include. We create the Incremental_archive_entry here and
890 // attach it to the Archive, but we do not add it to the list of
891 // input objects until report_archive_end is called.
894 Incremental_inputs::report_archive_begin(Library_base* arch,
895 unsigned int arg_serial,
896 Script_info* script_info)
898 Stringpool::Key filename_key;
899 Timespec mtime = arch->get_mtime();
901 // For a file loaded from a script, don't record its argument serial number.
902 if (script_info != NULL)
905 this->strtab_->add(arch->filename().c_str(), false, &filename_key);
906 Incremental_archive_entry* entry =
907 new Incremental_archive_entry(filename_key, arg_serial, mtime);
908 arch->set_incremental_info(entry);
910 if (script_info != NULL)
912 Incremental_script_entry* script_entry = script_info->incremental_info();
913 gold_assert(script_entry != NULL);
914 script_entry->add_object(entry);
918 // Visitor class for processing the unused global symbols in a library.
919 // An instance of this class is passed to the library's
920 // for_all_unused_symbols() iterator, which will call the visit()
921 // function for each global symbol defined in each unused library
922 // member. We add those symbol names to the incremental info for the
925 class Unused_symbol_visitor : public Library_base::Symbol_visitor_base
928 Unused_symbol_visitor(Incremental_archive_entry* entry, Stringpool* strtab)
929 : entry_(entry), strtab_(strtab)
933 visit(const char* sym)
935 Stringpool::Key symbol_key;
936 this->strtab_->add(sym, true, &symbol_key);
937 this->entry_->add_unused_global_symbol(symbol_key);
941 Incremental_archive_entry* entry_;
945 // Finish recording the input archive file ARCHIVE. This is called by the
946 // Add_archive_symbols task after determining which archive members
950 Incremental_inputs::report_archive_end(Library_base* arch)
952 Incremental_archive_entry* entry = arch->incremental_info();
954 gold_assert(entry != NULL);
955 this->inputs_.push_back(entry);
957 // Collect unused global symbols.
958 Unused_symbol_visitor v(entry, this->strtab_);
959 arch->for_all_unused_symbols(&v);
962 // Record the input object file OBJ. If ARCH is not NULL, attach
963 // the object file to the archive. This is called by the
964 // Add_symbols task after finding out the type of the file.
967 Incremental_inputs::report_object(Object* obj, unsigned int arg_serial,
968 Library_base* arch, Script_info* script_info)
970 Stringpool::Key filename_key;
971 Timespec mtime = obj->get_mtime();
973 // For a file loaded from a script, don't record its argument serial number.
974 if (script_info != NULL)
977 this->strtab_->add(obj->name().c_str(), false, &filename_key);
978 Incremental_object_entry* obj_entry =
979 new Incremental_object_entry(filename_key, obj, arg_serial, mtime);
980 if (obj->is_in_system_directory())
981 obj_entry->set_is_in_system_directory();
982 this->inputs_.push_back(obj_entry);
986 Incremental_archive_entry* arch_entry = arch->incremental_info();
987 gold_assert(arch_entry != NULL);
988 arch_entry->add_object(obj_entry);
991 if (script_info != NULL)
993 Incremental_script_entry* script_entry = script_info->incremental_info();
994 gold_assert(script_entry != NULL);
995 script_entry->add_object(obj_entry);
998 this->current_object_ = obj;
999 this->current_object_entry_ = obj_entry;
1002 // Record the input object file OBJ. If ARCH is not NULL, attach
1003 // the object file to the archive. This is called by the
1004 // Add_symbols task after finding out the type of the file.
1007 Incremental_inputs::report_input_section(Object* obj, unsigned int shndx,
1008 const char* name, off_t sh_size)
1010 Stringpool::Key key = 0;
1013 this->strtab_->add(name, true, &key);
1015 gold_assert(obj == this->current_object_);
1016 this->current_object_entry_->add_input_section(shndx, key, sh_size);
1019 // Record that the input argument INPUT is a script SCRIPT. This is
1020 // called by read_script after parsing the script and reading the list
1021 // of inputs added by this script.
1024 Incremental_inputs::report_script(Script_info* script,
1025 unsigned int arg_serial,
1028 Stringpool::Key filename_key;
1030 this->strtab_->add(script->filename().c_str(), false, &filename_key);
1031 Incremental_script_entry* entry =
1032 new Incremental_script_entry(filename_key, arg_serial, script, mtime);
1033 this->inputs_.push_back(entry);
1034 script->set_incremental_info(entry);
1037 // Finalize the incremental link information. Called from
1038 // Layout::finalize.
1041 Incremental_inputs::finalize()
1043 // Finalize the string table.
1044 this->strtab_->set_string_offsets();
1047 // Create the .gnu_incremental_inputs, _symtab, and _relocs input sections.
1050 Incremental_inputs::create_data_sections(Symbol_table* symtab)
1052 switch (parameters->size_and_endianness())
1054 #ifdef HAVE_TARGET_32_LITTLE
1055 case Parameters::TARGET_32_LITTLE:
1056 this->inputs_section_ =
1057 new Output_section_incremental_inputs<32, false>(this, symtab);
1060 #ifdef HAVE_TARGET_32_BIG
1061 case Parameters::TARGET_32_BIG:
1062 this->inputs_section_ =
1063 new Output_section_incremental_inputs<32, true>(this, symtab);
1066 #ifdef HAVE_TARGET_64_LITTLE
1067 case Parameters::TARGET_64_LITTLE:
1068 this->inputs_section_ =
1069 new Output_section_incremental_inputs<64, false>(this, symtab);
1072 #ifdef HAVE_TARGET_64_BIG
1073 case Parameters::TARGET_64_BIG:
1074 this->inputs_section_ =
1075 new Output_section_incremental_inputs<64, true>(this, symtab);
1081 this->symtab_section_ = new Output_data_space(4, "** incremental_symtab");
1082 this->relocs_section_ = new Output_data_space(4, "** incremental_relocs");
1083 this->got_plt_section_ = new Output_data_space(4, "** incremental_got_plt");
1086 // Return the sh_entsize value for the .gnu_incremental_relocs section.
1088 Incremental_inputs::relocs_entsize() const
1090 return 8 + 2 * parameters->target().get_size() / 8;
1093 // Class Output_section_incremental_inputs.
1095 // Finalize the offsets for each input section and supplemental info block,
1096 // and set the final data size of the incremental output sections.
1098 template<int size, bool big_endian>
1100 Output_section_incremental_inputs<size, big_endian>::set_final_data_size()
1102 const Incremental_inputs* inputs = this->inputs_;
1103 const unsigned int sizeof_addr = size / 8;
1104 const unsigned int rel_size = 8 + 2 * sizeof_addr;
1106 // Offset of each input entry.
1107 unsigned int input_offset = this->header_size;
1109 // Offset of each supplemental info block.
1110 unsigned int file_index = 0;
1111 unsigned int info_offset = this->header_size;
1112 info_offset += this->input_entry_size * inputs->input_file_count();
1114 // Count each input file and its supplemental information block.
1115 for (Incremental_inputs::Input_list::const_iterator p =
1116 inputs->input_files().begin();
1117 p != inputs->input_files().end();
1120 // Set the index and offset of the input file entry.
1121 (*p)->set_offset(file_index, input_offset);
1123 input_offset += this->input_entry_size;
1125 // Set the offset of the supplemental info block.
1126 switch ((*p)->type())
1128 case INCREMENTAL_INPUT_SCRIPT:
1130 Incremental_script_entry *entry = (*p)->script_entry();
1131 gold_assert(entry != NULL);
1132 (*p)->set_info_offset(info_offset);
1136 info_offset += (entry->get_object_count() * 4);
1139 case INCREMENTAL_INPUT_OBJECT:
1140 case INCREMENTAL_INPUT_ARCHIVE_MEMBER:
1142 Incremental_object_entry* entry = (*p)->object_entry();
1143 gold_assert(entry != NULL);
1144 (*p)->set_info_offset(info_offset);
1145 // Input section count, global symbol count, local symbol offset,
1146 // local symbol count, first dynamic reloc, dynamic reloc count.
1148 // Each input section.
1149 info_offset += (entry->get_input_section_count()
1150 * (8 + 2 * sizeof_addr));
1151 // Each global symbol.
1152 const Object::Symbols* syms = entry->object()->get_global_symbols();
1153 info_offset += syms->size() * 20;
1156 case INCREMENTAL_INPUT_SHARED_LIBRARY:
1158 Incremental_object_entry* entry = (*p)->object_entry();
1159 gold_assert(entry != NULL);
1160 (*p)->set_info_offset(info_offset);
1161 // Global symbol count.
1163 // Each global symbol.
1164 const Object::Symbols* syms = entry->object()->get_global_symbols();
1165 gold_assert(syms != NULL);
1166 unsigned int nsyms = syms->size();
1167 unsigned int nsyms_out = 0;
1168 for (unsigned int i = 0; i < nsyms; ++i)
1170 const Symbol* sym = (*syms)[i];
1173 if (sym->is_forwarder())
1174 sym = this->symtab_->resolve_forwards(sym);
1175 if (sym->symtab_index() != -1U)
1178 info_offset += nsyms_out * 4;
1181 case INCREMENTAL_INPUT_ARCHIVE:
1183 Incremental_archive_entry* entry = (*p)->archive_entry();
1184 gold_assert(entry != NULL);
1185 (*p)->set_info_offset(info_offset);
1186 // Member count + unused global symbol count.
1189 info_offset += (entry->get_member_count() * 4);
1190 // Each global symbol.
1191 info_offset += (entry->get_unused_global_symbol_count() * 4);
1199 this->set_data_size(info_offset);
1201 // Set the size of the .gnu_incremental_symtab section.
1202 inputs->symtab_section()->set_current_data_size(this->symtab_->output_count()
1203 * sizeof(unsigned int));
1205 // Set the size of the .gnu_incremental_relocs section.
1206 inputs->relocs_section()->set_current_data_size(inputs->get_reloc_count()
1209 // Set the size of the .gnu_incremental_got_plt section.
1210 Sized_target<size, big_endian>* target =
1211 parameters->sized_target<size, big_endian>();
1212 unsigned int got_count = target->got_entry_count();
1213 unsigned int plt_count = target->plt_entry_count();
1214 unsigned int got_plt_size = 8; // GOT entry count, PLT entry count.
1215 got_plt_size = (got_plt_size + got_count + 3) & ~3; // GOT type array.
1216 got_plt_size += got_count * 8 + plt_count * 4; // GOT array, PLT array.
1217 inputs->got_plt_section()->set_current_data_size(got_plt_size);
1220 // Write the contents of the .gnu_incremental_inputs and
1221 // .gnu_incremental_symtab sections.
1223 template<int size, bool big_endian>
1225 Output_section_incremental_inputs<size, big_endian>::do_write(Output_file* of)
1227 const Incremental_inputs* inputs = this->inputs_;
1228 Stringpool* strtab = inputs->get_stringpool();
1230 // Get a view into the .gnu_incremental_inputs section.
1231 const off_t off = this->offset();
1232 const off_t oview_size = this->data_size();
1233 unsigned char* const oview = of->get_output_view(off, oview_size);
1234 unsigned char* pov = oview;
1236 // Get a view into the .gnu_incremental_symtab section.
1237 const off_t symtab_off = inputs->symtab_section()->offset();
1238 const off_t symtab_size = inputs->symtab_section()->data_size();
1239 unsigned char* const symtab_view = of->get_output_view(symtab_off,
1242 // Allocate an array of linked list heads for the .gnu_incremental_symtab
1243 // section. Each element corresponds to a global symbol in the output
1244 // symbol table, and points to the head of the linked list that threads
1245 // through the object file input entries. The value of each element
1246 // is the section-relative offset to a global symbol entry in a
1247 // supplemental information block.
1248 unsigned int global_sym_count = this->symtab_->output_count();
1249 unsigned int* global_syms = new unsigned int[global_sym_count];
1250 memset(global_syms, 0, global_sym_count * sizeof(unsigned int));
1252 // Write the section header.
1253 Stringpool::Key command_line_key = inputs->command_line_key();
1254 pov = this->write_header(pov, inputs->input_file_count(),
1255 strtab->get_offset_from_key(command_line_key));
1257 // Write the list of input files.
1258 pov = this->write_input_files(oview, pov, strtab);
1260 // Write the supplemental information blocks for each input file.
1261 pov = this->write_info_blocks(oview, pov, strtab, global_syms,
1264 gold_assert(pov - oview == oview_size);
1266 // Write the .gnu_incremental_symtab section.
1267 gold_assert(global_sym_count * 4 == symtab_size);
1268 this->write_symtab(symtab_view, global_syms, global_sym_count);
1270 delete[] global_syms;
1272 // Write the .gnu_incremental_got_plt section.
1273 const off_t got_plt_off = inputs->got_plt_section()->offset();
1274 const off_t got_plt_size = inputs->got_plt_section()->data_size();
1275 unsigned char* const got_plt_view = of->get_output_view(got_plt_off,
1277 this->write_got_plt(got_plt_view, got_plt_size);
1279 of->write_output_view(off, oview_size, oview);
1280 of->write_output_view(symtab_off, symtab_size, symtab_view);
1281 of->write_output_view(got_plt_off, got_plt_size, got_plt_view);
1284 // Write the section header: version, input file count, offset of command line
1285 // in the string table, and 4 bytes of padding.
1287 template<int size, bool big_endian>
1289 Output_section_incremental_inputs<size, big_endian>::write_header(
1291 unsigned int input_file_count,
1292 section_offset_type command_line_offset)
1294 Swap32::writeval(pov, INCREMENTAL_LINK_VERSION);
1295 Swap32::writeval(pov + 4, input_file_count);
1296 Swap32::writeval(pov + 8, command_line_offset);
1297 Swap32::writeval(pov + 12, 0);
1298 return pov + this->header_size;
1301 // Write the input file entries.
1303 template<int size, bool big_endian>
1305 Output_section_incremental_inputs<size, big_endian>::write_input_files(
1306 unsigned char* oview,
1310 const Incremental_inputs* inputs = this->inputs_;
1312 for (Incremental_inputs::Input_list::const_iterator p =
1313 inputs->input_files().begin();
1314 p != inputs->input_files().end();
1317 gold_assert(static_cast<unsigned int>(pov - oview) == (*p)->get_offset());
1318 section_offset_type filename_offset =
1319 strtab->get_offset_from_key((*p)->get_filename_key());
1320 const Timespec& mtime = (*p)->get_mtime();
1321 unsigned int flags = (*p)->type();
1322 if ((*p)->is_in_system_directory())
1323 flags |= INCREMENTAL_INPUT_IN_SYSTEM_DIR;
1324 Swap32::writeval(pov, filename_offset);
1325 Swap32::writeval(pov + 4, (*p)->get_info_offset());
1326 Swap64::writeval(pov + 8, mtime.seconds);
1327 Swap32::writeval(pov + 16, mtime.nanoseconds);
1328 Swap16::writeval(pov + 20, flags);
1329 Swap16::writeval(pov + 22, (*p)->arg_serial());
1330 pov += this->input_entry_size;
1335 // Write the supplemental information blocks.
1337 template<int size, bool big_endian>
1339 Output_section_incremental_inputs<size, big_endian>::write_info_blocks(
1340 unsigned char* oview,
1343 unsigned int* global_syms,
1344 unsigned int global_sym_count)
1346 const Incremental_inputs* inputs = this->inputs_;
1347 unsigned int first_global_index = this->symtab_->first_global_index();
1349 for (Incremental_inputs::Input_list::const_iterator p =
1350 inputs->input_files().begin();
1351 p != inputs->input_files().end();
1354 switch ((*p)->type())
1356 case INCREMENTAL_INPUT_SCRIPT:
1358 gold_assert(static_cast<unsigned int>(pov - oview)
1359 == (*p)->get_info_offset());
1360 Incremental_script_entry* entry = (*p)->script_entry();
1361 gold_assert(entry != NULL);
1363 // Write the object count.
1364 unsigned int nobjects = entry->get_object_count();
1365 Swap32::writeval(pov, nobjects);
1368 // For each object, write the offset to its input file entry.
1369 for (unsigned int i = 0; i < nobjects; ++i)
1371 Incremental_input_entry* obj = entry->get_object(i);
1372 Swap32::writeval(pov, obj->get_offset());
1378 case INCREMENTAL_INPUT_OBJECT:
1379 case INCREMENTAL_INPUT_ARCHIVE_MEMBER:
1381 gold_assert(static_cast<unsigned int>(pov - oview)
1382 == (*p)->get_info_offset());
1383 Incremental_object_entry* entry = (*p)->object_entry();
1384 gold_assert(entry != NULL);
1385 const Object* obj = entry->object();
1386 const Relobj* relobj = static_cast<const Relobj*>(obj);
1387 const Object::Symbols* syms = obj->get_global_symbols();
1388 // Write the input section count and global symbol count.
1389 unsigned int nsections = entry->get_input_section_count();
1390 unsigned int nsyms = syms->size();
1391 off_t locals_offset = relobj->local_symbol_offset();
1392 unsigned int nlocals = relobj->output_local_symbol_count();
1393 unsigned int first_dynrel = relobj->first_dyn_reloc();
1394 unsigned int ndynrel = relobj->dyn_reloc_count();
1395 Swap32::writeval(pov, nsections);
1396 Swap32::writeval(pov + 4, nsyms);
1397 Swap32::writeval(pov + 8, static_cast<unsigned int>(locals_offset));
1398 Swap32::writeval(pov + 12, nlocals);
1399 Swap32::writeval(pov + 16, first_dynrel);
1400 Swap32::writeval(pov + 20, ndynrel);
1403 // Build a temporary array to map input section indexes
1404 // from the original object file index to the index in the
1405 // incremental info table.
1406 unsigned int* index_map = new unsigned int[obj->shnum()];
1407 memset(index_map, 0, obj->shnum() * sizeof(unsigned int));
1409 // For each input section, write the name, output section index,
1410 // offset within output section, and input section size.
1411 for (unsigned int i = 0; i < nsections; i++)
1413 unsigned int shndx = entry->get_input_section_index(i);
1414 index_map[shndx] = i + 1;
1415 Stringpool::Key key = entry->get_input_section_name_key(i);
1416 off_t name_offset = 0;
1418 name_offset = strtab->get_offset_from_key(key);
1420 off_t out_offset = 0;
1422 Output_section* os = obj->output_section(shndx);
1425 out_shndx = os->out_shndx();
1426 out_offset = obj->output_section_offset(shndx);
1427 sh_size = entry->get_input_section_size(i);
1429 Swap32::writeval(pov, name_offset);
1430 Swap32::writeval(pov + 4, out_shndx);
1431 Swap::writeval(pov + 8, out_offset);
1432 Swap::writeval(pov + 8 + sizeof_addr, sh_size);
1433 pov += 8 + 2 * sizeof_addr;
1436 // For each global symbol, write its associated relocations,
1437 // add it to the linked list of globals, then write the
1438 // supplemental information: global symbol table index,
1439 // input section index, linked list chain pointer, relocation
1440 // count, and offset to the relocations.
1441 for (unsigned int i = 0; i < nsyms; i++)
1443 const Symbol* sym = (*syms)[i];
1444 if (sym->is_forwarder())
1445 sym = this->symtab_->resolve_forwards(sym);
1446 unsigned int shndx = 0;
1447 if (sym->source() == Symbol::FROM_OBJECT
1448 && sym->object() == obj
1449 && sym->is_defined())
1452 unsigned int orig_shndx = sym->shndx(&is_ordinary);
1454 shndx = index_map[orig_shndx];
1456 unsigned int symtab_index = sym->symtab_index();
1457 unsigned int chain = 0;
1458 unsigned int first_reloc = 0;
1459 unsigned int nrelocs = obj->get_incremental_reloc_count(i);
1462 gold_assert(symtab_index != -1U
1463 && (symtab_index - first_global_index
1464 < global_sym_count));
1465 first_reloc = obj->get_incremental_reloc_base(i);
1466 chain = global_syms[symtab_index - first_global_index];
1467 global_syms[symtab_index - first_global_index] =
1470 Swap32::writeval(pov, symtab_index);
1471 Swap32::writeval(pov + 4, shndx);
1472 Swap32::writeval(pov + 8, chain);
1473 Swap32::writeval(pov + 12, nrelocs);
1474 Swap32::writeval(pov + 16, first_reloc * 3 * sizeof_addr);
1482 case INCREMENTAL_INPUT_SHARED_LIBRARY:
1484 gold_assert(static_cast<unsigned int>(pov - oview)
1485 == (*p)->get_info_offset());
1486 Incremental_object_entry* entry = (*p)->object_entry();
1487 gold_assert(entry != NULL);
1488 const Object* obj = entry->object();
1489 const Object::Symbols* syms = obj->get_global_symbols();
1491 // Skip the global symbol count for now.
1492 unsigned char* orig_pov = pov;
1495 // For each global symbol, write the global symbol table index.
1496 unsigned int nsyms = syms->size();
1497 unsigned int nsyms_out = 0;
1498 for (unsigned int i = 0; i < nsyms; i++)
1500 const Symbol* sym = (*syms)[i];
1503 if (sym->is_forwarder())
1504 sym = this->symtab_->resolve_forwards(sym);
1505 if (sym->symtab_index() == -1U)
1507 unsigned int def_flag = 0;
1508 if (sym->source() == Symbol::FROM_OBJECT
1509 && sym->object() == obj
1510 && sym->is_defined())
1511 def_flag = 1U << 31;
1512 Swap32::writeval(pov, sym->symtab_index() | def_flag);
1517 // Now write the global symbol count.
1518 Swap32::writeval(orig_pov, nsyms_out);
1522 case INCREMENTAL_INPUT_ARCHIVE:
1524 gold_assert(static_cast<unsigned int>(pov - oview)
1525 == (*p)->get_info_offset());
1526 Incremental_archive_entry* entry = (*p)->archive_entry();
1527 gold_assert(entry != NULL);
1529 // Write the member count and unused global symbol count.
1530 unsigned int nmembers = entry->get_member_count();
1531 unsigned int nsyms = entry->get_unused_global_symbol_count();
1532 Swap32::writeval(pov, nmembers);
1533 Swap32::writeval(pov + 4, nsyms);
1536 // For each member, write the offset to its input file entry.
1537 for (unsigned int i = 0; i < nmembers; ++i)
1539 Incremental_object_entry* member = entry->get_member(i);
1540 Swap32::writeval(pov, member->get_offset());
1544 // For each global symbol, write the name offset.
1545 for (unsigned int i = 0; i < nsyms; ++i)
1547 Stringpool::Key key = entry->get_unused_global_symbol(i);
1548 Swap32::writeval(pov, strtab->get_offset_from_key(key));
1561 // Write the contents of the .gnu_incremental_symtab section.
1563 template<int size, bool big_endian>
1565 Output_section_incremental_inputs<size, big_endian>::write_symtab(
1567 unsigned int* global_syms,
1568 unsigned int global_sym_count)
1570 for (unsigned int i = 0; i < global_sym_count; ++i)
1572 Swap32::writeval(pov, global_syms[i]);
1577 // This struct holds the view information needed to write the
1578 // .gnu_incremental_got_plt section.
1580 struct Got_plt_view_info
1582 // Start of the GOT type array in the output view.
1583 unsigned char* got_type_p;
1584 // Start of the GOT descriptor array in the output view.
1585 unsigned char* got_desc_p;
1586 // Start of the PLT descriptor array in the output view.
1587 unsigned char* plt_desc_p;
1588 // Number of GOT entries.
1589 unsigned int got_count;
1590 // Number of PLT entries.
1591 unsigned int plt_count;
1592 // Offset of the first non-reserved PLT entry (this is a target-dependent value).
1593 unsigned int first_plt_entry_offset;
1594 // Size of a PLT entry (this is a target-dependent value).
1595 unsigned int plt_entry_size;
1596 // Symbol index to write in the GOT descriptor array. For global symbols,
1597 // this is the global symbol table index; for local symbols, it is the
1598 // local symbol table index.
1599 unsigned int sym_index;
1600 // Input file index to write in the GOT descriptor array. For global
1601 // symbols, this is 0; for local symbols, it is the index of the input
1602 // file entry in the .gnu_incremental_inputs section.
1603 unsigned int input_index;
1606 // Functor class for processing a GOT offset list for local symbols.
1607 // Writes the GOT type and symbol index into the GOT type and descriptor
1608 // arrays in the output section.
1610 template<int size, bool big_endian>
1611 class Local_got_offset_visitor : public Got_offset_list::Visitor
1614 Local_got_offset_visitor(struct Got_plt_view_info& info)
1619 visit(unsigned int got_type, unsigned int got_offset)
1621 unsigned int got_index = got_offset / this->got_entry_size_;
1622 gold_assert(got_index < this->info_.got_count);
1623 // We can only handle GOT entry types in the range 0..0x7e
1624 // because we use a byte array to store them, and we use the
1625 // high bit to flag a local symbol.
1626 gold_assert(got_type < 0x7f);
1627 this->info_.got_type_p[got_index] = got_type | 0x80;
1628 unsigned char* pov = this->info_.got_desc_p + got_index * 8;
1629 elfcpp::Swap<32, big_endian>::writeval(pov, this->info_.sym_index);
1630 elfcpp::Swap<32, big_endian>::writeval(pov + 4, this->info_.input_index);
1634 static const unsigned int got_entry_size_ = size / 8;
1635 struct Got_plt_view_info& info_;
1638 // Functor class for processing a GOT offset list. Writes the GOT type
1639 // and symbol index into the GOT type and descriptor arrays in the output
1642 template<int size, bool big_endian>
1643 class Global_got_offset_visitor : public Got_offset_list::Visitor
1646 Global_got_offset_visitor(struct Got_plt_view_info& info)
1651 visit(unsigned int got_type, unsigned int got_offset)
1653 unsigned int got_index = got_offset / this->got_entry_size_;
1654 gold_assert(got_index < this->info_.got_count);
1655 // We can only handle GOT entry types in the range 0..0x7e
1656 // because we use a byte array to store them, and we use the
1657 // high bit to flag a local symbol.
1658 gold_assert(got_type < 0x7f);
1659 this->info_.got_type_p[got_index] = got_type;
1660 unsigned char* pov = this->info_.got_desc_p + got_index * 8;
1661 elfcpp::Swap<32, big_endian>::writeval(pov, this->info_.sym_index);
1662 elfcpp::Swap<32, big_endian>::writeval(pov + 4, 0);
1666 static const unsigned int got_entry_size_ = size / 8;
1667 struct Got_plt_view_info& info_;
1670 // Functor class for processing the global symbol table. Processes the
1671 // GOT offset list for the symbol, and writes the symbol table index
1672 // into the PLT descriptor array in the output section.
1674 template<int size, bool big_endian>
1675 class Global_symbol_visitor_got_plt
1678 Global_symbol_visitor_got_plt(struct Got_plt_view_info& info)
1683 operator()(const Sized_symbol<size>* sym)
1685 typedef Global_got_offset_visitor<size, big_endian> Got_visitor;
1686 const Got_offset_list* got_offsets = sym->got_offset_list();
1687 if (got_offsets != NULL)
1689 this->info_.sym_index = sym->symtab_index();
1690 this->info_.input_index = 0;
1691 Got_visitor v(this->info_);
1692 got_offsets->for_all_got_offsets(&v);
1694 if (sym->has_plt_offset())
1696 unsigned int plt_index =
1697 ((sym->plt_offset() - this->info_.first_plt_entry_offset)
1698 / this->info_.plt_entry_size);
1699 gold_assert(plt_index < this->info_.plt_count);
1700 unsigned char* pov = this->info_.plt_desc_p + plt_index * 4;
1701 elfcpp::Swap<32, big_endian>::writeval(pov, sym->symtab_index());
1706 struct Got_plt_view_info& info_;
1709 // Write the contents of the .gnu_incremental_got_plt section.
1711 template<int size, bool big_endian>
1713 Output_section_incremental_inputs<size, big_endian>::write_got_plt(
1717 Sized_target<size, big_endian>* target =
1718 parameters->sized_target<size, big_endian>();
1720 // Set up the view information for the functors.
1721 struct Got_plt_view_info view_info;
1722 view_info.got_count = target->got_entry_count();
1723 view_info.plt_count = target->plt_entry_count();
1724 view_info.first_plt_entry_offset = target->first_plt_entry_offset();
1725 view_info.plt_entry_size = target->plt_entry_size();
1726 view_info.got_type_p = pov + 8;
1727 view_info.got_desc_p = (view_info.got_type_p
1728 + ((view_info.got_count + 3) & ~3));
1729 view_info.plt_desc_p = view_info.got_desc_p + view_info.got_count * 8;
1731 gold_assert(pov + view_size ==
1732 view_info.plt_desc_p + view_info.plt_count * 4);
1734 // Write the section header.
1735 Swap32::writeval(pov, view_info.got_count);
1736 Swap32::writeval(pov + 4, view_info.plt_count);
1738 // Initialize the GOT type array to 0xff (reserved).
1739 memset(view_info.got_type_p, 0xff, view_info.got_count);
1741 // Write the incremental GOT descriptors for local symbols.
1742 typedef Local_got_offset_visitor<size, big_endian> Got_visitor;
1743 for (Incremental_inputs::Input_list::const_iterator p =
1744 this->inputs_->input_files().begin();
1745 p != this->inputs_->input_files().end();
1748 if ((*p)->type() != INCREMENTAL_INPUT_OBJECT
1749 && (*p)->type() != INCREMENTAL_INPUT_ARCHIVE_MEMBER)
1751 Incremental_object_entry* entry = (*p)->object_entry();
1752 gold_assert(entry != NULL);
1753 const Object* obj = entry->object();
1754 gold_assert(obj != NULL);
1755 view_info.input_index = (*p)->get_file_index();
1756 Got_visitor v(view_info);
1757 obj->for_all_local_got_entries(&v);
1760 // Write the incremental GOT and PLT descriptors for global symbols.
1761 typedef Global_symbol_visitor_got_plt<size, big_endian> Symbol_visitor;
1762 symtab_->for_all_symbols<size, Symbol_visitor>(Symbol_visitor(view_info));
1765 // Class Sized_relobj_incr. Most of these methods are not used for
1766 // Incremental objects, but are required to be implemented by the
1767 // base class Object.
1769 template<int size, bool big_endian>
1770 Sized_relobj_incr<size, big_endian>::Sized_relobj_incr(
1771 const std::string& name,
1772 Sized_incremental_binary<size, big_endian>* ibase,
1773 unsigned int input_file_index)
1774 : Sized_relobj<size, big_endian>(name, NULL), ibase_(ibase),
1775 input_file_index_(input_file_index),
1776 input_reader_(ibase->inputs_reader().input_file(input_file_index)),
1777 local_symbol_count_(0), output_local_dynsym_count_(0),
1778 local_symbol_index_(0), local_symbol_offset_(0), local_dynsym_offset_(0),
1779 symbols_(), incr_reloc_offset_(-1U), incr_reloc_count_(0),
1780 incr_reloc_output_index_(0), incr_relocs_(NULL), local_symbols_()
1782 if (this->input_reader_.is_in_system_directory())
1783 this->set_is_in_system_directory();
1784 const unsigned int shnum = this->input_reader_.get_input_section_count() + 1;
1785 this->set_shnum(shnum);
1786 ibase->set_input_object(input_file_index, this);
1789 // Read the symbols.
1791 template<int size, bool big_endian>
1793 Sized_relobj_incr<size, big_endian>::do_read_symbols(Read_symbols_data*)
1798 // Lay out the input sections.
1800 template<int size, bool big_endian>
1802 Sized_relobj_incr<size, big_endian>::do_layout(
1807 const unsigned int shnum = this->shnum();
1808 Incremental_inputs* incremental_inputs = layout->incremental_inputs();
1809 gold_assert(incremental_inputs != NULL);
1810 Output_sections& out_sections(this->output_sections());
1811 out_sections.resize(shnum);
1812 this->section_offsets().resize(shnum);
1813 for (unsigned int i = 1; i < shnum; i++)
1815 typename Input_entry_reader::Input_section_info sect =
1816 this->input_reader_.get_input_section(i - 1);
1817 // Add the section to the incremental inputs layout.
1818 incremental_inputs->report_input_section(this, i, sect.name,
1820 if (sect.output_shndx == 0 || sect.sh_offset == -1)
1822 Output_section* os = this->ibase_->output_section(sect.output_shndx);
1823 gold_assert(os != NULL);
1824 out_sections[i] = os;
1825 this->section_offsets()[i] = static_cast<Address>(sect.sh_offset);
1829 // Layout sections whose layout was deferred while waiting for
1830 // input files from a plugin.
1831 template<int size, bool big_endian>
1833 Sized_relobj_incr<size, big_endian>::do_layout_deferred_sections(Layout*)
1837 // Add the symbols to the symbol table.
1839 template<int size, bool big_endian>
1841 Sized_relobj_incr<size, big_endian>::do_add_symbols(
1842 Symbol_table* symtab,
1846 const int sym_size = elfcpp::Elf_sizes<size>::sym_size;
1847 unsigned char symbuf[sym_size];
1848 elfcpp::Sym<size, big_endian> sym(symbuf);
1849 elfcpp::Sym_write<size, big_endian> osym(symbuf);
1851 typedef typename elfcpp::Elf_types<size>::Elf_WXword Elf_size_type;
1853 unsigned int nsyms = this->input_reader_.get_global_symbol_count();
1854 this->symbols_.resize(nsyms);
1856 Incremental_binary::View symtab_view(NULL);
1857 unsigned int symtab_count;
1858 elfcpp::Elf_strtab strtab(NULL, 0);
1859 this->ibase_->get_symtab_view(&symtab_view, &symtab_count, &strtab);
1861 Incremental_symtab_reader<big_endian> isymtab(this->ibase_->symtab_reader());
1862 unsigned int isym_count = isymtab.symbol_count();
1863 unsigned int first_global = symtab_count - isym_count;
1865 const unsigned char* sym_p;
1866 for (unsigned int i = 0; i < nsyms; ++i)
1868 Incremental_global_symbol_reader<big_endian> info =
1869 this->input_reader_.get_global_symbol_reader(i);
1870 unsigned int output_symndx = info.output_symndx();
1871 sym_p = symtab_view.data() + output_symndx * sym_size;
1872 elfcpp::Sym<size, big_endian> gsym(sym_p);
1874 if (!strtab.get_c_string(gsym.get_st_name(), &name))
1877 typename elfcpp::Elf_types<size>::Elf_Addr v = gsym.get_st_value();
1878 unsigned int shndx = gsym.get_st_shndx();
1879 elfcpp::STB st_bind = gsym.get_st_bind();
1880 elfcpp::STT st_type = gsym.get_st_type();
1882 // Local hidden symbols start out as globals, but get converted to
1883 // to local during output.
1884 if (st_bind == elfcpp::STB_LOCAL)
1885 st_bind = elfcpp::STB_GLOBAL;
1887 unsigned int input_shndx = info.shndx();
1888 if (input_shndx == 0)
1890 shndx = elfcpp::SHN_UNDEF;
1893 else if (shndx != elfcpp::SHN_ABS)
1895 // Find the input section and calculate the section-relative value.
1896 gold_assert(shndx != elfcpp::SHN_UNDEF);
1897 Output_section* os = this->ibase_->output_section(shndx);
1898 gold_assert(os != NULL && os->has_fixed_layout());
1899 typename Input_entry_reader::Input_section_info sect =
1900 this->input_reader_.get_input_section(input_shndx - 1);
1901 gold_assert(sect.output_shndx == shndx);
1902 if (st_type != elfcpp::STT_TLS)
1904 v -= sect.sh_offset;
1905 shndx = input_shndx;
1908 osym.put_st_name(0);
1909 osym.put_st_value(v);
1910 osym.put_st_size(gsym.get_st_size());
1911 osym.put_st_info(st_bind, st_type);
1912 osym.put_st_other(gsym.get_st_other());
1913 osym.put_st_shndx(shndx);
1916 symtab->add_from_incrobj(this, name, NULL, &sym);
1917 this->ibase_->add_global_symbol(output_symndx - first_global,
1922 // Return TRUE if we should include this object from an archive library.
1924 template<int size, bool big_endian>
1925 Archive::Should_include
1926 Sized_relobj_incr<size, big_endian>::do_should_include_member(
1935 // Iterate over global symbols, calling a visitor class V for each.
1937 template<int size, bool big_endian>
1939 Sized_relobj_incr<size, big_endian>::do_for_all_global_symbols(
1941 Library_base::Symbol_visitor_base*)
1943 // This routine is not used for incremental objects.
1946 // Get the size of a section.
1948 template<int size, bool big_endian>
1950 Sized_relobj_incr<size, big_endian>::do_section_size(unsigned int)
1955 // Get the name of a section.
1957 template<int size, bool big_endian>
1959 Sized_relobj_incr<size, big_endian>::do_section_name(unsigned int)
1964 // Return a view of the contents of a section.
1966 template<int size, bool big_endian>
1968 Sized_relobj_incr<size, big_endian>::do_section_contents(unsigned int)
1973 // Return section flags.
1975 template<int size, bool big_endian>
1977 Sized_relobj_incr<size, big_endian>::do_section_flags(unsigned int)
1982 // Return section entsize.
1984 template<int size, bool big_endian>
1986 Sized_relobj_incr<size, big_endian>::do_section_entsize(unsigned int)
1991 // Return section address.
1993 template<int size, bool big_endian>
1995 Sized_relobj_incr<size, big_endian>::do_section_address(unsigned int)
2000 // Return section type.
2002 template<int size, bool big_endian>
2004 Sized_relobj_incr<size, big_endian>::do_section_type(unsigned int)
2009 // Return the section link field.
2011 template<int size, bool big_endian>
2013 Sized_relobj_incr<size, big_endian>::do_section_link(unsigned int)
2018 // Return the section link field.
2020 template<int size, bool big_endian>
2022 Sized_relobj_incr<size, big_endian>::do_section_info(unsigned int)
2027 // Return the section alignment.
2029 template<int size, bool big_endian>
2031 Sized_relobj_incr<size, big_endian>::do_section_addralign(unsigned int)
2036 // Return the Xindex structure to use.
2038 template<int size, bool big_endian>
2040 Sized_relobj_incr<size, big_endian>::do_initialize_xindex()
2045 // Get symbol counts.
2047 template<int size, bool big_endian>
2049 Sized_relobj_incr<size, big_endian>::do_get_global_symbol_counts(
2050 const Symbol_table*, size_t*, size_t*) const
2057 template<int size, bool big_endian>
2059 Sized_relobj_incr<size, big_endian>::do_read_relocs(Read_relocs_data*)
2063 // Process the relocs to find list of referenced sections. Used only
2064 // during garbage collection.
2066 template<int size, bool big_endian>
2068 Sized_relobj_incr<size, big_endian>::do_gc_process_relocs(Symbol_table*,
2075 // Scan the relocs and adjust the symbol table.
2077 template<int size, bool big_endian>
2079 Sized_relobj_incr<size, big_endian>::do_scan_relocs(Symbol_table*,
2083 // Count the incremental relocations for this object.
2084 unsigned int nsyms = this->input_reader_.get_global_symbol_count();
2085 this->allocate_incremental_reloc_counts();
2086 for (unsigned int i = 0; i < nsyms; i++)
2088 Incremental_global_symbol_reader<big_endian> sym =
2089 this->input_reader_.get_global_symbol_reader(i);
2090 unsigned int reloc_count = sym.reloc_count();
2091 if (reloc_count > 0 && this->incr_reloc_offset_ == -1U)
2092 this->incr_reloc_offset_ = sym.reloc_offset();
2093 this->incr_reloc_count_ += reloc_count;
2094 for (unsigned int j = 0; j < reloc_count; j++)
2095 this->count_incremental_reloc(i);
2097 this->incr_reloc_output_index_ =
2098 layout->incremental_inputs()->get_reloc_count();
2099 this->finalize_incremental_relocs(layout, false);
2101 // The incoming incremental relocations may not end up in the same
2102 // location after the incremental update, because the incremental info
2103 // is regenerated in each link. Because the new location may overlap
2104 // with other data in the updated output file, we need to copy the
2105 // relocations into a buffer so that we can still read them safely
2106 // after we start writing updates to the output file.
2107 if (this->incr_reloc_count_ > 0)
2109 const Incremental_relocs_reader<size, big_endian>& relocs_reader =
2110 this->ibase_->relocs_reader();
2111 const unsigned int incr_reloc_size = relocs_reader.reloc_size;
2112 unsigned int len = this->incr_reloc_count_ * incr_reloc_size;
2113 this->incr_relocs_ = new unsigned char[len];
2114 memcpy(this->incr_relocs_,
2115 relocs_reader.data(this->incr_reloc_offset_),
2120 // Count the local symbols.
2122 template<int size, bool big_endian>
2124 Sized_relobj_incr<size, big_endian>::do_count_local_symbols(
2125 Stringpool_template<char>* pool,
2126 Stringpool_template<char>*)
2128 const int sym_size = elfcpp::Elf_sizes<size>::sym_size;
2130 // Set the count of local symbols based on the incremental info.
2131 unsigned int nlocals = this->input_reader_.get_local_symbol_count();
2132 this->local_symbol_count_ = nlocals;
2133 this->local_symbols_.reserve(nlocals);
2135 // Get views of the base file's symbol table and string table.
2136 Incremental_binary::View symtab_view(NULL);
2137 unsigned int symtab_count;
2138 elfcpp::Elf_strtab strtab(NULL, 0);
2139 this->ibase_->get_symtab_view(&symtab_view, &symtab_count, &strtab);
2141 // Read the local symbols from the base file's symbol table.
2142 off_t off = this->input_reader_.get_local_symbol_offset();
2143 const unsigned char* symp = symtab_view.data() + off;
2144 for (unsigned int i = 0; i < nlocals; ++i, symp += sym_size)
2146 elfcpp::Sym<size, big_endian> sym(symp);
2148 if (!strtab.get_c_string(sym.get_st_name(), &name))
2150 gold_debug(DEBUG_INCREMENTAL, "Local symbol %d: %s", i, name);
2151 name = pool->add(name, true, NULL);
2152 this->local_symbols_.push_back(Local_symbol(name,
2161 // Finalize the local symbols.
2163 template<int size, bool big_endian>
2165 Sized_relobj_incr<size, big_endian>::do_finalize_local_symbols(
2170 this->local_symbol_index_ = index;
2171 this->local_symbol_offset_ = off;
2172 return index + this->local_symbol_count_;
2175 // Set the offset where local dynamic symbol information will be stored.
2177 template<int size, bool big_endian>
2179 Sized_relobj_incr<size, big_endian>::do_set_local_dynsym_indexes(
2182 // FIXME: set local dynsym indexes.
2186 // Set the offset where local dynamic symbol information will be stored.
2188 template<int size, bool big_endian>
2190 Sized_relobj_incr<size, big_endian>::do_set_local_dynsym_offset(off_t)
2195 // Relocate the input sections and write out the local symbols.
2196 // We don't actually do any relocation here. For unchanged input files,
2197 // we reapply relocations only for symbols that have changed; that happens
2198 // in queue_final_tasks. We do need to rewrite the incremental relocations
2201 template<int size, bool big_endian>
2203 Sized_relobj_incr<size, big_endian>::do_relocate(const Symbol_table*,
2204 const Layout* layout,
2207 if (this->incr_reloc_count_ == 0)
2210 const unsigned int incr_reloc_size =
2211 Incremental_relocs_reader<size, big_endian>::reloc_size;
2213 // Get a view for the .gnu_incremental_relocs section.
2214 Incremental_inputs* inputs = layout->incremental_inputs();
2215 gold_assert(inputs != NULL);
2216 const off_t relocs_off = inputs->relocs_section()->offset();
2217 const off_t relocs_size = inputs->relocs_section()->data_size();
2218 unsigned char* const view = of->get_output_view(relocs_off, relocs_size);
2220 // Copy the relocations from the buffer.
2221 off_t off = this->incr_reloc_output_index_ * incr_reloc_size;
2222 unsigned int len = this->incr_reloc_count_ * incr_reloc_size;
2223 memcpy(view + off, this->incr_relocs_, len);
2225 // The output section table may have changed, so we need to map
2226 // the old section index to the new section index for each relocation.
2227 for (unsigned int i = 0; i < this->incr_reloc_count_; ++i)
2229 unsigned char* pov = view + off + i * incr_reloc_size;
2230 unsigned int shndx = elfcpp::Swap<32, big_endian>::readval(pov + 4);
2231 Output_section* os = this->ibase_->output_section(shndx);
2232 gold_assert(os != NULL);
2233 shndx = os->out_shndx();
2234 elfcpp::Swap<32, big_endian>::writeval(pov + 4, shndx);
2237 of->write_output_view(off, len, view);
2239 // Get views into the output file for the portions of the symbol table
2240 // and the dynamic symbol table that we will be writing.
2241 off_t symtab_off = layout->symtab_section()->offset();
2242 off_t output_size = this->local_symbol_count_ * This::sym_size;
2243 unsigned char* oview = NULL;
2244 if (output_size > 0)
2245 oview = of->get_output_view(symtab_off + this->local_symbol_offset_,
2248 off_t dyn_output_size = this->output_local_dynsym_count_ * sym_size;
2249 unsigned char* dyn_oview = NULL;
2250 if (dyn_output_size > 0)
2251 dyn_oview = of->get_output_view(this->local_dynsym_offset_,
2254 // Write the local symbols.
2255 unsigned char* ov = oview;
2256 unsigned char* dyn_ov = dyn_oview;
2257 const Stringpool* sympool = layout->sympool();
2258 const Stringpool* dynpool = layout->dynpool();
2259 Output_symtab_xindex* symtab_xindex = layout->symtab_xindex();
2260 Output_symtab_xindex* dynsym_xindex = layout->dynsym_xindex();
2261 for (unsigned int i = 0; i < this->local_symbol_count_; ++i)
2263 Local_symbol& lsym(this->local_symbols_[i]);
2266 unsigned int st_shndx = this->adjust_sym_shndx(i, lsym.st_shndx,
2270 Output_section* os = this->ibase_->output_section(st_shndx);
2271 st_shndx = os->out_shndx();
2272 if (st_shndx >= elfcpp::SHN_LORESERVE)
2274 symtab_xindex->add(this->local_symbol_index_ + i, st_shndx);
2275 if (lsym.needs_dynsym_entry)
2276 dynsym_xindex->add(lsym.output_dynsym_index, st_shndx);
2277 st_shndx = elfcpp::SHN_XINDEX;
2281 // Write the symbol to the output symbol table.
2283 elfcpp::Sym_write<size, big_endian> osym(ov);
2284 osym.put_st_name(sympool->get_offset(lsym.name));
2285 osym.put_st_value(lsym.st_value);
2286 osym.put_st_size(lsym.st_size);
2287 osym.put_st_info(elfcpp::STB_LOCAL,
2288 static_cast<elfcpp::STT>(lsym.st_type));
2289 osym.put_st_other(0);
2290 osym.put_st_shndx(st_shndx);
2294 // Write the symbol to the output dynamic symbol table.
2295 if (lsym.needs_dynsym_entry)
2297 gold_assert(dyn_ov < dyn_oview + dyn_output_size);
2298 elfcpp::Sym_write<size, big_endian> osym(dyn_ov);
2299 osym.put_st_name(dynpool->get_offset(lsym.name));
2300 osym.put_st_value(lsym.st_value);
2301 osym.put_st_size(lsym.st_size);
2302 osym.put_st_info(elfcpp::STB_LOCAL,
2303 static_cast<elfcpp::STT>(lsym.st_type));
2304 osym.put_st_other(0);
2305 osym.put_st_shndx(st_shndx);
2310 if (output_size > 0)
2312 gold_assert(ov - oview == output_size);
2313 of->write_output_view(symtab_off + this->local_symbol_offset_,
2314 output_size, oview);
2317 if (dyn_output_size > 0)
2319 gold_assert(dyn_ov - dyn_oview == dyn_output_size);
2320 of->write_output_view(this->local_dynsym_offset_, dyn_output_size,
2325 // Set the offset of a section.
2327 template<int size, bool big_endian>
2329 Sized_relobj_incr<size, big_endian>::do_set_section_offset(unsigned int,
2334 // Class Sized_incr_dynobj. Most of these methods are not used for
2335 // Incremental objects, but are required to be implemented by the
2336 // base class Object.
2338 template<int size, bool big_endian>
2339 Sized_incr_dynobj<size, big_endian>::Sized_incr_dynobj(
2340 const std::string& name,
2341 Sized_incremental_binary<size, big_endian>* ibase,
2342 unsigned int input_file_index)
2343 : Dynobj(name, NULL), ibase_(ibase),
2344 input_file_index_(input_file_index),
2345 input_reader_(ibase->inputs_reader().input_file(input_file_index)),
2348 if (this->input_reader_.is_in_system_directory())
2349 this->set_is_in_system_directory();
2353 // Read the symbols.
2355 template<int size, bool big_endian>
2357 Sized_incr_dynobj<size, big_endian>::do_read_symbols(Read_symbols_data*)
2362 // Lay out the input sections.
2364 template<int size, bool big_endian>
2366 Sized_incr_dynobj<size, big_endian>::do_layout(
2373 // Add the symbols to the symbol table.
2375 template<int size, bool big_endian>
2377 Sized_incr_dynobj<size, big_endian>::do_add_symbols(
2378 Symbol_table* symtab,
2382 const int sym_size = elfcpp::Elf_sizes<size>::sym_size;
2383 unsigned char symbuf[sym_size];
2384 elfcpp::Sym<size, big_endian> sym(symbuf);
2385 elfcpp::Sym_write<size, big_endian> osym(symbuf);
2387 typedef typename elfcpp::Elf_types<size>::Elf_WXword Elf_size_type;
2389 unsigned int nsyms = this->input_reader_.get_global_symbol_count();
2390 this->symbols_.resize(nsyms);
2392 Incremental_binary::View symtab_view(NULL);
2393 unsigned int symtab_count;
2394 elfcpp::Elf_strtab strtab(NULL, 0);
2395 this->ibase_->get_symtab_view(&symtab_view, &symtab_count, &strtab);
2397 Incremental_symtab_reader<big_endian> isymtab(this->ibase_->symtab_reader());
2398 unsigned int isym_count = isymtab.symbol_count();
2399 unsigned int first_global = symtab_count - isym_count;
2401 const unsigned char* sym_p;
2402 for (unsigned int i = 0; i < nsyms; ++i)
2405 unsigned int output_symndx =
2406 this->input_reader_.get_output_symbol_index(i, &is_def);
2407 sym_p = symtab_view.data() + output_symndx * sym_size;
2408 elfcpp::Sym<size, big_endian> gsym(sym_p);
2410 if (!strtab.get_c_string(gsym.get_st_name(), &name))
2413 typename elfcpp::Elf_types<size>::Elf_Addr v;
2415 elfcpp::STB st_bind = gsym.get_st_bind();
2416 elfcpp::STT st_type = gsym.get_st_type();
2418 // Local hidden symbols start out as globals, but get converted to
2419 // to local during output.
2420 if (st_bind == elfcpp::STB_LOCAL)
2421 st_bind = elfcpp::STB_GLOBAL;
2425 shndx = elfcpp::SHN_UNDEF;
2430 // For a symbol defined in a shared object, the section index
2431 // is meaningless, as long as it's not SHN_UNDEF.
2433 v = gsym.get_st_value();
2436 osym.put_st_name(0);
2437 osym.put_st_value(v);
2438 osym.put_st_size(gsym.get_st_size());
2439 osym.put_st_info(st_bind, st_type);
2440 osym.put_st_other(gsym.get_st_other());
2441 osym.put_st_shndx(shndx);
2444 symtab->add_from_incrobj<size, big_endian>(this, name, NULL, &sym);
2445 this->ibase_->add_global_symbol(output_symndx - first_global,
2450 // Return TRUE if we should include this object from an archive library.
2452 template<int size, bool big_endian>
2453 Archive::Should_include
2454 Sized_incr_dynobj<size, big_endian>::do_should_include_member(
2463 // Iterate over global symbols, calling a visitor class V for each.
2465 template<int size, bool big_endian>
2467 Sized_incr_dynobj<size, big_endian>::do_for_all_global_symbols(
2469 Library_base::Symbol_visitor_base*)
2471 // This routine is not used for dynamic libraries.
2474 // Iterate over local symbols, calling a visitor class V for each GOT offset
2475 // associated with a local symbol.
2477 template<int size, bool big_endian>
2479 Sized_incr_dynobj<size, big_endian>::do_for_all_local_got_entries(
2480 Got_offset_list::Visitor*) const
2484 // Get the size of a section.
2486 template<int size, bool big_endian>
2488 Sized_incr_dynobj<size, big_endian>::do_section_size(unsigned int)
2493 // Get the name of a section.
2495 template<int size, bool big_endian>
2497 Sized_incr_dynobj<size, big_endian>::do_section_name(unsigned int)
2502 // Return a view of the contents of a section.
2504 template<int size, bool big_endian>
2506 Sized_incr_dynobj<size, big_endian>::do_section_contents(unsigned int)
2511 // Return section flags.
2513 template<int size, bool big_endian>
2515 Sized_incr_dynobj<size, big_endian>::do_section_flags(unsigned int)
2520 // Return section entsize.
2522 template<int size, bool big_endian>
2524 Sized_incr_dynobj<size, big_endian>::do_section_entsize(unsigned int)
2529 // Return section address.
2531 template<int size, bool big_endian>
2533 Sized_incr_dynobj<size, big_endian>::do_section_address(unsigned int)
2538 // Return section type.
2540 template<int size, bool big_endian>
2542 Sized_incr_dynobj<size, big_endian>::do_section_type(unsigned int)
2547 // Return the section link field.
2549 template<int size, bool big_endian>
2551 Sized_incr_dynobj<size, big_endian>::do_section_link(unsigned int)
2556 // Return the section link field.
2558 template<int size, bool big_endian>
2560 Sized_incr_dynobj<size, big_endian>::do_section_info(unsigned int)
2565 // Return the section alignment.
2567 template<int size, bool big_endian>
2569 Sized_incr_dynobj<size, big_endian>::do_section_addralign(unsigned int)
2574 // Return the Xindex structure to use.
2576 template<int size, bool big_endian>
2578 Sized_incr_dynobj<size, big_endian>::do_initialize_xindex()
2583 // Get symbol counts.
2585 template<int size, bool big_endian>
2587 Sized_incr_dynobj<size, big_endian>::do_get_global_symbol_counts(
2588 const Symbol_table*, size_t*, size_t*) const
2593 // Allocate an incremental object of the appropriate size and endianness.
2596 make_sized_incremental_object(
2597 Incremental_binary* ibase,
2598 unsigned int input_file_index,
2599 Incremental_input_type input_type,
2600 const Incremental_binary::Input_reader* input_reader)
2603 std::string name(input_reader->filename());
2605 switch (parameters->size_and_endianness())
2607 #ifdef HAVE_TARGET_32_LITTLE
2608 case Parameters::TARGET_32_LITTLE:
2610 Sized_incremental_binary<32, false>* sized_ibase =
2611 static_cast<Sized_incremental_binary<32, false>*>(ibase);
2612 if (input_type == INCREMENTAL_INPUT_SHARED_LIBRARY)
2613 obj = new Sized_incr_dynobj<32, false>(name, sized_ibase,
2616 obj = new Sized_relobj_incr<32, false>(name, sized_ibase,
2621 #ifdef HAVE_TARGET_32_BIG
2622 case Parameters::TARGET_32_BIG:
2624 Sized_incremental_binary<32, true>* sized_ibase =
2625 static_cast<Sized_incremental_binary<32, true>*>(ibase);
2626 if (input_type == INCREMENTAL_INPUT_SHARED_LIBRARY)
2627 obj = new Sized_incr_dynobj<32, true>(name, sized_ibase,
2630 obj = new Sized_relobj_incr<32, true>(name, sized_ibase,
2635 #ifdef HAVE_TARGET_64_LITTLE
2636 case Parameters::TARGET_64_LITTLE:
2638 Sized_incremental_binary<64, false>* sized_ibase =
2639 static_cast<Sized_incremental_binary<64, false>*>(ibase);
2640 if (input_type == INCREMENTAL_INPUT_SHARED_LIBRARY)
2641 obj = new Sized_incr_dynobj<64, false>(name, sized_ibase,
2644 obj = new Sized_relobj_incr<64, false>(name, sized_ibase,
2649 #ifdef HAVE_TARGET_64_BIG
2650 case Parameters::TARGET_64_BIG:
2652 Sized_incremental_binary<64, true>* sized_ibase =
2653 static_cast<Sized_incremental_binary<64, true>*>(ibase);
2654 if (input_type == INCREMENTAL_INPUT_SHARED_LIBRARY)
2655 obj = new Sized_incr_dynobj<64, true>(name, sized_ibase,
2658 obj = new Sized_relobj_incr<64, true>(name, sized_ibase,
2667 gold_assert(obj != NULL);
2671 // Copy the unused symbols from the incremental input info.
2672 // We need to do this because we may be overwriting the incremental
2673 // input info in the base file before we write the new incremental
2676 Incremental_library::copy_unused_symbols()
2678 unsigned int symcount = this->input_reader_->get_unused_symbol_count();
2679 this->unused_symbols_.reserve(symcount);
2680 for (unsigned int i = 0; i < symcount; ++i)
2682 std::string name(this->input_reader_->get_unused_symbol(i));
2683 this->unused_symbols_.push_back(name);
2687 // Iterator for unused global symbols in the library.
2689 Incremental_library::do_for_all_unused_symbols(Symbol_visitor_base* v) const
2691 for (Symbol_list::const_iterator p = this->unused_symbols_.begin();
2692 p != this->unused_symbols_.end();
2694 v->visit(p->c_str());
2697 // Instantiate the templates we need.
2699 #ifdef HAVE_TARGET_32_LITTLE
2701 class Sized_incremental_binary<32, false>;
2704 class Sized_relobj_incr<32, false>;
2707 class Sized_incr_dynobj<32, false>;
2710 #ifdef HAVE_TARGET_32_BIG
2712 class Sized_incremental_binary<32, true>;
2715 class Sized_relobj_incr<32, true>;
2718 class Sized_incr_dynobj<32, true>;
2721 #ifdef HAVE_TARGET_64_LITTLE
2723 class Sized_incremental_binary<64, false>;
2726 class Sized_relobj_incr<64, false>;
2729 class Sized_incr_dynobj<64, false>;
2732 #ifdef HAVE_TARGET_64_BIG
2734 class Sized_incremental_binary<64, true>;
2737 class Sized_relobj_incr<64, true>;
2740 class Sized_incr_dynobj<64, true>;
2743 } // End namespace gold.