Update gas/i386/ilp32/x86-64-arch-2.d.
[binutils.git] / gold / output.cc
blob1158a77661c0893b55bf469d6b17b5f19f562de6
1 // output.cc -- manage the output file for gold
3 // Copyright 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
4 // Written by Ian Lance Taylor <iant@google.com>.
6 // This file is part of gold.
8 // This program is free software; you can redistribute it and/or modify
9 // it under the terms of the GNU General Public License as published by
10 // the Free Software Foundation; either version 3 of the License, or
11 // (at your option) any later version.
13 // This program is distributed in the hope that it will be useful,
14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 // GNU General Public License for more details.
18 // You should have received a copy of the GNU General Public License
19 // along with this program; if not, write to the Free Software
20 // Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 // MA 02110-1301, USA.
23 #include "gold.h"
25 #include <cstdlib>
26 #include <cstring>
27 #include <cerrno>
28 #include <fcntl.h>
29 #include <unistd.h>
30 #include <sys/mman.h>
31 #include <sys/stat.h>
32 #include <algorithm>
33 #include "libiberty.h"
35 #include "parameters.h"
36 #include "object.h"
37 #include "symtab.h"
38 #include "reloc.h"
39 #include "merge.h"
40 #include "descriptors.h"
41 #include "output.h"
43 // Some BSD systems still use MAP_ANON instead of MAP_ANONYMOUS
44 #ifndef MAP_ANONYMOUS
45 # define MAP_ANONYMOUS MAP_ANON
46 #endif
48 #ifndef HAVE_POSIX_FALLOCATE
49 // A dummy, non general, version of posix_fallocate. Here we just set
50 // the file size and hope that there is enough disk space. FIXME: We
51 // could allocate disk space by walking block by block and writing a
52 // zero byte into each block.
53 static int
54 posix_fallocate(int o, off_t offset, off_t len)
56 return ftruncate(o, offset + len);
58 #endif // !defined(HAVE_POSIX_FALLOCATE)
60 namespace gold
63 // Output_data variables.
65 bool Output_data::allocated_sizes_are_fixed;
67 // Output_data methods.
69 Output_data::~Output_data()
73 // Return the default alignment for the target size.
75 uint64_t
76 Output_data::default_alignment()
78 return Output_data::default_alignment_for_size(
79 parameters->target().get_size());
82 // Return the default alignment for a size--32 or 64.
84 uint64_t
85 Output_data::default_alignment_for_size(int size)
87 if (size == 32)
88 return 4;
89 else if (size == 64)
90 return 8;
91 else
92 gold_unreachable();
95 // Output_section_header methods. This currently assumes that the
96 // segment and section lists are complete at construction time.
98 Output_section_headers::Output_section_headers(
99 const Layout* layout,
100 const Layout::Segment_list* segment_list,
101 const Layout::Section_list* section_list,
102 const Layout::Section_list* unattached_section_list,
103 const Stringpool* secnamepool,
104 const Output_section* shstrtab_section)
105 : layout_(layout),
106 segment_list_(segment_list),
107 section_list_(section_list),
108 unattached_section_list_(unattached_section_list),
109 secnamepool_(secnamepool),
110 shstrtab_section_(shstrtab_section)
114 // Compute the current data size.
116 off_t
117 Output_section_headers::do_size() const
119 // Count all the sections. Start with 1 for the null section.
120 off_t count = 1;
121 if (!parameters->options().relocatable())
123 for (Layout::Segment_list::const_iterator p =
124 this->segment_list_->begin();
125 p != this->segment_list_->end();
126 ++p)
127 if ((*p)->type() == elfcpp::PT_LOAD)
128 count += (*p)->output_section_count();
130 else
132 for (Layout::Section_list::const_iterator p =
133 this->section_list_->begin();
134 p != this->section_list_->end();
135 ++p)
136 if (((*p)->flags() & elfcpp::SHF_ALLOC) != 0)
137 ++count;
139 count += this->unattached_section_list_->size();
141 const int size = parameters->target().get_size();
142 int shdr_size;
143 if (size == 32)
144 shdr_size = elfcpp::Elf_sizes<32>::shdr_size;
145 else if (size == 64)
146 shdr_size = elfcpp::Elf_sizes<64>::shdr_size;
147 else
148 gold_unreachable();
150 return count * shdr_size;
153 // Write out the section headers.
155 void
156 Output_section_headers::do_write(Output_file* of)
158 switch (parameters->size_and_endianness())
160 #ifdef HAVE_TARGET_32_LITTLE
161 case Parameters::TARGET_32_LITTLE:
162 this->do_sized_write<32, false>(of);
163 break;
164 #endif
165 #ifdef HAVE_TARGET_32_BIG
166 case Parameters::TARGET_32_BIG:
167 this->do_sized_write<32, true>(of);
168 break;
169 #endif
170 #ifdef HAVE_TARGET_64_LITTLE
171 case Parameters::TARGET_64_LITTLE:
172 this->do_sized_write<64, false>(of);
173 break;
174 #endif
175 #ifdef HAVE_TARGET_64_BIG
176 case Parameters::TARGET_64_BIG:
177 this->do_sized_write<64, true>(of);
178 break;
179 #endif
180 default:
181 gold_unreachable();
185 template<int size, bool big_endian>
186 void
187 Output_section_headers::do_sized_write(Output_file* of)
189 off_t all_shdrs_size = this->data_size();
190 unsigned char* view = of->get_output_view(this->offset(), all_shdrs_size);
192 const int shdr_size = elfcpp::Elf_sizes<size>::shdr_size;
193 unsigned char* v = view;
196 typename elfcpp::Shdr_write<size, big_endian> oshdr(v);
197 oshdr.put_sh_name(0);
198 oshdr.put_sh_type(elfcpp::SHT_NULL);
199 oshdr.put_sh_flags(0);
200 oshdr.put_sh_addr(0);
201 oshdr.put_sh_offset(0);
203 size_t section_count = (this->data_size()
204 / elfcpp::Elf_sizes<size>::shdr_size);
205 if (section_count < elfcpp::SHN_LORESERVE)
206 oshdr.put_sh_size(0);
207 else
208 oshdr.put_sh_size(section_count);
210 unsigned int shstrndx = this->shstrtab_section_->out_shndx();
211 if (shstrndx < elfcpp::SHN_LORESERVE)
212 oshdr.put_sh_link(0);
213 else
214 oshdr.put_sh_link(shstrndx);
216 size_t segment_count = this->segment_list_->size();
217 oshdr.put_sh_info(segment_count >= elfcpp::PN_XNUM ? segment_count : 0);
219 oshdr.put_sh_addralign(0);
220 oshdr.put_sh_entsize(0);
223 v += shdr_size;
225 unsigned int shndx = 1;
226 if (!parameters->options().relocatable())
228 for (Layout::Segment_list::const_iterator p =
229 this->segment_list_->begin();
230 p != this->segment_list_->end();
231 ++p)
232 v = (*p)->write_section_headers<size, big_endian>(this->layout_,
233 this->secnamepool_,
235 &shndx);
237 else
239 for (Layout::Section_list::const_iterator p =
240 this->section_list_->begin();
241 p != this->section_list_->end();
242 ++p)
244 // We do unallocated sections below, except that group
245 // sections have to come first.
246 if (((*p)->flags() & elfcpp::SHF_ALLOC) == 0
247 && (*p)->type() != elfcpp::SHT_GROUP)
248 continue;
249 gold_assert(shndx == (*p)->out_shndx());
250 elfcpp::Shdr_write<size, big_endian> oshdr(v);
251 (*p)->write_header(this->layout_, this->secnamepool_, &oshdr);
252 v += shdr_size;
253 ++shndx;
257 for (Layout::Section_list::const_iterator p =
258 this->unattached_section_list_->begin();
259 p != this->unattached_section_list_->end();
260 ++p)
262 // For a relocatable link, we did unallocated group sections
263 // above, since they have to come first.
264 if ((*p)->type() == elfcpp::SHT_GROUP
265 && parameters->options().relocatable())
266 continue;
267 gold_assert(shndx == (*p)->out_shndx());
268 elfcpp::Shdr_write<size, big_endian> oshdr(v);
269 (*p)->write_header(this->layout_, this->secnamepool_, &oshdr);
270 v += shdr_size;
271 ++shndx;
274 of->write_output_view(this->offset(), all_shdrs_size, view);
277 // Output_segment_header methods.
279 Output_segment_headers::Output_segment_headers(
280 const Layout::Segment_list& segment_list)
281 : segment_list_(segment_list)
285 void
286 Output_segment_headers::do_write(Output_file* of)
288 switch (parameters->size_and_endianness())
290 #ifdef HAVE_TARGET_32_LITTLE
291 case Parameters::TARGET_32_LITTLE:
292 this->do_sized_write<32, false>(of);
293 break;
294 #endif
295 #ifdef HAVE_TARGET_32_BIG
296 case Parameters::TARGET_32_BIG:
297 this->do_sized_write<32, true>(of);
298 break;
299 #endif
300 #ifdef HAVE_TARGET_64_LITTLE
301 case Parameters::TARGET_64_LITTLE:
302 this->do_sized_write<64, false>(of);
303 break;
304 #endif
305 #ifdef HAVE_TARGET_64_BIG
306 case Parameters::TARGET_64_BIG:
307 this->do_sized_write<64, true>(of);
308 break;
309 #endif
310 default:
311 gold_unreachable();
315 template<int size, bool big_endian>
316 void
317 Output_segment_headers::do_sized_write(Output_file* of)
319 const int phdr_size = elfcpp::Elf_sizes<size>::phdr_size;
320 off_t all_phdrs_size = this->segment_list_.size() * phdr_size;
321 gold_assert(all_phdrs_size == this->data_size());
322 unsigned char* view = of->get_output_view(this->offset(),
323 all_phdrs_size);
324 unsigned char* v = view;
325 for (Layout::Segment_list::const_iterator p = this->segment_list_.begin();
326 p != this->segment_list_.end();
327 ++p)
329 elfcpp::Phdr_write<size, big_endian> ophdr(v);
330 (*p)->write_header(&ophdr);
331 v += phdr_size;
334 gold_assert(v - view == all_phdrs_size);
336 of->write_output_view(this->offset(), all_phdrs_size, view);
339 off_t
340 Output_segment_headers::do_size() const
342 const int size = parameters->target().get_size();
343 int phdr_size;
344 if (size == 32)
345 phdr_size = elfcpp::Elf_sizes<32>::phdr_size;
346 else if (size == 64)
347 phdr_size = elfcpp::Elf_sizes<64>::phdr_size;
348 else
349 gold_unreachable();
351 return this->segment_list_.size() * phdr_size;
354 // Output_file_header methods.
356 Output_file_header::Output_file_header(const Target* target,
357 const Symbol_table* symtab,
358 const Output_segment_headers* osh,
359 const char* entry)
360 : target_(target),
361 symtab_(symtab),
362 segment_header_(osh),
363 section_header_(NULL),
364 shstrtab_(NULL),
365 entry_(entry)
367 this->set_data_size(this->do_size());
370 // Set the section table information for a file header.
372 void
373 Output_file_header::set_section_info(const Output_section_headers* shdrs,
374 const Output_section* shstrtab)
376 this->section_header_ = shdrs;
377 this->shstrtab_ = shstrtab;
380 // Write out the file header.
382 void
383 Output_file_header::do_write(Output_file* of)
385 gold_assert(this->offset() == 0);
387 switch (parameters->size_and_endianness())
389 #ifdef HAVE_TARGET_32_LITTLE
390 case Parameters::TARGET_32_LITTLE:
391 this->do_sized_write<32, false>(of);
392 break;
393 #endif
394 #ifdef HAVE_TARGET_32_BIG
395 case Parameters::TARGET_32_BIG:
396 this->do_sized_write<32, true>(of);
397 break;
398 #endif
399 #ifdef HAVE_TARGET_64_LITTLE
400 case Parameters::TARGET_64_LITTLE:
401 this->do_sized_write<64, false>(of);
402 break;
403 #endif
404 #ifdef HAVE_TARGET_64_BIG
405 case Parameters::TARGET_64_BIG:
406 this->do_sized_write<64, true>(of);
407 break;
408 #endif
409 default:
410 gold_unreachable();
414 // Write out the file header with appropriate size and endianess.
416 template<int size, bool big_endian>
417 void
418 Output_file_header::do_sized_write(Output_file* of)
420 gold_assert(this->offset() == 0);
422 int ehdr_size = elfcpp::Elf_sizes<size>::ehdr_size;
423 unsigned char* view = of->get_output_view(0, ehdr_size);
424 elfcpp::Ehdr_write<size, big_endian> oehdr(view);
426 unsigned char e_ident[elfcpp::EI_NIDENT];
427 memset(e_ident, 0, elfcpp::EI_NIDENT);
428 e_ident[elfcpp::EI_MAG0] = elfcpp::ELFMAG0;
429 e_ident[elfcpp::EI_MAG1] = elfcpp::ELFMAG1;
430 e_ident[elfcpp::EI_MAG2] = elfcpp::ELFMAG2;
431 e_ident[elfcpp::EI_MAG3] = elfcpp::ELFMAG3;
432 if (size == 32)
433 e_ident[elfcpp::EI_CLASS] = elfcpp::ELFCLASS32;
434 else if (size == 64)
435 e_ident[elfcpp::EI_CLASS] = elfcpp::ELFCLASS64;
436 else
437 gold_unreachable();
438 e_ident[elfcpp::EI_DATA] = (big_endian
439 ? elfcpp::ELFDATA2MSB
440 : elfcpp::ELFDATA2LSB);
441 e_ident[elfcpp::EI_VERSION] = elfcpp::EV_CURRENT;
442 oehdr.put_e_ident(e_ident);
444 elfcpp::ET e_type;
445 if (parameters->options().relocatable())
446 e_type = elfcpp::ET_REL;
447 else if (parameters->options().output_is_position_independent())
448 e_type = elfcpp::ET_DYN;
449 else
450 e_type = elfcpp::ET_EXEC;
451 oehdr.put_e_type(e_type);
453 oehdr.put_e_machine(this->target_->machine_code());
454 oehdr.put_e_version(elfcpp::EV_CURRENT);
456 oehdr.put_e_entry(this->entry<size>());
458 if (this->segment_header_ == NULL)
459 oehdr.put_e_phoff(0);
460 else
461 oehdr.put_e_phoff(this->segment_header_->offset());
463 oehdr.put_e_shoff(this->section_header_->offset());
464 oehdr.put_e_flags(this->target_->processor_specific_flags());
465 oehdr.put_e_ehsize(elfcpp::Elf_sizes<size>::ehdr_size);
467 if (this->segment_header_ == NULL)
469 oehdr.put_e_phentsize(0);
470 oehdr.put_e_phnum(0);
472 else
474 oehdr.put_e_phentsize(elfcpp::Elf_sizes<size>::phdr_size);
475 size_t phnum = (this->segment_header_->data_size()
476 / elfcpp::Elf_sizes<size>::phdr_size);
477 if (phnum > elfcpp::PN_XNUM)
478 phnum = elfcpp::PN_XNUM;
479 oehdr.put_e_phnum(phnum);
482 oehdr.put_e_shentsize(elfcpp::Elf_sizes<size>::shdr_size);
483 size_t section_count = (this->section_header_->data_size()
484 / elfcpp::Elf_sizes<size>::shdr_size);
486 if (section_count < elfcpp::SHN_LORESERVE)
487 oehdr.put_e_shnum(this->section_header_->data_size()
488 / elfcpp::Elf_sizes<size>::shdr_size);
489 else
490 oehdr.put_e_shnum(0);
492 unsigned int shstrndx = this->shstrtab_->out_shndx();
493 if (shstrndx < elfcpp::SHN_LORESERVE)
494 oehdr.put_e_shstrndx(this->shstrtab_->out_shndx());
495 else
496 oehdr.put_e_shstrndx(elfcpp::SHN_XINDEX);
498 // Let the target adjust the ELF header, e.g., to set EI_OSABI in
499 // the e_ident field.
500 parameters->target().adjust_elf_header(view, ehdr_size);
502 of->write_output_view(0, ehdr_size, view);
505 // Return the value to use for the entry address. THIS->ENTRY_ is the
506 // symbol specified on the command line, if any.
508 template<int size>
509 typename elfcpp::Elf_types<size>::Elf_Addr
510 Output_file_header::entry()
512 const bool should_issue_warning = (this->entry_ != NULL
513 && !parameters->options().relocatable()
514 && !parameters->options().shared());
516 // FIXME: Need to support target specific entry symbol.
517 const char* entry = this->entry_;
518 if (entry == NULL)
519 entry = "_start";
521 Symbol* sym = this->symtab_->lookup(entry);
523 typename Sized_symbol<size>::Value_type v;
524 if (sym != NULL)
526 Sized_symbol<size>* ssym;
527 ssym = this->symtab_->get_sized_symbol<size>(sym);
528 if (!ssym->is_defined() && should_issue_warning)
529 gold_warning("entry symbol '%s' exists but is not defined", entry);
530 v = ssym->value();
532 else
534 // We couldn't find the entry symbol. See if we can parse it as
535 // a number. This supports, e.g., -e 0x1000.
536 char* endptr;
537 v = strtoull(entry, &endptr, 0);
538 if (*endptr != '\0')
540 if (should_issue_warning)
541 gold_warning("cannot find entry symbol '%s'", entry);
542 v = 0;
546 return v;
549 // Compute the current data size.
551 off_t
552 Output_file_header::do_size() const
554 const int size = parameters->target().get_size();
555 if (size == 32)
556 return elfcpp::Elf_sizes<32>::ehdr_size;
557 else if (size == 64)
558 return elfcpp::Elf_sizes<64>::ehdr_size;
559 else
560 gold_unreachable();
563 // Output_data_const methods.
565 void
566 Output_data_const::do_write(Output_file* of)
568 of->write(this->offset(), this->data_.data(), this->data_.size());
571 // Output_data_const_buffer methods.
573 void
574 Output_data_const_buffer::do_write(Output_file* of)
576 of->write(this->offset(), this->p_, this->data_size());
579 // Output_section_data methods.
581 // Record the output section, and set the entry size and such.
583 void
584 Output_section_data::set_output_section(Output_section* os)
586 gold_assert(this->output_section_ == NULL);
587 this->output_section_ = os;
588 this->do_adjust_output_section(os);
591 // Return the section index of the output section.
593 unsigned int
594 Output_section_data::do_out_shndx() const
596 gold_assert(this->output_section_ != NULL);
597 return this->output_section_->out_shndx();
600 // Set the alignment, which means we may need to update the alignment
601 // of the output section.
603 void
604 Output_section_data::set_addralign(uint64_t addralign)
606 this->addralign_ = addralign;
607 if (this->output_section_ != NULL
608 && this->output_section_->addralign() < addralign)
609 this->output_section_->set_addralign(addralign);
612 // Output_data_strtab methods.
614 // Set the final data size.
616 void
617 Output_data_strtab::set_final_data_size()
619 this->strtab_->set_string_offsets();
620 this->set_data_size(this->strtab_->get_strtab_size());
623 // Write out a string table.
625 void
626 Output_data_strtab::do_write(Output_file* of)
628 this->strtab_->write(of, this->offset());
631 // Output_reloc methods.
633 // A reloc against a global symbol.
635 template<bool dynamic, int size, bool big_endian>
636 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc(
637 Symbol* gsym,
638 unsigned int type,
639 Output_data* od,
640 Address address,
641 bool is_relative,
642 bool is_symbolless)
643 : address_(address), local_sym_index_(GSYM_CODE), type_(type),
644 is_relative_(is_relative), is_symbolless_(is_symbolless),
645 is_section_symbol_(false), shndx_(INVALID_CODE)
647 // this->type_ is a bitfield; make sure TYPE fits.
648 gold_assert(this->type_ == type);
649 this->u1_.gsym = gsym;
650 this->u2_.od = od;
651 if (dynamic)
652 this->set_needs_dynsym_index();
655 template<bool dynamic, int size, bool big_endian>
656 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc(
657 Symbol* gsym,
658 unsigned int type,
659 Sized_relobj<size, big_endian>* relobj,
660 unsigned int shndx,
661 Address address,
662 bool is_relative,
663 bool is_symbolless)
664 : address_(address), local_sym_index_(GSYM_CODE), type_(type),
665 is_relative_(is_relative), is_symbolless_(is_symbolless),
666 is_section_symbol_(false), shndx_(shndx)
668 gold_assert(shndx != INVALID_CODE);
669 // this->type_ is a bitfield; make sure TYPE fits.
670 gold_assert(this->type_ == type);
671 this->u1_.gsym = gsym;
672 this->u2_.relobj = relobj;
673 if (dynamic)
674 this->set_needs_dynsym_index();
677 // A reloc against a local symbol.
679 template<bool dynamic, int size, bool big_endian>
680 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc(
681 Sized_relobj<size, big_endian>* relobj,
682 unsigned int local_sym_index,
683 unsigned int type,
684 Output_data* od,
685 Address address,
686 bool is_relative,
687 bool is_symbolless,
688 bool is_section_symbol)
689 : address_(address), local_sym_index_(local_sym_index), type_(type),
690 is_relative_(is_relative), is_symbolless_(is_symbolless),
691 is_section_symbol_(is_section_symbol), shndx_(INVALID_CODE)
693 gold_assert(local_sym_index != GSYM_CODE
694 && local_sym_index != INVALID_CODE);
695 // this->type_ is a bitfield; make sure TYPE fits.
696 gold_assert(this->type_ == type);
697 this->u1_.relobj = relobj;
698 this->u2_.od = od;
699 if (dynamic)
700 this->set_needs_dynsym_index();
703 template<bool dynamic, int size, bool big_endian>
704 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc(
705 Sized_relobj<size, big_endian>* relobj,
706 unsigned int local_sym_index,
707 unsigned int type,
708 unsigned int shndx,
709 Address address,
710 bool is_relative,
711 bool is_symbolless,
712 bool is_section_symbol)
713 : address_(address), local_sym_index_(local_sym_index), type_(type),
714 is_relative_(is_relative), is_symbolless_(is_symbolless),
715 is_section_symbol_(is_section_symbol), shndx_(shndx)
717 gold_assert(local_sym_index != GSYM_CODE
718 && local_sym_index != INVALID_CODE);
719 gold_assert(shndx != INVALID_CODE);
720 // this->type_ is a bitfield; make sure TYPE fits.
721 gold_assert(this->type_ == type);
722 this->u1_.relobj = relobj;
723 this->u2_.relobj = relobj;
724 if (dynamic)
725 this->set_needs_dynsym_index();
728 // A reloc against the STT_SECTION symbol of an output section.
730 template<bool dynamic, int size, bool big_endian>
731 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc(
732 Output_section* os,
733 unsigned int type,
734 Output_data* od,
735 Address address)
736 : address_(address), local_sym_index_(SECTION_CODE), type_(type),
737 is_relative_(false), is_symbolless_(false),
738 is_section_symbol_(true), shndx_(INVALID_CODE)
740 // this->type_ is a bitfield; make sure TYPE fits.
741 gold_assert(this->type_ == type);
742 this->u1_.os = os;
743 this->u2_.od = od;
744 if (dynamic)
745 this->set_needs_dynsym_index();
746 else
747 os->set_needs_symtab_index();
750 template<bool dynamic, int size, bool big_endian>
751 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc(
752 Output_section* os,
753 unsigned int type,
754 Sized_relobj<size, big_endian>* relobj,
755 unsigned int shndx,
756 Address address)
757 : address_(address), local_sym_index_(SECTION_CODE), type_(type),
758 is_relative_(false), is_symbolless_(false),
759 is_section_symbol_(true), shndx_(shndx)
761 gold_assert(shndx != INVALID_CODE);
762 // this->type_ is a bitfield; make sure TYPE fits.
763 gold_assert(this->type_ == type);
764 this->u1_.os = os;
765 this->u2_.relobj = relobj;
766 if (dynamic)
767 this->set_needs_dynsym_index();
768 else
769 os->set_needs_symtab_index();
772 // An absolute relocation.
774 template<bool dynamic, int size, bool big_endian>
775 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc(
776 unsigned int type,
777 Output_data* od,
778 Address address)
779 : address_(address), local_sym_index_(0), type_(type),
780 is_relative_(false), is_symbolless_(false),
781 is_section_symbol_(false), shndx_(INVALID_CODE)
783 // this->type_ is a bitfield; make sure TYPE fits.
784 gold_assert(this->type_ == type);
785 this->u1_.relobj = NULL;
786 this->u2_.od = od;
789 template<bool dynamic, int size, bool big_endian>
790 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc(
791 unsigned int type,
792 Sized_relobj<size, big_endian>* relobj,
793 unsigned int shndx,
794 Address address)
795 : address_(address), local_sym_index_(0), type_(type),
796 is_relative_(false), is_symbolless_(false),
797 is_section_symbol_(false), shndx_(shndx)
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 = NULL;
803 this->u2_.relobj = relobj;
806 // A target specific relocation.
808 template<bool dynamic, int size, bool big_endian>
809 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc(
810 unsigned int type,
811 void* arg,
812 Output_data* od,
813 Address address)
814 : address_(address), local_sym_index_(TARGET_CODE), type_(type),
815 is_relative_(false), is_symbolless_(false),
816 is_section_symbol_(false), shndx_(INVALID_CODE)
818 // this->type_ is a bitfield; make sure TYPE fits.
819 gold_assert(this->type_ == type);
820 this->u1_.arg = arg;
821 this->u2_.od = od;
824 template<bool dynamic, int size, bool big_endian>
825 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc(
826 unsigned int type,
827 void* arg,
828 Sized_relobj<size, big_endian>* relobj,
829 unsigned int shndx,
830 Address address)
831 : address_(address), local_sym_index_(TARGET_CODE), type_(type),
832 is_relative_(false), is_symbolless_(false),
833 is_section_symbol_(false), shndx_(shndx)
835 gold_assert(shndx != INVALID_CODE);
836 // this->type_ is a bitfield; make sure TYPE fits.
837 gold_assert(this->type_ == type);
838 this->u1_.arg = arg;
839 this->u2_.relobj = relobj;
842 // Record that we need a dynamic symbol index for this relocation.
844 template<bool dynamic, int size, bool big_endian>
845 void
846 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::
847 set_needs_dynsym_index()
849 if (this->is_symbolless_)
850 return;
851 switch (this->local_sym_index_)
853 case INVALID_CODE:
854 gold_unreachable();
856 case GSYM_CODE:
857 this->u1_.gsym->set_needs_dynsym_entry();
858 break;
860 case SECTION_CODE:
861 this->u1_.os->set_needs_dynsym_index();
862 break;
864 case TARGET_CODE:
865 // The target must take care of this if necessary.
866 break;
868 case 0:
869 break;
871 default:
873 const unsigned int lsi = this->local_sym_index_;
874 if (!this->is_section_symbol_)
875 this->u1_.relobj->set_needs_output_dynsym_entry(lsi);
876 else
877 this->u1_.relobj->output_section(lsi)->set_needs_dynsym_index();
879 break;
883 // Get the symbol index of a relocation.
885 template<bool dynamic, int size, bool big_endian>
886 unsigned int
887 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::get_symbol_index()
888 const
890 unsigned int index;
891 if (this->is_symbolless_)
892 return 0;
893 switch (this->local_sym_index_)
895 case INVALID_CODE:
896 gold_unreachable();
898 case GSYM_CODE:
899 if (this->u1_.gsym == NULL)
900 index = 0;
901 else if (dynamic)
902 index = this->u1_.gsym->dynsym_index();
903 else
904 index = this->u1_.gsym->symtab_index();
905 break;
907 case SECTION_CODE:
908 if (dynamic)
909 index = this->u1_.os->dynsym_index();
910 else
911 index = this->u1_.os->symtab_index();
912 break;
914 case TARGET_CODE:
915 index = parameters->target().reloc_symbol_index(this->u1_.arg,
916 this->type_);
917 break;
919 case 0:
920 // Relocations without symbols use a symbol index of 0.
921 index = 0;
922 break;
924 default:
926 const unsigned int lsi = this->local_sym_index_;
927 if (!this->is_section_symbol_)
929 if (dynamic)
930 index = this->u1_.relobj->dynsym_index(lsi);
931 else
932 index = this->u1_.relobj->symtab_index(lsi);
934 else
936 Output_section* os = this->u1_.relobj->output_section(lsi);
937 gold_assert(os != NULL);
938 if (dynamic)
939 index = os->dynsym_index();
940 else
941 index = os->symtab_index();
944 break;
946 gold_assert(index != -1U);
947 return index;
950 // For a local section symbol, get the address of the offset ADDEND
951 // within the input section.
953 template<bool dynamic, int size, bool big_endian>
954 typename elfcpp::Elf_types<size>::Elf_Addr
955 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::
956 local_section_offset(Addend addend) const
958 gold_assert(this->local_sym_index_ != GSYM_CODE
959 && this->local_sym_index_ != SECTION_CODE
960 && this->local_sym_index_ != TARGET_CODE
961 && this->local_sym_index_ != INVALID_CODE
962 && this->local_sym_index_ != 0
963 && this->is_section_symbol_);
964 const unsigned int lsi = this->local_sym_index_;
965 Output_section* os = this->u1_.relobj->output_section(lsi);
966 gold_assert(os != NULL);
967 Address offset = this->u1_.relobj->get_output_section_offset(lsi);
968 if (offset != invalid_address)
969 return offset + addend;
970 // This is a merge section.
971 offset = os->output_address(this->u1_.relobj, lsi, addend);
972 gold_assert(offset != invalid_address);
973 return offset;
976 // Get the output address of a relocation.
978 template<bool dynamic, int size, bool big_endian>
979 typename elfcpp::Elf_types<size>::Elf_Addr
980 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::get_address() const
982 Address address = this->address_;
983 if (this->shndx_ != INVALID_CODE)
985 Output_section* os = this->u2_.relobj->output_section(this->shndx_);
986 gold_assert(os != NULL);
987 Address off = this->u2_.relobj->get_output_section_offset(this->shndx_);
988 if (off != invalid_address)
989 address += os->address() + off;
990 else
992 address = os->output_address(this->u2_.relobj, this->shndx_,
993 address);
994 gold_assert(address != invalid_address);
997 else if (this->u2_.od != NULL)
998 address += this->u2_.od->address();
999 return address;
1002 // Write out the offset and info fields of a Rel or Rela relocation
1003 // entry.
1005 template<bool dynamic, int size, bool big_endian>
1006 template<typename Write_rel>
1007 void
1008 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::write_rel(
1009 Write_rel* wr) const
1011 wr->put_r_offset(this->get_address());
1012 unsigned int sym_index = this->get_symbol_index();
1013 wr->put_r_info(elfcpp::elf_r_info<size>(sym_index, this->type_));
1016 // Write out a Rel relocation.
1018 template<bool dynamic, int size, bool big_endian>
1019 void
1020 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::write(
1021 unsigned char* pov) const
1023 elfcpp::Rel_write<size, big_endian> orel(pov);
1024 this->write_rel(&orel);
1027 // Get the value of the symbol referred to by a Rel relocation.
1029 template<bool dynamic, int size, bool big_endian>
1030 typename elfcpp::Elf_types<size>::Elf_Addr
1031 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::symbol_value(
1032 Addend addend) const
1034 if (this->local_sym_index_ == GSYM_CODE)
1036 const Sized_symbol<size>* sym;
1037 sym = static_cast<const Sized_symbol<size>*>(this->u1_.gsym);
1038 return sym->value() + addend;
1040 gold_assert(this->local_sym_index_ != SECTION_CODE
1041 && this->local_sym_index_ != TARGET_CODE
1042 && this->local_sym_index_ != INVALID_CODE
1043 && this->local_sym_index_ != 0
1044 && !this->is_section_symbol_);
1045 const unsigned int lsi = this->local_sym_index_;
1046 const Symbol_value<size>* symval = this->u1_.relobj->local_symbol(lsi);
1047 return symval->value(this->u1_.relobj, addend);
1050 // Reloc comparison. This function sorts the dynamic relocs for the
1051 // benefit of the dynamic linker. First we sort all relative relocs
1052 // to the front. Among relative relocs, we sort by output address.
1053 // Among non-relative relocs, we sort by symbol index, then by output
1054 // address.
1056 template<bool dynamic, int size, bool big_endian>
1058 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::
1059 compare(const Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>& r2)
1060 const
1062 if (this->is_relative_)
1064 if (!r2.is_relative_)
1065 return -1;
1066 // Otherwise sort by reloc address below.
1068 else if (r2.is_relative_)
1069 return 1;
1070 else
1072 unsigned int sym1 = this->get_symbol_index();
1073 unsigned int sym2 = r2.get_symbol_index();
1074 if (sym1 < sym2)
1075 return -1;
1076 else if (sym1 > sym2)
1077 return 1;
1078 // Otherwise sort by reloc address.
1081 section_offset_type addr1 = this->get_address();
1082 section_offset_type addr2 = r2.get_address();
1083 if (addr1 < addr2)
1084 return -1;
1085 else if (addr1 > addr2)
1086 return 1;
1088 // Final tie breaker, in order to generate the same output on any
1089 // host: reloc type.
1090 unsigned int type1 = this->type_;
1091 unsigned int type2 = r2.type_;
1092 if (type1 < type2)
1093 return -1;
1094 else if (type1 > type2)
1095 return 1;
1097 // These relocs appear to be exactly the same.
1098 return 0;
1101 // Write out a Rela relocation.
1103 template<bool dynamic, int size, bool big_endian>
1104 void
1105 Output_reloc<elfcpp::SHT_RELA, dynamic, size, big_endian>::write(
1106 unsigned char* pov) const
1108 elfcpp::Rela_write<size, big_endian> orel(pov);
1109 this->rel_.write_rel(&orel);
1110 Addend addend = this->addend_;
1111 if (this->rel_.is_target_specific())
1112 addend = parameters->target().reloc_addend(this->rel_.target_arg(),
1113 this->rel_.type(), addend);
1114 else if (this->rel_.is_symbolless())
1115 addend = this->rel_.symbol_value(addend);
1116 else if (this->rel_.is_local_section_symbol())
1117 addend = this->rel_.local_section_offset(addend);
1118 orel.put_r_addend(addend);
1121 // Output_data_reloc_base methods.
1123 // Adjust the output section.
1125 template<int sh_type, bool dynamic, int size, bool big_endian>
1126 void
1127 Output_data_reloc_base<sh_type, dynamic, size, big_endian>
1128 ::do_adjust_output_section(Output_section* os)
1130 if (sh_type == elfcpp::SHT_REL)
1131 os->set_entsize(elfcpp::Elf_sizes<size>::rel_size);
1132 else if (sh_type == elfcpp::SHT_RELA)
1133 os->set_entsize(elfcpp::Elf_sizes<size>::rela_size);
1134 else
1135 gold_unreachable();
1137 // A STT_GNU_IFUNC symbol may require a IRELATIVE reloc when doing a
1138 // static link. The backends will generate a dynamic reloc section
1139 // to hold this. In that case we don't want to link to the dynsym
1140 // section, because there isn't one.
1141 if (!dynamic)
1142 os->set_should_link_to_symtab();
1143 else if (parameters->doing_static_link())
1145 else
1146 os->set_should_link_to_dynsym();
1149 // Write out relocation data.
1151 template<int sh_type, bool dynamic, int size, bool big_endian>
1152 void
1153 Output_data_reloc_base<sh_type, dynamic, size, big_endian>::do_write(
1154 Output_file* of)
1156 const off_t off = this->offset();
1157 const off_t oview_size = this->data_size();
1158 unsigned char* const oview = of->get_output_view(off, oview_size);
1160 if (this->sort_relocs())
1162 gold_assert(dynamic);
1163 std::sort(this->relocs_.begin(), this->relocs_.end(),
1164 Sort_relocs_comparison());
1167 unsigned char* pov = oview;
1168 for (typename Relocs::const_iterator p = this->relocs_.begin();
1169 p != this->relocs_.end();
1170 ++p)
1172 p->write(pov);
1173 pov += reloc_size;
1176 gold_assert(pov - oview == oview_size);
1178 of->write_output_view(off, oview_size, oview);
1180 // We no longer need the relocation entries.
1181 this->relocs_.clear();
1184 // Class Output_relocatable_relocs.
1186 template<int sh_type, int size, bool big_endian>
1187 void
1188 Output_relocatable_relocs<sh_type, size, big_endian>::set_final_data_size()
1190 this->set_data_size(this->rr_->output_reloc_count()
1191 * Reloc_types<sh_type, size, big_endian>::reloc_size);
1194 // class Output_data_group.
1196 template<int size, bool big_endian>
1197 Output_data_group<size, big_endian>::Output_data_group(
1198 Sized_relobj<size, big_endian>* relobj,
1199 section_size_type entry_count,
1200 elfcpp::Elf_Word flags,
1201 std::vector<unsigned int>* input_shndxes)
1202 : Output_section_data(entry_count * 4, 4, false),
1203 relobj_(relobj),
1204 flags_(flags)
1206 this->input_shndxes_.swap(*input_shndxes);
1209 // Write out the section group, which means translating the section
1210 // indexes to apply to the output file.
1212 template<int size, bool big_endian>
1213 void
1214 Output_data_group<size, big_endian>::do_write(Output_file* of)
1216 const off_t off = this->offset();
1217 const section_size_type oview_size =
1218 convert_to_section_size_type(this->data_size());
1219 unsigned char* const oview = of->get_output_view(off, oview_size);
1221 elfcpp::Elf_Word* contents = reinterpret_cast<elfcpp::Elf_Word*>(oview);
1222 elfcpp::Swap<32, big_endian>::writeval(contents, this->flags_);
1223 ++contents;
1225 for (std::vector<unsigned int>::const_iterator p =
1226 this->input_shndxes_.begin();
1227 p != this->input_shndxes_.end();
1228 ++p, ++contents)
1230 Output_section* os = this->relobj_->output_section(*p);
1232 unsigned int output_shndx;
1233 if (os != NULL)
1234 output_shndx = os->out_shndx();
1235 else
1237 this->relobj_->error(_("section group retained but "
1238 "group element discarded"));
1239 output_shndx = 0;
1242 elfcpp::Swap<32, big_endian>::writeval(contents, output_shndx);
1245 size_t wrote = reinterpret_cast<unsigned char*>(contents) - oview;
1246 gold_assert(wrote == oview_size);
1248 of->write_output_view(off, oview_size, oview);
1250 // We no longer need this information.
1251 this->input_shndxes_.clear();
1254 // Output_data_got::Got_entry methods.
1256 // Write out the entry.
1258 template<int size, bool big_endian>
1259 void
1260 Output_data_got<size, big_endian>::Got_entry::write(unsigned char* pov) const
1262 Valtype val = 0;
1264 switch (this->local_sym_index_)
1266 case GSYM_CODE:
1268 // If the symbol is resolved locally, we need to write out the
1269 // link-time value, which will be relocated dynamically by a
1270 // RELATIVE relocation.
1271 Symbol* gsym = this->u_.gsym;
1272 if (this->use_plt_offset_ && gsym->has_plt_offset())
1273 val = (parameters->target().plt_section_for_global(gsym)->address()
1274 + gsym->plt_offset());
1275 else
1277 Sized_symbol<size>* sgsym;
1278 // This cast is a bit ugly. We don't want to put a
1279 // virtual method in Symbol, because we want Symbol to be
1280 // as small as possible.
1281 sgsym = static_cast<Sized_symbol<size>*>(gsym);
1282 val = sgsym->value();
1285 break;
1287 case CONSTANT_CODE:
1288 val = this->u_.constant;
1289 break;
1291 default:
1293 const Sized_relobj<size, big_endian>* object = this->u_.object;
1294 const unsigned int lsi = this->local_sym_index_;
1295 const Symbol_value<size>* symval = object->local_symbol(lsi);
1296 if (!this->use_plt_offset_)
1297 val = symval->value(this->u_.object, 0);
1298 else
1300 const Output_data* plt =
1301 parameters->target().plt_section_for_local(object, lsi);
1302 val = plt->address() + object->local_plt_offset(lsi);
1305 break;
1308 elfcpp::Swap<size, big_endian>::writeval(pov, val);
1311 // Output_data_got methods.
1313 // Add an entry for a global symbol to the GOT. This returns true if
1314 // this is a new GOT entry, false if the symbol already had a GOT
1315 // entry.
1317 template<int size, bool big_endian>
1318 bool
1319 Output_data_got<size, big_endian>::add_global(
1320 Symbol* gsym,
1321 unsigned int got_type)
1323 if (gsym->has_got_offset(got_type))
1324 return false;
1326 this->entries_.push_back(Got_entry(gsym, false));
1327 this->set_got_size();
1328 gsym->set_got_offset(got_type, this->last_got_offset());
1329 return true;
1332 // Like add_global, but use the PLT offset.
1334 template<int size, bool big_endian>
1335 bool
1336 Output_data_got<size, big_endian>::add_global_plt(Symbol* gsym,
1337 unsigned int got_type)
1339 if (gsym->has_got_offset(got_type))
1340 return false;
1342 this->entries_.push_back(Got_entry(gsym, true));
1343 this->set_got_size();
1344 gsym->set_got_offset(got_type, this->last_got_offset());
1345 return true;
1348 // Add an entry for a global symbol to the GOT, and add a dynamic
1349 // relocation of type R_TYPE for the GOT entry.
1351 template<int size, bool big_endian>
1352 void
1353 Output_data_got<size, big_endian>::add_global_with_rel(
1354 Symbol* gsym,
1355 unsigned int got_type,
1356 Rel_dyn* rel_dyn,
1357 unsigned int r_type)
1359 if (gsym->has_got_offset(got_type))
1360 return;
1362 this->entries_.push_back(Got_entry());
1363 this->set_got_size();
1364 unsigned int got_offset = this->last_got_offset();
1365 gsym->set_got_offset(got_type, got_offset);
1366 rel_dyn->add_global(gsym, r_type, this, got_offset);
1369 template<int size, bool big_endian>
1370 void
1371 Output_data_got<size, big_endian>::add_global_with_rela(
1372 Symbol* gsym,
1373 unsigned int got_type,
1374 Rela_dyn* rela_dyn,
1375 unsigned int r_type)
1377 if (gsym->has_got_offset(got_type))
1378 return;
1380 this->entries_.push_back(Got_entry());
1381 this->set_got_size();
1382 unsigned int got_offset = this->last_got_offset();
1383 gsym->set_got_offset(got_type, got_offset);
1384 rela_dyn->add_global(gsym, r_type, this, got_offset, 0);
1387 // Add a pair of entries for a global symbol to the GOT, and add
1388 // dynamic relocations of type R_TYPE_1 and R_TYPE_2, respectively.
1389 // If R_TYPE_2 == 0, add the second entry with no relocation.
1390 template<int size, bool big_endian>
1391 void
1392 Output_data_got<size, big_endian>::add_global_pair_with_rel(
1393 Symbol* gsym,
1394 unsigned int got_type,
1395 Rel_dyn* rel_dyn,
1396 unsigned int r_type_1,
1397 unsigned int r_type_2)
1399 if (gsym->has_got_offset(got_type))
1400 return;
1402 this->entries_.push_back(Got_entry());
1403 unsigned int got_offset = this->last_got_offset();
1404 gsym->set_got_offset(got_type, got_offset);
1405 rel_dyn->add_global(gsym, r_type_1, this, got_offset);
1407 this->entries_.push_back(Got_entry());
1408 if (r_type_2 != 0)
1410 got_offset = this->last_got_offset();
1411 rel_dyn->add_global(gsym, r_type_2, this, got_offset);
1414 this->set_got_size();
1417 template<int size, bool big_endian>
1418 void
1419 Output_data_got<size, big_endian>::add_global_pair_with_rela(
1420 Symbol* gsym,
1421 unsigned int got_type,
1422 Rela_dyn* rela_dyn,
1423 unsigned int r_type_1,
1424 unsigned int r_type_2)
1426 if (gsym->has_got_offset(got_type))
1427 return;
1429 this->entries_.push_back(Got_entry());
1430 unsigned int got_offset = this->last_got_offset();
1431 gsym->set_got_offset(got_type, got_offset);
1432 rela_dyn->add_global(gsym, r_type_1, this, got_offset, 0);
1434 this->entries_.push_back(Got_entry());
1435 if (r_type_2 != 0)
1437 got_offset = this->last_got_offset();
1438 rela_dyn->add_global(gsym, r_type_2, this, got_offset, 0);
1441 this->set_got_size();
1444 // Add an entry for a local symbol to the GOT. This returns true if
1445 // this is a new GOT entry, false if the symbol already has a GOT
1446 // entry.
1448 template<int size, bool big_endian>
1449 bool
1450 Output_data_got<size, big_endian>::add_local(
1451 Sized_relobj<size, big_endian>* object,
1452 unsigned int symndx,
1453 unsigned int got_type)
1455 if (object->local_has_got_offset(symndx, got_type))
1456 return false;
1458 this->entries_.push_back(Got_entry(object, symndx, false));
1459 this->set_got_size();
1460 object->set_local_got_offset(symndx, got_type, this->last_got_offset());
1461 return true;
1464 // Like add_local, but use the PLT offset.
1466 template<int size, bool big_endian>
1467 bool
1468 Output_data_got<size, big_endian>::add_local_plt(
1469 Sized_relobj<size, big_endian>* object,
1470 unsigned int symndx,
1471 unsigned int got_type)
1473 if (object->local_has_got_offset(symndx, got_type))
1474 return false;
1476 this->entries_.push_back(Got_entry(object, symndx, true));
1477 this->set_got_size();
1478 object->set_local_got_offset(symndx, got_type, this->last_got_offset());
1479 return true;
1482 // Add an entry for a local symbol to the GOT, and add a dynamic
1483 // relocation of type R_TYPE for the GOT entry.
1485 template<int size, bool big_endian>
1486 void
1487 Output_data_got<size, big_endian>::add_local_with_rel(
1488 Sized_relobj<size, big_endian>* object,
1489 unsigned int symndx,
1490 unsigned int got_type,
1491 Rel_dyn* rel_dyn,
1492 unsigned int r_type)
1494 if (object->local_has_got_offset(symndx, got_type))
1495 return;
1497 this->entries_.push_back(Got_entry());
1498 this->set_got_size();
1499 unsigned int got_offset = this->last_got_offset();
1500 object->set_local_got_offset(symndx, got_type, got_offset);
1501 rel_dyn->add_local(object, symndx, r_type, this, got_offset);
1504 template<int size, bool big_endian>
1505 void
1506 Output_data_got<size, big_endian>::add_local_with_rela(
1507 Sized_relobj<size, big_endian>* object,
1508 unsigned int symndx,
1509 unsigned int got_type,
1510 Rela_dyn* rela_dyn,
1511 unsigned int r_type)
1513 if (object->local_has_got_offset(symndx, got_type))
1514 return;
1516 this->entries_.push_back(Got_entry());
1517 this->set_got_size();
1518 unsigned int got_offset = this->last_got_offset();
1519 object->set_local_got_offset(symndx, got_type, got_offset);
1520 rela_dyn->add_local(object, symndx, r_type, this, got_offset, 0);
1523 // Add a pair of entries for a local symbol to the GOT, and add
1524 // dynamic relocations of type R_TYPE_1 and R_TYPE_2, respectively.
1525 // If R_TYPE_2 == 0, add the second entry with no relocation.
1526 template<int size, bool big_endian>
1527 void
1528 Output_data_got<size, big_endian>::add_local_pair_with_rel(
1529 Sized_relobj<size, big_endian>* object,
1530 unsigned int symndx,
1531 unsigned int shndx,
1532 unsigned int got_type,
1533 Rel_dyn* rel_dyn,
1534 unsigned int r_type_1,
1535 unsigned int r_type_2)
1537 if (object->local_has_got_offset(symndx, got_type))
1538 return;
1540 this->entries_.push_back(Got_entry());
1541 unsigned int got_offset = this->last_got_offset();
1542 object->set_local_got_offset(symndx, got_type, got_offset);
1543 Output_section* os = object->output_section(shndx);
1544 rel_dyn->add_output_section(os, r_type_1, this, got_offset);
1546 this->entries_.push_back(Got_entry(object, symndx, false));
1547 if (r_type_2 != 0)
1549 got_offset = this->last_got_offset();
1550 rel_dyn->add_output_section(os, r_type_2, this, got_offset);
1553 this->set_got_size();
1556 template<int size, bool big_endian>
1557 void
1558 Output_data_got<size, big_endian>::add_local_pair_with_rela(
1559 Sized_relobj<size, big_endian>* object,
1560 unsigned int symndx,
1561 unsigned int shndx,
1562 unsigned int got_type,
1563 Rela_dyn* rela_dyn,
1564 unsigned int r_type_1,
1565 unsigned int r_type_2)
1567 if (object->local_has_got_offset(symndx, got_type))
1568 return;
1570 this->entries_.push_back(Got_entry());
1571 unsigned int got_offset = this->last_got_offset();
1572 object->set_local_got_offset(symndx, got_type, got_offset);
1573 Output_section* os = object->output_section(shndx);
1574 rela_dyn->add_output_section(os, r_type_1, this, got_offset, 0);
1576 this->entries_.push_back(Got_entry(object, symndx, false));
1577 if (r_type_2 != 0)
1579 got_offset = this->last_got_offset();
1580 rela_dyn->add_output_section(os, r_type_2, this, got_offset, 0);
1583 this->set_got_size();
1586 // Write out the GOT.
1588 template<int size, bool big_endian>
1589 void
1590 Output_data_got<size, big_endian>::do_write(Output_file* of)
1592 const int add = size / 8;
1594 const off_t off = this->offset();
1595 const off_t oview_size = this->data_size();
1596 unsigned char* const oview = of->get_output_view(off, oview_size);
1598 unsigned char* pov = oview;
1599 for (typename Got_entries::const_iterator p = this->entries_.begin();
1600 p != this->entries_.end();
1601 ++p)
1603 p->write(pov);
1604 pov += add;
1607 gold_assert(pov - oview == oview_size);
1609 of->write_output_view(off, oview_size, oview);
1611 // We no longer need the GOT entries.
1612 this->entries_.clear();
1615 // Output_data_dynamic::Dynamic_entry methods.
1617 // Write out the entry.
1619 template<int size, bool big_endian>
1620 void
1621 Output_data_dynamic::Dynamic_entry::write(
1622 unsigned char* pov,
1623 const Stringpool* pool) const
1625 typename elfcpp::Elf_types<size>::Elf_WXword val;
1626 switch (this->offset_)
1628 case DYNAMIC_NUMBER:
1629 val = this->u_.val;
1630 break;
1632 case DYNAMIC_SECTION_SIZE:
1633 val = this->u_.od->data_size();
1634 if (this->od2 != NULL)
1635 val += this->od2->data_size();
1636 break;
1638 case DYNAMIC_SYMBOL:
1640 const Sized_symbol<size>* s =
1641 static_cast<const Sized_symbol<size>*>(this->u_.sym);
1642 val = s->value();
1644 break;
1646 case DYNAMIC_STRING:
1647 val = pool->get_offset(this->u_.str);
1648 break;
1650 default:
1651 val = this->u_.od->address() + this->offset_;
1652 break;
1655 elfcpp::Dyn_write<size, big_endian> dw(pov);
1656 dw.put_d_tag(this->tag_);
1657 dw.put_d_val(val);
1660 // Output_data_dynamic methods.
1662 // Adjust the output section to set the entry size.
1664 void
1665 Output_data_dynamic::do_adjust_output_section(Output_section* os)
1667 if (parameters->target().get_size() == 32)
1668 os->set_entsize(elfcpp::Elf_sizes<32>::dyn_size);
1669 else if (parameters->target().get_size() == 64)
1670 os->set_entsize(elfcpp::Elf_sizes<64>::dyn_size);
1671 else
1672 gold_unreachable();
1675 // Set the final data size.
1677 void
1678 Output_data_dynamic::set_final_data_size()
1680 // Add the terminating entry if it hasn't been added.
1681 // Because of relaxation, we can run this multiple times.
1682 if (this->entries_.empty() || this->entries_.back().tag() != elfcpp::DT_NULL)
1684 int extra = parameters->options().spare_dynamic_tags();
1685 for (int i = 0; i < extra; ++i)
1686 this->add_constant(elfcpp::DT_NULL, 0);
1687 this->add_constant(elfcpp::DT_NULL, 0);
1690 int dyn_size;
1691 if (parameters->target().get_size() == 32)
1692 dyn_size = elfcpp::Elf_sizes<32>::dyn_size;
1693 else if (parameters->target().get_size() == 64)
1694 dyn_size = elfcpp::Elf_sizes<64>::dyn_size;
1695 else
1696 gold_unreachable();
1697 this->set_data_size(this->entries_.size() * dyn_size);
1700 // Write out the dynamic entries.
1702 void
1703 Output_data_dynamic::do_write(Output_file* of)
1705 switch (parameters->size_and_endianness())
1707 #ifdef HAVE_TARGET_32_LITTLE
1708 case Parameters::TARGET_32_LITTLE:
1709 this->sized_write<32, false>(of);
1710 break;
1711 #endif
1712 #ifdef HAVE_TARGET_32_BIG
1713 case Parameters::TARGET_32_BIG:
1714 this->sized_write<32, true>(of);
1715 break;
1716 #endif
1717 #ifdef HAVE_TARGET_64_LITTLE
1718 case Parameters::TARGET_64_LITTLE:
1719 this->sized_write<64, false>(of);
1720 break;
1721 #endif
1722 #ifdef HAVE_TARGET_64_BIG
1723 case Parameters::TARGET_64_BIG:
1724 this->sized_write<64, true>(of);
1725 break;
1726 #endif
1727 default:
1728 gold_unreachable();
1732 template<int size, bool big_endian>
1733 void
1734 Output_data_dynamic::sized_write(Output_file* of)
1736 const int dyn_size = elfcpp::Elf_sizes<size>::dyn_size;
1738 const off_t offset = this->offset();
1739 const off_t oview_size = this->data_size();
1740 unsigned char* const oview = of->get_output_view(offset, oview_size);
1742 unsigned char* pov = oview;
1743 for (typename Dynamic_entries::const_iterator p = this->entries_.begin();
1744 p != this->entries_.end();
1745 ++p)
1747 p->write<size, big_endian>(pov, this->pool_);
1748 pov += dyn_size;
1751 gold_assert(pov - oview == oview_size);
1753 of->write_output_view(offset, oview_size, oview);
1755 // We no longer need the dynamic entries.
1756 this->entries_.clear();
1759 // Class Output_symtab_xindex.
1761 void
1762 Output_symtab_xindex::do_write(Output_file* of)
1764 const off_t offset = this->offset();
1765 const off_t oview_size = this->data_size();
1766 unsigned char* const oview = of->get_output_view(offset, oview_size);
1768 memset(oview, 0, oview_size);
1770 if (parameters->target().is_big_endian())
1771 this->endian_do_write<true>(oview);
1772 else
1773 this->endian_do_write<false>(oview);
1775 of->write_output_view(offset, oview_size, oview);
1777 // We no longer need the data.
1778 this->entries_.clear();
1781 template<bool big_endian>
1782 void
1783 Output_symtab_xindex::endian_do_write(unsigned char* const oview)
1785 for (Xindex_entries::const_iterator p = this->entries_.begin();
1786 p != this->entries_.end();
1787 ++p)
1789 unsigned int symndx = p->first;
1790 gold_assert(symndx * 4 < this->data_size());
1791 elfcpp::Swap<32, big_endian>::writeval(oview + symndx * 4, p->second);
1795 // Output_section::Input_section methods.
1797 // Return the data size. For an input section we store the size here.
1798 // For an Output_section_data, we have to ask it for the size.
1800 off_t
1801 Output_section::Input_section::data_size() const
1803 if (this->is_input_section())
1804 return this->u1_.data_size;
1805 else
1806 return this->u2_.posd->data_size();
1809 // Return the object for an input section.
1811 Relobj*
1812 Output_section::Input_section::relobj() const
1814 if (this->is_input_section())
1815 return this->u2_.object;
1816 else if (this->is_merge_section())
1818 gold_assert(this->u2_.pomb->first_relobj() != NULL);
1819 return this->u2_.pomb->first_relobj();
1821 else if (this->is_relaxed_input_section())
1822 return this->u2_.poris->relobj();
1823 else
1824 gold_unreachable();
1827 // Return the input section index for an input section.
1829 unsigned int
1830 Output_section::Input_section::shndx() const
1832 if (this->is_input_section())
1833 return this->shndx_;
1834 else if (this->is_merge_section())
1836 gold_assert(this->u2_.pomb->first_relobj() != NULL);
1837 return this->u2_.pomb->first_shndx();
1839 else if (this->is_relaxed_input_section())
1840 return this->u2_.poris->shndx();
1841 else
1842 gold_unreachable();
1845 // Set the address and file offset.
1847 void
1848 Output_section::Input_section::set_address_and_file_offset(
1849 uint64_t address,
1850 off_t file_offset,
1851 off_t section_file_offset)
1853 if (this->is_input_section())
1854 this->u2_.object->set_section_offset(this->shndx_,
1855 file_offset - section_file_offset);
1856 else
1857 this->u2_.posd->set_address_and_file_offset(address, file_offset);
1860 // Reset the address and file offset.
1862 void
1863 Output_section::Input_section::reset_address_and_file_offset()
1865 if (!this->is_input_section())
1866 this->u2_.posd->reset_address_and_file_offset();
1869 // Finalize the data size.
1871 void
1872 Output_section::Input_section::finalize_data_size()
1874 if (!this->is_input_section())
1875 this->u2_.posd->finalize_data_size();
1878 // Try to turn an input offset into an output offset. We want to
1879 // return the output offset relative to the start of this
1880 // Input_section in the output section.
1882 inline bool
1883 Output_section::Input_section::output_offset(
1884 const Relobj* object,
1885 unsigned int shndx,
1886 section_offset_type offset,
1887 section_offset_type* poutput) const
1889 if (!this->is_input_section())
1890 return this->u2_.posd->output_offset(object, shndx, offset, poutput);
1891 else
1893 if (this->shndx_ != shndx || this->u2_.object != object)
1894 return false;
1895 *poutput = offset;
1896 return true;
1900 // Return whether this is the merge section for the input section
1901 // SHNDX in OBJECT.
1903 inline bool
1904 Output_section::Input_section::is_merge_section_for(const Relobj* object,
1905 unsigned int shndx) const
1907 if (this->is_input_section())
1908 return false;
1909 return this->u2_.posd->is_merge_section_for(object, shndx);
1912 // Write out the data. We don't have to do anything for an input
1913 // section--they are handled via Object::relocate--but this is where
1914 // we write out the data for an Output_section_data.
1916 void
1917 Output_section::Input_section::write(Output_file* of)
1919 if (!this->is_input_section())
1920 this->u2_.posd->write(of);
1923 // Write the data to a buffer. As for write(), we don't have to do
1924 // anything for an input section.
1926 void
1927 Output_section::Input_section::write_to_buffer(unsigned char* buffer)
1929 if (!this->is_input_section())
1930 this->u2_.posd->write_to_buffer(buffer);
1933 // Print to a map file.
1935 void
1936 Output_section::Input_section::print_to_mapfile(Mapfile* mapfile) const
1938 switch (this->shndx_)
1940 case OUTPUT_SECTION_CODE:
1941 case MERGE_DATA_SECTION_CODE:
1942 case MERGE_STRING_SECTION_CODE:
1943 this->u2_.posd->print_to_mapfile(mapfile);
1944 break;
1946 case RELAXED_INPUT_SECTION_CODE:
1948 Output_relaxed_input_section* relaxed_section =
1949 this->relaxed_input_section();
1950 mapfile->print_input_section(relaxed_section->relobj(),
1951 relaxed_section->shndx());
1953 break;
1954 default:
1955 mapfile->print_input_section(this->u2_.object, this->shndx_);
1956 break;
1960 // Output_section methods.
1962 // Construct an Output_section. NAME will point into a Stringpool.
1964 Output_section::Output_section(const char* name, elfcpp::Elf_Word type,
1965 elfcpp::Elf_Xword flags)
1966 : name_(name),
1967 addralign_(0),
1968 entsize_(0),
1969 load_address_(0),
1970 link_section_(NULL),
1971 link_(0),
1972 info_section_(NULL),
1973 info_symndx_(NULL),
1974 info_(0),
1975 type_(type),
1976 flags_(flags),
1977 order_(ORDER_INVALID),
1978 out_shndx_(-1U),
1979 symtab_index_(0),
1980 dynsym_index_(0),
1981 input_sections_(),
1982 first_input_offset_(0),
1983 fills_(),
1984 postprocessing_buffer_(NULL),
1985 needs_symtab_index_(false),
1986 needs_dynsym_index_(false),
1987 should_link_to_symtab_(false),
1988 should_link_to_dynsym_(false),
1989 after_input_sections_(false),
1990 requires_postprocessing_(false),
1991 found_in_sections_clause_(false),
1992 has_load_address_(false),
1993 info_uses_section_index_(false),
1994 input_section_order_specified_(false),
1995 may_sort_attached_input_sections_(false),
1996 must_sort_attached_input_sections_(false),
1997 attached_input_sections_are_sorted_(false),
1998 is_relro_(false),
1999 is_small_section_(false),
2000 is_large_section_(false),
2001 generate_code_fills_at_write_(false),
2002 is_entsize_zero_(false),
2003 section_offsets_need_adjustment_(false),
2004 is_noload_(false),
2005 always_keeps_input_sections_(false),
2006 tls_offset_(0),
2007 checkpoint_(NULL),
2008 lookup_maps_(new Output_section_lookup_maps)
2010 // An unallocated section has no address. Forcing this means that
2011 // we don't need special treatment for symbols defined in debug
2012 // sections.
2013 if ((flags & elfcpp::SHF_ALLOC) == 0)
2014 this->set_address(0);
2017 Output_section::~Output_section()
2019 delete this->checkpoint_;
2022 // Set the entry size.
2024 void
2025 Output_section::set_entsize(uint64_t v)
2027 if (this->is_entsize_zero_)
2029 else if (this->entsize_ == 0)
2030 this->entsize_ = v;
2031 else if (this->entsize_ != v)
2033 this->entsize_ = 0;
2034 this->is_entsize_zero_ = 1;
2038 // Add the input section SHNDX, with header SHDR, named SECNAME, in
2039 // OBJECT, to the Output_section. RELOC_SHNDX is the index of a
2040 // relocation section which applies to this section, or 0 if none, or
2041 // -1U if more than one. Return the offset of the input section
2042 // within the output section. Return -1 if the input section will
2043 // receive special handling. In the normal case we don't always keep
2044 // track of input sections for an Output_section. Instead, each
2045 // Object keeps track of the Output_section for each of its input
2046 // sections. However, if HAVE_SECTIONS_SCRIPT is true, we do keep
2047 // track of input sections here; this is used when SECTIONS appears in
2048 // a linker script.
2050 template<int size, bool big_endian>
2051 off_t
2052 Output_section::add_input_section(Layout* layout,
2053 Sized_relobj<size, big_endian>* object,
2054 unsigned int shndx,
2055 const char* secname,
2056 const elfcpp::Shdr<size, big_endian>& shdr,
2057 unsigned int reloc_shndx,
2058 bool have_sections_script)
2060 elfcpp::Elf_Xword addralign = shdr.get_sh_addralign();
2061 if ((addralign & (addralign - 1)) != 0)
2063 object->error(_("invalid alignment %lu for section \"%s\""),
2064 static_cast<unsigned long>(addralign), secname);
2065 addralign = 1;
2068 if (addralign > this->addralign_)
2069 this->addralign_ = addralign;
2071 typename elfcpp::Elf_types<size>::Elf_WXword sh_flags = shdr.get_sh_flags();
2072 uint64_t entsize = shdr.get_sh_entsize();
2074 // .debug_str is a mergeable string section, but is not always so
2075 // marked by compilers. Mark manually here so we can optimize.
2076 if (strcmp(secname, ".debug_str") == 0)
2078 sh_flags |= (elfcpp::SHF_MERGE | elfcpp::SHF_STRINGS);
2079 entsize = 1;
2082 this->update_flags_for_input_section(sh_flags);
2083 this->set_entsize(entsize);
2085 // If this is a SHF_MERGE section, we pass all the input sections to
2086 // a Output_data_merge. We don't try to handle relocations for such
2087 // a section. We don't try to handle empty merge sections--they
2088 // mess up the mappings, and are useless anyhow.
2089 if ((sh_flags & elfcpp::SHF_MERGE) != 0
2090 && reloc_shndx == 0
2091 && shdr.get_sh_size() > 0)
2093 // Keep information about merged input sections for rebuilding fast
2094 // lookup maps if we have sections-script or we do relaxation.
2095 bool keeps_input_sections = (this->always_keeps_input_sections_
2096 || have_sections_script
2097 || parameters->target().may_relax());
2099 if (this->add_merge_input_section(object, shndx, sh_flags, entsize,
2100 addralign, keeps_input_sections))
2102 // Tell the relocation routines that they need to call the
2103 // output_offset method to determine the final address.
2104 return -1;
2108 off_t offset_in_section = this->current_data_size_for_child();
2109 off_t aligned_offset_in_section = align_address(offset_in_section,
2110 addralign);
2112 // Determine if we want to delay code-fill generation until the output
2113 // section is written. When the target is relaxing, we want to delay fill
2114 // generating to avoid adjusting them during relaxation.
2115 if (!this->generate_code_fills_at_write_
2116 && !have_sections_script
2117 && (sh_flags & elfcpp::SHF_EXECINSTR) != 0
2118 && parameters->target().has_code_fill()
2119 && parameters->target().may_relax())
2121 gold_assert(this->fills_.empty());
2122 this->generate_code_fills_at_write_ = true;
2125 if (aligned_offset_in_section > offset_in_section
2126 && !this->generate_code_fills_at_write_
2127 && !have_sections_script
2128 && (sh_flags & elfcpp::SHF_EXECINSTR) != 0
2129 && parameters->target().has_code_fill())
2131 // We need to add some fill data. Using fill_list_ when
2132 // possible is an optimization, since we will often have fill
2133 // sections without input sections.
2134 off_t fill_len = aligned_offset_in_section - offset_in_section;
2135 if (this->input_sections_.empty())
2136 this->fills_.push_back(Fill(offset_in_section, fill_len));
2137 else
2139 std::string fill_data(parameters->target().code_fill(fill_len));
2140 Output_data_const* odc = new Output_data_const(fill_data, 1);
2141 this->input_sections_.push_back(Input_section(odc));
2145 section_size_type input_section_size = shdr.get_sh_size();
2146 section_size_type uncompressed_size;
2147 if (object->section_is_compressed(shndx, &uncompressed_size))
2148 input_section_size = uncompressed_size;
2150 this->set_current_data_size_for_child(aligned_offset_in_section
2151 + input_section_size);
2153 // We need to keep track of this section if we are already keeping
2154 // track of sections, or if we are relaxing. Also, if this is a
2155 // section which requires sorting, or which may require sorting in
2156 // the future, we keep track of the sections. If the
2157 // --section-ordering-file option is used to specify the order of
2158 // sections, we need to keep track of sections.
2159 if (this->always_keeps_input_sections_
2160 || have_sections_script
2161 || !this->input_sections_.empty()
2162 || this->may_sort_attached_input_sections()
2163 || this->must_sort_attached_input_sections()
2164 || parameters->options().user_set_Map()
2165 || parameters->target().may_relax()
2166 || parameters->options().section_ordering_file())
2168 Input_section isecn(object, shndx, input_section_size, addralign);
2169 if (parameters->options().section_ordering_file())
2171 unsigned int section_order_index =
2172 layout->find_section_order_index(std::string(secname));
2173 if (section_order_index != 0)
2175 isecn.set_section_order_index(section_order_index);
2176 this->set_input_section_order_specified();
2179 this->input_sections_.push_back(isecn);
2182 return aligned_offset_in_section;
2185 // Add arbitrary data to an output section.
2187 void
2188 Output_section::add_output_section_data(Output_section_data* posd)
2190 Input_section inp(posd);
2191 this->add_output_section_data(&inp);
2193 if (posd->is_data_size_valid())
2195 off_t offset_in_section = this->current_data_size_for_child();
2196 off_t aligned_offset_in_section = align_address(offset_in_section,
2197 posd->addralign());
2198 this->set_current_data_size_for_child(aligned_offset_in_section
2199 + posd->data_size());
2203 // Add a relaxed input section.
2205 void
2206 Output_section::add_relaxed_input_section(Layout* layout,
2207 Output_relaxed_input_section* poris,
2208 const std::string& name)
2210 Input_section inp(poris);
2212 // If the --section-ordering-file option is used to specify the order of
2213 // sections, we need to keep track of sections.
2214 if (parameters->options().section_ordering_file())
2216 unsigned int section_order_index =
2217 layout->find_section_order_index(name);
2218 if (section_order_index != 0)
2220 inp.set_section_order_index(section_order_index);
2221 this->set_input_section_order_specified();
2225 this->add_output_section_data(&inp);
2226 if (this->lookup_maps_->is_valid())
2227 this->lookup_maps_->add_relaxed_input_section(poris->relobj(),
2228 poris->shndx(), poris);
2230 // For a relaxed section, we use the current data size. Linker scripts
2231 // get all the input sections, including relaxed one from an output
2232 // section and add them back to them same output section to compute the
2233 // output section size. If we do not account for sizes of relaxed input
2234 // sections, an output section would be incorrectly sized.
2235 off_t offset_in_section = this->current_data_size_for_child();
2236 off_t aligned_offset_in_section = align_address(offset_in_section,
2237 poris->addralign());
2238 this->set_current_data_size_for_child(aligned_offset_in_section
2239 + poris->current_data_size());
2242 // Add arbitrary data to an output section by Input_section.
2244 void
2245 Output_section::add_output_section_data(Input_section* inp)
2247 if (this->input_sections_.empty())
2248 this->first_input_offset_ = this->current_data_size_for_child();
2250 this->input_sections_.push_back(*inp);
2252 uint64_t addralign = inp->addralign();
2253 if (addralign > this->addralign_)
2254 this->addralign_ = addralign;
2256 inp->set_output_section(this);
2259 // Add a merge section to an output section.
2261 void
2262 Output_section::add_output_merge_section(Output_section_data* posd,
2263 bool is_string, uint64_t entsize)
2265 Input_section inp(posd, is_string, entsize);
2266 this->add_output_section_data(&inp);
2269 // Add an input section to a SHF_MERGE section.
2271 bool
2272 Output_section::add_merge_input_section(Relobj* object, unsigned int shndx,
2273 uint64_t flags, uint64_t entsize,
2274 uint64_t addralign,
2275 bool keeps_input_sections)
2277 bool is_string = (flags & elfcpp::SHF_STRINGS) != 0;
2279 // We only merge strings if the alignment is not more than the
2280 // character size. This could be handled, but it's unusual.
2281 if (is_string && addralign > entsize)
2282 return false;
2284 // We cannot restore merged input section states.
2285 gold_assert(this->checkpoint_ == NULL);
2287 // Look up merge sections by required properties.
2288 // Currently, we only invalidate the lookup maps in script processing
2289 // and relaxation. We should not have done either when we reach here.
2290 // So we assume that the lookup maps are valid to simply code.
2291 gold_assert(this->lookup_maps_->is_valid());
2292 Merge_section_properties msp(is_string, entsize, addralign);
2293 Output_merge_base* pomb = this->lookup_maps_->find_merge_section(msp);
2294 bool is_new = false;
2295 if (pomb != NULL)
2297 gold_assert(pomb->is_string() == is_string
2298 && pomb->entsize() == entsize
2299 && pomb->addralign() == addralign);
2301 else
2303 // Create a new Output_merge_data or Output_merge_string_data.
2304 if (!is_string)
2305 pomb = new Output_merge_data(entsize, addralign);
2306 else
2308 switch (entsize)
2310 case 1:
2311 pomb = new Output_merge_string<char>(addralign);
2312 break;
2313 case 2:
2314 pomb = new Output_merge_string<uint16_t>(addralign);
2315 break;
2316 case 4:
2317 pomb = new Output_merge_string<uint32_t>(addralign);
2318 break;
2319 default:
2320 return false;
2323 // If we need to do script processing or relaxation, we need to keep
2324 // the original input sections to rebuild the fast lookup maps.
2325 if (keeps_input_sections)
2326 pomb->set_keeps_input_sections();
2327 is_new = true;
2330 if (pomb->add_input_section(object, shndx))
2332 // Add new merge section to this output section and link merge
2333 // section properties to new merge section in map.
2334 if (is_new)
2336 this->add_output_merge_section(pomb, is_string, entsize);
2337 this->lookup_maps_->add_merge_section(msp, pomb);
2340 // Add input section to new merge section and link input section to new
2341 // merge section in map.
2342 this->lookup_maps_->add_merge_input_section(object, shndx, pomb);
2343 return true;
2345 else
2347 // If add_input_section failed, delete new merge section to avoid
2348 // exporting empty merge sections in Output_section::get_input_section.
2349 if (is_new)
2350 delete pomb;
2351 return false;
2355 // Build a relaxation map to speed up relaxation of existing input sections.
2356 // Look up to the first LIMIT elements in INPUT_SECTIONS.
2358 void
2359 Output_section::build_relaxation_map(
2360 const Input_section_list& input_sections,
2361 size_t limit,
2362 Relaxation_map* relaxation_map) const
2364 for (size_t i = 0; i < limit; ++i)
2366 const Input_section& is(input_sections[i]);
2367 if (is.is_input_section() || is.is_relaxed_input_section())
2369 Section_id sid(is.relobj(), is.shndx());
2370 (*relaxation_map)[sid] = i;
2375 // Convert regular input sections in INPUT_SECTIONS into relaxed input
2376 // sections in RELAXED_SECTIONS. MAP is a prebuilt map from section id
2377 // indices of INPUT_SECTIONS.
2379 void
2380 Output_section::convert_input_sections_in_list_to_relaxed_sections(
2381 const std::vector<Output_relaxed_input_section*>& relaxed_sections,
2382 const Relaxation_map& map,
2383 Input_section_list* input_sections)
2385 for (size_t i = 0; i < relaxed_sections.size(); ++i)
2387 Output_relaxed_input_section* poris = relaxed_sections[i];
2388 Section_id sid(poris->relobj(), poris->shndx());
2389 Relaxation_map::const_iterator p = map.find(sid);
2390 gold_assert(p != map.end());
2391 gold_assert((*input_sections)[p->second].is_input_section());
2393 // Remember section order index of original input section
2394 // if it is set. Copy it to the relaxed input section.
2395 unsigned int soi =
2396 (*input_sections)[p->second].section_order_index();
2397 (*input_sections)[p->second] = Input_section(poris);
2398 (*input_sections)[p->second].set_section_order_index(soi);
2402 // Convert regular input sections into relaxed input sections. RELAXED_SECTIONS
2403 // is a vector of pointers to Output_relaxed_input_section or its derived
2404 // classes. The relaxed sections must correspond to existing input sections.
2406 void
2407 Output_section::convert_input_sections_to_relaxed_sections(
2408 const std::vector<Output_relaxed_input_section*>& relaxed_sections)
2410 gold_assert(parameters->target().may_relax());
2412 // We want to make sure that restore_states does not undo the effect of
2413 // this. If there is no checkpoint active, just search the current
2414 // input section list and replace the sections there. If there is
2415 // a checkpoint, also replace the sections there.
2417 // By default, we look at the whole list.
2418 size_t limit = this->input_sections_.size();
2420 if (this->checkpoint_ != NULL)
2422 // Replace input sections with relaxed input section in the saved
2423 // copy of the input section list.
2424 if (this->checkpoint_->input_sections_saved())
2426 Relaxation_map map;
2427 this->build_relaxation_map(
2428 *(this->checkpoint_->input_sections()),
2429 this->checkpoint_->input_sections()->size(),
2430 &map);
2431 this->convert_input_sections_in_list_to_relaxed_sections(
2432 relaxed_sections,
2433 map,
2434 this->checkpoint_->input_sections());
2436 else
2438 // We have not copied the input section list yet. Instead, just
2439 // look at the portion that would be saved.
2440 limit = this->checkpoint_->input_sections_size();
2444 // Convert input sections in input_section_list.
2445 Relaxation_map map;
2446 this->build_relaxation_map(this->input_sections_, limit, &map);
2447 this->convert_input_sections_in_list_to_relaxed_sections(
2448 relaxed_sections,
2449 map,
2450 &this->input_sections_);
2452 // Update fast look-up map.
2453 if (this->lookup_maps_->is_valid())
2454 for (size_t i = 0; i < relaxed_sections.size(); ++i)
2456 Output_relaxed_input_section* poris = relaxed_sections[i];
2457 this->lookup_maps_->add_relaxed_input_section(poris->relobj(),
2458 poris->shndx(), poris);
2462 // Update the output section flags based on input section flags.
2464 void
2465 Output_section::update_flags_for_input_section(elfcpp::Elf_Xword flags)
2467 // If we created the section with SHF_ALLOC clear, we set the
2468 // address. If we are now setting the SHF_ALLOC flag, we need to
2469 // undo that.
2470 if ((this->flags_ & elfcpp::SHF_ALLOC) == 0
2471 && (flags & elfcpp::SHF_ALLOC) != 0)
2472 this->mark_address_invalid();
2474 this->flags_ |= (flags
2475 & (elfcpp::SHF_WRITE
2476 | elfcpp::SHF_ALLOC
2477 | elfcpp::SHF_EXECINSTR));
2479 if ((flags & elfcpp::SHF_MERGE) == 0)
2480 this->flags_ &=~ elfcpp::SHF_MERGE;
2481 else
2483 if (this->current_data_size_for_child() == 0)
2484 this->flags_ |= elfcpp::SHF_MERGE;
2487 if ((flags & elfcpp::SHF_STRINGS) == 0)
2488 this->flags_ &=~ elfcpp::SHF_STRINGS;
2489 else
2491 if (this->current_data_size_for_child() == 0)
2492 this->flags_ |= elfcpp::SHF_STRINGS;
2496 // Find the merge section into which an input section with index SHNDX in
2497 // OBJECT has been added. Return NULL if none found.
2499 Output_section_data*
2500 Output_section::find_merge_section(const Relobj* object,
2501 unsigned int shndx) const
2503 if (!this->lookup_maps_->is_valid())
2504 this->build_lookup_maps();
2505 return this->lookup_maps_->find_merge_section(object, shndx);
2508 // Build the lookup maps for merge and relaxed sections. This is needs
2509 // to be declared as a const methods so that it is callable with a const
2510 // Output_section pointer. The method only updates states of the maps.
2512 void
2513 Output_section::build_lookup_maps() const
2515 this->lookup_maps_->clear();
2516 for (Input_section_list::const_iterator p = this->input_sections_.begin();
2517 p != this->input_sections_.end();
2518 ++p)
2520 if (p->is_merge_section())
2522 Output_merge_base* pomb = p->output_merge_base();
2523 Merge_section_properties msp(pomb->is_string(), pomb->entsize(),
2524 pomb->addralign());
2525 this->lookup_maps_->add_merge_section(msp, pomb);
2526 for (Output_merge_base::Input_sections::const_iterator is =
2527 pomb->input_sections_begin();
2528 is != pomb->input_sections_end();
2529 ++is)
2531 const Const_section_id& csid = *is;
2532 this->lookup_maps_->add_merge_input_section(csid.first,
2533 csid.second, pomb);
2537 else if (p->is_relaxed_input_section())
2539 Output_relaxed_input_section* poris = p->relaxed_input_section();
2540 this->lookup_maps_->add_relaxed_input_section(poris->relobj(),
2541 poris->shndx(), poris);
2546 // Find an relaxed input section corresponding to an input section
2547 // in OBJECT with index SHNDX.
2549 const Output_relaxed_input_section*
2550 Output_section::find_relaxed_input_section(const Relobj* object,
2551 unsigned int shndx) const
2553 if (!this->lookup_maps_->is_valid())
2554 this->build_lookup_maps();
2555 return this->lookup_maps_->find_relaxed_input_section(object, shndx);
2558 // Given an address OFFSET relative to the start of input section
2559 // SHNDX in OBJECT, return whether this address is being included in
2560 // the final link. This should only be called if SHNDX in OBJECT has
2561 // a special mapping.
2563 bool
2564 Output_section::is_input_address_mapped(const Relobj* object,
2565 unsigned int shndx,
2566 off_t offset) const
2568 // Look at the Output_section_data_maps first.
2569 const Output_section_data* posd = this->find_merge_section(object, shndx);
2570 if (posd == NULL)
2571 posd = this->find_relaxed_input_section(object, shndx);
2573 if (posd != NULL)
2575 section_offset_type output_offset;
2576 bool found = posd->output_offset(object, shndx, offset, &output_offset);
2577 gold_assert(found);
2578 return output_offset != -1;
2581 // Fall back to the slow look-up.
2582 for (Input_section_list::const_iterator p = this->input_sections_.begin();
2583 p != this->input_sections_.end();
2584 ++p)
2586 section_offset_type output_offset;
2587 if (p->output_offset(object, shndx, offset, &output_offset))
2588 return output_offset != -1;
2591 // By default we assume that the address is mapped. This should
2592 // only be called after we have passed all sections to Layout. At
2593 // that point we should know what we are discarding.
2594 return true;
2597 // Given an address OFFSET relative to the start of input section
2598 // SHNDX in object OBJECT, return the output offset relative to the
2599 // start of the input section in the output section. This should only
2600 // be called if SHNDX in OBJECT has a special mapping.
2602 section_offset_type
2603 Output_section::output_offset(const Relobj* object, unsigned int shndx,
2604 section_offset_type offset) const
2606 // This can only be called meaningfully when we know the data size
2607 // of this.
2608 gold_assert(this->is_data_size_valid());
2610 // Look at the Output_section_data_maps first.
2611 const Output_section_data* posd = this->find_merge_section(object, shndx);
2612 if (posd == NULL)
2613 posd = this->find_relaxed_input_section(object, shndx);
2614 if (posd != NULL)
2616 section_offset_type output_offset;
2617 bool found = posd->output_offset(object, shndx, offset, &output_offset);
2618 gold_assert(found);
2619 return output_offset;
2622 // Fall back to the slow look-up.
2623 for (Input_section_list::const_iterator p = this->input_sections_.begin();
2624 p != this->input_sections_.end();
2625 ++p)
2627 section_offset_type output_offset;
2628 if (p->output_offset(object, shndx, offset, &output_offset))
2629 return output_offset;
2631 gold_unreachable();
2634 // Return the output virtual address of OFFSET relative to the start
2635 // of input section SHNDX in object OBJECT.
2637 uint64_t
2638 Output_section::output_address(const Relobj* object, unsigned int shndx,
2639 off_t offset) const
2641 uint64_t addr = this->address() + this->first_input_offset_;
2643 // Look at the Output_section_data_maps first.
2644 const Output_section_data* posd = this->find_merge_section(object, shndx);
2645 if (posd == NULL)
2646 posd = this->find_relaxed_input_section(object, shndx);
2647 if (posd != NULL && posd->is_address_valid())
2649 section_offset_type output_offset;
2650 bool found = posd->output_offset(object, shndx, offset, &output_offset);
2651 gold_assert(found);
2652 return posd->address() + output_offset;
2655 // Fall back to the slow look-up.
2656 for (Input_section_list::const_iterator p = this->input_sections_.begin();
2657 p != this->input_sections_.end();
2658 ++p)
2660 addr = align_address(addr, p->addralign());
2661 section_offset_type output_offset;
2662 if (p->output_offset(object, shndx, offset, &output_offset))
2664 if (output_offset == -1)
2665 return -1ULL;
2666 return addr + output_offset;
2668 addr += p->data_size();
2671 // If we get here, it means that we don't know the mapping for this
2672 // input section. This might happen in principle if
2673 // add_input_section were called before add_output_section_data.
2674 // But it should never actually happen.
2676 gold_unreachable();
2679 // Find the output address of the start of the merged section for
2680 // input section SHNDX in object OBJECT.
2682 bool
2683 Output_section::find_starting_output_address(const Relobj* object,
2684 unsigned int shndx,
2685 uint64_t* paddr) const
2687 // FIXME: This becomes a bottle-neck if we have many relaxed sections.
2688 // Looking up the merge section map does not always work as we sometimes
2689 // find a merge section without its address set.
2690 uint64_t addr = this->address() + this->first_input_offset_;
2691 for (Input_section_list::const_iterator p = this->input_sections_.begin();
2692 p != this->input_sections_.end();
2693 ++p)
2695 addr = align_address(addr, p->addralign());
2697 // It would be nice if we could use the existing output_offset
2698 // method to get the output offset of input offset 0.
2699 // Unfortunately we don't know for sure that input offset 0 is
2700 // mapped at all.
2701 if (p->is_merge_section_for(object, shndx))
2703 *paddr = addr;
2704 return true;
2707 addr += p->data_size();
2710 // We couldn't find a merge output section for this input section.
2711 return false;
2714 // Set the data size of an Output_section. This is where we handle
2715 // setting the addresses of any Output_section_data objects.
2717 void
2718 Output_section::set_final_data_size()
2720 if (this->input_sections_.empty())
2722 this->set_data_size(this->current_data_size_for_child());
2723 return;
2726 if (this->must_sort_attached_input_sections()
2727 || this->input_section_order_specified())
2728 this->sort_attached_input_sections();
2730 uint64_t address = this->address();
2731 off_t startoff = this->offset();
2732 off_t off = startoff + this->first_input_offset_;
2733 for (Input_section_list::iterator p = this->input_sections_.begin();
2734 p != this->input_sections_.end();
2735 ++p)
2737 off = align_address(off, p->addralign());
2738 p->set_address_and_file_offset(address + (off - startoff), off,
2739 startoff);
2740 off += p->data_size();
2743 this->set_data_size(off - startoff);
2746 // Reset the address and file offset.
2748 void
2749 Output_section::do_reset_address_and_file_offset()
2751 // An unallocated section has no address. Forcing this means that
2752 // we don't need special treatment for symbols defined in debug
2753 // sections. We do the same in the constructor. This does not
2754 // apply to NOLOAD sections though.
2755 if (((this->flags_ & elfcpp::SHF_ALLOC) == 0) && !this->is_noload_)
2756 this->set_address(0);
2758 for (Input_section_list::iterator p = this->input_sections_.begin();
2759 p != this->input_sections_.end();
2760 ++p)
2761 p->reset_address_and_file_offset();
2764 // Return true if address and file offset have the values after reset.
2766 bool
2767 Output_section::do_address_and_file_offset_have_reset_values() const
2769 if (this->is_offset_valid())
2770 return false;
2772 // An unallocated section has address 0 after its construction or a reset.
2773 if ((this->flags_ & elfcpp::SHF_ALLOC) == 0)
2774 return this->is_address_valid() && this->address() == 0;
2775 else
2776 return !this->is_address_valid();
2779 // Set the TLS offset. Called only for SHT_TLS sections.
2781 void
2782 Output_section::do_set_tls_offset(uint64_t tls_base)
2784 this->tls_offset_ = this->address() - tls_base;
2787 // In a few cases we need to sort the input sections attached to an
2788 // output section. This is used to implement the type of constructor
2789 // priority ordering implemented by the GNU linker, in which the
2790 // priority becomes part of the section name and the sections are
2791 // sorted by name. We only do this for an output section if we see an
2792 // attached input section matching ".ctor.*", ".dtor.*",
2793 // ".init_array.*" or ".fini_array.*".
2795 class Output_section::Input_section_sort_entry
2797 public:
2798 Input_section_sort_entry()
2799 : input_section_(), index_(-1U), section_has_name_(false),
2800 section_name_()
2803 Input_section_sort_entry(const Input_section& input_section,
2804 unsigned int index,
2805 bool must_sort_attached_input_sections)
2806 : input_section_(input_section), index_(index),
2807 section_has_name_(input_section.is_input_section()
2808 || input_section.is_relaxed_input_section())
2810 if (this->section_has_name_
2811 && must_sort_attached_input_sections)
2813 // This is only called single-threaded from Layout::finalize,
2814 // so it is OK to lock. Unfortunately we have no way to pass
2815 // in a Task token.
2816 const Task* dummy_task = reinterpret_cast<const Task*>(-1);
2817 Object* obj = (input_section.is_input_section()
2818 ? input_section.relobj()
2819 : input_section.relaxed_input_section()->relobj());
2820 Task_lock_obj<Object> tl(dummy_task, obj);
2822 // This is a slow operation, which should be cached in
2823 // Layout::layout if this becomes a speed problem.
2824 this->section_name_ = obj->section_name(input_section.shndx());
2828 // Return the Input_section.
2829 const Input_section&
2830 input_section() const
2832 gold_assert(this->index_ != -1U);
2833 return this->input_section_;
2836 // The index of this entry in the original list. This is used to
2837 // make the sort stable.
2838 unsigned int
2839 index() const
2841 gold_assert(this->index_ != -1U);
2842 return this->index_;
2845 // Whether there is a section name.
2846 bool
2847 section_has_name() const
2848 { return this->section_has_name_; }
2850 // The section name.
2851 const std::string&
2852 section_name() const
2854 gold_assert(this->section_has_name_);
2855 return this->section_name_;
2858 // Return true if the section name has a priority. This is assumed
2859 // to be true if it has a dot after the initial dot.
2860 bool
2861 has_priority() const
2863 gold_assert(this->section_has_name_);
2864 return this->section_name_.find('.', 1) != std::string::npos;
2867 // Return true if this an input file whose base name matches
2868 // FILE_NAME. The base name must have an extension of ".o", and
2869 // must be exactly FILE_NAME.o or FILE_NAME, one character, ".o".
2870 // This is to match crtbegin.o as well as crtbeginS.o without
2871 // getting confused by other possibilities. Overall matching the
2872 // file name this way is a dreadful hack, but the GNU linker does it
2873 // in order to better support gcc, and we need to be compatible.
2874 bool
2875 match_file_name(const char* match_file_name) const
2877 const std::string& file_name(this->input_section_.relobj()->name());
2878 const char* base_name = lbasename(file_name.c_str());
2879 size_t match_len = strlen(match_file_name);
2880 if (strncmp(base_name, match_file_name, match_len) != 0)
2881 return false;
2882 size_t base_len = strlen(base_name);
2883 if (base_len != match_len + 2 && base_len != match_len + 3)
2884 return false;
2885 return memcmp(base_name + base_len - 2, ".o", 2) == 0;
2888 // Returns 1 if THIS should appear before S in section order, -1 if S
2889 // appears before THIS and 0 if they are not comparable.
2891 compare_section_ordering(const Input_section_sort_entry& s) const
2893 unsigned int this_secn_index = this->input_section_.section_order_index();
2894 unsigned int s_secn_index = s.input_section().section_order_index();
2895 if (this_secn_index > 0 && s_secn_index > 0)
2897 if (this_secn_index < s_secn_index)
2898 return 1;
2899 else if (this_secn_index > s_secn_index)
2900 return -1;
2902 return 0;
2905 private:
2906 // The Input_section we are sorting.
2907 Input_section input_section_;
2908 // The index of this Input_section in the original list.
2909 unsigned int index_;
2910 // Whether this Input_section has a section name--it won't if this
2911 // is some random Output_section_data.
2912 bool section_has_name_;
2913 // The section name if there is one.
2914 std::string section_name_;
2917 // Return true if S1 should come before S2 in the output section.
2919 bool
2920 Output_section::Input_section_sort_compare::operator()(
2921 const Output_section::Input_section_sort_entry& s1,
2922 const Output_section::Input_section_sort_entry& s2) const
2924 // crtbegin.o must come first.
2925 bool s1_begin = s1.match_file_name("crtbegin");
2926 bool s2_begin = s2.match_file_name("crtbegin");
2927 if (s1_begin || s2_begin)
2929 if (!s1_begin)
2930 return false;
2931 if (!s2_begin)
2932 return true;
2933 return s1.index() < s2.index();
2936 // crtend.o must come last.
2937 bool s1_end = s1.match_file_name("crtend");
2938 bool s2_end = s2.match_file_name("crtend");
2939 if (s1_end || s2_end)
2941 if (!s1_end)
2942 return true;
2943 if (!s2_end)
2944 return false;
2945 return s1.index() < s2.index();
2948 // We sort all the sections with no names to the end.
2949 if (!s1.section_has_name() || !s2.section_has_name())
2951 if (s1.section_has_name())
2952 return true;
2953 if (s2.section_has_name())
2954 return false;
2955 return s1.index() < s2.index();
2958 // A section with a priority follows a section without a priority.
2959 bool s1_has_priority = s1.has_priority();
2960 bool s2_has_priority = s2.has_priority();
2961 if (s1_has_priority && !s2_has_priority)
2962 return false;
2963 if (!s1_has_priority && s2_has_priority)
2964 return true;
2966 // Check if a section order exists for these sections through a section
2967 // ordering file. If sequence_num is 0, an order does not exist.
2968 int sequence_num = s1.compare_section_ordering(s2);
2969 if (sequence_num != 0)
2970 return sequence_num == 1;
2972 // Otherwise we sort by name.
2973 int compare = s1.section_name().compare(s2.section_name());
2974 if (compare != 0)
2975 return compare < 0;
2977 // Otherwise we keep the input order.
2978 return s1.index() < s2.index();
2981 // Return true if S1 should come before S2 in an .init_array or .fini_array
2982 // output section.
2984 bool
2985 Output_section::Input_section_sort_init_fini_compare::operator()(
2986 const Output_section::Input_section_sort_entry& s1,
2987 const Output_section::Input_section_sort_entry& s2) const
2989 // We sort all the sections with no names to the end.
2990 if (!s1.section_has_name() || !s2.section_has_name())
2992 if (s1.section_has_name())
2993 return true;
2994 if (s2.section_has_name())
2995 return false;
2996 return s1.index() < s2.index();
2999 // A section without a priority follows a section with a priority.
3000 // This is the reverse of .ctors and .dtors sections.
3001 bool s1_has_priority = s1.has_priority();
3002 bool s2_has_priority = s2.has_priority();
3003 if (s1_has_priority && !s2_has_priority)
3004 return true;
3005 if (!s1_has_priority && s2_has_priority)
3006 return false;
3008 // Check if a section order exists for these sections through a section
3009 // ordering file. If sequence_num is 0, an order does not exist.
3010 int sequence_num = s1.compare_section_ordering(s2);
3011 if (sequence_num != 0)
3012 return sequence_num == 1;
3014 // Otherwise we sort by name.
3015 int compare = s1.section_name().compare(s2.section_name());
3016 if (compare != 0)
3017 return compare < 0;
3019 // Otherwise we keep the input order.
3020 return s1.index() < s2.index();
3023 // Return true if S1 should come before S2. Sections that do not match
3024 // any pattern in the section ordering file are placed ahead of the sections
3025 // that match some pattern.
3027 bool
3028 Output_section::Input_section_sort_section_order_index_compare::operator()(
3029 const Output_section::Input_section_sort_entry& s1,
3030 const Output_section::Input_section_sort_entry& s2) const
3032 unsigned int s1_secn_index = s1.input_section().section_order_index();
3033 unsigned int s2_secn_index = s2.input_section().section_order_index();
3035 // Keep input order if section ordering cannot determine order.
3036 if (s1_secn_index == s2_secn_index)
3037 return s1.index() < s2.index();
3039 return s1_secn_index < s2_secn_index;
3042 // Sort the input sections attached to an output section.
3044 void
3045 Output_section::sort_attached_input_sections()
3047 if (this->attached_input_sections_are_sorted_)
3048 return;
3050 if (this->checkpoint_ != NULL
3051 && !this->checkpoint_->input_sections_saved())
3052 this->checkpoint_->save_input_sections();
3054 // The only thing we know about an input section is the object and
3055 // the section index. We need the section name. Recomputing this
3056 // is slow but this is an unusual case. If this becomes a speed
3057 // problem we can cache the names as required in Layout::layout.
3059 // We start by building a larger vector holding a copy of each
3060 // Input_section, plus its current index in the list and its name.
3061 std::vector<Input_section_sort_entry> sort_list;
3063 unsigned int i = 0;
3064 for (Input_section_list::iterator p = this->input_sections_.begin();
3065 p != this->input_sections_.end();
3066 ++p, ++i)
3067 sort_list.push_back(Input_section_sort_entry(*p, i,
3068 this->must_sort_attached_input_sections()));
3070 // Sort the input sections.
3071 if (this->must_sort_attached_input_sections())
3073 if (this->type() == elfcpp::SHT_PREINIT_ARRAY
3074 || this->type() == elfcpp::SHT_INIT_ARRAY
3075 || this->type() == elfcpp::SHT_FINI_ARRAY)
3076 std::sort(sort_list.begin(), sort_list.end(),
3077 Input_section_sort_init_fini_compare());
3078 else
3079 std::sort(sort_list.begin(), sort_list.end(),
3080 Input_section_sort_compare());
3082 else
3084 gold_assert(parameters->options().section_ordering_file());
3085 std::sort(sort_list.begin(), sort_list.end(),
3086 Input_section_sort_section_order_index_compare());
3089 // Copy the sorted input sections back to our list.
3090 this->input_sections_.clear();
3091 for (std::vector<Input_section_sort_entry>::iterator p = sort_list.begin();
3092 p != sort_list.end();
3093 ++p)
3094 this->input_sections_.push_back(p->input_section());
3095 sort_list.clear();
3097 // Remember that we sorted the input sections, since we might get
3098 // called again.
3099 this->attached_input_sections_are_sorted_ = true;
3102 // Write the section header to *OSHDR.
3104 template<int size, bool big_endian>
3105 void
3106 Output_section::write_header(const Layout* layout,
3107 const Stringpool* secnamepool,
3108 elfcpp::Shdr_write<size, big_endian>* oshdr) const
3110 oshdr->put_sh_name(secnamepool->get_offset(this->name_));
3111 oshdr->put_sh_type(this->type_);
3113 elfcpp::Elf_Xword flags = this->flags_;
3114 if (this->info_section_ != NULL && this->info_uses_section_index_)
3115 flags |= elfcpp::SHF_INFO_LINK;
3116 oshdr->put_sh_flags(flags);
3118 oshdr->put_sh_addr(this->address());
3119 oshdr->put_sh_offset(this->offset());
3120 oshdr->put_sh_size(this->data_size());
3121 if (this->link_section_ != NULL)
3122 oshdr->put_sh_link(this->link_section_->out_shndx());
3123 else if (this->should_link_to_symtab_)
3124 oshdr->put_sh_link(layout->symtab_section()->out_shndx());
3125 else if (this->should_link_to_dynsym_)
3126 oshdr->put_sh_link(layout->dynsym_section()->out_shndx());
3127 else
3128 oshdr->put_sh_link(this->link_);
3130 elfcpp::Elf_Word info;
3131 if (this->info_section_ != NULL)
3133 if (this->info_uses_section_index_)
3134 info = this->info_section_->out_shndx();
3135 else
3136 info = this->info_section_->symtab_index();
3138 else if (this->info_symndx_ != NULL)
3139 info = this->info_symndx_->symtab_index();
3140 else
3141 info = this->info_;
3142 oshdr->put_sh_info(info);
3144 oshdr->put_sh_addralign(this->addralign_);
3145 oshdr->put_sh_entsize(this->entsize_);
3148 // Write out the data. For input sections the data is written out by
3149 // Object::relocate, but we have to handle Output_section_data objects
3150 // here.
3152 void
3153 Output_section::do_write(Output_file* of)
3155 gold_assert(!this->requires_postprocessing());
3157 // If the target performs relaxation, we delay filler generation until now.
3158 gold_assert(!this->generate_code_fills_at_write_ || this->fills_.empty());
3160 off_t output_section_file_offset = this->offset();
3161 for (Fill_list::iterator p = this->fills_.begin();
3162 p != this->fills_.end();
3163 ++p)
3165 std::string fill_data(parameters->target().code_fill(p->length()));
3166 of->write(output_section_file_offset + p->section_offset(),
3167 fill_data.data(), fill_data.size());
3170 off_t off = this->offset() + this->first_input_offset_;
3171 for (Input_section_list::iterator p = this->input_sections_.begin();
3172 p != this->input_sections_.end();
3173 ++p)
3175 off_t aligned_off = align_address(off, p->addralign());
3176 if (this->generate_code_fills_at_write_ && (off != aligned_off))
3178 size_t fill_len = aligned_off - off;
3179 std::string fill_data(parameters->target().code_fill(fill_len));
3180 of->write(off, fill_data.data(), fill_data.size());
3183 p->write(of);
3184 off = aligned_off + p->data_size();
3188 // If a section requires postprocessing, create the buffer to use.
3190 void
3191 Output_section::create_postprocessing_buffer()
3193 gold_assert(this->requires_postprocessing());
3195 if (this->postprocessing_buffer_ != NULL)
3196 return;
3198 if (!this->input_sections_.empty())
3200 off_t off = this->first_input_offset_;
3201 for (Input_section_list::iterator p = this->input_sections_.begin();
3202 p != this->input_sections_.end();
3203 ++p)
3205 off = align_address(off, p->addralign());
3206 p->finalize_data_size();
3207 off += p->data_size();
3209 this->set_current_data_size_for_child(off);
3212 off_t buffer_size = this->current_data_size_for_child();
3213 this->postprocessing_buffer_ = new unsigned char[buffer_size];
3216 // Write all the data of an Output_section into the postprocessing
3217 // buffer. This is used for sections which require postprocessing,
3218 // such as compression. Input sections are handled by
3219 // Object::Relocate.
3221 void
3222 Output_section::write_to_postprocessing_buffer()
3224 gold_assert(this->requires_postprocessing());
3226 // If the target performs relaxation, we delay filler generation until now.
3227 gold_assert(!this->generate_code_fills_at_write_ || this->fills_.empty());
3229 unsigned char* buffer = this->postprocessing_buffer();
3230 for (Fill_list::iterator p = this->fills_.begin();
3231 p != this->fills_.end();
3232 ++p)
3234 std::string fill_data(parameters->target().code_fill(p->length()));
3235 memcpy(buffer + p->section_offset(), fill_data.data(),
3236 fill_data.size());
3239 off_t off = this->first_input_offset_;
3240 for (Input_section_list::iterator p = this->input_sections_.begin();
3241 p != this->input_sections_.end();
3242 ++p)
3244 off_t aligned_off = align_address(off, p->addralign());
3245 if (this->generate_code_fills_at_write_ && (off != aligned_off))
3247 size_t fill_len = aligned_off - off;
3248 std::string fill_data(parameters->target().code_fill(fill_len));
3249 memcpy(buffer + off, fill_data.data(), fill_data.size());
3252 p->write_to_buffer(buffer + aligned_off);
3253 off = aligned_off + p->data_size();
3257 // Get the input sections for linker script processing. We leave
3258 // behind the Output_section_data entries. Note that this may be
3259 // slightly incorrect for merge sections. We will leave them behind,
3260 // but it is possible that the script says that they should follow
3261 // some other input sections, as in:
3262 // .rodata { *(.rodata) *(.rodata.cst*) }
3263 // For that matter, we don't handle this correctly:
3264 // .rodata { foo.o(.rodata.cst*) *(.rodata.cst*) }
3265 // With luck this will never matter.
3267 uint64_t
3268 Output_section::get_input_sections(
3269 uint64_t address,
3270 const std::string& fill,
3271 std::list<Input_section>* input_sections)
3273 if (this->checkpoint_ != NULL
3274 && !this->checkpoint_->input_sections_saved())
3275 this->checkpoint_->save_input_sections();
3277 // Invalidate fast look-up maps.
3278 this->lookup_maps_->invalidate();
3280 uint64_t orig_address = address;
3282 address = align_address(address, this->addralign());
3284 Input_section_list remaining;
3285 for (Input_section_list::iterator p = this->input_sections_.begin();
3286 p != this->input_sections_.end();
3287 ++p)
3289 if (p->is_input_section()
3290 || p->is_relaxed_input_section()
3291 || p->is_merge_section())
3292 input_sections->push_back(*p);
3293 else
3295 uint64_t aligned_address = align_address(address, p->addralign());
3296 if (aligned_address != address && !fill.empty())
3298 section_size_type length =
3299 convert_to_section_size_type(aligned_address - address);
3300 std::string this_fill;
3301 this_fill.reserve(length);
3302 while (this_fill.length() + fill.length() <= length)
3303 this_fill += fill;
3304 if (this_fill.length() < length)
3305 this_fill.append(fill, 0, length - this_fill.length());
3307 Output_section_data* posd = new Output_data_const(this_fill, 0);
3308 remaining.push_back(Input_section(posd));
3310 address = aligned_address;
3312 remaining.push_back(*p);
3314 p->finalize_data_size();
3315 address += p->data_size();
3319 this->input_sections_.swap(remaining);
3320 this->first_input_offset_ = 0;
3322 uint64_t data_size = address - orig_address;
3323 this->set_current_data_size_for_child(data_size);
3324 return data_size;
3327 // Add a script input section. SIS is an Output_section::Input_section,
3328 // which can be either a plain input section or a special input section like
3329 // a relaxed input section. For a special input section, its size must be
3330 // finalized.
3332 void
3333 Output_section::add_script_input_section(const Input_section& sis)
3335 uint64_t data_size = sis.data_size();
3336 uint64_t addralign = sis.addralign();
3337 if (addralign > this->addralign_)
3338 this->addralign_ = addralign;
3340 off_t offset_in_section = this->current_data_size_for_child();
3341 off_t aligned_offset_in_section = align_address(offset_in_section,
3342 addralign);
3344 this->set_current_data_size_for_child(aligned_offset_in_section
3345 + data_size);
3347 this->input_sections_.push_back(sis);
3349 // Update fast lookup maps if necessary.
3350 if (this->lookup_maps_->is_valid())
3352 if (sis.is_merge_section())
3354 Output_merge_base* pomb = sis.output_merge_base();
3355 Merge_section_properties msp(pomb->is_string(), pomb->entsize(),
3356 pomb->addralign());
3357 this->lookup_maps_->add_merge_section(msp, pomb);
3358 for (Output_merge_base::Input_sections::const_iterator p =
3359 pomb->input_sections_begin();
3360 p != pomb->input_sections_end();
3361 ++p)
3362 this->lookup_maps_->add_merge_input_section(p->first, p->second,
3363 pomb);
3365 else if (sis.is_relaxed_input_section())
3367 Output_relaxed_input_section* poris = sis.relaxed_input_section();
3368 this->lookup_maps_->add_relaxed_input_section(poris->relobj(),
3369 poris->shndx(), poris);
3374 // Save states for relaxation.
3376 void
3377 Output_section::save_states()
3379 gold_assert(this->checkpoint_ == NULL);
3380 Checkpoint_output_section* checkpoint =
3381 new Checkpoint_output_section(this->addralign_, this->flags_,
3382 this->input_sections_,
3383 this->first_input_offset_,
3384 this->attached_input_sections_are_sorted_);
3385 this->checkpoint_ = checkpoint;
3386 gold_assert(this->fills_.empty());
3389 void
3390 Output_section::discard_states()
3392 gold_assert(this->checkpoint_ != NULL);
3393 delete this->checkpoint_;
3394 this->checkpoint_ = NULL;
3395 gold_assert(this->fills_.empty());
3397 // Simply invalidate the fast lookup maps since we do not keep
3398 // track of them.
3399 this->lookup_maps_->invalidate();
3402 void
3403 Output_section::restore_states()
3405 gold_assert(this->checkpoint_ != NULL);
3406 Checkpoint_output_section* checkpoint = this->checkpoint_;
3408 this->addralign_ = checkpoint->addralign();
3409 this->flags_ = checkpoint->flags();
3410 this->first_input_offset_ = checkpoint->first_input_offset();
3412 if (!checkpoint->input_sections_saved())
3414 // If we have not copied the input sections, just resize it.
3415 size_t old_size = checkpoint->input_sections_size();
3416 gold_assert(this->input_sections_.size() >= old_size);
3417 this->input_sections_.resize(old_size);
3419 else
3421 // We need to copy the whole list. This is not efficient for
3422 // extremely large output with hundreads of thousands of input
3423 // objects. We may need to re-think how we should pass sections
3424 // to scripts.
3425 this->input_sections_ = *checkpoint->input_sections();
3428 this->attached_input_sections_are_sorted_ =
3429 checkpoint->attached_input_sections_are_sorted();
3431 // Simply invalidate the fast lookup maps since we do not keep
3432 // track of them.
3433 this->lookup_maps_->invalidate();
3436 // Update the section offsets of input sections in this. This is required if
3437 // relaxation causes some input sections to change sizes.
3439 void
3440 Output_section::adjust_section_offsets()
3442 if (!this->section_offsets_need_adjustment_)
3443 return;
3445 off_t off = 0;
3446 for (Input_section_list::iterator p = this->input_sections_.begin();
3447 p != this->input_sections_.end();
3448 ++p)
3450 off = align_address(off, p->addralign());
3451 if (p->is_input_section())
3452 p->relobj()->set_section_offset(p->shndx(), off);
3453 off += p->data_size();
3456 this->section_offsets_need_adjustment_ = false;
3459 // Print to the map file.
3461 void
3462 Output_section::do_print_to_mapfile(Mapfile* mapfile) const
3464 mapfile->print_output_section(this);
3466 for (Input_section_list::const_iterator p = this->input_sections_.begin();
3467 p != this->input_sections_.end();
3468 ++p)
3469 p->print_to_mapfile(mapfile);
3472 // Print stats for merge sections to stderr.
3474 void
3475 Output_section::print_merge_stats()
3477 Input_section_list::iterator p;
3478 for (p = this->input_sections_.begin();
3479 p != this->input_sections_.end();
3480 ++p)
3481 p->print_merge_stats(this->name_);
3484 // Output segment methods.
3486 Output_segment::Output_segment(elfcpp::Elf_Word type, elfcpp::Elf_Word flags)
3487 : vaddr_(0),
3488 paddr_(0),
3489 memsz_(0),
3490 max_align_(0),
3491 min_p_align_(0),
3492 offset_(0),
3493 filesz_(0),
3494 type_(type),
3495 flags_(flags),
3496 is_max_align_known_(false),
3497 are_addresses_set_(false),
3498 is_large_data_segment_(false)
3500 // The ELF ABI specifies that a PT_TLS segment always has PF_R as
3501 // the flags.
3502 if (type == elfcpp::PT_TLS)
3503 this->flags_ = elfcpp::PF_R;
3506 // Add an Output_section to a PT_LOAD Output_segment.
3508 void
3509 Output_segment::add_output_section_to_load(Layout* layout,
3510 Output_section* os,
3511 elfcpp::Elf_Word seg_flags)
3513 gold_assert(this->type() == elfcpp::PT_LOAD);
3514 gold_assert((os->flags() & elfcpp::SHF_ALLOC) != 0);
3515 gold_assert(!this->is_max_align_known_);
3516 gold_assert(os->is_large_data_section() == this->is_large_data_segment());
3518 this->update_flags_for_output_section(seg_flags);
3520 // We don't want to change the ordering if we have a linker script
3521 // with a SECTIONS clause.
3522 Output_section_order order = os->order();
3523 if (layout->script_options()->saw_sections_clause())
3524 order = static_cast<Output_section_order>(0);
3525 else
3526 gold_assert(order != ORDER_INVALID);
3528 this->output_lists_[order].push_back(os);
3531 // Add an Output_section to a non-PT_LOAD Output_segment.
3533 void
3534 Output_segment::add_output_section_to_nonload(Output_section* os,
3535 elfcpp::Elf_Word seg_flags)
3537 gold_assert(this->type() != elfcpp::PT_LOAD);
3538 gold_assert((os->flags() & elfcpp::SHF_ALLOC) != 0);
3539 gold_assert(!this->is_max_align_known_);
3541 this->update_flags_for_output_section(seg_flags);
3543 this->output_lists_[0].push_back(os);
3546 // Remove an Output_section from this segment. It is an error if it
3547 // is not present.
3549 void
3550 Output_segment::remove_output_section(Output_section* os)
3552 for (int i = 0; i < static_cast<int>(ORDER_MAX); ++i)
3554 Output_data_list* pdl = &this->output_lists_[i];
3555 for (Output_data_list::iterator p = pdl->begin(); p != pdl->end(); ++p)
3557 if (*p == os)
3559 pdl->erase(p);
3560 return;
3564 gold_unreachable();
3567 // Add an Output_data (which need not be an Output_section) to the
3568 // start of a segment.
3570 void
3571 Output_segment::add_initial_output_data(Output_data* od)
3573 gold_assert(!this->is_max_align_known_);
3574 Output_data_list::iterator p = this->output_lists_[0].begin();
3575 this->output_lists_[0].insert(p, od);
3578 // Return true if this segment has any sections which hold actual
3579 // data, rather than being a BSS section.
3581 bool
3582 Output_segment::has_any_data_sections() const
3584 for (int i = 0; i < static_cast<int>(ORDER_MAX); ++i)
3586 const Output_data_list* pdl = &this->output_lists_[i];
3587 for (Output_data_list::const_iterator p = pdl->begin();
3588 p != pdl->end();
3589 ++p)
3591 if (!(*p)->is_section())
3592 return true;
3593 if ((*p)->output_section()->type() != elfcpp::SHT_NOBITS)
3594 return true;
3597 return false;
3600 // Return whether the first data section (not counting TLS sections)
3601 // is a relro section.
3603 bool
3604 Output_segment::is_first_section_relro() const
3606 for (int i = 0; i < static_cast<int>(ORDER_MAX); ++i)
3608 if (i == static_cast<int>(ORDER_TLS_DATA)
3609 || i == static_cast<int>(ORDER_TLS_BSS))
3610 continue;
3611 const Output_data_list* pdl = &this->output_lists_[i];
3612 if (!pdl->empty())
3614 Output_data* p = pdl->front();
3615 return p->is_section() && p->output_section()->is_relro();
3618 return false;
3621 // Return the maximum alignment of the Output_data in Output_segment.
3623 uint64_t
3624 Output_segment::maximum_alignment()
3626 if (!this->is_max_align_known_)
3628 for (int i = 0; i < static_cast<int>(ORDER_MAX); ++i)
3630 const Output_data_list* pdl = &this->output_lists_[i];
3631 uint64_t addralign = Output_segment::maximum_alignment_list(pdl);
3632 if (addralign > this->max_align_)
3633 this->max_align_ = addralign;
3635 this->is_max_align_known_ = true;
3638 return this->max_align_;
3641 // Return the maximum alignment of a list of Output_data.
3643 uint64_t
3644 Output_segment::maximum_alignment_list(const Output_data_list* pdl)
3646 uint64_t ret = 0;
3647 for (Output_data_list::const_iterator p = pdl->begin();
3648 p != pdl->end();
3649 ++p)
3651 uint64_t addralign = (*p)->addralign();
3652 if (addralign > ret)
3653 ret = addralign;
3655 return ret;
3658 // Return whether this segment has any dynamic relocs.
3660 bool
3661 Output_segment::has_dynamic_reloc() const
3663 for (int i = 0; i < static_cast<int>(ORDER_MAX); ++i)
3664 if (this->has_dynamic_reloc_list(&this->output_lists_[i]))
3665 return true;
3666 return false;
3669 // Return whether this Output_data_list has any dynamic relocs.
3671 bool
3672 Output_segment::has_dynamic_reloc_list(const Output_data_list* pdl) const
3674 for (Output_data_list::const_iterator p = pdl->begin();
3675 p != pdl->end();
3676 ++p)
3677 if ((*p)->has_dynamic_reloc())
3678 return true;
3679 return false;
3682 // Set the section addresses for an Output_segment. If RESET is true,
3683 // reset the addresses first. ADDR is the address and *POFF is the
3684 // file offset. Set the section indexes starting with *PSHNDX.
3685 // INCREASE_RELRO is the size of the portion of the first non-relro
3686 // section that should be included in the PT_GNU_RELRO segment.
3687 // If this segment has relro sections, and has been aligned for
3688 // that purpose, set *HAS_RELRO to TRUE. Return the address of
3689 // the immediately following segment. Update *HAS_RELRO, *POFF,
3690 // and *PSHNDX.
3692 uint64_t
3693 Output_segment::set_section_addresses(const Layout* layout, bool reset,
3694 uint64_t addr,
3695 unsigned int* increase_relro,
3696 bool* has_relro,
3697 off_t* poff,
3698 unsigned int* pshndx)
3700 gold_assert(this->type_ == elfcpp::PT_LOAD);
3702 uint64_t last_relro_pad = 0;
3703 off_t orig_off = *poff;
3705 bool in_tls = false;
3707 // If we have relro sections, we need to pad forward now so that the
3708 // relro sections plus INCREASE_RELRO end on a common page boundary.
3709 if (parameters->options().relro()
3710 && this->is_first_section_relro()
3711 && (!this->are_addresses_set_ || reset))
3713 uint64_t relro_size = 0;
3714 off_t off = *poff;
3715 uint64_t max_align = 0;
3716 for (int i = 0; i <= static_cast<int>(ORDER_RELRO_LAST); ++i)
3718 Output_data_list* pdl = &this->output_lists_[i];
3719 Output_data_list::iterator p;
3720 for (p = pdl->begin(); p != pdl->end(); ++p)
3722 if (!(*p)->is_section())
3723 break;
3724 uint64_t align = (*p)->addralign();
3725 if (align > max_align)
3726 max_align = align;
3727 if ((*p)->is_section_flag_set(elfcpp::SHF_TLS))
3728 in_tls = true;
3729 else if (in_tls)
3731 // Align the first non-TLS section to the alignment
3732 // of the TLS segment.
3733 align = max_align;
3734 in_tls = false;
3736 relro_size = align_address(relro_size, align);
3737 // Ignore the size of the .tbss section.
3738 if ((*p)->is_section_flag_set(elfcpp::SHF_TLS)
3739 && (*p)->is_section_type(elfcpp::SHT_NOBITS))
3740 continue;
3741 if ((*p)->is_address_valid())
3742 relro_size += (*p)->data_size();
3743 else
3745 // FIXME: This could be faster.
3746 (*p)->set_address_and_file_offset(addr + relro_size,
3747 off + relro_size);
3748 relro_size += (*p)->data_size();
3749 (*p)->reset_address_and_file_offset();
3752 if (p != pdl->end())
3753 break;
3755 relro_size += *increase_relro;
3756 // Pad the total relro size to a multiple of the maximum
3757 // section alignment seen.
3758 uint64_t aligned_size = align_address(relro_size, max_align);
3759 // Note the amount of padding added after the last relro section.
3760 last_relro_pad = aligned_size - relro_size;
3761 *has_relro = true;
3763 uint64_t page_align = parameters->target().common_pagesize();
3765 // Align to offset N such that (N + RELRO_SIZE) % PAGE_ALIGN == 0.
3766 uint64_t desired_align = page_align - (aligned_size % page_align);
3767 if (desired_align < *poff % page_align)
3768 *poff += page_align - *poff % page_align;
3769 *poff += desired_align - *poff % page_align;
3770 addr += *poff - orig_off;
3771 orig_off = *poff;
3774 if (!reset && this->are_addresses_set_)
3776 gold_assert(this->paddr_ == addr);
3777 addr = this->vaddr_;
3779 else
3781 this->vaddr_ = addr;
3782 this->paddr_ = addr;
3783 this->are_addresses_set_ = true;
3786 in_tls = false;
3788 this->offset_ = orig_off;
3790 off_t off = 0;
3791 uint64_t ret;
3792 for (int i = 0; i < static_cast<int>(ORDER_MAX); ++i)
3794 if (i == static_cast<int>(ORDER_RELRO_LAST))
3796 *poff += last_relro_pad;
3797 addr += last_relro_pad;
3798 if (this->output_lists_[i].empty())
3800 // If there is nothing in the ORDER_RELRO_LAST list,
3801 // the padding will occur at the end of the relro
3802 // segment, and we need to add it to *INCREASE_RELRO.
3803 *increase_relro += last_relro_pad;
3806 addr = this->set_section_list_addresses(layout, reset,
3807 &this->output_lists_[i],
3808 addr, poff, pshndx, &in_tls);
3809 if (i < static_cast<int>(ORDER_SMALL_BSS))
3811 this->filesz_ = *poff - orig_off;
3812 off = *poff;
3815 ret = addr;
3818 // If the last section was a TLS section, align upward to the
3819 // alignment of the TLS segment, so that the overall size of the TLS
3820 // segment is aligned.
3821 if (in_tls)
3823 uint64_t segment_align = layout->tls_segment()->maximum_alignment();
3824 *poff = align_address(*poff, segment_align);
3827 this->memsz_ = *poff - orig_off;
3829 // Ignore the file offset adjustments made by the BSS Output_data
3830 // objects.
3831 *poff = off;
3833 return ret;
3836 // Set the addresses and file offsets in a list of Output_data
3837 // structures.
3839 uint64_t
3840 Output_segment::set_section_list_addresses(const Layout* layout, bool reset,
3841 Output_data_list* pdl,
3842 uint64_t addr, off_t* poff,
3843 unsigned int* pshndx,
3844 bool* in_tls)
3846 off_t startoff = *poff;
3848 off_t off = startoff;
3849 for (Output_data_list::iterator p = pdl->begin();
3850 p != pdl->end();
3851 ++p)
3853 if (reset)
3854 (*p)->reset_address_and_file_offset();
3856 // When using a linker script the section will most likely
3857 // already have an address.
3858 if (!(*p)->is_address_valid())
3860 uint64_t align = (*p)->addralign();
3862 if ((*p)->is_section_flag_set(elfcpp::SHF_TLS))
3864 // Give the first TLS section the alignment of the
3865 // entire TLS segment. Otherwise the TLS segment as a
3866 // whole may be misaligned.
3867 if (!*in_tls)
3869 Output_segment* tls_segment = layout->tls_segment();
3870 gold_assert(tls_segment != NULL);
3871 uint64_t segment_align = tls_segment->maximum_alignment();
3872 gold_assert(segment_align >= align);
3873 align = segment_align;
3875 *in_tls = true;
3878 else
3880 // If this is the first section after the TLS segment,
3881 // align it to at least the alignment of the TLS
3882 // segment, so that the size of the overall TLS segment
3883 // is aligned.
3884 if (*in_tls)
3886 uint64_t segment_align =
3887 layout->tls_segment()->maximum_alignment();
3888 if (segment_align > align)
3889 align = segment_align;
3891 *in_tls = false;
3895 off = align_address(off, align);
3896 (*p)->set_address_and_file_offset(addr + (off - startoff), off);
3898 else
3900 // The script may have inserted a skip forward, but it
3901 // better not have moved backward.
3902 if ((*p)->address() >= addr + (off - startoff))
3903 off += (*p)->address() - (addr + (off - startoff));
3904 else
3906 if (!layout->script_options()->saw_sections_clause())
3907 gold_unreachable();
3908 else
3910 Output_section* os = (*p)->output_section();
3912 // Cast to unsigned long long to avoid format warnings.
3913 unsigned long long previous_dot =
3914 static_cast<unsigned long long>(addr + (off - startoff));
3915 unsigned long long dot =
3916 static_cast<unsigned long long>((*p)->address());
3918 if (os == NULL)
3919 gold_error(_("dot moves backward in linker script "
3920 "from 0x%llx to 0x%llx"), previous_dot, dot);
3921 else
3922 gold_error(_("address of section '%s' moves backward "
3923 "from 0x%llx to 0x%llx"),
3924 os->name(), previous_dot, dot);
3927 (*p)->set_file_offset(off);
3928 (*p)->finalize_data_size();
3931 // We want to ignore the size of a SHF_TLS or SHT_NOBITS
3932 // section. Such a section does not affect the size of a
3933 // PT_LOAD segment.
3934 if (!(*p)->is_section_flag_set(elfcpp::SHF_TLS)
3935 || !(*p)->is_section_type(elfcpp::SHT_NOBITS))
3936 off += (*p)->data_size();
3938 if ((*p)->is_section())
3940 (*p)->set_out_shndx(*pshndx);
3941 ++*pshndx;
3945 *poff = off;
3946 return addr + (off - startoff);
3949 // For a non-PT_LOAD segment, set the offset from the sections, if
3950 // any. Add INCREASE to the file size and the memory size.
3952 void
3953 Output_segment::set_offset(unsigned int increase)
3955 gold_assert(this->type_ != elfcpp::PT_LOAD);
3957 gold_assert(!this->are_addresses_set_);
3959 // A non-load section only uses output_lists_[0].
3961 Output_data_list* pdl = &this->output_lists_[0];
3963 if (pdl->empty())
3965 gold_assert(increase == 0);
3966 this->vaddr_ = 0;
3967 this->paddr_ = 0;
3968 this->are_addresses_set_ = true;
3969 this->memsz_ = 0;
3970 this->min_p_align_ = 0;
3971 this->offset_ = 0;
3972 this->filesz_ = 0;
3973 return;
3976 // Find the first and last section by address.
3977 const Output_data* first = NULL;
3978 const Output_data* last_data = NULL;
3979 const Output_data* last_bss = NULL;
3980 for (Output_data_list::const_iterator p = pdl->begin();
3981 p != pdl->end();
3982 ++p)
3984 if (first == NULL
3985 || (*p)->address() < first->address()
3986 || ((*p)->address() == first->address()
3987 && (*p)->data_size() < first->data_size()))
3988 first = *p;
3989 const Output_data** plast;
3990 if ((*p)->is_section()
3991 && (*p)->output_section()->type() == elfcpp::SHT_NOBITS)
3992 plast = &last_bss;
3993 else
3994 plast = &last_data;
3995 if (*plast == NULL
3996 || (*p)->address() > (*plast)->address()
3997 || ((*p)->address() == (*plast)->address()
3998 && (*p)->data_size() > (*plast)->data_size()))
3999 *plast = *p;
4002 this->vaddr_ = first->address();
4003 this->paddr_ = (first->has_load_address()
4004 ? first->load_address()
4005 : this->vaddr_);
4006 this->are_addresses_set_ = true;
4007 this->offset_ = first->offset();
4009 if (last_data == NULL)
4010 this->filesz_ = 0;
4011 else
4012 this->filesz_ = (last_data->address()
4013 + last_data->data_size()
4014 - this->vaddr_);
4016 const Output_data* last = last_bss != NULL ? last_bss : last_data;
4017 this->memsz_ = (last->address()
4018 + last->data_size()
4019 - this->vaddr_);
4021 this->filesz_ += increase;
4022 this->memsz_ += increase;
4024 // If this is a RELRO segment, verify that the segment ends at a
4025 // page boundary.
4026 if (this->type_ == elfcpp::PT_GNU_RELRO)
4028 uint64_t page_align = parameters->target().common_pagesize();
4029 uint64_t segment_end = this->vaddr_ + this->memsz_;
4030 gold_assert(segment_end == align_address(segment_end, page_align));
4033 // If this is a TLS segment, align the memory size. The code in
4034 // set_section_list ensures that the section after the TLS segment
4035 // is aligned to give us room.
4036 if (this->type_ == elfcpp::PT_TLS)
4038 uint64_t segment_align = this->maximum_alignment();
4039 gold_assert(this->vaddr_ == align_address(this->vaddr_, segment_align));
4040 this->memsz_ = align_address(this->memsz_, segment_align);
4044 // Set the TLS offsets of the sections in the PT_TLS segment.
4046 void
4047 Output_segment::set_tls_offsets()
4049 gold_assert(this->type_ == elfcpp::PT_TLS);
4051 for (Output_data_list::iterator p = this->output_lists_[0].begin();
4052 p != this->output_lists_[0].end();
4053 ++p)
4054 (*p)->set_tls_offset(this->vaddr_);
4057 // Return the load address of the first section.
4059 uint64_t
4060 Output_segment::first_section_load_address() const
4062 for (int i = 0; i < static_cast<int>(ORDER_MAX); ++i)
4064 const Output_data_list* pdl = &this->output_lists_[i];
4065 for (Output_data_list::const_iterator p = pdl->begin();
4066 p != pdl->end();
4067 ++p)
4069 if ((*p)->is_section())
4070 return ((*p)->has_load_address()
4071 ? (*p)->load_address()
4072 : (*p)->address());
4075 gold_unreachable();
4078 // Return the number of Output_sections in an Output_segment.
4080 unsigned int
4081 Output_segment::output_section_count() const
4083 unsigned int ret = 0;
4084 for (int i = 0; i < static_cast<int>(ORDER_MAX); ++i)
4085 ret += this->output_section_count_list(&this->output_lists_[i]);
4086 return ret;
4089 // Return the number of Output_sections in an Output_data_list.
4091 unsigned int
4092 Output_segment::output_section_count_list(const Output_data_list* pdl) const
4094 unsigned int count = 0;
4095 for (Output_data_list::const_iterator p = pdl->begin();
4096 p != pdl->end();
4097 ++p)
4099 if ((*p)->is_section())
4100 ++count;
4102 return count;
4105 // Return the section attached to the list segment with the lowest
4106 // load address. This is used when handling a PHDRS clause in a
4107 // linker script.
4109 Output_section*
4110 Output_segment::section_with_lowest_load_address() const
4112 Output_section* found = NULL;
4113 uint64_t found_lma = 0;
4114 for (int i = 0; i < static_cast<int>(ORDER_MAX); ++i)
4115 this->lowest_load_address_in_list(&this->output_lists_[i], &found,
4116 &found_lma);
4117 return found;
4120 // Look through a list for a section with a lower load address.
4122 void
4123 Output_segment::lowest_load_address_in_list(const Output_data_list* pdl,
4124 Output_section** found,
4125 uint64_t* found_lma) const
4127 for (Output_data_list::const_iterator p = pdl->begin();
4128 p != pdl->end();
4129 ++p)
4131 if (!(*p)->is_section())
4132 continue;
4133 Output_section* os = static_cast<Output_section*>(*p);
4134 uint64_t lma = (os->has_load_address()
4135 ? os->load_address()
4136 : os->address());
4137 if (*found == NULL || lma < *found_lma)
4139 *found = os;
4140 *found_lma = lma;
4145 // Write the segment data into *OPHDR.
4147 template<int size, bool big_endian>
4148 void
4149 Output_segment::write_header(elfcpp::Phdr_write<size, big_endian>* ophdr)
4151 ophdr->put_p_type(this->type_);
4152 ophdr->put_p_offset(this->offset_);
4153 ophdr->put_p_vaddr(this->vaddr_);
4154 ophdr->put_p_paddr(this->paddr_);
4155 ophdr->put_p_filesz(this->filesz_);
4156 ophdr->put_p_memsz(this->memsz_);
4157 ophdr->put_p_flags(this->flags_);
4158 ophdr->put_p_align(std::max(this->min_p_align_, this->maximum_alignment()));
4161 // Write the section headers into V.
4163 template<int size, bool big_endian>
4164 unsigned char*
4165 Output_segment::write_section_headers(const Layout* layout,
4166 const Stringpool* secnamepool,
4167 unsigned char* v,
4168 unsigned int* pshndx) const
4170 // Every section that is attached to a segment must be attached to a
4171 // PT_LOAD segment, so we only write out section headers for PT_LOAD
4172 // segments.
4173 if (this->type_ != elfcpp::PT_LOAD)
4174 return v;
4176 for (int i = 0; i < static_cast<int>(ORDER_MAX); ++i)
4178 const Output_data_list* pdl = &this->output_lists_[i];
4179 v = this->write_section_headers_list<size, big_endian>(layout,
4180 secnamepool,
4181 pdl,
4182 v, pshndx);
4185 return v;
4188 template<int size, bool big_endian>
4189 unsigned char*
4190 Output_segment::write_section_headers_list(const Layout* layout,
4191 const Stringpool* secnamepool,
4192 const Output_data_list* pdl,
4193 unsigned char* v,
4194 unsigned int* pshndx) const
4196 const int shdr_size = elfcpp::Elf_sizes<size>::shdr_size;
4197 for (Output_data_list::const_iterator p = pdl->begin();
4198 p != pdl->end();
4199 ++p)
4201 if ((*p)->is_section())
4203 const Output_section* ps = static_cast<const Output_section*>(*p);
4204 gold_assert(*pshndx == ps->out_shndx());
4205 elfcpp::Shdr_write<size, big_endian> oshdr(v);
4206 ps->write_header(layout, secnamepool, &oshdr);
4207 v += shdr_size;
4208 ++*pshndx;
4211 return v;
4214 // Print the output sections to the map file.
4216 void
4217 Output_segment::print_sections_to_mapfile(Mapfile* mapfile) const
4219 if (this->type() != elfcpp::PT_LOAD)
4220 return;
4221 for (int i = 0; i < static_cast<int>(ORDER_MAX); ++i)
4222 this->print_section_list_to_mapfile(mapfile, &this->output_lists_[i]);
4225 // Print an output section list to the map file.
4227 void
4228 Output_segment::print_section_list_to_mapfile(Mapfile* mapfile,
4229 const Output_data_list* pdl) const
4231 for (Output_data_list::const_iterator p = pdl->begin();
4232 p != pdl->end();
4233 ++p)
4234 (*p)->print_to_mapfile(mapfile);
4237 // Output_file methods.
4239 Output_file::Output_file(const char* name)
4240 : name_(name),
4241 o_(-1),
4242 file_size_(0),
4243 base_(NULL),
4244 map_is_anonymous_(false),
4245 is_temporary_(false)
4249 // Try to open an existing file. Returns false if the file doesn't
4250 // exist, has a size of 0 or can't be mmapped.
4252 bool
4253 Output_file::open_for_modification()
4255 // The name "-" means "stdout".
4256 if (strcmp(this->name_, "-") == 0)
4257 return false;
4259 // Don't bother opening files with a size of zero.
4260 struct stat s;
4261 if (::stat(this->name_, &s) != 0 || s.st_size == 0)
4262 return false;
4264 int o = open_descriptor(-1, this->name_, O_RDWR, 0);
4265 if (o < 0)
4266 gold_fatal(_("%s: open: %s"), this->name_, strerror(errno));
4267 this->o_ = o;
4268 this->file_size_ = s.st_size;
4270 // If the file can't be mmapped, copying the content to an anonymous
4271 // map will probably negate the performance benefits of incremental
4272 // linking. This could be helped by using views and loading only
4273 // the necessary parts, but this is not supported as of now.
4274 if (!this->map_no_anonymous())
4276 release_descriptor(o, true);
4277 this->o_ = -1;
4278 this->file_size_ = 0;
4279 return false;
4282 return true;
4285 // Open the output file.
4287 void
4288 Output_file::open(off_t file_size)
4290 this->file_size_ = file_size;
4292 // Unlink the file first; otherwise the open() may fail if the file
4293 // is busy (e.g. it's an executable that's currently being executed).
4295 // However, the linker may be part of a system where a zero-length
4296 // file is created for it to write to, with tight permissions (gcc
4297 // 2.95 did something like this). Unlinking the file would work
4298 // around those permission controls, so we only unlink if the file
4299 // has a non-zero size. We also unlink only regular files to avoid
4300 // trouble with directories/etc.
4302 // If we fail, continue; this command is merely a best-effort attempt
4303 // to improve the odds for open().
4305 // We let the name "-" mean "stdout"
4306 if (!this->is_temporary_)
4308 if (strcmp(this->name_, "-") == 0)
4309 this->o_ = STDOUT_FILENO;
4310 else
4312 struct stat s;
4313 if (::stat(this->name_, &s) == 0
4314 && (S_ISREG (s.st_mode) || S_ISLNK (s.st_mode)))
4316 if (s.st_size != 0)
4317 ::unlink(this->name_);
4318 else if (!parameters->options().relocatable())
4320 // If we don't unlink the existing file, add execute
4321 // permission where read permissions already exist
4322 // and where the umask permits.
4323 int mask = ::umask(0);
4324 ::umask(mask);
4325 s.st_mode |= (s.st_mode & 0444) >> 2;
4326 ::chmod(this->name_, s.st_mode & ~mask);
4330 int mode = parameters->options().relocatable() ? 0666 : 0777;
4331 int o = open_descriptor(-1, this->name_, O_RDWR | O_CREAT | O_TRUNC,
4332 mode);
4333 if (o < 0)
4334 gold_fatal(_("%s: open: %s"), this->name_, strerror(errno));
4335 this->o_ = o;
4339 this->map();
4342 // Resize the output file.
4344 void
4345 Output_file::resize(off_t file_size)
4347 // If the mmap is mapping an anonymous memory buffer, this is easy:
4348 // just mremap to the new size. If it's mapping to a file, we want
4349 // to unmap to flush to the file, then remap after growing the file.
4350 if (this->map_is_anonymous_)
4352 void* base = ::mremap(this->base_, this->file_size_, file_size,
4353 MREMAP_MAYMOVE);
4354 if (base == MAP_FAILED)
4355 gold_fatal(_("%s: mremap: %s"), this->name_, strerror(errno));
4356 this->base_ = static_cast<unsigned char*>(base);
4357 this->file_size_ = file_size;
4359 else
4361 this->unmap();
4362 this->file_size_ = file_size;
4363 if (!this->map_no_anonymous())
4364 gold_fatal(_("%s: mmap: %s"), this->name_, strerror(errno));
4368 // Map an anonymous block of memory which will later be written to the
4369 // file. Return whether the map succeeded.
4371 bool
4372 Output_file::map_anonymous()
4374 void* base = ::mmap(NULL, this->file_size_, PROT_READ | PROT_WRITE,
4375 MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
4376 if (base != MAP_FAILED)
4378 this->map_is_anonymous_ = true;
4379 this->base_ = static_cast<unsigned char*>(base);
4380 return true;
4382 return false;
4385 // Map the file into memory. Return whether the mapping succeeded.
4387 bool
4388 Output_file::map_no_anonymous()
4390 const int o = this->o_;
4392 // If the output file is not a regular file, don't try to mmap it;
4393 // instead, we'll mmap a block of memory (an anonymous buffer), and
4394 // then later write the buffer to the file.
4395 void* base;
4396 struct stat statbuf;
4397 if (o == STDOUT_FILENO || o == STDERR_FILENO
4398 || ::fstat(o, &statbuf) != 0
4399 || !S_ISREG(statbuf.st_mode)
4400 || this->is_temporary_)
4401 return false;
4403 // Ensure that we have disk space available for the file. If we
4404 // don't do this, it is possible that we will call munmap, close,
4405 // and exit with dirty buffers still in the cache with no assigned
4406 // disk blocks. If the disk is out of space at that point, the
4407 // output file will wind up incomplete, but we will have already
4408 // exited. The alternative to fallocate would be to use fdatasync,
4409 // but that would be a more significant performance hit.
4410 if (::posix_fallocate(o, 0, this->file_size_) < 0)
4411 gold_fatal(_("%s: %s"), this->name_, strerror(errno));
4413 // Map the file into memory.
4414 base = ::mmap(NULL, this->file_size_, PROT_READ | PROT_WRITE,
4415 MAP_SHARED, o, 0);
4417 // The mmap call might fail because of file system issues: the file
4418 // system might not support mmap at all, or it might not support
4419 // mmap with PROT_WRITE.
4420 if (base == MAP_FAILED)
4421 return false;
4423 this->map_is_anonymous_ = false;
4424 this->base_ = static_cast<unsigned char*>(base);
4425 return true;
4428 // Map the file into memory.
4430 void
4431 Output_file::map()
4433 if (this->map_no_anonymous())
4434 return;
4436 // The mmap call might fail because of file system issues: the file
4437 // system might not support mmap at all, or it might not support
4438 // mmap with PROT_WRITE. I'm not sure which errno values we will
4439 // see in all cases, so if the mmap fails for any reason and we
4440 // don't care about file contents, try for an anonymous map.
4441 if (this->map_anonymous())
4442 return;
4444 gold_fatal(_("%s: mmap: failed to allocate %lu bytes for output file: %s"),
4445 this->name_, static_cast<unsigned long>(this->file_size_),
4446 strerror(errno));
4449 // Unmap the file from memory.
4451 void
4452 Output_file::unmap()
4454 if (::munmap(this->base_, this->file_size_) < 0)
4455 gold_error(_("%s: munmap: %s"), this->name_, strerror(errno));
4456 this->base_ = NULL;
4459 // Close the output file.
4461 void
4462 Output_file::close()
4464 // If the map isn't file-backed, we need to write it now.
4465 if (this->map_is_anonymous_ && !this->is_temporary_)
4467 size_t bytes_to_write = this->file_size_;
4468 size_t offset = 0;
4469 while (bytes_to_write > 0)
4471 ssize_t bytes_written = ::write(this->o_, this->base_ + offset,
4472 bytes_to_write);
4473 if (bytes_written == 0)
4474 gold_error(_("%s: write: unexpected 0 return-value"), this->name_);
4475 else if (bytes_written < 0)
4476 gold_error(_("%s: write: %s"), this->name_, strerror(errno));
4477 else
4479 bytes_to_write -= bytes_written;
4480 offset += bytes_written;
4484 this->unmap();
4486 // We don't close stdout or stderr
4487 if (this->o_ != STDOUT_FILENO
4488 && this->o_ != STDERR_FILENO
4489 && !this->is_temporary_)
4490 if (::close(this->o_) < 0)
4491 gold_error(_("%s: close: %s"), this->name_, strerror(errno));
4492 this->o_ = -1;
4495 // Instantiate the templates we need. We could use the configure
4496 // script to restrict this to only the ones for implemented targets.
4498 #ifdef HAVE_TARGET_32_LITTLE
4499 template
4500 off_t
4501 Output_section::add_input_section<32, false>(
4502 Layout* layout,
4503 Sized_relobj<32, false>* object,
4504 unsigned int shndx,
4505 const char* secname,
4506 const elfcpp::Shdr<32, false>& shdr,
4507 unsigned int reloc_shndx,
4508 bool have_sections_script);
4509 #endif
4511 #ifdef HAVE_TARGET_32_BIG
4512 template
4513 off_t
4514 Output_section::add_input_section<32, true>(
4515 Layout* layout,
4516 Sized_relobj<32, true>* object,
4517 unsigned int shndx,
4518 const char* secname,
4519 const elfcpp::Shdr<32, true>& shdr,
4520 unsigned int reloc_shndx,
4521 bool have_sections_script);
4522 #endif
4524 #ifdef HAVE_TARGET_64_LITTLE
4525 template
4526 off_t
4527 Output_section::add_input_section<64, false>(
4528 Layout* layout,
4529 Sized_relobj<64, false>* object,
4530 unsigned int shndx,
4531 const char* secname,
4532 const elfcpp::Shdr<64, false>& shdr,
4533 unsigned int reloc_shndx,
4534 bool have_sections_script);
4535 #endif
4537 #ifdef HAVE_TARGET_64_BIG
4538 template
4539 off_t
4540 Output_section::add_input_section<64, true>(
4541 Layout* layout,
4542 Sized_relobj<64, true>* object,
4543 unsigned int shndx,
4544 const char* secname,
4545 const elfcpp::Shdr<64, true>& shdr,
4546 unsigned int reloc_shndx,
4547 bool have_sections_script);
4548 #endif
4550 #ifdef HAVE_TARGET_32_LITTLE
4551 template
4552 class Output_reloc<elfcpp::SHT_REL, false, 32, false>;
4553 #endif
4555 #ifdef HAVE_TARGET_32_BIG
4556 template
4557 class Output_reloc<elfcpp::SHT_REL, false, 32, true>;
4558 #endif
4560 #ifdef HAVE_TARGET_64_LITTLE
4561 template
4562 class Output_reloc<elfcpp::SHT_REL, false, 64, false>;
4563 #endif
4565 #ifdef HAVE_TARGET_64_BIG
4566 template
4567 class Output_reloc<elfcpp::SHT_REL, false, 64, true>;
4568 #endif
4570 #ifdef HAVE_TARGET_32_LITTLE
4571 template
4572 class Output_reloc<elfcpp::SHT_REL, true, 32, false>;
4573 #endif
4575 #ifdef HAVE_TARGET_32_BIG
4576 template
4577 class Output_reloc<elfcpp::SHT_REL, true, 32, true>;
4578 #endif
4580 #ifdef HAVE_TARGET_64_LITTLE
4581 template
4582 class Output_reloc<elfcpp::SHT_REL, true, 64, false>;
4583 #endif
4585 #ifdef HAVE_TARGET_64_BIG
4586 template
4587 class Output_reloc<elfcpp::SHT_REL, true, 64, true>;
4588 #endif
4590 #ifdef HAVE_TARGET_32_LITTLE
4591 template
4592 class Output_reloc<elfcpp::SHT_RELA, false, 32, false>;
4593 #endif
4595 #ifdef HAVE_TARGET_32_BIG
4596 template
4597 class Output_reloc<elfcpp::SHT_RELA, false, 32, true>;
4598 #endif
4600 #ifdef HAVE_TARGET_64_LITTLE
4601 template
4602 class Output_reloc<elfcpp::SHT_RELA, false, 64, false>;
4603 #endif
4605 #ifdef HAVE_TARGET_64_BIG
4606 template
4607 class Output_reloc<elfcpp::SHT_RELA, false, 64, true>;
4608 #endif
4610 #ifdef HAVE_TARGET_32_LITTLE
4611 template
4612 class Output_reloc<elfcpp::SHT_RELA, true, 32, false>;
4613 #endif
4615 #ifdef HAVE_TARGET_32_BIG
4616 template
4617 class Output_reloc<elfcpp::SHT_RELA, true, 32, true>;
4618 #endif
4620 #ifdef HAVE_TARGET_64_LITTLE
4621 template
4622 class Output_reloc<elfcpp::SHT_RELA, true, 64, false>;
4623 #endif
4625 #ifdef HAVE_TARGET_64_BIG
4626 template
4627 class Output_reloc<elfcpp::SHT_RELA, true, 64, true>;
4628 #endif
4630 #ifdef HAVE_TARGET_32_LITTLE
4631 template
4632 class Output_data_reloc<elfcpp::SHT_REL, false, 32, false>;
4633 #endif
4635 #ifdef HAVE_TARGET_32_BIG
4636 template
4637 class Output_data_reloc<elfcpp::SHT_REL, false, 32, true>;
4638 #endif
4640 #ifdef HAVE_TARGET_64_LITTLE
4641 template
4642 class Output_data_reloc<elfcpp::SHT_REL, false, 64, false>;
4643 #endif
4645 #ifdef HAVE_TARGET_64_BIG
4646 template
4647 class Output_data_reloc<elfcpp::SHT_REL, false, 64, true>;
4648 #endif
4650 #ifdef HAVE_TARGET_32_LITTLE
4651 template
4652 class Output_data_reloc<elfcpp::SHT_REL, true, 32, false>;
4653 #endif
4655 #ifdef HAVE_TARGET_32_BIG
4656 template
4657 class Output_data_reloc<elfcpp::SHT_REL, true, 32, true>;
4658 #endif
4660 #ifdef HAVE_TARGET_64_LITTLE
4661 template
4662 class Output_data_reloc<elfcpp::SHT_REL, true, 64, false>;
4663 #endif
4665 #ifdef HAVE_TARGET_64_BIG
4666 template
4667 class Output_data_reloc<elfcpp::SHT_REL, true, 64, true>;
4668 #endif
4670 #ifdef HAVE_TARGET_32_LITTLE
4671 template
4672 class Output_data_reloc<elfcpp::SHT_RELA, false, 32, false>;
4673 #endif
4675 #ifdef HAVE_TARGET_32_BIG
4676 template
4677 class Output_data_reloc<elfcpp::SHT_RELA, false, 32, true>;
4678 #endif
4680 #ifdef HAVE_TARGET_64_LITTLE
4681 template
4682 class Output_data_reloc<elfcpp::SHT_RELA, false, 64, false>;
4683 #endif
4685 #ifdef HAVE_TARGET_64_BIG
4686 template
4687 class Output_data_reloc<elfcpp::SHT_RELA, false, 64, true>;
4688 #endif
4690 #ifdef HAVE_TARGET_32_LITTLE
4691 template
4692 class Output_data_reloc<elfcpp::SHT_RELA, true, 32, false>;
4693 #endif
4695 #ifdef HAVE_TARGET_32_BIG
4696 template
4697 class Output_data_reloc<elfcpp::SHT_RELA, true, 32, true>;
4698 #endif
4700 #ifdef HAVE_TARGET_64_LITTLE
4701 template
4702 class Output_data_reloc<elfcpp::SHT_RELA, true, 64, false>;
4703 #endif
4705 #ifdef HAVE_TARGET_64_BIG
4706 template
4707 class Output_data_reloc<elfcpp::SHT_RELA, true, 64, true>;
4708 #endif
4710 #ifdef HAVE_TARGET_32_LITTLE
4711 template
4712 class Output_relocatable_relocs<elfcpp::SHT_REL, 32, false>;
4713 #endif
4715 #ifdef HAVE_TARGET_32_BIG
4716 template
4717 class Output_relocatable_relocs<elfcpp::SHT_REL, 32, true>;
4718 #endif
4720 #ifdef HAVE_TARGET_64_LITTLE
4721 template
4722 class Output_relocatable_relocs<elfcpp::SHT_REL, 64, false>;
4723 #endif
4725 #ifdef HAVE_TARGET_64_BIG
4726 template
4727 class Output_relocatable_relocs<elfcpp::SHT_REL, 64, true>;
4728 #endif
4730 #ifdef HAVE_TARGET_32_LITTLE
4731 template
4732 class Output_relocatable_relocs<elfcpp::SHT_RELA, 32, false>;
4733 #endif
4735 #ifdef HAVE_TARGET_32_BIG
4736 template
4737 class Output_relocatable_relocs<elfcpp::SHT_RELA, 32, true>;
4738 #endif
4740 #ifdef HAVE_TARGET_64_LITTLE
4741 template
4742 class Output_relocatable_relocs<elfcpp::SHT_RELA, 64, false>;
4743 #endif
4745 #ifdef HAVE_TARGET_64_BIG
4746 template
4747 class Output_relocatable_relocs<elfcpp::SHT_RELA, 64, true>;
4748 #endif
4750 #ifdef HAVE_TARGET_32_LITTLE
4751 template
4752 class Output_data_group<32, false>;
4753 #endif
4755 #ifdef HAVE_TARGET_32_BIG
4756 template
4757 class Output_data_group<32, true>;
4758 #endif
4760 #ifdef HAVE_TARGET_64_LITTLE
4761 template
4762 class Output_data_group<64, false>;
4763 #endif
4765 #ifdef HAVE_TARGET_64_BIG
4766 template
4767 class Output_data_group<64, true>;
4768 #endif
4770 #ifdef HAVE_TARGET_32_LITTLE
4771 template
4772 class Output_data_got<32, false>;
4773 #endif
4775 #ifdef HAVE_TARGET_32_BIG
4776 template
4777 class Output_data_got<32, true>;
4778 #endif
4780 #ifdef HAVE_TARGET_64_LITTLE
4781 template
4782 class Output_data_got<64, false>;
4783 #endif
4785 #ifdef HAVE_TARGET_64_BIG
4786 template
4787 class Output_data_got<64, true>;
4788 #endif
4790 } // End namespace gold.