Merge branch 'vendor/GCC50'
[dragonfly.git] / contrib / binutils-2.25 / gold / output.cc
1 // output.cc -- manage the output file for gold
2
3 // Copyright (C) 2006-2014 Free Software Foundation, Inc.
4 // Written by Ian Lance Taylor <iant@google.com>.
5
6 // This file is part of gold.
7
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.
12
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.
17
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.
22
23 #include "gold.h"
24
25 #include <cstdlib>
26 #include <cstring>
27 #include <cerrno>
28 #include <fcntl.h>
29 #include <unistd.h>
30 #include <sys/stat.h>
31 #include <algorithm>
32
33 #ifdef HAVE_SYS_MMAN_H
34 #include <sys/mman.h>
35 #endif
36
37 #include "libiberty.h"
38
39 #include "dwarf.h"
40 #include "parameters.h"
41 #include "object.h"
42 #include "symtab.h"
43 #include "reloc.h"
44 #include "merge.h"
45 #include "descriptors.h"
46 #include "layout.h"
47 #include "output.h"
48
49 // For systems without mmap support.
50 #ifndef HAVE_MMAP
51 # define mmap gold_mmap
52 # define munmap gold_munmap
53 # define mremap gold_mremap
54 # ifndef MAP_FAILED
55 #  define MAP_FAILED (reinterpret_cast<void*>(-1))
56 # endif
57 # ifndef PROT_READ
58 #  define PROT_READ 0
59 # endif
60 # ifndef PROT_WRITE
61 #  define PROT_WRITE 0
62 # endif
63 # ifndef MAP_PRIVATE
64 #  define MAP_PRIVATE 0
65 # endif
66 # ifndef MAP_ANONYMOUS
67 #  define MAP_ANONYMOUS 0
68 # endif
69 # ifndef MAP_SHARED
70 #  define MAP_SHARED 0
71 # endif
72
73 # ifndef ENOSYS
74 #  define ENOSYS EINVAL
75 # endif
76
77 static void *
78 gold_mmap(void *, size_t, int, int, int, off_t)
79 {
80   errno = ENOSYS;
81   return MAP_FAILED;
82 }
83
84 static int
85 gold_munmap(void *, size_t)
86 {
87   errno = ENOSYS;
88   return -1;
89 }
90
91 static void *
92 gold_mremap(void *, size_t, size_t, int)
93 {
94   errno = ENOSYS;
95   return MAP_FAILED;
96 }
97
98 #endif
99
100 #if defined(HAVE_MMAP) && !defined(HAVE_MREMAP)
101 # define mremap gold_mremap
102 extern "C" void *gold_mremap(void *, size_t, size_t, int);
103 #endif
104
105 // Some BSD systems still use MAP_ANON instead of MAP_ANONYMOUS
106 #ifndef MAP_ANONYMOUS
107 # define MAP_ANONYMOUS  MAP_ANON
108 #endif
109
110 #ifndef MREMAP_MAYMOVE
111 # define MREMAP_MAYMOVE 1
112 #endif
113
114 // Mingw does not have S_ISLNK.
115 #ifndef S_ISLNK
116 # define S_ISLNK(mode) 0
117 #endif
118
119 namespace gold
120 {
121
122 // A wrapper around posix_fallocate.  If we don't have posix_fallocate,
123 // or the --no-posix-fallocate option is set, we try the fallocate
124 // system call directly.  If that fails, we use ftruncate to set
125 // the file size and hope that there is enough disk space.
126
127 static int
128 gold_fallocate(int o, off_t offset, off_t len)
129 {
130 #ifdef HAVE_POSIX_FALLOCATE
131   if (parameters->options().posix_fallocate())
132     return ::posix_fallocate(o, offset, len);
133 #endif // defined(HAVE_POSIX_FALLOCATE)
134 #ifdef HAVE_FALLOCATE
135   if (::fallocate(o, 0, offset, len) == 0)
136     return 0;
137 #endif // defined(HAVE_FALLOCATE)
138   if (::ftruncate(o, offset + len) < 0)
139     return errno;
140   return 0;
141 }
142
143 // Output_data variables.
144
145 bool Output_data::allocated_sizes_are_fixed;
146
147 // Output_data methods.
148
149 Output_data::~Output_data()
150 {
151 }
152
153 // Return the default alignment for the target size.
154
155 uint64_t
156 Output_data::default_alignment()
157 {
158   return Output_data::default_alignment_for_size(
159       parameters->target().get_size());
160 }
161
162 // Return the default alignment for a size--32 or 64.
163
164 uint64_t
165 Output_data::default_alignment_for_size(int size)
166 {
167   if (size == 32)
168     return 4;
169   else if (size == 64)
170     return 8;
171   else
172     gold_unreachable();
173 }
174
175 // Output_section_header methods.  This currently assumes that the
176 // segment and section lists are complete at construction time.
177
178 Output_section_headers::Output_section_headers(
179     const Layout* layout,
180     const Layout::Segment_list* segment_list,
181     const Layout::Section_list* section_list,
182     const Layout::Section_list* unattached_section_list,
183     const Stringpool* secnamepool,
184     const Output_section* shstrtab_section)
185   : layout_(layout),
186     segment_list_(segment_list),
187     section_list_(section_list),
188     unattached_section_list_(unattached_section_list),
189     secnamepool_(secnamepool),
190     shstrtab_section_(shstrtab_section)
191 {
192 }
193
194 // Compute the current data size.
195
196 off_t
197 Output_section_headers::do_size() const
198 {
199   // Count all the sections.  Start with 1 for the null section.
200   off_t count = 1;
201   if (!parameters->options().relocatable())
202     {
203       for (Layout::Segment_list::const_iterator p =
204              this->segment_list_->begin();
205            p != this->segment_list_->end();
206            ++p)
207         if ((*p)->type() == elfcpp::PT_LOAD)
208           count += (*p)->output_section_count();
209     }
210   else
211     {
212       for (Layout::Section_list::const_iterator p =
213              this->section_list_->begin();
214            p != this->section_list_->end();
215            ++p)
216         if (((*p)->flags() & elfcpp::SHF_ALLOC) != 0)
217           ++count;
218     }
219   count += this->unattached_section_list_->size();
220
221   const int size = parameters->target().get_size();
222   int shdr_size;
223   if (size == 32)
224     shdr_size = elfcpp::Elf_sizes<32>::shdr_size;
225   else if (size == 64)
226     shdr_size = elfcpp::Elf_sizes<64>::shdr_size;
227   else
228     gold_unreachable();
229
230   return count * shdr_size;
231 }
232
233 // Write out the section headers.
234
235 void
236 Output_section_headers::do_write(Output_file* of)
237 {
238   switch (parameters->size_and_endianness())
239     {
240 #ifdef HAVE_TARGET_32_LITTLE
241     case Parameters::TARGET_32_LITTLE:
242       this->do_sized_write<32, false>(of);
243       break;
244 #endif
245 #ifdef HAVE_TARGET_32_BIG
246     case Parameters::TARGET_32_BIG:
247       this->do_sized_write<32, true>(of);
248       break;
249 #endif
250 #ifdef HAVE_TARGET_64_LITTLE
251     case Parameters::TARGET_64_LITTLE:
252       this->do_sized_write<64, false>(of);
253       break;
254 #endif
255 #ifdef HAVE_TARGET_64_BIG
256     case Parameters::TARGET_64_BIG:
257       this->do_sized_write<64, true>(of);
258       break;
259 #endif
260     default:
261       gold_unreachable();
262     }
263 }
264
265 template<int size, bool big_endian>
266 void
267 Output_section_headers::do_sized_write(Output_file* of)
268 {
269   off_t all_shdrs_size = this->data_size();
270   unsigned char* view = of->get_output_view(this->offset(), all_shdrs_size);
271
272   const int shdr_size = elfcpp::Elf_sizes<size>::shdr_size;
273   unsigned char* v = view;
274
275   {
276     typename elfcpp::Shdr_write<size, big_endian> oshdr(v);
277     oshdr.put_sh_name(0);
278     oshdr.put_sh_type(elfcpp::SHT_NULL);
279     oshdr.put_sh_flags(0);
280     oshdr.put_sh_addr(0);
281     oshdr.put_sh_offset(0);
282
283     size_t section_count = (this->data_size()
284                             / elfcpp::Elf_sizes<size>::shdr_size);
285     if (section_count < elfcpp::SHN_LORESERVE)
286       oshdr.put_sh_size(0);
287     else
288       oshdr.put_sh_size(section_count);
289
290     unsigned int shstrndx = this->shstrtab_section_->out_shndx();
291     if (shstrndx < elfcpp::SHN_LORESERVE)
292       oshdr.put_sh_link(0);
293     else
294       oshdr.put_sh_link(shstrndx);
295
296     size_t segment_count = this->segment_list_->size();
297     oshdr.put_sh_info(segment_count >= elfcpp::PN_XNUM ? segment_count : 0);
298
299     oshdr.put_sh_addralign(0);
300     oshdr.put_sh_entsize(0);
301   }
302
303   v += shdr_size;
304
305   unsigned int shndx = 1;
306   if (!parameters->options().relocatable())
307     {
308       for (Layout::Segment_list::const_iterator p =
309              this->segment_list_->begin();
310            p != this->segment_list_->end();
311            ++p)
312         v = (*p)->write_section_headers<size, big_endian>(this->layout_,
313                                                           this->secnamepool_,
314                                                           v,
315                                                           &shndx);
316     }
317   else
318     {
319       for (Layout::Section_list::const_iterator p =
320              this->section_list_->begin();
321            p != this->section_list_->end();
322            ++p)
323         {
324           // We do unallocated sections below, except that group
325           // sections have to come first.
326           if (((*p)->flags() & elfcpp::SHF_ALLOC) == 0
327               && (*p)->type() != elfcpp::SHT_GROUP)
328             continue;
329           gold_assert(shndx == (*p)->out_shndx());
330           elfcpp::Shdr_write<size, big_endian> oshdr(v);
331           (*p)->write_header(this->layout_, this->secnamepool_, &oshdr);
332           v += shdr_size;
333           ++shndx;
334         }
335     }
336
337   for (Layout::Section_list::const_iterator p =
338          this->unattached_section_list_->begin();
339        p != this->unattached_section_list_->end();
340        ++p)
341     {
342       // For a relocatable link, we did unallocated group sections
343       // above, since they have to come first.
344       if ((*p)->type() == elfcpp::SHT_GROUP
345           && parameters->options().relocatable())
346         continue;
347       gold_assert(shndx == (*p)->out_shndx());
348       elfcpp::Shdr_write<size, big_endian> oshdr(v);
349       (*p)->write_header(this->layout_, this->secnamepool_, &oshdr);
350       v += shdr_size;
351       ++shndx;
352     }
353
354   of->write_output_view(this->offset(), all_shdrs_size, view);
355 }
356
357 // Output_segment_header methods.
358
359 Output_segment_headers::Output_segment_headers(
360     const Layout::Segment_list& segment_list)
361   : segment_list_(segment_list)
362 {
363   this->set_current_data_size_for_child(this->do_size());
364 }
365
366 void
367 Output_segment_headers::do_write(Output_file* of)
368 {
369   switch (parameters->size_and_endianness())
370     {
371 #ifdef HAVE_TARGET_32_LITTLE
372     case Parameters::TARGET_32_LITTLE:
373       this->do_sized_write<32, false>(of);
374       break;
375 #endif
376 #ifdef HAVE_TARGET_32_BIG
377     case Parameters::TARGET_32_BIG:
378       this->do_sized_write<32, true>(of);
379       break;
380 #endif
381 #ifdef HAVE_TARGET_64_LITTLE
382     case Parameters::TARGET_64_LITTLE:
383       this->do_sized_write<64, false>(of);
384       break;
385 #endif
386 #ifdef HAVE_TARGET_64_BIG
387     case Parameters::TARGET_64_BIG:
388       this->do_sized_write<64, true>(of);
389       break;
390 #endif
391     default:
392       gold_unreachable();
393     }
394 }
395
396 template<int size, bool big_endian>
397 void
398 Output_segment_headers::do_sized_write(Output_file* of)
399 {
400   const int phdr_size = elfcpp::Elf_sizes<size>::phdr_size;
401   off_t all_phdrs_size = this->segment_list_.size() * phdr_size;
402   gold_assert(all_phdrs_size == this->data_size());
403   unsigned char* view = of->get_output_view(this->offset(),
404                                             all_phdrs_size);
405   unsigned char* v = view;
406   for (Layout::Segment_list::const_iterator p = this->segment_list_.begin();
407        p != this->segment_list_.end();
408        ++p)
409     {
410       elfcpp::Phdr_write<size, big_endian> ophdr(v);
411       (*p)->write_header(&ophdr);
412       v += phdr_size;
413     }
414
415   gold_assert(v - view == all_phdrs_size);
416
417   of->write_output_view(this->offset(), all_phdrs_size, view);
418 }
419
420 off_t
421 Output_segment_headers::do_size() const
422 {
423   const int size = parameters->target().get_size();
424   int phdr_size;
425   if (size == 32)
426     phdr_size = elfcpp::Elf_sizes<32>::phdr_size;
427   else if (size == 64)
428     phdr_size = elfcpp::Elf_sizes<64>::phdr_size;
429   else
430     gold_unreachable();
431
432   return this->segment_list_.size() * phdr_size;
433 }
434
435 // Output_file_header methods.
436
437 Output_file_header::Output_file_header(Target* target,
438                                        const Symbol_table* symtab,
439                                        const Output_segment_headers* osh)
440   : target_(target),
441     symtab_(symtab),
442     segment_header_(osh),
443     section_header_(NULL),
444     shstrtab_(NULL)
445 {
446   this->set_data_size(this->do_size());
447 }
448
449 // Set the section table information for a file header.
450
451 void
452 Output_file_header::set_section_info(const Output_section_headers* shdrs,
453                                      const Output_section* shstrtab)
454 {
455   this->section_header_ = shdrs;
456   this->shstrtab_ = shstrtab;
457 }
458
459 // Write out the file header.
460
461 void
462 Output_file_header::do_write(Output_file* of)
463 {
464   gold_assert(this->offset() == 0);
465
466   switch (parameters->size_and_endianness())
467     {
468 #ifdef HAVE_TARGET_32_LITTLE
469     case Parameters::TARGET_32_LITTLE:
470       this->do_sized_write<32, false>(of);
471       break;
472 #endif
473 #ifdef HAVE_TARGET_32_BIG
474     case Parameters::TARGET_32_BIG:
475       this->do_sized_write<32, true>(of);
476       break;
477 #endif
478 #ifdef HAVE_TARGET_64_LITTLE
479     case Parameters::TARGET_64_LITTLE:
480       this->do_sized_write<64, false>(of);
481       break;
482 #endif
483 #ifdef HAVE_TARGET_64_BIG
484     case Parameters::TARGET_64_BIG:
485       this->do_sized_write<64, true>(of);
486       break;
487 #endif
488     default:
489       gold_unreachable();
490     }
491 }
492
493 // Write out the file header with appropriate size and endianness.
494
495 template<int size, bool big_endian>
496 void
497 Output_file_header::do_sized_write(Output_file* of)
498 {
499   gold_assert(this->offset() == 0);
500
501   int ehdr_size = elfcpp::Elf_sizes<size>::ehdr_size;
502   unsigned char* view = of->get_output_view(0, ehdr_size);
503   elfcpp::Ehdr_write<size, big_endian> oehdr(view);
504
505   unsigned char e_ident[elfcpp::EI_NIDENT];
506   memset(e_ident, 0, elfcpp::EI_NIDENT);
507   e_ident[elfcpp::EI_MAG0] = elfcpp::ELFMAG0;
508   e_ident[elfcpp::EI_MAG1] = elfcpp::ELFMAG1;
509   e_ident[elfcpp::EI_MAG2] = elfcpp::ELFMAG2;
510   e_ident[elfcpp::EI_MAG3] = elfcpp::ELFMAG3;
511   if (size == 32)
512     e_ident[elfcpp::EI_CLASS] = elfcpp::ELFCLASS32;
513   else if (size == 64)
514     e_ident[elfcpp::EI_CLASS] = elfcpp::ELFCLASS64;
515   else
516     gold_unreachable();
517   e_ident[elfcpp::EI_DATA] = (big_endian
518                               ? elfcpp::ELFDATA2MSB
519                               : elfcpp::ELFDATA2LSB);
520   e_ident[elfcpp::EI_VERSION] = elfcpp::EV_CURRENT;
521   oehdr.put_e_ident(e_ident);
522
523   elfcpp::ET e_type;
524   if (parameters->options().relocatable())
525     e_type = elfcpp::ET_REL;
526   else if (parameters->options().output_is_position_independent())
527     e_type = elfcpp::ET_DYN;
528   else
529     e_type = elfcpp::ET_EXEC;
530   oehdr.put_e_type(e_type);
531
532   oehdr.put_e_machine(this->target_->machine_code());
533   oehdr.put_e_version(elfcpp::EV_CURRENT);
534
535   oehdr.put_e_entry(this->entry<size>());
536
537   if (this->segment_header_ == NULL)
538     oehdr.put_e_phoff(0);
539   else
540     oehdr.put_e_phoff(this->segment_header_->offset());
541
542   oehdr.put_e_shoff(this->section_header_->offset());
543   oehdr.put_e_flags(this->target_->processor_specific_flags());
544   oehdr.put_e_ehsize(elfcpp::Elf_sizes<size>::ehdr_size);
545
546   if (this->segment_header_ == NULL)
547     {
548       oehdr.put_e_phentsize(0);
549       oehdr.put_e_phnum(0);
550     }
551   else
552     {
553       oehdr.put_e_phentsize(elfcpp::Elf_sizes<size>::phdr_size);
554       size_t phnum = (this->segment_header_->data_size()
555                       / elfcpp::Elf_sizes<size>::phdr_size);
556       if (phnum > elfcpp::PN_XNUM)
557         phnum = elfcpp::PN_XNUM;
558       oehdr.put_e_phnum(phnum);
559     }
560
561   oehdr.put_e_shentsize(elfcpp::Elf_sizes<size>::shdr_size);
562   size_t section_count = (this->section_header_->data_size()
563                           / elfcpp::Elf_sizes<size>::shdr_size);
564
565   if (section_count < elfcpp::SHN_LORESERVE)
566     oehdr.put_e_shnum(this->section_header_->data_size()
567                       / elfcpp::Elf_sizes<size>::shdr_size);
568   else
569     oehdr.put_e_shnum(0);
570
571   unsigned int shstrndx = this->shstrtab_->out_shndx();
572   if (shstrndx < elfcpp::SHN_LORESERVE)
573     oehdr.put_e_shstrndx(this->shstrtab_->out_shndx());
574   else
575     oehdr.put_e_shstrndx(elfcpp::SHN_XINDEX);
576
577   // Let the target adjust the ELF header, e.g., to set EI_OSABI in
578   // the e_ident field.
579   this->target_->adjust_elf_header(view, ehdr_size);
580
581   of->write_output_view(0, ehdr_size, view);
582 }
583
584 // Return the value to use for the entry address.
585
586 template<int size>
587 typename elfcpp::Elf_types<size>::Elf_Addr
588 Output_file_header::entry()
589 {
590   const bool should_issue_warning = (parameters->options().entry() != NULL
591                                      && !parameters->options().relocatable()
592                                      && !parameters->options().shared());
593   const char* entry = parameters->entry();
594   Symbol* sym = this->symtab_->lookup(entry);
595
596   typename Sized_symbol<size>::Value_type v;
597   if (sym != NULL)
598     {
599       Sized_symbol<size>* ssym;
600       ssym = this->symtab_->get_sized_symbol<size>(sym);
601       if (!ssym->is_defined() && should_issue_warning)
602         gold_warning("entry symbol '%s' exists but is not defined", entry);
603       v = ssym->value();
604     }
605   else
606     {
607       // We couldn't find the entry symbol.  See if we can parse it as
608       // a number.  This supports, e.g., -e 0x1000.
609       char* endptr;
610       v = strtoull(entry, &endptr, 0);
611       if (*endptr != '\0')
612         {
613           if (should_issue_warning)
614             gold_warning("cannot find entry symbol '%s'", entry);
615           v = 0;
616         }
617     }
618
619   return v;
620 }
621
622 // Compute the current data size.
623
624 off_t
625 Output_file_header::do_size() const
626 {
627   const int size = parameters->target().get_size();
628   if (size == 32)
629     return elfcpp::Elf_sizes<32>::ehdr_size;
630   else if (size == 64)
631     return elfcpp::Elf_sizes<64>::ehdr_size;
632   else
633     gold_unreachable();
634 }
635
636 // Output_data_const methods.
637
638 void
639 Output_data_const::do_write(Output_file* of)
640 {
641   of->write(this->offset(), this->data_.data(), this->data_.size());
642 }
643
644 // Output_data_const_buffer methods.
645
646 void
647 Output_data_const_buffer::do_write(Output_file* of)
648 {
649   of->write(this->offset(), this->p_, this->data_size());
650 }
651
652 // Output_section_data methods.
653
654 // Record the output section, and set the entry size and such.
655
656 void
657 Output_section_data::set_output_section(Output_section* os)
658 {
659   gold_assert(this->output_section_ == NULL);
660   this->output_section_ = os;
661   this->do_adjust_output_section(os);
662 }
663
664 // Return the section index of the output section.
665
666 unsigned int
667 Output_section_data::do_out_shndx() const
668 {
669   gold_assert(this->output_section_ != NULL);
670   return this->output_section_->out_shndx();
671 }
672
673 // Set the alignment, which means we may need to update the alignment
674 // of the output section.
675
676 void
677 Output_section_data::set_addralign(uint64_t addralign)
678 {
679   this->addralign_ = addralign;
680   if (this->output_section_ != NULL
681       && this->output_section_->addralign() < addralign)
682     this->output_section_->set_addralign(addralign);
683 }
684
685 // Output_data_strtab methods.
686
687 // Set the final data size.
688
689 void
690 Output_data_strtab::set_final_data_size()
691 {
692   this->strtab_->set_string_offsets();
693   this->set_data_size(this->strtab_->get_strtab_size());
694 }
695
696 // Write out a string table.
697
698 void
699 Output_data_strtab::do_write(Output_file* of)
700 {
701   this->strtab_->write(of, this->offset());
702 }
703
704 // Output_reloc methods.
705
706 // A reloc against a global symbol.
707
708 template<bool dynamic, int size, bool big_endian>
709 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc(
710     Symbol* gsym,
711     unsigned int type,
712     Output_data* od,
713     Address address,
714     bool is_relative,
715     bool is_symbolless,
716     bool use_plt_offset)
717   : address_(address), local_sym_index_(GSYM_CODE), type_(type),
718     is_relative_(is_relative), is_symbolless_(is_symbolless),
719     is_section_symbol_(false), use_plt_offset_(use_plt_offset), shndx_(INVALID_CODE)
720 {
721   // this->type_ is a bitfield; make sure TYPE fits.
722   gold_assert(this->type_ == type);
723   this->u1_.gsym = gsym;
724   this->u2_.od = od;
725   if (dynamic)
726     this->set_needs_dynsym_index();
727 }
728
729 template<bool dynamic, int size, bool big_endian>
730 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc(
731     Symbol* gsym,
732     unsigned int type,
733     Sized_relobj<size, big_endian>* relobj,
734     unsigned int shndx,
735     Address address,
736     bool is_relative,
737     bool is_symbolless,
738     bool use_plt_offset)
739   : address_(address), local_sym_index_(GSYM_CODE), type_(type),
740     is_relative_(is_relative), is_symbolless_(is_symbolless),
741     is_section_symbol_(false), use_plt_offset_(use_plt_offset), shndx_(shndx)
742 {
743   gold_assert(shndx != INVALID_CODE);
744   // this->type_ is a bitfield; make sure TYPE fits.
745   gold_assert(this->type_ == type);
746   this->u1_.gsym = gsym;
747   this->u2_.relobj = relobj;
748   if (dynamic)
749     this->set_needs_dynsym_index();
750 }
751
752 // A reloc against a local symbol.
753
754 template<bool dynamic, int size, bool big_endian>
755 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc(
756     Sized_relobj<size, big_endian>* relobj,
757     unsigned int local_sym_index,
758     unsigned int type,
759     Output_data* od,
760     Address address,
761     bool is_relative,
762     bool is_symbolless,
763     bool is_section_symbol,
764     bool use_plt_offset)
765   : address_(address), local_sym_index_(local_sym_index), type_(type),
766     is_relative_(is_relative), is_symbolless_(is_symbolless),
767     is_section_symbol_(is_section_symbol), use_plt_offset_(use_plt_offset),
768     shndx_(INVALID_CODE)
769 {
770   gold_assert(local_sym_index != GSYM_CODE
771               && local_sym_index != INVALID_CODE);
772   // this->type_ is a bitfield; make sure TYPE fits.
773   gold_assert(this->type_ == type);
774   this->u1_.relobj = relobj;
775   this->u2_.od = od;
776   if (dynamic)
777     this->set_needs_dynsym_index();
778 }
779
780 template<bool dynamic, int size, bool big_endian>
781 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc(
782     Sized_relobj<size, big_endian>* relobj,
783     unsigned int local_sym_index,
784     unsigned int type,
785     unsigned int shndx,
786     Address address,
787     bool is_relative,
788     bool is_symbolless,
789     bool is_section_symbol,
790     bool use_plt_offset)
791   : address_(address), local_sym_index_(local_sym_index), type_(type),
792     is_relative_(is_relative), is_symbolless_(is_symbolless),
793     is_section_symbol_(is_section_symbol), use_plt_offset_(use_plt_offset),
794     shndx_(shndx)
795 {
796   gold_assert(local_sym_index != GSYM_CODE
797               && local_sym_index != INVALID_CODE);
798   gold_assert(shndx != INVALID_CODE);
799   // this->type_ is a bitfield; make sure TYPE fits.
800   gold_assert(this->type_ == type);
801   this->u1_.relobj = relobj;
802   this->u2_.relobj = relobj;
803   if (dynamic)
804     this->set_needs_dynsym_index();
805 }
806
807 // A reloc against the STT_SECTION symbol of an output section.
808
809 template<bool dynamic, int size, bool big_endian>
810 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc(
811     Output_section* os,
812     unsigned int type,
813     Output_data* od,
814     Address address,
815     bool is_relative)
816   : address_(address), local_sym_index_(SECTION_CODE), type_(type),
817     is_relative_(is_relative), is_symbolless_(is_relative),
818     is_section_symbol_(true), use_plt_offset_(false), shndx_(INVALID_CODE)
819 {
820   // this->type_ is a bitfield; make sure TYPE fits.
821   gold_assert(this->type_ == type);
822   this->u1_.os = os;
823   this->u2_.od = od;
824   if (dynamic)
825     this->set_needs_dynsym_index();
826   else
827     os->set_needs_symtab_index();
828 }
829
830 template<bool dynamic, int size, bool big_endian>
831 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc(
832     Output_section* os,
833     unsigned int type,
834     Sized_relobj<size, big_endian>* relobj,
835     unsigned int shndx,
836     Address address,
837     bool is_relative)
838   : address_(address), local_sym_index_(SECTION_CODE), type_(type),
839     is_relative_(is_relative), is_symbolless_(is_relative),
840     is_section_symbol_(true), use_plt_offset_(false), shndx_(shndx)
841 {
842   gold_assert(shndx != INVALID_CODE);
843   // this->type_ is a bitfield; make sure TYPE fits.
844   gold_assert(this->type_ == type);
845   this->u1_.os = os;
846   this->u2_.relobj = relobj;
847   if (dynamic)
848     this->set_needs_dynsym_index();
849   else
850     os->set_needs_symtab_index();
851 }
852
853 // An absolute or relative relocation.
854
855 template<bool dynamic, int size, bool big_endian>
856 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc(
857     unsigned int type,
858     Output_data* od,
859     Address address,
860     bool is_relative)
861   : address_(address), local_sym_index_(0), type_(type),
862     is_relative_(is_relative), is_symbolless_(false),
863     is_section_symbol_(false), use_plt_offset_(false), shndx_(INVALID_CODE)
864 {
865   // this->type_ is a bitfield; make sure TYPE fits.
866   gold_assert(this->type_ == type);
867   this->u1_.relobj = NULL;
868   this->u2_.od = od;
869 }
870
871 template<bool dynamic, int size, bool big_endian>
872 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc(
873     unsigned int type,
874     Sized_relobj<size, big_endian>* relobj,
875     unsigned int shndx,
876     Address address,
877     bool is_relative)
878   : address_(address), local_sym_index_(0), type_(type),
879     is_relative_(is_relative), is_symbolless_(false),
880     is_section_symbol_(false), use_plt_offset_(false), shndx_(shndx)
881 {
882   gold_assert(shndx != INVALID_CODE);
883   // this->type_ is a bitfield; make sure TYPE fits.
884   gold_assert(this->type_ == type);
885   this->u1_.relobj = NULL;
886   this->u2_.relobj = relobj;
887 }
888
889 // A target specific relocation.
890
891 template<bool dynamic, int size, bool big_endian>
892 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc(
893     unsigned int type,
894     void* arg,
895     Output_data* od,
896     Address address)
897   : address_(address), local_sym_index_(TARGET_CODE), type_(type),
898     is_relative_(false), is_symbolless_(false),
899     is_section_symbol_(false), use_plt_offset_(false), shndx_(INVALID_CODE)
900 {
901   // this->type_ is a bitfield; make sure TYPE fits.
902   gold_assert(this->type_ == type);
903   this->u1_.arg = arg;
904   this->u2_.od = od;
905 }
906
907 template<bool dynamic, int size, bool big_endian>
908 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc(
909     unsigned int type,
910     void* arg,
911     Sized_relobj<size, big_endian>* relobj,
912     unsigned int shndx,
913     Address address)
914   : address_(address), local_sym_index_(TARGET_CODE), type_(type),
915     is_relative_(false), is_symbolless_(false),
916     is_section_symbol_(false), use_plt_offset_(false), shndx_(shndx)
917 {
918   gold_assert(shndx != INVALID_CODE);
919   // this->type_ is a bitfield; make sure TYPE fits.
920   gold_assert(this->type_ == type);
921   this->u1_.arg = arg;
922   this->u2_.relobj = relobj;
923 }
924
925 // Record that we need a dynamic symbol index for this relocation.
926
927 template<bool dynamic, int size, bool big_endian>
928 void
929 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::
930 set_needs_dynsym_index()
931 {
932   if (this->is_symbolless_)
933     return;
934   switch (this->local_sym_index_)
935     {
936     case INVALID_CODE:
937       gold_unreachable();
938
939     case GSYM_CODE:
940       this->u1_.gsym->set_needs_dynsym_entry();
941       break;
942
943     case SECTION_CODE:
944       this->u1_.os->set_needs_dynsym_index();
945       break;
946
947     case TARGET_CODE:
948       // The target must take care of this if necessary.
949       break;
950
951     case 0:
952       break;
953
954     default:
955       {
956         const unsigned int lsi = this->local_sym_index_;
957         Sized_relobj_file<size, big_endian>* relobj =
958             this->u1_.relobj->sized_relobj();
959         gold_assert(relobj != NULL);
960         if (!this->is_section_symbol_)
961           relobj->set_needs_output_dynsym_entry(lsi);
962         else
963           relobj->output_section(lsi)->set_needs_dynsym_index();
964       }
965       break;
966     }
967 }
968
969 // Get the symbol index of a relocation.
970
971 template<bool dynamic, int size, bool big_endian>
972 unsigned int
973 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::get_symbol_index()
974   const
975 {
976   unsigned int index;
977   if (this->is_symbolless_)
978     return 0;
979   switch (this->local_sym_index_)
980     {
981     case INVALID_CODE:
982       gold_unreachable();
983
984     case GSYM_CODE:
985       if (this->u1_.gsym == NULL)
986         index = 0;
987       else if (dynamic)
988         index = this->u1_.gsym->dynsym_index();
989       else
990         index = this->u1_.gsym->symtab_index();
991       break;
992
993     case SECTION_CODE:
994       if (dynamic)
995         index = this->u1_.os->dynsym_index();
996       else
997         index = this->u1_.os->symtab_index();
998       break;
999
1000     case TARGET_CODE:
1001       index = parameters->target().reloc_symbol_index(this->u1_.arg,
1002                                                       this->type_);
1003       break;
1004
1005     case 0:
1006       // Relocations without symbols use a symbol index of 0.
1007       index = 0;
1008       break;
1009
1010     default:
1011       {
1012         const unsigned int lsi = this->local_sym_index_;
1013         Sized_relobj_file<size, big_endian>* relobj =
1014             this->u1_.relobj->sized_relobj();
1015         gold_assert(relobj != NULL);
1016         if (!this->is_section_symbol_)
1017           {
1018             if (dynamic)
1019               index = relobj->dynsym_index(lsi);
1020             else
1021               index = relobj->symtab_index(lsi);
1022           }
1023         else
1024           {
1025             Output_section* os = relobj->output_section(lsi);
1026             gold_assert(os != NULL);
1027             if (dynamic)
1028               index = os->dynsym_index();
1029             else
1030               index = os->symtab_index();
1031           }
1032       }
1033       break;
1034     }
1035   gold_assert(index != -1U);
1036   return index;
1037 }
1038
1039 // For a local section symbol, get the address of the offset ADDEND
1040 // within the input section.
1041
1042 template<bool dynamic, int size, bool big_endian>
1043 typename elfcpp::Elf_types<size>::Elf_Addr
1044 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::
1045   local_section_offset(Addend addend) const
1046 {
1047   gold_assert(this->local_sym_index_ != GSYM_CODE
1048               && this->local_sym_index_ != SECTION_CODE
1049               && this->local_sym_index_ != TARGET_CODE
1050               && this->local_sym_index_ != INVALID_CODE
1051               && this->local_sym_index_ != 0
1052               && this->is_section_symbol_);
1053   const unsigned int lsi = this->local_sym_index_;
1054   Output_section* os = this->u1_.relobj->output_section(lsi);
1055   gold_assert(os != NULL);
1056   Address offset = this->u1_.relobj->get_output_section_offset(lsi);
1057   if (offset != invalid_address)
1058     return offset + addend;
1059   // This is a merge section.
1060   Sized_relobj_file<size, big_endian>* relobj =
1061       this->u1_.relobj->sized_relobj();
1062   gold_assert(relobj != NULL);
1063   offset = os->output_address(relobj, lsi, addend);
1064   gold_assert(offset != invalid_address);
1065   return offset;
1066 }
1067
1068 // Get the output address of a relocation.
1069
1070 template<bool dynamic, int size, bool big_endian>
1071 typename elfcpp::Elf_types<size>::Elf_Addr
1072 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::get_address() const
1073 {
1074   Address address = this->address_;
1075   if (this->shndx_ != INVALID_CODE)
1076     {
1077       Output_section* os = this->u2_.relobj->output_section(this->shndx_);
1078       gold_assert(os != NULL);
1079       Address off = this->u2_.relobj->get_output_section_offset(this->shndx_);
1080       if (off != invalid_address)
1081         address += os->address() + off;
1082       else
1083         {
1084           Sized_relobj_file<size, big_endian>* relobj =
1085               this->u2_.relobj->sized_relobj();
1086           gold_assert(relobj != NULL);
1087           address = os->output_address(relobj, this->shndx_, address);
1088           gold_assert(address != invalid_address);
1089         }
1090     }
1091   else if (this->u2_.od != NULL)
1092     address += this->u2_.od->address();
1093   return address;
1094 }
1095
1096 // Write out the offset and info fields of a Rel or Rela relocation
1097 // entry.
1098
1099 template<bool dynamic, int size, bool big_endian>
1100 template<typename Write_rel>
1101 void
1102 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::write_rel(
1103     Write_rel* wr) const
1104 {
1105   wr->put_r_offset(this->get_address());
1106   unsigned int sym_index = this->get_symbol_index();
1107   wr->put_r_info(elfcpp::elf_r_info<size>(sym_index, this->type_));
1108 }
1109
1110 // Write out a Rel relocation.
1111
1112 template<bool dynamic, int size, bool big_endian>
1113 void
1114 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::write(
1115     unsigned char* pov) const
1116 {
1117   elfcpp::Rel_write<size, big_endian> orel(pov);
1118   this->write_rel(&orel);
1119 }
1120
1121 // Get the value of the symbol referred to by a Rel relocation.
1122
1123 template<bool dynamic, int size, bool big_endian>
1124 typename elfcpp::Elf_types<size>::Elf_Addr
1125 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::symbol_value(
1126     Addend addend) const
1127 {
1128   if (this->local_sym_index_ == GSYM_CODE)
1129     {
1130       const Sized_symbol<size>* sym;
1131       sym = static_cast<const Sized_symbol<size>*>(this->u1_.gsym);
1132       if (this->use_plt_offset_ && sym->has_plt_offset())
1133         return parameters->target().plt_address_for_global(sym);
1134       else
1135         return sym->value() + addend;
1136     }
1137   if (this->local_sym_index_ == SECTION_CODE)
1138     {
1139       gold_assert(!this->use_plt_offset_);
1140       return this->u1_.os->address() + addend;
1141     }
1142   gold_assert(this->local_sym_index_ != TARGET_CODE
1143               && this->local_sym_index_ != INVALID_CODE
1144               && this->local_sym_index_ != 0
1145               && !this->is_section_symbol_);
1146   const unsigned int lsi = this->local_sym_index_;
1147   Sized_relobj_file<size, big_endian>* relobj =
1148       this->u1_.relobj->sized_relobj();
1149   gold_assert(relobj != NULL);
1150   if (this->use_plt_offset_)
1151     return parameters->target().plt_address_for_local(relobj, lsi);
1152   const Symbol_value<size>* symval = relobj->local_symbol(lsi);
1153   return symval->value(relobj, addend);
1154 }
1155
1156 // Reloc comparison.  This function sorts the dynamic relocs for the
1157 // benefit of the dynamic linker.  First we sort all relative relocs
1158 // to the front.  Among relative relocs, we sort by output address.
1159 // Among non-relative relocs, we sort by symbol index, then by output
1160 // address.
1161
1162 template<bool dynamic, int size, bool big_endian>
1163 int
1164 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::
1165   compare(const Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>& r2)
1166     const
1167 {
1168   if (this->is_relative_)
1169     {
1170       if (!r2.is_relative_)
1171         return -1;
1172       // Otherwise sort by reloc address below.
1173     }
1174   else if (r2.is_relative_)
1175     return 1;
1176   else
1177     {
1178       unsigned int sym1 = this->get_symbol_index();
1179       unsigned int sym2 = r2.get_symbol_index();
1180       if (sym1 < sym2)
1181         return -1;
1182       else if (sym1 > sym2)
1183         return 1;
1184       // Otherwise sort by reloc address.
1185     }
1186
1187   section_offset_type addr1 = this->get_address();
1188   section_offset_type addr2 = r2.get_address();
1189   if (addr1 < addr2)
1190     return -1;
1191   else if (addr1 > addr2)
1192     return 1;
1193
1194   // Final tie breaker, in order to generate the same output on any
1195   // host: reloc type.
1196   unsigned int type1 = this->type_;
1197   unsigned int type2 = r2.type_;
1198   if (type1 < type2)
1199     return -1;
1200   else if (type1 > type2)
1201     return 1;
1202
1203   // These relocs appear to be exactly the same.
1204   return 0;
1205 }
1206
1207 // Write out a Rela relocation.
1208
1209 template<bool dynamic, int size, bool big_endian>
1210 void
1211 Output_reloc<elfcpp::SHT_RELA, dynamic, size, big_endian>::write(
1212     unsigned char* pov) const
1213 {
1214   elfcpp::Rela_write<size, big_endian> orel(pov);
1215   this->rel_.write_rel(&orel);
1216   Addend addend = this->addend_;
1217   if (this->rel_.is_target_specific())
1218     addend = parameters->target().reloc_addend(this->rel_.target_arg(),
1219                                                this->rel_.type(), addend);
1220   else if (this->rel_.is_symbolless())
1221     addend = this->rel_.symbol_value(addend);
1222   else if (this->rel_.is_local_section_symbol())
1223     addend = this->rel_.local_section_offset(addend);
1224   orel.put_r_addend(addend);
1225 }
1226
1227 // Output_data_reloc_base methods.
1228
1229 // Adjust the output section.
1230
1231 template<int sh_type, bool dynamic, int size, bool big_endian>
1232 void
1233 Output_data_reloc_base<sh_type, dynamic, size, big_endian>
1234     ::do_adjust_output_section(Output_section* os)
1235 {
1236   if (sh_type == elfcpp::SHT_REL)
1237     os->set_entsize(elfcpp::Elf_sizes<size>::rel_size);
1238   else if (sh_type == elfcpp::SHT_RELA)
1239     os->set_entsize(elfcpp::Elf_sizes<size>::rela_size);
1240   else
1241     gold_unreachable();
1242
1243   // A STT_GNU_IFUNC symbol may require a IRELATIVE reloc when doing a
1244   // static link.  The backends will generate a dynamic reloc section
1245   // to hold this.  In that case we don't want to link to the dynsym
1246   // section, because there isn't one.
1247   if (!dynamic)
1248     os->set_should_link_to_symtab();
1249   else if (parameters->doing_static_link())
1250     ;
1251   else
1252     os->set_should_link_to_dynsym();
1253 }
1254
1255 // Write out relocation data.
1256
1257 template<int sh_type, bool dynamic, int size, bool big_endian>
1258 void
1259 Output_data_reloc_base<sh_type, dynamic, size, big_endian>::do_write(
1260     Output_file* of)
1261 {
1262   const off_t off = this->offset();
1263   const off_t oview_size = this->data_size();
1264   unsigned char* const oview = of->get_output_view(off, oview_size);
1265
1266   if (this->sort_relocs())
1267     {
1268       gold_assert(dynamic);
1269       std::sort(this->relocs_.begin(), this->relocs_.end(),
1270                 Sort_relocs_comparison());
1271     }
1272
1273   unsigned char* pov = oview;
1274   for (typename Relocs::const_iterator p = this->relocs_.begin();
1275        p != this->relocs_.end();
1276        ++p)
1277     {
1278       p->write(pov);
1279       pov += reloc_size;
1280     }
1281
1282   gold_assert(pov - oview == oview_size);
1283
1284   of->write_output_view(off, oview_size, oview);
1285
1286   // We no longer need the relocation entries.
1287   this->relocs_.clear();
1288 }
1289
1290 // Class Output_relocatable_relocs.
1291
1292 template<int sh_type, int size, bool big_endian>
1293 void
1294 Output_relocatable_relocs<sh_type, size, big_endian>::set_final_data_size()
1295 {
1296   this->set_data_size(this->rr_->output_reloc_count()
1297                       * Reloc_types<sh_type, size, big_endian>::reloc_size);
1298 }
1299
1300 // class Output_data_group.
1301
1302 template<int size, bool big_endian>
1303 Output_data_group<size, big_endian>::Output_data_group(
1304     Sized_relobj_file<size, big_endian>* relobj,
1305     section_size_type entry_count,
1306     elfcpp::Elf_Word flags,
1307     std::vector<unsigned int>* input_shndxes)
1308   : Output_section_data(entry_count * 4, 4, false),
1309     relobj_(relobj),
1310     flags_(flags)
1311 {
1312   this->input_shndxes_.swap(*input_shndxes);
1313 }
1314
1315 // Write out the section group, which means translating the section
1316 // indexes to apply to the output file.
1317
1318 template<int size, bool big_endian>
1319 void
1320 Output_data_group<size, big_endian>::do_write(Output_file* of)
1321 {
1322   const off_t off = this->offset();
1323   const section_size_type oview_size =
1324     convert_to_section_size_type(this->data_size());
1325   unsigned char* const oview = of->get_output_view(off, oview_size);
1326
1327   elfcpp::Elf_Word* contents = reinterpret_cast<elfcpp::Elf_Word*>(oview);
1328   elfcpp::Swap<32, big_endian>::writeval(contents, this->flags_);
1329   ++contents;
1330
1331   for (std::vector<unsigned int>::const_iterator p =
1332          this->input_shndxes_.begin();
1333        p != this->input_shndxes_.end();
1334        ++p, ++contents)
1335     {
1336       Output_section* os = this->relobj_->output_section(*p);
1337
1338       unsigned int output_shndx;
1339       if (os != NULL)
1340         output_shndx = os->out_shndx();
1341       else
1342         {
1343           this->relobj_->error(_("section group retained but "
1344                                  "group element discarded"));
1345           output_shndx = 0;
1346         }
1347
1348       elfcpp::Swap<32, big_endian>::writeval(contents, output_shndx);
1349     }
1350
1351   size_t wrote = reinterpret_cast<unsigned char*>(contents) - oview;
1352   gold_assert(wrote == oview_size);
1353
1354   of->write_output_view(off, oview_size, oview);
1355
1356   // We no longer need this information.
1357   this->input_shndxes_.clear();
1358 }
1359
1360 // Output_data_got::Got_entry methods.
1361
1362 // Write out the entry.
1363
1364 template<int got_size, bool big_endian>
1365 void
1366 Output_data_got<got_size, big_endian>::Got_entry::write(
1367     unsigned int got_indx,
1368     unsigned char* pov) const
1369 {
1370   Valtype val = 0;
1371
1372   switch (this->local_sym_index_)
1373     {
1374     case GSYM_CODE:
1375       {
1376         // If the symbol is resolved locally, we need to write out the
1377         // link-time value, which will be relocated dynamically by a
1378         // RELATIVE relocation.
1379         Symbol* gsym = this->u_.gsym;
1380         if (this->use_plt_or_tls_offset_ && gsym->has_plt_offset())
1381           val = parameters->target().plt_address_for_global(gsym);
1382         else
1383           {
1384             switch (parameters->size_and_endianness())
1385               {
1386 #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG)
1387               case Parameters::TARGET_32_LITTLE:
1388               case Parameters::TARGET_32_BIG:
1389                 {
1390                   // This cast is ugly.  We don't want to put a
1391                   // virtual method in Symbol, because we want Symbol
1392                   // to be as small as possible.
1393                   Sized_symbol<32>::Value_type v;
1394                   v = static_cast<Sized_symbol<32>*>(gsym)->value();
1395                   val = convert_types<Valtype, Sized_symbol<32>::Value_type>(v);
1396                 }
1397                 break;
1398 #endif
1399 #if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG)
1400               case Parameters::TARGET_64_LITTLE:
1401               case Parameters::TARGET_64_BIG:
1402                 {
1403                   Sized_symbol<64>::Value_type v;
1404                   v = static_cast<Sized_symbol<64>*>(gsym)->value();
1405                   val = convert_types<Valtype, Sized_symbol<64>::Value_type>(v);
1406                 }
1407                 break;
1408 #endif
1409               default:
1410                 gold_unreachable();
1411               }
1412             if (this->use_plt_or_tls_offset_
1413                 && gsym->type() == elfcpp::STT_TLS)
1414               val += parameters->target().tls_offset_for_global(gsym,
1415                                                                 got_indx);
1416           }
1417       }
1418       break;
1419
1420     case CONSTANT_CODE:
1421       val = this->u_.constant;
1422       break;
1423
1424     case RESERVED_CODE:
1425       // If we're doing an incremental update, don't touch this GOT entry.
1426       if (parameters->incremental_update())
1427         return;
1428       val = this->u_.constant;
1429       break;
1430
1431     default:
1432       {
1433         const Relobj* object = this->u_.object;
1434         const unsigned int lsi = this->local_sym_index_;
1435         bool is_tls = object->local_is_tls(lsi);
1436         if (this->use_plt_or_tls_offset_ && !is_tls)
1437           val = parameters->target().plt_address_for_local(object, lsi);
1438         else
1439           {
1440             uint64_t lval = object->local_symbol_value(lsi, 0);
1441             val = convert_types<Valtype, uint64_t>(lval);
1442             if (this->use_plt_or_tls_offset_ && is_tls)
1443               val += parameters->target().tls_offset_for_local(object, lsi,
1444                                                                got_indx);
1445           }
1446       }
1447       break;
1448     }
1449
1450   elfcpp::Swap<got_size, big_endian>::writeval(pov, val);
1451 }
1452
1453 // Output_data_got methods.
1454
1455 // Add an entry for a global symbol to the GOT.  This returns true if
1456 // this is a new GOT entry, false if the symbol already had a GOT
1457 // entry.
1458
1459 template<int got_size, bool big_endian>
1460 bool
1461 Output_data_got<got_size, big_endian>::add_global(
1462     Symbol* gsym,
1463     unsigned int got_type)
1464 {
1465   if (gsym->has_got_offset(got_type))
1466     return false;
1467
1468   unsigned int got_offset = this->add_got_entry(Got_entry(gsym, false));
1469   gsym->set_got_offset(got_type, got_offset);
1470   return true;
1471 }
1472
1473 // Like add_global, but use the PLT offset.
1474
1475 template<int got_size, bool big_endian>
1476 bool
1477 Output_data_got<got_size, big_endian>::add_global_plt(Symbol* gsym,
1478                                                       unsigned int got_type)
1479 {
1480   if (gsym->has_got_offset(got_type))
1481     return false;
1482
1483   unsigned int got_offset = this->add_got_entry(Got_entry(gsym, true));
1484   gsym->set_got_offset(got_type, got_offset);
1485   return true;
1486 }
1487
1488 // Add an entry for a global symbol to the GOT, and add a dynamic
1489 // relocation of type R_TYPE for the GOT entry.
1490
1491 template<int got_size, bool big_endian>
1492 void
1493 Output_data_got<got_size, big_endian>::add_global_with_rel(
1494     Symbol* gsym,
1495     unsigned int got_type,
1496     Output_data_reloc_generic* rel_dyn,
1497     unsigned int r_type)
1498 {
1499   if (gsym->has_got_offset(got_type))
1500     return;
1501
1502   unsigned int got_offset = this->add_got_entry(Got_entry());
1503   gsym->set_got_offset(got_type, got_offset);
1504   rel_dyn->add_global_generic(gsym, r_type, this, got_offset, 0);
1505 }
1506
1507 // Add a pair of entries for a global symbol to the GOT, and add
1508 // dynamic relocations of type R_TYPE_1 and R_TYPE_2, respectively.
1509 // If R_TYPE_2 == 0, add the second entry with no relocation.
1510 template<int got_size, bool big_endian>
1511 void
1512 Output_data_got<got_size, big_endian>::add_global_pair_with_rel(
1513     Symbol* gsym,
1514     unsigned int got_type,
1515     Output_data_reloc_generic* rel_dyn,
1516     unsigned int r_type_1,
1517     unsigned int r_type_2)
1518 {
1519   if (gsym->has_got_offset(got_type))
1520     return;
1521
1522   unsigned int got_offset = this->add_got_entry_pair(Got_entry(), Got_entry());
1523   gsym->set_got_offset(got_type, got_offset);
1524   rel_dyn->add_global_generic(gsym, r_type_1, this, got_offset, 0);
1525
1526   if (r_type_2 != 0)
1527     rel_dyn->add_global_generic(gsym, r_type_2, this,
1528                                 got_offset + got_size / 8, 0);
1529 }
1530
1531 // Add an entry for a local symbol to the GOT.  This returns true if
1532 // this is a new GOT entry, false if the symbol already has a GOT
1533 // entry.
1534
1535 template<int got_size, bool big_endian>
1536 bool
1537 Output_data_got<got_size, big_endian>::add_local(
1538     Relobj* object,
1539     unsigned int symndx,
1540     unsigned int got_type)
1541 {
1542   if (object->local_has_got_offset(symndx, got_type))
1543     return false;
1544
1545   unsigned int got_offset = this->add_got_entry(Got_entry(object, symndx,
1546                                                           false));
1547   object->set_local_got_offset(symndx, got_type, got_offset);
1548   return true;
1549 }
1550
1551 // Like add_local, but use the PLT offset.
1552
1553 template<int got_size, bool big_endian>
1554 bool
1555 Output_data_got<got_size, big_endian>::add_local_plt(
1556     Relobj* object,
1557     unsigned int symndx,
1558     unsigned int got_type)
1559 {
1560   if (object->local_has_got_offset(symndx, got_type))
1561     return false;
1562
1563   unsigned int got_offset = this->add_got_entry(Got_entry(object, symndx,
1564                                                           true));
1565   object->set_local_got_offset(symndx, got_type, got_offset);
1566   return true;
1567 }
1568
1569 // Add an entry for a local symbol to the GOT, and add a dynamic
1570 // relocation of type R_TYPE for the GOT entry.
1571
1572 template<int got_size, bool big_endian>
1573 void
1574 Output_data_got<got_size, big_endian>::add_local_with_rel(
1575     Relobj* object,
1576     unsigned int symndx,
1577     unsigned int got_type,
1578     Output_data_reloc_generic* rel_dyn,
1579     unsigned int r_type)
1580 {
1581   if (object->local_has_got_offset(symndx, got_type))
1582     return;
1583
1584   unsigned int got_offset = this->add_got_entry(Got_entry());
1585   object->set_local_got_offset(symndx, got_type, got_offset);
1586   rel_dyn->add_local_generic(object, symndx, r_type, this, got_offset, 0);
1587 }
1588
1589 // Add a pair of entries for a local symbol to the GOT, and add
1590 // a dynamic relocation of type R_TYPE using the section symbol of
1591 // the output section to which input section SHNDX maps, on the first.
1592 // The first got entry will have a value of zero, the second the
1593 // value of the local symbol.
1594 template<int got_size, bool big_endian>
1595 void
1596 Output_data_got<got_size, big_endian>::add_local_pair_with_rel(
1597     Relobj* object,
1598     unsigned int symndx,
1599     unsigned int shndx,
1600     unsigned int got_type,
1601     Output_data_reloc_generic* rel_dyn,
1602     unsigned int r_type)
1603 {
1604   if (object->local_has_got_offset(symndx, got_type))
1605     return;
1606
1607   unsigned int got_offset =
1608       this->add_got_entry_pair(Got_entry(),
1609                                Got_entry(object, symndx, false));
1610   object->set_local_got_offset(symndx, got_type, got_offset);
1611   Output_section* os = object->output_section(shndx);
1612   rel_dyn->add_output_section_generic(os, r_type, this, got_offset, 0);
1613 }
1614
1615 // Add a pair of entries for a local symbol to the GOT, and add
1616 // a dynamic relocation of type R_TYPE using STN_UNDEF on the first.
1617 // The first got entry will have a value of zero, the second the
1618 // value of the local symbol offset by Target::tls_offset_for_local.
1619 template<int got_size, bool big_endian>
1620 void
1621 Output_data_got<got_size, big_endian>::add_local_tls_pair(
1622     Relobj* object,
1623     unsigned int symndx,
1624     unsigned int got_type,
1625     Output_data_reloc_generic* rel_dyn,
1626     unsigned int r_type)
1627 {
1628   if (object->local_has_got_offset(symndx, got_type))
1629     return;
1630
1631   unsigned int got_offset
1632     = this->add_got_entry_pair(Got_entry(),
1633                                Got_entry(object, symndx, true));
1634   object->set_local_got_offset(symndx, got_type, got_offset);
1635   rel_dyn->add_local_generic(object, 0, r_type, this, got_offset, 0);
1636 }
1637
1638 // Reserve a slot in the GOT for a local symbol or the second slot of a pair.
1639
1640 template<int got_size, bool big_endian>
1641 void
1642 Output_data_got<got_size, big_endian>::reserve_local(
1643     unsigned int i,
1644     Relobj* object,
1645     unsigned int sym_index,
1646     unsigned int got_type)
1647 {
1648   this->do_reserve_slot(i);
1649   object->set_local_got_offset(sym_index, got_type, this->got_offset(i));
1650 }
1651
1652 // Reserve a slot in the GOT for a global symbol.
1653
1654 template<int got_size, bool big_endian>
1655 void
1656 Output_data_got<got_size, big_endian>::reserve_global(
1657     unsigned int i,
1658     Symbol* gsym,
1659     unsigned int got_type)
1660 {
1661   this->do_reserve_slot(i);
1662   gsym->set_got_offset(got_type, this->got_offset(i));
1663 }
1664
1665 // Write out the GOT.
1666
1667 template<int got_size, bool big_endian>
1668 void
1669 Output_data_got<got_size, big_endian>::do_write(Output_file* of)
1670 {
1671   const int add = got_size / 8;
1672
1673   const off_t off = this->offset();
1674   const off_t oview_size = this->data_size();
1675   unsigned char* const oview = of->get_output_view(off, oview_size);
1676
1677   unsigned char* pov = oview;
1678   for (unsigned int i = 0; i < this->entries_.size(); ++i)
1679     {
1680       this->entries_[i].write(i, pov);
1681       pov += add;
1682     }
1683
1684   gold_assert(pov - oview == oview_size);
1685
1686   of->write_output_view(off, oview_size, oview);
1687
1688   // We no longer need the GOT entries.
1689   this->entries_.clear();
1690 }
1691
1692 // Create a new GOT entry and return its offset.
1693
1694 template<int got_size, bool big_endian>
1695 unsigned int
1696 Output_data_got<got_size, big_endian>::add_got_entry(Got_entry got_entry)
1697 {
1698   if (!this->is_data_size_valid())
1699     {
1700       this->entries_.push_back(got_entry);
1701       this->set_got_size();
1702       return this->last_got_offset();
1703     }
1704   else
1705     {
1706       // For an incremental update, find an available slot.
1707       off_t got_offset = this->free_list_.allocate(got_size / 8,
1708                                                    got_size / 8, 0);
1709       if (got_offset == -1)
1710         gold_fallback(_("out of patch space (GOT);"
1711                         " relink with --incremental-full"));
1712       unsigned int got_index = got_offset / (got_size / 8);
1713       gold_assert(got_index < this->entries_.size());
1714       this->entries_[got_index] = got_entry;
1715       return static_cast<unsigned int>(got_offset);
1716     }
1717 }
1718
1719 // Create a pair of new GOT entries and return the offset of the first.
1720
1721 template<int got_size, bool big_endian>
1722 unsigned int
1723 Output_data_got<got_size, big_endian>::add_got_entry_pair(
1724     Got_entry got_entry_1,
1725     Got_entry got_entry_2)
1726 {
1727   if (!this->is_data_size_valid())
1728     {
1729       unsigned int got_offset;
1730       this->entries_.push_back(got_entry_1);
1731       got_offset = this->last_got_offset();
1732       this->entries_.push_back(got_entry_2);
1733       this->set_got_size();
1734       return got_offset;
1735     }
1736   else
1737     {
1738       // For an incremental update, find an available pair of slots.
1739       off_t got_offset = this->free_list_.allocate(2 * got_size / 8,
1740                                                    got_size / 8, 0);
1741       if (got_offset == -1)
1742         gold_fallback(_("out of patch space (GOT);"
1743                         " relink with --incremental-full"));
1744       unsigned int got_index = got_offset / (got_size / 8);
1745       gold_assert(got_index < this->entries_.size());
1746       this->entries_[got_index] = got_entry_1;
1747       this->entries_[got_index + 1] = got_entry_2;
1748       return static_cast<unsigned int>(got_offset);
1749     }
1750 }
1751
1752 // Replace GOT entry I with a new value.
1753
1754 template<int got_size, bool big_endian>
1755 void
1756 Output_data_got<got_size, big_endian>::replace_got_entry(
1757     unsigned int i,
1758     Got_entry got_entry)
1759 {
1760   gold_assert(i < this->entries_.size());
1761   this->entries_[i] = got_entry;
1762 }
1763
1764 // Output_data_dynamic::Dynamic_entry methods.
1765
1766 // Write out the entry.
1767
1768 template<int size, bool big_endian>
1769 void
1770 Output_data_dynamic::Dynamic_entry::write(
1771     unsigned char* pov,
1772     const Stringpool* pool) const
1773 {
1774   typename elfcpp::Elf_types<size>::Elf_WXword val;
1775   switch (this->offset_)
1776     {
1777     case DYNAMIC_NUMBER:
1778       val = this->u_.val;
1779       break;
1780
1781     case DYNAMIC_SECTION_SIZE:
1782       val = this->u_.od->data_size();
1783       if (this->od2 != NULL)
1784         val += this->od2->data_size();
1785       break;
1786
1787     case DYNAMIC_SYMBOL:
1788       {
1789         const Sized_symbol<size>* s =
1790           static_cast<const Sized_symbol<size>*>(this->u_.sym);
1791         val = s->value();
1792       }
1793       break;
1794
1795     case DYNAMIC_STRING:
1796       val = pool->get_offset(this->u_.str);
1797       break;
1798
1799     case DYNAMIC_CUSTOM:
1800       val = parameters->target().dynamic_tag_custom_value(this->tag_);
1801       break;
1802
1803     default:
1804       val = this->u_.od->address() + this->offset_;
1805       break;
1806     }
1807
1808   elfcpp::Dyn_write<size, big_endian> dw(pov);
1809   dw.put_d_tag(this->tag_);
1810   dw.put_d_val(val);
1811 }
1812
1813 // Output_data_dynamic methods.
1814
1815 // Adjust the output section to set the entry size.
1816
1817 void
1818 Output_data_dynamic::do_adjust_output_section(Output_section* os)
1819 {
1820   if (parameters->target().get_size() == 32)
1821     os->set_entsize(elfcpp::Elf_sizes<32>::dyn_size);
1822   else if (parameters->target().get_size() == 64)
1823     os->set_entsize(elfcpp::Elf_sizes<64>::dyn_size);
1824   else
1825     gold_unreachable();
1826 }
1827
1828 // Set the final data size.
1829
1830 void
1831 Output_data_dynamic::set_final_data_size()
1832 {
1833   // Add the terminating entry if it hasn't been added.
1834   // Because of relaxation, we can run this multiple times.
1835   if (this->entries_.empty() || this->entries_.back().tag() != elfcpp::DT_NULL)
1836     {
1837       int extra = parameters->options().spare_dynamic_tags();
1838       for (int i = 0; i < extra; ++i)
1839         this->add_constant(elfcpp::DT_NULL, 0);
1840       this->add_constant(elfcpp::DT_NULL, 0);
1841     }
1842
1843   int dyn_size;
1844   if (parameters->target().get_size() == 32)
1845     dyn_size = elfcpp::Elf_sizes<32>::dyn_size;
1846   else if (parameters->target().get_size() == 64)
1847     dyn_size = elfcpp::Elf_sizes<64>::dyn_size;
1848   else
1849     gold_unreachable();
1850   this->set_data_size(this->entries_.size() * dyn_size);
1851 }
1852
1853 // Write out the dynamic entries.
1854
1855 void
1856 Output_data_dynamic::do_write(Output_file* of)
1857 {
1858   switch (parameters->size_and_endianness())
1859     {
1860 #ifdef HAVE_TARGET_32_LITTLE
1861     case Parameters::TARGET_32_LITTLE:
1862       this->sized_write<32, false>(of);
1863       break;
1864 #endif
1865 #ifdef HAVE_TARGET_32_BIG
1866     case Parameters::TARGET_32_BIG:
1867       this->sized_write<32, true>(of);
1868       break;
1869 #endif
1870 #ifdef HAVE_TARGET_64_LITTLE
1871     case Parameters::TARGET_64_LITTLE:
1872       this->sized_write<64, false>(of);
1873       break;
1874 #endif
1875 #ifdef HAVE_TARGET_64_BIG
1876     case Parameters::TARGET_64_BIG:
1877       this->sized_write<64, true>(of);
1878       break;
1879 #endif
1880     default:
1881       gold_unreachable();
1882     }
1883 }
1884
1885 template<int size, bool big_endian>
1886 void
1887 Output_data_dynamic::sized_write(Output_file* of)
1888 {
1889   const int dyn_size = elfcpp::Elf_sizes<size>::dyn_size;
1890
1891   const off_t offset = this->offset();
1892   const off_t oview_size = this->data_size();
1893   unsigned char* const oview = of->get_output_view(offset, oview_size);
1894
1895   unsigned char* pov = oview;
1896   for (typename Dynamic_entries::const_iterator p = this->entries_.begin();
1897        p != this->entries_.end();
1898        ++p)
1899     {
1900       p->write<size, big_endian>(pov, this->pool_);
1901       pov += dyn_size;
1902     }
1903
1904   gold_assert(pov - oview == oview_size);
1905
1906   of->write_output_view(offset, oview_size, oview);
1907
1908   // We no longer need the dynamic entries.
1909   this->entries_.clear();
1910 }
1911
1912 // Class Output_symtab_xindex.
1913
1914 void
1915 Output_symtab_xindex::do_write(Output_file* of)
1916 {
1917   const off_t offset = this->offset();
1918   const off_t oview_size = this->data_size();
1919   unsigned char* const oview = of->get_output_view(offset, oview_size);
1920
1921   memset(oview, 0, oview_size);
1922
1923   if (parameters->target().is_big_endian())
1924     this->endian_do_write<true>(oview);
1925   else
1926     this->endian_do_write<false>(oview);
1927
1928   of->write_output_view(offset, oview_size, oview);
1929
1930   // We no longer need the data.
1931   this->entries_.clear();
1932 }
1933
1934 template<bool big_endian>
1935 void
1936 Output_symtab_xindex::endian_do_write(unsigned char* const oview)
1937 {
1938   for (Xindex_entries::const_iterator p = this->entries_.begin();
1939        p != this->entries_.end();
1940        ++p)
1941     {
1942       unsigned int symndx = p->first;
1943       gold_assert(static_cast<off_t>(symndx) * 4 < this->data_size());
1944       elfcpp::Swap<32, big_endian>::writeval(oview + symndx * 4, p->second);
1945     }
1946 }
1947
1948 // Output_fill_debug_info methods.
1949
1950 // Return the minimum size needed for a dummy compilation unit header.
1951
1952 size_t
1953 Output_fill_debug_info::do_minimum_hole_size() const
1954 {
1955   // Compile unit header fields: unit_length, version, debug_abbrev_offset,
1956   // address_size.
1957   const size_t len = 4 + 2 + 4 + 1;
1958   // For type units, add type_signature, type_offset.
1959   if (this->is_debug_types_)
1960     return len + 8 + 4;
1961   return len;
1962 }
1963
1964 // Write a dummy compilation unit header to fill a hole in the
1965 // .debug_info or .debug_types section.
1966
1967 void
1968 Output_fill_debug_info::do_write(Output_file* of, off_t off, size_t len) const
1969 {
1970   gold_debug(DEBUG_INCREMENTAL, "fill_debug_info(%08lx, %08lx)",
1971              static_cast<long>(off), static_cast<long>(len));
1972
1973   gold_assert(len >= this->do_minimum_hole_size());
1974
1975   unsigned char* const oview = of->get_output_view(off, len);
1976   unsigned char* pov = oview;
1977
1978   // Write header fields: unit_length, version, debug_abbrev_offset,
1979   // address_size.
1980   if (this->is_big_endian())
1981     {
1982       elfcpp::Swap_unaligned<32, true>::writeval(pov, len - 4);
1983       elfcpp::Swap_unaligned<16, true>::writeval(pov + 4, this->version);
1984       elfcpp::Swap_unaligned<32, true>::writeval(pov + 6, 0);
1985     }
1986   else
1987     {
1988       elfcpp::Swap_unaligned<32, false>::writeval(pov, len - 4);
1989       elfcpp::Swap_unaligned<16, false>::writeval(pov + 4, this->version);
1990       elfcpp::Swap_unaligned<32, false>::writeval(pov + 6, 0);
1991     }
1992   pov += 4 + 2 + 4;
1993   *pov++ = 4;
1994
1995   // For type units, the additional header fields -- type_signature,
1996   // type_offset -- can be filled with zeroes.
1997
1998   // Fill the remainder of the free space with zeroes.  The first
1999   // zero should tell the consumer there are no DIEs to read in this
2000   // compilation unit.
2001   if (pov < oview + len)
2002     memset(pov, 0, oview + len - pov);
2003
2004   of->write_output_view(off, len, oview);
2005 }
2006
2007 // Output_fill_debug_line methods.
2008
2009 // Return the minimum size needed for a dummy line number program header.
2010
2011 size_t
2012 Output_fill_debug_line::do_minimum_hole_size() const
2013 {
2014   // Line number program header fields: unit_length, version, header_length,
2015   // minimum_instruction_length, default_is_stmt, line_base, line_range,
2016   // opcode_base, standard_opcode_lengths[], include_directories, filenames.
2017   const size_t len = 4 + 2 + 4 + this->header_length;
2018   return len;
2019 }
2020
2021 // Write a dummy line number program header to fill a hole in the
2022 // .debug_line section.
2023
2024 void
2025 Output_fill_debug_line::do_write(Output_file* of, off_t off, size_t len) const
2026 {
2027   gold_debug(DEBUG_INCREMENTAL, "fill_debug_line(%08lx, %08lx)",
2028              static_cast<long>(off), static_cast<long>(len));
2029
2030   gold_assert(len >= this->do_minimum_hole_size());
2031
2032   unsigned char* const oview = of->get_output_view(off, len);
2033   unsigned char* pov = oview;
2034
2035   // Write header fields: unit_length, version, header_length,
2036   // minimum_instruction_length, default_is_stmt, line_base, line_range,
2037   // opcode_base, standard_opcode_lengths[], include_directories, filenames.
2038   // We set the header_length field to cover the entire hole, so the
2039   // line number program is empty.
2040   if (this->is_big_endian())
2041     {
2042       elfcpp::Swap_unaligned<32, true>::writeval(pov, len - 4);
2043       elfcpp::Swap_unaligned<16, true>::writeval(pov + 4, this->version);
2044       elfcpp::Swap_unaligned<32, true>::writeval(pov + 6, len - (4 + 2 + 4));
2045     }
2046   else
2047     {
2048       elfcpp::Swap_unaligned<32, false>::writeval(pov, len - 4);
2049       elfcpp::Swap_unaligned<16, false>::writeval(pov + 4, this->version);
2050       elfcpp::Swap_unaligned<32, false>::writeval(pov + 6, len - (4 + 2 + 4));
2051     }
2052   pov += 4 + 2 + 4;
2053   *pov++ = 1;   // minimum_instruction_length
2054   *pov++ = 0;   // default_is_stmt
2055   *pov++ = 0;   // line_base
2056   *pov++ = 5;   // line_range
2057   *pov++ = 13;  // opcode_base
2058   *pov++ = 0;   // standard_opcode_lengths[1]
2059   *pov++ = 1;   // standard_opcode_lengths[2]
2060   *pov++ = 1;   // standard_opcode_lengths[3]
2061   *pov++ = 1;   // standard_opcode_lengths[4]
2062   *pov++ = 1;   // standard_opcode_lengths[5]
2063   *pov++ = 0;   // standard_opcode_lengths[6]
2064   *pov++ = 0;   // standard_opcode_lengths[7]
2065   *pov++ = 0;   // standard_opcode_lengths[8]
2066   *pov++ = 1;   // standard_opcode_lengths[9]
2067   *pov++ = 0;   // standard_opcode_lengths[10]
2068   *pov++ = 0;   // standard_opcode_lengths[11]
2069   *pov++ = 1;   // standard_opcode_lengths[12]
2070   *pov++ = 0;   // include_directories (empty)
2071   *pov++ = 0;   // filenames (empty)
2072
2073   // Some consumers don't check the header_length field, and simply
2074   // start reading the line number program immediately following the
2075   // header.  For those consumers, we fill the remainder of the free
2076   // space with DW_LNS_set_basic_block opcodes.  These are effectively
2077   // no-ops: the resulting line table program will not create any rows.
2078   if (pov < oview + len)
2079     memset(pov, elfcpp::DW_LNS_set_basic_block, oview + len - pov);
2080
2081   of->write_output_view(off, len, oview);
2082 }
2083
2084 // Output_section::Input_section methods.
2085
2086 // Return the current data size.  For an input section we store the size here.
2087 // For an Output_section_data, we have to ask it for the size.
2088
2089 off_t
2090 Output_section::Input_section::current_data_size() const
2091 {
2092   if (this->is_input_section())
2093     return this->u1_.data_size;
2094   else
2095     {
2096       this->u2_.posd->pre_finalize_data_size();
2097       return this->u2_.posd->current_data_size();
2098     }
2099 }
2100
2101 // Return the data size.  For an input section we store the size here.
2102 // For an Output_section_data, we have to ask it for the size.
2103
2104 off_t
2105 Output_section::Input_section::data_size() const
2106 {
2107   if (this->is_input_section())
2108     return this->u1_.data_size;
2109   else
2110     return this->u2_.posd->data_size();
2111 }
2112
2113 // Return the object for an input section.
2114
2115 Relobj*
2116 Output_section::Input_section::relobj() const
2117 {
2118   if (this->is_input_section())
2119     return this->u2_.object;
2120   else if (this->is_merge_section())
2121     {
2122       gold_assert(this->u2_.pomb->first_relobj() != NULL);
2123       return this->u2_.pomb->first_relobj();
2124     }
2125   else if (this->is_relaxed_input_section())
2126     return this->u2_.poris->relobj();
2127   else
2128     gold_unreachable();
2129 }
2130
2131 // Return the input section index for an input section.
2132
2133 unsigned int
2134 Output_section::Input_section::shndx() const
2135 {
2136   if (this->is_input_section())
2137     return this->shndx_;
2138   else if (this->is_merge_section())
2139     {
2140       gold_assert(this->u2_.pomb->first_relobj() != NULL);
2141       return this->u2_.pomb->first_shndx();
2142     }
2143   else if (this->is_relaxed_input_section())
2144     return this->u2_.poris->shndx();
2145   else
2146     gold_unreachable();
2147 }
2148
2149 // Set the address and file offset.
2150
2151 void
2152 Output_section::Input_section::set_address_and_file_offset(
2153     uint64_t address,
2154     off_t file_offset,
2155     off_t section_file_offset)
2156 {
2157   if (this->is_input_section())
2158     this->u2_.object->set_section_offset(this->shndx_,
2159                                          file_offset - section_file_offset);
2160   else
2161     this->u2_.posd->set_address_and_file_offset(address, file_offset);
2162 }
2163
2164 // Reset the address and file offset.
2165
2166 void
2167 Output_section::Input_section::reset_address_and_file_offset()
2168 {
2169   if (!this->is_input_section())
2170     this->u2_.posd->reset_address_and_file_offset();
2171 }
2172
2173 // Finalize the data size.
2174
2175 void
2176 Output_section::Input_section::finalize_data_size()
2177 {
2178   if (!this->is_input_section())
2179     this->u2_.posd->finalize_data_size();
2180 }
2181
2182 // Try to turn an input offset into an output offset.  We want to
2183 // return the output offset relative to the start of this
2184 // Input_section in the output section.
2185
2186 inline bool
2187 Output_section::Input_section::output_offset(
2188     const Relobj* object,
2189     unsigned int shndx,
2190     section_offset_type offset,
2191     section_offset_type* poutput) const
2192 {
2193   if (!this->is_input_section())
2194     return this->u2_.posd->output_offset(object, shndx, offset, poutput);
2195   else
2196     {
2197       if (this->shndx_ != shndx || this->u2_.object != object)
2198         return false;
2199       *poutput = offset;
2200       return true;
2201     }
2202 }
2203
2204 // Return whether this is the merge section for the input section
2205 // SHNDX in OBJECT.
2206
2207 inline bool
2208 Output_section::Input_section::is_merge_section_for(const Relobj* object,
2209                                                     unsigned int shndx) const
2210 {
2211   if (this->is_input_section())
2212     return false;
2213   return this->u2_.posd->is_merge_section_for(object, shndx);
2214 }
2215
2216 // Write out the data.  We don't have to do anything for an input
2217 // section--they are handled via Object::relocate--but this is where
2218 // we write out the data for an Output_section_data.
2219
2220 void
2221 Output_section::Input_section::write(Output_file* of)
2222 {
2223   if (!this->is_input_section())
2224     this->u2_.posd->write(of);
2225 }
2226
2227 // Write the data to a buffer.  As for write(), we don't have to do
2228 // anything for an input section.
2229
2230 void
2231 Output_section::Input_section::write_to_buffer(unsigned char* buffer)
2232 {
2233   if (!this->is_input_section())
2234     this->u2_.posd->write_to_buffer(buffer);
2235 }
2236
2237 // Print to a map file.
2238
2239 void
2240 Output_section::Input_section::print_to_mapfile(Mapfile* mapfile) const
2241 {
2242   switch (this->shndx_)
2243     {
2244     case OUTPUT_SECTION_CODE:
2245     case MERGE_DATA_SECTION_CODE:
2246     case MERGE_STRING_SECTION_CODE:
2247       this->u2_.posd->print_to_mapfile(mapfile);
2248       break;
2249
2250     case RELAXED_INPUT_SECTION_CODE:
2251       {
2252         Output_relaxed_input_section* relaxed_section =
2253           this->relaxed_input_section();
2254         mapfile->print_input_section(relaxed_section->relobj(),
2255                                      relaxed_section->shndx());
2256       }
2257       break;
2258     default:
2259       mapfile->print_input_section(this->u2_.object, this->shndx_);
2260       break;
2261     }
2262 }
2263
2264 // Output_section methods.
2265
2266 // Construct an Output_section.  NAME will point into a Stringpool.
2267
2268 Output_section::Output_section(const char* name, elfcpp::Elf_Word type,
2269                                elfcpp::Elf_Xword flags)
2270   : name_(name),
2271     addralign_(0),
2272     entsize_(0),
2273     load_address_(0),
2274     link_section_(NULL),
2275     link_(0),
2276     info_section_(NULL),
2277     info_symndx_(NULL),
2278     info_(0),
2279     type_(type),
2280     flags_(flags),
2281     order_(ORDER_INVALID),
2282     out_shndx_(-1U),
2283     symtab_index_(0),
2284     dynsym_index_(0),
2285     input_sections_(),
2286     first_input_offset_(0),
2287     fills_(),
2288     postprocessing_buffer_(NULL),
2289     needs_symtab_index_(false),
2290     needs_dynsym_index_(false),
2291     should_link_to_symtab_(false),
2292     should_link_to_dynsym_(false),
2293     after_input_sections_(false),
2294     requires_postprocessing_(false),
2295     found_in_sections_clause_(false),
2296     has_load_address_(false),
2297     info_uses_section_index_(false),
2298     input_section_order_specified_(false),
2299     may_sort_attached_input_sections_(false),
2300     must_sort_attached_input_sections_(false),
2301     attached_input_sections_are_sorted_(false),
2302     is_relro_(false),
2303     is_small_section_(false),
2304     is_large_section_(false),
2305     generate_code_fills_at_write_(false),
2306     is_entsize_zero_(false),
2307     section_offsets_need_adjustment_(false),
2308     is_noload_(false),
2309     always_keeps_input_sections_(false),
2310     has_fixed_layout_(false),
2311     is_patch_space_allowed_(false),
2312     is_unique_segment_(false),
2313     tls_offset_(0),
2314     extra_segment_flags_(0),
2315     segment_alignment_(0),
2316     checkpoint_(NULL),
2317     lookup_maps_(new Output_section_lookup_maps),
2318     free_list_(),
2319     free_space_fill_(NULL),
2320     patch_space_(0)
2321 {
2322   // An unallocated section has no address.  Forcing this means that
2323   // we don't need special treatment for symbols defined in debug
2324   // sections.
2325   if ((flags & elfcpp::SHF_ALLOC) == 0)
2326     this->set_address(0);
2327 }
2328
2329 Output_section::~Output_section()
2330 {
2331   delete this->checkpoint_;
2332 }
2333
2334 // Set the entry size.
2335
2336 void
2337 Output_section::set_entsize(uint64_t v)
2338 {
2339   if (this->is_entsize_zero_)
2340     ;
2341   else if (this->entsize_ == 0)
2342     this->entsize_ = v;
2343   else if (this->entsize_ != v)
2344     {
2345       this->entsize_ = 0;
2346       this->is_entsize_zero_ = 1;
2347     }
2348 }
2349
2350 // Add the input section SHNDX, with header SHDR, named SECNAME, in
2351 // OBJECT, to the Output_section.  RELOC_SHNDX is the index of a
2352 // relocation section which applies to this section, or 0 if none, or
2353 // -1U if more than one.  Return the offset of the input section
2354 // within the output section.  Return -1 if the input section will
2355 // receive special handling.  In the normal case we don't always keep
2356 // track of input sections for an Output_section.  Instead, each
2357 // Object keeps track of the Output_section for each of its input
2358 // sections.  However, if HAVE_SECTIONS_SCRIPT is true, we do keep
2359 // track of input sections here; this is used when SECTIONS appears in
2360 // a linker script.
2361
2362 template<int size, bool big_endian>
2363 off_t
2364 Output_section::add_input_section(Layout* layout,
2365                                   Sized_relobj_file<size, big_endian>* object,
2366                                   unsigned int shndx,
2367                                   const char* secname,
2368                                   const elfcpp::Shdr<size, big_endian>& shdr,
2369                                   unsigned int reloc_shndx,
2370                                   bool have_sections_script)
2371 {
2372   elfcpp::Elf_Xword addralign = shdr.get_sh_addralign();
2373   if ((addralign & (addralign - 1)) != 0)
2374     {
2375       object->error(_("invalid alignment %lu for section \"%s\""),
2376                     static_cast<unsigned long>(addralign), secname);
2377       addralign = 1;
2378     }
2379
2380   if (addralign > this->addralign_)
2381     this->addralign_ = addralign;
2382
2383   typename elfcpp::Elf_types<size>::Elf_WXword sh_flags = shdr.get_sh_flags();
2384   uint64_t entsize = shdr.get_sh_entsize();
2385
2386   // .debug_str is a mergeable string section, but is not always so
2387   // marked by compilers.  Mark manually here so we can optimize.
2388   if (strcmp(secname, ".debug_str") == 0)
2389     {
2390       sh_flags |= (elfcpp::SHF_MERGE | elfcpp::SHF_STRINGS);
2391       entsize = 1;
2392     }
2393
2394   this->update_flags_for_input_section(sh_flags);
2395   this->set_entsize(entsize);
2396
2397   // If this is a SHF_MERGE section, we pass all the input sections to
2398   // a Output_data_merge.  We don't try to handle relocations for such
2399   // a section.  We don't try to handle empty merge sections--they
2400   // mess up the mappings, and are useless anyhow.
2401   // FIXME: Need to handle merge sections during incremental update.
2402   if ((sh_flags & elfcpp::SHF_MERGE) != 0
2403       && reloc_shndx == 0
2404       && shdr.get_sh_size() > 0
2405       && !parameters->incremental())
2406     {
2407       // Keep information about merged input sections for rebuilding fast
2408       // lookup maps if we have sections-script or we do relaxation.
2409       bool keeps_input_sections = (this->always_keeps_input_sections_
2410                                    || have_sections_script
2411                                    || parameters->target().may_relax());
2412
2413       if (this->add_merge_input_section(object, shndx, sh_flags, entsize,
2414                                         addralign, keeps_input_sections))
2415         {
2416           // Tell the relocation routines that they need to call the
2417           // output_offset method to determine the final address.
2418           return -1;
2419         }
2420     }
2421
2422   section_size_type input_section_size = shdr.get_sh_size();
2423   section_size_type uncompressed_size;
2424   if (object->section_is_compressed(shndx, &uncompressed_size))
2425     input_section_size = uncompressed_size;
2426
2427   off_t offset_in_section;
2428
2429   if (this->has_fixed_layout())
2430     {
2431       // For incremental updates, find a chunk of unused space in the section.
2432       offset_in_section = this->free_list_.allocate(input_section_size,
2433                                                     addralign, 0);
2434       if (offset_in_section == -1)
2435         gold_fallback(_("out of patch space in section %s; "
2436                         "relink with --incremental-full"),
2437                       this->name());
2438       return offset_in_section;
2439     }
2440
2441   offset_in_section = this->current_data_size_for_child();
2442   off_t aligned_offset_in_section = align_address(offset_in_section,
2443                                                   addralign);
2444   this->set_current_data_size_for_child(aligned_offset_in_section
2445                                         + input_section_size);
2446
2447   // Determine if we want to delay code-fill generation until the output
2448   // section is written.  When the target is relaxing, we want to delay fill
2449   // generating to avoid adjusting them during relaxation.  Also, if we are
2450   // sorting input sections we must delay fill generation.
2451   if (!this->generate_code_fills_at_write_
2452       && !have_sections_script
2453       && (sh_flags & elfcpp::SHF_EXECINSTR) != 0
2454       && parameters->target().has_code_fill()
2455       && (parameters->target().may_relax()
2456           || layout->is_section_ordering_specified()))
2457     {
2458       gold_assert(this->fills_.empty());
2459       this->generate_code_fills_at_write_ = true;
2460     }
2461
2462   if (aligned_offset_in_section > offset_in_section
2463       && !this->generate_code_fills_at_write_
2464       && !have_sections_script
2465       && (sh_flags & elfcpp::SHF_EXECINSTR) != 0
2466       && parameters->target().has_code_fill())
2467     {
2468       // We need to add some fill data.  Using fill_list_ when
2469       // possible is an optimization, since we will often have fill
2470       // sections without input sections.
2471       off_t fill_len = aligned_offset_in_section - offset_in_section;
2472       if (this->input_sections_.empty())
2473         this->fills_.push_back(Fill(offset_in_section, fill_len));
2474       else
2475         {
2476           std::string fill_data(parameters->target().code_fill(fill_len));
2477           Output_data_const* odc = new Output_data_const(fill_data, 1);
2478           this->input_sections_.push_back(Input_section(odc));
2479         }
2480     }
2481
2482   // We need to keep track of this section if we are already keeping
2483   // track of sections, or if we are relaxing.  Also, if this is a
2484   // section which requires sorting, or which may require sorting in
2485   // the future, we keep track of the sections.  If the
2486   // --section-ordering-file option is used to specify the order of
2487   // sections, we need to keep track of sections.
2488   if (this->always_keeps_input_sections_
2489       || have_sections_script
2490       || !this->input_sections_.empty()
2491       || this->may_sort_attached_input_sections()
2492       || this->must_sort_attached_input_sections()
2493       || parameters->options().user_set_Map()
2494       || parameters->target().may_relax()
2495       || layout->is_section_ordering_specified())
2496     {
2497       Input_section isecn(object, shndx, input_section_size, addralign);
2498       /* If section ordering is requested by specifying a ordering file,
2499          using --section-ordering-file, match the section name with
2500          a pattern.  */
2501       if (parameters->options().section_ordering_file())
2502         {
2503           unsigned int section_order_index =
2504             layout->find_section_order_index(std::string(secname));
2505           if (section_order_index != 0)
2506             {
2507               isecn.set_section_order_index(section_order_index);
2508               this->set_input_section_order_specified();
2509             }
2510         }
2511       this->input_sections_.push_back(isecn);
2512     }
2513
2514   return aligned_offset_in_section;
2515 }
2516
2517 // Add arbitrary data to an output section.
2518
2519 void
2520 Output_section::add_output_section_data(Output_section_data* posd)
2521 {
2522   Input_section inp(posd);
2523   this->add_output_section_data(&inp);
2524
2525   if (posd->is_data_size_valid())
2526     {
2527       off_t offset_in_section;
2528       if (this->has_fixed_layout())
2529         {
2530           // For incremental updates, find a chunk of unused space.
2531           offset_in_section = this->free_list_.allocate(posd->data_size(),
2532                                                         posd->addralign(), 0);
2533           if (offset_in_section == -1)
2534             gold_fallback(_("out of patch space in section %s; "
2535                             "relink with --incremental-full"),
2536                           this->name());
2537           // Finalize the address and offset now.
2538           uint64_t addr = this->address();
2539           off_t offset = this->offset();
2540           posd->set_address_and_file_offset(addr + offset_in_section,
2541                                             offset + offset_in_section);
2542         }
2543       else
2544         {
2545           offset_in_section = this->current_data_size_for_child();
2546           off_t aligned_offset_in_section = align_address(offset_in_section,
2547                                                           posd->addralign());
2548           this->set_current_data_size_for_child(aligned_offset_in_section
2549                                                 + posd->data_size());
2550         }
2551     }
2552   else if (this->has_fixed_layout())
2553     {
2554       // For incremental updates, arrange for the data to have a fixed layout.
2555       // This will mean that additions to the data must be allocated from
2556       // free space within the containing output section.
2557       uint64_t addr = this->address();
2558       posd->set_address(addr);
2559       posd->set_file_offset(0);
2560       // FIXME: This should eventually be unreachable.
2561       // gold_unreachable();
2562     }
2563 }
2564
2565 // Add a relaxed input section.
2566
2567 void
2568 Output_section::add_relaxed_input_section(Layout* layout,
2569                                           Output_relaxed_input_section* poris,
2570                                           const std::string& name)
2571 {
2572   Input_section inp(poris);
2573
2574   // If the --section-ordering-file option is used to specify the order of
2575   // sections, we need to keep track of sections.
2576   if (layout->is_section_ordering_specified())
2577     {
2578       unsigned int section_order_index =
2579         layout->find_section_order_index(name);
2580       if (section_order_index != 0)
2581         {
2582           inp.set_section_order_index(section_order_index);
2583           this->set_input_section_order_specified();
2584         }
2585     }
2586
2587   this->add_output_section_data(&inp);
2588   if (this->lookup_maps_->is_valid())
2589     this->lookup_maps_->add_relaxed_input_section(poris->relobj(),
2590                                                   poris->shndx(), poris);
2591
2592   // For a relaxed section, we use the current data size.  Linker scripts
2593   // get all the input sections, including relaxed one from an output
2594   // section and add them back to the same output section to compute the
2595   // output section size.  If we do not account for sizes of relaxed input
2596   // sections, an output section would be incorrectly sized.
2597   off_t offset_in_section = this->current_data_size_for_child();
2598   off_t aligned_offset_in_section = align_address(offset_in_section,
2599                                                   poris->addralign());
2600   this->set_current_data_size_for_child(aligned_offset_in_section
2601                                         + poris->current_data_size());
2602 }
2603
2604 // Add arbitrary data to an output section by Input_section.
2605
2606 void
2607 Output_section::add_output_section_data(Input_section* inp)
2608 {
2609   if (this->input_sections_.empty())
2610     this->first_input_offset_ = this->current_data_size_for_child();
2611
2612   this->input_sections_.push_back(*inp);
2613
2614   uint64_t addralign = inp->addralign();
2615   if (addralign > this->addralign_)
2616     this->addralign_ = addralign;
2617
2618   inp->set_output_section(this);
2619 }
2620
2621 // Add a merge section to an output section.
2622
2623 void
2624 Output_section::add_output_merge_section(Output_section_data* posd,
2625                                          bool is_string, uint64_t entsize)
2626 {
2627   Input_section inp(posd, is_string, entsize);
2628   this->add_output_section_data(&inp);
2629 }
2630
2631 // Add an input section to a SHF_MERGE section.
2632
2633 bool
2634 Output_section::add_merge_input_section(Relobj* object, unsigned int shndx,
2635                                         uint64_t flags, uint64_t entsize,
2636                                         uint64_t addralign,
2637                                         bool keeps_input_sections)
2638 {
2639   bool is_string = (flags & elfcpp::SHF_STRINGS) != 0;
2640
2641   // We cannot restore merged input section states.
2642   gold_assert(this->checkpoint_ == NULL);
2643
2644   // Look up merge sections by required properties.
2645   // Currently, we only invalidate the lookup maps in script processing
2646   // and relaxation.  We should not have done either when we reach here.
2647   // So we assume that the lookup maps are valid to simply code.
2648   gold_assert(this->lookup_maps_->is_valid());
2649   Merge_section_properties msp(is_string, entsize, addralign);
2650   Output_merge_base* pomb = this->lookup_maps_->find_merge_section(msp);
2651   bool is_new = false;
2652   if (pomb != NULL)
2653     {
2654       gold_assert(pomb->is_string() == is_string
2655                   && pomb->entsize() == entsize
2656                   && pomb->addralign() == addralign);
2657     }
2658   else
2659     {
2660       // Create a new Output_merge_data or Output_merge_string_data.
2661       if (!is_string)
2662         pomb = new Output_merge_data(entsize, addralign);
2663       else
2664         {
2665           switch (entsize)
2666             {
2667             case 1:
2668               pomb = new Output_merge_string<char>(addralign);
2669               break;
2670             case 2:
2671               pomb = new Output_merge_string<uint16_t>(addralign);
2672               break;
2673             case 4:
2674               pomb = new Output_merge_string<uint32_t>(addralign);
2675               break;
2676             default:
2677               return false;
2678             }
2679         }
2680       // If we need to do script processing or relaxation, we need to keep
2681       // the original input sections to rebuild the fast lookup maps.
2682       if (keeps_input_sections)
2683         pomb->set_keeps_input_sections();
2684       is_new = true;
2685     }
2686
2687   if (pomb->add_input_section(object, shndx))
2688     {
2689       // Add new merge section to this output section and link merge
2690       // section properties to new merge section in map.
2691       if (is_new)
2692         {
2693           this->add_output_merge_section(pomb, is_string, entsize);
2694           this->lookup_maps_->add_merge_section(msp, pomb);
2695         }
2696
2697       // Add input section to new merge section and link input section to new
2698       // merge section in map.
2699       this->lookup_maps_->add_merge_input_section(object, shndx, pomb);
2700       return true;
2701     }
2702   else
2703     {
2704       // If add_input_section failed, delete new merge section to avoid
2705       // exporting empty merge sections in Output_section::get_input_section.
2706       if (is_new)
2707         delete pomb;
2708       return false;
2709     }
2710 }
2711
2712 // Build a relaxation map to speed up relaxation of existing input sections.
2713 // Look up to the first LIMIT elements in INPUT_SECTIONS.
2714
2715 void
2716 Output_section::build_relaxation_map(
2717   const Input_section_list& input_sections,
2718   size_t limit,
2719   Relaxation_map* relaxation_map) const
2720 {
2721   for (size_t i = 0; i < limit; ++i)
2722     {
2723       const Input_section& is(input_sections[i]);
2724       if (is.is_input_section() || is.is_relaxed_input_section())
2725         {
2726           Section_id sid(is.relobj(), is.shndx());
2727           (*relaxation_map)[sid] = i;
2728         }
2729     }
2730 }
2731
2732 // Convert regular input sections in INPUT_SECTIONS into relaxed input
2733 // sections in RELAXED_SECTIONS.  MAP is a prebuilt map from section id
2734 // indices of INPUT_SECTIONS.
2735
2736 void
2737 Output_section::convert_input_sections_in_list_to_relaxed_sections(
2738   const std::vector<Output_relaxed_input_section*>& relaxed_sections,
2739   const Relaxation_map& map,
2740   Input_section_list* input_sections)
2741 {
2742   for (size_t i = 0; i < relaxed_sections.size(); ++i)
2743     {
2744       Output_relaxed_input_section* poris = relaxed_sections[i];
2745       Section_id sid(poris->relobj(), poris->shndx());
2746       Relaxation_map::const_iterator p = map.find(sid);
2747       gold_assert(p != map.end());
2748       gold_assert((*input_sections)[p->second].is_input_section());
2749
2750       // Remember section order index of original input section
2751       // if it is set.  Copy it to the relaxed input section.
2752       unsigned int soi =
2753         (*input_sections)[p->second].section_order_index();
2754       (*input_sections)[p->second] = Input_section(poris);
2755       (*input_sections)[p->second].set_section_order_index(soi);
2756     }
2757 }
2758
2759 // Convert regular input sections into relaxed input sections. RELAXED_SECTIONS
2760 // is a vector of pointers to Output_relaxed_input_section or its derived
2761 // classes.  The relaxed sections must correspond to existing input sections.
2762
2763 void
2764 Output_section::convert_input_sections_to_relaxed_sections(
2765   const std::vector<Output_relaxed_input_section*>& relaxed_sections)
2766 {
2767   gold_assert(parameters->target().may_relax());
2768
2769   // We want to make sure that restore_states does not undo the effect of
2770   // this.  If there is no checkpoint active, just search the current
2771   // input section list and replace the sections there.  If there is
2772   // a checkpoint, also replace the sections there.
2773
2774   // By default, we look at the whole list.
2775   size_t limit = this->input_sections_.size();
2776
2777   if (this->checkpoint_ != NULL)
2778     {
2779       // Replace input sections with relaxed input section in the saved
2780       // copy of the input section list.
2781       if (this->checkpoint_->input_sections_saved())
2782         {
2783           Relaxation_map map;
2784           this->build_relaxation_map(
2785                     *(this->checkpoint_->input_sections()),
2786                     this->checkpoint_->input_sections()->size(),
2787                     &map);
2788           this->convert_input_sections_in_list_to_relaxed_sections(
2789                     relaxed_sections,
2790                     map,
2791                     this->checkpoint_->input_sections());
2792         }
2793       else
2794         {
2795           // We have not copied the input section list yet.  Instead, just
2796           // look at the portion that would be saved.
2797           limit = this->checkpoint_->input_sections_size();
2798         }
2799     }
2800
2801   // Convert input sections in input_section_list.
2802   Relaxation_map map;
2803   this->build_relaxation_map(this->input_sections_, limit, &map);
2804   this->convert_input_sections_in_list_to_relaxed_sections(
2805             relaxed_sections,
2806             map,
2807             &this->input_sections_);
2808
2809   // Update fast look-up map.
2810   if (this->lookup_maps_->is_valid())
2811     for (size_t i = 0; i < relaxed_sections.size(); ++i)
2812       {
2813         Output_relaxed_input_section* poris = relaxed_sections[i];
2814         this->lookup_maps_->add_relaxed_input_section(poris->relobj(),
2815                                                       poris->shndx(), poris);
2816       }
2817 }
2818
2819 // Update the output section flags based on input section flags.
2820
2821 void
2822 Output_section::update_flags_for_input_section(elfcpp::Elf_Xword flags)
2823 {
2824   // If we created the section with SHF_ALLOC clear, we set the
2825   // address.  If we are now setting the SHF_ALLOC flag, we need to
2826   // undo that.
2827   if ((this->flags_ & elfcpp::SHF_ALLOC) == 0
2828       && (flags & elfcpp::SHF_ALLOC) != 0)
2829     this->mark_address_invalid();
2830
2831   this->flags_ |= (flags
2832                    & (elfcpp::SHF_WRITE
2833                       | elfcpp::SHF_ALLOC
2834                       | elfcpp::SHF_EXECINSTR));
2835
2836   if ((flags & elfcpp::SHF_MERGE) == 0)
2837     this->flags_ &=~ elfcpp::SHF_MERGE;
2838   else
2839     {
2840       if (this->current_data_size_for_child() == 0)
2841         this->flags_ |= elfcpp::SHF_MERGE;
2842     }
2843
2844   if ((flags & elfcpp::SHF_STRINGS) == 0)
2845     this->flags_ &=~ elfcpp::SHF_STRINGS;
2846   else
2847     {
2848       if (this->current_data_size_for_child() == 0)
2849         this->flags_ |= elfcpp::SHF_STRINGS;
2850     }
2851 }
2852
2853 // Find the merge section into which an input section with index SHNDX in
2854 // OBJECT has been added.  Return NULL if none found.
2855
2856 Output_section_data*
2857 Output_section::find_merge_section(const Relobj* object,
2858                                    unsigned int shndx) const
2859 {
2860   if (!this->lookup_maps_->is_valid())
2861     this->build_lookup_maps();
2862   return this->lookup_maps_->find_merge_section(object, shndx);
2863 }
2864
2865 // Build the lookup maps for merge and relaxed sections.  This is needs
2866 // to be declared as a const methods so that it is callable with a const
2867 // Output_section pointer.  The method only updates states of the maps.
2868
2869 void
2870 Output_section::build_lookup_maps() const
2871 {
2872   this->lookup_maps_->clear();
2873   for (Input_section_list::const_iterator p = this->input_sections_.begin();
2874        p != this->input_sections_.end();
2875        ++p)
2876     {
2877       if (p->is_merge_section())
2878         {
2879           Output_merge_base* pomb = p->output_merge_base();
2880           Merge_section_properties msp(pomb->is_string(), pomb->entsize(),
2881                                        pomb->addralign());
2882           this->lookup_maps_->add_merge_section(msp, pomb);
2883           for (Output_merge_base::Input_sections::const_iterator is =
2884                  pomb->input_sections_begin();
2885                is != pomb->input_sections_end();
2886                ++is)
2887             {
2888               const Const_section_id& csid = *is;
2889             this->lookup_maps_->add_merge_input_section(csid.first,
2890                                                         csid.second, pomb);
2891             }
2892
2893         }
2894       else if (p->is_relaxed_input_section())
2895         {
2896           Output_relaxed_input_section* poris = p->relaxed_input_section();
2897           this->lookup_maps_->add_relaxed_input_section(poris->relobj(),
2898                                                         poris->shndx(), poris);
2899         }
2900     }
2901 }
2902
2903 // Find an relaxed input section corresponding to an input section
2904 // in OBJECT with index SHNDX.
2905
2906 const Output_relaxed_input_section*
2907 Output_section::find_relaxed_input_section(const Relobj* object,
2908                                            unsigned int shndx) const
2909 {
2910   if (!this->lookup_maps_->is_valid())
2911     this->build_lookup_maps();
2912   return this->lookup_maps_->find_relaxed_input_section(object, shndx);
2913 }
2914
2915 // Given an address OFFSET relative to the start of input section
2916 // SHNDX in OBJECT, return whether this address is being included in
2917 // the final link.  This should only be called if SHNDX in OBJECT has
2918 // a special mapping.
2919
2920 bool
2921 Output_section::is_input_address_mapped(const Relobj* object,
2922                                         unsigned int shndx,
2923                                         off_t offset) const
2924 {
2925   // Look at the Output_section_data_maps first.
2926   const Output_section_data* posd = this->find_merge_section(object, shndx);
2927   if (posd == NULL)
2928     posd = this->find_relaxed_input_section(object, shndx);
2929
2930   if (posd != NULL)
2931     {
2932       section_offset_type output_offset;
2933       bool found = posd->output_offset(object, shndx, offset, &output_offset);
2934       gold_assert(found);
2935       return output_offset != -1;
2936     }
2937
2938   // Fall back to the slow look-up.
2939   for (Input_section_list::const_iterator p = this->input_sections_.begin();
2940        p != this->input_sections_.end();
2941        ++p)
2942     {
2943       section_offset_type output_offset;
2944       if (p->output_offset(object, shndx, offset, &output_offset))
2945         return output_offset != -1;
2946     }
2947
2948   // By default we assume that the address is mapped.  This should
2949   // only be called after we have passed all sections to Layout.  At
2950   // that point we should know what we are discarding.
2951   return true;
2952 }
2953
2954 // Given an address OFFSET relative to the start of input section
2955 // SHNDX in object OBJECT, return the output offset relative to the
2956 // start of the input section in the output section.  This should only
2957 // be called if SHNDX in OBJECT has a special mapping.
2958
2959 section_offset_type
2960 Output_section::output_offset(const Relobj* object, unsigned int shndx,
2961                               section_offset_type offset) const
2962 {
2963   // This can only be called meaningfully when we know the data size
2964   // of this.
2965   gold_assert(this->is_data_size_valid());
2966
2967   // Look at the Output_section_data_maps first.
2968   const Output_section_data* posd = this->find_merge_section(object, shndx);
2969   if (posd == NULL)
2970     posd = this->find_relaxed_input_section(object, shndx);
2971   if (posd != NULL)
2972     {
2973       section_offset_type output_offset;
2974       bool found = posd->output_offset(object, shndx, offset, &output_offset);
2975       gold_assert(found);
2976       return output_offset;
2977     }
2978
2979   // Fall back to the slow look-up.
2980   for (Input_section_list::const_iterator p = this->input_sections_.begin();
2981        p != this->input_sections_.end();
2982        ++p)
2983     {
2984       section_offset_type output_offset;
2985       if (p->output_offset(object, shndx, offset, &output_offset))
2986         return output_offset;
2987     }
2988   gold_unreachable();
2989 }
2990
2991 // Return the output virtual address of OFFSET relative to the start
2992 // of input section SHNDX in object OBJECT.
2993
2994 uint64_t
2995 Output_section::output_address(const Relobj* object, unsigned int shndx,
2996                                off_t offset) const
2997 {
2998   uint64_t addr = this->address() + this->first_input_offset_;
2999
3000   // Look at the Output_section_data_maps first.
3001   const Output_section_data* posd = this->find_merge_section(object, shndx);
3002   if (posd == NULL)
3003     posd = this->find_relaxed_input_section(object, shndx);
3004   if (posd != NULL && posd->is_address_valid())
3005     {
3006       section_offset_type output_offset;
3007       bool found = posd->output_offset(object, shndx, offset, &output_offset);
3008       gold_assert(found);
3009       return posd->address() + output_offset;
3010     }
3011
3012   // Fall back to the slow look-up.
3013   for (Input_section_list::const_iterator p = this->input_sections_.begin();
3014        p != this->input_sections_.end();
3015        ++p)
3016     {
3017       addr = align_address(addr, p->addralign());
3018       section_offset_type output_offset;
3019       if (p->output_offset(object, shndx, offset, &output_offset))
3020         {
3021           if (output_offset == -1)
3022             return -1ULL;
3023           return addr + output_offset;
3024         }
3025       addr += p->data_size();
3026     }
3027
3028   // If we get here, it means that we don't know the mapping for this
3029   // input section.  This might happen in principle if
3030   // add_input_section were called before add_output_section_data.
3031   // But it should never actually happen.
3032
3033   gold_unreachable();
3034 }
3035
3036 // Find the output address of the start of the merged section for
3037 // input section SHNDX in object OBJECT.
3038
3039 bool
3040 Output_section::find_starting_output_address(const Relobj* object,
3041                                              unsigned int shndx,
3042                                              uint64_t* paddr) const
3043 {
3044   // FIXME: This becomes a bottle-neck if we have many relaxed sections.
3045   // Looking up the merge section map does not always work as we sometimes
3046   // find a merge section without its address set.
3047   uint64_t addr = this->address() + this->first_input_offset_;
3048   for (Input_section_list::const_iterator p = this->input_sections_.begin();
3049        p != this->input_sections_.end();
3050        ++p)
3051     {
3052       addr = align_address(addr, p->addralign());
3053
3054       // It would be nice if we could use the existing output_offset
3055       // method to get the output offset of input offset 0.
3056       // Unfortunately we don't know for sure that input offset 0 is
3057       // mapped at all.
3058       if (p->is_merge_section_for(object, shndx))
3059         {
3060           *paddr = addr;
3061           return true;
3062         }
3063
3064       addr += p->data_size();
3065     }
3066
3067   // We couldn't find a merge output section for this input section.
3068   return false;
3069 }
3070
3071 // Update the data size of an Output_section.
3072
3073 void
3074 Output_section::update_data_size()
3075 {
3076   if (this->input_sections_.empty())
3077       return;
3078
3079   if (this->must_sort_attached_input_sections()
3080       || this->input_section_order_specified())
3081     this->sort_attached_input_sections();
3082
3083   off_t off = this->first_input_offset_;
3084   for (Input_section_list::iterator p = this->input_sections_.begin();
3085        p != this->input_sections_.end();
3086        ++p)
3087     {
3088       off = align_address(off, p->addralign());
3089       off += p->current_data_size();
3090     }
3091
3092   this->set_current_data_size_for_child(off);
3093 }
3094
3095 // Set the data size of an Output_section.  This is where we handle
3096 // setting the addresses of any Output_section_data objects.
3097
3098 void
3099 Output_section::set_final_data_size()
3100 {
3101   off_t data_size;
3102
3103   if (this->input_sections_.empty())
3104     data_size = this->current_data_size_for_child();
3105   else
3106     {
3107       if (this->must_sort_attached_input_sections()
3108           || this->input_section_order_specified())
3109         this->sort_attached_input_sections();
3110
3111       uint64_t address = this->address();
3112       off_t startoff = this->offset();
3113       off_t off = startoff + this->first_input_offset_;
3114       for (Input_section_list::iterator p = this->input_sections_.begin();
3115            p != this->input_sections_.end();
3116            ++p)
3117         {
3118           off = align_address(off, p->addralign());
3119           p->set_address_and_file_offset(address + (off - startoff), off,
3120                                          startoff);
3121           off += p->data_size();
3122         }
3123       data_size = off - startoff;
3124     }
3125
3126   // For full incremental links, we want to allocate some patch space
3127   // in most sections for subsequent incremental updates.
3128   if (this->is_patch_space_allowed_ && parameters->incremental_full())
3129     {
3130       double pct = parameters->options().incremental_patch();
3131       size_t extra = static_cast<size_t>(data_size * pct);
3132       if (this->free_space_fill_ != NULL
3133           && this->free_space_fill_->minimum_hole_size() > extra)
3134         extra = this->free_space_fill_->minimum_hole_size();
3135       off_t new_size = align_address(data_size + extra, this->addralign());
3136       this->patch_space_ = new_size - data_size;
3137       gold_debug(DEBUG_INCREMENTAL,
3138                  "set_final_data_size: %08lx + %08lx: section %s",
3139                  static_cast<long>(data_size),
3140                  static_cast<long>(this->patch_space_),
3141                  this->name());
3142       data_size = new_size;
3143     }
3144
3145   this->set_data_size(data_size);
3146 }
3147
3148 // Reset the address and file offset.
3149
3150 void
3151 Output_section::do_reset_address_and_file_offset()
3152 {
3153   // An unallocated section has no address.  Forcing this means that
3154   // we don't need special treatment for symbols defined in debug
3155   // sections.  We do the same in the constructor.  This does not
3156   // apply to NOLOAD sections though.
3157   if (((this->flags_ & elfcpp::SHF_ALLOC) == 0) && !this->is_noload_)
3158      this->set_address(0);
3159
3160   for (Input_section_list::iterator p = this->input_sections_.begin();
3161        p != this->input_sections_.end();
3162        ++p)
3163     p->reset_address_and_file_offset();
3164
3165   // Remove any patch space that was added in set_final_data_size.
3166   if (this->patch_space_ > 0)
3167     {
3168       this->set_current_data_size_for_child(this->current_data_size_for_child()
3169                                             - this->patch_space_);
3170       this->patch_space_ = 0;
3171     }
3172 }
3173
3174 // Return true if address and file offset have the values after reset.
3175
3176 bool
3177 Output_section::do_address_and_file_offset_have_reset_values() const
3178 {
3179   if (this->is_offset_valid())
3180     return false;
3181
3182   // An unallocated section has address 0 after its construction or a reset.
3183   if ((this->flags_ & elfcpp::SHF_ALLOC) == 0)
3184     return this->is_address_valid() && this->address() == 0;
3185   else
3186     return !this->is_address_valid();
3187 }
3188
3189 // Set the TLS offset.  Called only for SHT_TLS sections.
3190
3191 void
3192 Output_section::do_set_tls_offset(uint64_t tls_base)
3193 {
3194   this->tls_offset_ = this->address() - tls_base;
3195 }
3196
3197 // In a few cases we need to sort the input sections attached to an
3198 // output section.  This is used to implement the type of constructor
3199 // priority ordering implemented by the GNU linker, in which the
3200 // priority becomes part of the section name and the sections are
3201 // sorted by name.  We only do this for an output section if we see an
3202 // attached input section matching ".ctors.*", ".dtors.*",
3203 // ".init_array.*" or ".fini_array.*".
3204
3205 class Output_section::Input_section_sort_entry
3206 {
3207  public:
3208   Input_section_sort_entry()
3209     : input_section_(), index_(-1U), section_name_()
3210   { }
3211
3212   Input_section_sort_entry(const Input_section& input_section,
3213                            unsigned int index,
3214                            bool must_sort_attached_input_sections,
3215                            const char* output_section_name)
3216     : input_section_(input_section), index_(index), section_name_()
3217   {
3218     if ((input_section.is_input_section()
3219          || input_section.is_relaxed_input_section())
3220         && must_sort_attached_input_sections)
3221       {
3222         // This is only called single-threaded from Layout::finalize,
3223         // so it is OK to lock.  Unfortunately we have no way to pass
3224         // in a Task token.
3225         const Task* dummy_task = reinterpret_cast<const Task*>(-1);
3226         Object* obj = (input_section.is_input_section()
3227                        ? input_section.relobj()
3228                        : input_section.relaxed_input_section()->relobj());
3229         Task_lock_obj<Object> tl(dummy_task, obj);
3230
3231         // This is a slow operation, which should be cached in
3232         // Layout::layout if this becomes a speed problem.
3233         this->section_name_ = obj->section_name(input_section.shndx());
3234       }
3235     else if (input_section.is_output_section_data()
3236              && must_sort_attached_input_sections)
3237       {
3238         // For linker-generated sections, use the output section name.
3239         this->section_name_.assign(output_section_name);
3240       }
3241   }
3242
3243   // Return the Input_section.
3244   const Input_section&
3245   input_section() const
3246   {
3247     gold_assert(this->index_ != -1U);
3248     return this->input_section_;
3249   }
3250
3251   // The index of this entry in the original list.  This is used to
3252   // make the sort stable.
3253   unsigned int
3254   index() const
3255   {
3256     gold_assert(this->index_ != -1U);
3257     return this->index_;
3258   }
3259
3260   // The section name.
3261   const std::string&
3262   section_name() const
3263   {
3264     return this->section_name_;
3265   }
3266
3267   // Return true if the section name has a priority.  This is assumed
3268   // to be true if it has a dot after the initial dot.
3269   bool
3270   has_priority() const
3271   {
3272     return this->section_name_.find('.', 1) != std::string::npos;
3273   }
3274
3275   // Return the priority.  Believe it or not, gcc encodes the priority
3276   // differently for .ctors/.dtors and .init_array/.fini_array
3277   // sections.
3278   unsigned int
3279   get_priority() const
3280   {
3281     bool is_ctors;
3282     if (is_prefix_of(".ctors.", this->section_name_.c_str())
3283         || is_prefix_of(".dtors.", this->section_name_.c_str()))
3284       is_ctors = true;
3285     else if (is_prefix_of(".init_array.", this->section_name_.c_str())
3286              || is_prefix_of(".fini_array.", this->section_name_.c_str()))
3287       is_ctors = false;
3288     else
3289       return 0;
3290     char* end;
3291     unsigned long prio = strtoul((this->section_name_.c_str()
3292                                   + (is_ctors ? 7 : 12)),
3293                                  &end, 10);
3294     if (*end != '\0')
3295       return 0;
3296     else if (is_ctors)
3297       return 65535 - prio;
3298     else
3299       return prio;
3300   }
3301
3302   // Return true if this an input file whose base name matches
3303   // FILE_NAME.  The base name must have an extension of ".o", and
3304   // must be exactly FILE_NAME.o or FILE_NAME, one character, ".o".
3305   // This is to match crtbegin.o as well as crtbeginS.o without
3306   // getting confused by other possibilities.  Overall matching the
3307   // file name this way is a dreadful hack, but the GNU linker does it
3308   // in order to better support gcc, and we need to be compatible.
3309   bool
3310   match_file_name(const char* file_name) const
3311   {
3312     if (this->input_section_.is_output_section_data())
3313       return false;
3314     return Layout::match_file_name(this->input_section_.relobj(), file_name);
3315   }
3316
3317   // Returns 1 if THIS should appear before S in section order, -1 if S
3318   // appears before THIS and 0 if they are not comparable.
3319   int
3320   compare_section_ordering(const Input_section_sort_entry& s) const
3321   {
3322     unsigned int this_secn_index = this->input_section_.section_order_index();
3323     unsigned int s_secn_index = s.input_section().section_order_index();
3324     if (this_secn_index > 0 && s_secn_index > 0)
3325       {
3326         if (this_secn_index < s_secn_index)
3327           return 1;
3328         else if (this_secn_index > s_secn_index)
3329           return -1;
3330       }
3331     return 0;
3332   }
3333
3334  private:
3335   // The Input_section we are sorting.
3336   Input_section input_section_;
3337   // The index of this Input_section in the original list.
3338   unsigned int index_;
3339   // The section name if there is one.
3340   std::string section_name_;
3341 };
3342
3343 // Return true if S1 should come before S2 in the output section.
3344
3345 bool
3346 Output_section::Input_section_sort_compare::operator()(
3347     const Output_section::Input_section_sort_entry& s1,
3348     const Output_section::Input_section_sort_entry& s2) const
3349 {
3350   // crtbegin.o must come first.
3351   bool s1_begin = s1.match_file_name("crtbegin");
3352   bool s2_begin = s2.match_file_name("crtbegin");
3353   if (s1_begin || s2_begin)
3354     {
3355       if (!s1_begin)
3356         return false;
3357       if (!s2_begin)
3358         return true;
3359       return s1.index() < s2.index();
3360     }
3361
3362   // crtend.o must come last.
3363   bool s1_end = s1.match_file_name("crtend");
3364   bool s2_end = s2.match_file_name("crtend");
3365   if (s1_end || s2_end)
3366     {
3367       if (!s1_end)
3368         return true;
3369       if (!s2_end)
3370         return false;
3371       return s1.index() < s2.index();
3372     }
3373
3374   // A section with a priority follows a section without a priority.
3375   bool s1_has_priority = s1.has_priority();
3376   bool s2_has_priority = s2.has_priority();
3377   if (s1_has_priority && !s2_has_priority)
3378     return false;
3379   if (!s1_has_priority && s2_has_priority)
3380     return true;
3381
3382   // Check if a section order exists for these sections through a section
3383   // ordering file.  If sequence_num is 0, an order does not exist.
3384   int sequence_num = s1.compare_section_ordering(s2);
3385   if (sequence_num != 0)
3386     return sequence_num == 1;
3387
3388   // Otherwise we sort by name.
3389   int compare = s1.section_name().compare(s2.section_name());
3390   if (compare != 0)
3391     return compare < 0;
3392
3393   // Otherwise we keep the input order.
3394   return s1.index() < s2.index();
3395 }
3396
3397 // Return true if S1 should come before S2 in an .init_array or .fini_array
3398 // output section.
3399
3400 bool
3401 Output_section::Input_section_sort_init_fini_compare::operator()(
3402     const Output_section::Input_section_sort_entry& s1,
3403     const Output_section::Input_section_sort_entry& s2) const
3404 {
3405   // A section without a priority follows a section with a priority.
3406   // This is the reverse of .ctors and .dtors sections.
3407   bool s1_has_priority = s1.has_priority();
3408   bool s2_has_priority = s2.has_priority();
3409   if (s1_has_priority && !s2_has_priority)
3410     return true;
3411   if (!s1_has_priority && s2_has_priority)
3412     return false;
3413
3414   // .ctors and .dtors sections without priority come after
3415   // .init_array and .fini_array sections without priority.
3416   if (!s1_has_priority
3417       && (s1.section_name() == ".ctors" || s1.section_name() == ".dtors")
3418       && s1.section_name() != s2.section_name())
3419     return false;
3420   if (!s2_has_priority
3421       && (s2.section_name() == ".ctors" || s2.section_name() == ".dtors")
3422       && s2.section_name() != s1.section_name())
3423     return true;
3424
3425   // Sort by priority if we can.
3426   if (s1_has_priority)
3427     {
3428       unsigned int s1_prio = s1.get_priority();
3429       unsigned int s2_prio = s2.get_priority();
3430       if (s1_prio < s2_prio)
3431         return true;
3432       else if (s1_prio > s2_prio)
3433         return false;
3434     }
3435
3436   // Check if a section order exists for these sections through a section
3437   // ordering file.  If sequence_num is 0, an order does not exist.
3438   int sequence_num = s1.compare_section_ordering(s2);
3439   if (sequence_num != 0)
3440     return sequence_num == 1;
3441
3442   // Otherwise we sort by name.
3443   int compare = s1.section_name().compare(s2.section_name());
3444   if (compare != 0)
3445     return compare < 0;
3446
3447   // Otherwise we keep the input order.
3448   return s1.index() < s2.index();
3449 }
3450
3451 // Return true if S1 should come before S2.  Sections that do not match
3452 // any pattern in the section ordering file are placed ahead of the sections
3453 // that match some pattern.
3454
3455 bool
3456 Output_section::Input_section_sort_section_order_index_compare::operator()(
3457     const Output_section::Input_section_sort_entry& s1,
3458     const Output_section::Input_section_sort_entry& s2) const
3459 {
3460   unsigned int s1_secn_index = s1.input_section().section_order_index();
3461   unsigned int s2_secn_index = s2.input_section().section_order_index();
3462
3463   // Keep input order if section ordering cannot determine order.
3464   if (s1_secn_index == s2_secn_index)
3465     return s1.index() < s2.index();
3466
3467   return s1_secn_index < s2_secn_index;
3468 }
3469
3470 // Return true if S1 should come before S2.  This is the sort comparison
3471 // function for .text to sort sections with prefixes
3472 // .text.{unlikely,exit,startup,hot} before other sections.
3473
3474 bool
3475 Output_section::Input_section_sort_section_prefix_special_ordering_compare
3476   ::operator()(
3477     const Output_section::Input_section_sort_entry& s1,
3478     const Output_section::Input_section_sort_entry& s2) const
3479 {
3480   // Some input section names have special ordering requirements.
3481   int o1 = Layout::special_ordering_of_input_section(s1.section_name().c_str());
3482   int o2 = Layout::special_ordering_of_input_section(s2.section_name().c_str());
3483   if (o1 != o2)
3484     {
3485       if (o1 < 0)
3486         return false;
3487       else if (o2 < 0)
3488         return true;
3489       else
3490         return o1 < o2;
3491     }
3492
3493   // Keep input order otherwise.
3494   return s1.index() < s2.index();
3495 }
3496
3497 // Return true if S1 should come before S2.  This is the sort comparison
3498 // function for sections to sort them by name.
3499
3500 bool
3501 Output_section::Input_section_sort_section_name_compare
3502   ::operator()(
3503     const Output_section::Input_section_sort_entry& s1,
3504     const Output_section::Input_section_sort_entry& s2) const
3505 {
3506   // We sort by name.
3507   int compare = s1.section_name().compare(s2.section_name());
3508   if (compare != 0)
3509     return compare < 0;
3510
3511   // Keep input order otherwise.
3512   return s1.index() < s2.index();
3513 }
3514
3515 // This updates the section order index of input sections according to the
3516 // the order specified in the mapping from Section id to order index.
3517
3518 void
3519 Output_section::update_section_layout(
3520   const Section_layout_order* order_map)
3521 {
3522   for (Input_section_list::iterator p = this->input_sections_.begin();
3523        p != this->input_sections_.end();
3524        ++p)
3525     {
3526       if (p->is_input_section()
3527           || p->is_relaxed_input_section())
3528         {
3529           Object* obj = (p->is_input_section()
3530                          ? p->relobj()
3531                          : p->relaxed_input_section()->relobj());
3532           unsigned int shndx = p->shndx();
3533           Section_layout_order::const_iterator it
3534             = order_map->find(Section_id(obj, shndx));
3535           if (it == order_map->end())
3536             continue;
3537           unsigned int section_order_index = it->second;
3538           if (section_order_index != 0)
3539             {
3540               p->set_section_order_index(section_order_index);
3541               this->set_input_section_order_specified();
3542             }
3543         }
3544     }
3545 }
3546
3547 // Sort the input sections attached to an output section.
3548
3549 void
3550 Output_section::sort_attached_input_sections()
3551 {
3552   if (this->attached_input_sections_are_sorted_)
3553     return;
3554
3555   if (this->checkpoint_ != NULL
3556       && !this->checkpoint_->input_sections_saved())
3557     this->checkpoint_->save_input_sections();
3558
3559   // The only thing we know about an input section is the object and
3560   // the section index.  We need the section name.  Recomputing this
3561   // is slow but this is an unusual case.  If this becomes a speed
3562   // problem we can cache the names as required in Layout::layout.
3563
3564   // We start by building a larger vector holding a copy of each
3565   // Input_section, plus its current index in the list and its name.
3566   std::vector<Input_section_sort_entry> sort_list;
3567
3568   unsigned int i = 0;
3569   for (Input_section_list::iterator p = this->input_sections_.begin();
3570        p != this->input_sections_.end();
3571        ++p, ++i)
3572       sort_list.push_back(Input_section_sort_entry(*p, i,
3573                             this->must_sort_attached_input_sections(),
3574                             this->name()));
3575
3576   // Sort the input sections.
3577   if (this->must_sort_attached_input_sections())
3578     {
3579       if (this->type() == elfcpp::SHT_PREINIT_ARRAY
3580           || this->type() == elfcpp::SHT_INIT_ARRAY
3581           || this->type() == elfcpp::SHT_FINI_ARRAY)
3582         std::sort(sort_list.begin(), sort_list.end(),
3583                   Input_section_sort_init_fini_compare());
3584       else if (strcmp(parameters->options().sort_section(), "name") == 0)
3585         std::sort(sort_list.begin(), sort_list.end(),
3586                   Input_section_sort_section_name_compare());
3587       else if (strcmp(this->name(), ".text") == 0)
3588         std::sort(sort_list.begin(), sort_list.end(),
3589                   Input_section_sort_section_prefix_special_ordering_compare());
3590       else
3591         std::sort(sort_list.begin(), sort_list.end(),
3592                   Input_section_sort_compare());
3593     }
3594   else
3595     {
3596       gold_assert(this->input_section_order_specified());
3597       std::sort(sort_list.begin(), sort_list.end(),
3598                 Input_section_sort_section_order_index_compare());
3599     }
3600
3601   // Copy the sorted input sections back to our list.
3602   this->input_sections_.clear();
3603   for (std::vector<Input_section_sort_entry>::iterator p = sort_list.begin();
3604        p != sort_list.end();
3605        ++p)
3606     this->input_sections_.push_back(p->input_section());
3607   sort_list.clear();
3608
3609   // Remember that we sorted the input sections, since we might get
3610   // called again.
3611   this->attached_input_sections_are_sorted_ = true;
3612 }
3613
3614 // Write the section header to *OSHDR.
3615
3616 template<int size, bool big_endian>
3617 void
3618 Output_section::write_header(const Layout* layout,
3619                              const Stringpool* secnamepool,
3620                              elfcpp::Shdr_write<size, big_endian>* oshdr) const
3621 {
3622   oshdr->put_sh_name(secnamepool->get_offset(this->name_));
3623   oshdr->put_sh_type(this->type_);
3624
3625   elfcpp::Elf_Xword flags = this->flags_;
3626   if (this->info_section_ != NULL && this->info_uses_section_index_)
3627     flags |= elfcpp::SHF_INFO_LINK;
3628   oshdr->put_sh_flags(flags);
3629
3630   oshdr->put_sh_addr(this->address());
3631   oshdr->put_sh_offset(this->offset());
3632   oshdr->put_sh_size(this->data_size());
3633   if (this->link_section_ != NULL)
3634     oshdr->put_sh_link(this->link_section_->out_shndx());
3635   else if (this->should_link_to_symtab_)
3636     oshdr->put_sh_link(layout->symtab_section_shndx());
3637   else if (this->should_link_to_dynsym_)
3638     oshdr->put_sh_link(layout->dynsym_section()->out_shndx());
3639   else
3640     oshdr->put_sh_link(this->link_);
3641
3642   elfcpp::Elf_Word info;
3643   if (this->info_section_ != NULL)
3644     {
3645       if (this->info_uses_section_index_)
3646         info = this->info_section_->out_shndx();
3647       else
3648         info = this->info_section_->symtab_index();
3649     }
3650   else if (this->info_symndx_ != NULL)
3651     info = this->info_symndx_->symtab_index();
3652   else
3653     info = this->info_;
3654   oshdr->put_sh_info(info);
3655
3656   oshdr->put_sh_addralign(this->addralign_);
3657   oshdr->put_sh_entsize(this->entsize_);
3658 }
3659
3660 // Write out the data.  For input sections the data is written out by
3661 // Object::relocate, but we have to handle Output_section_data objects
3662 // here.
3663
3664 void
3665 Output_section::do_write(Output_file* of)
3666 {
3667   gold_assert(!this->requires_postprocessing());
3668
3669   // If the target performs relaxation, we delay filler generation until now.
3670   gold_assert(!this->generate_code_fills_at_write_ || this->fills_.empty());
3671
3672   off_t output_section_file_offset = this->offset();
3673   for (Fill_list::iterator p = this->fills_.begin();
3674        p != this->fills_.end();
3675        ++p)
3676     {
3677       std::string fill_data(parameters->target().code_fill(p->length()));
3678       of->write(output_section_file_offset + p->section_offset(),
3679                 fill_data.data(), fill_data.size());
3680     }
3681
3682   off_t off = this->offset() + this->first_input_offset_;
3683   for (Input_section_list::iterator p = this->input_sections_.begin();
3684        p != this->input_sections_.end();
3685        ++p)
3686     {
3687       off_t aligned_off = align_address(off, p->addralign());
3688       if (this->generate_code_fills_at_write_ && (off != aligned_off))
3689         {
3690           size_t fill_len = aligned_off - off;
3691           std::string fill_data(parameters->target().code_fill(fill_len));
3692           of->write(off, fill_data.data(), fill_data.size());
3693         }
3694
3695       p->write(of);
3696       off = aligned_off + p->data_size();
3697     }
3698
3699   // For incremental links, fill in unused chunks in debug sections
3700   // with dummy compilation unit headers.
3701   if (this->free_space_fill_ != NULL)
3702     {
3703       for (Free_list::Const_iterator p = this->free_list_.begin();
3704            p != this->free_list_.end();
3705            ++p)
3706         {
3707           off_t off = p->start_;
3708           size_t len = p->end_ - off;
3709           this->free_space_fill_->write(of, this->offset() + off, len);
3710         }
3711       if (this->patch_space_ > 0)
3712         {
3713           off_t off = this->current_data_size_for_child() - this->patch_space_;
3714           this->free_space_fill_->write(of, this->offset() + off,
3715                                         this->patch_space_);
3716         }
3717     }
3718 }
3719
3720 // If a section requires postprocessing, create the buffer to use.
3721
3722 void
3723 Output_section::create_postprocessing_buffer()
3724 {
3725   gold_assert(this->requires_postprocessing());
3726
3727   if (this->postprocessing_buffer_ != NULL)
3728     return;
3729
3730   if (!this->input_sections_.empty())
3731     {
3732       off_t off = this->first_input_offset_;
3733       for (Input_section_list::iterator p = this->input_sections_.begin();
3734            p != this->input_sections_.end();
3735            ++p)
3736         {
3737           off = align_address(off, p->addralign());
3738           p->finalize_data_size();
3739           off += p->data_size();
3740         }
3741       this->set_current_data_size_for_child(off);
3742     }
3743
3744   off_t buffer_size = this->current_data_size_for_child();
3745   this->postprocessing_buffer_ = new unsigned char[buffer_size];
3746 }
3747
3748 // Write all the data of an Output_section into the postprocessing
3749 // buffer.  This is used for sections which require postprocessing,
3750 // such as compression.  Input sections are handled by
3751 // Object::Relocate.
3752
3753 void
3754 Output_section::write_to_postprocessing_buffer()
3755 {
3756   gold_assert(this->requires_postprocessing());
3757
3758   // If the target performs relaxation, we delay filler generation until now.
3759   gold_assert(!this->generate_code_fills_at_write_ || this->fills_.empty());
3760
3761   unsigned char* buffer = this->postprocessing_buffer();
3762   for (Fill_list::iterator p = this->fills_.begin();
3763        p != this->fills_.end();
3764        ++p)
3765     {
3766       std::string fill_data(parameters->target().code_fill(p->length()));
3767       memcpy(buffer + p->section_offset(), fill_data.data(),
3768              fill_data.size());
3769     }
3770
3771   off_t off = this->first_input_offset_;
3772   for (Input_section_list::iterator p = this->input_sections_.begin();
3773        p != this->input_sections_.end();
3774        ++p)
3775     {
3776       off_t aligned_off = align_address(off, p->addralign());
3777       if (this->generate_code_fills_at_write_ && (off != aligned_off))
3778         {
3779           size_t fill_len = aligned_off - off;
3780           std::string fill_data(parameters->target().code_fill(fill_len));
3781           memcpy(buffer + off, fill_data.data(), fill_data.size());
3782         }
3783
3784       p->write_to_buffer(buffer + aligned_off);
3785       off = aligned_off + p->data_size();
3786     }
3787 }
3788
3789 // Get the input sections for linker script processing.  We leave
3790 // behind the Output_section_data entries.  Note that this may be
3791 // slightly incorrect for merge sections.  We will leave them behind,
3792 // but it is possible that the script says that they should follow
3793 // some other input sections, as in:
3794 //    .rodata { *(.rodata) *(.rodata.cst*) }
3795 // For that matter, we don't handle this correctly:
3796 //    .rodata { foo.o(.rodata.cst*) *(.rodata.cst*) }
3797 // With luck this will never matter.
3798
3799 uint64_t
3800 Output_section::get_input_sections(
3801     uint64_t address,
3802     const std::string& fill,
3803     std::list<Input_section>* input_sections)
3804 {
3805   if (this->checkpoint_ != NULL
3806       && !this->checkpoint_->input_sections_saved())
3807     this->checkpoint_->save_input_sections();
3808
3809   // Invalidate fast look-up maps.
3810   this->lookup_maps_->invalidate();
3811
3812   uint64_t orig_address = address;
3813
3814   address = align_address(address, this->addralign());
3815
3816   Input_section_list remaining;
3817   for (Input_section_list::iterator p = this->input_sections_.begin();
3818        p != this->input_sections_.end();
3819        ++p)
3820     {
3821       if (p->is_input_section()
3822           || p->is_relaxed_input_section()
3823           || p->is_merge_section())
3824         input_sections->push_back(*p);
3825       else
3826         {
3827           uint64_t aligned_address = align_address(address, p->addralign());
3828           if (aligned_address != address && !fill.empty())
3829             {
3830               section_size_type length =
3831                 convert_to_section_size_type(aligned_address - address);
3832               std::string this_fill;
3833               this_fill.reserve(length);
3834               while (this_fill.length() + fill.length() <= length)
3835                 this_fill += fill;
3836               if (this_fill.length() < length)
3837                 this_fill.append(fill, 0, length - this_fill.length());
3838
3839               Output_section_data* posd = new Output_data_const(this_fill, 0);
3840               remaining.push_back(Input_section(posd));
3841             }
3842           address = aligned_address;
3843
3844           remaining.push_back(*p);
3845
3846           p->finalize_data_size();
3847           address += p->data_size();
3848         }
3849     }
3850
3851   this->input_sections_.swap(remaining);
3852   this->first_input_offset_ = 0;
3853
3854   uint64_t data_size = address - orig_address;
3855   this->set_current_data_size_for_child(data_size);
3856   return data_size;
3857 }
3858
3859 // Add a script input section.  SIS is an Output_section::Input_section,
3860 // which can be either a plain input section or a special input section like
3861 // a relaxed input section.  For a special input section, its size must be
3862 // finalized.
3863
3864 void
3865 Output_section::add_script_input_section(const Input_section& sis)
3866 {
3867   uint64_t data_size = sis.data_size();
3868   uint64_t addralign = sis.addralign();
3869   if (addralign > this->addralign_)
3870     this->addralign_ = addralign;
3871
3872   off_t offset_in_section = this->current_data_size_for_child();
3873   off_t aligned_offset_in_section = align_address(offset_in_section,
3874                                                   addralign);
3875
3876   this->set_current_data_size_for_child(aligned_offset_in_section
3877                                         + data_size);
3878
3879   this->input_sections_.push_back(sis);
3880
3881   // Update fast lookup maps if necessary.
3882   if (this->lookup_maps_->is_valid())
3883     {
3884       if (sis.is_merge_section())
3885         {
3886           Output_merge_base* pomb = sis.output_merge_base();
3887           Merge_section_properties msp(pomb->is_string(), pomb->entsize(),
3888                                        pomb->addralign());
3889           this->lookup_maps_->add_merge_section(msp, pomb);
3890           for (Output_merge_base::Input_sections::const_iterator p =
3891                  pomb->input_sections_begin();
3892                p != pomb->input_sections_end();
3893                ++p)
3894             this->lookup_maps_->add_merge_input_section(p->first, p->second,
3895                                                         pomb);
3896         }
3897       else if (sis.is_relaxed_input_section())
3898         {
3899           Output_relaxed_input_section* poris = sis.relaxed_input_section();
3900           this->lookup_maps_->add_relaxed_input_section(poris->relobj(),
3901                                                         poris->shndx(), poris);
3902         }
3903     }
3904 }
3905
3906 // Save states for relaxation.
3907
3908 void
3909 Output_section::save_states()
3910 {
3911   gold_assert(this->checkpoint_ == NULL);
3912   Checkpoint_output_section* checkpoint =
3913     new Checkpoint_output_section(this->addralign_, this->flags_,
3914                                   this->input_sections_,
3915                                   this->first_input_offset_,
3916                                   this->attached_input_sections_are_sorted_);
3917   this->checkpoint_ = checkpoint;
3918   gold_assert(this->fills_.empty());
3919 }
3920
3921 void
3922 Output_section::discard_states()
3923 {
3924   gold_assert(this->checkpoint_ != NULL);
3925   delete this->checkpoint_;
3926   this->checkpoint_ = NULL;
3927   gold_assert(this->fills_.empty());
3928
3929   // Simply invalidate the fast lookup maps since we do not keep
3930   // track of them.
3931   this->lookup_maps_->invalidate();
3932 }
3933
3934 void
3935 Output_section::restore_states()
3936 {
3937   gold_assert(this->checkpoint_ != NULL);
3938   Checkpoint_output_section* checkpoint = this->checkpoint_;
3939
3940   this->addralign_ = checkpoint->addralign();
3941   this->flags_ = checkpoint->flags();
3942   this->first_input_offset_ = checkpoint->first_input_offset();
3943
3944   if (!checkpoint->input_sections_saved())
3945     {
3946       // If we have not copied the input sections, just resize it.
3947       size_t old_size = checkpoint->input_sections_size();
3948       gold_assert(this->input_sections_.size() >= old_size);
3949       this->input_sections_.resize(old_size);
3950     }
3951   else
3952     {
3953       // We need to copy the whole list.  This is not efficient for
3954       // extremely large output with hundreads of thousands of input
3955       // objects.  We may need to re-think how we should pass sections
3956       // to scripts.
3957       this->input_sections_ = *checkpoint->input_sections();
3958     }
3959
3960   this->attached_input_sections_are_sorted_ =
3961     checkpoint->attached_input_sections_are_sorted();
3962
3963   // Simply invalidate the fast lookup maps since we do not keep
3964   // track of them.
3965   this->lookup_maps_->invalidate();
3966 }
3967
3968 // Update the section offsets of input sections in this.  This is required if
3969 // relaxation causes some input sections to change sizes.
3970
3971 void
3972 Output_section::adjust_section_offsets()
3973 {
3974   if (!this->section_offsets_need_adjustment_)
3975     return;
3976
3977   off_t off = 0;
3978   for (Input_section_list::iterator p = this->input_sections_.begin();
3979        p != this->input_sections_.end();
3980        ++p)
3981     {
3982       off = align_address(off, p->addralign());
3983       if (p->is_input_section())
3984         p->relobj()->set_section_offset(p->shndx(), off);
3985       off += p->data_size();
3986     }
3987
3988   this->section_offsets_need_adjustment_ = false;
3989 }
3990
3991 // Print to the map file.
3992
3993 void
3994 Output_section::do_print_to_mapfile(Mapfile* mapfile) const
3995 {
3996   mapfile->print_output_section(this);
3997
3998   for (Input_section_list::const_iterator p = this->input_sections_.begin();
3999        p != this->input_sections_.end();
4000        ++p)
4001     p->print_to_mapfile(mapfile);
4002 }
4003
4004 // Print stats for merge sections to stderr.
4005
4006 void
4007 Output_section::print_merge_stats()
4008 {
4009   Input_section_list::iterator p;
4010   for (p = this->input_sections_.begin();
4011        p != this->input_sections_.end();
4012        ++p)
4013     p->print_merge_stats(this->name_);
4014 }
4015
4016 // Set a fixed layout for the section.  Used for incremental update links.
4017
4018 void
4019 Output_section::set_fixed_layout(uint64_t sh_addr, off_t sh_offset,
4020                                  off_t sh_size, uint64_t sh_addralign)
4021 {
4022   this->addralign_ = sh_addralign;
4023   this->set_current_data_size(sh_size);
4024   if ((this->flags_ & elfcpp::SHF_ALLOC) != 0)
4025     this->set_address(sh_addr);
4026   this->set_file_offset(sh_offset);
4027   this->finalize_data_size();
4028   this->free_list_.init(sh_size, false);
4029   this->has_fixed_layout_ = true;
4030 }
4031
4032 // Reserve space within the fixed layout for the section.  Used for
4033 // incremental update links.
4034
4035 void
4036 Output_section::reserve(uint64_t sh_offset, uint64_t sh_size)
4037 {
4038   this->free_list_.remove(sh_offset, sh_offset + sh_size);
4039 }
4040
4041 // Allocate space from the free list for the section.  Used for
4042 // incremental update links.
4043
4044 off_t
4045 Output_section::allocate(off_t len, uint64_t addralign)
4046 {
4047   return this->free_list_.allocate(len, addralign, 0);
4048 }
4049
4050 // Output segment methods.
4051
4052 Output_segment::Output_segment(elfcpp::Elf_Word type, elfcpp::Elf_Word flags)
4053   : vaddr_(0),
4054     paddr_(0),
4055     memsz_(0),
4056     max_align_(0),
4057     min_p_align_(0),
4058     offset_(0),
4059     filesz_(0),
4060     type_(type),
4061     flags_(flags),
4062     is_max_align_known_(false),
4063     are_addresses_set_(false),
4064     is_large_data_segment_(false),
4065     is_unique_segment_(false)
4066 {
4067   // The ELF ABI specifies that a PT_TLS segment always has PF_R as
4068   // the flags.
4069   if (type == elfcpp::PT_TLS)
4070     this->flags_ = elfcpp::PF_R;
4071 }
4072
4073 // Add an Output_section to a PT_LOAD Output_segment.
4074
4075 void
4076 Output_segment::add_output_section_to_load(Layout* layout,
4077                                            Output_section* os,
4078                                            elfcpp::Elf_Word seg_flags)
4079 {
4080   gold_assert(this->type() == elfcpp::PT_LOAD);
4081   gold_assert((os->flags() & elfcpp::SHF_ALLOC) != 0);
4082   gold_assert(!this->is_max_align_known_);
4083   gold_assert(os->is_large_data_section() == this->is_large_data_segment());
4084
4085   this->update_flags_for_output_section(seg_flags);
4086
4087   // We don't want to change the ordering if we have a linker script
4088   // with a SECTIONS clause.
4089   Output_section_order order = os->order();
4090   if (layout->script_options()->saw_sections_clause())
4091     order = static_cast<Output_section_order>(0);
4092   else
4093     gold_assert(order != ORDER_INVALID);
4094
4095   this->output_lists_[order].push_back(os);
4096 }
4097
4098 // Add an Output_section to a non-PT_LOAD Output_segment.
4099
4100 void
4101 Output_segment::add_output_section_to_nonload(Output_section* os,
4102                                               elfcpp::Elf_Word seg_flags)
4103 {
4104   gold_assert(this->type() != elfcpp::PT_LOAD);
4105   gold_assert((os->flags() & elfcpp::SHF_ALLOC) != 0);
4106   gold_assert(!this->is_max_align_known_);
4107
4108   this->update_flags_for_output_section(seg_flags);
4109
4110   this->output_lists_[0].push_back(os);
4111 }
4112
4113 // Remove an Output_section from this segment.  It is an error if it
4114 // is not present.
4115
4116 void
4117 Output_segment::remove_output_section(Output_section* os)
4118 {
4119   for (int i = 0; i < static_cast<int>(ORDER_MAX); ++i)
4120     {
4121       Output_data_list* pdl = &this->output_lists_[i];
4122       for (Output_data_list::iterator p = pdl->begin(); p != pdl->end(); ++p)
4123         {
4124           if (*p == os)
4125             {
4126               pdl->erase(p);
4127               return;
4128             }
4129         }
4130     }
4131   gold_unreachable();
4132 }
4133
4134 // Add an Output_data (which need not be an Output_section) to the
4135 // start of a segment.
4136
4137 void
4138 Output_segment::add_initial_output_data(Output_data* od)
4139 {
4140   gold_assert(!this->is_max_align_known_);
4141   Output_data_list::iterator p = this->output_lists_[0].begin();
4142   this->output_lists_[0].insert(p, od);
4143 }
4144
4145 // Return true if this segment has any sections which hold actual
4146 // data, rather than being a BSS section.
4147
4148 bool
4149 Output_segment::has_any_data_sections() const
4150 {
4151   for (int i = 0; i < static_cast<int>(ORDER_MAX); ++i)
4152     {
4153       const Output_data_list* pdl = &this->output_lists_[i];
4154       for (Output_data_list::const_iterator p = pdl->begin();
4155            p != pdl->end();
4156            ++p)
4157         {
4158           if (!(*p)->is_section())
4159             return true;
4160           if ((*p)->output_section()->type() != elfcpp::SHT_NOBITS)
4161             return true;
4162         }
4163     }
4164   return false;
4165 }
4166
4167 // Return whether the first data section (not counting TLS sections)
4168 // is a relro section.
4169
4170 bool
4171 Output_segment::is_first_section_relro() const
4172 {
4173   for (int i = 0; i < static_cast<int>(ORDER_MAX); ++i)
4174     {
4175       if (i == static_cast<int>(ORDER_TLS_DATA)
4176           || i == static_cast<int>(ORDER_TLS_BSS))
4177         continue;
4178       const Output_data_list* pdl = &this->output_lists_[i];
4179       if (!pdl->empty())
4180         {
4181           Output_data* p = pdl->front();
4182           return p->is_section() && p->output_section()->is_relro();
4183         }
4184     }
4185   return false;
4186 }
4187
4188 // Return the maximum alignment of the Output_data in Output_segment.
4189
4190 uint64_t
4191 Output_segment::maximum_alignment()
4192 {
4193   if (!this->is_max_align_known_)
4194     {
4195       for (int i = 0; i < static_cast<int>(ORDER_MAX); ++i)
4196         {
4197           const Output_data_list* pdl = &this->output_lists_[i];
4198           uint64_t addralign = Output_segment::maximum_alignment_list(pdl);
4199           if (addralign > this->max_align_)
4200             this->max_align_ = addralign;
4201         }
4202       this->is_max_align_known_ = true;
4203     }
4204
4205   return this->max_align_;
4206 }
4207
4208 // Return the maximum alignment of a list of Output_data.
4209
4210 uint64_t
4211 Output_segment::maximum_alignment_list(const Output_data_list* pdl)
4212 {
4213   uint64_t ret = 0;
4214   for (Output_data_list::const_iterator p = pdl->begin();
4215        p != pdl->end();
4216        ++p)
4217     {
4218       uint64_t addralign = (*p)->addralign();
4219       if (addralign > ret)
4220         ret = addralign;
4221     }
4222   return ret;
4223 }
4224
4225 // Return whether this segment has any dynamic relocs.
4226
4227 bool
4228 Output_segment::has_dynamic_reloc() const
4229 {
4230   for (int i = 0; i < static_cast<int>(ORDER_MAX); ++i)
4231     if (this->has_dynamic_reloc_list(&this->output_lists_[i]))
4232       return true;
4233   return false;
4234 }
4235
4236 // Return whether this Output_data_list has any dynamic relocs.
4237
4238 bool
4239 Output_segment::has_dynamic_reloc_list(const Output_data_list* pdl) const
4240 {
4241   for (Output_data_list::const_iterator p = pdl->begin();
4242        p != pdl->end();
4243        ++p)
4244     if ((*p)->has_dynamic_reloc())
4245       return true;
4246   return false;
4247 }
4248
4249 // Set the section addresses for an Output_segment.  If RESET is true,
4250 // reset the addresses first.  ADDR is the address and *POFF is the
4251 // file offset.  Set the section indexes starting with *PSHNDX.
4252 // INCREASE_RELRO is the size of the portion of the first non-relro
4253 // section that should be included in the PT_GNU_RELRO segment.
4254 // If this segment has relro sections, and has been aligned for
4255 // that purpose, set *HAS_RELRO to TRUE.  Return the address of
4256 // the immediately following segment.  Update *HAS_RELRO, *POFF,
4257 // and *PSHNDX.
4258
4259 uint64_t
4260 Output_segment::set_section_addresses(const Target* target,
4261                                       Layout* layout, bool reset,
4262                                       uint64_t addr,
4263                                       unsigned int* increase_relro,
4264                                       bool* has_relro,
4265                                       off_t* poff,
4266                                       unsigned int* pshndx)
4267 {
4268   gold_assert(this->type_ == elfcpp::PT_LOAD);
4269
4270   uint64_t last_relro_pad = 0;
4271   off_t orig_off = *poff;
4272
4273   bool in_tls = false;