1 // output.cc -- manage the output file for gold
3 // Copyright 2006, 2007, 2008, 2009, 2010, 2011, 2012
4 // Free Software Foundation, Inc.
5 // Written by Ian Lance Taylor <iant@google.com>.
7 // This file is part of gold.
9 // This program is free software; you can redistribute it and/or modify
10 // it under the terms of the GNU General Public License as published by
11 // the Free Software Foundation; either version 3 of the License, or
12 // (at your option) any later version.
14 // This program is distributed in the hope that it will be useful,
15 // but WITHOUT ANY WARRANTY; without even the implied warranty of
16 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 // GNU General Public License for more details.
19 // You should have received a copy of the GNU General Public License
20 // along with this program; if not, write to the Free Software
21 // Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
22 // MA 02110-1301, USA.
34 #ifdef HAVE_SYS_MMAN_H
38 #include "libiberty.h"
41 #include "parameters.h"
46 #include "descriptors.h"
50 // For systems without mmap support.
52 # define mmap gold_mmap
53 # define munmap gold_munmap
54 # define mremap gold_mremap
56 # define MAP_FAILED (reinterpret_cast<void*>(-1))
65 # define MAP_PRIVATE 0
67 # ifndef MAP_ANONYMOUS
68 # define MAP_ANONYMOUS 0
75 # define ENOSYS EINVAL
79 gold_mmap(void *, size_t, int, int, int, off_t
)
86 gold_munmap(void *, size_t)
93 gold_mremap(void *, size_t, size_t, int)
101 #if defined(HAVE_MMAP) && !defined(HAVE_MREMAP)
102 # define mremap gold_mremap
103 extern "C" void *gold_mremap(void *, size_t, size_t, int);
106 // Some BSD systems still use MAP_ANON instead of MAP_ANONYMOUS
107 #ifndef MAP_ANONYMOUS
108 # define MAP_ANONYMOUS MAP_ANON
111 #ifndef MREMAP_MAYMOVE
112 # define MREMAP_MAYMOVE 1
115 // Mingw does not have S_ISLNK.
117 # define S_ISLNK(mode) 0
123 // A wrapper around posix_fallocate. If we don't have posix_fallocate,
124 // or the --no-posix-fallocate option is set, we try the fallocate
125 // system call directly. If that fails, we use ftruncate to set
126 // the file size and hope that there is enough disk space.
129 gold_fallocate(int o
, off_t offset
, off_t len
)
131 #ifdef HAVE_POSIX_FALLOCATE
132 if (parameters
->options().posix_fallocate())
133 return ::posix_fallocate(o
, offset
, len
);
134 #endif // defined(HAVE_POSIX_FALLOCATE)
135 #ifdef HAVE_FALLOCATE
136 if (::fallocate(o
, 0, offset
, len
) == 0)
138 #endif // defined(HAVE_FALLOCATE)
139 if (::ftruncate(o
, offset
+ len
) < 0)
144 // Output_data variables.
146 bool Output_data::allocated_sizes_are_fixed
;
148 // Output_data methods.
150 Output_data::~Output_data()
154 // Return the default alignment for the target size.
157 Output_data::default_alignment()
159 return Output_data::default_alignment_for_size(
160 parameters
->target().get_size());
163 // Return the default alignment for a size--32 or 64.
166 Output_data::default_alignment_for_size(int size
)
176 // Output_section_header methods. This currently assumes that the
177 // segment and section lists are complete at construction time.
179 Output_section_headers::Output_section_headers(
180 const Layout
* layout
,
181 const Layout::Segment_list
* segment_list
,
182 const Layout::Section_list
* section_list
,
183 const Layout::Section_list
* unattached_section_list
,
184 const Stringpool
* secnamepool
,
185 const Output_section
* shstrtab_section
)
187 segment_list_(segment_list
),
188 section_list_(section_list
),
189 unattached_section_list_(unattached_section_list
),
190 secnamepool_(secnamepool
),
191 shstrtab_section_(shstrtab_section
)
195 // Compute the current data size.
198 Output_section_headers::do_size() const
200 // Count all the sections. Start with 1 for the null section.
202 if (!parameters
->options().relocatable())
204 for (Layout::Segment_list::const_iterator p
=
205 this->segment_list_
->begin();
206 p
!= this->segment_list_
->end();
208 if ((*p
)->type() == elfcpp::PT_LOAD
)
209 count
+= (*p
)->output_section_count();
213 for (Layout::Section_list::const_iterator p
=
214 this->section_list_
->begin();
215 p
!= this->section_list_
->end();
217 if (((*p
)->flags() & elfcpp::SHF_ALLOC
) != 0)
220 count
+= this->unattached_section_list_
->size();
222 const int size
= parameters
->target().get_size();
225 shdr_size
= elfcpp::Elf_sizes
<32>::shdr_size
;
227 shdr_size
= elfcpp::Elf_sizes
<64>::shdr_size
;
231 return count
* shdr_size
;
234 // Write out the section headers.
237 Output_section_headers::do_write(Output_file
* of
)
239 switch (parameters
->size_and_endianness())
241 #ifdef HAVE_TARGET_32_LITTLE
242 case Parameters::TARGET_32_LITTLE
:
243 this->do_sized_write
<32, false>(of
);
246 #ifdef HAVE_TARGET_32_BIG
247 case Parameters::TARGET_32_BIG
:
248 this->do_sized_write
<32, true>(of
);
251 #ifdef HAVE_TARGET_64_LITTLE
252 case Parameters::TARGET_64_LITTLE
:
253 this->do_sized_write
<64, false>(of
);
256 #ifdef HAVE_TARGET_64_BIG
257 case Parameters::TARGET_64_BIG
:
258 this->do_sized_write
<64, true>(of
);
266 template<int size
, bool big_endian
>
268 Output_section_headers::do_sized_write(Output_file
* of
)
270 off_t all_shdrs_size
= this->data_size();
271 unsigned char* view
= of
->get_output_view(this->offset(), all_shdrs_size
);
273 const int shdr_size
= elfcpp::Elf_sizes
<size
>::shdr_size
;
274 unsigned char* v
= view
;
277 typename
elfcpp::Shdr_write
<size
, big_endian
> oshdr(v
);
278 oshdr
.put_sh_name(0);
279 oshdr
.put_sh_type(elfcpp::SHT_NULL
);
280 oshdr
.put_sh_flags(0);
281 oshdr
.put_sh_addr(0);
282 oshdr
.put_sh_offset(0);
284 size_t section_count
= (this->data_size()
285 / elfcpp::Elf_sizes
<size
>::shdr_size
);
286 if (section_count
< elfcpp::SHN_LORESERVE
)
287 oshdr
.put_sh_size(0);
289 oshdr
.put_sh_size(section_count
);
291 unsigned int shstrndx
= this->shstrtab_section_
->out_shndx();
292 if (shstrndx
< elfcpp::SHN_LORESERVE
)
293 oshdr
.put_sh_link(0);
295 oshdr
.put_sh_link(shstrndx
);
297 size_t segment_count
= this->segment_list_
->size();
298 oshdr
.put_sh_info(segment_count
>= elfcpp::PN_XNUM
? segment_count
: 0);
300 oshdr
.put_sh_addralign(0);
301 oshdr
.put_sh_entsize(0);
306 unsigned int shndx
= 1;
307 if (!parameters
->options().relocatable())
309 for (Layout::Segment_list::const_iterator p
=
310 this->segment_list_
->begin();
311 p
!= this->segment_list_
->end();
313 v
= (*p
)->write_section_headers
<size
, big_endian
>(this->layout_
,
320 for (Layout::Section_list::const_iterator p
=
321 this->section_list_
->begin();
322 p
!= this->section_list_
->end();
325 // We do unallocated sections below, except that group
326 // sections have to come first.
327 if (((*p
)->flags() & elfcpp::SHF_ALLOC
) == 0
328 && (*p
)->type() != elfcpp::SHT_GROUP
)
330 gold_assert(shndx
== (*p
)->out_shndx());
331 elfcpp::Shdr_write
<size
, big_endian
> oshdr(v
);
332 (*p
)->write_header(this->layout_
, this->secnamepool_
, &oshdr
);
338 for (Layout::Section_list::const_iterator p
=
339 this->unattached_section_list_
->begin();
340 p
!= this->unattached_section_list_
->end();
343 // For a relocatable link, we did unallocated group sections
344 // above, since they have to come first.
345 if ((*p
)->type() == elfcpp::SHT_GROUP
346 && parameters
->options().relocatable())
348 gold_assert(shndx
== (*p
)->out_shndx());
349 elfcpp::Shdr_write
<size
, big_endian
> oshdr(v
);
350 (*p
)->write_header(this->layout_
, this->secnamepool_
, &oshdr
);
355 of
->write_output_view(this->offset(), all_shdrs_size
, view
);
358 // Output_segment_header methods.
360 Output_segment_headers::Output_segment_headers(
361 const Layout::Segment_list
& segment_list
)
362 : segment_list_(segment_list
)
364 this->set_current_data_size_for_child(this->do_size());
368 Output_segment_headers::do_write(Output_file
* of
)
370 switch (parameters
->size_and_endianness())
372 #ifdef HAVE_TARGET_32_LITTLE
373 case Parameters::TARGET_32_LITTLE
:
374 this->do_sized_write
<32, false>(of
);
377 #ifdef HAVE_TARGET_32_BIG
378 case Parameters::TARGET_32_BIG
:
379 this->do_sized_write
<32, true>(of
);
382 #ifdef HAVE_TARGET_64_LITTLE
383 case Parameters::TARGET_64_LITTLE
:
384 this->do_sized_write
<64, false>(of
);
387 #ifdef HAVE_TARGET_64_BIG
388 case Parameters::TARGET_64_BIG
:
389 this->do_sized_write
<64, true>(of
);
397 template<int size
, bool big_endian
>
399 Output_segment_headers::do_sized_write(Output_file
* of
)
401 const int phdr_size
= elfcpp::Elf_sizes
<size
>::phdr_size
;
402 off_t all_phdrs_size
= this->segment_list_
.size() * phdr_size
;
403 gold_assert(all_phdrs_size
== this->data_size());
404 unsigned char* view
= of
->get_output_view(this->offset(),
406 unsigned char* v
= view
;
407 for (Layout::Segment_list::const_iterator p
= this->segment_list_
.begin();
408 p
!= this->segment_list_
.end();
411 elfcpp::Phdr_write
<size
, big_endian
> ophdr(v
);
412 (*p
)->write_header(&ophdr
);
416 gold_assert(v
- view
== all_phdrs_size
);
418 of
->write_output_view(this->offset(), all_phdrs_size
, view
);
422 Output_segment_headers::do_size() const
424 const int size
= parameters
->target().get_size();
427 phdr_size
= elfcpp::Elf_sizes
<32>::phdr_size
;
429 phdr_size
= elfcpp::Elf_sizes
<64>::phdr_size
;
433 return this->segment_list_
.size() * phdr_size
;
436 // Output_file_header methods.
438 Output_file_header::Output_file_header(const Target
* target
,
439 const Symbol_table
* symtab
,
440 const Output_segment_headers
* osh
)
443 segment_header_(osh
),
444 section_header_(NULL
),
447 this->set_data_size(this->do_size());
450 // Set the section table information for a file header.
453 Output_file_header::set_section_info(const Output_section_headers
* shdrs
,
454 const Output_section
* shstrtab
)
456 this->section_header_
= shdrs
;
457 this->shstrtab_
= shstrtab
;
460 // Write out the file header.
463 Output_file_header::do_write(Output_file
* of
)
465 gold_assert(this->offset() == 0);
467 switch (parameters
->size_and_endianness())
469 #ifdef HAVE_TARGET_32_LITTLE
470 case Parameters::TARGET_32_LITTLE
:
471 this->do_sized_write
<32, false>(of
);
474 #ifdef HAVE_TARGET_32_BIG
475 case Parameters::TARGET_32_BIG
:
476 this->do_sized_write
<32, true>(of
);
479 #ifdef HAVE_TARGET_64_LITTLE
480 case Parameters::TARGET_64_LITTLE
:
481 this->do_sized_write
<64, false>(of
);
484 #ifdef HAVE_TARGET_64_BIG
485 case Parameters::TARGET_64_BIG
:
486 this->do_sized_write
<64, true>(of
);
494 // Write out the file header with appropriate size and endianness.
496 template<int size
, bool big_endian
>
498 Output_file_header::do_sized_write(Output_file
* of
)
500 gold_assert(this->offset() == 0);
502 int ehdr_size
= elfcpp::Elf_sizes
<size
>::ehdr_size
;
503 unsigned char* view
= of
->get_output_view(0, ehdr_size
);
504 elfcpp::Ehdr_write
<size
, big_endian
> oehdr(view
);
506 unsigned char e_ident
[elfcpp::EI_NIDENT
];
507 memset(e_ident
, 0, elfcpp::EI_NIDENT
);
508 e_ident
[elfcpp::EI_MAG0
] = elfcpp::ELFMAG0
;
509 e_ident
[elfcpp::EI_MAG1
] = elfcpp::ELFMAG1
;
510 e_ident
[elfcpp::EI_MAG2
] = elfcpp::ELFMAG2
;
511 e_ident
[elfcpp::EI_MAG3
] = elfcpp::ELFMAG3
;
513 e_ident
[elfcpp::EI_CLASS
] = elfcpp::ELFCLASS32
;
515 e_ident
[elfcpp::EI_CLASS
] = elfcpp::ELFCLASS64
;
518 e_ident
[elfcpp::EI_DATA
] = (big_endian
519 ? elfcpp::ELFDATA2MSB
520 : elfcpp::ELFDATA2LSB
);
521 e_ident
[elfcpp::EI_VERSION
] = elfcpp::EV_CURRENT
;
522 oehdr
.put_e_ident(e_ident
);
525 if (parameters
->options().relocatable())
526 e_type
= elfcpp::ET_REL
;
527 else if (parameters
->options().output_is_position_independent())
528 e_type
= elfcpp::ET_DYN
;
530 e_type
= elfcpp::ET_EXEC
;
531 oehdr
.put_e_type(e_type
);
533 oehdr
.put_e_machine(this->target_
->machine_code());
534 oehdr
.put_e_version(elfcpp::EV_CURRENT
);
536 oehdr
.put_e_entry(this->entry
<size
>());
538 if (this->segment_header_
== NULL
)
539 oehdr
.put_e_phoff(0);
541 oehdr
.put_e_phoff(this->segment_header_
->offset());
543 oehdr
.put_e_shoff(this->section_header_
->offset());
544 oehdr
.put_e_flags(this->target_
->processor_specific_flags());
545 oehdr
.put_e_ehsize(elfcpp::Elf_sizes
<size
>::ehdr_size
);
547 if (this->segment_header_
== NULL
)
549 oehdr
.put_e_phentsize(0);
550 oehdr
.put_e_phnum(0);
554 oehdr
.put_e_phentsize(elfcpp::Elf_sizes
<size
>::phdr_size
);
555 size_t phnum
= (this->segment_header_
->data_size()
556 / elfcpp::Elf_sizes
<size
>::phdr_size
);
557 if (phnum
> elfcpp::PN_XNUM
)
558 phnum
= elfcpp::PN_XNUM
;
559 oehdr
.put_e_phnum(phnum
);
562 oehdr
.put_e_shentsize(elfcpp::Elf_sizes
<size
>::shdr_size
);
563 size_t section_count
= (this->section_header_
->data_size()
564 / elfcpp::Elf_sizes
<size
>::shdr_size
);
566 if (section_count
< elfcpp::SHN_LORESERVE
)
567 oehdr
.put_e_shnum(this->section_header_
->data_size()
568 / elfcpp::Elf_sizes
<size
>::shdr_size
);
570 oehdr
.put_e_shnum(0);
572 unsigned int shstrndx
= this->shstrtab_
->out_shndx();
573 if (shstrndx
< elfcpp::SHN_LORESERVE
)
574 oehdr
.put_e_shstrndx(this->shstrtab_
->out_shndx());
576 oehdr
.put_e_shstrndx(elfcpp::SHN_XINDEX
);
578 // Let the target adjust the ELF header, e.g., to set EI_OSABI in
579 // the e_ident field.
580 parameters
->target().adjust_elf_header(view
, ehdr_size
);
582 of
->write_output_view(0, ehdr_size
, view
);
585 // Return the value to use for the entry address.
588 typename
elfcpp::Elf_types
<size
>::Elf_Addr
589 Output_file_header::entry()
591 const bool should_issue_warning
= (parameters
->options().entry() != NULL
592 && !parameters
->options().relocatable()
593 && !parameters
->options().shared());
594 const char* entry
= parameters
->entry();
595 Symbol
* sym
= this->symtab_
->lookup(entry
);
597 typename Sized_symbol
<size
>::Value_type v
;
600 Sized_symbol
<size
>* ssym
;
601 ssym
= this->symtab_
->get_sized_symbol
<size
>(sym
);
602 if (!ssym
->is_defined() && should_issue_warning
)
603 gold_warning("entry symbol '%s' exists but is not defined", entry
);
608 // We couldn't find the entry symbol. See if we can parse it as
609 // a number. This supports, e.g., -e 0x1000.
611 v
= strtoull(entry
, &endptr
, 0);
614 if (should_issue_warning
)
615 gold_warning("cannot find entry symbol '%s'", entry
);
623 // Compute the current data size.
626 Output_file_header::do_size() const
628 const int size
= parameters
->target().get_size();
630 return elfcpp::Elf_sizes
<32>::ehdr_size
;
632 return elfcpp::Elf_sizes
<64>::ehdr_size
;
637 // Output_data_const methods.
640 Output_data_const::do_write(Output_file
* of
)
642 of
->write(this->offset(), this->data_
.data(), this->data_
.size());
645 // Output_data_const_buffer methods.
648 Output_data_const_buffer::do_write(Output_file
* of
)
650 of
->write(this->offset(), this->p_
, this->data_size());
653 // Output_section_data methods.
655 // Record the output section, and set the entry size and such.
658 Output_section_data::set_output_section(Output_section
* os
)
660 gold_assert(this->output_section_
== NULL
);
661 this->output_section_
= os
;
662 this->do_adjust_output_section(os
);
665 // Return the section index of the output section.
668 Output_section_data::do_out_shndx() const
670 gold_assert(this->output_section_
!= NULL
);
671 return this->output_section_
->out_shndx();
674 // Set the alignment, which means we may need to update the alignment
675 // of the output section.
678 Output_section_data::set_addralign(uint64_t addralign
)
680 this->addralign_
= addralign
;
681 if (this->output_section_
!= NULL
682 && this->output_section_
->addralign() < addralign
)
683 this->output_section_
->set_addralign(addralign
);
686 // Output_data_strtab methods.
688 // Set the final data size.
691 Output_data_strtab::set_final_data_size()
693 this->strtab_
->set_string_offsets();
694 this->set_data_size(this->strtab_
->get_strtab_size());
697 // Write out a string table.
700 Output_data_strtab::do_write(Output_file
* of
)
702 this->strtab_
->write(of
, this->offset());
705 // Output_reloc methods.
707 // A reloc against a global symbol.
709 template<bool dynamic
, int size
, bool big_endian
>
710 Output_reloc
<elfcpp::SHT_REL
, dynamic
, size
, big_endian
>::Output_reloc(
718 : address_(address
), local_sym_index_(GSYM_CODE
), type_(type
),
719 is_relative_(is_relative
), is_symbolless_(is_symbolless
),
720 is_section_symbol_(false), use_plt_offset_(use_plt_offset
), shndx_(INVALID_CODE
)
722 // this->type_ is a bitfield; make sure TYPE fits.
723 gold_assert(this->type_
== type
);
724 this->u1_
.gsym
= gsym
;
727 this->set_needs_dynsym_index();
730 template<bool dynamic
, int size
, bool big_endian
>
731 Output_reloc
<elfcpp::SHT_REL
, dynamic
, size
, big_endian
>::Output_reloc(
734 Sized_relobj
<size
, big_endian
>* relobj
,
740 : address_(address
), local_sym_index_(GSYM_CODE
), type_(type
),
741 is_relative_(is_relative
), is_symbolless_(is_symbolless
),
742 is_section_symbol_(false), use_plt_offset_(use_plt_offset
), shndx_(shndx
)
744 gold_assert(shndx
!= INVALID_CODE
);
745 // this->type_ is a bitfield; make sure TYPE fits.
746 gold_assert(this->type_
== type
);
747 this->u1_
.gsym
= gsym
;
748 this->u2_
.relobj
= relobj
;
750 this->set_needs_dynsym_index();
753 // A reloc against a local symbol.
755 template<bool dynamic
, int size
, bool big_endian
>
756 Output_reloc
<elfcpp::SHT_REL
, dynamic
, size
, big_endian
>::Output_reloc(
757 Sized_relobj
<size
, big_endian
>* relobj
,
758 unsigned int local_sym_index
,
764 bool is_section_symbol
,
766 : address_(address
), local_sym_index_(local_sym_index
), type_(type
),
767 is_relative_(is_relative
), is_symbolless_(is_symbolless
),
768 is_section_symbol_(is_section_symbol
), use_plt_offset_(use_plt_offset
),
771 gold_assert(local_sym_index
!= GSYM_CODE
772 && local_sym_index
!= INVALID_CODE
);
773 // this->type_ is a bitfield; make sure TYPE fits.
774 gold_assert(this->type_
== type
);
775 this->u1_
.relobj
= relobj
;
778 this->set_needs_dynsym_index();
781 template<bool dynamic
, int size
, bool big_endian
>
782 Output_reloc
<elfcpp::SHT_REL
, dynamic
, size
, big_endian
>::Output_reloc(
783 Sized_relobj
<size
, big_endian
>* relobj
,
784 unsigned int local_sym_index
,
790 bool is_section_symbol
,
792 : address_(address
), local_sym_index_(local_sym_index
), type_(type
),
793 is_relative_(is_relative
), is_symbolless_(is_symbolless
),
794 is_section_symbol_(is_section_symbol
), use_plt_offset_(use_plt_offset
),
797 gold_assert(local_sym_index
!= GSYM_CODE
798 && local_sym_index
!= INVALID_CODE
);
799 gold_assert(shndx
!= INVALID_CODE
);
800 // this->type_ is a bitfield; make sure TYPE fits.
801 gold_assert(this->type_
== type
);
802 this->u1_
.relobj
= relobj
;
803 this->u2_
.relobj
= relobj
;
805 this->set_needs_dynsym_index();
808 // A reloc against the STT_SECTION symbol of an output section.
810 template<bool dynamic
, int size
, bool big_endian
>
811 Output_reloc
<elfcpp::SHT_REL
, dynamic
, size
, big_endian
>::Output_reloc(
817 : address_(address
), local_sym_index_(SECTION_CODE
), type_(type
),
818 is_relative_(is_relative
), is_symbolless_(is_relative
),
819 is_section_symbol_(true), use_plt_offset_(false), shndx_(INVALID_CODE
)
821 // this->type_ is a bitfield; make sure TYPE fits.
822 gold_assert(this->type_
== type
);
826 this->set_needs_dynsym_index();
828 os
->set_needs_symtab_index();
831 template<bool dynamic
, int size
, bool big_endian
>
832 Output_reloc
<elfcpp::SHT_REL
, dynamic
, size
, big_endian
>::Output_reloc(
835 Sized_relobj
<size
, big_endian
>* relobj
,
839 : address_(address
), local_sym_index_(SECTION_CODE
), type_(type
),
840 is_relative_(is_relative
), is_symbolless_(is_relative
),
841 is_section_symbol_(true), use_plt_offset_(false), shndx_(shndx
)
843 gold_assert(shndx
!= INVALID_CODE
);
844 // this->type_ is a bitfield; make sure TYPE fits.
845 gold_assert(this->type_
== type
);
847 this->u2_
.relobj
= relobj
;
849 this->set_needs_dynsym_index();
851 os
->set_needs_symtab_index();
854 // An absolute relocation.
856 template<bool dynamic
, int size
, bool big_endian
>
857 Output_reloc
<elfcpp::SHT_REL
, dynamic
, size
, big_endian
>::Output_reloc(
861 : address_(address
), local_sym_index_(0), type_(type
),
862 is_relative_(false), is_symbolless_(false),
863 is_section_symbol_(false), use_plt_offset_(false), shndx_(INVALID_CODE
)
865 // this->type_ is a bitfield; make sure TYPE fits.
866 gold_assert(this->type_
== type
);
867 this->u1_
.relobj
= NULL
;
871 template<bool dynamic
, int size
, bool big_endian
>
872 Output_reloc
<elfcpp::SHT_REL
, dynamic
, size
, big_endian
>::Output_reloc(
874 Sized_relobj
<size
, big_endian
>* relobj
,
877 : address_(address
), local_sym_index_(0), type_(type
),
878 is_relative_(false), is_symbolless_(false),
879 is_section_symbol_(false), use_plt_offset_(false), shndx_(shndx
)
881 gold_assert(shndx
!= INVALID_CODE
);
882 // this->type_ is a bitfield; make sure TYPE fits.
883 gold_assert(this->type_
== type
);
884 this->u1_
.relobj
= NULL
;
885 this->u2_
.relobj
= relobj
;
888 // A target specific relocation.
890 template<bool dynamic
, int size
, bool big_endian
>
891 Output_reloc
<elfcpp::SHT_REL
, dynamic
, size
, big_endian
>::Output_reloc(
896 : address_(address
), local_sym_index_(TARGET_CODE
), type_(type
),
897 is_relative_(false), is_symbolless_(false),
898 is_section_symbol_(false), use_plt_offset_(false), shndx_(INVALID_CODE
)
900 // this->type_ is a bitfield; make sure TYPE fits.
901 gold_assert(this->type_
== type
);
906 template<bool dynamic
, int size
, bool big_endian
>
907 Output_reloc
<elfcpp::SHT_REL
, dynamic
, size
, big_endian
>::Output_reloc(
910 Sized_relobj
<size
, big_endian
>* relobj
,
913 : address_(address
), local_sym_index_(TARGET_CODE
), type_(type
),
914 is_relative_(false), is_symbolless_(false),
915 is_section_symbol_(false), use_plt_offset_(false), shndx_(shndx
)
917 gold_assert(shndx
!= INVALID_CODE
);
918 // this->type_ is a bitfield; make sure TYPE fits.
919 gold_assert(this->type_
== type
);
921 this->u2_
.relobj
= relobj
;
924 // Record that we need a dynamic symbol index for this relocation.
926 template<bool dynamic
, int size
, bool big_endian
>
928 Output_reloc
<elfcpp::SHT_REL
, dynamic
, size
, big_endian
>::
929 set_needs_dynsym_index()
931 if (this->is_symbolless_
)
933 switch (this->local_sym_index_
)
939 this->u1_
.gsym
->set_needs_dynsym_entry();
943 this->u1_
.os
->set_needs_dynsym_index();
947 // The target must take care of this if necessary.
955 const unsigned int lsi
= this->local_sym_index_
;
956 Sized_relobj_file
<size
, big_endian
>* relobj
=
957 this->u1_
.relobj
->sized_relobj();
958 gold_assert(relobj
!= NULL
);
959 if (!this->is_section_symbol_
)
960 relobj
->set_needs_output_dynsym_entry(lsi
);
962 relobj
->output_section(lsi
)->set_needs_dynsym_index();
968 // Get the symbol index of a relocation.
970 template<bool dynamic
, int size
, bool big_endian
>
972 Output_reloc
<elfcpp::SHT_REL
, dynamic
, size
, big_endian
>::get_symbol_index()
976 if (this->is_symbolless_
)
978 switch (this->local_sym_index_
)
984 if (this->u1_
.gsym
== NULL
)
987 index
= this->u1_
.gsym
->dynsym_index();
989 index
= this->u1_
.gsym
->symtab_index();
994 index
= this->u1_
.os
->dynsym_index();
996 index
= this->u1_
.os
->symtab_index();
1000 index
= parameters
->target().reloc_symbol_index(this->u1_
.arg
,
1005 // Relocations without symbols use a symbol index of 0.
1011 const unsigned int lsi
= this->local_sym_index_
;
1012 Sized_relobj_file
<size
, big_endian
>* relobj
=
1013 this->u1_
.relobj
->sized_relobj();
1014 gold_assert(relobj
!= NULL
);
1015 if (!this->is_section_symbol_
)
1018 index
= relobj
->dynsym_index(lsi
);
1020 index
= relobj
->symtab_index(lsi
);
1024 Output_section
* os
= relobj
->output_section(lsi
);
1025 gold_assert(os
!= NULL
);
1027 index
= os
->dynsym_index();
1029 index
= os
->symtab_index();
1034 gold_assert(index
!= -1U);
1038 // For a local section symbol, get the address of the offset ADDEND
1039 // within the input section.
1041 template<bool dynamic
, int size
, bool big_endian
>
1042 typename
elfcpp::Elf_types
<size
>::Elf_Addr
1043 Output_reloc
<elfcpp::SHT_REL
, dynamic
, size
, big_endian
>::
1044 local_section_offset(Addend addend
) const
1046 gold_assert(this->local_sym_index_
!= GSYM_CODE
1047 && this->local_sym_index_
!= SECTION_CODE
1048 && this->local_sym_index_
!= TARGET_CODE
1049 && this->local_sym_index_
!= INVALID_CODE
1050 && this->local_sym_index_
!= 0
1051 && this->is_section_symbol_
);
1052 const unsigned int lsi
= this->local_sym_index_
;
1053 Output_section
* os
= this->u1_
.relobj
->output_section(lsi
);
1054 gold_assert(os
!= NULL
);
1055 Address offset
= this->u1_
.relobj
->get_output_section_offset(lsi
);
1056 if (offset
!= invalid_address
)
1057 return offset
+ addend
;
1058 // This is a merge section.
1059 Sized_relobj_file
<size
, big_endian
>* relobj
=
1060 this->u1_
.relobj
->sized_relobj();
1061 gold_assert(relobj
!= NULL
);
1062 offset
= os
->output_address(relobj
, lsi
, addend
);
1063 gold_assert(offset
!= invalid_address
);
1067 // Get the output address of a relocation.
1069 template<bool dynamic
, int size
, bool big_endian
>
1070 typename
elfcpp::Elf_types
<size
>::Elf_Addr
1071 Output_reloc
<elfcpp::SHT_REL
, dynamic
, size
, big_endian
>::get_address() const
1073 Address address
= this->address_
;
1074 if (this->shndx_
!= INVALID_CODE
)
1076 Output_section
* os
= this->u2_
.relobj
->output_section(this->shndx_
);
1077 gold_assert(os
!= NULL
);
1078 Address off
= this->u2_
.relobj
->get_output_section_offset(this->shndx_
);
1079 if (off
!= invalid_address
)
1080 address
+= os
->address() + off
;
1083 Sized_relobj_file
<size
, big_endian
>* relobj
=
1084 this->u2_
.relobj
->sized_relobj();
1085 gold_assert(relobj
!= NULL
);
1086 address
= os
->output_address(relobj
, this->shndx_
, address
);
1087 gold_assert(address
!= invalid_address
);
1090 else if (this->u2_
.od
!= NULL
)
1091 address
+= this->u2_
.od
->address();
1095 // Write out the offset and info fields of a Rel or Rela relocation
1098 template<bool dynamic
, int size
, bool big_endian
>
1099 template<typename Write_rel
>
1101 Output_reloc
<elfcpp::SHT_REL
, dynamic
, size
, big_endian
>::write_rel(
1102 Write_rel
* wr
) const
1104 wr
->put_r_offset(this->get_address());
1105 unsigned int sym_index
= this->get_symbol_index();
1106 wr
->put_r_info(elfcpp::elf_r_info
<size
>(sym_index
, this->type_
));
1109 // Write out a Rel relocation.
1111 template<bool dynamic
, int size
, bool big_endian
>
1113 Output_reloc
<elfcpp::SHT_REL
, dynamic
, size
, big_endian
>::write(
1114 unsigned char* pov
) const
1116 elfcpp::Rel_write
<size
, big_endian
> orel(pov
);
1117 this->write_rel(&orel
);
1120 // Get the value of the symbol referred to by a Rel relocation.
1122 template<bool dynamic
, int size
, bool big_endian
>
1123 typename
elfcpp::Elf_types
<size
>::Elf_Addr
1124 Output_reloc
<elfcpp::SHT_REL
, dynamic
, size
, big_endian
>::symbol_value(
1125 Addend addend
) const
1127 if (this->local_sym_index_
== GSYM_CODE
)
1129 const Sized_symbol
<size
>* sym
;
1130 sym
= static_cast<const Sized_symbol
<size
>*>(this->u1_
.gsym
);
1131 if (this->use_plt_offset_
&& sym
->has_plt_offset())
1133 uint64_t plt_address
=
1134 parameters
->target().plt_address_for_global(sym
);
1135 return plt_address
+ sym
->plt_offset();
1138 return sym
->value() + addend
;
1140 if (this->local_sym_index_
== SECTION_CODE
)
1142 gold_assert(!this->use_plt_offset_
);
1143 return this->u1_
.os
->address() + addend
;
1145 gold_assert(this->local_sym_index_
!= TARGET_CODE
1146 && this->local_sym_index_
!= INVALID_CODE
1147 && this->local_sym_index_
!= 0
1148 && !this->is_section_symbol_
);
1149 const unsigned int lsi
= this->local_sym_index_
;
1150 Sized_relobj_file
<size
, big_endian
>* relobj
=
1151 this->u1_
.relobj
->sized_relobj();
1152 gold_assert(relobj
!= NULL
);
1153 if (this->use_plt_offset_
)
1155 uint64_t plt_address
=
1156 parameters
->target().plt_address_for_local(relobj
, lsi
);
1157 return plt_address
+ relobj
->local_plt_offset(lsi
);
1159 const Symbol_value
<size
>* symval
= relobj
->local_symbol(lsi
);
1160 return symval
->value(relobj
, addend
);
1163 // Reloc comparison. This function sorts the dynamic relocs for the
1164 // benefit of the dynamic linker. First we sort all relative relocs
1165 // to the front. Among relative relocs, we sort by output address.
1166 // Among non-relative relocs, we sort by symbol index, then by output
1169 template<bool dynamic
, int size
, bool big_endian
>
1171 Output_reloc
<elfcpp::SHT_REL
, dynamic
, size
, big_endian
>::
1172 compare(const Output_reloc
<elfcpp::SHT_REL
, dynamic
, size
, big_endian
>& r2
)
1175 if (this->is_relative_
)
1177 if (!r2
.is_relative_
)
1179 // Otherwise sort by reloc address below.
1181 else if (r2
.is_relative_
)
1185 unsigned int sym1
= this->get_symbol_index();
1186 unsigned int sym2
= r2
.get_symbol_index();
1189 else if (sym1
> sym2
)
1191 // Otherwise sort by reloc address.
1194 section_offset_type addr1
= this->get_address();
1195 section_offset_type addr2
= r2
.get_address();
1198 else if (addr1
> addr2
)
1201 // Final tie breaker, in order to generate the same output on any
1202 // host: reloc type.
1203 unsigned int type1
= this->type_
;
1204 unsigned int type2
= r2
.type_
;
1207 else if (type1
> type2
)
1210 // These relocs appear to be exactly the same.
1214 // Write out a Rela relocation.
1216 template<bool dynamic
, int size
, bool big_endian
>
1218 Output_reloc
<elfcpp::SHT_RELA
, dynamic
, size
, big_endian
>::write(
1219 unsigned char* pov
) const
1221 elfcpp::Rela_write
<size
, big_endian
> orel(pov
);
1222 this->rel_
.write_rel(&orel
);
1223 Addend addend
= this->addend_
;
1224 if (this->rel_
.is_target_specific())
1225 addend
= parameters
->target().reloc_addend(this->rel_
.target_arg(),
1226 this->rel_
.type(), addend
);
1227 else if (this->rel_
.is_symbolless())
1228 addend
= this->rel_
.symbol_value(addend
);
1229 else if (this->rel_
.is_local_section_symbol())
1230 addend
= this->rel_
.local_section_offset(addend
);
1231 orel
.put_r_addend(addend
);
1234 // Output_data_reloc_base methods.
1236 // Adjust the output section.
1238 template<int sh_type
, bool dynamic
, int size
, bool big_endian
>
1240 Output_data_reloc_base
<sh_type
, dynamic
, size
, big_endian
>
1241 ::do_adjust_output_section(Output_section
* os
)
1243 if (sh_type
== elfcpp::SHT_REL
)
1244 os
->set_entsize(elfcpp::Elf_sizes
<size
>::rel_size
);
1245 else if (sh_type
== elfcpp::SHT_RELA
)
1246 os
->set_entsize(elfcpp::Elf_sizes
<size
>::rela_size
);
1250 // A STT_GNU_IFUNC symbol may require a IRELATIVE reloc when doing a
1251 // static link. The backends will generate a dynamic reloc section
1252 // to hold this. In that case we don't want to link to the dynsym
1253 // section, because there isn't one.
1255 os
->set_should_link_to_symtab();
1256 else if (parameters
->doing_static_link())
1259 os
->set_should_link_to_dynsym();
1262 // Write out relocation data.
1264 template<int sh_type
, bool dynamic
, int size
, bool big_endian
>
1266 Output_data_reloc_base
<sh_type
, dynamic
, size
, big_endian
>::do_write(
1269 const off_t off
= this->offset();
1270 const off_t oview_size
= this->data_size();
1271 unsigned char* const oview
= of
->get_output_view(off
, oview_size
);
1273 if (this->sort_relocs())
1275 gold_assert(dynamic
);
1276 std::sort(this->relocs_
.begin(), this->relocs_
.end(),
1277 Sort_relocs_comparison());
1280 unsigned char* pov
= oview
;
1281 for (typename
Relocs::const_iterator p
= this->relocs_
.begin();
1282 p
!= this->relocs_
.end();
1289 gold_assert(pov
- oview
== oview_size
);
1291 of
->write_output_view(off
, oview_size
, oview
);
1293 // We no longer need the relocation entries.
1294 this->relocs_
.clear();
1297 // Class Output_relocatable_relocs.
1299 template<int sh_type
, int size
, bool big_endian
>
1301 Output_relocatable_relocs
<sh_type
, size
, big_endian
>::set_final_data_size()
1303 this->set_data_size(this->rr_
->output_reloc_count()
1304 * Reloc_types
<sh_type
, size
, big_endian
>::reloc_size
);
1307 // class Output_data_group.
1309 template<int size
, bool big_endian
>
1310 Output_data_group
<size
, big_endian
>::Output_data_group(
1311 Sized_relobj_file
<size
, big_endian
>* relobj
,
1312 section_size_type entry_count
,
1313 elfcpp::Elf_Word flags
,
1314 std::vector
<unsigned int>* input_shndxes
)
1315 : Output_section_data(entry_count
* 4, 4, false),
1319 this->input_shndxes_
.swap(*input_shndxes
);
1322 // Write out the section group, which means translating the section
1323 // indexes to apply to the output file.
1325 template<int size
, bool big_endian
>
1327 Output_data_group
<size
, big_endian
>::do_write(Output_file
* of
)
1329 const off_t off
= this->offset();
1330 const section_size_type oview_size
=
1331 convert_to_section_size_type(this->data_size());
1332 unsigned char* const oview
= of
->get_output_view(off
, oview_size
);
1334 elfcpp::Elf_Word
* contents
= reinterpret_cast<elfcpp::Elf_Word
*>(oview
);
1335 elfcpp::Swap
<32, big_endian
>::writeval(contents
, this->flags_
);
1338 for (std::vector
<unsigned int>::const_iterator p
=
1339 this->input_shndxes_
.begin();
1340 p
!= this->input_shndxes_
.end();
1343 Output_section
* os
= this->relobj_
->output_section(*p
);
1345 unsigned int output_shndx
;
1347 output_shndx
= os
->out_shndx();
1350 this->relobj_
->error(_("section group retained but "
1351 "group element discarded"));
1355 elfcpp::Swap
<32, big_endian
>::writeval(contents
, output_shndx
);
1358 size_t wrote
= reinterpret_cast<unsigned char*>(contents
) - oview
;
1359 gold_assert(wrote
== oview_size
);
1361 of
->write_output_view(off
, oview_size
, oview
);
1363 // We no longer need this information.
1364 this->input_shndxes_
.clear();
1367 // Output_data_got::Got_entry methods.
1369 // Write out the entry.
1371 template<int got_size
, bool big_endian
>
1373 Output_data_got
<got_size
, big_endian
>::Got_entry::write(
1374 unsigned int got_indx
,
1375 unsigned char* pov
) const
1379 switch (this->local_sym_index_
)
1383 // If the symbol is resolved locally, we need to write out the
1384 // link-time value, which will be relocated dynamically by a
1385 // RELATIVE relocation.
1386 Symbol
* gsym
= this->u_
.gsym
;
1387 if (this->use_plt_or_tls_offset_
&& gsym
->has_plt_offset())
1388 val
= (parameters
->target().plt_address_for_global(gsym
)
1389 + gsym
->plt_offset());
1392 switch (parameters
->size_and_endianness())
1394 #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG)
1395 case Parameters::TARGET_32_LITTLE
:
1396 case Parameters::TARGET_32_BIG
:
1398 // This cast is ugly. We don't want to put a
1399 // virtual method in Symbol, because we want Symbol
1400 // to be as small as possible.
1401 Sized_symbol
<32>::Value_type v
;
1402 v
= static_cast<Sized_symbol
<32>*>(gsym
)->value();
1403 val
= convert_types
<Valtype
, Sized_symbol
<32>::Value_type
>(v
);
1407 #if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG)
1408 case Parameters::TARGET_64_LITTLE
:
1409 case Parameters::TARGET_64_BIG
:
1411 Sized_symbol
<64>::Value_type v
;
1412 v
= static_cast<Sized_symbol
<64>*>(gsym
)->value();
1413 val
= convert_types
<Valtype
, Sized_symbol
<64>::Value_type
>(v
);
1420 if (this->use_plt_or_tls_offset_
1421 && gsym
->type() == elfcpp::STT_TLS
)
1422 val
+= parameters
->target().tls_offset_for_global(gsym
,
1429 val
= this->u_
.constant
;
1433 // If we're doing an incremental update, don't touch this GOT entry.
1434 if (parameters
->incremental_update())
1436 val
= this->u_
.constant
;
1441 const Relobj
* object
= this->u_
.object
;
1442 const unsigned int lsi
= this->local_sym_index_
;
1443 bool is_tls
= object
->local_is_tls(lsi
);
1444 if (this->use_plt_or_tls_offset_
&& !is_tls
)
1446 uint64_t plt_address
=
1447 parameters
->target().plt_address_for_local(object
, lsi
);
1448 val
= plt_address
+ object
->local_plt_offset(lsi
);
1452 uint64_t lval
= object
->local_symbol_value(lsi
, 0);
1453 val
= convert_types
<Valtype
, uint64_t>(lval
);
1454 if (this->use_plt_or_tls_offset_
&& is_tls
)
1455 val
+= parameters
->target().tls_offset_for_local(object
, lsi
,
1462 elfcpp::Swap
<got_size
, big_endian
>::writeval(pov
, val
);
1465 // Output_data_got methods.
1467 // Add an entry for a global symbol to the GOT. This returns true if
1468 // this is a new GOT entry, false if the symbol already had a GOT
1471 template<int got_size
, bool big_endian
>
1473 Output_data_got
<got_size
, big_endian
>::add_global(
1475 unsigned int got_type
)
1477 if (gsym
->has_got_offset(got_type
))
1480 unsigned int got_offset
= this->add_got_entry(Got_entry(gsym
, false));
1481 gsym
->set_got_offset(got_type
, got_offset
);
1485 // Like add_global, but use the PLT offset.
1487 template<int got_size
, bool big_endian
>
1489 Output_data_got
<got_size
, big_endian
>::add_global_plt(Symbol
* gsym
,
1490 unsigned int got_type
)
1492 if (gsym
->has_got_offset(got_type
))
1495 unsigned int got_offset
= this->add_got_entry(Got_entry(gsym
, true));
1496 gsym
->set_got_offset(got_type
, got_offset
);
1500 // Add an entry for a global symbol to the GOT, and add a dynamic
1501 // relocation of type R_TYPE for the GOT entry.
1503 template<int got_size
, bool big_endian
>
1505 Output_data_got
<got_size
, big_endian
>::add_global_with_rel(
1507 unsigned int got_type
,
1508 Output_data_reloc_generic
* rel_dyn
,
1509 unsigned int r_type
)
1511 if (gsym
->has_got_offset(got_type
))
1514 unsigned int got_offset
= this->add_got_entry(Got_entry());
1515 gsym
->set_got_offset(got_type
, got_offset
);
1516 rel_dyn
->add_global_generic(gsym
, r_type
, this, got_offset
, 0);
1519 // Add a pair of entries for a global symbol to the GOT, and add
1520 // dynamic relocations of type R_TYPE_1 and R_TYPE_2, respectively.
1521 // If R_TYPE_2 == 0, add the second entry with no relocation.
1522 template<int got_size
, bool big_endian
>
1524 Output_data_got
<got_size
, big_endian
>::add_global_pair_with_rel(
1526 unsigned int got_type
,
1527 Output_data_reloc_generic
* rel_dyn
,
1528 unsigned int r_type_1
,
1529 unsigned int r_type_2
)
1531 if (gsym
->has_got_offset(got_type
))
1534 unsigned int got_offset
= this->add_got_entry_pair(Got_entry(), Got_entry());
1535 gsym
->set_got_offset(got_type
, got_offset
);
1536 rel_dyn
->add_global_generic(gsym
, r_type_1
, this, got_offset
, 0);
1539 rel_dyn
->add_global_generic(gsym
, r_type_2
, this,
1540 got_offset
+ got_size
/ 8, 0);
1543 // Add an entry for a local symbol to the GOT. This returns true if
1544 // this is a new GOT entry, false if the symbol already has a GOT
1547 template<int got_size
, bool big_endian
>
1549 Output_data_got
<got_size
, big_endian
>::add_local(
1551 unsigned int symndx
,
1552 unsigned int got_type
)
1554 if (object
->local_has_got_offset(symndx
, got_type
))
1557 unsigned int got_offset
= this->add_got_entry(Got_entry(object
, symndx
,
1559 object
->set_local_got_offset(symndx
, got_type
, got_offset
);
1563 // Like add_local, but use the PLT offset.
1565 template<int got_size
, bool big_endian
>
1567 Output_data_got
<got_size
, big_endian
>::add_local_plt(
1569 unsigned int symndx
,
1570 unsigned int got_type
)
1572 if (object
->local_has_got_offset(symndx
, got_type
))
1575 unsigned int got_offset
= this->add_got_entry(Got_entry(object
, symndx
,
1577 object
->set_local_got_offset(symndx
, got_type
, got_offset
);
1581 // Add an entry for a local symbol to the GOT, and add a dynamic
1582 // relocation of type R_TYPE for the GOT entry.
1584 template<int got_size
, bool big_endian
>
1586 Output_data_got
<got_size
, big_endian
>::add_local_with_rel(
1588 unsigned int symndx
,
1589 unsigned int got_type
,
1590 Output_data_reloc_generic
* rel_dyn
,
1591 unsigned int r_type
)
1593 if (object
->local_has_got_offset(symndx
, got_type
))
1596 unsigned int got_offset
= this->add_got_entry(Got_entry());
1597 object
->set_local_got_offset(symndx
, got_type
, got_offset
);
1598 rel_dyn
->add_local_generic(object
, symndx
, r_type
, this, got_offset
, 0);
1601 // Add a pair of entries for a local symbol to the GOT, and add
1602 // a dynamic relocation of type R_TYPE using the section symbol of
1603 // the output section to which input section SHNDX maps, on the first.
1604 // The first got entry will have a value of zero, the second the
1605 // value of the local symbol.
1606 template<int got_size
, bool big_endian
>
1608 Output_data_got
<got_size
, big_endian
>::add_local_pair_with_rel(
1610 unsigned int symndx
,
1612 unsigned int got_type
,
1613 Output_data_reloc_generic
* rel_dyn
,
1614 unsigned int r_type
)
1616 if (object
->local_has_got_offset(symndx
, got_type
))
1619 unsigned int got_offset
=
1620 this->add_got_entry_pair(Got_entry(),
1621 Got_entry(object
, symndx
, false));
1622 object
->set_local_got_offset(symndx
, got_type
, got_offset
);
1623 Output_section
* os
= object
->output_section(shndx
);
1624 rel_dyn
->add_output_section_generic(os
, r_type
, this, got_offset
, 0);
1627 // Add a pair of entries for a local symbol to the GOT, and add
1628 // a dynamic relocation of type R_TYPE using STN_UNDEF on the first.
1629 // The first got entry will have a value of zero, the second the
1630 // value of the local symbol offset by Target::tls_offset_for_local.
1631 template<int got_size
, bool big_endian
>
1633 Output_data_got
<got_size
, big_endian
>::add_local_tls_pair(
1635 unsigned int symndx
,
1636 unsigned int got_type
,
1637 Output_data_reloc_generic
* rel_dyn
,
1638 unsigned int r_type
)
1640 if (object
->local_has_got_offset(symndx
, got_type
))
1643 unsigned int got_offset
1644 = this->add_got_entry_pair(Got_entry(),
1645 Got_entry(object
, symndx
, true));
1646 object
->set_local_got_offset(symndx
, got_type
, got_offset
);
1647 rel_dyn
->add_local_generic(object
, 0, r_type
, this, got_offset
, 0);
1650 // Reserve a slot in the GOT for a local symbol or the second slot of a pair.
1652 template<int got_size
, bool big_endian
>
1654 Output_data_got
<got_size
, big_endian
>::reserve_local(
1657 unsigned int sym_index
,
1658 unsigned int got_type
)
1660 this->do_reserve_slot(i
);
1661 object
->set_local_got_offset(sym_index
, got_type
, this->got_offset(i
));
1664 // Reserve a slot in the GOT for a global symbol.
1666 template<int got_size
, bool big_endian
>
1668 Output_data_got
<got_size
, big_endian
>::reserve_global(
1671 unsigned int got_type
)
1673 this->do_reserve_slot(i
);
1674 gsym
->set_got_offset(got_type
, this->got_offset(i
));
1677 // Write out the GOT.
1679 template<int got_size
, bool big_endian
>
1681 Output_data_got
<got_size
, big_endian
>::do_write(Output_file
* of
)
1683 const int add
= got_size
/ 8;
1685 const off_t off
= this->offset();
1686 const off_t oview_size
= this->data_size();
1687 unsigned char* const oview
= of
->get_output_view(off
, oview_size
);
1689 unsigned char* pov
= oview
;
1690 for (unsigned int i
= 0; i
< this->entries_
.size(); ++i
)
1692 this->entries_
[i
].write(i
, pov
);
1696 gold_assert(pov
- oview
== oview_size
);
1698 of
->write_output_view(off
, oview_size
, oview
);
1700 // We no longer need the GOT entries.
1701 this->entries_
.clear();
1704 // Create a new GOT entry and return its offset.
1706 template<int got_size
, bool big_endian
>
1708 Output_data_got
<got_size
, big_endian
>::add_got_entry(Got_entry got_entry
)
1710 if (!this->is_data_size_valid())
1712 this->entries_
.push_back(got_entry
);
1713 this->set_got_size();
1714 return this->last_got_offset();
1718 // For an incremental update, find an available slot.
1719 off_t got_offset
= this->free_list_
.allocate(got_size
/ 8,
1721 if (got_offset
== -1)
1722 gold_fallback(_("out of patch space (GOT);"
1723 " relink with --incremental-full"));
1724 unsigned int got_index
= got_offset
/ (got_size
/ 8);
1725 gold_assert(got_index
< this->entries_
.size());
1726 this->entries_
[got_index
] = got_entry
;
1727 return static_cast<unsigned int>(got_offset
);
1731 // Create a pair of new GOT entries and return the offset of the first.
1733 template<int got_size
, bool big_endian
>
1735 Output_data_got
<got_size
, big_endian
>::add_got_entry_pair(
1736 Got_entry got_entry_1
,
1737 Got_entry got_entry_2
)
1739 if (!this->is_data_size_valid())
1741 unsigned int got_offset
;
1742 this->entries_
.push_back(got_entry_1
);
1743 got_offset
= this->last_got_offset();
1744 this->entries_
.push_back(got_entry_2
);
1745 this->set_got_size();
1750 // For an incremental update, find an available pair of slots.
1751 off_t got_offset
= this->free_list_
.allocate(2 * got_size
/ 8,
1753 if (got_offset
== -1)
1754 gold_fallback(_("out of patch space (GOT);"
1755 " relink with --incremental-full"));
1756 unsigned int got_index
= got_offset
/ (got_size
/ 8);
1757 gold_assert(got_index
< this->entries_
.size());
1758 this->entries_
[got_index
] = got_entry_1
;
1759 this->entries_
[got_index
+ 1] = got_entry_2
;
1760 return static_cast<unsigned int>(got_offset
);
1764 // Replace GOT entry I with a new value.
1766 template<int got_size
, bool big_endian
>
1768 Output_data_got
<got_size
, big_endian
>::replace_got_entry(
1770 Got_entry got_entry
)
1772 gold_assert(i
< this->entries_
.size());
1773 this->entries_
[i
] = got_entry
;
1776 // Output_data_dynamic::Dynamic_entry methods.
1778 // Write out the entry.
1780 template<int size
, bool big_endian
>
1782 Output_data_dynamic::Dynamic_entry::write(
1784 const Stringpool
* pool
) const
1786 typename
elfcpp::Elf_types
<size
>::Elf_WXword val
;
1787 switch (this->offset_
)
1789 case DYNAMIC_NUMBER
:
1793 case DYNAMIC_SECTION_SIZE
:
1794 val
= this->u_
.od
->data_size();
1795 if (this->od2
!= NULL
)
1796 val
+= this->od2
->data_size();
1799 case DYNAMIC_SYMBOL
:
1801 const Sized_symbol
<size
>* s
=
1802 static_cast<const Sized_symbol
<size
>*>(this->u_
.sym
);
1807 case DYNAMIC_STRING
:
1808 val
= pool
->get_offset(this->u_
.str
);
1812 val
= this->u_
.od
->address() + this->offset_
;
1816 elfcpp::Dyn_write
<size
, big_endian
> dw(pov
);
1817 dw
.put_d_tag(this->tag_
);
1821 // Output_data_dynamic methods.
1823 // Adjust the output section to set the entry size.
1826 Output_data_dynamic::do_adjust_output_section(Output_section
* os
)
1828 if (parameters
->target().get_size() == 32)
1829 os
->set_entsize(elfcpp::Elf_sizes
<32>::dyn_size
);
1830 else if (parameters
->target().get_size() == 64)
1831 os
->set_entsize(elfcpp::Elf_sizes
<64>::dyn_size
);
1836 // Set the final data size.
1839 Output_data_dynamic::set_final_data_size()
1841 // Add the terminating entry if it hasn't been added.
1842 // Because of relaxation, we can run this multiple times.
1843 if (this->entries_
.empty() || this->entries_
.back().tag() != elfcpp::DT_NULL
)
1845 int extra
= parameters
->options().spare_dynamic_tags();
1846 for (int i
= 0; i
< extra
; ++i
)
1847 this->add_constant(elfcpp::DT_NULL
, 0);
1848 this->add_constant(elfcpp::DT_NULL
, 0);
1852 if (parameters
->target().get_size() == 32)
1853 dyn_size
= elfcpp::Elf_sizes
<32>::dyn_size
;
1854 else if (parameters
->target().get_size() == 64)
1855 dyn_size
= elfcpp::Elf_sizes
<64>::dyn_size
;
1858 this->set_data_size(this->entries_
.size() * dyn_size
);
1861 // Write out the dynamic entries.
1864 Output_data_dynamic::do_write(Output_file
* of
)
1866 switch (parameters
->size_and_endianness())
1868 #ifdef HAVE_TARGET_32_LITTLE
1869 case Parameters::TARGET_32_LITTLE
:
1870 this->sized_write
<32, false>(of
);
1873 #ifdef HAVE_TARGET_32_BIG
1874 case Parameters::TARGET_32_BIG
:
1875 this->sized_write
<32, true>(of
);
1878 #ifdef HAVE_TARGET_64_LITTLE
1879 case Parameters::TARGET_64_LITTLE
:
1880 this->sized_write
<64, false>(of
);
1883 #ifdef HAVE_TARGET_64_BIG
1884 case Parameters::TARGET_64_BIG
:
1885 this->sized_write
<64, true>(of
);
1893 template<int size
, bool big_endian
>
1895 Output_data_dynamic::sized_write(Output_file
* of
)
1897 const int dyn_size
= elfcpp::Elf_sizes
<size
>::dyn_size
;
1899 const off_t offset
= this->offset();
1900 const off_t oview_size
= this->data_size();
1901 unsigned char* const oview
= of
->get_output_view(offset
, oview_size
);
1903 unsigned char* pov
= oview
;
1904 for (typename
Dynamic_entries::const_iterator p
= this->entries_
.begin();
1905 p
!= this->entries_
.end();
1908 p
->write
<size
, big_endian
>(pov
, this->pool_
);
1912 gold_assert(pov
- oview
== oview_size
);
1914 of
->write_output_view(offset
, oview_size
, oview
);
1916 // We no longer need the dynamic entries.
1917 this->entries_
.clear();
1920 // Class Output_symtab_xindex.
1923 Output_symtab_xindex::do_write(Output_file
* of
)
1925 const off_t offset
= this->offset();
1926 const off_t oview_size
= this->data_size();
1927 unsigned char* const oview
= of
->get_output_view(offset
, oview_size
);
1929 memset(oview
, 0, oview_size
);
1931 if (parameters
->target().is_big_endian())
1932 this->endian_do_write
<true>(oview
);
1934 this->endian_do_write
<false>(oview
);
1936 of
->write_output_view(offset
, oview_size
, oview
);
1938 // We no longer need the data.
1939 this->entries_
.clear();
1942 template<bool big_endian
>
1944 Output_symtab_xindex::endian_do_write(unsigned char* const oview
)
1946 for (Xindex_entries::const_iterator p
= this->entries_
.begin();
1947 p
!= this->entries_
.end();
1950 unsigned int symndx
= p
->first
;
1951 gold_assert(symndx
* 4 < this->data_size());
1952 elfcpp::Swap
<32, big_endian
>::writeval(oview
+ symndx
* 4, p
->second
);
1956 // Output_fill_debug_info methods.
1958 // Return the minimum size needed for a dummy compilation unit header.
1961 Output_fill_debug_info::do_minimum_hole_size() const
1963 // Compile unit header fields: unit_length, version, debug_abbrev_offset,
1965 const size_t len
= 4 + 2 + 4 + 1;
1966 // For type units, add type_signature, type_offset.
1967 if (this->is_debug_types_
)
1972 // Write a dummy compilation unit header to fill a hole in the
1973 // .debug_info or .debug_types section.
1976 Output_fill_debug_info::do_write(Output_file
* of
, off_t off
, size_t len
) const
1978 gold_debug(DEBUG_INCREMENTAL
, "fill_debug_info(%08lx, %08lx)",
1979 static_cast<long>(off
), static_cast<long>(len
));
1981 gold_assert(len
>= this->do_minimum_hole_size());
1983 unsigned char* const oview
= of
->get_output_view(off
, len
);
1984 unsigned char* pov
= oview
;
1986 // Write header fields: unit_length, version, debug_abbrev_offset,
1988 if (this->is_big_endian())
1990 elfcpp::Swap_unaligned
<32, true>::writeval(pov
, len
- 4);
1991 elfcpp::Swap_unaligned
<16, true>::writeval(pov
+ 4, this->version
);
1992 elfcpp::Swap_unaligned
<32, true>::writeval(pov
+ 6, 0);
1996 elfcpp::Swap_unaligned
<32, false>::writeval(pov
, len
- 4);
1997 elfcpp::Swap_unaligned
<16, false>::writeval(pov
+ 4, this->version
);
1998 elfcpp::Swap_unaligned
<32, false>::writeval(pov
+ 6, 0);
2003 // For type units, the additional header fields -- type_signature,
2004 // type_offset -- can be filled with zeroes.
2006 // Fill the remainder of the free space with zeroes. The first
2007 // zero should tell the consumer there are no DIEs to read in this
2008 // compilation unit.
2009 if (pov
< oview
+ len
)
2010 memset(pov
, 0, oview
+ len
- pov
);
2012 of
->write_output_view(off
, len
, oview
);
2015 // Output_fill_debug_line methods.
2017 // Return the minimum size needed for a dummy line number program header.
2020 Output_fill_debug_line::do_minimum_hole_size() const
2022 // Line number program header fields: unit_length, version, header_length,
2023 // minimum_instruction_length, default_is_stmt, line_base, line_range,
2024 // opcode_base, standard_opcode_lengths[], include_directories, filenames.
2025 const size_t len
= 4 + 2 + 4 + this->header_length
;
2029 // Write a dummy line number program header to fill a hole in the
2030 // .debug_line section.
2033 Output_fill_debug_line::do_write(Output_file
* of
, off_t off
, size_t len
) const
2035 gold_debug(DEBUG_INCREMENTAL
, "fill_debug_line(%08lx, %08lx)",
2036 static_cast<long>(off
), static_cast<long>(len
));
2038 gold_assert(len
>= this->do_minimum_hole_size());
2040 unsigned char* const oview
= of
->get_output_view(off
, len
);
2041 unsigned char* pov
= oview
;
2043 // Write header fields: unit_length, version, header_length,
2044 // minimum_instruction_length, default_is_stmt, line_base, line_range,
2045 // opcode_base, standard_opcode_lengths[], include_directories, filenames.
2046 // We set the header_length field to cover the entire hole, so the
2047 // line number program is empty.
2048 if (this->is_big_endian())
2050 elfcpp::Swap_unaligned
<32, true>::writeval(pov
, len
- 4);
2051 elfcpp::Swap_unaligned
<16, true>::writeval(pov
+ 4, this->version
);
2052 elfcpp::Swap_unaligned
<32, true>::writeval(pov
+ 6, len
- (4 + 2 + 4));
2056 elfcpp::Swap_unaligned
<32, false>::writeval(pov
, len
- 4);
2057 elfcpp::Swap_unaligned
<16, false>::writeval(pov
+ 4, this->version
);
2058 elfcpp::Swap_unaligned
<32, false>::writeval(pov
+ 6, len
- (4 + 2 + 4));
2061 *pov
++ = 1; // minimum_instruction_length
2062 *pov
++ = 0; // default_is_stmt
2063 *pov
++ = 0; // line_base
2064 *pov
++ = 5; // line_range
2065 *pov
++ = 13; // opcode_base
2066 *pov
++ = 0; // standard_opcode_lengths[1]
2067 *pov
++ = 1; // standard_opcode_lengths[2]
2068 *pov
++ = 1; // standard_opcode_lengths[3]
2069 *pov
++ = 1; // standard_opcode_lengths[4]
2070 *pov
++ = 1; // standard_opcode_lengths[5]
2071 *pov
++ = 0; // standard_opcode_lengths[6]
2072 *pov
++ = 0; // standard_opcode_lengths[7]
2073 *pov
++ = 0; // standard_opcode_lengths[8]
2074 *pov
++ = 1; // standard_opcode_lengths[9]
2075 *pov
++ = 0; // standard_opcode_lengths[10]
2076 *pov
++ = 0; // standard_opcode_lengths[11]
2077 *pov
++ = 1; // standard_opcode_lengths[12]
2078 *pov
++ = 0; // include_directories (empty)
2079 *pov
++ = 0; // filenames (empty)
2081 // Some consumers don't check the header_length field, and simply
2082 // start reading the line number program immediately following the
2083 // header. For those consumers, we fill the remainder of the free
2084 // space with DW_LNS_set_basic_block opcodes. These are effectively
2085 // no-ops: the resulting line table program will not create any rows.
2086 if (pov
< oview
+ len
)
2087 memset(pov
, elfcpp::DW_LNS_set_basic_block
, oview
+ len
- pov
);
2089 of
->write_output_view(off
, len
, oview
);
2092 // Output_section::Input_section methods.
2094 // Return the current data size. For an input section we store the size here.
2095 // For an Output_section_data, we have to ask it for the size.
2098 Output_section::Input_section::current_data_size() const
2100 if (this->is_input_section())
2101 return this->u1_
.data_size
;
2104 this->u2_
.posd
->pre_finalize_data_size();
2105 return this->u2_
.posd
->current_data_size();
2109 // Return the data size. For an input section we store the size here.
2110 // For an Output_section_data, we have to ask it for the size.
2113 Output_section::Input_section::data_size() const
2115 if (this->is_input_section())
2116 return this->u1_
.data_size
;
2118 return this->u2_
.posd
->data_size();
2121 // Return the object for an input section.
2124 Output_section::Input_section::relobj() const
2126 if (this->is_input_section())
2127 return this->u2_
.object
;
2128 else if (this->is_merge_section())
2130 gold_assert(this->u2_
.pomb
->first_relobj() != NULL
);
2131 return this->u2_
.pomb
->first_relobj();
2133 else if (this->is_relaxed_input_section())
2134 return this->u2_
.poris
->relobj();
2139 // Return the input section index for an input section.
2142 Output_section::Input_section::shndx() const
2144 if (this->is_input_section())
2145 return this->shndx_
;
2146 else if (this->is_merge_section())
2148 gold_assert(this->u2_
.pomb
->first_relobj() != NULL
);
2149 return this->u2_
.pomb
->first_shndx();
2151 else if (this->is_relaxed_input_section())
2152 return this->u2_
.poris
->shndx();
2157 // Set the address and file offset.
2160 Output_section::Input_section::set_address_and_file_offset(
2163 off_t section_file_offset
)
2165 if (this->is_input_section())
2166 this->u2_
.object
->set_section_offset(this->shndx_
,
2167 file_offset
- section_file_offset
);
2169 this->u2_
.posd
->set_address_and_file_offset(address
, file_offset
);
2172 // Reset the address and file offset.
2175 Output_section::Input_section::reset_address_and_file_offset()
2177 if (!this->is_input_section())
2178 this->u2_
.posd
->reset_address_and_file_offset();
2181 // Finalize the data size.
2184 Output_section::Input_section::finalize_data_size()
2186 if (!this->is_input_section())
2187 this->u2_
.posd
->finalize_data_size();
2190 // Try to turn an input offset into an output offset. We want to
2191 // return the output offset relative to the start of this
2192 // Input_section in the output section.
2195 Output_section::Input_section::output_offset(
2196 const Relobj
* object
,
2198 section_offset_type offset
,
2199 section_offset_type
* poutput
) const
2201 if (!this->is_input_section())
2202 return this->u2_
.posd
->output_offset(object
, shndx
, offset
, poutput
);
2205 if (this->shndx_
!= shndx
|| this->u2_
.object
!= object
)
2212 // Return whether this is the merge section for the input section
2216 Output_section::Input_section::is_merge_section_for(const Relobj
* object
,
2217 unsigned int shndx
) const
2219 if (this->is_input_section())
2221 return this->u2_
.posd
->is_merge_section_for(object
, shndx
);
2224 // Write out the data. We don't have to do anything for an input
2225 // section--they are handled via Object::relocate--but this is where
2226 // we write out the data for an Output_section_data.
2229 Output_section::Input_section::write(Output_file
* of
)
2231 if (!this->is_input_section())
2232 this->u2_
.posd
->write(of
);
2235 // Write the data to a buffer. As for write(), we don't have to do
2236 // anything for an input section.
2239 Output_section::Input_section::write_to_buffer(unsigned char* buffer
)
2241 if (!this->is_input_section())
2242 this->u2_
.posd
->write_to_buffer(buffer
);
2245 // Print to a map file.
2248 Output_section::Input_section::print_to_mapfile(Mapfile
* mapfile
) const
2250 switch (this->shndx_
)
2252 case OUTPUT_SECTION_CODE
:
2253 case MERGE_DATA_SECTION_CODE
:
2254 case MERGE_STRING_SECTION_CODE
:
2255 this->u2_
.posd
->print_to_mapfile(mapfile
);
2258 case RELAXED_INPUT_SECTION_CODE
:
2260 Output_relaxed_input_section
* relaxed_section
=
2261 this->relaxed_input_section();
2262 mapfile
->print_input_section(relaxed_section
->relobj(),
2263 relaxed_section
->shndx());
2267 mapfile
->print_input_section(this->u2_
.object
, this->shndx_
);
2272 // Output_section methods.
2274 // Construct an Output_section. NAME will point into a Stringpool.
2276 Output_section::Output_section(const char* name
, elfcpp::Elf_Word type
,
2277 elfcpp::Elf_Xword flags
)
2282 link_section_(NULL
),
2284 info_section_(NULL
),
2289 order_(ORDER_INVALID
),
2294 first_input_offset_(0),
2296 postprocessing_buffer_(NULL
),
2297 needs_symtab_index_(false),
2298 needs_dynsym_index_(false),
2299 should_link_to_symtab_(false),
2300 should_link_to_dynsym_(false),
2301 after_input_sections_(false),
2302 requires_postprocessing_(false),
2303 found_in_sections_clause_(false),
2304 has_load_address_(false),
2305 info_uses_section_index_(false),
2306 input_section_order_specified_(false),
2307 may_sort_attached_input_sections_(false),
2308 must_sort_attached_input_sections_(false),
2309 attached_input_sections_are_sorted_(false),
2311 is_small_section_(false),
2312 is_large_section_(false),
2313 generate_code_fills_at_write_(false),
2314 is_entsize_zero_(false),
2315 section_offsets_need_adjustment_(false),
2317 always_keeps_input_sections_(false),
2318 has_fixed_layout_(false),
2319 is_patch_space_allowed_(false),
2320 is_unique_segment_(false),
2322 extra_segment_flags_(0),
2323 segment_alignment_(0),
2325 lookup_maps_(new Output_section_lookup_maps
),
2327 free_space_fill_(NULL
),
2330 // An unallocated section has no address. Forcing this means that
2331 // we don't need special treatment for symbols defined in debug
2333 if ((flags
& elfcpp::SHF_ALLOC
) == 0)
2334 this->set_address(0);
2337 Output_section::~Output_section()
2339 delete this->checkpoint_
;
2342 // Set the entry size.
2345 Output_section::set_entsize(uint64_t v
)
2347 if (this->is_entsize_zero_
)
2349 else if (this->entsize_
== 0)
2351 else if (this->entsize_
!= v
)
2354 this->is_entsize_zero_
= 1;
2358 // Add the input section SHNDX, with header SHDR, named SECNAME, in
2359 // OBJECT, to the Output_section. RELOC_SHNDX is the index of a
2360 // relocation section which applies to this section, or 0 if none, or
2361 // -1U if more than one. Return the offset of the input section
2362 // within the output section. Return -1 if the input section will
2363 // receive special handling. In the normal case we don't always keep
2364 // track of input sections for an Output_section. Instead, each
2365 // Object keeps track of the Output_section for each of its input
2366 // sections. However, if HAVE_SECTIONS_SCRIPT is true, we do keep
2367 // track of input sections here; this is used when SECTIONS appears in
2370 template<int size
, bool big_endian
>
2372 Output_section::add_input_section(Layout
* layout
,
2373 Sized_relobj_file
<size
, big_endian
>* object
,
2375 const char* secname
,
2376 const elfcpp::Shdr
<size
, big_endian
>& shdr
,
2377 unsigned int reloc_shndx
,
2378 bool have_sections_script
)
2380 elfcpp::Elf_Xword addralign
= shdr
.get_sh_addralign();
2381 if ((addralign
& (addralign
- 1)) != 0)
2383 object
->error(_("invalid alignment %lu for section \"%s\""),
2384 static_cast<unsigned long>(addralign
), secname
);
2388 if (addralign
> this->addralign_
)
2389 this->addralign_
= addralign
;
2391 typename
elfcpp::Elf_types
<size
>::Elf_WXword sh_flags
= shdr
.get_sh_flags();
2392 uint64_t entsize
= shdr
.get_sh_entsize();
2394 // .debug_str is a mergeable string section, but is not always so
2395 // marked by compilers. Mark manually here so we can optimize.
2396 if (strcmp(secname
, ".debug_str") == 0)
2398 sh_flags
|= (elfcpp::SHF_MERGE
| elfcpp::SHF_STRINGS
);
2402 this->update_flags_for_input_section(sh_flags
);
2403 this->set_entsize(entsize
);
2405 // If this is a SHF_MERGE section, we pass all the input sections to
2406 // a Output_data_merge. We don't try to handle relocations for such
2407 // a section. We don't try to handle empty merge sections--they
2408 // mess up the mappings, and are useless anyhow.
2409 // FIXME: Need to handle merge sections during incremental update.
2410 if ((sh_flags
& elfcpp::SHF_MERGE
) != 0
2412 && shdr
.get_sh_size() > 0
2413 && !parameters
->incremental())
2415 // Keep information about merged input sections for rebuilding fast
2416 // lookup maps if we have sections-script or we do relaxation.
2417 bool keeps_input_sections
= (this->always_keeps_input_sections_
2418 || have_sections_script
2419 || parameters
->target().may_relax());
2421 if (this->add_merge_input_section(object
, shndx
, sh_flags
, entsize
,
2422 addralign
, keeps_input_sections
))
2424 // Tell the relocation routines that they need to call the
2425 // output_offset method to determine the final address.
2430 section_size_type input_section_size
= shdr
.get_sh_size();
2431 section_size_type uncompressed_size
;
2432 if (object
->section_is_compressed(shndx
, &uncompressed_size
))
2433 input_section_size
= uncompressed_size
;
2435 off_t offset_in_section
;
2436 off_t aligned_offset_in_section
;
2437 if (this->has_fixed_layout())
2439 // For incremental updates, find a chunk of unused space in the section.
2440 offset_in_section
= this->free_list_
.allocate(input_section_size
,
2442 if (offset_in_section
== -1)
2443 gold_fallback(_("out of patch space in section %s; "
2444 "relink with --incremental-full"),
2446 aligned_offset_in_section
= offset_in_section
;
2450 offset_in_section
= this->current_data_size_for_child();
2451 aligned_offset_in_section
= align_address(offset_in_section
,
2453 this->set_current_data_size_for_child(aligned_offset_in_section
2454 + input_section_size
);
2457 // Determine if we want to delay code-fill generation until the output
2458 // section is written. When the target is relaxing, we want to delay fill
2459 // generating to avoid adjusting them during relaxation. Also, if we are
2460 // sorting input sections we must delay fill generation.
2461 if (!this->generate_code_fills_at_write_
2462 && !have_sections_script
2463 && (sh_flags
& elfcpp::SHF_EXECINSTR
) != 0
2464 && parameters
->target().has_code_fill()
2465 && (parameters
->target().may_relax()
2466 || layout
->is_section_ordering_specified()))
2468 gold_assert(this->fills_
.empty());
2469 this->generate_code_fills_at_write_
= true;
2472 if (aligned_offset_in_section
> offset_in_section
2473 && !this->generate_code_fills_at_write_
2474 && !have_sections_script
2475 && (sh_flags
& elfcpp::SHF_EXECINSTR
) != 0
2476 && parameters
->target().has_code_fill())
2478 // We need to add some fill data. Using fill_list_ when
2479 // possible is an optimization, since we will often have fill
2480 // sections without input sections.
2481 off_t fill_len
= aligned_offset_in_section
- offset_in_section
;
2482 if (this->input_sections_
.empty())
2483 this->fills_
.push_back(Fill(offset_in_section
, fill_len
));
2486 std::string
fill_data(parameters
->target().code_fill(fill_len
));
2487 Output_data_const
* odc
= new Output_data_const(fill_data
, 1);
2488 this->input_sections_
.push_back(Input_section(odc
));
2492 // We need to keep track of this section if we are already keeping
2493 // track of sections, or if we are relaxing. Also, if this is a
2494 // section which requires sorting, or which may require sorting in
2495 // the future, we keep track of the sections. If the
2496 // --section-ordering-file option is used to specify the order of
2497 // sections, we need to keep track of sections.
2498 if (this->always_keeps_input_sections_
2499 || have_sections_script
2500 || !this->input_sections_
.empty()
2501 || this->may_sort_attached_input_sections()
2502 || this->must_sort_attached_input_sections()
2503 || parameters
->options().user_set_Map()
2504 || parameters
->target().may_relax()
2505 || layout
->is_section_ordering_specified())
2507 Input_section
isecn(object
, shndx
, input_section_size
, addralign
);
2508 /* If section ordering is requested by specifying a ordering file,
2509 using --section-ordering-file, match the section name with
2511 if (parameters
->options().section_ordering_file())
2513 unsigned int section_order_index
=
2514 layout
->find_section_order_index(std::string(secname
));
2515 if (section_order_index
!= 0)
2517 isecn
.set_section_order_index(section_order_index
);
2518 this->set_input_section_order_specified();
2521 if (this->has_fixed_layout())
2523 // For incremental updates, finalize the address and offset now.
2524 uint64_t addr
= this->address();
2525 isecn
.set_address_and_file_offset(addr
+ aligned_offset_in_section
,
2526 aligned_offset_in_section
,
2529 this->input_sections_
.push_back(isecn
);
2532 return aligned_offset_in_section
;
2535 // Add arbitrary data to an output section.
2538 Output_section::add_output_section_data(Output_section_data
* posd
)
2540 Input_section
inp(posd
);
2541 this->add_output_section_data(&inp
);
2543 if (posd
->is_data_size_valid())
2545 off_t offset_in_section
;
2546 if (this->has_fixed_layout())
2548 // For incremental updates, find a chunk of unused space.
2549 offset_in_section
= this->free_list_
.allocate(posd
->data_size(),
2550 posd
->addralign(), 0);
2551 if (offset_in_section
== -1)
2552 gold_fallback(_("out of patch space in section %s; "
2553 "relink with --incremental-full"),
2555 // Finalize the address and offset now.
2556 uint64_t addr
= this->address();
2557 off_t offset
= this->offset();
2558 posd
->set_address_and_file_offset(addr
+ offset_in_section
,
2559 offset
+ offset_in_section
);
2563 offset_in_section
= this->current_data_size_for_child();
2564 off_t aligned_offset_in_section
= align_address(offset_in_section
,
2566 this->set_current_data_size_for_child(aligned_offset_in_section
2567 + posd
->data_size());
2570 else if (this->has_fixed_layout())
2572 // For incremental updates, arrange for the data to have a fixed layout.
2573 // This will mean that additions to the data must be allocated from
2574 // free space within the containing output section.
2575 uint64_t addr
= this->address();
2576 posd
->set_address(addr
);
2577 posd
->set_file_offset(0);
2578 // FIXME: This should eventually be unreachable.
2579 // gold_unreachable();
2583 // Add a relaxed input section.
2586 Output_section::add_relaxed_input_section(Layout
* layout
,
2587 Output_relaxed_input_section
* poris
,
2588 const std::string
& name
)
2590 Input_section
inp(poris
);
2592 // If the --section-ordering-file option is used to specify the order of
2593 // sections, we need to keep track of sections.
2594 if (layout
->is_section_ordering_specified())
2596 unsigned int section_order_index
=
2597 layout
->find_section_order_index(name
);
2598 if (section_order_index
!= 0)
2600 inp
.set_section_order_index(section_order_index
);
2601 this->set_input_section_order_specified();
2605 this->add_output_section_data(&inp
);
2606 if (this->lookup_maps_
->is_valid())
2607 this->lookup_maps_
->add_relaxed_input_section(poris
->relobj(),
2608 poris
->shndx(), poris
);
2610 // For a relaxed section, we use the current data size. Linker scripts
2611 // get all the input sections, including relaxed one from an output
2612 // section and add them back to them same output section to compute the
2613 // output section size. If we do not account for sizes of relaxed input
2614 // sections, an output section would be incorrectly sized.
2615 off_t offset_in_section
= this->current_data_size_for_child();
2616 off_t aligned_offset_in_section
= align_address(offset_in_section
,
2617 poris
->addralign());
2618 this->set_current_data_size_for_child(aligned_offset_in_section
2619 + poris
->current_data_size());
2622 // Add arbitrary data to an output section by Input_section.
2625 Output_section::add_output_section_data(Input_section
* inp
)
2627 if (this->input_sections_
.empty())
2628 this->first_input_offset_
= this->current_data_size_for_child();
2630 this->input_sections_
.push_back(*inp
);
2632 uint64_t addralign
= inp
->addralign();
2633 if (addralign
> this->addralign_
)
2634 this->addralign_
= addralign
;
2636 inp
->set_output_section(this);
2639 // Add a merge section to an output section.
2642 Output_section::add_output_merge_section(Output_section_data
* posd
,
2643 bool is_string
, uint64_t entsize
)
2645 Input_section
inp(posd
, is_string
, entsize
);
2646 this->add_output_section_data(&inp
);
2649 // Add an input section to a SHF_MERGE section.
2652 Output_section::add_merge_input_section(Relobj
* object
, unsigned int shndx
,
2653 uint64_t flags
, uint64_t entsize
,
2655 bool keeps_input_sections
)
2657 bool is_string
= (flags
& elfcpp::SHF_STRINGS
) != 0;
2659 // We only merge strings if the alignment is not more than the
2660 // character size. This could be handled, but it's unusual.
2661 if (is_string
&& addralign
> entsize
)
2664 // We cannot restore merged input section states.
2665 gold_assert(this->checkpoint_
== NULL
);
2667 // Look up merge sections by required properties.
2668 // Currently, we only invalidate the lookup maps in script processing
2669 // and relaxation. We should not have done either when we reach here.
2670 // So we assume that the lookup maps are valid to simply code.
2671 gold_assert(this->lookup_maps_
->is_valid());
2672 Merge_section_properties
msp(is_string
, entsize
, addralign
);
2673 Output_merge_base
* pomb
= this->lookup_maps_
->find_merge_section(msp
);
2674 bool is_new
= false;
2677 gold_assert(pomb
->is_string() == is_string
2678 && pomb
->entsize() == entsize
2679 && pomb
->addralign() == addralign
);
2683 // Create a new Output_merge_data or Output_merge_string_data.
2685 pomb
= new Output_merge_data(entsize
, addralign
);
2691 pomb
= new Output_merge_string
<char>(addralign
);
2694 pomb
= new Output_merge_string
<uint16_t>(addralign
);
2697 pomb
= new Output_merge_string
<uint32_t>(addralign
);
2703 // If we need to do script processing or relaxation, we need to keep
2704 // the original input sections to rebuild the fast lookup maps.
2705 if (keeps_input_sections
)
2706 pomb
->set_keeps_input_sections();
2710 if (pomb
->add_input_section(object
, shndx
))
2712 // Add new merge section to this output section and link merge
2713 // section properties to new merge section in map.
2716 this->add_output_merge_section(pomb
, is_string
, entsize
);
2717 this->lookup_maps_
->add_merge_section(msp
, pomb
);
2720 // Add input section to new merge section and link input section to new
2721 // merge section in map.
2722 this->lookup_maps_
->add_merge_input_section(object
, shndx
, pomb
);
2727 // If add_input_section failed, delete new merge section to avoid
2728 // exporting empty merge sections in Output_section::get_input_section.
2735 // Build a relaxation map to speed up relaxation of existing input sections.
2736 // Look up to the first LIMIT elements in INPUT_SECTIONS.
2739 Output_section::build_relaxation_map(
2740 const Input_section_list
& input_sections
,
2742 Relaxation_map
* relaxation_map
) const
2744 for (size_t i
= 0; i
< limit
; ++i
)
2746 const Input_section
& is(input_sections
[i
]);
2747 if (is
.is_input_section() || is
.is_relaxed_input_section())
2749 Section_id
sid(is
.relobj(), is
.shndx());
2750 (*relaxation_map
)[sid
] = i
;
2755 // Convert regular input sections in INPUT_SECTIONS into relaxed input
2756 // sections in RELAXED_SECTIONS. MAP is a prebuilt map from section id
2757 // indices of INPUT_SECTIONS.
2760 Output_section::convert_input_sections_in_list_to_relaxed_sections(
2761 const std::vector
<Output_relaxed_input_section
*>& relaxed_sections
,
2762 const Relaxation_map
& map
,
2763 Input_section_list
* input_sections
)
2765 for (size_t i
= 0; i
< relaxed_sections
.size(); ++i
)
2767 Output_relaxed_input_section
* poris
= relaxed_sections
[i
];
2768 Section_id
sid(poris
->relobj(), poris
->shndx());
2769 Relaxation_map::const_iterator p
= map
.find(sid
);
2770 gold_assert(p
!= map
.end());
2771 gold_assert((*input_sections
)[p
->second
].is_input_section());
2773 // Remember section order index of original input section
2774 // if it is set. Copy it to the relaxed input section.
2776 (*input_sections
)[p
->second
].section_order_index();
2777 (*input_sections
)[p
->second
] = Input_section(poris
);
2778 (*input_sections
)[p
->second
].set_section_order_index(soi
);
2782 // Convert regular input sections into relaxed input sections. RELAXED_SECTIONS
2783 // is a vector of pointers to Output_relaxed_input_section or its derived
2784 // classes. The relaxed sections must correspond to existing input sections.
2787 Output_section::convert_input_sections_to_relaxed_sections(
2788 const std::vector
<Output_relaxed_input_section
*>& relaxed_sections
)
2790 gold_assert(parameters
->target().may_relax());
2792 // We want to make sure that restore_states does not undo the effect of
2793 // this. If there is no checkpoint active, just search the current
2794 // input section list and replace the sections there. If there is
2795 // a checkpoint, also replace the sections there.
2797 // By default, we look at the whole list.
2798 size_t limit
= this->input_sections_
.size();
2800 if (this->checkpoint_
!= NULL
)
2802 // Replace input sections with relaxed input section in the saved
2803 // copy of the input section list.
2804 if (this->checkpoint_
->input_sections_saved())
2807 this->build_relaxation_map(
2808 *(this->checkpoint_
->input_sections()),
2809 this->checkpoint_
->input_sections()->size(),
2811 this->convert_input_sections_in_list_to_relaxed_sections(
2814 this->checkpoint_
->input_sections());
2818 // We have not copied the input section list yet. Instead, just
2819 // look at the portion that would be saved.
2820 limit
= this->checkpoint_
->input_sections_size();
2824 // Convert input sections in input_section_list.
2826 this->build_relaxation_map(this->input_sections_
, limit
, &map
);
2827 this->convert_input_sections_in_list_to_relaxed_sections(
2830 &this->input_sections_
);
2832 // Update fast look-up map.
2833 if (this->lookup_maps_
->is_valid())
2834 for (size_t i
= 0; i
< relaxed_sections
.size(); ++i
)
2836 Output_relaxed_input_section
* poris
= relaxed_sections
[i
];
2837 this->lookup_maps_
->add_relaxed_input_section(poris
->relobj(),
2838 poris
->shndx(), poris
);
2842 // Update the output section flags based on input section flags.
2845 Output_section::update_flags_for_input_section(elfcpp::Elf_Xword flags
)
2847 // If we created the section with SHF_ALLOC clear, we set the
2848 // address. If we are now setting the SHF_ALLOC flag, we need to
2850 if ((this->flags_
& elfcpp::SHF_ALLOC
) == 0
2851 && (flags
& elfcpp::SHF_ALLOC
) != 0)
2852 this->mark_address_invalid();
2854 this->flags_
|= (flags
2855 & (elfcpp::SHF_WRITE
2857 | elfcpp::SHF_EXECINSTR
));
2859 if ((flags
& elfcpp::SHF_MERGE
) == 0)
2860 this->flags_
&=~ elfcpp::SHF_MERGE
;
2863 if (this->current_data_size_for_child() == 0)
2864 this->flags_
|= elfcpp::SHF_MERGE
;
2867 if ((flags
& elfcpp::SHF_STRINGS
) == 0)
2868 this->flags_
&=~ elfcpp::SHF_STRINGS
;
2871 if (this->current_data_size_for_child() == 0)
2872 this->flags_
|= elfcpp::SHF_STRINGS
;
2876 // Find the merge section into which an input section with index SHNDX in
2877 // OBJECT has been added. Return NULL if none found.
2879 Output_section_data
*
2880 Output_section::find_merge_section(const Relobj
* object
,
2881 unsigned int shndx
) const
2883 if (!this->lookup_maps_
->is_valid())
2884 this->build_lookup_maps();
2885 return this->lookup_maps_
->find_merge_section(object
, shndx
);
2888 // Build the lookup maps for merge and relaxed sections. This is needs
2889 // to be declared as a const methods so that it is callable with a const
2890 // Output_section pointer. The method only updates states of the maps.
2893 Output_section::build_lookup_maps() const
2895 this->lookup_maps_
->clear();
2896 for (Input_section_list::const_iterator p
= this->input_sections_
.begin();
2897 p
!= this->input_sections_
.end();
2900 if (p
->is_merge_section())
2902 Output_merge_base
* pomb
= p
->output_merge_base();
2903 Merge_section_properties
msp(pomb
->is_string(), pomb
->entsize(),
2905 this->lookup_maps_
->add_merge_section(msp
, pomb
);
2906 for (Output_merge_base::Input_sections::const_iterator is
=
2907 pomb
->input_sections_begin();
2908 is
!= pomb
->input_sections_end();
2911 const Const_section_id
& csid
= *is
;
2912 this->lookup_maps_
->add_merge_input_section(csid
.first
,
2917 else if (p
->is_relaxed_input_section())
2919 Output_relaxed_input_section
* poris
= p
->relaxed_input_section();
2920 this->lookup_maps_
->add_relaxed_input_section(poris
->relobj(),
2921 poris
->shndx(), poris
);
2926 // Find an relaxed input section corresponding to an input section
2927 // in OBJECT with index SHNDX.
2929 const Output_relaxed_input_section
*
2930 Output_section::find_relaxed_input_section(const Relobj
* object
,
2931 unsigned int shndx
) const
2933 if (!this->lookup_maps_
->is_valid())
2934 this->build_lookup_maps();
2935 return this->lookup_maps_
->find_relaxed_input_section(object
, shndx
);
2938 // Given an address OFFSET relative to the start of input section
2939 // SHNDX in OBJECT, return whether this address is being included in
2940 // the final link. This should only be called if SHNDX in OBJECT has
2941 // a special mapping.
2944 Output_section::is_input_address_mapped(const Relobj
* object
,
2948 // Look at the Output_section_data_maps first.
2949 const Output_section_data
* posd
= this->find_merge_section(object
, shndx
);
2951 posd
= this->find_relaxed_input_section(object
, shndx
);
2955 section_offset_type output_offset
;
2956 bool found
= posd
->output_offset(object
, shndx
, offset
, &output_offset
);
2958 return output_offset
!= -1;
2961 // Fall back to the slow look-up.
2962 for (Input_section_list::const_iterator p
= this->input_sections_
.begin();
2963 p
!= this->input_sections_
.end();
2966 section_offset_type output_offset
;
2967 if (p
->output_offset(object
, shndx
, offset
, &output_offset
))
2968 return output_offset
!= -1;
2971 // By default we assume that the address is mapped. This should
2972 // only be called after we have passed all sections to Layout. At
2973 // that point we should know what we are discarding.
2977 // Given an address OFFSET relative to the start of input section
2978 // SHNDX in object OBJECT, return the output offset relative to the
2979 // start of the input section in the output section. This should only
2980 // be called if SHNDX in OBJECT has a special mapping.
2983 Output_section::output_offset(const Relobj
* object
, unsigned int shndx
,
2984 section_offset_type offset
) const
2986 // This can only be called meaningfully when we know the data size
2988 gold_assert(this->is_data_size_valid());
2990 // Look at the Output_section_data_maps first.
2991 const Output_section_data
* posd
= this->find_merge_section(object
, shndx
);
2993 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
);
2999 return output_offset
;
3002 // Fall back to the slow look-up.
3003 for (Input_section_list::const_iterator p
= this->input_sections_
.begin();
3004 p
!= this->input_sections_
.end();
3007 section_offset_type output_offset
;
3008 if (p
->output_offset(object
, shndx
, offset
, &output_offset
))
3009 return output_offset
;
3014 // Return the output virtual address of OFFSET relative to the start
3015 // of input section SHNDX in object OBJECT.
3018 Output_section::output_address(const Relobj
* object
, unsigned int shndx
,
3021 uint64_t addr
= this->address() + this->first_input_offset_
;
3023 // Look at the Output_section_data_maps first.
3024 const Output_section_data
* posd
= this->find_merge_section(object
, shndx
);
3026 posd
= this->find_relaxed_input_section(object
, shndx
);
3027 if (posd
!= NULL
&& posd
->is_address_valid())
3029 section_offset_type output_offset
;
3030 bool found
= posd
->output_offset(object
, shndx
, offset
, &output_offset
);
3032 return posd
->address() + output_offset
;
3035 // Fall back to the slow look-up.
3036 for (Input_section_list::const_iterator p
= this->input_sections_
.begin();
3037 p
!= this->input_sections_
.end();
3040 addr
= align_address(addr
, p
->addralign());
3041 section_offset_type output_offset
;
3042 if (p
->output_offset(object
, shndx
, offset
, &output_offset
))
3044 if (output_offset
== -1)
3046 return addr
+ output_offset
;
3048 addr
+= p
->data_size();
3051 // If we get here, it means that we don't know the mapping for this
3052 // input section. This might happen in principle if
3053 // add_input_section were called before add_output_section_data.
3054 // But it should never actually happen.
3059 // Find the output address of the start of the merged section for
3060 // input section SHNDX in object OBJECT.
3063 Output_section::find_starting_output_address(const Relobj
* object
,
3065 uint64_t* paddr
) const
3067 // FIXME: This becomes a bottle-neck if we have many relaxed sections.
3068 // Looking up the merge section map does not always work as we sometimes
3069 // find a merge section without its address set.
3070 uint64_t addr
= this->address() + this->first_input_offset_
;
3071 for (Input_section_list::const_iterator p
= this->input_sections_
.begin();
3072 p
!= this->input_sections_
.end();
3075 addr
= align_address(addr
, p
->addralign());
3077 // It would be nice if we could use the existing output_offset
3078 // method to get the output offset of input offset 0.
3079 // Unfortunately we don't know for sure that input offset 0 is
3081 if (p
->is_merge_section_for(object
, shndx
))
3087 addr
+= p
->data_size();
3090 // We couldn't find a merge output section for this input section.
3094 // Update the data size of an Output_section.
3097 Output_section::update_data_size()
3099 if (this->input_sections_
.empty())
3102 if (this->must_sort_attached_input_sections()
3103 || this->input_section_order_specified())
3104 this->sort_attached_input_sections();
3106 off_t off
= this->first_input_offset_
;
3107 for (Input_section_list::iterator p
= this->input_sections_
.begin();
3108 p
!= this->input_sections_
.end();
3111 off
= align_address(off
, p
->addralign());
3112 off
+= p
->current_data_size();
3115 this->set_current_data_size_for_child(off
);
3118 // Set the data size of an Output_section. This is where we handle
3119 // setting the addresses of any Output_section_data objects.
3122 Output_section::set_final_data_size()
3126 if (this->input_sections_
.empty())
3127 data_size
= this->current_data_size_for_child();
3130 if (this->must_sort_attached_input_sections()
3131 || this->input_section_order_specified())
3132 this->sort_attached_input_sections();
3134 uint64_t address
= this->address();
3135 off_t startoff
= this->offset();
3136 off_t off
= startoff
+ this->first_input_offset_
;
3137 for (Input_section_list::iterator p
= this->input_sections_
.begin();
3138 p
!= this->input_sections_
.end();
3141 off
= align_address(off
, p
->addralign());
3142 p
->set_address_and_file_offset(address
+ (off
- startoff
), off
,
3144 off
+= p
->data_size();
3146 data_size
= off
- startoff
;
3149 // For full incremental links, we want to allocate some patch space
3150 // in most sections for subsequent incremental updates.
3151 if (this->is_patch_space_allowed_
&& parameters
->incremental_full())
3153 double pct
= parameters
->options().incremental_patch();
3154 size_t extra
= static_cast<size_t>(data_size
* pct
);
3155 if (this->free_space_fill_
!= NULL
3156 && this->free_space_fill_
->minimum_hole_size() > extra
)
3157 extra
= this->free_space_fill_
->minimum_hole_size();
3158 off_t new_size
= align_address(data_size
+ extra
, this->addralign());
3159 this->patch_space_
= new_size
- data_size
;
3160 gold_debug(DEBUG_INCREMENTAL
,
3161 "set_final_data_size: %08lx + %08lx: section %s",
3162 static_cast<long>(data_size
),
3163 static_cast<long>(this->patch_space_
),
3165 data_size
= new_size
;
3168 this->set_data_size(data_size
);
3171 // Reset the address and file offset.
3174 Output_section::do_reset_address_and_file_offset()
3176 // An unallocated section has no address. Forcing this means that
3177 // we don't need special treatment for symbols defined in debug
3178 // sections. We do the same in the constructor. This does not
3179 // apply to NOLOAD sections though.
3180 if (((this->flags_
& elfcpp::SHF_ALLOC
) == 0) && !this->is_noload_
)
3181 this->set_address(0);
3183 for (Input_section_list::iterator p
= this->input_sections_
.begin();
3184 p
!= this->input_sections_
.end();
3186 p
->reset_address_and_file_offset();
3188 // Remove any patch space that was added in set_final_data_size.
3189 if (this->patch_space_
> 0)
3191 this->set_current_data_size_for_child(this->current_data_size_for_child()
3192 - this->patch_space_
);
3193 this->patch_space_
= 0;
3197 // Return true if address and file offset have the values after reset.
3200 Output_section::do_address_and_file_offset_have_reset_values() const
3202 if (this->is_offset_valid())
3205 // An unallocated section has address 0 after its construction or a reset.
3206 if ((this->flags_
& elfcpp::SHF_ALLOC
) == 0)
3207 return this->is_address_valid() && this->address() == 0;
3209 return !this->is_address_valid();
3212 // Set the TLS offset. Called only for SHT_TLS sections.
3215 Output_section::do_set_tls_offset(uint64_t tls_base
)
3217 this->tls_offset_
= this->address() - tls_base
;
3220 // In a few cases we need to sort the input sections attached to an
3221 // output section. This is used to implement the type of constructor
3222 // priority ordering implemented by the GNU linker, in which the
3223 // priority becomes part of the section name and the sections are
3224 // sorted by name. We only do this for an output section if we see an
3225 // attached input section matching ".ctors.*", ".dtors.*",
3226 // ".init_array.*" or ".fini_array.*".
3228 class Output_section::Input_section_sort_entry
3231 Input_section_sort_entry()
3232 : input_section_(), index_(-1U), section_has_name_(false),
3236 Input_section_sort_entry(const Input_section
& input_section
,
3238 bool must_sort_attached_input_sections
)
3239 : input_section_(input_section
), index_(index
),
3240 section_has_name_(input_section
.is_input_section()
3241 || input_section
.is_relaxed_input_section())
3243 if (this->section_has_name_
3244 && must_sort_attached_input_sections
)
3246 // This is only called single-threaded from Layout::finalize,
3247 // so it is OK to lock. Unfortunately we have no way to pass
3249 const Task
* dummy_task
= reinterpret_cast<const Task
*>(-1);
3250 Object
* obj
= (input_section
.is_input_section()
3251 ? input_section
.relobj()
3252 : input_section
.relaxed_input_section()->relobj());
3253 Task_lock_obj
<Object
> tl(dummy_task
, obj
);
3255 // This is a slow operation, which should be cached in
3256 // Layout::layout if this becomes a speed problem.
3257 this->section_name_
= obj
->section_name(input_section
.shndx());
3261 // Return the Input_section.
3262 const Input_section
&
3263 input_section() const
3265 gold_assert(this->index_
!= -1U);
3266 return this->input_section_
;
3269 // The index of this entry in the original list. This is used to
3270 // make the sort stable.
3274 gold_assert(this->index_
!= -1U);
3275 return this->index_
;
3278 // Whether there is a section name.
3280 section_has_name() const
3281 { return this->section_has_name_
; }
3283 // The section name.
3285 section_name() const
3287 gold_assert(this->section_has_name_
);
3288 return this->section_name_
;
3291 // Return true if the section name has a priority. This is assumed
3292 // to be true if it has a dot after the initial dot.
3294 has_priority() const
3296 gold_assert(this->section_has_name_
);
3297 return this->section_name_
.find('.', 1) != std::string::npos
;
3300 // Return the priority. Believe it or not, gcc encodes the priority
3301 // differently for .ctors/.dtors and .init_array/.fini_array
3304 get_priority() const
3306 gold_assert(this->section_has_name_
);
3308 if (is_prefix_of(".ctors.", this->section_name_
.c_str())
3309 || is_prefix_of(".dtors.", this->section_name_
.c_str()))
3311 else if (is_prefix_of(".init_array.", this->section_name_
.c_str())
3312 || is_prefix_of(".fini_array.", this->section_name_
.c_str()))
3317 unsigned long prio
= strtoul((this->section_name_
.c_str()
3318 + (is_ctors
? 7 : 12)),
3323 return 65535 - prio
;
3328 // Return true if this an input file whose base name matches
3329 // FILE_NAME. The base name must have an extension of ".o", and
3330 // must be exactly FILE_NAME.o or FILE_NAME, one character, ".o".
3331 // This is to match crtbegin.o as well as crtbeginS.o without
3332 // getting confused by other possibilities. Overall matching the
3333 // file name this way is a dreadful hack, but the GNU linker does it
3334 // in order to better support gcc, and we need to be compatible.
3336 match_file_name(const char* file_name
) const
3337 { return Layout::match_file_name(this->input_section_
.relobj(), file_name
); }
3339 // Returns 1 if THIS should appear before S in section order, -1 if S
3340 // appears before THIS and 0 if they are not comparable.
3342 compare_section_ordering(const Input_section_sort_entry
& s
) const
3344 unsigned int this_secn_index
= this->input_section_
.section_order_index();
3345 unsigned int s_secn_index
= s
.input_section().section_order_index();
3346 if (this_secn_index
> 0 && s_secn_index
> 0)
3348 if (this_secn_index
< s_secn_index
)
3350 else if (this_secn_index
> s_secn_index
)
3357 // The Input_section we are sorting.
3358 Input_section input_section_
;
3359 // The index of this Input_section in the original list.
3360 unsigned int index_
;
3361 // Whether this Input_section has a section name--it won't if this
3362 // is some random Output_section_data.
3363 bool section_has_name_
;
3364 // The section name if there is one.
3365 std::string section_name_
;
3368 // Return true if S1 should come before S2 in the output section.
3371 Output_section::Input_section_sort_compare::operator()(
3372 const Output_section::Input_section_sort_entry
& s1
,
3373 const Output_section::Input_section_sort_entry
& s2
) const
3375 // crtbegin.o must come first.
3376 bool s1_begin
= s1
.match_file_name("crtbegin");
3377 bool s2_begin
= s2
.match_file_name("crtbegin");
3378 if (s1_begin
|| s2_begin
)
3384 return s1
.index() < s2
.index();
3387 // crtend.o must come last.
3388 bool s1_end
= s1
.match_file_name("crtend");
3389 bool s2_end
= s2
.match_file_name("crtend");
3390 if (s1_end
|| s2_end
)
3396 return s1
.index() < s2
.index();
3399 // We sort all the sections with no names to the end.
3400 if (!s1
.section_has_name() || !s2
.section_has_name())
3402 if (s1
.section_has_name())
3404 if (s2
.section_has_name())
3406 return s1
.index() < s2
.index();
3409 // A section with a priority follows a section without a priority.
3410 bool s1_has_priority
= s1
.has_priority();
3411 bool s2_has_priority
= s2
.has_priority();
3412 if (s1_has_priority
&& !s2_has_priority
)
3414 if (!s1_has_priority
&& s2_has_priority
)
3417 // Check if a section order exists for these sections through a section
3418 // ordering file. If sequence_num is 0, an order does not exist.
3419 int sequence_num
= s1
.compare_section_ordering(s2
);
3420 if (sequence_num
!= 0)
3421 return sequence_num
== 1;
3423 // Otherwise we sort by name.
3424 int compare
= s1
.section_name().compare(s2
.section_name());
3428 // Otherwise we keep the input order.
3429 return s1
.index() < s2
.index();
3432 // Return true if S1 should come before S2 in an .init_array or .fini_array
3436 Output_section::Input_section_sort_init_fini_compare::operator()(
3437 const Output_section::Input_section_sort_entry
& s1
,
3438 const Output_section::Input_section_sort_entry
& s2
) const
3440 // We sort all the sections with no names to the end.
3441 if (!s1
.section_has_name() || !s2
.section_has_name())
3443 if (s1
.section_has_name())
3445 if (s2
.section_has_name())
3447 return s1
.index() < s2
.index();
3450 // A section without a priority follows a section with a priority.
3451 // This is the reverse of .ctors and .dtors sections.
3452 bool s1_has_priority
= s1
.has_priority();
3453 bool s2_has_priority
= s2
.has_priority();
3454 if (s1_has_priority
&& !s2_has_priority
)
3456 if (!s1_has_priority
&& s2_has_priority
)
3459 // .ctors and .dtors sections without priority come after
3460 // .init_array and .fini_array sections without priority.
3461 if (!s1_has_priority
3462 && (s1
.section_name() == ".ctors" || s1
.section_name() == ".dtors")
3463 && s1
.section_name() != s2
.section_name())
3465 if (!s2_has_priority
3466 && (s2
.section_name() == ".ctors" || s2
.section_name() == ".dtors")
3467 && s2
.section_name() != s1
.section_name())
3470 // Sort by priority if we can.
3471 if (s1_has_priority
)
3473 unsigned int s1_prio
= s1
.get_priority();
3474 unsigned int s2_prio
= s2
.get_priority();
3475 if (s1_prio
< s2_prio
)
3477 else if (s1_prio
> s2_prio
)
3481 // Check if a section order exists for these sections through a section
3482 // ordering file. If sequence_num is 0, an order does not exist.
3483 int sequence_num
= s1
.compare_section_ordering(s2
);
3484 if (sequence_num
!= 0)
3485 return sequence_num
== 1;
3487 // Otherwise we sort by name.
3488 int compare
= s1
.section_name().compare(s2
.section_name());
3492 // Otherwise we keep the input order.
3493 return s1
.index() < s2
.index();
3496 // Return true if S1 should come before S2. Sections that do not match
3497 // any pattern in the section ordering file are placed ahead of the sections
3498 // that match some pattern.
3501 Output_section::Input_section_sort_section_order_index_compare::operator()(
3502 const Output_section::Input_section_sort_entry
& s1
,
3503 const Output_section::Input_section_sort_entry
& s2
) const
3505 unsigned int s1_secn_index
= s1
.input_section().section_order_index();
3506 unsigned int s2_secn_index
= s2
.input_section().section_order_index();
3508 // Keep input order if section ordering cannot determine order.
3509 if (s1_secn_index
== s2_secn_index
)
3510 return s1
.index() < s2
.index();
3512 return s1_secn_index
< s2_secn_index
;
3515 // This updates the section order index of input sections according to the
3516 // the order specified in the mapping from Section id to order index.
3519 Output_section::update_section_layout(
3520 const Section_layout_order
* order_map
)
3522 for (Input_section_list::iterator p
= this->input_sections_
.begin();
3523 p
!= this->input_sections_
.end();
3526 if (p
->is_input_section()
3527 || p
->is_relaxed_input_section())
3529 Object
* obj
= (p
->is_input_section()
3531 : p
->relaxed_input_section()->relobj());
3532 unsigned int shndx
= p
->shndx();
3533 Section_layout_order::const_iterator it
3534 = order_map
->find(Section_id(obj
, shndx
));
3535 if (it
== order_map
->end())
3537 unsigned int section_order_index
= it
->second
;
3538 if (section_order_index
!= 0)
3540 p
->set_section_order_index(section_order_index
);
3541 this->set_input_section_order_specified();
3547 // Sort the input sections attached to an output section.
3550 Output_section::sort_attached_input_sections()
3552 if (this->attached_input_sections_are_sorted_
)
3555 if (this->checkpoint_
!= NULL
3556 && !this->checkpoint_
->input_sections_saved())
3557 this->checkpoint_
->save_input_sections();
3559 // The only thing we know about an input section is the object and
3560 // the section index. We need the section name. Recomputing this
3561 // is slow but this is an unusual case. If this becomes a speed
3562 // problem we can cache the names as required in Layout::layout.
3564 // We start by building a larger vector holding a copy of each
3565 // Input_section, plus its current index in the list and its name.
3566 std::vector
<Input_section_sort_entry
> sort_list
;
3569 for (Input_section_list::iterator p
= this->input_sections_
.begin();
3570 p
!= this->input_sections_
.end();
3572 sort_list
.push_back(Input_section_sort_entry(*p
, i
,
3573 this->must_sort_attached_input_sections()));
3575 // Sort the input sections.
3576 if (this->must_sort_attached_input_sections())
3578 if (this->type() == elfcpp::SHT_PREINIT_ARRAY
3579 || this->type() == elfcpp::SHT_INIT_ARRAY
3580 || this->type() == elfcpp::SHT_FINI_ARRAY
)
3581 std::sort(sort_list
.begin(), sort_list
.end(),
3582 Input_section_sort_init_fini_compare());
3584 std::sort(sort_list
.begin(), sort_list
.end(),
3585 Input_section_sort_compare());
3589 gold_assert(this->input_section_order_specified());
3590 std::sort(sort_list
.begin(), sort_list
.end(),
3591 Input_section_sort_section_order_index_compare());
3594 // Copy the sorted input sections back to our list.
3595 this->input_sections_
.clear();
3596 for (std::vector
<Input_section_sort_entry
>::iterator p
= sort_list
.begin();
3597 p
!= sort_list
.end();
3599 this->input_sections_
.push_back(p
->input_section());
3602 // Remember that we sorted the input sections, since we might get
3604 this->attached_input_sections_are_sorted_
= true;
3607 // Write the section header to *OSHDR.
3609 template<int size
, bool big_endian
>
3611 Output_section::write_header(const Layout
* layout
,
3612 const Stringpool
* secnamepool
,
3613 elfcpp::Shdr_write
<size
, big_endian
>* oshdr
) const
3615 oshdr
->put_sh_name(secnamepool
->get_offset(this->name_
));
3616 oshdr
->put_sh_type(this->type_
);
3618 elfcpp::Elf_Xword flags
= this->flags_
;
3619 if (this->info_section_
!= NULL
&& this->info_uses_section_index_
)
3620 flags
|= elfcpp::SHF_INFO_LINK
;
3621 oshdr
->put_sh_flags(flags
);
3623 oshdr
->put_sh_addr(this->address());
3624 oshdr
->put_sh_offset(this->offset());
3625 oshdr
->put_sh_size(this->data_size());
3626 if (this->link_section_
!= NULL
)
3627 oshdr
->put_sh_link(this->link_section_
->out_shndx());
3628 else if (this->should_link_to_symtab_
)
3629 oshdr
->put_sh_link(layout
->symtab_section_shndx());
3630 else if (this->should_link_to_dynsym_
)
3631 oshdr
->put_sh_link(layout
->dynsym_section()->out_shndx());
3633 oshdr
->put_sh_link(this->link_
);
3635 elfcpp::Elf_Word info
;
3636 if (this->info_section_
!= NULL
)
3638 if (this->info_uses_section_index_
)
3639 info
= this->info_section_
->out_shndx();
3641 info
= this->info_section_
->symtab_index();
3643 else if (this->info_symndx_
!= NULL
)
3644 info
= this->info_symndx_
->symtab_index();
3647 oshdr
->put_sh_info(info
);
3649 oshdr
->put_sh_addralign(this->addralign_
);
3650 oshdr
->put_sh_entsize(this->entsize_
);
3653 // Write out the data. For input sections the data is written out by
3654 // Object::relocate, but we have to handle Output_section_data objects
3658 Output_section::do_write(Output_file
* of
)
3660 gold_assert(!this->requires_postprocessing());
3662 // If the target performs relaxation, we delay filler generation until now.
3663 gold_assert(!this->generate_code_fills_at_write_
|| this->fills_
.empty());
3665 off_t output_section_file_offset
= this->offset();
3666 for (Fill_list::iterator p
= this->fills_
.begin();
3667 p
!= this->fills_
.end();
3670 std::string
fill_data(parameters
->target().code_fill(p
->length()));
3671 of
->write(output_section_file_offset
+ p
->section_offset(),
3672 fill_data
.data(), fill_data
.size());
3675 off_t off
= this->offset() + this->first_input_offset_
;
3676 for (Input_section_list::iterator p
= this->input_sections_
.begin();
3677 p
!= this->input_sections_
.end();
3680 off_t aligned_off
= align_address(off
, p
->addralign());
3681 if (this->generate_code_fills_at_write_
&& (off
!= aligned_off
))
3683 size_t fill_len
= aligned_off
- off
;
3684 std::string
fill_data(parameters
->target().code_fill(fill_len
));
3685 of
->write(off
, fill_data
.data(), fill_data
.size());
3689 off
= aligned_off
+ p
->data_size();
3692 // For incremental links, fill in unused chunks in debug sections
3693 // with dummy compilation unit headers.
3694 if (this->free_space_fill_
!= NULL
)
3696 for (Free_list::Const_iterator p
= this->free_list_
.begin();
3697 p
!= this->free_list_
.end();
3700 off_t off
= p
->start_
;
3701 size_t len
= p
->end_
- off
;
3702 this->free_space_fill_
->write(of
, this->offset() + off
, len
);
3704 if (this->patch_space_
> 0)
3706 off_t off
= this->current_data_size_for_child() - this->patch_space_
;
3707 this->free_space_fill_
->write(of
, this->offset() + off
,
3708 this->patch_space_
);
3713 // If a section requires postprocessing, create the buffer to use.
3716 Output_section::create_postprocessing_buffer()
3718 gold_assert(this->requires_postprocessing());
3720 if (this->postprocessing_buffer_
!= NULL
)
3723 if (!this->input_sections_
.empty())
3725 off_t off
= this->first_input_offset_
;
3726 for (Input_section_list::iterator p
= this->input_sections_
.begin();
3727 p
!= this->input_sections_
.end();
3730 off
= align_address(off
, p
->addralign());
3731 p
->finalize_data_size();
3732 off
+= p
->data_size();
3734 this->set_current_data_size_for_child(off
);
3737 off_t buffer_size
= this->current_data_size_for_child();
3738 this->postprocessing_buffer_
= new unsigned char[buffer_size
];
3741 // Write all the data of an Output_section into the postprocessing
3742 // buffer. This is used for sections which require postprocessing,
3743 // such as compression. Input sections are handled by
3744 // Object::Relocate.
3747 Output_section::write_to_postprocessing_buffer()
3749 gold_assert(this->requires_postprocessing());
3751 // If the target performs relaxation, we delay filler generation until now.
3752 gold_assert(!this->generate_code_fills_at_write_
|| this->fills_
.empty());
3754 unsigned char* buffer
= this->postprocessing_buffer();
3755 for (Fill_list::iterator p
= this->fills_
.begin();
3756 p
!= this->fills_
.end();
3759 std::string
fill_data(parameters
->target().code_fill(p
->length()));
3760 memcpy(buffer
+ p
->section_offset(), fill_data
.data(),
3764 off_t off
= this->first_input_offset_
;
3765 for (Input_section_list::iterator p
= this->input_sections_
.begin();
3766 p
!= this->input_sections_
.end();
3769 off_t aligned_off
= align_address(off
, p
->addralign());
3770 if (this->generate_code_fills_at_write_
&& (off
!= aligned_off
))
3772 size_t fill_len
= aligned_off
- off
;
3773 std::string
fill_data(parameters
->target().code_fill(fill_len
));
3774 memcpy(buffer
+ off
, fill_data
.data(), fill_data
.size());
3777 p
->write_to_buffer(buffer
+ aligned_off
);
3778 off
= aligned_off
+ p
->data_size();
3782 // Get the input sections for linker script processing. We leave
3783 // behind the Output_section_data entries. Note that this may be
3784 // slightly incorrect for merge sections. We will leave them behind,
3785 // but it is possible that the script says that they should follow
3786 // some other input sections, as in:
3787 // .rodata { *(.rodata) *(.rodata.cst*) }
3788 // For that matter, we don't handle this correctly:
3789 // .rodata { foo.o(.rodata.cst*) *(.rodata.cst*) }
3790 // With luck this will never matter.
3793 Output_section::get_input_sections(
3795 const std::string
& fill
,
3796 std::list
<Input_section
>* input_sections
)
3798 if (this->checkpoint_
!= NULL
3799 && !this->checkpoint_
->input_sections_saved())
3800 this->checkpoint_
->save_input_sections();
3802 // Invalidate fast look-up maps.
3803 this->lookup_maps_
->invalidate();
3805 uint64_t orig_address
= address
;
3807 address
= align_address(address
, this->addralign());
3809 Input_section_list remaining
;
3810 for (Input_section_list::iterator p
= this->input_sections_
.begin();
3811 p
!= this->input_sections_
.end();
3814 if (p
->is_input_section()
3815 || p
->is_relaxed_input_section()
3816 || p
->is_merge_section())
3817 input_sections
->push_back(*p
);
3820 uint64_t aligned_address
= align_address(address
, p
->addralign());
3821 if (aligned_address
!= address
&& !fill
.empty())
3823 section_size_type length
=
3824 convert_to_section_size_type(aligned_address
- address
);
3825 std::string this_fill
;
3826 this_fill
.reserve(length
);
3827 while (this_fill
.length() + fill
.length() <= length
)
3829 if (this_fill
.length() < length
)
3830 this_fill
.append(fill
, 0, length
- this_fill
.length());
3832 Output_section_data
* posd
= new Output_data_const(this_fill
, 0);
3833 remaining
.push_back(Input_section(posd
));
3835 address
= aligned_address
;
3837 remaining
.push_back(*p
);
3839 p
->finalize_data_size();
3840 address
+= p
->data_size();
3844 this->input_sections_
.swap(remaining
);
3845 this->first_input_offset_
= 0;
3847 uint64_t data_size
= address
- orig_address
;
3848 this->set_current_data_size_for_child(data_size
);
3852 // Add a script input section. SIS is an Output_section::Input_section,
3853 // which can be either a plain input section or a special input section like
3854 // a relaxed input section. For a special input section, its size must be
3858 Output_section::add_script_input_section(const Input_section
& sis
)
3860 uint64_t data_size
= sis
.data_size();
3861 uint64_t addralign
= sis
.addralign();
3862 if (addralign
> this->addralign_
)
3863 this->addralign_
= addralign
;
3865 off_t offset_in_section
= this->current_data_size_for_child();
3866 off_t aligned_offset_in_section
= align_address(offset_in_section
,
3869 this->set_current_data_size_for_child(aligned_offset_in_section
3872 this->input_sections_
.push_back(sis
);
3874 // Update fast lookup maps if necessary.
3875 if (this->lookup_maps_
->is_valid())
3877 if (sis
.is_merge_section())
3879 Output_merge_base
* pomb
= sis
.output_merge_base();
3880 Merge_section_properties
msp(pomb
->is_string(), pomb
->entsize(),
3882 this->lookup_maps_
->add_merge_section(msp
, pomb
);
3883 for (Output_merge_base::Input_sections::const_iterator p
=
3884 pomb
->input_sections_begin();
3885 p
!= pomb
->input_sections_end();
3887 this->lookup_maps_
->add_merge_input_section(p
->first
, p
->second
,
3890 else if (sis
.is_relaxed_input_section())
3892 Output_relaxed_input_section
* poris
= sis
.relaxed_input_section();
3893 this->lookup_maps_
->add_relaxed_input_section(poris
->relobj(),
3894 poris
->shndx(), poris
);
3899 // Save states for relaxation.
3902 Output_section::save_states()
3904 gold_assert(this->checkpoint_
== NULL
);
3905 Checkpoint_output_section
* checkpoint
=
3906 new Checkpoint_output_section(this->addralign_
, this->flags_
,
3907 this->input_sections_
,
3908 this->first_input_offset_
,
3909 this->attached_input_sections_are_sorted_
);
3910 this->checkpoint_
= checkpoint
;
3911 gold_assert(this->fills_
.empty());
3915 Output_section::discard_states()
3917 gold_assert(this->checkpoint_
!= NULL
);
3918 delete this->checkpoint_
;
3919 this->checkpoint_
= NULL
;
3920 gold_assert(this->fills_
.empty());
3922 // Simply invalidate the fast lookup maps since we do not keep
3924 this->lookup_maps_
->invalidate();
3928 Output_section::restore_states()
3930 gold_assert(this->checkpoint_
!= NULL
);
3931 Checkpoint_output_section
* checkpoint
= this->checkpoint_
;
3933 this->addralign_
= checkpoint
->addralign();
3934 this->flags_
= checkpoint
->flags();
3935 this->first_input_offset_
= checkpoint
->first_input_offset();
3937 if (!checkpoint
->input_sections_saved())
3939 // If we have not copied the input sections, just resize it.
3940 size_t old_size
= checkpoint
->input_sections_size();
3941 gold_assert(this->input_sections_
.size() >= old_size
);
3942 this->input_sections_
.resize(old_size
);
3946 // We need to copy the whole list. This is not efficient for
3947 // extremely large output with hundreads of thousands of input
3948 // objects. We may need to re-think how we should pass sections
3950 this->input_sections_
= *checkpoint
->input_sections();
3953 this->attached_input_sections_are_sorted_
=
3954 checkpoint
->attached_input_sections_are_sorted();
3956 // Simply invalidate the fast lookup maps since we do not keep
3958 this->lookup_maps_
->invalidate();
3961 // Update the section offsets of input sections in this. This is required if
3962 // relaxation causes some input sections to change sizes.
3965 Output_section::adjust_section_offsets()
3967 if (!this->section_offsets_need_adjustment_
)
3971 for (Input_section_list::iterator p
= this->input_sections_
.begin();
3972 p
!= this->input_sections_
.end();
3975 off
= align_address(off
, p
->addralign());
3976 if (p
->is_input_section())
3977 p
->relobj()->set_section_offset(p
->shndx(), off
);
3978 off
+= p
->data_size();
3981 this->section_offsets_need_adjustment_
= false;
3984 // Print to the map file.
3987 Output_section::do_print_to_mapfile(Mapfile
* mapfile
) const
3989 mapfile
->print_output_section(this);
3991 for (Input_section_list::const_iterator p
= this->input_sections_
.begin();
3992 p
!= this->input_sections_
.end();
3994 p
->print_to_mapfile(mapfile
);
3997 // Print stats for merge sections to stderr.
4000 Output_section::print_merge_stats()
4002 Input_section_list::iterator p
;
4003 for (p
= this->input_sections_
.begin();
4004 p
!= this->input_sections_
.end();
4006 p
->print_merge_stats(this->name_
);
4009 // Set a fixed layout for the section. Used for incremental update links.
4012 Output_section::set_fixed_layout(uint64_t sh_addr
, off_t sh_offset
,
4013 off_t sh_size
, uint64_t sh_addralign
)
4015 this->addralign_
= sh_addralign
;
4016 this->set_current_data_size(sh_size
);
4017 if ((this->flags_
& elfcpp::SHF_ALLOC
) != 0)
4018 this->set_address(sh_addr
);
4019 this->set_file_offset(sh_offset
);
4020 this->finalize_data_size();
4021 this->free_list_
.init(sh_size
, false);
4022 this->has_fixed_layout_
= true;
4025 // Reserve space within the fixed layout for the section. Used for
4026 // incremental update links.
4029 Output_section::reserve(uint64_t sh_offset
, uint64_t sh_size
)
4031 this->free_list_
.remove(sh_offset
, sh_offset
+ sh_size
);
4034 // Allocate space from the free list for the section. Used for
4035 // incremental update links.
4038 Output_section::allocate(off_t len
, uint64_t addralign
)
4040 return this->free_list_
.allocate(len
, addralign
, 0);
4043 // Output segment methods.
4045 Output_segment::Output_segment(elfcpp::Elf_Word type
, elfcpp::Elf_Word flags
)
4055 is_max_align_known_(false),
4056 are_addresses_set_(false),
4057 is_large_data_segment_(false),
4058 is_unique_segment_(false)
4060 // The ELF ABI specifies that a PT_TLS segment always has PF_R as
4062 if (type
== elfcpp::PT_TLS
)
4063 this->flags_
= elfcpp::PF_R
;
4066 // Add an Output_section to a PT_LOAD Output_segment.
4069 Output_segment::add_output_section_to_load(Layout
* layout
,
4071 elfcpp::Elf_Word seg_flags
)
4073 gold_assert(this->type() == elfcpp::PT_LOAD
);
4074 gold_assert((os
->flags() & elfcpp::SHF_ALLOC
) != 0);
4075 gold_assert(!this->is_max_align_known_
);
4076 gold_assert(os
->is_large_data_section() == this->is_large_data_segment());
4078 this->update_flags_for_output_section(seg_flags
);
4080 // We don't want to change the ordering if we have a linker script
4081 // with a SECTIONS clause.
4082 Output_section_order order
= os
->order();
4083 if (layout
->script_options()->saw_sections_clause())
4084 order
= static_cast<Output_section_order
>(0);
4086 gold_assert(order
!= ORDER_INVALID
);
4088 this->output_lists_
[order
].push_back(os
);
4091 // Add an Output_section to a non-PT_LOAD Output_segment.
4094 Output_segment::add_output_section_to_nonload(Output_section
* os
,
4095 elfcpp::Elf_Word seg_flags
)
4097 gold_assert(this->type() != elfcpp::PT_LOAD
);
4098 gold_assert((os
->flags() & elfcpp::SHF_ALLOC
) != 0);
4099 gold_assert(!this->is_max_align_known_
);
4101 this->update_flags_for_output_section(seg_flags
);
4103 this->output_lists_
[0].push_back(os
);
4106 // Remove an Output_section from this segment. It is an error if it
4110 Output_segment::remove_output_section(Output_section
* os
)
4112 for (int i
= 0; i
< static_cast<int>(ORDER_MAX
); ++i
)
4114 Output_data_list
* pdl
= &this->output_lists_
[i
];
4115 for (Output_data_list::iterator p
= pdl
->begin(); p
!= pdl
->end(); ++p
)
4127 // Add an Output_data (which need not be an Output_section) to the
4128 // start of a segment.
4131 Output_segment::add_initial_output_data(Output_data
* od
)
4133 gold_assert(!this->is_max_align_known_
);
4134 Output_data_list::iterator p
= this->output_lists_
[0].begin();
4135 this->output_lists_
[0].insert(p
, od
);
4138 // Return true if this segment has any sections which hold actual
4139 // data, rather than being a BSS section.
4142 Output_segment::has_any_data_sections() const
4144 for (int i
= 0; i
< static_cast<int>(ORDER_MAX
); ++i
)
4146 const Output_data_list
* pdl
= &this->output_lists_
[i
];
4147 for (Output_data_list::const_iterator p
= pdl
->begin();
4151 if (!(*p
)->is_section())
4153 if ((*p
)->output_section()->type() != elfcpp::SHT_NOBITS
)
4160 // Return whether the first data section (not counting TLS sections)
4161 // is a relro section.
4164 Output_segment::is_first_section_relro() const
4166 for (int i
= 0; i
< static_cast<int>(ORDER_MAX
); ++i
)
4168 if (i
== static_cast<int>(ORDER_TLS_DATA
)
4169 || i
== static_cast<int>(ORDER_TLS_BSS
))
4171 const Output_data_list
* pdl
= &this->output_lists_
[i
];
4174 Output_data
* p
= pdl
->front();
4175 return p
->is_section() && p
->output_section()->is_relro();
4181 // Return the maximum alignment of the Output_data in Output_segment.
4184 Output_segment::maximum_alignment()
4186 if (!this->is_max_align_known_
)
4188 for (int i
= 0; i
< static_cast<int>(ORDER_MAX
); ++i
)
4190 const Output_data_list
* pdl
= &this->output_lists_
[i
];
4191 uint64_t addralign
= Output_segment::maximum_alignment_list(pdl
);
4192 if (addralign
> this->max_align_
)
4193 this->max_align_
= addralign
;
4195 this->is_max_align_known_
= true;
4198 return this->max_align_
;
4201 // Return the maximum alignment of a list of Output_data.
4204 Output_segment::maximum_alignment_list(const Output_data_list
* pdl
)
4207 for (Output_data_list::const_iterator p
= pdl
->begin();
4211 uint64_t addralign
= (*p
)->addralign();
4212 if (addralign
> ret
)
4218 // Return whether this segment has any dynamic relocs.
4221 Output_segment::has_dynamic_reloc() const
4223 for (int i
= 0; i
< static_cast<int>(ORDER_MAX
); ++i
)
4224 if (this->has_dynamic_reloc_list(&this->output_lists_
[i
]))
4229 // Return whether this Output_data_list has any dynamic relocs.
4232 Output_segment::has_dynamic_reloc_list(const Output_data_list
* pdl
) const
4234 for (Output_data_list::const_iterator p
= pdl
->begin();
4237 if ((*p
)->has_dynamic_reloc())
4242 // Set the section addresses for an Output_segment. If RESET is true,
4243 // reset the addresses first. ADDR is the address and *POFF is the
4244 // file offset. Set the section indexes starting with *PSHNDX.
4245 // INCREASE_RELRO is the size of the portion of the first non-relro
4246 // section that should be included in the PT_GNU_RELRO segment.
4247 // If this segment has relro sections, and has been aligned for
4248 // that purpose, set *HAS_RELRO to TRUE. Return the address of
4249 // the immediately following segment. Update *HAS_RELRO, *POFF,
4253 Output_segment::set_section_addresses(Layout
* layout
, bool reset
,
4255 unsigned int* increase_relro
,
4258 unsigned int* pshndx
)
4260 gold_assert(this->type_
== elfcpp::PT_LOAD
);
4262 uint64_t last_relro_pad
= 0;
4263 off_t orig_off
= *poff
;
4265 bool in_tls
= false;
4267 // If we have relro sections, we need to pad forward now so that the
4268 // relro sections plus INCREASE_RELRO end on an abi page boundary.
4269 if (parameters
->options().relro()
4270 && this->is_first_section_relro()
4271 && (!this->are_addresses_set_
|| reset
))
4273 uint64_t relro_size
= 0;
4275 uint64_t max_align
= 0;
4276 for (int i
= 0; i
<= static_cast<int>(ORDER_RELRO_LAST
); ++i
)
4278 Output_data_list
* pdl
= &this->output_lists_
[i
];
4279 Output_data_list::iterator p
;
4280 for (p
= pdl
->begin(); p
!= pdl
->end(); ++p
)
4282 if (!(*p
)->is_section())
4284 uint64_t align
= (*p
)->addralign();
4285 if (align
> max_align
)
4287 if ((*p
)->is_section_flag_set(elfcpp::SHF_TLS
))
4291 // Align the first non-TLS section to the alignment
4292 // of the TLS segment.
4296 relro_size
= align_address(relro_size
, align
);
4297 // Ignore the size of the .tbss section.
4298 if ((*p
)->is_section_flag_set(elfcpp::SHF_TLS
)
4299 && (*p
)->is_section_type(elfcpp::SHT_NOBITS
))
4301 if ((*p
)->is_address_valid())
4302 relro_size
+= (*p
)->data_size();
4305 // FIXME: This could be faster.
4306 (*p
)->set_address_and_file_offset(addr
+ relro_size
,
4308 relro_size
+= (*p
)->data_size();
4309 (*p
)->reset_address_and_file_offset();
4312 if (p
!= pdl
->end())
4315 relro_size
+= *increase_relro
;
4316 // Pad the total relro size to a multiple of the maximum
4317 // section alignment seen.
4318 uint64_t aligned_size
= align_address(relro_size
, max_align
);
4319 // Note the amount of padding added after the last relro section.
4320 last_relro_pad
= aligned_size
- relro_size
;
4323 uint64_t page_align
= parameters
->target().abi_pagesize();
4325 // Align to offset N such that (N + RELRO_SIZE) % PAGE_ALIGN == 0.
4326 uint64_t desired_align
= page_align
- (aligned_size
% page_align
);
4327 if (desired_align
< *poff
% page_align
)
4328 *poff
+= page_align
- *poff
% page_align
;
4329 *poff
+= desired_align
- *poff
% page_align
;
4330 addr
+= *poff
- orig_off
;
4334 if (!reset
&& this->are_addresses_set_
)
4336 gold_assert(this->paddr_
== addr
);
4337 addr
= this->vaddr_
;
4341 this->vaddr_
= addr
;
4342 this->paddr_
= addr
;
4343 this->are_addresses_set_
= true;
4348 this->offset_
= orig_off
;
4352 for (int i
= 0; i
< static_cast<int>(ORDER_MAX
); ++i
)
4354 if (i
== static_cast<int>(ORDER_RELRO_LAST
))
4356 *poff
+= last_relro_pad
;
4357 addr
+= last_relro_pad
;
4358 if (this->output_lists_
[i
].empty())
4360 // If there is nothing in the ORDER_RELRO_LAST list,
4361 // the padding will occur at the end of the relro
4362 // segment, and we need to add it to *INCREASE_RELRO.
4363 *increase_relro
+= last_relro_pad
;
4366 addr
= this->set_section_list_addresses(layout
, reset
,
4367 &this->output_lists_
[i
],
4368 addr
, poff
, pshndx
, &in_tls
);
4369 if (i
< static_cast<int>(ORDER_SMALL_BSS
))
4371 this->filesz_
= *poff
- orig_off
;
4378 // If the last section was a TLS section, align upward to the
4379 // alignment of the TLS segment, so that the overall size of the TLS
4380 // segment is aligned.
4383 uint64_t segment_align
= layout
->tls_segment()->maximum_alignment();
4384 *poff
= align_address(*poff
, segment_align
);
4387 this->memsz_
= *poff
- orig_off
;
4389 // Ignore the file offset adjustments made by the BSS Output_data
4396 // Set the addresses and file offsets in a list of Output_data
4400 Output_segment::set_section_list_addresses(Layout
* layout
, bool reset
,
4401 Output_data_list
* pdl
,
4402 uint64_t addr
, off_t
* poff
,
4403 unsigned int* pshndx
,
4406 off_t startoff
= *poff
;
4407 // For incremental updates, we may allocate non-fixed sections from
4408 // free space in the file. This keeps track of the high-water mark.
4409 off_t maxoff
= startoff
;
4411 off_t off
= startoff
;
4412 for (Output_data_list::iterator p
= pdl
->begin();
4417 (*p
)->reset_address_and_file_offset();
4419 // When doing an incremental update or when using a linker script,
4420 // the section will most likely already have an address.
4421 if (!(*p
)->is_address_valid())
4423 uint64_t align
= (*p
)->addralign();
4425 if ((*p
)->is_section_flag_set(elfcpp::SHF_TLS
))
4427 // Give the first TLS section the alignment of the
4428 // entire TLS segment. Otherwise the TLS segment as a
4429 // whole may be misaligned.
4432 Output_segment
* tls_segment
= layout
->tls_segment();
4433 gold_assert(tls_segment
!= NULL
);
4434 uint64_t segment_align
= tls_segment
->maximum_alignment();
4435 gold_assert(segment_align
>= align
);
4436 align
= segment_align
;
4443 // If this is the first section after the TLS segment,
4444 // align it to at least the alignment of the TLS
4445 // segment, so that the size of the overall TLS segment
4449 uint64_t segment_align
=
4450 layout
->tls_segment()->maximum_alignment();
4451 if (segment_align
> align
)
4452 align
= segment_align
;
4458 if (!parameters
->incremental_update())
4460 off
= align_address(off
, align
);
4461 (*p
)->set_address_and_file_offset(addr
+ (off
- startoff
), off
);
4465 // Incremental update: allocate file space from free list.
4466 (*p
)->pre_finalize_data_size();
4467 off_t current_size
= (*p
)->current_data_size();
4468 off
= layout
->allocate(current_size
, align
, startoff
);
4471 gold_assert((*p
)->output_section() != NULL
);
4472 gold_fallback(_("out of patch space for section %s; "
4473 "relink with --incremental-full"),
4474 (*p
)->output_section()->name());
4476 (*p
)->set_address_and_file_offset(addr
+ (off
- startoff
), off
);
4477 if ((*p
)->data_size() > current_size
)
4479 gold_assert((*p
)->output_section() != NULL
);
4480 gold_fallback(_("%s: section changed size; "
4481 "relink with --incremental-full"),
4482 (*p
)->output_section()->name());
4486 else if (parameters
->incremental_update())
4488 // For incremental updates, use the fixed offset for the
4489 // high-water mark computation.
4490 off
= (*p
)->offset();
4494 // The script may have inserted a skip forward, but it
4495 // better not have moved backward.
4496 if ((*p
)->address() >= addr
+ (off
- startoff
))
4497 off
+= (*p
)->address() - (addr
+ (off
- startoff
));
4500 if (!layout
->script_options()->saw_sections_clause())
4504 Output_section
* os
= (*p
)->output_section();
4506 // Cast to unsigned long long to avoid format warnings.
4507 unsigned long long previous_dot
=
4508 static_cast<unsigned long long>(addr
+ (off
- startoff
));
4509 unsigned long long dot
=
4510 static_cast<unsigned long long>((*p
)->address());
4513 gold_error(_("dot moves backward in linker script "
4514 "from 0x%llx to 0x%llx"), previous_dot
, dot
);
4516 gold_error(_("address of section '%s' moves backward "
4517 "from 0x%llx to 0x%llx"),
4518 os
->name(), previous_dot
, dot
);
4521 (*p
)->set_file_offset(off
);
4522 (*p
)->finalize_data_size();
4525 if (parameters
->incremental_update())
4526 gold_debug(DEBUG_INCREMENTAL
,
4527 "set_section_list_addresses: %08lx %08lx %s",
4528 static_cast<long>(off
),
4529 static_cast<long>((*p
)->data_size()),
4530 ((*p
)->output_section() != NULL
4531 ? (*p
)->output_section()->name() : "(special)"));
4533 // We want to ignore the size of a SHF_TLS SHT_NOBITS
4534 // section. Such a section does not affect the size of a
4536 if (!(*p
)->is_section_flag_set(elfcpp::SHF_TLS
)
4537 || !(*p
)->is_section_type(elfcpp::SHT_NOBITS
))
4538 off
+= (*p
)->data_size();
4543 if ((*p
)->is_section())
4545 (*p
)->set_out_shndx(*pshndx
);
4551 return addr
+ (maxoff
- startoff
);
4554 // For a non-PT_LOAD segment, set the offset from the sections, if
4555 // any. Add INCREASE to the file size and the memory size.
4558 Output_segment::set_offset(unsigned int increase
)
4560 gold_assert(this->type_
!= elfcpp::PT_LOAD
);
4562 gold_assert(!this->are_addresses_set_
);
4564 // A non-load section only uses output_lists_[0].
4566 Output_data_list
* pdl
= &this->output_lists_
[0];
4570 gold_assert(increase
== 0);
4573 this->are_addresses_set_
= true;
4575 this->min_p_align_
= 0;
4581 // Find the first and last section by address.
4582 const Output_data
* first
= NULL
;
4583 const Output_data
* last_data
= NULL
;
4584 const Output_data
* last_bss
= NULL
;
4585 for (Output_data_list::const_iterator p
= pdl
->begin();
4590 || (*p
)->address() < first
->address()
4591 || ((*p
)->address() == first
->address()
4592 && (*p
)->data_size() < first
->data_size()))
4594 const Output_data
** plast
;
4595 if ((*p
)->is_section()
4596 && (*p
)->output_section()->type() == elfcpp::SHT_NOBITS
)
4601 || (*p
)->address() > (*plast
)->address()
4602 || ((*p
)->address() == (*plast
)->address()
4603 && (*p
)->data_size() > (*plast
)->data_size()))
4607 this->vaddr_
= first
->address();
4608 this->paddr_
= (first
->has_load_address()
4609 ? first
->load_address()
4611 this->are_addresses_set_
= true;
4612 this->offset_
= first
->offset();
4614 if (last_data
== NULL
)
4617 this->filesz_
= (last_data
->address()
4618 + last_data
->data_size()
4621 const Output_data
* last
= last_bss
!= NULL
? last_bss
: last_data
;
4622 this->memsz_
= (last
->address()
4626 this->filesz_
+= increase
;
4627 this->memsz_
+= increase
;
4629 // If this is a RELRO segment, verify that the segment ends at a
4631 if (this->type_
== elfcpp::PT_GNU_RELRO
)
4633 uint64_t page_align
= parameters
->target().abi_pagesize();
4634 uint64_t segment_end
= this->vaddr_
+ this->memsz_
;
4635 if (parameters
->incremental_update())
4637 // The INCREASE_RELRO calculation is bypassed for an incremental
4638 // update, so we need to adjust the segment size manually here.
4639 segment_end
= align_address(segment_end
, page_align
);
4640 this->memsz_
= segment_end
- this->vaddr_
;
4643 gold_assert(segment_end
== align_address(segment_end
, page_align
));
4646 // If this is a TLS segment, align the memory size. The code in
4647 // set_section_list ensures that the section after the TLS segment
4648 // is aligned to give us room.
4649 if (this->type_
== elfcpp::PT_TLS
)
4651 uint64_t segment_align
= this->maximum_alignment();
4652 gold_assert(this->vaddr_
== align_address(this->vaddr_
, segment_align
));
4653 this->memsz_
= align_address(this->memsz_
, segment_align
);
4657 // Set the TLS offsets of the sections in the PT_TLS segment.
4660 Output_segment::set_tls_offsets()
4662 gold_assert(this->type_
== elfcpp::PT_TLS
);
4664 for (Output_data_list::iterator p
= this->output_lists_
[0].begin();
4665 p
!= this->output_lists_
[0].end();
4667 (*p
)->set_tls_offset(this->vaddr_
);
4670 // Return the first section.
4673 Output_segment::first_section() const
4675 for (int i
= 0; i
< static_cast<int>(ORDER_MAX
); ++i
)
4677 const Output_data_list
* pdl
= &this->output_lists_
[i
];
4678 for (Output_data_list::const_iterator p
= pdl
->begin();
4682 if ((*p
)->is_section())
4683 return (*p
)->output_section();
4689 // Return the number of Output_sections in an Output_segment.
4692 Output_segment::output_section_count() const
4694 unsigned int ret
= 0;
4695 for (int i
= 0; i
< static_cast<int>(ORDER_MAX
); ++i
)
4696 ret
+= this->output_section_count_list(&this->output_lists_
[i
]);
4700 // Return the number of Output_sections in an Output_data_list.
4703 Output_segment::output_section_count_list(const Output_data_list
* pdl
) const
4705 unsigned int count
= 0;
4706 for (Output_data_list::const_iterator p
= pdl
->begin();
4710 if ((*p
)->is_section())
4716 // Return the section attached to the list segment with the lowest
4717 // load address. This is used when handling a PHDRS clause in a
4721 Output_segment::section_with_lowest_load_address() const
4723 Output_section
* found
= NULL
;
4724 uint64_t found_lma
= 0;
4725 for (int i
= 0; i
< static_cast<int>(ORDER_MAX
); ++i
)
4726 this->lowest_load_address_in_list(&this->output_lists_
[i
], &found
,
4731 // Look through a list for a section with a lower load address.
4734 Output_segment::lowest_load_address_in_list(const Output_data_list
* pdl
,
4735 Output_section
** found
,
4736 uint64_t* found_lma
) const
4738 for (Output_data_list::const_iterator p
= pdl
->begin();
4742 if (!(*p
)->is_section())
4744 Output_section
* os
= static_cast<Output_section
*>(*p
);
4745 uint64_t lma
= (os
->has_load_address()
4746 ? os
->load_address()
4748 if (*found
== NULL
|| lma
< *found_lma
)
4756 // Write the segment data into *OPHDR.
4758 template<int size
, bool big_endian
>
4760 Output_segment::write_header(elfcpp::Phdr_write
<size
, big_endian
>* ophdr
)
4762 ophdr
->put_p_type(this->type_
);
4763 ophdr
->put_p_offset(this->offset_
);
4764 ophdr
->put_p_vaddr(this->vaddr_
);
4765 ophdr
->put_p_paddr(this->paddr_
);
4766 ophdr
->put_p_filesz(this->filesz_
);
4767 ophdr
->put_p_memsz(this->memsz_
);
4768 ophdr
->put_p_flags(this->flags_
);
4769 ophdr
->put_p_align(std::max(this->min_p_align_
, this->maximum_alignment()));
4772 // Write the section headers into V.
4774 template<int size
, bool big_endian
>
4776 Output_segment::write_section_headers(const Layout
* layout
,
4777 const Stringpool
* secnamepool
,
4779 unsigned int* pshndx
) const
4781 // Every section that is attached to a segment must be attached to a
4782 // PT_LOAD segment, so we only write out section headers for PT_LOAD
4784 if (this->type_
!= elfcpp::PT_LOAD
)
4787 for (int i
= 0; i
< static_cast<int>(ORDER_MAX
); ++i
)
4789 const Output_data_list
* pdl
= &this->output_lists_
[i
];
4790 v
= this->write_section_headers_list
<size
, big_endian
>(layout
,
4799 template<int size
, bool big_endian
>
4801 Output_segment::write_section_headers_list(const Layout
* layout
,
4802 const Stringpool
* secnamepool
,
4803 const Output_data_list
* pdl
,
4805 unsigned int* pshndx
) const
4807 const int shdr_size
= elfcpp::Elf_sizes
<size
>::shdr_size
;
4808 for (Output_data_list::const_iterator p
= pdl
->begin();
4812 if ((*p
)->is_section())
4814 const Output_section
* ps
= static_cast<const Output_section
*>(*p
);
4815 gold_assert(*pshndx
== ps
->out_shndx());
4816 elfcpp::Shdr_write
<size
, big_endian
> oshdr(v
);
4817 ps
->write_header(layout
, secnamepool
, &oshdr
);
4825 // Print the output sections to the map file.
4828 Output_segment::print_sections_to_mapfile(Mapfile
* mapfile
) const
4830 if (this->type() != elfcpp::PT_LOAD
)
4832 for (int i
= 0; i
< static_cast<int>(ORDER_MAX
); ++i
)
4833 this->print_section_list_to_mapfile(mapfile
, &this->output_lists_
[i
]);
4836 // Print an output section list to the map file.
4839 Output_segment::print_section_list_to_mapfile(Mapfile
* mapfile
,
4840 const Output_data_list
* pdl
) const
4842 for (Output_data_list::const_iterator p
= pdl
->begin();
4845 (*p
)->print_to_mapfile(mapfile
);
4848 // Output_file methods.
4850 Output_file::Output_file(const char* name
)
4855 map_is_anonymous_(false),
4856 map_is_allocated_(false),
4857 is_temporary_(false)
4861 // Try to open an existing file. Returns false if the file doesn't
4862 // exist, has a size of 0 or can't be mmapped. If BASE_NAME is not
4863 // NULL, open that file as the base for incremental linking, and
4864 // copy its contents to the new output file. This routine can
4865 // be called for incremental updates, in which case WRITABLE should
4866 // be true, or by the incremental-dump utility, in which case
4867 // WRITABLE should be false.
4870 Output_file::open_base_file(const char* base_name
, bool writable
)
4872 // The name "-" means "stdout".
4873 if (strcmp(this->name_
, "-") == 0)
4876 bool use_base_file
= base_name
!= NULL
;
4878 base_name
= this->name_
;
4879 else if (strcmp(base_name
, this->name_
) == 0)
4880 gold_fatal(_("%s: incremental base and output file name are the same"),
4883 // Don't bother opening files with a size of zero.
4885 if (::stat(base_name
, &s
) != 0)
4887 gold_info(_("%s: stat: %s"), base_name
, strerror(errno
));
4892 gold_info(_("%s: incremental base file is empty"), base_name
);
4896 // If we're using a base file, we want to open it read-only.
4900 int oflags
= writable
? O_RDWR
: O_RDONLY
;
4901 int o
= open_descriptor(-1, base_name
, oflags
, 0);
4904 gold_info(_("%s: open: %s"), base_name
, strerror(errno
));
4908 // If the base file and the output file are different, open a
4909 // new output file and read the contents from the base file into
4910 // the newly-mapped region.
4913 this->open(s
.st_size
);
4914 ssize_t bytes_to_read
= s
.st_size
;
4915 unsigned char* p
= this->base_
;
4916 while (bytes_to_read
> 0)
4918 ssize_t len
= ::read(o
, p
, bytes_to_read
);
4921 gold_info(_("%s: read failed: %s"), base_name
, strerror(errno
));
4926 gold_info(_("%s: file too short: read only %lld of %lld bytes"),
4928 static_cast<long long>(s
.st_size
- bytes_to_read
),
4929 static_cast<long long>(s
.st_size
));
4933 bytes_to_read
-= len
;
4940 this->file_size_
= s
.st_size
;
4942 if (!this->map_no_anonymous(writable
))
4944 release_descriptor(o
, true);
4946 this->file_size_
= 0;
4953 // Open the output file.
4956 Output_file::open(off_t file_size
)
4958 this->file_size_
= file_size
;
4960 // Unlink the file first; otherwise the open() may fail if the file
4961 // is busy (e.g. it's an executable that's currently being executed).
4963 // However, the linker may be part of a system where a zero-length
4964 // file is created for it to write to, with tight permissions (gcc
4965 // 2.95 did something like this). Unlinking the file would work
4966 // around those permission controls, so we only unlink if the file
4967 // has a non-zero size. We also unlink only regular files to avoid
4968 // trouble with directories/etc.
4970 // If we fail, continue; this command is merely a best-effort attempt
4971 // to improve the odds for open().
4973 // We let the name "-" mean "stdout"
4974 if (!this->is_temporary_
)
4976 if (strcmp(this->name_
, "-") == 0)
4977 this->o_
= STDOUT_FILENO
;
4981 if (::stat(this->name_
, &s
) == 0
4982 && (S_ISREG (s
.st_mode
) || S_ISLNK (s
.st_mode
)))
4985 ::unlink(this->name_
);
4986 else if (!parameters
->options().relocatable())
4988 // If we don't unlink the existing file, add execute
4989 // permission where read permissions already exist
4990 // and where the umask permits.
4991 int mask
= ::umask(0);
4993 s
.st_mode
|= (s
.st_mode
& 0444) >> 2;
4994 ::chmod(this->name_
, s
.st_mode
& ~mask
);
4998 int mode
= parameters
->options().relocatable() ? 0666 : 0777;
4999 int o
= open_descriptor(-1, this->name_
, O_RDWR
| O_CREAT
| O_TRUNC
,
5002 gold_fatal(_("%s: open: %s"), this->name_
, strerror(errno
));
5010 // Resize the output file.
5013 Output_file::resize(off_t file_size
)
5015 // If the mmap is mapping an anonymous memory buffer, this is easy:
5016 // just mremap to the new size. If it's mapping to a file, we want
5017 // to unmap to flush to the file, then remap after growing the file.
5018 if (this->map_is_anonymous_
)
5021 if (!this->map_is_allocated_
)
5023 base
= ::mremap(this->base_
, this->file_size_
, file_size
,
5025 if (base
== MAP_FAILED
)
5026 gold_fatal(_("%s: mremap: %s"), this->name_
, strerror(errno
));
5030 base
= realloc(this->base_
, file_size
);
5033 if (file_size
> this->file_size_
)
5034 memset(static_cast<char*>(base
) + this->file_size_
, 0,
5035 file_size
- this->file_size_
);
5037 this->base_
= static_cast<unsigned char*>(base
);
5038 this->file_size_
= file_size
;
5043 this->file_size_
= file_size
;
5044 if (!this->map_no_anonymous(true))
5045 gold_fatal(_("%s: mmap: %s"), this->name_
, strerror(errno
));
5049 // Map an anonymous block of memory which will later be written to the
5050 // file. Return whether the map succeeded.
5053 Output_file::map_anonymous()
5055 void* base
= ::mmap(NULL
, this->file_size_
, PROT_READ
| PROT_WRITE
,
5056 MAP_PRIVATE
| MAP_ANONYMOUS
, -1, 0);
5057 if (base
== MAP_FAILED
)
5059 base
= malloc(this->file_size_
);
5062 memset(base
, 0, this->file_size_
);
5063 this->map_is_allocated_
= true;
5065 this->base_
= static_cast<unsigned char*>(base
);
5066 this->map_is_anonymous_
= true;
5070 // Map the file into memory. Return whether the mapping succeeded.
5071 // If WRITABLE is true, map with write access.
5074 Output_file::map_no_anonymous(bool writable
)
5076 const int o
= this->o_
;
5078 // If the output file is not a regular file, don't try to mmap it;
5079 // instead, we'll mmap a block of memory (an anonymous buffer), and
5080 // then later write the buffer to the file.
5082 struct stat statbuf
;
5083 if (o
== STDOUT_FILENO
|| o
== STDERR_FILENO
5084 || ::fstat(o
, &statbuf
) != 0
5085 || !S_ISREG(statbuf
.st_mode
)
5086 || this->is_temporary_
)
5089 // Ensure that we have disk space available for the file. If we
5090 // don't do this, it is possible that we will call munmap, close,
5091 // and exit with dirty buffers still in the cache with no assigned
5092 // disk blocks. If the disk is out of space at that point, the
5093 // output file will wind up incomplete, but we will have already
5094 // exited. The alternative to fallocate would be to use fdatasync,
5095 // but that would be a more significant performance hit.
5098 int err
= gold_fallocate(o
, 0, this->file_size_
);
5100 gold_fatal(_("%s: %s"), this->name_
, strerror(err
));
5103 // Map the file into memory.
5104 int prot
= PROT_READ
;
5107 base
= ::mmap(NULL
, this->file_size_
, prot
, MAP_SHARED
, o
, 0);
5109 // The mmap call might fail because of file system issues: the file
5110 // system might not support mmap at all, or it might not support
5111 // mmap with PROT_WRITE.
5112 if (base
== MAP_FAILED
)
5115 this->map_is_anonymous_
= false;
5116 this->base_
= static_cast<unsigned char*>(base
);
5120 // Map the file into memory.
5125 if (parameters
->options().mmap_output_file()
5126 && this->map_no_anonymous(true))
5129 // The mmap call might fail because of file system issues: the file
5130 // system might not support mmap at all, or it might not support
5131 // mmap with PROT_WRITE. I'm not sure which errno values we will
5132 // see in all cases, so if the mmap fails for any reason and we
5133 // don't care about file contents, try for an anonymous map.
5134 if (this->map_anonymous())
5137 gold_fatal(_("%s: mmap: failed to allocate %lu bytes for output file: %s"),
5138 this->name_
, static_cast<unsigned long>(this->file_size_
),
5142 // Unmap the file from memory.
5145 Output_file::unmap()
5147 if (this->map_is_anonymous_
)
5149 // We've already written out the data, so there is no reason to
5150 // waste time unmapping or freeing the memory.
5154 if (::munmap(this->base_
, this->file_size_
) < 0)
5155 gold_error(_("%s: munmap: %s"), this->name_
, strerror(errno
));
5160 // Close the output file.
5163 Output_file::close()
5165 // If the map isn't file-backed, we need to write it now.
5166 if (this->map_is_anonymous_
&& !this->is_temporary_
)
5168 size_t bytes_to_write
= this->file_size_
;
5170 while (bytes_to_write
> 0)
5172 ssize_t bytes_written
= ::write(this->o_
, this->base_
+ offset
,
5174 if (bytes_written
== 0)
5175 gold_error(_("%s: write: unexpected 0 return-value"), this->name_
);
5176 else if (bytes_written
< 0)
5177 gold_error(_("%s: write: %s"), this->name_
, strerror(errno
));
5180 bytes_to_write
-= bytes_written
;
5181 offset
+= bytes_written
;
5187 // We don't close stdout or stderr
5188 if (this->o_
!= STDOUT_FILENO
5189 && this->o_
!= STDERR_FILENO
5190 && !this->is_temporary_
)
5191 if (::close(this->o_
) < 0)
5192 gold_error(_("%s: close: %s"), this->name_
, strerror(errno
));
5196 // Instantiate the templates we need. We could use the configure
5197 // script to restrict this to only the ones for implemented targets.
5199 #ifdef HAVE_TARGET_32_LITTLE
5202 Output_section::add_input_section
<32, false>(
5204 Sized_relobj_file
<32, false>* object
,
5206 const char* secname
,
5207 const elfcpp::Shdr
<32, false>& shdr
,
5208 unsigned int reloc_shndx
,
5209 bool have_sections_script
);
5212 #ifdef HAVE_TARGET_32_BIG
5215 Output_section::add_input_section
<32, true>(
5217 Sized_relobj_file
<32, true>* object
,
5219 const char* secname
,
5220 const elfcpp::Shdr
<32, true>& shdr
,
5221 unsigned int reloc_shndx
,
5222 bool have_sections_script
);
5225 #ifdef HAVE_TARGET_64_LITTLE
5228 Output_section::add_input_section
<64, false>(
5230 Sized_relobj_file
<64, false>* object
,
5232 const char* secname
,
5233 const elfcpp::Shdr
<64, false>& shdr
,
5234 unsigned int reloc_shndx
,
5235 bool have_sections_script
);
5238 #ifdef HAVE_TARGET_64_BIG
5241 Output_section::add_input_section
<64, true>(
5243 Sized_relobj_file
<64, true>* object
,
5245 const char* secname
,
5246 const elfcpp::Shdr
<64, true>& shdr
,
5247 unsigned int reloc_shndx
,
5248 bool have_sections_script
);
5251 #ifdef HAVE_TARGET_32_LITTLE
5253 class Output_reloc
<elfcpp::SHT_REL
, false, 32, false>;
5256 #ifdef HAVE_TARGET_32_BIG
5258 class Output_reloc
<elfcpp::SHT_REL
, false, 32, true>;
5261 #ifdef HAVE_TARGET_64_LITTLE
5263 class Output_reloc
<elfcpp::SHT_REL
, false, 64, false>;
5266 #ifdef HAVE_TARGET_64_BIG
5268 class Output_reloc
<elfcpp::SHT_REL
, false, 64, true>;
5271 #ifdef HAVE_TARGET_32_LITTLE
5273 class Output_reloc
<elfcpp::SHT_REL
, true, 32, false>;
5276 #ifdef HAVE_TARGET_32_BIG
5278 class Output_reloc
<elfcpp::SHT_REL
, true, 32, true>;
5281 #ifdef HAVE_TARGET_64_LITTLE
5283 class Output_reloc
<elfcpp::SHT_REL
, true, 64, false>;
5286 #ifdef HAVE_TARGET_64_BIG
5288 class Output_reloc
<elfcpp::SHT_REL
, true, 64, true>;
5291 #ifdef HAVE_TARGET_32_LITTLE
5293 class Output_reloc
<elfcpp::SHT_RELA
, false, 32, false>;
5296 #ifdef HAVE_TARGET_32_BIG
5298 class Output_reloc
<elfcpp::SHT_RELA
, false, 32, true>;
5301 #ifdef HAVE_TARGET_64_LITTLE
5303 class Output_reloc
<elfcpp::SHT_RELA
, false, 64, false>;
5306 #ifdef HAVE_TARGET_64_BIG
5308 class Output_reloc
<elfcpp::SHT_RELA
, false, 64, true>;
5311 #ifdef HAVE_TARGET_32_LITTLE
5313 class Output_reloc
<elfcpp::SHT_RELA
, true, 32, false>;
5316 #ifdef HAVE_TARGET_32_BIG
5318 class Output_reloc
<elfcpp::SHT_RELA
, true, 32, true>;
5321 #ifdef HAVE_TARGET_64_LITTLE
5323 class Output_reloc
<elfcpp::SHT_RELA
, true, 64, false>;
5326 #ifdef HAVE_TARGET_64_BIG
5328 class Output_reloc
<elfcpp::SHT_RELA
, true, 64, true>;
5331 #ifdef HAVE_TARGET_32_LITTLE
5333 class Output_data_reloc
<elfcpp::SHT_REL
, false, 32, false>;
5336 #ifdef HAVE_TARGET_32_BIG
5338 class Output_data_reloc
<elfcpp::SHT_REL
, false, 32, true>;
5341 #ifdef HAVE_TARGET_64_LITTLE
5343 class Output_data_reloc
<elfcpp::SHT_REL
, false, 64, false>;
5346 #ifdef HAVE_TARGET_64_BIG
5348 class Output_data_reloc
<elfcpp::SHT_REL
, false, 64, true>;
5351 #ifdef HAVE_TARGET_32_LITTLE
5353 class Output_data_reloc
<elfcpp::SHT_REL
, true, 32, false>;
5356 #ifdef HAVE_TARGET_32_BIG
5358 class Output_data_reloc
<elfcpp::SHT_REL
, true, 32, true>;
5361 #ifdef HAVE_TARGET_64_LITTLE
5363 class Output_data_reloc
<elfcpp::SHT_REL
, true, 64, false>;
5366 #ifdef HAVE_TARGET_64_BIG
5368 class Output_data_reloc
<elfcpp::SHT_REL
, true, 64, true>;
5371 #ifdef HAVE_TARGET_32_LITTLE
5373 class Output_data_reloc
<elfcpp::SHT_RELA
, false, 32, false>;
5376 #ifdef HAVE_TARGET_32_BIG
5378 class Output_data_reloc
<elfcpp::SHT_RELA
, false, 32, true>;
5381 #ifdef HAVE_TARGET_64_LITTLE
5383 class Output_data_reloc
<elfcpp::SHT_RELA
, false, 64, false>;
5386 #ifdef HAVE_TARGET_64_BIG
5388 class Output_data_reloc
<elfcpp::SHT_RELA
, false, 64, true>;
5391 #ifdef HAVE_TARGET_32_LITTLE
5393 class Output_data_reloc
<elfcpp::SHT_RELA
, true, 32, false>;
5396 #ifdef HAVE_TARGET_32_BIG
5398 class Output_data_reloc
<elfcpp::SHT_RELA
, true, 32, true>;
5401 #ifdef HAVE_TARGET_64_LITTLE
5403 class Output_data_reloc
<elfcpp::SHT_RELA
, true, 64, false>;
5406 #ifdef HAVE_TARGET_64_BIG
5408 class Output_data_reloc
<elfcpp::SHT_RELA
, true, 64, true>;
5411 #ifdef HAVE_TARGET_32_LITTLE
5413 class Output_relocatable_relocs
<elfcpp::SHT_REL
, 32, false>;
5416 #ifdef HAVE_TARGET_32_BIG
5418 class Output_relocatable_relocs
<elfcpp::SHT_REL
, 32, true>;
5421 #ifdef HAVE_TARGET_64_LITTLE
5423 class Output_relocatable_relocs
<elfcpp::SHT_REL
, 64, false>;
5426 #ifdef HAVE_TARGET_64_BIG
5428 class Output_relocatable_relocs
<elfcpp::SHT_REL
, 64, true>;
5431 #ifdef HAVE_TARGET_32_LITTLE
5433 class Output_relocatable_relocs
<elfcpp::SHT_RELA
, 32, false>;
5436 #ifdef HAVE_TARGET_32_BIG
5438 class Output_relocatable_relocs
<elfcpp::SHT_RELA
, 32, true>;
5441 #ifdef HAVE_TARGET_64_LITTLE
5443 class Output_relocatable_relocs
<elfcpp::SHT_RELA
, 64, false>;
5446 #ifdef HAVE_TARGET_64_BIG
5448 class Output_relocatable_relocs
<elfcpp::SHT_RELA
, 64, true>;
5451 #ifdef HAVE_TARGET_32_LITTLE
5453 class Output_data_group
<32, false>;
5456 #ifdef HAVE_TARGET_32_BIG
5458 class Output_data_group
<32, true>;
5461 #ifdef HAVE_TARGET_64_LITTLE
5463 class Output_data_group
<64, false>;
5466 #ifdef HAVE_TARGET_64_BIG
5468 class Output_data_group
<64, true>;
5472 class Output_data_got
<32, false>;
5475 class Output_data_got
<32, true>;
5478 class Output_data_got
<64, false>;
5481 class Output_data_got
<64, true>;
5483 } // End namespace gold.