1 // output.cc -- manage the output file for gold
3 // Copyright (C) 2006-2021 Free Software Foundation, Inc.
4 // Written by Ian Lance Taylor <iant@google.com>.
6 // This file is part of gold.
8 // This program is free software; you can redistribute it and/or modify
9 // it under the terms of the GNU General Public License as published by
10 // the Free Software Foundation; either version 3 of the License, or
11 // (at your option) any later version.
13 // This program is distributed in the hope that it will be useful,
14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 // GNU General Public License for more details.
18 // You should have received a copy of the GNU General Public License
19 // along with this program; if not, write to the Free Software
20 // Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 // MA 02110-1301, USA.
33 #ifdef HAVE_SYS_MMAN_H
37 #include "libiberty.h"
40 #include "parameters.h"
45 #include "descriptors.h"
49 // For systems without mmap support.
51 # define mmap gold_mmap
52 # define munmap gold_munmap
53 # define mremap gold_mremap
55 # define MAP_FAILED (reinterpret_cast<void*>(-1))
64 # define MAP_PRIVATE 0
66 # ifndef MAP_ANONYMOUS
67 # define MAP_ANONYMOUS 0
74 # define ENOSYS EINVAL
78 gold_mmap(void *, size_t, int, int, int, off_t
)
85 gold_munmap(void *, size_t)
92 gold_mremap(void *, size_t, size_t, int)
100 #if defined(HAVE_MMAP) && !defined(HAVE_MREMAP)
101 # define mremap gold_mremap
102 extern "C" void *gold_mremap(void *, size_t, size_t, int);
105 // Some BSD systems still use MAP_ANON instead of MAP_ANONYMOUS
106 #ifndef MAP_ANONYMOUS
107 # define MAP_ANONYMOUS MAP_ANON
110 #ifndef MREMAP_MAYMOVE
111 # define MREMAP_MAYMOVE 1
114 // Mingw does not have S_ISLNK.
116 # define S_ISLNK(mode) 0
122 // A wrapper around posix_fallocate. If we don't have posix_fallocate,
123 // or the --no-posix-fallocate option is set, we try the fallocate
124 // system call directly. If that fails, we use ftruncate to set
125 // the file size and hope that there is enough disk space.
128 gold_fallocate(int o
, off_t offset
, off_t len
)
133 #ifdef HAVE_POSIX_FALLOCATE
134 if (parameters
->options().posix_fallocate())
136 int err
= ::posix_fallocate(o
, offset
, len
);
137 if (err
!= EINVAL
&& err
!= ENOSYS
&& err
!= EOPNOTSUPP
)
140 #endif // defined(HAVE_POSIX_FALLOCATE)
142 #ifdef HAVE_FALLOCATE
145 int err
= ::fallocate(o
, 0, offset
, len
);
146 if (err
< 0 && errno
!= EINVAL
&& errno
!= ENOSYS
&& errno
!= EOPNOTSUPP
)
149 #endif // defined(HAVE_FALLOCATE)
152 if (::ftruncate(o
, offset
+ len
) < 0)
157 // Output_data variables.
159 bool Output_data::allocated_sizes_are_fixed
;
161 // Output_data methods.
163 Output_data::~Output_data()
167 // Return the default alignment for the target size.
170 Output_data::default_alignment()
172 return Output_data::default_alignment_for_size(
173 parameters
->target().get_size());
176 // Return the default alignment for a size--32 or 64.
179 Output_data::default_alignment_for_size(int size
)
189 // Output_section_header methods. This currently assumes that the
190 // segment and section lists are complete at construction time.
192 Output_section_headers::Output_section_headers(
193 const Layout
* layout
,
194 const Layout::Segment_list
* segment_list
,
195 const Layout::Section_list
* section_list
,
196 const Layout::Section_list
* unattached_section_list
,
197 const Stringpool
* secnamepool
,
198 const Output_section
* shstrtab_section
)
200 segment_list_(segment_list
),
201 section_list_(section_list
),
202 unattached_section_list_(unattached_section_list
),
203 secnamepool_(secnamepool
),
204 shstrtab_section_(shstrtab_section
)
208 // Compute the current data size.
211 Output_section_headers::do_size() const
213 // Count all the sections. Start with 1 for the null section.
215 if (!parameters
->options().relocatable())
217 for (Layout::Segment_list::const_iterator p
=
218 this->segment_list_
->begin();
219 p
!= this->segment_list_
->end();
221 if ((*p
)->type() == elfcpp::PT_LOAD
)
222 count
+= (*p
)->output_section_count();
226 for (Layout::Section_list::const_iterator p
=
227 this->section_list_
->begin();
228 p
!= this->section_list_
->end();
230 if (((*p
)->flags() & elfcpp::SHF_ALLOC
) != 0)
233 count
+= this->unattached_section_list_
->size();
235 const int size
= parameters
->target().get_size();
238 shdr_size
= elfcpp::Elf_sizes
<32>::shdr_size
;
240 shdr_size
= elfcpp::Elf_sizes
<64>::shdr_size
;
244 return count
* shdr_size
;
247 // Write out the section headers.
250 Output_section_headers::do_write(Output_file
* of
)
252 switch (parameters
->size_and_endianness())
254 #ifdef HAVE_TARGET_32_LITTLE
255 case Parameters::TARGET_32_LITTLE
:
256 this->do_sized_write
<32, false>(of
);
259 #ifdef HAVE_TARGET_32_BIG
260 case Parameters::TARGET_32_BIG
:
261 this->do_sized_write
<32, true>(of
);
264 #ifdef HAVE_TARGET_64_LITTLE
265 case Parameters::TARGET_64_LITTLE
:
266 this->do_sized_write
<64, false>(of
);
269 #ifdef HAVE_TARGET_64_BIG
270 case Parameters::TARGET_64_BIG
:
271 this->do_sized_write
<64, true>(of
);
279 template<int size
, bool big_endian
>
281 Output_section_headers::do_sized_write(Output_file
* of
)
283 off_t all_shdrs_size
= this->data_size();
284 unsigned char* view
= of
->get_output_view(this->offset(), all_shdrs_size
);
286 const int shdr_size
= elfcpp::Elf_sizes
<size
>::shdr_size
;
287 unsigned char* v
= view
;
290 typename
elfcpp::Shdr_write
<size
, big_endian
> oshdr(v
);
291 oshdr
.put_sh_name(0);
292 oshdr
.put_sh_type(elfcpp::SHT_NULL
);
293 oshdr
.put_sh_flags(0);
294 oshdr
.put_sh_addr(0);
295 oshdr
.put_sh_offset(0);
297 size_t section_count
= (this->data_size()
298 / elfcpp::Elf_sizes
<size
>::shdr_size
);
299 if (section_count
< elfcpp::SHN_LORESERVE
)
300 oshdr
.put_sh_size(0);
302 oshdr
.put_sh_size(section_count
);
304 unsigned int shstrndx
= this->shstrtab_section_
->out_shndx();
305 if (shstrndx
< elfcpp::SHN_LORESERVE
)
306 oshdr
.put_sh_link(0);
308 oshdr
.put_sh_link(shstrndx
);
310 size_t segment_count
= this->segment_list_
->size();
311 oshdr
.put_sh_info(segment_count
>= elfcpp::PN_XNUM
? segment_count
: 0);
313 oshdr
.put_sh_addralign(0);
314 oshdr
.put_sh_entsize(0);
319 unsigned int shndx
= 1;
320 if (!parameters
->options().relocatable())
322 for (Layout::Segment_list::const_iterator p
=
323 this->segment_list_
->begin();
324 p
!= this->segment_list_
->end();
326 v
= (*p
)->write_section_headers
<size
, big_endian
>(this->layout_
,
333 for (Layout::Section_list::const_iterator p
=
334 this->section_list_
->begin();
335 p
!= this->section_list_
->end();
338 // We do unallocated sections below, except that group
339 // sections have to come first.
340 if (((*p
)->flags() & elfcpp::SHF_ALLOC
) == 0
341 && (*p
)->type() != elfcpp::SHT_GROUP
)
343 gold_assert(shndx
== (*p
)->out_shndx());
344 elfcpp::Shdr_write
<size
, big_endian
> oshdr(v
);
345 (*p
)->write_header(this->layout_
, this->secnamepool_
, &oshdr
);
351 for (Layout::Section_list::const_iterator p
=
352 this->unattached_section_list_
->begin();
353 p
!= this->unattached_section_list_
->end();
356 // For a relocatable link, we did unallocated group sections
357 // above, since they have to come first.
358 if ((*p
)->type() == elfcpp::SHT_GROUP
359 && parameters
->options().relocatable())
361 gold_assert(shndx
== (*p
)->out_shndx());
362 elfcpp::Shdr_write
<size
, big_endian
> oshdr(v
);
363 (*p
)->write_header(this->layout_
, this->secnamepool_
, &oshdr
);
368 of
->write_output_view(this->offset(), all_shdrs_size
, view
);
371 // Output_segment_header methods.
373 Output_segment_headers::Output_segment_headers(
374 const Layout::Segment_list
& segment_list
)
375 : segment_list_(segment_list
)
377 this->set_current_data_size_for_child(this->do_size());
381 Output_segment_headers::do_write(Output_file
* of
)
383 switch (parameters
->size_and_endianness())
385 #ifdef HAVE_TARGET_32_LITTLE
386 case Parameters::TARGET_32_LITTLE
:
387 this->do_sized_write
<32, false>(of
);
390 #ifdef HAVE_TARGET_32_BIG
391 case Parameters::TARGET_32_BIG
:
392 this->do_sized_write
<32, true>(of
);
395 #ifdef HAVE_TARGET_64_LITTLE
396 case Parameters::TARGET_64_LITTLE
:
397 this->do_sized_write
<64, false>(of
);
400 #ifdef HAVE_TARGET_64_BIG
401 case Parameters::TARGET_64_BIG
:
402 this->do_sized_write
<64, true>(of
);
410 template<int size
, bool big_endian
>
412 Output_segment_headers::do_sized_write(Output_file
* of
)
414 const int phdr_size
= elfcpp::Elf_sizes
<size
>::phdr_size
;
415 off_t all_phdrs_size
= this->segment_list_
.size() * phdr_size
;
416 gold_assert(all_phdrs_size
== this->data_size());
417 unsigned char* view
= of
->get_output_view(this->offset(),
419 unsigned char* v
= view
;
420 for (Layout::Segment_list::const_iterator p
= this->segment_list_
.begin();
421 p
!= this->segment_list_
.end();
424 elfcpp::Phdr_write
<size
, big_endian
> ophdr(v
);
425 (*p
)->write_header(&ophdr
);
429 gold_assert(v
- view
== all_phdrs_size
);
431 of
->write_output_view(this->offset(), all_phdrs_size
, view
);
435 Output_segment_headers::do_size() const
437 const int size
= parameters
->target().get_size();
440 phdr_size
= elfcpp::Elf_sizes
<32>::phdr_size
;
442 phdr_size
= elfcpp::Elf_sizes
<64>::phdr_size
;
446 return this->segment_list_
.size() * phdr_size
;
449 // Output_file_header methods.
451 Output_file_header::Output_file_header(Target
* target
,
452 const Symbol_table
* symtab
,
453 const Output_segment_headers
* osh
)
456 segment_header_(osh
),
457 section_header_(NULL
),
460 this->set_data_size(this->do_size());
463 // Set the section table information for a file header.
466 Output_file_header::set_section_info(const Output_section_headers
* shdrs
,
467 const Output_section
* shstrtab
)
469 this->section_header_
= shdrs
;
470 this->shstrtab_
= shstrtab
;
473 // Write out the file header.
476 Output_file_header::do_write(Output_file
* of
)
478 gold_assert(this->offset() == 0);
480 switch (parameters
->size_and_endianness())
482 #ifdef HAVE_TARGET_32_LITTLE
483 case Parameters::TARGET_32_LITTLE
:
484 this->do_sized_write
<32, false>(of
);
487 #ifdef HAVE_TARGET_32_BIG
488 case Parameters::TARGET_32_BIG
:
489 this->do_sized_write
<32, true>(of
);
492 #ifdef HAVE_TARGET_64_LITTLE
493 case Parameters::TARGET_64_LITTLE
:
494 this->do_sized_write
<64, false>(of
);
497 #ifdef HAVE_TARGET_64_BIG
498 case Parameters::TARGET_64_BIG
:
499 this->do_sized_write
<64, true>(of
);
507 // Write out the file header with appropriate size and endianness.
509 template<int size
, bool big_endian
>
511 Output_file_header::do_sized_write(Output_file
* of
)
513 gold_assert(this->offset() == 0);
515 int ehdr_size
= elfcpp::Elf_sizes
<size
>::ehdr_size
;
516 unsigned char* view
= of
->get_output_view(0, ehdr_size
);
517 elfcpp::Ehdr_write
<size
, big_endian
> oehdr(view
);
519 unsigned char e_ident
[elfcpp::EI_NIDENT
];
520 memset(e_ident
, 0, elfcpp::EI_NIDENT
);
521 e_ident
[elfcpp::EI_MAG0
] = elfcpp::ELFMAG0
;
522 e_ident
[elfcpp::EI_MAG1
] = elfcpp::ELFMAG1
;
523 e_ident
[elfcpp::EI_MAG2
] = elfcpp::ELFMAG2
;
524 e_ident
[elfcpp::EI_MAG3
] = elfcpp::ELFMAG3
;
526 e_ident
[elfcpp::EI_CLASS
] = elfcpp::ELFCLASS32
;
528 e_ident
[elfcpp::EI_CLASS
] = elfcpp::ELFCLASS64
;
531 e_ident
[elfcpp::EI_DATA
] = (big_endian
532 ? elfcpp::ELFDATA2MSB
533 : elfcpp::ELFDATA2LSB
);
534 e_ident
[elfcpp::EI_VERSION
] = elfcpp::EV_CURRENT
;
535 oehdr
.put_e_ident(e_ident
);
538 if (parameters
->options().relocatable())
539 e_type
= elfcpp::ET_REL
;
540 else if (parameters
->options().output_is_position_independent())
541 e_type
= elfcpp::ET_DYN
;
543 e_type
= elfcpp::ET_EXEC
;
544 oehdr
.put_e_type(e_type
);
546 oehdr
.put_e_machine(this->target_
->machine_code());
547 oehdr
.put_e_version(elfcpp::EV_CURRENT
);
549 oehdr
.put_e_entry(this->entry
<size
>());
551 if (this->segment_header_
== NULL
)
552 oehdr
.put_e_phoff(0);
554 oehdr
.put_e_phoff(this->segment_header_
->offset());
556 oehdr
.put_e_shoff(this->section_header_
->offset());
557 oehdr
.put_e_flags(this->target_
->processor_specific_flags());
558 oehdr
.put_e_ehsize(elfcpp::Elf_sizes
<size
>::ehdr_size
);
560 if (this->segment_header_
== NULL
)
562 oehdr
.put_e_phentsize(0);
563 oehdr
.put_e_phnum(0);
567 oehdr
.put_e_phentsize(elfcpp::Elf_sizes
<size
>::phdr_size
);
568 size_t phnum
= (this->segment_header_
->data_size()
569 / elfcpp::Elf_sizes
<size
>::phdr_size
);
570 if (phnum
> elfcpp::PN_XNUM
)
571 phnum
= elfcpp::PN_XNUM
;
572 oehdr
.put_e_phnum(phnum
);
575 oehdr
.put_e_shentsize(elfcpp::Elf_sizes
<size
>::shdr_size
);
576 size_t section_count
= (this->section_header_
->data_size()
577 / elfcpp::Elf_sizes
<size
>::shdr_size
);
579 if (section_count
< elfcpp::SHN_LORESERVE
)
580 oehdr
.put_e_shnum(this->section_header_
->data_size()
581 / elfcpp::Elf_sizes
<size
>::shdr_size
);
583 oehdr
.put_e_shnum(0);
585 unsigned int shstrndx
= this->shstrtab_
->out_shndx();
586 if (shstrndx
< elfcpp::SHN_LORESERVE
)
587 oehdr
.put_e_shstrndx(this->shstrtab_
->out_shndx());
589 oehdr
.put_e_shstrndx(elfcpp::SHN_XINDEX
);
591 // Let the target adjust the ELF header, e.g., to set EI_OSABI in
592 // the e_ident field.
593 this->target_
->adjust_elf_header(view
, ehdr_size
);
595 of
->write_output_view(0, ehdr_size
, view
);
598 // Return the value to use for the entry address.
601 typename
elfcpp::Elf_types
<size
>::Elf_Addr
602 Output_file_header::entry()
604 const bool should_issue_warning
= (parameters
->options().entry() != NULL
605 && !parameters
->options().relocatable()
606 && !parameters
->options().shared());
607 const char* entry
= parameters
->entry();
608 Symbol
* sym
= this->symtab_
->lookup(entry
);
610 typename Sized_symbol
<size
>::Value_type v
;
613 Sized_symbol
<size
>* ssym
;
614 ssym
= this->symtab_
->get_sized_symbol
<size
>(sym
);
615 if (!ssym
->is_defined() && should_issue_warning
)
616 gold_warning("entry symbol '%s' exists but is not defined", entry
);
621 // We couldn't find the entry symbol. See if we can parse it as
622 // a number. This supports, e.g., -e 0x1000.
624 v
= strtoull(entry
, &endptr
, 0);
627 if (should_issue_warning
)
628 gold_warning("cannot find entry symbol '%s'", entry
);
636 // Compute the current data size.
639 Output_file_header::do_size() const
641 const int size
= parameters
->target().get_size();
643 return elfcpp::Elf_sizes
<32>::ehdr_size
;
645 return elfcpp::Elf_sizes
<64>::ehdr_size
;
650 // Output_data_const methods.
653 Output_data_const::do_write(Output_file
* of
)
655 of
->write(this->offset(), this->data_
.data(), this->data_
.size());
658 // Output_data_const_buffer methods.
661 Output_data_const_buffer::do_write(Output_file
* of
)
663 of
->write(this->offset(), this->p_
, this->data_size());
666 // Output_section_data methods.
668 // Record the output section, and set the entry size and such.
671 Output_section_data::set_output_section(Output_section
* os
)
673 gold_assert(this->output_section_
== NULL
);
674 this->output_section_
= os
;
675 this->do_adjust_output_section(os
);
678 // Return the section index of the output section.
681 Output_section_data::do_out_shndx() const
683 gold_assert(this->output_section_
!= NULL
);
684 return this->output_section_
->out_shndx();
687 // Set the alignment, which means we may need to update the alignment
688 // of the output section.
691 Output_section_data::set_addralign(uint64_t addralign
)
693 this->addralign_
= addralign
;
694 if (this->output_section_
!= NULL
695 && this->output_section_
->addralign() < addralign
)
696 this->output_section_
->set_addralign(addralign
);
699 // Output_data_strtab methods.
701 // Set the final data size.
704 Output_data_strtab::set_final_data_size()
706 this->strtab_
->set_string_offsets();
707 this->set_data_size(this->strtab_
->get_strtab_size());
710 // Write out a string table.
713 Output_data_strtab::do_write(Output_file
* of
)
715 this->strtab_
->write(of
, this->offset());
718 // Output_reloc methods.
720 // A reloc against a global symbol.
722 template<bool dynamic
, int size
, bool big_endian
>
723 Output_reloc
<elfcpp::SHT_REL
, dynamic
, size
, big_endian
>::Output_reloc(
731 : address_(address
), local_sym_index_(GSYM_CODE
), type_(type
),
732 is_relative_(is_relative
), is_symbolless_(is_symbolless
),
733 is_section_symbol_(false), use_plt_offset_(use_plt_offset
), shndx_(INVALID_CODE
)
735 // this->type_ is a bitfield; make sure TYPE fits.
736 gold_assert(this->type_
== type
);
737 this->u1_
.gsym
= gsym
;
740 this->set_needs_dynsym_index();
743 template<bool dynamic
, int size
, bool big_endian
>
744 Output_reloc
<elfcpp::SHT_REL
, dynamic
, size
, big_endian
>::Output_reloc(
747 Sized_relobj
<size
, big_endian
>* relobj
,
753 : address_(address
), local_sym_index_(GSYM_CODE
), type_(type
),
754 is_relative_(is_relative
), is_symbolless_(is_symbolless
),
755 is_section_symbol_(false), use_plt_offset_(use_plt_offset
), shndx_(shndx
)
757 gold_assert(shndx
!= INVALID_CODE
);
758 // this->type_ is a bitfield; make sure TYPE fits.
759 gold_assert(this->type_
== type
);
760 this->u1_
.gsym
= gsym
;
761 this->u2_
.relobj
= relobj
;
763 this->set_needs_dynsym_index();
766 // A reloc against a local symbol.
768 template<bool dynamic
, int size
, bool big_endian
>
769 Output_reloc
<elfcpp::SHT_REL
, dynamic
, size
, big_endian
>::Output_reloc(
770 Sized_relobj
<size
, big_endian
>* relobj
,
771 unsigned int local_sym_index
,
777 bool is_section_symbol
,
779 : address_(address
), local_sym_index_(local_sym_index
), type_(type
),
780 is_relative_(is_relative
), is_symbolless_(is_symbolless
),
781 is_section_symbol_(is_section_symbol
), use_plt_offset_(use_plt_offset
),
784 gold_assert(local_sym_index
!= GSYM_CODE
785 && local_sym_index
!= INVALID_CODE
);
786 // this->type_ is a bitfield; make sure TYPE fits.
787 gold_assert(this->type_
== type
);
788 this->u1_
.relobj
= relobj
;
791 this->set_needs_dynsym_index();
794 template<bool dynamic
, int size
, bool big_endian
>
795 Output_reloc
<elfcpp::SHT_REL
, dynamic
, size
, big_endian
>::Output_reloc(
796 Sized_relobj
<size
, big_endian
>* relobj
,
797 unsigned int local_sym_index
,
803 bool is_section_symbol
,
805 : address_(address
), local_sym_index_(local_sym_index
), type_(type
),
806 is_relative_(is_relative
), is_symbolless_(is_symbolless
),
807 is_section_symbol_(is_section_symbol
), use_plt_offset_(use_plt_offset
),
810 gold_assert(local_sym_index
!= GSYM_CODE
811 && local_sym_index
!= INVALID_CODE
);
812 gold_assert(shndx
!= INVALID_CODE
);
813 // this->type_ is a bitfield; make sure TYPE fits.
814 gold_assert(this->type_
== type
);
815 this->u1_
.relobj
= relobj
;
816 this->u2_
.relobj
= relobj
;
818 this->set_needs_dynsym_index();
821 // A reloc against the STT_SECTION symbol of an output section.
823 template<bool dynamic
, int size
, bool big_endian
>
824 Output_reloc
<elfcpp::SHT_REL
, dynamic
, size
, big_endian
>::Output_reloc(
830 : address_(address
), local_sym_index_(SECTION_CODE
), type_(type
),
831 is_relative_(is_relative
), is_symbolless_(is_relative
),
832 is_section_symbol_(true), use_plt_offset_(false), shndx_(INVALID_CODE
)
834 // this->type_ is a bitfield; make sure TYPE fits.
835 gold_assert(this->type_
== type
);
839 this->set_needs_dynsym_index();
841 os
->set_needs_symtab_index();
844 template<bool dynamic
, int size
, bool big_endian
>
845 Output_reloc
<elfcpp::SHT_REL
, dynamic
, size
, big_endian
>::Output_reloc(
848 Sized_relobj
<size
, big_endian
>* relobj
,
852 : address_(address
), local_sym_index_(SECTION_CODE
), type_(type
),
853 is_relative_(is_relative
), is_symbolless_(is_relative
),
854 is_section_symbol_(true), use_plt_offset_(false), shndx_(shndx
)
856 gold_assert(shndx
!= INVALID_CODE
);
857 // this->type_ is a bitfield; make sure TYPE fits.
858 gold_assert(this->type_
== type
);
860 this->u2_
.relobj
= relobj
;
862 this->set_needs_dynsym_index();
864 os
->set_needs_symtab_index();
867 // An absolute or relative relocation.
869 template<bool dynamic
, int size
, bool big_endian
>
870 Output_reloc
<elfcpp::SHT_REL
, dynamic
, size
, big_endian
>::Output_reloc(
875 : address_(address
), local_sym_index_(0), type_(type
),
876 is_relative_(is_relative
), is_symbolless_(false),
877 is_section_symbol_(false), use_plt_offset_(false), shndx_(INVALID_CODE
)
879 // this->type_ is a bitfield; make sure TYPE fits.
880 gold_assert(this->type_
== type
);
881 this->u1_
.relobj
= NULL
;
885 template<bool dynamic
, int size
, bool big_endian
>
886 Output_reloc
<elfcpp::SHT_REL
, dynamic
, size
, big_endian
>::Output_reloc(
888 Sized_relobj
<size
, big_endian
>* relobj
,
892 : address_(address
), local_sym_index_(0), type_(type
),
893 is_relative_(is_relative
), is_symbolless_(false),
894 is_section_symbol_(false), use_plt_offset_(false), shndx_(shndx
)
896 gold_assert(shndx
!= INVALID_CODE
);
897 // this->type_ is a bitfield; make sure TYPE fits.
898 gold_assert(this->type_
== type
);
899 this->u1_
.relobj
= NULL
;
900 this->u2_
.relobj
= relobj
;
903 // A target specific relocation.
905 template<bool dynamic
, int size
, bool big_endian
>
906 Output_reloc
<elfcpp::SHT_REL
, dynamic
, size
, big_endian
>::Output_reloc(
911 : address_(address
), local_sym_index_(TARGET_CODE
), type_(type
),
912 is_relative_(false), is_symbolless_(false),
913 is_section_symbol_(false), use_plt_offset_(false), shndx_(INVALID_CODE
)
915 // this->type_ is a bitfield; make sure TYPE fits.
916 gold_assert(this->type_
== type
);
921 template<bool dynamic
, int size
, bool big_endian
>
922 Output_reloc
<elfcpp::SHT_REL
, dynamic
, size
, big_endian
>::Output_reloc(
925 Sized_relobj
<size
, big_endian
>* relobj
,
928 : address_(address
), local_sym_index_(TARGET_CODE
), type_(type
),
929 is_relative_(false), is_symbolless_(false),
930 is_section_symbol_(false), use_plt_offset_(false), shndx_(shndx
)
932 gold_assert(shndx
!= INVALID_CODE
);
933 // this->type_ is a bitfield; make sure TYPE fits.
934 gold_assert(this->type_
== type
);
936 this->u2_
.relobj
= relobj
;
939 // Record that we need a dynamic symbol index for this relocation.
941 template<bool dynamic
, int size
, bool big_endian
>
943 Output_reloc
<elfcpp::SHT_REL
, dynamic
, size
, big_endian
>::
944 set_needs_dynsym_index()
946 if (this->is_symbolless_
)
948 switch (this->local_sym_index_
)
954 this->u1_
.gsym
->set_needs_dynsym_entry();
958 this->u1_
.os
->set_needs_dynsym_index();
962 // The target must take care of this if necessary.
970 const unsigned int lsi
= this->local_sym_index_
;
971 Sized_relobj_file
<size
, big_endian
>* relobj
=
972 this->u1_
.relobj
->sized_relobj();
973 gold_assert(relobj
!= NULL
);
974 if (!this->is_section_symbol_
)
975 relobj
->set_needs_output_dynsym_entry(lsi
);
977 relobj
->output_section(lsi
)->set_needs_dynsym_index();
983 // Get the symbol index of a relocation.
985 template<bool dynamic
, int size
, bool big_endian
>
987 Output_reloc
<elfcpp::SHT_REL
, dynamic
, size
, big_endian
>::get_symbol_index()
991 if (this->is_symbolless_
)
993 switch (this->local_sym_index_
)
999 if (this->u1_
.gsym
== NULL
)
1002 index
= this->u1_
.gsym
->dynsym_index();
1004 index
= this->u1_
.gsym
->symtab_index();
1009 index
= this->u1_
.os
->dynsym_index();
1011 index
= this->u1_
.os
->symtab_index();
1015 index
= parameters
->target().reloc_symbol_index(this->u1_
.arg
,
1020 // Relocations without symbols use a symbol index of 0.
1026 const unsigned int lsi
= this->local_sym_index_
;
1027 Sized_relobj_file
<size
, big_endian
>* relobj
=
1028 this->u1_
.relobj
->sized_relobj();
1029 gold_assert(relobj
!= NULL
);
1030 if (!this->is_section_symbol_
)
1033 index
= relobj
->dynsym_index(lsi
);
1035 index
= relobj
->symtab_index(lsi
);
1039 Output_section
* os
= relobj
->output_section(lsi
);
1040 gold_assert(os
!= NULL
);
1042 index
= os
->dynsym_index();
1044 index
= os
->symtab_index();
1049 gold_assert(index
!= -1U);
1053 // For a local section symbol, get the address of the offset ADDEND
1054 // within the input section.
1056 template<bool dynamic
, int size
, bool big_endian
>
1057 typename
elfcpp::Elf_types
<size
>::Elf_Addr
1058 Output_reloc
<elfcpp::SHT_REL
, dynamic
, size
, big_endian
>::
1059 local_section_offset(Addend addend
) const
1061 gold_assert(this->local_sym_index_
!= GSYM_CODE
1062 && this->local_sym_index_
!= SECTION_CODE
1063 && this->local_sym_index_
!= TARGET_CODE
1064 && this->local_sym_index_
!= INVALID_CODE
1065 && this->local_sym_index_
!= 0
1066 && this->is_section_symbol_
);
1067 const unsigned int lsi
= this->local_sym_index_
;
1068 Output_section
* os
= this->u1_
.relobj
->output_section(lsi
);
1069 gold_assert(os
!= NULL
);
1070 Address offset
= this->u1_
.relobj
->get_output_section_offset(lsi
);
1071 if (offset
!= invalid_address
)
1072 return offset
+ addend
;
1073 // This is a merge section.
1074 Sized_relobj_file
<size
, big_endian
>* relobj
=
1075 this->u1_
.relobj
->sized_relobj();
1076 gold_assert(relobj
!= NULL
);
1077 offset
= os
->output_address(relobj
, lsi
, addend
);
1078 gold_assert(offset
!= invalid_address
);
1082 // Get the output address of a relocation.
1084 template<bool dynamic
, int size
, bool big_endian
>
1085 typename
elfcpp::Elf_types
<size
>::Elf_Addr
1086 Output_reloc
<elfcpp::SHT_REL
, dynamic
, size
, big_endian
>::get_address() const
1088 Address address
= this->address_
;
1089 if (this->shndx_
!= INVALID_CODE
)
1091 Output_section
* os
= this->u2_
.relobj
->output_section(this->shndx_
);
1092 gold_assert(os
!= NULL
);
1093 Address off
= this->u2_
.relobj
->get_output_section_offset(this->shndx_
);
1094 if (off
!= invalid_address
)
1095 address
+= os
->address() + off
;
1098 Sized_relobj_file
<size
, big_endian
>* relobj
=
1099 this->u2_
.relobj
->sized_relobj();
1100 gold_assert(relobj
!= NULL
);
1101 address
= os
->output_address(relobj
, this->shndx_
, address
);
1102 gold_assert(address
!= invalid_address
);
1105 else if (this->u2_
.od
!= NULL
)
1106 address
+= this->u2_
.od
->address();
1110 // Write out the offset and info fields of a Rel or Rela relocation
1113 template<bool dynamic
, int size
, bool big_endian
>
1114 template<typename Write_rel
>
1116 Output_reloc
<elfcpp::SHT_REL
, dynamic
, size
, big_endian
>::write_rel(
1117 Write_rel
* wr
) const
1119 wr
->put_r_offset(this->get_address());
1120 unsigned int sym_index
= this->get_symbol_index();
1121 wr
->put_r_info(elfcpp::elf_r_info
<size
>(sym_index
, this->type_
));
1124 // Write out a Rel relocation.
1126 template<bool dynamic
, int size
, bool big_endian
>
1128 Output_reloc
<elfcpp::SHT_REL
, dynamic
, size
, big_endian
>::write(
1129 unsigned char* pov
) const
1131 elfcpp::Rel_write
<size
, big_endian
> orel(pov
);
1132 this->write_rel(&orel
);
1135 // Get the value of the symbol referred to by a Rel relocation.
1137 template<bool dynamic
, int size
, bool big_endian
>
1138 typename
elfcpp::Elf_types
<size
>::Elf_Addr
1139 Output_reloc
<elfcpp::SHT_REL
, dynamic
, size
, big_endian
>::symbol_value(
1140 Addend addend
) const
1142 if (this->local_sym_index_
== GSYM_CODE
)
1144 const Sized_symbol
<size
>* sym
;
1145 sym
= static_cast<const Sized_symbol
<size
>*>(this->u1_
.gsym
);
1146 if (this->use_plt_offset_
&& sym
->has_plt_offset())
1147 return parameters
->target().plt_address_for_global(sym
);
1149 return sym
->value() + addend
;
1151 if (this->local_sym_index_
== SECTION_CODE
)
1153 gold_assert(!this->use_plt_offset_
);
1154 return this->u1_
.os
->address() + addend
;
1156 gold_assert(this->local_sym_index_
!= TARGET_CODE
1157 && this->local_sym_index_
!= INVALID_CODE
1158 && this->local_sym_index_
!= 0
1159 && !this->is_section_symbol_
);
1160 const unsigned int lsi
= this->local_sym_index_
;
1161 Sized_relobj_file
<size
, big_endian
>* relobj
=
1162 this->u1_
.relobj
->sized_relobj();
1163 gold_assert(relobj
!= NULL
);
1164 if (this->use_plt_offset_
)
1165 return parameters
->target().plt_address_for_local(relobj
, lsi
);
1166 const Symbol_value
<size
>* symval
= relobj
->local_symbol(lsi
);
1167 return symval
->value(relobj
, addend
);
1170 // Reloc comparison. This function sorts the dynamic relocs for the
1171 // benefit of the dynamic linker. First we sort all relative relocs
1172 // to the front. Among relative relocs, we sort by output address.
1173 // Among non-relative relocs, we sort by symbol index, then by output
1176 template<bool dynamic
, int size
, bool big_endian
>
1178 Output_reloc
<elfcpp::SHT_REL
, dynamic
, size
, big_endian
>::
1179 compare(const Output_reloc
<elfcpp::SHT_REL
, dynamic
, size
, big_endian
>& r2
)
1182 if (this->is_relative_
)
1184 if (!r2
.is_relative_
)
1186 // Otherwise sort by reloc address below.
1188 else if (r2
.is_relative_
)
1192 unsigned int sym1
= this->get_symbol_index();
1193 unsigned int sym2
= r2
.get_symbol_index();
1196 else if (sym1
> sym2
)
1198 // Otherwise sort by reloc address.
1201 section_offset_type addr1
= this->get_address();
1202 section_offset_type addr2
= r2
.get_address();
1205 else if (addr1
> addr2
)
1208 // Final tie breaker, in order to generate the same output on any
1209 // host: reloc type.
1210 unsigned int type1
= this->type_
;
1211 unsigned int type2
= r2
.type_
;
1214 else if (type1
> type2
)
1217 // These relocs appear to be exactly the same.
1221 // Write out a Rela relocation.
1223 template<bool dynamic
, int size
, bool big_endian
>
1225 Output_reloc
<elfcpp::SHT_RELA
, dynamic
, size
, big_endian
>::write(
1226 unsigned char* pov
) const
1228 elfcpp::Rela_write
<size
, big_endian
> orel(pov
);
1229 this->rel_
.write_rel(&orel
);
1230 Addend addend
= this->addend_
;
1231 if (this->rel_
.is_target_specific())
1232 addend
= parameters
->target().reloc_addend(this->rel_
.target_arg(),
1233 this->rel_
.type(), addend
);
1234 else if (this->rel_
.is_symbolless())
1235 addend
= this->rel_
.symbol_value(addend
);
1236 else if (this->rel_
.is_local_section_symbol())
1237 addend
= this->rel_
.local_section_offset(addend
);
1238 orel
.put_r_addend(addend
);
1241 // Output_data_reloc_base methods.
1243 // Adjust the output section.
1245 template<int sh_type
, bool dynamic
, int size
, bool big_endian
>
1247 Output_data_reloc_base
<sh_type
, dynamic
, size
, big_endian
>
1248 ::do_adjust_output_section(Output_section
* os
)
1250 if (sh_type
== elfcpp::SHT_REL
)
1251 os
->set_entsize(elfcpp::Elf_sizes
<size
>::rel_size
);
1252 else if (sh_type
== elfcpp::SHT_RELA
)
1253 os
->set_entsize(elfcpp::Elf_sizes
<size
>::rela_size
);
1257 // A STT_GNU_IFUNC symbol may require a IRELATIVE reloc when doing a
1258 // static link. The backends will generate a dynamic reloc section
1259 // to hold this. In that case we don't want to link to the dynsym
1260 // section, because there isn't one.
1262 os
->set_should_link_to_symtab();
1263 else if (parameters
->doing_static_link())
1266 os
->set_should_link_to_dynsym();
1269 // Standard relocation writer, which just calls Output_reloc::write().
1271 template<int sh_type
, bool dynamic
, int size
, bool big_endian
>
1272 struct Output_reloc_writer
1274 typedef Output_reloc
<sh_type
, dynamic
, size
, big_endian
> Output_reloc_type
;
1275 typedef std::vector
<Output_reloc_type
> Relocs
;
1278 write(typename
Relocs::const_iterator p
, unsigned char* pov
)
1282 // Write out relocation data.
1284 template<int sh_type
, bool dynamic
, int size
, bool big_endian
>
1286 Output_data_reloc_base
<sh_type
, dynamic
, size
, big_endian
>::do_write(
1289 typedef Output_reloc_writer
<sh_type
, dynamic
, size
, big_endian
> Writer
;
1290 this->do_write_generic
<Writer
>(of
);
1293 // Class Output_relocatable_relocs.
1295 template<int sh_type
, int size
, bool big_endian
>
1297 Output_relocatable_relocs
<sh_type
, size
, big_endian
>::set_final_data_size()
1299 this->set_data_size(this->rr_
->output_reloc_count()
1300 * Reloc_types
<sh_type
, size
, big_endian
>::reloc_size
);
1303 // class Output_data_group.
1305 template<int size
, bool big_endian
>
1306 Output_data_group
<size
, big_endian
>::Output_data_group(
1307 Sized_relobj_file
<size
, big_endian
>* relobj
,
1308 section_size_type entry_count
,
1309 elfcpp::Elf_Word flags
,
1310 std::vector
<unsigned int>* input_shndxes
)
1311 : Output_section_data(entry_count
* 4, 4, false),
1315 this->input_shndxes_
.swap(*input_shndxes
);
1318 // Write out the section group, which means translating the section
1319 // indexes to apply to the output file.
1321 template<int size
, bool big_endian
>
1323 Output_data_group
<size
, big_endian
>::do_write(Output_file
* of
)
1325 const off_t off
= this->offset();
1326 const section_size_type oview_size
=
1327 convert_to_section_size_type(this->data_size());
1328 unsigned char* const oview
= of
->get_output_view(off
, oview_size
);
1330 elfcpp::Elf_Word
* contents
= reinterpret_cast<elfcpp::Elf_Word
*>(oview
);
1331 elfcpp::Swap
<32, big_endian
>::writeval(contents
, this->flags_
);
1334 for (std::vector
<unsigned int>::const_iterator p
=
1335 this->input_shndxes_
.begin();
1336 p
!= this->input_shndxes_
.end();
1339 Output_section
* os
= this->relobj_
->output_section(*p
);
1341 unsigned int output_shndx
;
1343 output_shndx
= os
->out_shndx();
1346 this->relobj_
->error(_("section group retained but "
1347 "group element discarded"));
1351 elfcpp::Swap
<32, big_endian
>::writeval(contents
, output_shndx
);
1354 size_t wrote
= reinterpret_cast<unsigned char*>(contents
) - oview
;
1355 gold_assert(wrote
== oview_size
);
1357 of
->write_output_view(off
, oview_size
, oview
);
1359 // We no longer need this information.
1360 this->input_shndxes_
.clear();
1363 // Output_data_got::Got_entry methods.
1365 // Write out the entry.
1367 template<int got_size
, bool big_endian
>
1369 Output_data_got
<got_size
, big_endian
>::Got_entry::write(
1370 unsigned int got_indx
,
1371 unsigned char* pov
) const
1375 switch (this->local_sym_index_
)
1379 // If the symbol is resolved locally, we need to write out the
1380 // link-time value, which will be relocated dynamically by a
1381 // RELATIVE relocation.
1382 Symbol
* gsym
= this->u_
.gsym
;
1383 if (this->use_plt_or_tls_offset_
&& gsym
->has_plt_offset())
1384 val
= parameters
->target().plt_address_for_global(gsym
);
1387 switch (parameters
->size_and_endianness())
1389 #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG)
1390 case Parameters::TARGET_32_LITTLE
:
1391 case Parameters::TARGET_32_BIG
:
1393 // This cast is ugly. We don't want to put a
1394 // virtual method in Symbol, because we want Symbol
1395 // to be as small as possible.
1396 Sized_symbol
<32>::Value_type v
;
1397 v
= static_cast<Sized_symbol
<32>*>(gsym
)->value();
1398 val
= convert_types
<Valtype
, Sized_symbol
<32>::Value_type
>(v
);
1402 #if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG)
1403 case Parameters::TARGET_64_LITTLE
:
1404 case Parameters::TARGET_64_BIG
:
1406 Sized_symbol
<64>::Value_type v
;
1407 v
= static_cast<Sized_symbol
<64>*>(gsym
)->value();
1408 val
= convert_types
<Valtype
, Sized_symbol
<64>::Value_type
>(v
);
1415 if (this->use_plt_or_tls_offset_
1416 && gsym
->type() == elfcpp::STT_TLS
)
1417 val
+= parameters
->target().tls_offset_for_global(gsym
,
1424 val
= this->u_
.constant
;
1428 // If we're doing an incremental update, don't touch this GOT entry.
1429 if (parameters
->incremental_update())
1431 val
= this->u_
.constant
;
1436 const Relobj
* object
= this->u_
.object
;
1437 const unsigned int lsi
= this->local_sym_index_
;
1438 bool is_tls
= object
->local_is_tls(lsi
);
1439 if (this->use_plt_or_tls_offset_
&& !is_tls
)
1440 val
= parameters
->target().plt_address_for_local(object
, lsi
);
1443 uint64_t lval
= object
->local_symbol_value(lsi
, this->addend_
);
1444 val
= convert_types
<Valtype
, uint64_t>(lval
);
1445 if (this->use_plt_or_tls_offset_
&& is_tls
)
1446 val
+= parameters
->target().tls_offset_for_local(object
, lsi
,
1453 elfcpp::Swap
<got_size
, big_endian
>::writeval(pov
, val
);
1456 // Output_data_got methods.
1458 // Add an entry for a global symbol to the GOT. This returns true if
1459 // this is a new GOT entry, false if the symbol already had a GOT
1462 template<int got_size
, bool big_endian
>
1464 Output_data_got
<got_size
, big_endian
>::add_global(
1466 unsigned int got_type
)
1468 if (gsym
->has_got_offset(got_type
))
1471 unsigned int got_offset
= this->add_got_entry(Got_entry(gsym
, false));
1472 gsym
->set_got_offset(got_type
, got_offset
);
1476 // Like add_global, but use the PLT offset.
1478 template<int got_size
, bool big_endian
>
1480 Output_data_got
<got_size
, big_endian
>::add_global_plt(Symbol
* gsym
,
1481 unsigned int got_type
)
1483 if (gsym
->has_got_offset(got_type
))
1486 unsigned int got_offset
= this->add_got_entry(Got_entry(gsym
, true));
1487 gsym
->set_got_offset(got_type
, got_offset
);
1491 // Add an entry for a global symbol to the GOT, and add a dynamic
1492 // relocation of type R_TYPE for the GOT entry.
1494 template<int got_size
, bool big_endian
>
1496 Output_data_got
<got_size
, big_endian
>::add_global_with_rel(
1498 unsigned int got_type
,
1499 Output_data_reloc_generic
* rel_dyn
,
1500 unsigned int r_type
)
1502 if (gsym
->has_got_offset(got_type
))
1505 unsigned int got_offset
= this->add_got_entry(Got_entry());
1506 gsym
->set_got_offset(got_type
, got_offset
);
1507 rel_dyn
->add_global_generic(gsym
, r_type
, this, got_offset
, 0);
1510 // Add a pair of entries for a global symbol to the GOT, and add
1511 // dynamic relocations of type R_TYPE_1 and R_TYPE_2, respectively.
1512 // If R_TYPE_2 == 0, add the second entry with no relocation.
1513 template<int got_size
, bool big_endian
>
1515 Output_data_got
<got_size
, big_endian
>::add_global_pair_with_rel(
1517 unsigned int got_type
,
1518 Output_data_reloc_generic
* rel_dyn
,
1519 unsigned int r_type_1
,
1520 unsigned int r_type_2
)
1522 if (gsym
->has_got_offset(got_type
))
1525 unsigned int got_offset
= this->add_got_entry_pair(Got_entry(), Got_entry());
1526 gsym
->set_got_offset(got_type
, got_offset
);
1527 rel_dyn
->add_global_generic(gsym
, r_type_1
, this, got_offset
, 0);
1530 rel_dyn
->add_global_generic(gsym
, r_type_2
, this,
1531 got_offset
+ got_size
/ 8, 0);
1534 // Add an entry for a local symbol to the GOT. This returns true if
1535 // this is a new GOT entry, false if the symbol already has a GOT
1538 template<int got_size
, bool big_endian
>
1540 Output_data_got
<got_size
, big_endian
>::add_local(
1542 unsigned int symndx
,
1543 unsigned int got_type
)
1545 if (object
->local_has_got_offset(symndx
, got_type
))
1548 unsigned int got_offset
= this->add_got_entry(Got_entry(object
, symndx
,
1550 object
->set_local_got_offset(symndx
, got_type
, got_offset
);
1554 // Add an entry for a local symbol plus ADDEND to the GOT. This returns
1555 // true if this is a new GOT entry, false if the symbol already has a GOT
1558 template<int got_size
, bool big_endian
>
1560 Output_data_got
<got_size
, big_endian
>::add_local(
1562 unsigned int symndx
,
1563 unsigned int got_type
,
1566 if (object
->local_has_got_offset(symndx
, got_type
, addend
))
1569 unsigned int got_offset
= this->add_got_entry(Got_entry(object
, symndx
,
1571 object
->set_local_got_offset(symndx
, got_type
, got_offset
, addend
);
1575 // Like add_local, but use the PLT offset.
1577 template<int got_size
, bool big_endian
>
1579 Output_data_got
<got_size
, big_endian
>::add_local_plt(
1581 unsigned int symndx
,
1582 unsigned int got_type
)
1584 if (object
->local_has_got_offset(symndx
, got_type
))
1587 unsigned int got_offset
= this->add_got_entry(Got_entry(object
, symndx
,
1589 object
->set_local_got_offset(symndx
, got_type
, got_offset
);
1593 // Add an entry for a local symbol to the GOT, and add a dynamic
1594 // relocation of type R_TYPE for the GOT entry.
1596 template<int got_size
, bool big_endian
>
1598 Output_data_got
<got_size
, big_endian
>::add_local_with_rel(
1600 unsigned int symndx
,
1601 unsigned int got_type
,
1602 Output_data_reloc_generic
* rel_dyn
,
1603 unsigned int r_type
)
1605 if (object
->local_has_got_offset(symndx
, got_type
))
1608 unsigned int got_offset
= this->add_got_entry(Got_entry());
1609 object
->set_local_got_offset(symndx
, got_type
, got_offset
);
1610 rel_dyn
->add_local_generic(object
, symndx
, r_type
, this, got_offset
, 0);
1613 // Add an entry for a local symbol plus ADDEND to the GOT, and add a dynamic
1614 // relocation of type R_TYPE for the GOT entry.
1616 template<int got_size
, bool big_endian
>
1618 Output_data_got
<got_size
, big_endian
>::add_local_with_rel(
1620 unsigned int symndx
,
1621 unsigned int got_type
,
1622 Output_data_reloc_generic
* rel_dyn
,
1623 unsigned int r_type
, uint64_t addend
)
1625 if (object
->local_has_got_offset(symndx
, got_type
, addend
))
1628 unsigned int got_offset
= this->add_got_entry(Got_entry());
1629 object
->set_local_got_offset(symndx
, got_type
, got_offset
, addend
);
1630 rel_dyn
->add_local_generic(object
, symndx
, r_type
, this, got_offset
,
1634 // Add a pair of entries for a local symbol to the GOT, and add
1635 // a dynamic relocation of type R_TYPE using the section symbol of
1636 // the output section to which input section SHNDX maps, on the first.
1637 // The first got entry will have a value of zero, the second the
1638 // value of the local symbol.
1639 template<int got_size
, bool big_endian
>
1641 Output_data_got
<got_size
, big_endian
>::add_local_pair_with_rel(
1643 unsigned int symndx
,
1645 unsigned int got_type
,
1646 Output_data_reloc_generic
* rel_dyn
,
1647 unsigned int r_type
)
1649 if (object
->local_has_got_offset(symndx
, got_type
))
1652 unsigned int got_offset
=
1653 this->add_got_entry_pair(Got_entry(),
1654 Got_entry(object
, symndx
, false));
1655 object
->set_local_got_offset(symndx
, got_type
, got_offset
);
1656 Output_section
* os
= object
->output_section(shndx
);
1657 rel_dyn
->add_output_section_generic(os
, r_type
, this, got_offset
, 0);
1660 // Add a pair of entries for a local symbol plus ADDEND to the GOT, and add
1661 // a dynamic relocation of type R_TYPE using the section symbol of
1662 // the output section to which input section SHNDX maps, on the first.
1663 // The first got entry will have a value of zero, the second the
1664 // value of the local symbol.
1665 template<int got_size
, bool big_endian
>
1667 Output_data_got
<got_size
, big_endian
>::add_local_pair_with_rel(
1669 unsigned int symndx
,
1671 unsigned int got_type
,
1672 Output_data_reloc_generic
* rel_dyn
,
1673 unsigned int r_type
, uint64_t addend
)
1675 if (object
->local_has_got_offset(symndx
, got_type
, addend
))
1678 unsigned int got_offset
=
1679 this->add_got_entry_pair(Got_entry(),
1680 Got_entry(object
, symndx
, false, addend
));
1681 object
->set_local_got_offset(symndx
, got_type
, got_offset
, addend
);
1682 Output_section
* os
= object
->output_section(shndx
);
1683 rel_dyn
->add_output_section_generic(os
, r_type
, this, got_offset
, addend
);
1686 // Add a pair of entries for a local symbol to the GOT, and add
1687 // a dynamic relocation of type R_TYPE using STN_UNDEF on the first.
1688 // The first got entry will have a value of zero, the second the
1689 // value of the local symbol offset by Target::tls_offset_for_local.
1690 template<int got_size
, bool big_endian
>
1692 Output_data_got
<got_size
, big_endian
>::add_local_tls_pair(
1694 unsigned int symndx
,
1695 unsigned int got_type
,
1696 Output_data_reloc_generic
* rel_dyn
,
1697 unsigned int r_type
)
1699 if (object
->local_has_got_offset(symndx
, got_type
))
1702 unsigned int got_offset
1703 = this->add_got_entry_pair(Got_entry(),
1704 Got_entry(object
, symndx
, true));
1705 object
->set_local_got_offset(symndx
, got_type
, got_offset
);
1706 rel_dyn
->add_local_generic(object
, 0, r_type
, this, got_offset
, 0);
1709 // Reserve a slot in the GOT for a local symbol or the second slot of a pair.
1711 template<int got_size
, bool big_endian
>
1713 Output_data_got
<got_size
, big_endian
>::reserve_local(
1716 unsigned int sym_index
,
1717 unsigned int got_type
)
1719 this->do_reserve_slot(i
);
1720 object
->set_local_got_offset(sym_index
, got_type
, this->got_offset(i
));
1723 // Reserve a slot in the GOT for a global symbol.
1725 template<int got_size
, bool big_endian
>
1727 Output_data_got
<got_size
, big_endian
>::reserve_global(
1730 unsigned int got_type
)
1732 this->do_reserve_slot(i
);
1733 gsym
->set_got_offset(got_type
, this->got_offset(i
));
1736 // Write out the GOT.
1738 template<int got_size
, bool big_endian
>
1740 Output_data_got
<got_size
, big_endian
>::do_write(Output_file
* of
)
1742 const int add
= got_size
/ 8;
1744 const off_t off
= this->offset();
1745 const off_t oview_size
= this->data_size();
1746 unsigned char* const oview
= of
->get_output_view(off
, oview_size
);
1748 unsigned char* pov
= oview
;
1749 for (unsigned int i
= 0; i
< this->entries_
.size(); ++i
)
1751 this->entries_
[i
].write(i
, pov
);
1755 gold_assert(pov
- oview
== oview_size
);
1757 of
->write_output_view(off
, oview_size
, oview
);
1759 // We no longer need the GOT entries.
1760 this->entries_
.clear();
1763 // Create a new GOT entry and return its offset.
1765 template<int got_size
, bool big_endian
>
1767 Output_data_got
<got_size
, big_endian
>::add_got_entry(Got_entry got_entry
)
1769 if (!this->is_data_size_valid())
1771 this->entries_
.push_back(got_entry
);
1772 this->set_got_size();
1773 return this->last_got_offset();
1777 // For an incremental update, find an available slot.
1778 off_t got_offset
= this->free_list_
.allocate(got_size
/ 8,
1780 if (got_offset
== -1)
1781 gold_fallback(_("out of patch space (GOT);"
1782 " relink with --incremental-full"));
1783 unsigned int got_index
= got_offset
/ (got_size
/ 8);
1784 gold_assert(got_index
< this->entries_
.size());
1785 this->entries_
[got_index
] = got_entry
;
1786 return static_cast<unsigned int>(got_offset
);
1790 // Create a pair of new GOT entries and return the offset of the first.
1792 template<int got_size
, bool big_endian
>
1794 Output_data_got
<got_size
, big_endian
>::add_got_entry_pair(
1795 Got_entry got_entry_1
,
1796 Got_entry got_entry_2
)
1798 if (!this->is_data_size_valid())
1800 unsigned int got_offset
;
1801 this->entries_
.push_back(got_entry_1
);
1802 got_offset
= this->last_got_offset();
1803 this->entries_
.push_back(got_entry_2
);
1804 this->set_got_size();
1809 // For an incremental update, find an available pair of slots.
1810 off_t got_offset
= this->free_list_
.allocate(2 * got_size
/ 8,
1812 if (got_offset
== -1)
1813 gold_fallback(_("out of patch space (GOT);"
1814 " relink with --incremental-full"));
1815 unsigned int got_index
= got_offset
/ (got_size
/ 8);
1816 gold_assert(got_index
< this->entries_
.size());
1817 this->entries_
[got_index
] = got_entry_1
;
1818 this->entries_
[got_index
+ 1] = got_entry_2
;
1819 return static_cast<unsigned int>(got_offset
);
1823 // Replace GOT entry I with a new value.
1825 template<int got_size
, bool big_endian
>
1827 Output_data_got
<got_size
, big_endian
>::replace_got_entry(
1829 Got_entry got_entry
)
1831 gold_assert(i
< this->entries_
.size());
1832 this->entries_
[i
] = got_entry
;
1835 // Output_data_dynamic::Dynamic_entry methods.
1837 // Write out the entry.
1839 template<int size
, bool big_endian
>
1841 Output_data_dynamic::Dynamic_entry::write(
1843 const Stringpool
* pool
) const
1845 typename
elfcpp::Elf_types
<size
>::Elf_WXword val
;
1846 switch (this->offset_
)
1848 case DYNAMIC_NUMBER
:
1852 case DYNAMIC_SECTION_SIZE
:
1853 val
= this->u_
.od
->data_size();
1854 if (this->od2
!= NULL
)
1855 val
+= this->od2
->data_size();
1858 case DYNAMIC_SYMBOL
:
1860 const Sized_symbol
<size
>* s
=
1861 static_cast<const Sized_symbol
<size
>*>(this->u_
.sym
);
1866 case DYNAMIC_STRING
:
1867 val
= pool
->get_offset(this->u_
.str
);
1870 case DYNAMIC_CUSTOM
:
1871 val
= parameters
->target().dynamic_tag_custom_value(this->tag_
);
1875 val
= this->u_
.od
->address() + this->offset_
;
1879 elfcpp::Dyn_write
<size
, big_endian
> dw(pov
);
1880 dw
.put_d_tag(this->tag_
);
1884 // Output_data_dynamic methods.
1886 // Adjust the output section to set the entry size.
1889 Output_data_dynamic::do_adjust_output_section(Output_section
* os
)
1891 if (parameters
->target().get_size() == 32)
1892 os
->set_entsize(elfcpp::Elf_sizes
<32>::dyn_size
);
1893 else if (parameters
->target().get_size() == 64)
1894 os
->set_entsize(elfcpp::Elf_sizes
<64>::dyn_size
);
1899 // Get a dynamic entry offset.
1902 Output_data_dynamic::get_entry_offset(elfcpp::DT tag
) const
1906 if (parameters
->target().get_size() == 32)
1907 dyn_size
= elfcpp::Elf_sizes
<32>::dyn_size
;
1908 else if (parameters
->target().get_size() == 64)
1909 dyn_size
= elfcpp::Elf_sizes
<64>::dyn_size
;
1913 for (size_t i
= 0; i
< entries_
.size(); ++i
)
1914 if (entries_
[i
].tag() == tag
)
1915 return i
* dyn_size
;
1920 // Set the final data size.
1923 Output_data_dynamic::set_final_data_size()
1925 // Add the terminating entry if it hasn't been added.
1926 // Because of relaxation, we can run this multiple times.
1927 if (this->entries_
.empty() || this->entries_
.back().tag() != elfcpp::DT_NULL
)
1929 int extra
= parameters
->options().spare_dynamic_tags();
1930 for (int i
= 0; i
< extra
; ++i
)
1931 this->add_constant(elfcpp::DT_NULL
, 0);
1932 this->add_constant(elfcpp::DT_NULL
, 0);
1936 if (parameters
->target().get_size() == 32)
1937 dyn_size
= elfcpp::Elf_sizes
<32>::dyn_size
;
1938 else if (parameters
->target().get_size() == 64)
1939 dyn_size
= elfcpp::Elf_sizes
<64>::dyn_size
;
1942 this->set_data_size(this->entries_
.size() * dyn_size
);
1945 // Write out the dynamic entries.
1948 Output_data_dynamic::do_write(Output_file
* of
)
1950 switch (parameters
->size_and_endianness())
1952 #ifdef HAVE_TARGET_32_LITTLE
1953 case Parameters::TARGET_32_LITTLE
:
1954 this->sized_write
<32, false>(of
);
1957 #ifdef HAVE_TARGET_32_BIG
1958 case Parameters::TARGET_32_BIG
:
1959 this->sized_write
<32, true>(of
);
1962 #ifdef HAVE_TARGET_64_LITTLE
1963 case Parameters::TARGET_64_LITTLE
:
1964 this->sized_write
<64, false>(of
);
1967 #ifdef HAVE_TARGET_64_BIG
1968 case Parameters::TARGET_64_BIG
:
1969 this->sized_write
<64, true>(of
);
1977 template<int size
, bool big_endian
>
1979 Output_data_dynamic::sized_write(Output_file
* of
)
1981 const int dyn_size
= elfcpp::Elf_sizes
<size
>::dyn_size
;
1983 const off_t offset
= this->offset();
1984 const off_t oview_size
= this->data_size();
1985 unsigned char* const oview
= of
->get_output_view(offset
, oview_size
);
1987 unsigned char* pov
= oview
;
1988 for (typename
Dynamic_entries::const_iterator p
= this->entries_
.begin();
1989 p
!= this->entries_
.end();
1992 p
->write
<size
, big_endian
>(pov
, this->pool_
);
1996 gold_assert(pov
- oview
== oview_size
);
1998 of
->write_output_view(offset
, oview_size
, oview
);
2000 // We no longer need the dynamic entries.
2001 this->entries_
.clear();
2004 // Class Output_symtab_xindex.
2007 Output_symtab_xindex::do_write(Output_file
* of
)
2009 const off_t offset
= this->offset();
2010 const off_t oview_size
= this->data_size();
2011 unsigned char* const oview
= of
->get_output_view(offset
, oview_size
);
2013 memset(oview
, 0, oview_size
);
2015 if (parameters
->target().is_big_endian())
2016 this->endian_do_write
<true>(oview
);
2018 this->endian_do_write
<false>(oview
);
2020 of
->write_output_view(offset
, oview_size
, oview
);
2022 // We no longer need the data.
2023 this->entries_
.clear();
2026 template<bool big_endian
>
2028 Output_symtab_xindex::endian_do_write(unsigned char* const oview
)
2030 for (Xindex_entries::const_iterator p
= this->entries_
.begin();
2031 p
!= this->entries_
.end();
2034 unsigned int symndx
= p
->first
;
2035 gold_assert(static_cast<off_t
>(symndx
) * 4 < this->data_size());
2036 elfcpp::Swap
<32, big_endian
>::writeval(oview
+ symndx
* 4, p
->second
);
2040 // Output_fill_debug_info methods.
2042 // Return the minimum size needed for a dummy compilation unit header.
2045 Output_fill_debug_info::do_minimum_hole_size() const
2047 // Compile unit header fields: unit_length, version, debug_abbrev_offset,
2049 const size_t len
= 4 + 2 + 4 + 1;
2050 // For type units, add type_signature, type_offset.
2051 if (this->is_debug_types_
)
2056 // Write a dummy compilation unit header to fill a hole in the
2057 // .debug_info or .debug_types section.
2060 Output_fill_debug_info::do_write(Output_file
* of
, off_t off
, size_t len
) const
2062 gold_debug(DEBUG_INCREMENTAL
, "fill_debug_info(%08lx, %08lx)",
2063 static_cast<long>(off
), static_cast<long>(len
));
2065 gold_assert(len
>= this->do_minimum_hole_size());
2067 unsigned char* const oview
= of
->get_output_view(off
, len
);
2068 unsigned char* pov
= oview
;
2070 // Write header fields: unit_length, version, debug_abbrev_offset,
2072 if (this->is_big_endian())
2074 elfcpp::Swap_unaligned
<32, true>::writeval(pov
, len
- 4);
2075 elfcpp::Swap_unaligned
<16, true>::writeval(pov
+ 4, this->version
);
2076 elfcpp::Swap_unaligned
<32, true>::writeval(pov
+ 6, 0);
2080 elfcpp::Swap_unaligned
<32, false>::writeval(pov
, len
- 4);
2081 elfcpp::Swap_unaligned
<16, false>::writeval(pov
+ 4, this->version
);
2082 elfcpp::Swap_unaligned
<32, false>::writeval(pov
+ 6, 0);
2087 // For type units, the additional header fields -- type_signature,
2088 // type_offset -- can be filled with zeroes.
2090 // Fill the remainder of the free space with zeroes. The first
2091 // zero should tell the consumer there are no DIEs to read in this
2092 // compilation unit.
2093 if (pov
< oview
+ len
)
2094 memset(pov
, 0, oview
+ len
- pov
);
2096 of
->write_output_view(off
, len
, oview
);
2099 // Output_fill_debug_line methods.
2101 // Return the minimum size needed for a dummy line number program header.
2104 Output_fill_debug_line::do_minimum_hole_size() const
2106 // Line number program header fields: unit_length, version, header_length,
2107 // minimum_instruction_length, default_is_stmt, line_base, line_range,
2108 // opcode_base, standard_opcode_lengths[], include_directories, filenames.
2109 const size_t len
= 4 + 2 + 4 + this->header_length
;
2113 // Write a dummy line number program header to fill a hole in the
2114 // .debug_line section.
2117 Output_fill_debug_line::do_write(Output_file
* of
, off_t off
, size_t len
) const
2119 gold_debug(DEBUG_INCREMENTAL
, "fill_debug_line(%08lx, %08lx)",
2120 static_cast<long>(off
), static_cast<long>(len
));
2122 gold_assert(len
>= this->do_minimum_hole_size());
2124 unsigned char* const oview
= of
->get_output_view(off
, len
);
2125 unsigned char* pov
= oview
;
2127 // Write header fields: unit_length, version, header_length,
2128 // minimum_instruction_length, default_is_stmt, line_base, line_range,
2129 // opcode_base, standard_opcode_lengths[], include_directories, filenames.
2130 // We set the header_length field to cover the entire hole, so the
2131 // line number program is empty.
2132 if (this->is_big_endian())
2134 elfcpp::Swap_unaligned
<32, true>::writeval(pov
, len
- 4);
2135 elfcpp::Swap_unaligned
<16, true>::writeval(pov
+ 4, this->version
);
2136 elfcpp::Swap_unaligned
<32, true>::writeval(pov
+ 6, len
- (4 + 2 + 4));
2140 elfcpp::Swap_unaligned
<32, false>::writeval(pov
, len
- 4);
2141 elfcpp::Swap_unaligned
<16, false>::writeval(pov
+ 4, this->version
);
2142 elfcpp::Swap_unaligned
<32, false>::writeval(pov
+ 6, len
- (4 + 2 + 4));
2145 *pov
++ = 1; // minimum_instruction_length
2146 *pov
++ = 0; // default_is_stmt
2147 *pov
++ = 0; // line_base
2148 *pov
++ = 5; // line_range
2149 *pov
++ = 13; // opcode_base
2150 *pov
++ = 0; // standard_opcode_lengths[1]
2151 *pov
++ = 1; // standard_opcode_lengths[2]
2152 *pov
++ = 1; // standard_opcode_lengths[3]
2153 *pov
++ = 1; // standard_opcode_lengths[4]
2154 *pov
++ = 1; // standard_opcode_lengths[5]
2155 *pov
++ = 0; // standard_opcode_lengths[6]
2156 *pov
++ = 0; // standard_opcode_lengths[7]
2157 *pov
++ = 0; // standard_opcode_lengths[8]
2158 *pov
++ = 1; // standard_opcode_lengths[9]
2159 *pov
++ = 0; // standard_opcode_lengths[10]
2160 *pov
++ = 0; // standard_opcode_lengths[11]
2161 *pov
++ = 1; // standard_opcode_lengths[12]
2162 *pov
++ = 0; // include_directories (empty)
2163 *pov
++ = 0; // filenames (empty)
2165 // Some consumers don't check the header_length field, and simply
2166 // start reading the line number program immediately following the
2167 // header. For those consumers, we fill the remainder of the free
2168 // space with DW_LNS_set_basic_block opcodes. These are effectively
2169 // no-ops: the resulting line table program will not create any rows.
2170 if (pov
< oview
+ len
)
2171 memset(pov
, elfcpp::DW_LNS_set_basic_block
, oview
+ len
- pov
);
2173 of
->write_output_view(off
, len
, oview
);
2176 // Output_section::Input_section methods.
2178 // Return the current data size. For an input section we store the size here.
2179 // For an Output_section_data, we have to ask it for the size.
2182 Output_section::Input_section::current_data_size() const
2184 if (this->is_input_section())
2185 return this->u1_
.data_size
;
2188 this->u2_
.posd
->pre_finalize_data_size();
2189 return this->u2_
.posd
->current_data_size();
2193 // Return the data size. For an input section we store the size here.
2194 // For an Output_section_data, we have to ask it for the size.
2197 Output_section::Input_section::data_size() const
2199 if (this->is_input_section())
2200 return this->u1_
.data_size
;
2202 return this->u2_
.posd
->data_size();
2205 // Return the object for an input section.
2208 Output_section::Input_section::relobj() const
2210 if (this->is_input_section())
2211 return this->u2_
.object
;
2212 else if (this->is_merge_section())
2214 gold_assert(this->u2_
.pomb
->first_relobj() != NULL
);
2215 return this->u2_
.pomb
->first_relobj();
2217 else if (this->is_relaxed_input_section())
2218 return this->u2_
.poris
->relobj();
2223 // Return the input section index for an input section.
2226 Output_section::Input_section::shndx() const
2228 if (this->is_input_section())
2229 return this->shndx_
;
2230 else if (this->is_merge_section())
2232 gold_assert(this->u2_
.pomb
->first_relobj() != NULL
);
2233 return this->u2_
.pomb
->first_shndx();
2235 else if (this->is_relaxed_input_section())
2236 return this->u2_
.poris
->shndx();
2241 // Set the address and file offset.
2244 Output_section::Input_section::set_address_and_file_offset(
2247 off_t section_file_offset
)
2249 if (this->is_input_section())
2250 this->u2_
.object
->set_section_offset(this->shndx_
,
2251 file_offset
- section_file_offset
);
2253 this->u2_
.posd
->set_address_and_file_offset(address
, file_offset
);
2256 // Reset the address and file offset.
2259 Output_section::Input_section::reset_address_and_file_offset()
2261 if (!this->is_input_section())
2262 this->u2_
.posd
->reset_address_and_file_offset();
2265 // Finalize the data size.
2268 Output_section::Input_section::finalize_data_size()
2270 if (!this->is_input_section())
2271 this->u2_
.posd
->finalize_data_size();
2274 // Try to turn an input offset into an output offset. We want to
2275 // return the output offset relative to the start of this
2276 // Input_section in the output section.
2279 Output_section::Input_section::output_offset(
2280 const Relobj
* object
,
2282 section_offset_type offset
,
2283 section_offset_type
* poutput
) const
2285 if (!this->is_input_section())
2286 return this->u2_
.posd
->output_offset(object
, shndx
, offset
, poutput
);
2289 if (this->shndx_
!= shndx
|| this->u2_
.object
!= object
)
2296 // Write out the data. We don't have to do anything for an input
2297 // section--they are handled via Object::relocate--but this is where
2298 // we write out the data for an Output_section_data.
2301 Output_section::Input_section::write(Output_file
* of
)
2303 if (!this->is_input_section())
2304 this->u2_
.posd
->write(of
);
2307 // Write the data to a buffer. As for write(), we don't have to do
2308 // anything for an input section.
2311 Output_section::Input_section::write_to_buffer(unsigned char* buffer
)
2313 if (!this->is_input_section())
2314 this->u2_
.posd
->write_to_buffer(buffer
);
2317 // Print to a map file.
2320 Output_section::Input_section::print_to_mapfile(Mapfile
* mapfile
) const
2322 switch (this->shndx_
)
2324 case OUTPUT_SECTION_CODE
:
2325 case MERGE_DATA_SECTION_CODE
:
2326 case MERGE_STRING_SECTION_CODE
:
2327 this->u2_
.posd
->print_to_mapfile(mapfile
);
2330 case RELAXED_INPUT_SECTION_CODE
:
2332 Output_relaxed_input_section
* relaxed_section
=
2333 this->relaxed_input_section();
2334 mapfile
->print_input_section(relaxed_section
->relobj(),
2335 relaxed_section
->shndx());
2339 mapfile
->print_input_section(this->u2_
.object
, this->shndx_
);
2344 // Output_section methods.
2346 // Construct an Output_section. NAME will point into a Stringpool.
2348 Output_section::Output_section(const char* name
, elfcpp::Elf_Word type
,
2349 elfcpp::Elf_Xword flags
)
2354 link_section_(NULL
),
2356 info_section_(NULL
),
2361 order_(ORDER_INVALID
),
2366 first_input_offset_(0),
2368 postprocessing_buffer_(NULL
),
2369 needs_symtab_index_(false),
2370 needs_dynsym_index_(false),
2371 should_link_to_symtab_(false),
2372 should_link_to_dynsym_(false),
2373 after_input_sections_(false),
2374 requires_postprocessing_(false),
2375 found_in_sections_clause_(false),
2376 has_load_address_(false),
2377 info_uses_section_index_(false),
2378 input_section_order_specified_(false),
2379 may_sort_attached_input_sections_(false),
2380 must_sort_attached_input_sections_(false),
2381 attached_input_sections_are_sorted_(false),
2383 is_small_section_(false),
2384 is_large_section_(false),
2385 generate_code_fills_at_write_(false),
2386 is_entsize_zero_(false),
2387 section_offsets_need_adjustment_(false),
2389 always_keeps_input_sections_(false),
2390 has_fixed_layout_(false),
2391 is_patch_space_allowed_(false),
2392 is_unique_segment_(false),
2394 extra_segment_flags_(0),
2395 segment_alignment_(0),
2397 lookup_maps_(new Output_section_lookup_maps
),
2399 free_space_fill_(NULL
),
2401 reloc_section_(NULL
)
2403 // An unallocated section has no address. Forcing this means that
2404 // we don't need special treatment for symbols defined in debug
2406 if ((flags
& elfcpp::SHF_ALLOC
) == 0)
2407 this->set_address(0);
2410 Output_section::~Output_section()
2412 delete this->checkpoint_
;
2415 // Set the entry size.
2418 Output_section::set_entsize(uint64_t v
)
2420 if (this->is_entsize_zero_
)
2422 else if (this->entsize_
== 0)
2424 else if (this->entsize_
!= v
)
2427 this->is_entsize_zero_
= 1;
2431 // Add the input section SHNDX, with header SHDR, named SECNAME, in
2432 // OBJECT, to the Output_section. RELOC_SHNDX is the index of a
2433 // relocation section which applies to this section, or 0 if none, or
2434 // -1U if more than one. Return the offset of the input section
2435 // within the output section. Return -1 if the input section will
2436 // receive special handling. In the normal case we don't always keep
2437 // track of input sections for an Output_section. Instead, each
2438 // Object keeps track of the Output_section for each of its input
2439 // sections. However, if HAVE_SECTIONS_SCRIPT is true, we do keep
2440 // track of input sections here; this is used when SECTIONS appears in
2443 template<int size
, bool big_endian
>
2445 Output_section::add_input_section(Layout
* layout
,
2446 Sized_relobj_file
<size
, big_endian
>* object
,
2448 const char* secname
,
2449 const elfcpp::Shdr
<size
, big_endian
>& shdr
,
2450 unsigned int reloc_shndx
,
2451 bool have_sections_script
)
2453 section_size_type input_section_size
= shdr
.get_sh_size();
2454 section_size_type uncompressed_size
;
2455 elfcpp::Elf_Xword addralign
= shdr
.get_sh_addralign();
2456 if (object
->section_is_compressed(shndx
, &uncompressed_size
,
2458 input_section_size
= uncompressed_size
;
2460 if ((addralign
& (addralign
- 1)) != 0)
2462 object
->error(_("invalid alignment %lu for section \"%s\""),
2463 static_cast<unsigned long>(addralign
), secname
);
2467 if (addralign
> this->addralign_
)
2468 this->addralign_
= addralign
;
2470 typename
elfcpp::Elf_types
<size
>::Elf_WXword sh_flags
= shdr
.get_sh_flags();
2471 uint64_t entsize
= shdr
.get_sh_entsize();
2473 // .debug_str is a mergeable string section, but is not always so
2474 // marked by compilers. Mark manually here so we can optimize.
2475 if (strcmp(secname
, ".debug_str") == 0)
2477 sh_flags
|= (elfcpp::SHF_MERGE
| elfcpp::SHF_STRINGS
);
2481 this->update_flags_for_input_section(sh_flags
);
2482 this->set_entsize(entsize
);
2484 // If this is a SHF_MERGE section, we pass all the input sections to
2485 // a Output_data_merge. We don't try to handle relocations for such
2486 // a section. We don't try to handle empty merge sections--they
2487 // mess up the mappings, and are useless anyhow.
2488 // FIXME: Need to handle merge sections during incremental update.
2489 if ((sh_flags
& elfcpp::SHF_MERGE
) != 0
2491 && shdr
.get_sh_size() > 0
2492 && !parameters
->incremental())
2494 // Keep information about merged input sections for rebuilding fast
2495 // lookup maps if we have sections-script or we do relaxation.
2496 bool keeps_input_sections
= (this->always_keeps_input_sections_
2497 || have_sections_script
2498 || parameters
->target().may_relax());
2500 if (this->add_merge_input_section(object
, shndx
, sh_flags
, entsize
,
2501 addralign
, keeps_input_sections
))
2503 // Tell the relocation routines that they need to call the
2504 // output_offset method to determine the final address.
2509 off_t offset_in_section
;
2511 if (this->has_fixed_layout())
2513 // For incremental updates, find a chunk of unused space in the section.
2514 offset_in_section
= this->free_list_
.allocate(input_section_size
,
2516 if (offset_in_section
== -1)
2517 gold_fallback(_("out of patch space in section %s; "
2518 "relink with --incremental-full"),
2520 return offset_in_section
;
2523 offset_in_section
= this->current_data_size_for_child();
2524 off_t aligned_offset_in_section
= align_address(offset_in_section
,
2526 this->set_current_data_size_for_child(aligned_offset_in_section
2527 + input_section_size
);
2529 // Determine if we want to delay code-fill generation until the output
2530 // section is written. When the target is relaxing, we want to delay fill
2531 // generating to avoid adjusting them during relaxation. Also, if we are
2532 // sorting input sections we must delay fill generation.
2533 if (!this->generate_code_fills_at_write_
2534 && !have_sections_script
2535 && (sh_flags
& elfcpp::SHF_EXECINSTR
) != 0
2536 && parameters
->target().has_code_fill()
2537 && (parameters
->target().may_relax()
2538 || layout
->is_section_ordering_specified()))
2540 gold_assert(this->fills_
.empty());
2541 this->generate_code_fills_at_write_
= true;
2544 if (aligned_offset_in_section
> offset_in_section
2545 && !this->generate_code_fills_at_write_
2546 && !have_sections_script
2547 && (sh_flags
& elfcpp::SHF_EXECINSTR
) != 0
2548 && parameters
->target().has_code_fill())
2550 // We need to add some fill data. Using fill_list_ when
2551 // possible is an optimization, since we will often have fill
2552 // sections without input sections.
2553 off_t fill_len
= aligned_offset_in_section
- offset_in_section
;
2554 if (this->input_sections_
.empty())
2555 this->fills_
.push_back(Fill(offset_in_section
, fill_len
));
2558 std::string
fill_data(parameters
->target().code_fill(fill_len
));
2559 Output_data_const
* odc
= new Output_data_const(fill_data
, 1);
2560 this->input_sections_
.push_back(Input_section(odc
));
2564 // We need to keep track of this section if we are already keeping
2565 // track of sections, or if we are relaxing. Also, if this is a
2566 // section which requires sorting, or which may require sorting in
2567 // the future, we keep track of the sections. If the
2568 // --section-ordering-file option is used to specify the order of
2569 // sections, we need to keep track of sections.
2570 if (this->always_keeps_input_sections_
2571 || have_sections_script
2572 || !this->input_sections_
.empty()
2573 || this->may_sort_attached_input_sections()
2574 || this->must_sort_attached_input_sections()
2575 || parameters
->options().user_set_Map()
2576 || parameters
->target().may_relax()
2577 || layout
->is_section_ordering_specified())
2579 Input_section
isecn(object
, shndx
, input_section_size
, addralign
);
2580 /* If section ordering is requested by specifying a ordering file,
2581 using --section-ordering-file, match the section name with
2583 if (parameters
->options().section_ordering_file())
2585 unsigned int section_order_index
=
2586 layout
->find_section_order_index(std::string(secname
));
2587 if (section_order_index
!= 0)
2589 isecn
.set_section_order_index(section_order_index
);
2590 this->set_input_section_order_specified();
2593 this->input_sections_
.push_back(isecn
);
2596 return aligned_offset_in_section
;
2599 // Add arbitrary data to an output section.
2602 Output_section::add_output_section_data(Output_section_data
* posd
)
2604 Input_section
inp(posd
);
2605 this->add_output_section_data(&inp
);
2607 if (posd
->is_data_size_valid())
2609 off_t offset_in_section
;
2610 if (this->has_fixed_layout())
2612 // For incremental updates, find a chunk of unused space.
2613 offset_in_section
= this->free_list_
.allocate(posd
->data_size(),
2614 posd
->addralign(), 0);
2615 if (offset_in_section
== -1)
2616 gold_fallback(_("out of patch space in section %s; "
2617 "relink with --incremental-full"),
2619 // Finalize the address and offset now.
2620 uint64_t addr
= this->address();
2621 off_t offset
= this->offset();
2622 posd
->set_address_and_file_offset(addr
+ offset_in_section
,
2623 offset
+ offset_in_section
);
2627 offset_in_section
= this->current_data_size_for_child();
2628 off_t aligned_offset_in_section
= align_address(offset_in_section
,
2630 this->set_current_data_size_for_child(aligned_offset_in_section
2631 + posd
->data_size());
2634 else if (this->has_fixed_layout())
2636 // For incremental updates, arrange for the data to have a fixed layout.
2637 // This will mean that additions to the data must be allocated from
2638 // free space within the containing output section.
2639 uint64_t addr
= this->address();
2640 posd
->set_address(addr
);
2641 posd
->set_file_offset(0);
2642 // FIXME: This should eventually be unreachable.
2643 // gold_unreachable();
2647 // Add a relaxed input section.
2650 Output_section::add_relaxed_input_section(Layout
* layout
,
2651 Output_relaxed_input_section
* poris
,
2652 const std::string
& name
)
2654 Input_section
inp(poris
);
2656 // If the --section-ordering-file option is used to specify the order of
2657 // sections, we need to keep track of sections.
2658 if (layout
->is_section_ordering_specified())
2660 unsigned int section_order_index
=
2661 layout
->find_section_order_index(name
);
2662 if (section_order_index
!= 0)
2664 inp
.set_section_order_index(section_order_index
);
2665 this->set_input_section_order_specified();
2669 this->add_output_section_data(&inp
);
2670 if (this->lookup_maps_
->is_valid())
2671 this->lookup_maps_
->add_relaxed_input_section(poris
->relobj(),
2672 poris
->shndx(), poris
);
2674 // For a relaxed section, we use the current data size. Linker scripts
2675 // get all the input sections, including relaxed one from an output
2676 // section and add them back to the same output section to compute the
2677 // output section size. If we do not account for sizes of relaxed input
2678 // sections, an output section would be incorrectly sized.
2679 off_t offset_in_section
= this->current_data_size_for_child();
2680 off_t aligned_offset_in_section
= align_address(offset_in_section
,
2681 poris
->addralign());
2682 this->set_current_data_size_for_child(aligned_offset_in_section
2683 + poris
->current_data_size());
2686 // Add arbitrary data to an output section by Input_section.
2689 Output_section::add_output_section_data(Input_section
* inp
)
2691 if (this->input_sections_
.empty())
2692 this->first_input_offset_
= this->current_data_size_for_child();
2694 this->input_sections_
.push_back(*inp
);
2696 uint64_t addralign
= inp
->addralign();
2697 if (addralign
> this->addralign_
)
2698 this->addralign_
= addralign
;
2700 inp
->set_output_section(this);
2703 // Add a merge section to an output section.
2706 Output_section::add_output_merge_section(Output_section_data
* posd
,
2707 bool is_string
, uint64_t entsize
)
2709 Input_section
inp(posd
, is_string
, entsize
);
2710 this->add_output_section_data(&inp
);
2713 // Add an input section to a SHF_MERGE section.
2716 Output_section::add_merge_input_section(Relobj
* object
, unsigned int shndx
,
2717 uint64_t flags
, uint64_t entsize
,
2719 bool keeps_input_sections
)
2721 // We cannot merge sections with entsize == 0.
2725 bool is_string
= (flags
& elfcpp::SHF_STRINGS
) != 0;
2727 // We cannot restore merged input section states.
2728 gold_assert(this->checkpoint_
== NULL
);
2730 // Look up merge sections by required properties.
2731 // Currently, we only invalidate the lookup maps in script processing
2732 // and relaxation. We should not have done either when we reach here.
2733 // So we assume that the lookup maps are valid to simply code.
2734 gold_assert(this->lookup_maps_
->is_valid());
2735 Merge_section_properties
msp(is_string
, entsize
, addralign
);
2736 Output_merge_base
* pomb
= this->lookup_maps_
->find_merge_section(msp
);
2737 bool is_new
= false;
2740 gold_assert(pomb
->is_string() == is_string
2741 && pomb
->entsize() == entsize
2742 && pomb
->addralign() == addralign
);
2746 // Create a new Output_merge_data or Output_merge_string_data.
2748 pomb
= new Output_merge_data(entsize
, addralign
);
2754 pomb
= new Output_merge_string
<char>(addralign
);
2757 pomb
= new Output_merge_string
<uint16_t>(addralign
);
2760 pomb
= new Output_merge_string
<uint32_t>(addralign
);
2766 // If we need to do script processing or relaxation, we need to keep
2767 // the original input sections to rebuild the fast lookup maps.
2768 if (keeps_input_sections
)
2769 pomb
->set_keeps_input_sections();
2773 if (pomb
->add_input_section(object
, shndx
))
2775 // Add new merge section to this output section and link merge
2776 // section properties to new merge section in map.
2779 this->add_output_merge_section(pomb
, is_string
, entsize
);
2780 this->lookup_maps_
->add_merge_section(msp
, pomb
);
2787 // If add_input_section failed, delete new merge section to avoid
2788 // exporting empty merge sections in Output_section::get_input_section.
2795 // Build a relaxation map to speed up relaxation of existing input sections.
2796 // Look up to the first LIMIT elements in INPUT_SECTIONS.
2799 Output_section::build_relaxation_map(
2800 const Input_section_list
& input_sections
,
2802 Relaxation_map
* relaxation_map
) const
2804 for (size_t i
= 0; i
< limit
; ++i
)
2806 const Input_section
& is(input_sections
[i
]);
2807 if (is
.is_input_section() || is
.is_relaxed_input_section())
2809 Section_id
sid(is
.relobj(), is
.shndx());
2810 (*relaxation_map
)[sid
] = i
;
2815 // Convert regular input sections in INPUT_SECTIONS into relaxed input
2816 // sections in RELAXED_SECTIONS. MAP is a prebuilt map from section id
2817 // indices of INPUT_SECTIONS.
2820 Output_section::convert_input_sections_in_list_to_relaxed_sections(
2821 const std::vector
<Output_relaxed_input_section
*>& relaxed_sections
,
2822 const Relaxation_map
& map
,
2823 Input_section_list
* input_sections
)
2825 for (size_t i
= 0; i
< relaxed_sections
.size(); ++i
)
2827 Output_relaxed_input_section
* poris
= relaxed_sections
[i
];
2828 Section_id
sid(poris
->relobj(), poris
->shndx());
2829 Relaxation_map::const_iterator p
= map
.find(sid
);
2830 gold_assert(p
!= map
.end());
2831 gold_assert((*input_sections
)[p
->second
].is_input_section());
2833 // Remember section order index of original input section
2834 // if it is set. Copy it to the relaxed input section.
2836 (*input_sections
)[p
->second
].section_order_index();
2837 (*input_sections
)[p
->second
] = Input_section(poris
);
2838 (*input_sections
)[p
->second
].set_section_order_index(soi
);
2842 // Convert regular input sections into relaxed input sections. RELAXED_SECTIONS
2843 // is a vector of pointers to Output_relaxed_input_section or its derived
2844 // classes. The relaxed sections must correspond to existing input sections.
2847 Output_section::convert_input_sections_to_relaxed_sections(
2848 const std::vector
<Output_relaxed_input_section
*>& relaxed_sections
)
2850 gold_assert(parameters
->target().may_relax());
2852 // We want to make sure that restore_states does not undo the effect of
2853 // this. If there is no checkpoint active, just search the current
2854 // input section list and replace the sections there. If there is
2855 // a checkpoint, also replace the sections there.
2857 // By default, we look at the whole list.
2858 size_t limit
= this->input_sections_
.size();
2860 if (this->checkpoint_
!= NULL
)
2862 // Replace input sections with relaxed input section in the saved
2863 // copy of the input section list.
2864 if (this->checkpoint_
->input_sections_saved())
2867 this->build_relaxation_map(
2868 *(this->checkpoint_
->input_sections()),
2869 this->checkpoint_
->input_sections()->size(),
2871 this->convert_input_sections_in_list_to_relaxed_sections(
2874 this->checkpoint_
->input_sections());
2878 // We have not copied the input section list yet. Instead, just
2879 // look at the portion that would be saved.
2880 limit
= this->checkpoint_
->input_sections_size();
2884 // Convert input sections in input_section_list.
2886 this->build_relaxation_map(this->input_sections_
, limit
, &map
);
2887 this->convert_input_sections_in_list_to_relaxed_sections(
2890 &this->input_sections_
);
2892 // Update fast look-up map.
2893 if (this->lookup_maps_
->is_valid())
2894 for (size_t i
= 0; i
< relaxed_sections
.size(); ++i
)
2896 Output_relaxed_input_section
* poris
= relaxed_sections
[i
];
2897 this->lookup_maps_
->add_relaxed_input_section(poris
->relobj(),
2898 poris
->shndx(), poris
);
2902 // Update the output section flags based on input section flags.
2905 Output_section::update_flags_for_input_section(elfcpp::Elf_Xword flags
)
2907 // If we created the section with SHF_ALLOC clear, we set the
2908 // address. If we are now setting the SHF_ALLOC flag, we need to
2910 if ((this->flags_
& elfcpp::SHF_ALLOC
) == 0
2911 && (flags
& elfcpp::SHF_ALLOC
) != 0)
2912 this->mark_address_invalid();
2914 this->flags_
|= (flags
2915 & (elfcpp::SHF_WRITE
2917 | elfcpp::SHF_EXECINSTR
));
2919 if ((flags
& elfcpp::SHF_MERGE
) == 0)
2920 this->flags_
&=~ elfcpp::SHF_MERGE
;
2923 if (this->current_data_size_for_child() == 0)
2924 this->flags_
|= elfcpp::SHF_MERGE
;
2927 if ((flags
& elfcpp::SHF_STRINGS
) == 0)
2928 this->flags_
&=~ elfcpp::SHF_STRINGS
;
2931 if (this->current_data_size_for_child() == 0)
2932 this->flags_
|= elfcpp::SHF_STRINGS
;
2936 // Find the merge section into which an input section with index SHNDX in
2937 // OBJECT has been added. Return NULL if none found.
2939 const Output_section_data
*
2940 Output_section::find_merge_section(const Relobj
* object
,
2941 unsigned int shndx
) const
2943 return object
->find_merge_section(shndx
);
2946 // Build the lookup maps for relaxed sections. This needs
2947 // to be declared as a const method so that it is callable with a const
2948 // Output_section pointer. The method only updates states of the maps.
2951 Output_section::build_lookup_maps() const
2953 this->lookup_maps_
->clear();
2954 for (Input_section_list::const_iterator p
= this->input_sections_
.begin();
2955 p
!= this->input_sections_
.end();
2958 if (p
->is_relaxed_input_section())
2960 Output_relaxed_input_section
* poris
= p
->relaxed_input_section();
2961 this->lookup_maps_
->add_relaxed_input_section(poris
->relobj(),
2962 poris
->shndx(), poris
);
2967 // Find an relaxed input section corresponding to an input section
2968 // in OBJECT with index SHNDX.
2970 const Output_relaxed_input_section
*
2971 Output_section::find_relaxed_input_section(const Relobj
* object
,
2972 unsigned int shndx
) const
2974 if (!this->lookup_maps_
->is_valid())
2975 this->build_lookup_maps();
2976 return this->lookup_maps_
->find_relaxed_input_section(object
, shndx
);
2979 // Given an address OFFSET relative to the start of input section
2980 // SHNDX in OBJECT, return whether this address is being included in
2981 // the final link. This should only be called if SHNDX in OBJECT has
2982 // a special mapping.
2985 Output_section::is_input_address_mapped(const Relobj
* object
,
2989 // Look at the Output_section_data_maps first.
2990 const Output_section_data
* posd
= this->find_merge_section(object
, shndx
);
2992 posd
= this->find_relaxed_input_section(object
, shndx
);
2996 section_offset_type output_offset
;
2997 bool found
= posd
->output_offset(object
, shndx
, offset
, &output_offset
);
2998 // By default we assume that the address is mapped. See comment at the
3002 return output_offset
!= -1;
3005 // Fall back to the slow look-up.
3006 for (Input_section_list::const_iterator p
= this->input_sections_
.begin();
3007 p
!= this->input_sections_
.end();
3010 section_offset_type output_offset
;
3011 if (p
->output_offset(object
, shndx
, offset
, &output_offset
))
3012 return output_offset
!= -1;
3015 // By default we assume that the address is mapped. This should
3016 // only be called after we have passed all sections to Layout. At
3017 // that point we should know what we are discarding.
3021 // Given an address OFFSET relative to the start of input section
3022 // SHNDX in object OBJECT, return the output offset relative to the
3023 // start of the input section in the output section. This should only
3024 // be called if SHNDX in OBJECT has a special mapping.
3027 Output_section::output_offset(const Relobj
* object
, unsigned int shndx
,
3028 section_offset_type offset
) const
3030 // This can only be called meaningfully when we know the data size
3032 gold_assert(this->is_data_size_valid());
3034 // Look at the Output_section_data_maps first.
3035 const Output_section_data
* posd
= this->find_merge_section(object
, shndx
);
3037 posd
= this->find_relaxed_input_section(object
, shndx
);
3040 section_offset_type output_offset
;
3041 bool found
= posd
->output_offset(object
, shndx
, offset
, &output_offset
);
3043 return output_offset
;
3046 // Fall back to the slow look-up.
3047 for (Input_section_list::const_iterator p
= this->input_sections_
.begin();
3048 p
!= this->input_sections_
.end();
3051 section_offset_type output_offset
;
3052 if (p
->output_offset(object
, shndx
, offset
, &output_offset
))
3053 return output_offset
;
3058 // Return the output virtual address of OFFSET relative to the start
3059 // of input section SHNDX in object OBJECT.
3062 Output_section::output_address(const Relobj
* object
, unsigned int shndx
,
3065 uint64_t addr
= this->address() + this->first_input_offset_
;
3067 // Look at the Output_section_data_maps first.
3068 const Output_section_data
* posd
= this->find_merge_section(object
, shndx
);
3070 posd
= this->find_relaxed_input_section(object
, shndx
);
3071 if (posd
!= NULL
&& posd
->is_address_valid())
3073 section_offset_type output_offset
;
3074 bool found
= posd
->output_offset(object
, shndx
, offset
, &output_offset
);
3076 return posd
->address() + output_offset
;
3079 // Fall back to the slow look-up.
3080 for (Input_section_list::const_iterator p
= this->input_sections_
.begin();
3081 p
!= this->input_sections_
.end();
3084 addr
= align_address(addr
, p
->addralign());
3085 section_offset_type output_offset
;
3086 if (p
->output_offset(object
, shndx
, offset
, &output_offset
))
3088 if (output_offset
== -1)
3090 return addr
+ output_offset
;
3092 addr
+= p
->data_size();
3095 // If we get here, it means that we don't know the mapping for this
3096 // input section. This might happen in principle if
3097 // add_input_section were called before add_output_section_data.
3098 // But it should never actually happen.
3103 // Find the output address of the start of the merged section for
3104 // input section SHNDX in object OBJECT.
3107 Output_section::find_starting_output_address(const Relobj
* object
,
3109 uint64_t* paddr
) const
3111 const Output_section_data
* data
= this->find_merge_section(object
, shndx
);
3115 // FIXME: This becomes a bottle-neck if we have many relaxed sections.
3116 // Looking up the merge section map does not always work as we sometimes
3117 // find a merge section without its address set.
3118 uint64_t addr
= this->address() + this->first_input_offset_
;
3119 for (Input_section_list::const_iterator p
= this->input_sections_
.begin();
3120 p
!= this->input_sections_
.end();
3123 addr
= align_address(addr
, p
->addralign());
3125 // It would be nice if we could use the existing output_offset
3126 // method to get the output offset of input offset 0.
3127 // Unfortunately we don't know for sure that input offset 0 is
3129 if (!p
->is_input_section() && p
->output_section_data() == data
)
3135 addr
+= p
->data_size();
3138 // We couldn't find a merge output section for this input section.
3142 // Update the data size of an Output_section.
3145 Output_section::update_data_size()
3147 if (this->input_sections_
.empty())
3150 if (this->must_sort_attached_input_sections()
3151 || this->input_section_order_specified())
3152 this->sort_attached_input_sections();
3154 off_t off
= this->first_input_offset_
;
3155 for (Input_section_list::iterator p
= this->input_sections_
.begin();
3156 p
!= this->input_sections_
.end();
3159 off
= align_address(off
, p
->addralign());
3160 off
+= p
->current_data_size();
3163 this->set_current_data_size_for_child(off
);
3166 // Set the data size of an Output_section. This is where we handle
3167 // setting the addresses of any Output_section_data objects.
3170 Output_section::set_final_data_size()
3174 if (this->input_sections_
.empty())
3175 data_size
= this->current_data_size_for_child();
3178 if (this->must_sort_attached_input_sections()
3179 || this->input_section_order_specified())
3180 this->sort_attached_input_sections();
3182 uint64_t address
= this->address();
3183 off_t startoff
= this->offset();
3184 off_t off
= this->first_input_offset_
;
3185 for (Input_section_list::iterator p
= this->input_sections_
.begin();
3186 p
!= this->input_sections_
.end();
3189 off
= align_address(off
, p
->addralign());
3190 p
->set_address_and_file_offset(address
+ off
, startoff
+ off
,
3192 off
+= p
->data_size();
3197 // For full incremental links, we want to allocate some patch space
3198 // in most sections for subsequent incremental updates.
3199 if (this->is_patch_space_allowed_
&& parameters
->incremental_full())
3201 double pct
= parameters
->options().incremental_patch();
3202 size_t extra
= static_cast<size_t>(data_size
* pct
);
3203 if (this->free_space_fill_
!= NULL
3204 && this->free_space_fill_
->minimum_hole_size() > extra
)
3205 extra
= this->free_space_fill_
->minimum_hole_size();
3206 off_t new_size
= align_address(data_size
+ extra
, this->addralign());
3207 this->patch_space_
= new_size
- data_size
;
3208 gold_debug(DEBUG_INCREMENTAL
,
3209 "set_final_data_size: %08lx + %08lx: section %s",
3210 static_cast<long>(data_size
),
3211 static_cast<long>(this->patch_space_
),
3213 data_size
= new_size
;
3216 this->set_data_size(data_size
);
3219 // Reset the address and file offset.
3222 Output_section::do_reset_address_and_file_offset()
3224 // An unallocated section has no address. Forcing this means that
3225 // we don't need special treatment for symbols defined in debug
3226 // sections. We do the same in the constructor. This does not
3227 // apply to NOLOAD sections though.
3228 if (((this->flags_
& elfcpp::SHF_ALLOC
) == 0) && !this->is_noload_
)
3229 this->set_address(0);
3231 for (Input_section_list::iterator p
= this->input_sections_
.begin();
3232 p
!= this->input_sections_
.end();
3234 p
->reset_address_and_file_offset();
3236 // Remove any patch space that was added in set_final_data_size.
3237 if (this->patch_space_
> 0)
3239 this->set_current_data_size_for_child(this->current_data_size_for_child()
3240 - this->patch_space_
);
3241 this->patch_space_
= 0;
3245 // Return true if address and file offset have the values after reset.
3248 Output_section::do_address_and_file_offset_have_reset_values() const
3250 if (this->is_offset_valid())
3253 // An unallocated section has address 0 after its construction or a reset.
3254 if ((this->flags_
& elfcpp::SHF_ALLOC
) == 0)
3255 return this->is_address_valid() && this->address() == 0;
3257 return !this->is_address_valid();
3260 // Set the TLS offset. Called only for SHT_TLS sections.
3263 Output_section::do_set_tls_offset(uint64_t tls_base
)
3265 this->tls_offset_
= this->address() - tls_base
;
3268 // In a few cases we need to sort the input sections attached to an
3269 // output section. This is used to implement the type of constructor
3270 // priority ordering implemented by the GNU linker, in which the
3271 // priority becomes part of the section name and the sections are
3272 // sorted by name. We only do this for an output section if we see an
3273 // attached input section matching ".ctors.*", ".dtors.*",
3274 // ".init_array.*" or ".fini_array.*".
3276 class Output_section::Input_section_sort_entry
3279 Input_section_sort_entry()
3280 : input_section_(), index_(-1U), section_name_()
3283 Input_section_sort_entry(const Input_section
& input_section
,
3285 bool must_sort_attached_input_sections
,
3286 const char* output_section_name
)
3287 : input_section_(input_section
), index_(index
), section_name_()
3289 if ((input_section
.is_input_section()
3290 || input_section
.is_relaxed_input_section())
3291 && must_sort_attached_input_sections
)
3293 // This is only called single-threaded from Layout::finalize,
3294 // so it is OK to lock. Unfortunately we have no way to pass
3296 const Task
* dummy_task
= reinterpret_cast<const Task
*>(-1);
3297 Object
* obj
= (input_section
.is_input_section()
3298 ? input_section
.relobj()
3299 : input_section
.relaxed_input_section()->relobj());
3300 Task_lock_obj
<Object
> tl(dummy_task
, obj
);
3302 // This is a slow operation, which should be cached in
3303 // Layout::layout if this becomes a speed problem.
3304 this->section_name_
= obj
->section_name(input_section
.shndx());
3306 else if (input_section
.is_output_section_data()
3307 && must_sort_attached_input_sections
)
3309 // For linker-generated sections, use the output section name.
3310 this->section_name_
.assign(output_section_name
);
3314 // Return the Input_section.
3315 const Input_section
&
3316 input_section() const
3318 gold_assert(this->index_
!= -1U);
3319 return this->input_section_
;
3322 // The index of this entry in the original list. This is used to
3323 // make the sort stable.
3327 gold_assert(this->index_
!= -1U);
3328 return this->index_
;
3331 // The section name.
3333 section_name() const
3335 return this->section_name_
;
3338 // Return true if the section name has a priority. This is assumed
3339 // to be true if it has a dot after the initial dot.
3341 has_priority() const
3343 return this->section_name_
.find('.', 1) != std::string::npos
;
3346 // Return the priority. Believe it or not, gcc encodes the priority
3347 // differently for .ctors/.dtors and .init_array/.fini_array
3350 get_priority() const
3353 if (is_prefix_of(".ctors.", this->section_name_
.c_str())
3354 || is_prefix_of(".dtors.", this->section_name_
.c_str()))
3356 else if (is_prefix_of(".init_array.", this->section_name_
.c_str())
3357 || is_prefix_of(".fini_array.", this->section_name_
.c_str()))
3362 unsigned long prio
= strtoul((this->section_name_
.c_str()
3363 + (is_ctors
? 7 : 12)),
3368 return 65535 - prio
;
3373 // Return true if this an input file whose base name matches
3374 // FILE_NAME. The base name must have an extension of ".o", and
3375 // must be exactly FILE_NAME.o or FILE_NAME, one character, ".o".
3376 // This is to match crtbegin.o as well as crtbeginS.o without
3377 // getting confused by other possibilities. Overall matching the
3378 // file name this way is a dreadful hack, but the GNU linker does it
3379 // in order to better support gcc, and we need to be compatible.
3381 match_file_name(const char* file_name
) const
3383 if (this->input_section_
.is_output_section_data())
3385 return Layout::match_file_name(this->input_section_
.relobj(), file_name
);
3388 // Returns 1 if THIS should appear before S in section order, -1 if S
3389 // appears before THIS and 0 if they are not comparable.
3391 compare_section_ordering(const Input_section_sort_entry
& s
) const
3393 unsigned int this_secn_index
= this->input_section_
.section_order_index();
3394 unsigned int s_secn_index
= s
.input_section().section_order_index();
3395 if (this_secn_index
> 0 && s_secn_index
> 0)
3397 if (this_secn_index
< s_secn_index
)
3399 else if (this_secn_index
> s_secn_index
)
3406 // The Input_section we are sorting.
3407 Input_section input_section_
;
3408 // The index of this Input_section in the original list.
3409 unsigned int index_
;
3410 // The section name if there is one.
3411 std::string section_name_
;
3414 // Return true if S1 should come before S2 in the output section.
3417 Output_section::Input_section_sort_compare::operator()(
3418 const Output_section::Input_section_sort_entry
& s1
,
3419 const Output_section::Input_section_sort_entry
& s2
) const
3421 // crtbegin.o must come first.
3422 bool s1_begin
= s1
.match_file_name("crtbegin");
3423 bool s2_begin
= s2
.match_file_name("crtbegin");
3424 if (s1_begin
|| s2_begin
)
3430 return s1
.index() < s2
.index();
3433 // crtend.o must come last.
3434 bool s1_end
= s1
.match_file_name("crtend");
3435 bool s2_end
= s2
.match_file_name("crtend");
3436 if (s1_end
|| s2_end
)
3442 return s1
.index() < s2
.index();
3445 // A section with a priority follows a section without a priority.
3446 bool s1_has_priority
= s1
.has_priority();
3447 bool s2_has_priority
= s2
.has_priority();
3448 if (s1_has_priority
&& !s2_has_priority
)
3450 if (!s1_has_priority
&& s2_has_priority
)
3453 // Check if a section order exists for these sections through a section
3454 // ordering file. If sequence_num is 0, an order does not exist.
3455 int sequence_num
= s1
.compare_section_ordering(s2
);
3456 if (sequence_num
!= 0)
3457 return sequence_num
== 1;
3459 // Otherwise we sort by name.
3460 int compare
= s1
.section_name().compare(s2
.section_name());
3464 // Otherwise we keep the input order.
3465 return s1
.index() < s2
.index();
3468 // Return true if S1 should come before S2 in an .init_array or .fini_array
3472 Output_section::Input_section_sort_init_fini_compare::operator()(
3473 const Output_section::Input_section_sort_entry
& s1
,
3474 const Output_section::Input_section_sort_entry
& s2
) const
3476 // A section without a priority follows a section with a priority.
3477 // This is the reverse of .ctors and .dtors sections.
3478 bool s1_has_priority
= s1
.has_priority();
3479 bool s2_has_priority
= s2
.has_priority();
3480 if (s1_has_priority
&& !s2_has_priority
)
3482 if (!s1_has_priority
&& s2_has_priority
)
3485 // .ctors and .dtors sections without priority come after
3486 // .init_array and .fini_array sections without priority.
3487 if (!s1_has_priority
3488 && (s1
.section_name() == ".ctors" || s1
.section_name() == ".dtors")
3489 && s1
.section_name() != s2
.section_name())
3491 if (!s2_has_priority
3492 && (s2
.section_name() == ".ctors" || s2
.section_name() == ".dtors")
3493 && s2
.section_name() != s1
.section_name())
3496 // Sort by priority if we can.
3497 if (s1_has_priority
)
3499 unsigned int s1_prio
= s1
.get_priority();
3500 unsigned int s2_prio
= s2
.get_priority();
3501 if (s1_prio
< s2_prio
)
3503 else if (s1_prio
> s2_prio
)
3507 // Check if a section order exists for these sections through a section
3508 // ordering file. If sequence_num is 0, an order does not exist.
3509 int sequence_num
= s1
.compare_section_ordering(s2
);
3510 if (sequence_num
!= 0)
3511 return sequence_num
== 1;
3513 // Otherwise we sort by name.
3514 int compare
= s1
.section_name().compare(s2
.section_name());
3518 // Otherwise we keep the input order.
3519 return s1
.index() < s2
.index();
3522 // Return true if S1 should come before S2. Sections that do not match
3523 // any pattern in the section ordering file are placed ahead of the sections
3524 // that match some pattern.
3527 Output_section::Input_section_sort_section_order_index_compare::operator()(
3528 const Output_section::Input_section_sort_entry
& s1
,
3529 const Output_section::Input_section_sort_entry
& s2
) const
3531 unsigned int s1_secn_index
= s1
.input_section().section_order_index();
3532 unsigned int s2_secn_index
= s2
.input_section().section_order_index();
3534 // Keep input order if section ordering cannot determine order.
3535 if (s1_secn_index
== s2_secn_index
)
3536 return s1
.index() < s2
.index();
3538 return s1_secn_index
< s2_secn_index
;
3541 // Return true if S1 should come before S2. This is the sort comparison
3542 // function for .text to sort sections with prefixes
3543 // .text.{unlikely,exit,startup,hot} before other sections.
3546 Output_section::Input_section_sort_section_prefix_special_ordering_compare
3548 const Output_section::Input_section_sort_entry
& s1
,
3549 const Output_section::Input_section_sort_entry
& s2
) const
3551 // Some input section names have special ordering requirements.
3552 const char *s1_section_name
= s1
.section_name().c_str();
3553 const char *s2_section_name
= s2
.section_name().c_str();
3554 int o1
= Layout::special_ordering_of_input_section(s1_section_name
);
3555 int o2
= Layout::special_ordering_of_input_section(s2_section_name
);
3565 else if (is_prefix_of(".text.sorted", s1_section_name
))
3566 return strcmp(s1_section_name
, s2_section_name
) <= 0;
3568 // Keep input order otherwise.
3569 return s1
.index() < s2
.index();
3572 // Return true if S1 should come before S2. This is the sort comparison
3573 // function for sections to sort them by name.
3576 Output_section::Input_section_sort_section_name_compare
3578 const Output_section::Input_section_sort_entry
& s1
,
3579 const Output_section::Input_section_sort_entry
& s2
) const
3582 int compare
= s1
.section_name().compare(s2
.section_name());
3586 // Keep input order otherwise.
3587 return s1
.index() < s2
.index();
3590 // This updates the section order index of input sections according to the
3591 // the order specified in the mapping from Section id to order index.
3594 Output_section::update_section_layout(
3595 const Section_layout_order
* order_map
)
3597 for (Input_section_list::iterator p
= this->input_sections_
.begin();
3598 p
!= this->input_sections_
.end();
3601 if (p
->is_input_section()
3602 || p
->is_relaxed_input_section())
3604 Relobj
* obj
= (p
->is_input_section()
3606 : p
->relaxed_input_section()->relobj());
3607 unsigned int shndx
= p
->shndx();
3608 Section_layout_order::const_iterator it
3609 = order_map
->find(Section_id(obj
, shndx
));
3610 if (it
== order_map
->end())
3612 unsigned int section_order_index
= it
->second
;
3613 if (section_order_index
!= 0)
3615 p
->set_section_order_index(section_order_index
);
3616 this->set_input_section_order_specified();
3622 // Sort the input sections attached to an output section.
3625 Output_section::sort_attached_input_sections()
3627 if (this->attached_input_sections_are_sorted_
)
3630 if (this->checkpoint_
!= NULL
3631 && !this->checkpoint_
->input_sections_saved())
3632 this->checkpoint_
->save_input_sections();
3634 // The only thing we know about an input section is the object and
3635 // the section index. We need the section name. Recomputing this
3636 // is slow but this is an unusual case. If this becomes a speed
3637 // problem we can cache the names as required in Layout::layout.
3639 // We start by building a larger vector holding a copy of each
3640 // Input_section, plus its current index in the list and its name.
3641 std::vector
<Input_section_sort_entry
> sort_list
;
3644 for (Input_section_list::iterator p
= this->input_sections_
.begin();
3645 p
!= this->input_sections_
.end();
3647 sort_list
.push_back(Input_section_sort_entry(*p
, i
,
3648 this->must_sort_attached_input_sections(),
3651 // Sort the input sections.
3652 if (this->must_sort_attached_input_sections())
3654 if (this->type() == elfcpp::SHT_PREINIT_ARRAY
3655 || this->type() == elfcpp::SHT_INIT_ARRAY
3656 || this->type() == elfcpp::SHT_FINI_ARRAY
)
3657 std::sort(sort_list
.begin(), sort_list
.end(),
3658 Input_section_sort_init_fini_compare());
3659 else if (strcmp(parameters
->options().sort_section(), "name") == 0)
3660 std::sort(sort_list
.begin(), sort_list
.end(),
3661 Input_section_sort_section_name_compare());
3662 else if (strcmp(this->name(), ".text") == 0)
3663 std::sort(sort_list
.begin(), sort_list
.end(),
3664 Input_section_sort_section_prefix_special_ordering_compare());
3666 std::sort(sort_list
.begin(), sort_list
.end(),
3667 Input_section_sort_compare());
3671 gold_assert(this->input_section_order_specified());
3672 std::sort(sort_list
.begin(), sort_list
.end(),
3673 Input_section_sort_section_order_index_compare());
3676 // Copy the sorted input sections back to our list.
3677 this->input_sections_
.clear();
3678 for (std::vector
<Input_section_sort_entry
>::iterator p
= sort_list
.begin();
3679 p
!= sort_list
.end();
3681 this->input_sections_
.push_back(p
->input_section());
3684 // Remember that we sorted the input sections, since we might get
3686 this->attached_input_sections_are_sorted_
= true;
3689 // Write the section header to *OSHDR.
3691 template<int size
, bool big_endian
>
3693 Output_section::write_header(const Layout
* layout
,
3694 const Stringpool
* secnamepool
,
3695 elfcpp::Shdr_write
<size
, big_endian
>* oshdr
) const
3697 oshdr
->put_sh_name(secnamepool
->get_offset(this->name_
));
3698 oshdr
->put_sh_type(this->type_
);
3700 elfcpp::Elf_Xword flags
= this->flags_
;
3701 if (this->info_section_
!= NULL
&& this->info_uses_section_index_
)
3702 flags
|= elfcpp::SHF_INFO_LINK
;
3703 oshdr
->put_sh_flags(flags
);
3705 oshdr
->put_sh_addr(this->address());
3706 oshdr
->put_sh_offset(this->offset());
3707 oshdr
->put_sh_size(this->data_size());
3708 if (this->link_section_
!= NULL
)
3709 oshdr
->put_sh_link(this->link_section_
->out_shndx());
3710 else if (this->should_link_to_symtab_
)
3711 oshdr
->put_sh_link(layout
->symtab_section_shndx());
3712 else if (this->should_link_to_dynsym_
)
3713 oshdr
->put_sh_link(layout
->dynsym_section()->out_shndx());
3715 oshdr
->put_sh_link(this->link_
);
3717 elfcpp::Elf_Word info
;
3718 if (this->info_section_
!= NULL
)
3720 if (this->info_uses_section_index_
)
3721 info
= this->info_section_
->out_shndx();
3723 info
= this->info_section_
->symtab_index();
3725 else if (this->info_symndx_
!= NULL
)
3726 info
= this->info_symndx_
->symtab_index();
3729 oshdr
->put_sh_info(info
);
3731 oshdr
->put_sh_addralign(this->addralign_
);
3732 oshdr
->put_sh_entsize(this->entsize_
);
3735 // Write out the data. For input sections the data is written out by
3736 // Object::relocate, but we have to handle Output_section_data objects
3740 Output_section::do_write(Output_file
* of
)
3742 gold_assert(!this->requires_postprocessing());
3744 // If the target performs relaxation, we delay filler generation until now.
3745 gold_assert(!this->generate_code_fills_at_write_
|| this->fills_
.empty());
3747 off_t output_section_file_offset
= this->offset();
3748 for (Fill_list::iterator p
= this->fills_
.begin();
3749 p
!= this->fills_
.end();
3752 std::string
fill_data(parameters
->target().code_fill(p
->length()));
3753 of
->write(output_section_file_offset
+ p
->section_offset(),
3754 fill_data
.data(), fill_data
.size());
3757 off_t off
= this->offset() + this->first_input_offset_
;
3758 for (Input_section_list::iterator p
= this->input_sections_
.begin();
3759 p
!= this->input_sections_
.end();
3762 off_t aligned_off
= align_address(off
, p
->addralign());
3763 if (this->generate_code_fills_at_write_
&& (off
!= aligned_off
))
3765 size_t fill_len
= aligned_off
- off
;
3766 std::string
fill_data(parameters
->target().code_fill(fill_len
));
3767 of
->write(off
, fill_data
.data(), fill_data
.size());
3771 off
= aligned_off
+ p
->data_size();
3774 // For incremental links, fill in unused chunks in debug sections
3775 // with dummy compilation unit headers.
3776 if (this->free_space_fill_
!= NULL
)
3778 for (Free_list::Const_iterator p
= this->free_list_
.begin();
3779 p
!= this->free_list_
.end();
3782 off_t off
= p
->start_
;
3783 size_t len
= p
->end_
- off
;
3784 this->free_space_fill_
->write(of
, this->offset() + off
, len
);
3786 if (this->patch_space_
> 0)
3788 off_t off
= this->current_data_size_for_child() - this->patch_space_
;
3789 this->free_space_fill_
->write(of
, this->offset() + off
,
3790 this->patch_space_
);
3795 // If a section requires postprocessing, create the buffer to use.
3798 Output_section::create_postprocessing_buffer()
3800 gold_assert(this->requires_postprocessing());
3802 if (this->postprocessing_buffer_
!= NULL
)
3805 if (!this->input_sections_
.empty())
3807 off_t off
= this->first_input_offset_
;
3808 for (Input_section_list::iterator p
= this->input_sections_
.begin();
3809 p
!= this->input_sections_
.end();
3812 off
= align_address(off
, p
->addralign());
3813 p
->finalize_data_size();
3814 off
+= p
->data_size();
3816 this->set_current_data_size_for_child(off
);
3819 off_t buffer_size
= this->current_data_size_for_child();
3820 this->postprocessing_buffer_
= new unsigned char[buffer_size
];
3823 // Write all the data of an Output_section into the postprocessing
3824 // buffer. This is used for sections which require postprocessing,
3825 // such as compression. Input sections are handled by
3826 // Object::Relocate.
3829 Output_section::write_to_postprocessing_buffer()
3831 gold_assert(this->requires_postprocessing());
3833 // If the target performs relaxation, we delay filler generation until now.
3834 gold_assert(!this->generate_code_fills_at_write_
|| this->fills_
.empty());
3836 unsigned char* buffer
= this->postprocessing_buffer();
3837 for (Fill_list::iterator p
= this->fills_
.begin();
3838 p
!= this->fills_
.end();
3841 std::string
fill_data(parameters
->target().code_fill(p
->length()));
3842 memcpy(buffer
+ p
->section_offset(), fill_data
.data(),
3846 off_t off
= this->first_input_offset_
;
3847 for (Input_section_list::iterator p
= this->input_sections_
.begin();
3848 p
!= this->input_sections_
.end();
3851 off_t aligned_off
= align_address(off
, p
->addralign());
3852 if (this->generate_code_fills_at_write_
&& (off
!= aligned_off
))
3854 size_t fill_len
= aligned_off
- off
;
3855 std::string
fill_data(parameters
->target().code_fill(fill_len
));
3856 memcpy(buffer
+ off
, fill_data
.data(), fill_data
.size());
3859 p
->write_to_buffer(buffer
+ aligned_off
);
3860 off
= aligned_off
+ p
->data_size();
3864 // Get the input sections for linker script processing. We leave
3865 // behind the Output_section_data entries. Note that this may be
3866 // slightly incorrect for merge sections. We will leave them behind,
3867 // but it is possible that the script says that they should follow
3868 // some other input sections, as in:
3869 // .rodata { *(.rodata) *(.rodata.cst*) }
3870 // For that matter, we don't handle this correctly:
3871 // .rodata { foo.o(.rodata.cst*) *(.rodata.cst*) }
3872 // With luck this will never matter.
3875 Output_section::get_input_sections(
3877 const std::string
& fill
,
3878 std::list
<Input_section
>* input_sections
)
3880 if (this->checkpoint_
!= NULL
3881 && !this->checkpoint_
->input_sections_saved())
3882 this->checkpoint_
->save_input_sections();
3884 // Invalidate fast look-up maps.
3885 this->lookup_maps_
->invalidate();
3887 uint64_t orig_address
= address
;
3889 address
= align_address(address
, this->addralign());
3891 Input_section_list remaining
;
3892 for (Input_section_list::iterator p
= this->input_sections_
.begin();
3893 p
!= this->input_sections_
.end();
3896 if (p
->is_input_section()
3897 || p
->is_relaxed_input_section()
3898 || p
->is_merge_section())
3899 input_sections
->push_back(*p
);
3902 uint64_t aligned_address
= align_address(address
, p
->addralign());
3903 if (aligned_address
!= address
&& !fill
.empty())
3905 section_size_type length
=
3906 convert_to_section_size_type(aligned_address
- address
);
3907 std::string this_fill
;
3908 this_fill
.reserve(length
);
3909 while (this_fill
.length() + fill
.length() <= length
)
3911 if (this_fill
.length() < length
)
3912 this_fill
.append(fill
, 0, length
- this_fill
.length());
3914 Output_section_data
* posd
= new Output_data_const(this_fill
, 0);
3915 remaining
.push_back(Input_section(posd
));
3917 address
= aligned_address
;
3919 remaining
.push_back(*p
);
3921 p
->finalize_data_size();
3922 address
+= p
->data_size();
3926 this->input_sections_
.swap(remaining
);
3927 this->first_input_offset_
= 0;
3929 uint64_t data_size
= address
- orig_address
;
3930 this->set_current_data_size_for_child(data_size
);
3934 // Add a script input section. SIS is an Output_section::Input_section,
3935 // which can be either a plain input section or a special input section like
3936 // a relaxed input section. For a special input section, its size must be
3940 Output_section::add_script_input_section(const Input_section
& sis
)
3942 uint64_t data_size
= sis
.data_size();
3943 uint64_t addralign
= sis
.addralign();
3944 if (addralign
> this->addralign_
)
3945 this->addralign_
= addralign
;
3947 off_t offset_in_section
= this->current_data_size_for_child();
3948 off_t aligned_offset_in_section
= align_address(offset_in_section
,
3951 this->set_current_data_size_for_child(aligned_offset_in_section
3954 this->input_sections_
.push_back(sis
);
3956 // Update fast lookup maps if necessary.
3957 if (this->lookup_maps_
->is_valid())
3959 if (sis
.is_relaxed_input_section())
3961 Output_relaxed_input_section
* poris
= sis
.relaxed_input_section();
3962 this->lookup_maps_
->add_relaxed_input_section(poris
->relobj(),
3963 poris
->shndx(), poris
);
3968 // Save states for relaxation.
3971 Output_section::save_states()
3973 gold_assert(this->checkpoint_
== NULL
);
3974 Checkpoint_output_section
* checkpoint
=
3975 new Checkpoint_output_section(this->addralign_
, this->flags_
,
3976 this->input_sections_
,
3977 this->first_input_offset_
,
3978 this->attached_input_sections_are_sorted_
);
3979 this->checkpoint_
= checkpoint
;
3980 gold_assert(this->fills_
.empty());
3984 Output_section::discard_states()
3986 gold_assert(this->checkpoint_
!= NULL
);
3987 delete this->checkpoint_
;
3988 this->checkpoint_
= NULL
;
3989 gold_assert(this->fills_
.empty());
3991 // Simply invalidate the fast lookup maps since we do not keep
3993 this->lookup_maps_
->invalidate();
3997 Output_section::restore_states()
3999 gold_assert(this->checkpoint_
!= NULL
);
4000 Checkpoint_output_section
* checkpoint
= this->checkpoint_
;
4002 this->addralign_
= checkpoint
->addralign();
4003 this->flags_
= checkpoint
->flags();
4004 this->first_input_offset_
= checkpoint
->first_input_offset();
4006 if (!checkpoint
->input_sections_saved())
4008 // If we have not copied the input sections, just resize it.
4009 size_t old_size
= checkpoint
->input_sections_size();
4010 gold_assert(this->input_sections_
.size() >= old_size
);
4011 this->input_sections_
.resize(old_size
);
4015 // We need to copy the whole list. This is not efficient for
4016 // extremely large output with hundreads of thousands of input
4017 // objects. We may need to re-think how we should pass sections
4019 this->input_sections_
= *checkpoint
->input_sections();
4022 this->attached_input_sections_are_sorted_
=
4023 checkpoint
->attached_input_sections_are_sorted();
4025 // Simply invalidate the fast lookup maps since we do not keep
4027 this->lookup_maps_
->invalidate();
4030 // Update the section offsets of input sections in this. This is required if
4031 // relaxation causes some input sections to change sizes.
4034 Output_section::adjust_section_offsets()
4036 if (!this->section_offsets_need_adjustment_
)
4040 for (Input_section_list::iterator p
= this->input_sections_
.begin();
4041 p
!= this->input_sections_
.end();
4044 off
= align_address(off
, p
->addralign());
4045 if (p
->is_input_section())
4046 p
->relobj()->set_section_offset(p
->shndx(), off
);
4047 off
+= p
->data_size();
4050 this->section_offsets_need_adjustment_
= false;
4053 // Print to the map file.
4056 Output_section::do_print_to_mapfile(Mapfile
* mapfile
) const
4058 mapfile
->print_output_section(this);
4060 for (Input_section_list::const_iterator p
= this->input_sections_
.begin();
4061 p
!= this->input_sections_
.end();
4063 p
->print_to_mapfile(mapfile
);
4066 // Print stats for merge sections to stderr.
4069 Output_section::print_merge_stats()
4071 Input_section_list::iterator p
;
4072 for (p
= this->input_sections_
.begin();
4073 p
!= this->input_sections_
.end();
4075 p
->print_merge_stats(this->name_
);
4078 // Set a fixed layout for the section. Used for incremental update links.
4081 Output_section::set_fixed_layout(uint64_t sh_addr
, off_t sh_offset
,
4082 off_t sh_size
, uint64_t sh_addralign
)
4084 this->addralign_
= sh_addralign
;
4085 this->set_current_data_size(sh_size
);
4086 if ((this->flags_
& elfcpp::SHF_ALLOC
) != 0)
4087 this->set_address(sh_addr
);
4088 this->set_file_offset(sh_offset
);
4089 this->finalize_data_size();
4090 this->free_list_
.init(sh_size
, false);
4091 this->has_fixed_layout_
= true;
4094 // Reserve space within the fixed layout for the section. Used for
4095 // incremental update links.
4098 Output_section::reserve(uint64_t sh_offset
, uint64_t sh_size
)
4100 this->free_list_
.remove(sh_offset
, sh_offset
+ sh_size
);
4103 // Allocate space from the free list for the section. Used for
4104 // incremental update links.
4107 Output_section::allocate(off_t len
, uint64_t addralign
)
4109 return this->free_list_
.allocate(len
, addralign
, 0);
4112 // Output segment methods.
4114 Output_segment::Output_segment(elfcpp::Elf_Word type
, elfcpp::Elf_Word flags
)
4125 is_max_align_known_(false),
4126 are_addresses_set_(false),
4127 is_large_data_segment_(false),
4128 is_unique_segment_(false)
4130 // The ELF ABI specifies that a PT_TLS segment always has PF_R as
4132 if (type
== elfcpp::PT_TLS
)
4133 this->flags_
= elfcpp::PF_R
;
4136 // Add an Output_section to a PT_LOAD Output_segment.
4139 Output_segment::add_output_section_to_load(Layout
* layout
,
4141 elfcpp::Elf_Word seg_flags
)
4143 gold_assert(this->type() == elfcpp::PT_LOAD
);
4144 gold_assert((os
->flags() & elfcpp::SHF_ALLOC
) != 0);
4145 gold_assert(!this->is_max_align_known_
);
4146 gold_assert(os
->is_large_data_section() == this->is_large_data_segment());
4148 this->update_flags_for_output_section(seg_flags
);
4150 // We don't want to change the ordering if we have a linker script
4151 // with a SECTIONS clause.
4152 Output_section_order order
= os
->order();
4153 if (layout
->script_options()->saw_sections_clause())
4154 order
= static_cast<Output_section_order
>(0);
4156 gold_assert(order
!= ORDER_INVALID
);
4158 this->output_lists_
[order
].push_back(os
);
4161 // Add an Output_section to a non-PT_LOAD Output_segment.
4164 Output_segment::add_output_section_to_nonload(Output_section
* os
,
4165 elfcpp::Elf_Word seg_flags
)
4167 gold_assert(this->type() != elfcpp::PT_LOAD
);
4168 gold_assert((os
->flags() & elfcpp::SHF_ALLOC
) != 0);
4169 gold_assert(!this->is_max_align_known_
);
4171 this->update_flags_for_output_section(seg_flags
);
4173 this->output_lists_
[0].push_back(os
);
4176 // Remove an Output_section from this segment. It is an error if it
4180 Output_segment::remove_output_section(Output_section
* os
)
4182 for (int i
= 0; i
< static_cast<int>(ORDER_MAX
); ++i
)
4184 Output_data_list
* pdl
= &this->output_lists_
[i
];
4185 for (Output_data_list::iterator p
= pdl
->begin(); p
!= pdl
->end(); ++p
)
4197 // Add an Output_data (which need not be an Output_section) to the
4198 // start of a segment.
4201 Output_segment::add_initial_output_data(Output_data
* od
)
4203 gold_assert(!this->is_max_align_known_
);
4204 Output_data_list::iterator p
= this->output_lists_
[0].begin();
4205 this->output_lists_
[0].insert(p
, od
);
4208 // Return true if this segment has any sections which hold actual
4209 // data, rather than being a BSS section.
4212 Output_segment::has_any_data_sections() const
4214 for (int i
= 0; i
< static_cast<int>(ORDER_MAX
); ++i
)
4216 const Output_data_list
* pdl
= &this->output_lists_
[i
];
4217 for (Output_data_list::const_iterator p
= pdl
->begin();
4221 if (!(*p
)->is_section())
4223 if ((*p
)->output_section()->type() != elfcpp::SHT_NOBITS
)
4230 // Return whether the first data section (not counting TLS sections)
4231 // is a relro section.
4234 Output_segment::is_first_section_relro() const
4236 for (int i
= 0; i
< static_cast<int>(ORDER_MAX
); ++i
)
4238 if (i
== static_cast<int>(ORDER_TLS_BSS
))
4240 const Output_data_list
* pdl
= &this->output_lists_
[i
];
4243 Output_data
* p
= pdl
->front();
4244 return p
->is_section() && p
->output_section()->is_relro();
4250 // Return the maximum alignment of the Output_data in Output_segment.
4253 Output_segment::maximum_alignment()
4255 if (!this->is_max_align_known_
)
4257 for (int i
= 0; i
< static_cast<int>(ORDER_MAX
); ++i
)
4259 const Output_data_list
* pdl
= &this->output_lists_
[i
];
4260 uint64_t addralign
= Output_segment::maximum_alignment_list(pdl
);
4261 if (addralign
> this->max_align_
)
4262 this->max_align_
= addralign
;
4264 this->is_max_align_known_
= true;
4267 return this->max_align_
;
4270 // Return the maximum alignment of a list of Output_data.
4273 Output_segment::maximum_alignment_list(const Output_data_list
* pdl
)
4276 for (Output_data_list::const_iterator p
= pdl
->begin();
4280 uint64_t addralign
= (*p
)->addralign();
4281 if (addralign
> ret
)
4287 // Return whether this segment has any dynamic relocs.
4290 Output_segment::has_dynamic_reloc() const
4292 for (int i
= 0; i
< static_cast<int>(ORDER_MAX
); ++i
)
4293 if (this->has_dynamic_reloc_list(&this->output_lists_
[i
]))
4298 // Return whether this Output_data_list has any dynamic relocs.
4301 Output_segment::has_dynamic_reloc_list(const Output_data_list
* pdl
) const
4303 for (Output_data_list::const_iterator p
= pdl
->begin();
4306 if ((*p
)->has_dynamic_reloc())
4311 // Set the section addresses for an Output_segment. If RESET is true,
4312 // reset the addresses first. ADDR is the address and *POFF is the
4313 // file offset. Set the section indexes starting with *PSHNDX.
4314 // INCREASE_RELRO is the size of the portion of the first non-relro
4315 // section that should be included in the PT_GNU_RELRO segment.
4316 // If this segment has relro sections, and has been aligned for
4317 // that purpose, set *HAS_RELRO to TRUE. Return the address of
4318 // the immediately following segment. Update *HAS_RELRO, *POFF,
4322 Output_segment::set_section_addresses(const Target
* target
,
4323 Layout
* layout
, bool reset
,
4325 unsigned int* increase_relro
,
4328 unsigned int* pshndx
)
4330 gold_assert(this->type_
== elfcpp::PT_LOAD
);
4332 uint64_t last_relro_pad
= 0;
4333 off_t orig_off
= *poff
;
4335 bool in_tls
= false;
4337 // If we have relro sections, we need to pad forward now so that the
4338 // relro sections plus INCREASE_RELRO end on an abi page boundary.
4339 if (parameters
->options().relro()
4340 && this->is_first_section_relro()
4341 && (!this->are_addresses_set_
|| reset
))
4343 uint64_t relro_size
= 0;
4345 uint64_t max_align
= 0;
4346 for (int i
= 0; i
<= static_cast<int>(ORDER_RELRO_LAST
); ++i
)
4348 Output_data_list
* pdl
= &this->output_lists_
[i
];
4349 Output_data_list::iterator p
;
4350 for (p
= pdl
->begin(); p
!= pdl
->end(); ++p
)
4352 if (!(*p
)->is_section())
4354 uint64_t align
= (*p
)->addralign();
4355 if (align
> max_align
)
4357 if ((*p
)->is_section_flag_set(elfcpp::SHF_TLS
))
4361 // Align the first non-TLS section to the alignment
4362 // of the TLS segment.
4366 // Ignore the size of the .tbss section.
4367 if ((*p
)->is_section_flag_set(elfcpp::SHF_TLS
)
4368 && (*p
)->is_section_type(elfcpp::SHT_NOBITS
))
4370 relro_size
= align_address(relro_size
, align
);
4371 if ((*p
)->is_address_valid())
4372 relro_size
+= (*p
)->data_size();
4375 // FIXME: This could be faster.
4376 (*p
)->set_address_and_file_offset(relro_size
,
4378 relro_size
+= (*p
)->data_size();
4379 (*p
)->reset_address_and_file_offset();
4382 if (p
!= pdl
->end())
4385 relro_size
+= *increase_relro
;
4386 // Pad the total relro size to a multiple of the maximum
4387 // section alignment seen.
4388 uint64_t aligned_size
= align_address(relro_size
, max_align
);
4389 // Note the amount of padding added after the last relro section.
4390 last_relro_pad
= aligned_size
- relro_size
;
4393 uint64_t page_align
= parameters
->target().abi_pagesize();
4395 // Align to offset N such that (N + RELRO_SIZE) % PAGE_ALIGN == 0.
4396 uint64_t desired_align
= page_align
- (aligned_size
% page_align
);
4397 if (desired_align
< off
% page_align
)
4399 off
+= desired_align
- off
% page_align
;
4400 addr
+= off
- orig_off
;
4405 if (!reset
&& this->are_addresses_set_
)
4407 gold_assert(this->paddr_
== addr
);
4408 addr
= this->vaddr_
;
4412 this->vaddr_
= addr
;
4413 this->paddr_
= addr
;
4414 this->are_addresses_set_
= true;
4419 this->offset_
= orig_off
;
4424 for (int i
= 0; i
< static_cast<int>(ORDER_MAX
); ++i
)
4426 if (i
== static_cast<int>(ORDER_RELRO_LAST
))
4428 *poff
+= last_relro_pad
;
4429 foff
+= last_relro_pad
;
4430 addr
+= last_relro_pad
;
4431 if (this->output_lists_
[i
].empty())
4433 // If there is nothing in the ORDER_RELRO_LAST list,
4434 // the padding will occur at the end of the relro
4435 // segment, and we need to add it to *INCREASE_RELRO.
4436 *increase_relro
+= last_relro_pad
;
4439 addr
= this->set_section_list_addresses(layout
, reset
,
4440 &this->output_lists_
[i
],
4441 addr
, poff
, &foff
, pshndx
,
4444 // FOFF tracks the last offset used for the file image,
4445 // and *POFF tracks the last offset used for the memory image.
4446 // When not using a linker script, bss sections should all
4447 // be processed in the ORDER_SMALL_BSS and later buckets.
4448 gold_assert(*poff
== foff
4449 || i
== static_cast<int>(ORDER_TLS_BSS
)
4450 || i
>= static_cast<int>(ORDER_SMALL_BSS
)
4451 || layout
->script_options()->saw_sections_clause());
4453 this->filesz_
= foff
- orig_off
;
4459 // If the last section was a TLS section, align upward to the
4460 // alignment of the TLS segment, so that the overall size of the TLS
4461 // segment is aligned.
4464 uint64_t segment_align
= layout
->tls_segment()->maximum_alignment();
4465 *poff
= align_address(*poff
, segment_align
);
4468 this->memsz_
= *poff
- orig_off
;
4470 // Ignore the file offset adjustments made by the BSS Output_data
4474 // If code segments must contain only code, and this code segment is
4475 // page-aligned in the file, then fill it out to a whole page with
4476 // code fill (the tail of the segment will not be within any section).
4477 // Thus the entire code segment can be mapped from the file as whole
4478 // pages and that mapping will contain only valid instructions.
4479 if (target
->isolate_execinstr() && (this->flags() & elfcpp::PF_X
) != 0)
4481 uint64_t abi_pagesize
= target
->abi_pagesize();
4482 if (orig_off
% abi_pagesize
== 0 && off
% abi_pagesize
!= 0)
4484 size_t fill_size
= abi_pagesize
- (off
% abi_pagesize
);
4486 std::string fill_data
;
4487 if (target
->has_code_fill())
4488 fill_data
= target
->code_fill(fill_size
);
4490 fill_data
.resize(fill_size
); // Zero fill.
4492 Output_data_const
* fill
= new Output_data_const(fill_data
, 0);
4493 fill
->set_address(this->vaddr_
+ this->memsz_
);
4494 fill
->set_file_offset(off
);
4495 layout
->add_relax_output(fill
);
4498 gold_assert(off
% abi_pagesize
== 0);
4500 gold_assert(ret
% abi_pagesize
== 0);
4502 gold_assert((uint64_t) this->filesz_
== this->memsz_
);
4503 this->memsz_
= this->filesz_
+= fill_size
;
4512 // Set the addresses and file offsets in a list of Output_data
4516 Output_segment::set_section_list_addresses(Layout
* layout
, bool reset
,
4517 Output_data_list
* pdl
,
4518 uint64_t addr
, off_t
* poff
,
4520 unsigned int* pshndx
,
4523 off_t startoff
= *poff
;
4524 // For incremental updates, we may allocate non-fixed sections from
4525 // free space in the file. This keeps track of the high-water mark.
4526 off_t maxoff
= startoff
;
4528 off_t off
= startoff
;
4529 off_t foff
= *pfoff
;
4530 for (Output_data_list::iterator p
= pdl
->begin();
4534 bool is_bss
= (*p
)->is_section_type(elfcpp::SHT_NOBITS
);
4535 bool is_tls
= (*p
)->is_section_flag_set(elfcpp::SHF_TLS
);
4538 (*p
)->reset_address_and_file_offset();
4540 // When doing an incremental update or when using a linker script,
4541 // the section will most likely already have an address.
4542 if (!(*p
)->is_address_valid())
4544 uint64_t align
= (*p
)->addralign();
4548 // Give the first TLS section the alignment of the
4549 // entire TLS segment. Otherwise the TLS segment as a
4550 // whole may be misaligned.
4553 Output_segment
* tls_segment
= layout
->tls_segment();
4554 gold_assert(tls_segment
!= NULL
);
4555 uint64_t segment_align
= tls_segment
->maximum_alignment();
4556 gold_assert(segment_align
>= align
);
4557 align
= segment_align
;
4564 // If this is the first section after the TLS segment,
4565 // align it to at least the alignment of the TLS
4566 // segment, so that the size of the overall TLS segment
4570 uint64_t segment_align
=
4571 layout
->tls_segment()->maximum_alignment();
4572 if (segment_align
> align
)
4573 align
= segment_align
;
4579 if (!parameters
->incremental_update())
4581 gold_assert(off
== foff
|| is_bss
);
4582 off
= align_address(off
, align
);
4583 if (is_tls
|| !is_bss
)
4585 (*p
)->set_address_and_file_offset(addr
+ (off
- startoff
), foff
);
4589 // Incremental update: allocate file space from free list.
4590 (*p
)->pre_finalize_data_size();
4591 off_t current_size
= (*p
)->current_data_size();
4592 off
= layout
->allocate(current_size
, align
, startoff
);
4596 gold_assert((*p
)->output_section() != NULL
);
4597 gold_fallback(_("out of patch space for section %s; "
4598 "relink with --incremental-full"),
4599 (*p
)->output_section()->name());
4601 (*p
)->set_address_and_file_offset(addr
+ (off
- startoff
), foff
);
4602 if ((*p
)->data_size() > current_size
)
4604 gold_assert((*p
)->output_section() != NULL
);
4605 gold_fallback(_("%s: section changed size; "
4606 "relink with --incremental-full"),
4607 (*p
)->output_section()->name());
4611 else if (parameters
->incremental_update())
4613 // For incremental updates, use the fixed offset for the
4614 // high-water mark computation.
4615 off
= (*p
)->offset();
4620 // The script may have inserted a skip forward, but it
4621 // better not have moved backward.
4622 if ((*p
)->address() >= addr
+ (off
- startoff
))
4624 if (!is_bss
&& off
> foff
)
4625 gold_warning(_("script places BSS section in the middle "
4626 "of a LOAD segment; space will be allocated "
4628 off
+= (*p
)->address() - (addr
+ (off
- startoff
));
4629 if (is_tls
|| !is_bss
)
4634 if (!layout
->script_options()->saw_sections_clause())
4638 Output_section
* os
= (*p
)->output_section();
4640 // Cast to unsigned long long to avoid format warnings.
4641 unsigned long long previous_dot
=
4642 static_cast<unsigned long long>(addr
+ (off
- startoff
));
4643 unsigned long long dot
=
4644 static_cast<unsigned long long>((*p
)->address());
4647 gold_error(_("dot moves backward in linker script "
4648 "from 0x%llx to 0x%llx"), previous_dot
, dot
);
4650 gold_error(_("address of section '%s' moves backward "
4651 "from 0x%llx to 0x%llx"),
4652 os
->name(), previous_dot
, dot
);
4655 (*p
)->set_file_offset(foff
);
4656 (*p
)->finalize_data_size();
4659 if (parameters
->incremental_update())
4660 gold_debug(DEBUG_INCREMENTAL
,
4661 "set_section_list_addresses: %08lx %08lx %s",
4662 static_cast<long>(off
),
4663 static_cast<long>((*p
)->data_size()),
4664 ((*p
)->output_section() != NULL
4665 ? (*p
)->output_section()->name() : "(special)"));
4667 // We want to ignore the size of a SHF_TLS SHT_NOBITS
4668 // section. Such a section does not affect the size of a
4670 if (!is_tls
|| !is_bss
)
4671 off
+= (*p
)->data_size();
4673 // We don't allocate space in the file for SHT_NOBITS sections,
4674 // unless a script has force-placed one in the middle of a segment.
4681 if ((*p
)->is_section())
4683 (*p
)->set_out_shndx(*pshndx
);
4690 return addr
+ (maxoff
- startoff
);
4693 // For a non-PT_LOAD segment, set the offset from the sections, if
4694 // any. Add INCREASE to the file size and the memory size.
4697 Output_segment::set_offset(unsigned int increase
)
4699 gold_assert(this->type_
!= elfcpp::PT_LOAD
);
4701 gold_assert(!this->are_addresses_set_
);
4703 // A non-load section only uses output_lists_[0].
4705 Output_data_list
* pdl
= &this->output_lists_
[0];
4709 gold_assert(increase
== 0);
4712 this->are_addresses_set_
= true;
4714 this->min_p_align_
= 0;
4720 // Find the first and last section by address.
4721 const Output_data
* first
= NULL
;
4722 const Output_data
* last_data
= NULL
;
4723 const Output_data
* last_bss
= NULL
;
4724 for (Output_data_list::const_iterator p
= pdl
->begin();
4729 || (*p
)->address() < first
->address()
4730 || ((*p
)->address() == first
->address()
4731 && (*p
)->data_size() < first
->data_size()))
4733 const Output_data
** plast
;
4734 if ((*p
)->is_section()
4735 && (*p
)->output_section()->type() == elfcpp::SHT_NOBITS
)
4740 || (*p
)->address() > (*plast
)->address()
4741 || ((*p
)->address() == (*plast
)->address()
4742 && (*p
)->data_size() > (*plast
)->data_size()))
4746 this->vaddr_
= first
->address();
4747 this->paddr_
= (first
->has_load_address()
4748 ? first
->load_address()
4750 this->are_addresses_set_
= true;
4751 this->offset_
= first
->offset();
4753 if (last_data
== NULL
)
4756 this->filesz_
= (last_data
->address()
4757 + last_data
->data_size()
4760 const Output_data
* last
= last_bss
!= NULL
? last_bss
: last_data
;
4761 this->memsz_
= (last
->address()
4765 this->filesz_
+= increase
;
4766 this->memsz_
+= increase
;
4768 // If this is a RELRO segment, verify that the segment ends at a
4770 if (this->type_
== elfcpp::PT_GNU_RELRO
)
4772 uint64_t page_align
= parameters
->target().abi_pagesize();
4773 uint64_t segment_end
= this->vaddr_
+ this->memsz_
;
4774 if (parameters
->incremental_update())
4776 // The INCREASE_RELRO calculation is bypassed for an incremental
4777 // update, so we need to adjust the segment size manually here.
4778 segment_end
= align_address(segment_end
, page_align
);
4779 this->memsz_
= segment_end
- this->vaddr_
;
4782 gold_assert(segment_end
== align_address(segment_end
, page_align
));
4785 // If this is a TLS segment, align the memory size. The code in
4786 // set_section_list ensures that the section after the TLS segment
4787 // is aligned to give us room.
4788 if (this->type_
== elfcpp::PT_TLS
)
4790 uint64_t segment_align
= this->maximum_alignment();
4791 gold_assert(this->vaddr_
== align_address(this->vaddr_
, segment_align
));
4792 this->memsz_
= align_address(this->memsz_
, segment_align
);
4796 // Set the TLS offsets of the sections in the PT_TLS segment.
4799 Output_segment::set_tls_offsets()
4801 gold_assert(this->type_
== elfcpp::PT_TLS
);
4803 for (Output_data_list::iterator p
= this->output_lists_
[0].begin();
4804 p
!= this->output_lists_
[0].end();
4806 (*p
)->set_tls_offset(this->vaddr_
);
4809 // Return the first section.
4812 Output_segment::first_section() const
4814 for (int i
= 0; i
< static_cast<int>(ORDER_MAX
); ++i
)
4816 const Output_data_list
* pdl
= &this->output_lists_
[i
];
4817 for (Output_data_list::const_iterator p
= pdl
->begin();
4821 if ((*p
)->is_section())
4822 return (*p
)->output_section();
4828 // Return the number of Output_sections in an Output_segment.
4831 Output_segment::output_section_count() const
4833 unsigned int ret
= 0;
4834 for (int i
= 0; i
< static_cast<int>(ORDER_MAX
); ++i
)
4835 ret
+= this->output_section_count_list(&this->output_lists_
[i
]);
4839 // Return the number of Output_sections in an Output_data_list.
4842 Output_segment::output_section_count_list(const Output_data_list
* pdl
) const
4844 unsigned int count
= 0;
4845 for (Output_data_list::const_iterator p
= pdl
->begin();
4849 if ((*p
)->is_section())
4855 // Return the section attached to the list segment with the lowest
4856 // load address. This is used when handling a PHDRS clause in a
4860 Output_segment::section_with_lowest_load_address() const
4862 Output_section
* found
= NULL
;
4863 uint64_t found_lma
= 0;
4864 for (int i
= 0; i
< static_cast<int>(ORDER_MAX
); ++i
)
4865 this->lowest_load_address_in_list(&this->output_lists_
[i
], &found
,
4870 // Look through a list for a section with a lower load address.
4873 Output_segment::lowest_load_address_in_list(const Output_data_list
* pdl
,
4874 Output_section
** found
,
4875 uint64_t* found_lma
) const
4877 for (Output_data_list::const_iterator p
= pdl
->begin();
4881 if (!(*p
)->is_section())
4883 Output_section
* os
= static_cast<Output_section
*>(*p
);
4884 uint64_t lma
= (os
->has_load_address()
4885 ? os
->load_address()
4887 if (*found
== NULL
|| lma
< *found_lma
)
4895 // Write the segment data into *OPHDR.
4897 template<int size
, bool big_endian
>
4899 Output_segment::write_header(elfcpp::Phdr_write
<size
, big_endian
>* ophdr
)
4901 ophdr
->put_p_type(this->type_
);
4902 ophdr
->put_p_offset(this->offset_
);
4903 ophdr
->put_p_vaddr(this->vaddr_
);
4904 ophdr
->put_p_paddr(this->paddr_
);
4905 ophdr
->put_p_filesz(this->filesz_
);
4906 ophdr
->put_p_memsz(this->memsz_
);
4907 ophdr
->put_p_flags(this->flags_
);
4908 ophdr
->put_p_align(std::max(this->min_p_align_
, this->maximum_alignment()));
4911 // Write the section headers into V.
4913 template<int size
, bool big_endian
>
4915 Output_segment::write_section_headers(const Layout
* layout
,
4916 const Stringpool
* secnamepool
,
4918 unsigned int* pshndx
) const
4920 // Every section that is attached to a segment must be attached to a
4921 // PT_LOAD segment, so we only write out section headers for PT_LOAD
4923 if (this->type_
!= elfcpp::PT_LOAD
)
4926 for (int i
= 0; i
< static_cast<int>(ORDER_MAX
); ++i
)
4928 const Output_data_list
* pdl
= &this->output_lists_
[i
];
4929 v
= this->write_section_headers_list
<size
, big_endian
>(layout
,
4938 template<int size
, bool big_endian
>
4940 Output_segment::write_section_headers_list(const Layout
* layout
,
4941 const Stringpool
* secnamepool
,
4942 const Output_data_list
* pdl
,
4944 unsigned int* pshndx
) const
4946 const int shdr_size
= elfcpp::Elf_sizes
<size
>::shdr_size
;
4947 for (Output_data_list::const_iterator p
= pdl
->begin();
4951 if ((*p
)->is_section())
4953 const Output_section
* ps
= static_cast<const Output_section
*>(*p
);
4954 gold_assert(*pshndx
== ps
->out_shndx());
4955 elfcpp::Shdr_write
<size
, big_endian
> oshdr(v
);
4956 ps
->write_header(layout
, secnamepool
, &oshdr
);
4964 // Print the output sections to the map file.
4967 Output_segment::print_sections_to_mapfile(Mapfile
* mapfile
) const
4969 if (this->type() != elfcpp::PT_LOAD
)
4971 for (int i
= 0; i
< static_cast<int>(ORDER_MAX
); ++i
)
4972 this->print_section_list_to_mapfile(mapfile
, &this->output_lists_
[i
]);
4975 // Print an output section list to the map file.
4978 Output_segment::print_section_list_to_mapfile(Mapfile
* mapfile
,
4979 const Output_data_list
* pdl
) const
4981 for (Output_data_list::const_iterator p
= pdl
->begin();
4984 (*p
)->print_to_mapfile(mapfile
);
4987 // Output_file methods.
4989 Output_file::Output_file(const char* name
)
4994 map_is_anonymous_(false),
4995 map_is_allocated_(false),
4996 is_temporary_(false)
5000 // Try to open an existing file. Returns false if the file doesn't
5001 // exist, has a size of 0 or can't be mmapped. If BASE_NAME is not
5002 // NULL, open that file as the base for incremental linking, and
5003 // copy its contents to the new output file. This routine can
5004 // be called for incremental updates, in which case WRITABLE should
5005 // be true, or by the incremental-dump utility, in which case
5006 // WRITABLE should be false.
5009 Output_file::open_base_file(const char* base_name
, bool writable
)
5011 // The name "-" means "stdout".
5012 if (strcmp(this->name_
, "-") == 0)
5015 bool use_base_file
= base_name
!= NULL
;
5017 base_name
= this->name_
;
5018 else if (strcmp(base_name
, this->name_
) == 0)
5019 gold_fatal(_("%s: incremental base and output file name are the same"),
5022 // Don't bother opening files with a size of zero.
5024 if (::stat(base_name
, &s
) != 0)
5026 gold_info(_("%s: stat: %s"), base_name
, strerror(errno
));
5031 gold_info(_("%s: incremental base file is empty"), base_name
);
5035 // If we're using a base file, we want to open it read-only.
5039 int oflags
= writable
? O_RDWR
: O_RDONLY
;
5040 int o
= open_descriptor(-1, base_name
, oflags
, 0);
5043 gold_info(_("%s: open: %s"), base_name
, strerror(errno
));
5047 // If the base file and the output file are different, open a
5048 // new output file and read the contents from the base file into
5049 // the newly-mapped region.
5052 this->open(s
.st_size
);
5053 ssize_t bytes_to_read
= s
.st_size
;
5054 unsigned char* p
= this->base_
;
5055 while (bytes_to_read
> 0)
5057 ssize_t len
= ::read(o
, p
, bytes_to_read
);
5060 gold_info(_("%s: read failed: %s"), base_name
, strerror(errno
));
5065 gold_info(_("%s: file too short: read only %lld of %lld bytes"),
5067 static_cast<long long>(s
.st_size
- bytes_to_read
),
5068 static_cast<long long>(s
.st_size
));
5072 bytes_to_read
-= len
;
5079 this->file_size_
= s
.st_size
;
5081 if (!this->map_no_anonymous(writable
))
5083 release_descriptor(o
, true);
5085 this->file_size_
= 0;
5092 // Open the output file.
5095 Output_file::open(off_t file_size
)
5097 this->file_size_
= file_size
;
5099 // Unlink the file first; otherwise the open() may fail if the file
5100 // is busy (e.g. it's an executable that's currently being executed).
5102 // However, the linker may be part of a system where a zero-length
5103 // file is created for it to write to, with tight permissions (gcc
5104 // 2.95 did something like this). Unlinking the file would work
5105 // around those permission controls, so we only unlink if the file
5106 // has a non-zero size. We also unlink only regular files to avoid
5107 // trouble with directories/etc.
5109 // If we fail, continue; this command is merely a best-effort attempt
5110 // to improve the odds for open().
5112 // We let the name "-" mean "stdout"
5113 if (!this->is_temporary_
)
5115 if (strcmp(this->name_
, "-") == 0)
5116 this->o_
= STDOUT_FILENO
;
5120 if (::stat(this->name_
, &s
) == 0
5121 && (S_ISREG (s
.st_mode
) || S_ISLNK (s
.st_mode
)))
5124 ::unlink(this->name_
);
5125 else if (!parameters
->options().relocatable())
5127 // If we don't unlink the existing file, add execute
5128 // permission where read permissions already exist
5129 // and where the umask permits.
5130 int mask
= ::umask(0);
5132 s
.st_mode
|= (s
.st_mode
& 0444) >> 2;
5133 ::chmod(this->name_
, s
.st_mode
& ~mask
);
5137 int mode
= parameters
->options().relocatable() ? 0666 : 0777;
5138 int o
= open_descriptor(-1, this->name_
, O_RDWR
| O_CREAT
| O_TRUNC
,
5141 gold_fatal(_("%s: open: %s"), this->name_
, strerror(errno
));
5149 // Resize the output file.
5152 Output_file::resize(off_t file_size
)
5154 // If the mmap is mapping an anonymous memory buffer, this is easy:
5155 // just mremap to the new size. If it's mapping to a file, we want
5156 // to unmap to flush to the file, then remap after growing the file.
5157 if (this->map_is_anonymous_
)
5160 if (!this->map_is_allocated_
)
5162 base
= ::mremap(this->base_
, this->file_size_
, file_size
,
5164 if (base
== MAP_FAILED
)
5165 gold_fatal(_("%s: mremap: %s"), this->name_
, strerror(errno
));
5169 base
= realloc(this->base_
, file_size
);
5172 if (file_size
> this->file_size_
)
5173 memset(static_cast<char*>(base
) + this->file_size_
, 0,
5174 file_size
- this->file_size_
);
5176 this->base_
= static_cast<unsigned char*>(base
);
5177 this->file_size_
= file_size
;
5182 this->file_size_
= file_size
;
5183 if (!this->map_no_anonymous(true))
5184 gold_fatal(_("%s: mmap: %s"), this->name_
, strerror(errno
));
5188 // Map an anonymous block of memory which will later be written to the
5189 // file. Return whether the map succeeded.
5192 Output_file::map_anonymous()
5194 void* base
= ::mmap(NULL
, this->file_size_
, PROT_READ
| PROT_WRITE
,
5195 MAP_PRIVATE
| MAP_ANONYMOUS
, -1, 0);
5196 if (base
== MAP_FAILED
)
5198 base
= malloc(this->file_size_
);
5201 memset(base
, 0, this->file_size_
);
5202 this->map_is_allocated_
= true;
5204 this->base_
= static_cast<unsigned char*>(base
);
5205 this->map_is_anonymous_
= true;
5209 // Map the file into memory. Return whether the mapping succeeded.
5210 // If WRITABLE is true, map with write access.
5213 Output_file::map_no_anonymous(bool writable
)
5215 const int o
= this->o_
;
5217 // If the output file is not a regular file, don't try to mmap it;
5218 // instead, we'll mmap a block of memory (an anonymous buffer), and
5219 // then later write the buffer to the file.
5221 struct stat statbuf
;
5222 if (o
== STDOUT_FILENO
|| o
== STDERR_FILENO
5223 || ::fstat(o
, &statbuf
) != 0
5224 || !S_ISREG(statbuf
.st_mode
)
5225 || this->is_temporary_
)
5228 // Ensure that we have disk space available for the file. If we
5229 // don't do this, it is possible that we will call munmap, close,
5230 // and exit with dirty buffers still in the cache with no assigned
5231 // disk blocks. If the disk is out of space at that point, the
5232 // output file will wind up incomplete, but we will have already
5233 // exited. The alternative to fallocate would be to use fdatasync,
5234 // but that would be a more significant performance hit.
5237 int err
= gold_fallocate(o
, 0, this->file_size_
);
5239 gold_fatal(_("%s: %s"), this->name_
, strerror(err
));
5242 // Map the file into memory.
5243 int prot
= PROT_READ
;
5246 base
= ::mmap(NULL
, this->file_size_
, prot
, MAP_SHARED
, o
, 0);
5248 // The mmap call might fail because of file system issues: the file
5249 // system might not support mmap at all, or it might not support
5250 // mmap with PROT_WRITE.
5251 if (base
== MAP_FAILED
)
5254 this->map_is_anonymous_
= false;
5255 this->base_
= static_cast<unsigned char*>(base
);
5259 // Map the file into memory.
5264 if (parameters
->options().mmap_output_file()
5265 && this->map_no_anonymous(true))
5268 // The mmap call might fail because of file system issues: the file
5269 // system might not support mmap at all, or it might not support
5270 // mmap with PROT_WRITE. I'm not sure which errno values we will
5271 // see in all cases, so if the mmap fails for any reason and we
5272 // don't care about file contents, try for an anonymous map.
5273 if (this->map_anonymous())
5276 gold_fatal(_("%s: mmap: failed to allocate %lu bytes for output file: %s"),
5277 this->name_
, static_cast<unsigned long>(this->file_size_
),
5281 // Unmap the file from memory.
5284 Output_file::unmap()
5286 if (this->map_is_anonymous_
)
5288 // We've already written out the data, so there is no reason to
5289 // waste time unmapping or freeing the memory.
5293 if (::munmap(this->base_
, this->file_size_
) < 0)
5294 gold_error(_("%s: munmap: %s"), this->name_
, strerror(errno
));
5299 // Close the output file.
5302 Output_file::close()
5304 // If the map isn't file-backed, we need to write it now.
5305 if (this->map_is_anonymous_
&& !this->is_temporary_
)
5307 size_t bytes_to_write
= this->file_size_
;
5309 while (bytes_to_write
> 0)
5311 ssize_t bytes_written
= ::write(this->o_
, this->base_
+ offset
,
5313 if (bytes_written
== 0)
5314 gold_error(_("%s: write: unexpected 0 return-value"), this->name_
);
5315 else if (bytes_written
< 0)
5316 gold_error(_("%s: write: %s"), this->name_
, strerror(errno
));
5319 bytes_to_write
-= bytes_written
;
5320 offset
+= bytes_written
;
5326 // We don't close stdout or stderr
5327 if (this->o_
!= STDOUT_FILENO
5328 && this->o_
!= STDERR_FILENO
5329 && !this->is_temporary_
)
5330 if (::close(this->o_
) < 0)
5331 gold_error(_("%s: close: %s"), this->name_
, strerror(errno
));
5335 // Instantiate the templates we need. We could use the configure
5336 // script to restrict this to only the ones for implemented targets.
5338 #ifdef HAVE_TARGET_32_LITTLE
5341 Output_section::add_input_section
<32, false>(
5343 Sized_relobj_file
<32, false>* object
,
5345 const char* secname
,
5346 const elfcpp::Shdr
<32, false>& shdr
,
5347 unsigned int reloc_shndx
,
5348 bool have_sections_script
);
5351 #ifdef HAVE_TARGET_32_BIG
5354 Output_section::add_input_section
<32, true>(
5356 Sized_relobj_file
<32, true>* object
,
5358 const char* secname
,
5359 const elfcpp::Shdr
<32, true>& shdr
,
5360 unsigned int reloc_shndx
,
5361 bool have_sections_script
);
5364 #ifdef HAVE_TARGET_64_LITTLE
5367 Output_section::add_input_section
<64, false>(
5369 Sized_relobj_file
<64, false>* object
,
5371 const char* secname
,
5372 const elfcpp::Shdr
<64, false>& shdr
,
5373 unsigned int reloc_shndx
,
5374 bool have_sections_script
);
5377 #ifdef HAVE_TARGET_64_BIG
5380 Output_section::add_input_section
<64, true>(
5382 Sized_relobj_file
<64, true>* object
,
5384 const char* secname
,
5385 const elfcpp::Shdr
<64, true>& shdr
,
5386 unsigned int reloc_shndx
,
5387 bool have_sections_script
);
5390 #ifdef HAVE_TARGET_32_LITTLE
5392 class Output_reloc
<elfcpp::SHT_REL
, false, 32, false>;
5395 #ifdef HAVE_TARGET_32_BIG
5397 class Output_reloc
<elfcpp::SHT_REL
, false, 32, true>;
5400 #ifdef HAVE_TARGET_64_LITTLE
5402 class Output_reloc
<elfcpp::SHT_REL
, false, 64, false>;
5405 #ifdef HAVE_TARGET_64_BIG
5407 class Output_reloc
<elfcpp::SHT_REL
, false, 64, true>;
5410 #ifdef HAVE_TARGET_32_LITTLE
5412 class Output_reloc
<elfcpp::SHT_REL
, true, 32, false>;
5415 #ifdef HAVE_TARGET_32_BIG
5417 class Output_reloc
<elfcpp::SHT_REL
, true, 32, true>;
5420 #ifdef HAVE_TARGET_64_LITTLE
5422 class Output_reloc
<elfcpp::SHT_REL
, true, 64, false>;
5425 #ifdef HAVE_TARGET_64_BIG
5427 class Output_reloc
<elfcpp::SHT_REL
, true, 64, true>;
5430 #ifdef HAVE_TARGET_32_LITTLE
5432 class Output_reloc
<elfcpp::SHT_RELA
, false, 32, false>;
5435 #ifdef HAVE_TARGET_32_BIG
5437 class Output_reloc
<elfcpp::SHT_RELA
, false, 32, true>;
5440 #ifdef HAVE_TARGET_64_LITTLE
5442 class Output_reloc
<elfcpp::SHT_RELA
, false, 64, false>;
5445 #ifdef HAVE_TARGET_64_BIG
5447 class Output_reloc
<elfcpp::SHT_RELA
, false, 64, true>;
5450 #ifdef HAVE_TARGET_32_LITTLE
5452 class Output_reloc
<elfcpp::SHT_RELA
, true, 32, false>;
5455 #ifdef HAVE_TARGET_32_BIG
5457 class Output_reloc
<elfcpp::SHT_RELA
, true, 32, true>;
5460 #ifdef HAVE_TARGET_64_LITTLE
5462 class Output_reloc
<elfcpp::SHT_RELA
, true, 64, false>;
5465 #ifdef HAVE_TARGET_64_BIG
5467 class Output_reloc
<elfcpp::SHT_RELA
, true, 64, true>;
5470 #ifdef HAVE_TARGET_32_LITTLE
5472 class Output_data_reloc
<elfcpp::SHT_REL
, false, 32, false>;
5475 #ifdef HAVE_TARGET_32_BIG
5477 class Output_data_reloc
<elfcpp::SHT_REL
, false, 32, true>;
5480 #ifdef HAVE_TARGET_64_LITTLE
5482 class Output_data_reloc
<elfcpp::SHT_REL
, false, 64, false>;
5485 #ifdef HAVE_TARGET_64_BIG
5487 class Output_data_reloc
<elfcpp::SHT_REL
, false, 64, true>;
5490 #ifdef HAVE_TARGET_32_LITTLE
5492 class Output_data_reloc
<elfcpp::SHT_REL
, true, 32, false>;
5495 #ifdef HAVE_TARGET_32_BIG
5497 class Output_data_reloc
<elfcpp::SHT_REL
, true, 32, true>;
5500 #ifdef HAVE_TARGET_64_LITTLE
5502 class Output_data_reloc
<elfcpp::SHT_REL
, true, 64, false>;
5505 #ifdef HAVE_TARGET_64_BIG
5507 class Output_data_reloc
<elfcpp::SHT_REL
, true, 64, true>;
5510 #ifdef HAVE_TARGET_32_LITTLE
5512 class Output_data_reloc
<elfcpp::SHT_RELA
, false, 32, false>;
5515 #ifdef HAVE_TARGET_32_BIG
5517 class Output_data_reloc
<elfcpp::SHT_RELA
, false, 32, true>;
5520 #ifdef HAVE_TARGET_64_LITTLE
5522 class Output_data_reloc
<elfcpp::SHT_RELA
, false, 64, false>;
5525 #ifdef HAVE_TARGET_64_BIG
5527 class Output_data_reloc
<elfcpp::SHT_RELA
, false, 64, true>;
5530 #ifdef HAVE_TARGET_32_LITTLE
5532 class Output_data_reloc
<elfcpp::SHT_RELA
, true, 32, false>;
5535 #ifdef HAVE_TARGET_32_BIG
5537 class Output_data_reloc
<elfcpp::SHT_RELA
, true, 32, true>;
5540 #ifdef HAVE_TARGET_64_LITTLE
5542 class Output_data_reloc
<elfcpp::SHT_RELA
, true, 64, false>;
5545 #ifdef HAVE_TARGET_64_BIG
5547 class Output_data_reloc
<elfcpp::SHT_RELA
, true, 64, true>;
5550 #ifdef HAVE_TARGET_32_LITTLE
5552 class Output_relocatable_relocs
<elfcpp::SHT_REL
, 32, false>;
5555 #ifdef HAVE_TARGET_32_BIG
5557 class Output_relocatable_relocs
<elfcpp::SHT_REL
, 32, true>;
5560 #ifdef HAVE_TARGET_64_LITTLE
5562 class Output_relocatable_relocs
<elfcpp::SHT_REL
, 64, false>;
5565 #ifdef HAVE_TARGET_64_BIG
5567 class Output_relocatable_relocs
<elfcpp::SHT_REL
, 64, true>;
5570 #ifdef HAVE_TARGET_32_LITTLE
5572 class Output_relocatable_relocs
<elfcpp::SHT_RELA
, 32, false>;
5575 #ifdef HAVE_TARGET_32_BIG
5577 class Output_relocatable_relocs
<elfcpp::SHT_RELA
, 32, true>;
5580 #ifdef HAVE_TARGET_64_LITTLE
5582 class Output_relocatable_relocs
<elfcpp::SHT_RELA
, 64, false>;
5585 #ifdef HAVE_TARGET_64_BIG
5587 class Output_relocatable_relocs
<elfcpp::SHT_RELA
, 64, true>;
5590 #ifdef HAVE_TARGET_32_LITTLE
5592 class Output_data_group
<32, false>;
5595 #ifdef HAVE_TARGET_32_BIG
5597 class Output_data_group
<32, true>;
5600 #ifdef HAVE_TARGET_64_LITTLE
5602 class Output_data_group
<64, false>;
5605 #ifdef HAVE_TARGET_64_BIG
5607 class Output_data_group
<64, true>;
5611 class Output_data_got
<32, false>;
5614 class Output_data_got
<32, true>;
5617 class Output_data_got
<64, false>;
5620 class Output_data_got
<64, true>;
5622 } // End namespace gold.