PR gold/14566
[external/binutils.git] / gold / output.cc
1 // output.cc -- manage the output file for gold
2
3 // Copyright 2006, 2007, 2008, 2009, 2010, 2011 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(const 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   parameters->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 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   : address_(address), local_sym_index_(0), type_(type),
861     is_relative_(false), is_symbolless_(false),
862     is_section_symbol_(false), use_plt_offset_(false), shndx_(INVALID_CODE)
863 {
864   // this->type_ is a bitfield; make sure TYPE fits.
865   gold_assert(this->type_ == type);
866   this->u1_.relobj = NULL;
867   this->u2_.od = od;
868 }
869
870 template<bool dynamic, int size, bool big_endian>
871 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc(
872     unsigned int type,
873     Sized_relobj<size, big_endian>* relobj,
874     unsigned int shndx,
875     Address address)
876   : address_(address), local_sym_index_(0), type_(type),
877     is_relative_(false), is_symbolless_(false),
878     is_section_symbol_(false), use_plt_offset_(false), shndx_(shndx)
879 {
880   gold_assert(shndx != INVALID_CODE);
881   // this->type_ is a bitfield; make sure TYPE fits.
882   gold_assert(this->type_ == type);
883   this->u1_.relobj = NULL;
884   this->u2_.relobj = relobj;
885 }
886
887 // A target specific relocation.
888
889 template<bool dynamic, int size, bool big_endian>
890 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc(
891     unsigned int type,
892     void* arg,
893     Output_data* od,
894     Address address)
895   : address_(address), local_sym_index_(TARGET_CODE), type_(type),
896     is_relative_(false), is_symbolless_(false),
897     is_section_symbol_(false), use_plt_offset_(false), shndx_(INVALID_CODE)
898 {
899   // this->type_ is a bitfield; make sure TYPE fits.
900   gold_assert(this->type_ == type);
901   this->u1_.arg = arg;
902   this->u2_.od = od;
903 }
904
905 template<bool dynamic, int size, bool big_endian>
906 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc(
907     unsigned int type,
908     void* arg,
909     Sized_relobj<size, big_endian>* relobj,
910     unsigned int shndx,
911     Address address)
912   : address_(address), local_sym_index_(TARGET_CODE), type_(type),
913     is_relative_(false), is_symbolless_(false),
914     is_section_symbol_(false), use_plt_offset_(false), shndx_(shndx)
915 {
916   gold_assert(shndx != INVALID_CODE);
917   // this->type_ is a bitfield; make sure TYPE fits.
918   gold_assert(this->type_ == type);
919   this->u1_.arg = arg;
920   this->u2_.relobj = relobj;
921 }
922
923 // Record that we need a dynamic symbol index for this relocation.
924
925 template<bool dynamic, int size, bool big_endian>
926 void
927 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::
928 set_needs_dynsym_index()
929 {
930   if (this->is_symbolless_)
931     return;
932   switch (this->local_sym_index_)
933     {
934     case INVALID_CODE:
935       gold_unreachable();
936
937     case GSYM_CODE:
938       this->u1_.gsym->set_needs_dynsym_entry();
939       break;
940
941     case SECTION_CODE:
942       this->u1_.os->set_needs_dynsym_index();
943       break;
944
945     case TARGET_CODE:
946       // The target must take care of this if necessary.
947       break;
948
949     case 0:
950       break;
951
952     default:
953       {
954         const unsigned int lsi = this->local_sym_index_;
955         Sized_relobj_file<size, big_endian>* relobj =
956             this->u1_.relobj->sized_relobj();
957         gold_assert(relobj != NULL);
958         if (!this->is_section_symbol_)
959           relobj->set_needs_output_dynsym_entry(lsi);
960         else
961           relobj->output_section(lsi)->set_needs_dynsym_index();
962       }
963       break;
964     }
965 }
966
967 // Get the symbol index of a relocation.
968
969 template<bool dynamic, int size, bool big_endian>
970 unsigned int
971 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::get_symbol_index()
972   const
973 {
974   unsigned int index;
975   if (this->is_symbolless_)
976     return 0;
977   switch (this->local_sym_index_)
978     {
979     case INVALID_CODE:
980       gold_unreachable();
981
982     case GSYM_CODE:
983       if (this->u1_.gsym == NULL)
984         index = 0;
985       else if (dynamic)
986         index = this->u1_.gsym->dynsym_index();
987       else
988         index = this->u1_.gsym->symtab_index();
989       break;
990
991     case SECTION_CODE:
992       if (dynamic)
993         index = this->u1_.os->dynsym_index();
994       else
995         index = this->u1_.os->symtab_index();
996       break;
997
998     case TARGET_CODE:
999       index = parameters->target().reloc_symbol_index(this->u1_.arg,
1000                                                       this->type_);
1001       break;
1002
1003     case 0:
1004       // Relocations without symbols use a symbol index of 0.
1005       index = 0;
1006       break;
1007
1008     default:
1009       {
1010         const unsigned int lsi = this->local_sym_index_;
1011         Sized_relobj_file<size, big_endian>* relobj =
1012             this->u1_.relobj->sized_relobj();
1013         gold_assert(relobj != NULL);
1014         if (!this->is_section_symbol_)
1015           {
1016             if (dynamic)
1017               index = relobj->dynsym_index(lsi);
1018             else
1019               index = relobj->symtab_index(lsi);
1020           }
1021         else
1022           {
1023             Output_section* os = relobj->output_section(lsi);
1024             gold_assert(os != NULL);
1025             if (dynamic)
1026               index = os->dynsym_index();
1027             else
1028               index = os->symtab_index();
1029           }
1030       }
1031       break;
1032     }
1033   gold_assert(index != -1U);
1034   return index;
1035 }
1036
1037 // For a local section symbol, get the address of the offset ADDEND
1038 // within the input section.
1039
1040 template<bool dynamic, int size, bool big_endian>
1041 typename elfcpp::Elf_types<size>::Elf_Addr
1042 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::
1043   local_section_offset(Addend addend) const
1044 {
1045   gold_assert(this->local_sym_index_ != GSYM_CODE
1046               && this->local_sym_index_ != SECTION_CODE
1047               && this->local_sym_index_ != TARGET_CODE
1048               && this->local_sym_index_ != INVALID_CODE
1049               && this->local_sym_index_ != 0
1050               && this->is_section_symbol_);
1051   const unsigned int lsi = this->local_sym_index_;
1052   Output_section* os = this->u1_.relobj->output_section(lsi);
1053   gold_assert(os != NULL);
1054   Address offset = this->u1_.relobj->get_output_section_offset(lsi);
1055   if (offset != invalid_address)
1056     return offset + addend;
1057   // This is a merge section.
1058   Sized_relobj_file<size, big_endian>* relobj =
1059       this->u1_.relobj->sized_relobj();
1060   gold_assert(relobj != NULL);
1061   offset = os->output_address(relobj, lsi, addend);
1062   gold_assert(offset != invalid_address);
1063   return offset;
1064 }
1065
1066 // Get the output address of a relocation.
1067
1068 template<bool dynamic, int size, bool big_endian>
1069 typename elfcpp::Elf_types<size>::Elf_Addr
1070 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::get_address() const
1071 {
1072   Address address = this->address_;
1073   if (this->shndx_ != INVALID_CODE)
1074     {
1075       Output_section* os = this->u2_.relobj->output_section(this->shndx_);
1076       gold_assert(os != NULL);
1077       Address off = this->u2_.relobj->get_output_section_offset(this->shndx_);
1078       if (off != invalid_address)
1079         address += os->address() + off;
1080       else
1081         {
1082           Sized_relobj_file<size, big_endian>* relobj =
1083               this->u2_.relobj->sized_relobj();
1084           gold_assert(relobj != NULL);
1085           address = os->output_address(relobj, this->shndx_, address);
1086           gold_assert(address != invalid_address);
1087         }
1088     }
1089   else if (this->u2_.od != NULL)
1090     address += this->u2_.od->address();
1091   return address;
1092 }
1093
1094 // Write out the offset and info fields of a Rel or Rela relocation
1095 // entry.
1096
1097 template<bool dynamic, int size, bool big_endian>
1098 template<typename Write_rel>
1099 void
1100 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::write_rel(
1101     Write_rel* wr) const
1102 {
1103   wr->put_r_offset(this->get_address());
1104   unsigned int sym_index = this->get_symbol_index();
1105   wr->put_r_info(elfcpp::elf_r_info<size>(sym_index, this->type_));
1106 }
1107
1108 // Write out a Rel relocation.
1109
1110 template<bool dynamic, int size, bool big_endian>
1111 void
1112 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::write(
1113     unsigned char* pov) const
1114 {
1115   elfcpp::Rel_write<size, big_endian> orel(pov);
1116   this->write_rel(&orel);
1117 }
1118
1119 // Get the value of the symbol referred to by a Rel relocation.
1120
1121 template<bool dynamic, int size, bool big_endian>
1122 typename elfcpp::Elf_types<size>::Elf_Addr
1123 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::symbol_value(
1124     Addend addend) const
1125 {
1126   if (this->local_sym_index_ == GSYM_CODE)
1127     {
1128       const Sized_symbol<size>* sym;
1129       sym = static_cast<const Sized_symbol<size>*>(this->u1_.gsym);
1130       if (this->use_plt_offset_ && sym->has_plt_offset())
1131         {
1132           uint64_t plt_address =
1133             parameters->target().plt_address_for_global(sym);
1134           return plt_address + sym->plt_offset();
1135         }
1136       else
1137         return sym->value() + addend;
1138     }
1139   if (this->local_sym_index_ == SECTION_CODE)
1140     {
1141       gold_assert(!this->use_plt_offset_);
1142       return this->u1_.os->address() + addend;
1143     }
1144   gold_assert(this->local_sym_index_ != TARGET_CODE
1145               && this->local_sym_index_ != INVALID_CODE
1146               && this->local_sym_index_ != 0
1147               && !this->is_section_symbol_);
1148   const unsigned int lsi = this->local_sym_index_;
1149   Sized_relobj_file<size, big_endian>* relobj =
1150       this->u1_.relobj->sized_relobj();
1151   gold_assert(relobj != NULL);
1152   if (this->use_plt_offset_)
1153     {
1154       uint64_t plt_address =
1155           parameters->target().plt_address_for_local(relobj, lsi);
1156       return plt_address + relobj->local_plt_offset(lsi);
1157     }
1158   const Symbol_value<size>* symval = relobj->local_symbol(lsi);
1159   return symval->value(relobj, addend);
1160 }
1161
1162 // Reloc comparison.  This function sorts the dynamic relocs for the
1163 // benefit of the dynamic linker.  First we sort all relative relocs
1164 // to the front.  Among relative relocs, we sort by output address.
1165 // Among non-relative relocs, we sort by symbol index, then by output
1166 // address.
1167
1168 template<bool dynamic, int size, bool big_endian>
1169 int
1170 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::
1171   compare(const Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>& r2)
1172     const
1173 {
1174   if (this->is_relative_)
1175     {
1176       if (!r2.is_relative_)
1177         return -1;
1178       // Otherwise sort by reloc address below.
1179     }
1180   else if (r2.is_relative_)
1181     return 1;
1182   else
1183     {
1184       unsigned int sym1 = this->get_symbol_index();
1185       unsigned int sym2 = r2.get_symbol_index();
1186       if (sym1 < sym2)
1187         return -1;
1188       else if (sym1 > sym2)
1189         return 1;
1190       // Otherwise sort by reloc address.
1191     }
1192
1193   section_offset_type addr1 = this->get_address();
1194   section_offset_type addr2 = r2.get_address();
1195   if (addr1 < addr2)
1196     return -1;
1197   else if (addr1 > addr2)
1198     return 1;
1199
1200   // Final tie breaker, in order to generate the same output on any
1201   // host: reloc type.
1202   unsigned int type1 = this->type_;
1203   unsigned int type2 = r2.type_;
1204   if (type1 < type2)
1205     return -1;
1206   else if (type1 > type2)
1207     return 1;
1208
1209   // These relocs appear to be exactly the same.
1210   return 0;
1211 }
1212
1213 // Write out a Rela relocation.
1214
1215 template<bool dynamic, int size, bool big_endian>
1216 void
1217 Output_reloc<elfcpp::SHT_RELA, dynamic, size, big_endian>::write(
1218     unsigned char* pov) const
1219 {
1220   elfcpp::Rela_write<size, big_endian> orel(pov);
1221   this->rel_.write_rel(&orel);
1222   Addend addend = this->addend_;
1223   if (this->rel_.is_target_specific())
1224     addend = parameters->target().reloc_addend(this->rel_.target_arg(),
1225                                                this->rel_.type(), addend);
1226   else if (this->rel_.is_symbolless())
1227     addend = this->rel_.symbol_value(addend);
1228   else if (this->rel_.is_local_section_symbol())
1229     addend = this->rel_.local_section_offset(addend);
1230   orel.put_r_addend(addend);
1231 }
1232
1233 // Output_data_reloc_base methods.
1234
1235 // Adjust the output section.
1236
1237 template<int sh_type, bool dynamic, int size, bool big_endian>
1238 void
1239 Output_data_reloc_base<sh_type, dynamic, size, big_endian>
1240     ::do_adjust_output_section(Output_section* os)
1241 {
1242   if (sh_type == elfcpp::SHT_REL)
1243     os->set_entsize(elfcpp::Elf_sizes<size>::rel_size);
1244   else if (sh_type == elfcpp::SHT_RELA)
1245     os->set_entsize(elfcpp::Elf_sizes<size>::rela_size);
1246   else
1247     gold_unreachable();
1248
1249   // A STT_GNU_IFUNC symbol may require a IRELATIVE reloc when doing a
1250   // static link.  The backends will generate a dynamic reloc section
1251   // to hold this.  In that case we don't want to link to the dynsym
1252   // section, because there isn't one.
1253   if (!dynamic)
1254     os->set_should_link_to_symtab();
1255   else if (parameters->doing_static_link())
1256     ;
1257   else
1258     os->set_should_link_to_dynsym();
1259 }
1260
1261 // Write out relocation data.
1262
1263 template<int sh_type, bool dynamic, int size, bool big_endian>
1264 void
1265 Output_data_reloc_base<sh_type, dynamic, size, big_endian>::do_write(
1266     Output_file* of)
1267 {
1268   const off_t off = this->offset();
1269   const off_t oview_size = this->data_size();
1270   unsigned char* const oview = of->get_output_view(off, oview_size);
1271
1272   if (this->sort_relocs())
1273     {
1274       gold_assert(dynamic);
1275       std::sort(this->relocs_.begin(), this->relocs_.end(),
1276                 Sort_relocs_comparison());
1277     }
1278
1279   unsigned char* pov = oview;
1280   for (typename Relocs::const_iterator p = this->relocs_.begin();
1281        p != this->relocs_.end();
1282        ++p)
1283     {
1284       p->write(pov);
1285       pov += reloc_size;
1286     }
1287
1288   gold_assert(pov - oview == oview_size);
1289
1290   of->write_output_view(off, oview_size, oview);
1291
1292   // We no longer need the relocation entries.
1293   this->relocs_.clear();
1294 }
1295
1296 // Class Output_relocatable_relocs.
1297
1298 template<int sh_type, int size, bool big_endian>
1299 void
1300 Output_relocatable_relocs<sh_type, size, big_endian>::set_final_data_size()
1301 {
1302   this->set_data_size(this->rr_->output_reloc_count()
1303                       * Reloc_types<sh_type, size, big_endian>::reloc_size);
1304 }
1305
1306 // class Output_data_group.
1307
1308 template<int size, bool big_endian>
1309 Output_data_group<size, big_endian>::Output_data_group(
1310     Sized_relobj_file<size, big_endian>* relobj,
1311     section_size_type entry_count,
1312     elfcpp::Elf_Word flags,
1313     std::vector<unsigned int>* input_shndxes)
1314   : Output_section_data(entry_count * 4, 4, false),
1315     relobj_(relobj),
1316     flags_(flags)
1317 {
1318   this->input_shndxes_.swap(*input_shndxes);
1319 }
1320
1321 // Write out the section group, which means translating the section
1322 // indexes to apply to the output file.
1323
1324 template<int size, bool big_endian>
1325 void
1326 Output_data_group<size, big_endian>::do_write(Output_file* of)
1327 {
1328   const off_t off = this->offset();
1329   const section_size_type oview_size =
1330     convert_to_section_size_type(this->data_size());
1331   unsigned char* const oview = of->get_output_view(off, oview_size);
1332
1333   elfcpp::Elf_Word* contents = reinterpret_cast<elfcpp::Elf_Word*>(oview);
1334   elfcpp::Swap<32, big_endian>::writeval(contents, this->flags_);
1335   ++contents;
1336
1337   for (std::vector<unsigned int>::const_iterator p =
1338          this->input_shndxes_.begin();
1339        p != this->input_shndxes_.end();
1340        ++p, ++contents)
1341     {
1342       Output_section* os = this->relobj_->output_section(*p);
1343
1344       unsigned int output_shndx;
1345       if (os != NULL)
1346         output_shndx = os->out_shndx();
1347       else
1348         {
1349           this->relobj_->error(_("section group retained but "
1350                                  "group element discarded"));
1351           output_shndx = 0;
1352         }
1353
1354       elfcpp::Swap<32, big_endian>::writeval(contents, output_shndx);
1355     }
1356
1357   size_t wrote = reinterpret_cast<unsigned char*>(contents) - oview;
1358   gold_assert(wrote == oview_size);
1359
1360   of->write_output_view(off, oview_size, oview);
1361
1362   // We no longer need this information.
1363   this->input_shndxes_.clear();
1364 }
1365
1366 // Output_data_got::Got_entry methods.
1367
1368 // Write out the entry.
1369
1370 template<int size, bool big_endian>
1371 void
1372 Output_data_got<size, big_endian>::Got_entry::write(
1373     unsigned int got_indx,
1374     unsigned char* pov) const
1375 {
1376   Valtype val = 0;
1377
1378   switch (this->local_sym_index_)
1379     {
1380     case GSYM_CODE:
1381       {
1382         // If the symbol is resolved locally, we need to write out the
1383         // link-time value, which will be relocated dynamically by a
1384         // RELATIVE relocation.
1385         Symbol* gsym = this->u_.gsym;
1386         if (this->use_plt_or_tls_offset_ && gsym->has_plt_offset())
1387           val = (parameters->target().plt_address_for_global(gsym)
1388                  + gsym->plt_offset());
1389         else
1390           {
1391             Sized_symbol<size>* sgsym;
1392             // This cast is a bit ugly.  We don't want to put a
1393             // virtual method in Symbol, because we want Symbol to be
1394             // as small as possible.
1395             sgsym = static_cast<Sized_symbol<size>*>(gsym);
1396             val = sgsym->value();
1397             if (this->use_plt_or_tls_offset_ && gsym->type() == elfcpp::STT_TLS)
1398               val += parameters->target().tls_offset_for_global(gsym,
1399                                                                 got_indx);
1400           }
1401       }
1402       break;
1403
1404     case CONSTANT_CODE:
1405       val = this->u_.constant;
1406       break;
1407
1408     case RESERVED_CODE:
1409       // If we're doing an incremental update, don't touch this GOT entry.
1410       if (parameters->incremental_update())
1411         return;
1412       val = this->u_.constant;
1413       break;
1414
1415     default:
1416       {
1417         const Sized_relobj_file<size, big_endian>* object
1418           = static_cast<Sized_relobj_file<size, big_endian>*>(this->u_.object);
1419         const unsigned int lsi = this->local_sym_index_;
1420         bool is_tls = object->local_symbol(lsi)->is_tls_symbol();
1421         if (this->use_plt_or_tls_offset_ && !is_tls)
1422           {
1423             uint64_t plt_address =
1424               parameters->target().plt_address_for_local(object, lsi);
1425             val = plt_address + object->local_plt_offset(lsi);
1426           }
1427         else
1428           {
1429             uint64_t lval = object->local_symbol_value(lsi, 0);
1430             val = convert_types<Valtype, uint64_t>(lval);
1431             if (this->use_plt_or_tls_offset_ && is_tls)
1432               val += parameters->target().tls_offset_for_local(object, lsi,
1433                                                                got_indx);
1434           }
1435       }
1436       break;
1437     }
1438
1439   elfcpp::Swap<size, big_endian>::writeval(pov, val);
1440 }
1441
1442 // Output_data_got methods.
1443
1444 // Add an entry for a global symbol to the GOT.  This returns true if
1445 // this is a new GOT entry, false if the symbol already had a GOT
1446 // entry.
1447
1448 template<int size, bool big_endian>
1449 bool
1450 Output_data_got<size, big_endian>::add_global(
1451     Symbol* gsym,
1452     unsigned int got_type)
1453 {
1454   if (gsym->has_got_offset(got_type))
1455     return false;
1456
1457   unsigned int got_offset = this->add_got_entry(Got_entry(gsym, false));
1458   gsym->set_got_offset(got_type, got_offset);
1459   return true;
1460 }
1461
1462 // Like add_global, but use the PLT offset.
1463
1464 template<int size, bool big_endian>
1465 bool
1466 Output_data_got<size, big_endian>::add_global_plt(Symbol* gsym,
1467                                                   unsigned int got_type)
1468 {
1469   if (gsym->has_got_offset(got_type))
1470     return false;
1471
1472   unsigned int got_offset = this->add_got_entry(Got_entry(gsym, true));
1473   gsym->set_got_offset(got_type, got_offset);
1474   return true;
1475 }
1476
1477 // Add an entry for a global symbol to the GOT, and add a dynamic
1478 // relocation of type R_TYPE for the GOT entry.
1479
1480 template<int size, bool big_endian>
1481 void
1482 Output_data_got<size, big_endian>::add_global_with_rel(
1483     Symbol* gsym,
1484     unsigned int got_type,
1485     Output_data_reloc_generic* rel_dyn,
1486     unsigned int r_type)
1487 {
1488   if (gsym->has_got_offset(got_type))
1489     return;
1490
1491   unsigned int got_offset = this->add_got_entry(Got_entry());
1492   gsym->set_got_offset(got_type, got_offset);
1493   rel_dyn->add_global_generic(gsym, r_type, this, got_offset, 0);
1494 }
1495
1496 // Add a pair of entries for a global symbol to the GOT, and add
1497 // dynamic relocations of type R_TYPE_1 and R_TYPE_2, respectively.
1498 // If R_TYPE_2 == 0, add the second entry with no relocation.
1499 template<int size, bool big_endian>
1500 void
1501 Output_data_got<size, big_endian>::add_global_pair_with_rel(
1502     Symbol* gsym,
1503     unsigned int got_type,
1504     Output_data_reloc_generic* rel_dyn,
1505     unsigned int r_type_1,
1506     unsigned int r_type_2)
1507 {
1508   if (gsym->has_got_offset(got_type))
1509     return;
1510
1511   unsigned int got_offset = this->add_got_entry_pair(Got_entry(), Got_entry());
1512   gsym->set_got_offset(got_type, got_offset);
1513   rel_dyn->add_global_generic(gsym, r_type_1, this, got_offset, 0);
1514
1515   if (r_type_2 != 0)
1516     rel_dyn->add_global_generic(gsym, r_type_2, this,
1517                                 got_offset + size / 8, 0);
1518 }
1519
1520 // Add an entry for a local symbol to the GOT.  This returns true if
1521 // this is a new GOT entry, false if the symbol already has a GOT
1522 // entry.
1523
1524 template<int size, bool big_endian>
1525 bool
1526 Output_data_got<size, big_endian>::add_local(
1527     Relobj* object,
1528     unsigned int symndx,
1529     unsigned int got_type)
1530 {
1531   if (object->local_has_got_offset(symndx, got_type))
1532     return false;
1533
1534   unsigned int got_offset = this->add_got_entry(Got_entry(object, symndx,
1535                                                           false));
1536   object->set_local_got_offset(symndx, got_type, got_offset);
1537   return true;
1538 }
1539
1540 // Like add_local, but use the PLT offset.
1541
1542 template<int size, bool big_endian>
1543 bool
1544 Output_data_got<size, big_endian>::add_local_plt(
1545     Relobj* object,
1546     unsigned int symndx,
1547     unsigned int got_type)
1548 {
1549   if (object->local_has_got_offset(symndx, got_type))
1550     return false;
1551
1552   unsigned int got_offset = this->add_got_entry(Got_entry(object, symndx,
1553                                                           true));
1554   object->set_local_got_offset(symndx, got_type, got_offset);
1555   return true;
1556 }
1557
1558 // Add an entry for a local symbol to the GOT, and add a dynamic
1559 // relocation of type R_TYPE for the GOT entry.
1560
1561 template<int size, bool big_endian>
1562 void
1563 Output_data_got<size, big_endian>::add_local_with_rel(
1564     Relobj* object,
1565     unsigned int symndx,
1566     unsigned int got_type,
1567     Output_data_reloc_generic* rel_dyn,
1568     unsigned int r_type)
1569 {
1570   if (object->local_has_got_offset(symndx, got_type))
1571     return;
1572
1573   unsigned int got_offset = this->add_got_entry(Got_entry());
1574   object->set_local_got_offset(symndx, got_type, got_offset);
1575   rel_dyn->add_local_generic(object, symndx, r_type, this, got_offset, 0);
1576 }
1577
1578 // Add a pair of entries for a local symbol to the GOT, and add
1579 // a dynamic relocation of type R_TYPE using the section symbol of
1580 // the output section to which input section SHNDX maps, on the first.
1581 // The first got entry will have a value of zero, the second the
1582 // value of the local symbol.
1583 template<int size, bool big_endian>
1584 void
1585 Output_data_got<size, big_endian>::add_local_pair_with_rel(
1586     Relobj* object,
1587     unsigned int symndx,
1588     unsigned int shndx,
1589     unsigned int got_type,
1590     Output_data_reloc_generic* rel_dyn,
1591     unsigned int r_type)
1592 {
1593   if (object->local_has_got_offset(symndx, got_type))
1594     return;
1595
1596   unsigned int got_offset =
1597       this->add_got_entry_pair(Got_entry(),
1598                                Got_entry(object, symndx, false));
1599   object->set_local_got_offset(symndx, got_type, got_offset);
1600   Output_section* os = object->output_section(shndx);
1601   rel_dyn->add_output_section_generic(os, r_type, this, got_offset, 0);
1602 }
1603
1604 // Add a pair of entries for a local symbol to the GOT, and add
1605 // a dynamic relocation of type R_TYPE using STN_UNDEF on the first.
1606 // The first got entry will have a value of zero, the second the
1607 // value of the local symbol offset by Target::tls_offset_for_local.
1608 template<int size, bool big_endian>
1609 void
1610 Output_data_got<size, big_endian>::add_local_tls_pair(
1611     Relobj* object,
1612     unsigned int symndx,
1613     unsigned int got_type,
1614     Output_data_reloc_generic* rel_dyn,
1615     unsigned int r_type)
1616 {
1617   if (object->local_has_got_offset(symndx, got_type))
1618     return;
1619
1620   unsigned int got_offset
1621     = this->add_got_entry_pair(Got_entry(),
1622                                Got_entry(object, symndx, true));
1623   object->set_local_got_offset(symndx, got_type, got_offset);
1624   rel_dyn->add_local_generic(object, 0, r_type, this, got_offset, 0);
1625 }
1626
1627 // Reserve a slot in the GOT for a local symbol or the second slot of a pair.
1628
1629 template<int size, bool big_endian>
1630 void
1631 Output_data_got<size, big_endian>::reserve_local(
1632     unsigned int i,
1633     Relobj* object,
1634     unsigned int sym_index,
1635     unsigned int got_type)
1636 {
1637   this->do_reserve_slot(i);
1638   object->set_local_got_offset(sym_index, got_type, this->got_offset(i));
1639 }
1640
1641 // Reserve a slot in the GOT for a global symbol.
1642
1643 template<int size, bool big_endian>
1644 void
1645 Output_data_got<size, big_endian>::reserve_global(
1646     unsigned int i,
1647     Symbol* gsym,
1648     unsigned int got_type)
1649 {
1650   this->do_reserve_slot(i);
1651   gsym->set_got_offset(got_type, this->got_offset(i));
1652 }
1653
1654 // Write out the GOT.
1655
1656 template<int size, bool big_endian>
1657 void
1658 Output_data_got<size, big_endian>::do_write(Output_file* of)
1659 {
1660   const int add = size / 8;
1661
1662   const off_t off = this->offset();
1663   const off_t oview_size = this->data_size();
1664   unsigned char* const oview = of->get_output_view(off, oview_size);
1665
1666   unsigned char* pov = oview;
1667   for (unsigned int i = 0; i < this->entries_.size(); ++i)
1668     {
1669       this->entries_[i].write(i, pov);
1670       pov += add;
1671     }
1672
1673   gold_assert(pov - oview == oview_size);
1674
1675   of->write_output_view(off, oview_size, oview);
1676
1677   // We no longer need the GOT entries.
1678   this->entries_.clear();
1679 }
1680
1681 // Create a new GOT entry and return its offset.
1682
1683 template<int size, bool big_endian>
1684 unsigned int
1685 Output_data_got<size, big_endian>::add_got_entry(Got_entry got_entry)
1686 {
1687   if (!this->is_data_size_valid())
1688     {
1689       this->entries_.push_back(got_entry);
1690       this->set_got_size();
1691       return this->last_got_offset();
1692     }
1693   else
1694     {
1695       // For an incremental update, find an available slot.
1696       off_t got_offset = this->free_list_.allocate(size / 8, size / 8, 0);
1697       if (got_offset == -1)
1698         gold_fallback(_("out of patch space (GOT);"
1699                         " relink with --incremental-full"));
1700       unsigned int got_index = got_offset / (size / 8);
1701       gold_assert(got_index < this->entries_.size());
1702       this->entries_[got_index] = got_entry;
1703       return static_cast<unsigned int>(got_offset);
1704     }
1705 }
1706
1707 // Create a pair of new GOT entries and return the offset of the first.
1708
1709 template<int size, bool big_endian>
1710 unsigned int
1711 Output_data_got<size, big_endian>::add_got_entry_pair(Got_entry got_entry_1,
1712                                                       Got_entry got_entry_2)
1713 {
1714   if (!this->is_data_size_valid())
1715     {
1716       unsigned int got_offset;
1717       this->entries_.push_back(got_entry_1);
1718       got_offset = this->last_got_offset();
1719       this->entries_.push_back(got_entry_2);
1720       this->set_got_size();
1721       return got_offset;
1722     }
1723   else
1724     {
1725       // For an incremental update, find an available pair of slots.
1726       off_t got_offset = this->free_list_.allocate(2 * size / 8, size / 8, 0);
1727       if (got_offset == -1)
1728         gold_fallback(_("out of patch space (GOT);"
1729                         " relink with --incremental-full"));
1730       unsigned int got_index = got_offset / (size / 8);
1731       gold_assert(got_index < this->entries_.size());
1732       this->entries_[got_index] = got_entry_1;
1733       this->entries_[got_index + 1] = got_entry_2;
1734       return static_cast<unsigned int>(got_offset);
1735     }
1736 }
1737
1738 // Replace GOT entry I with a new value.
1739
1740 template<int size, bool big_endian>
1741 void
1742 Output_data_got<size, big_endian>::replace_got_entry(
1743     unsigned int i,
1744     Got_entry got_entry)
1745 {
1746   gold_assert(i < this->entries_.size());
1747   this->entries_[i] = got_entry;
1748 }
1749
1750 // Output_data_dynamic::Dynamic_entry methods.
1751
1752 // Write out the entry.
1753
1754 template<int size, bool big_endian>
1755 void
1756 Output_data_dynamic::Dynamic_entry::write(
1757     unsigned char* pov,
1758     const Stringpool* pool) const
1759 {
1760   typename elfcpp::Elf_types<size>::Elf_WXword val;
1761   switch (this->offset_)
1762     {
1763     case DYNAMIC_NUMBER:
1764       val = this->u_.val;
1765       break;
1766
1767     case DYNAMIC_SECTION_SIZE:
1768       val = this->u_.od->data_size();
1769       if (this->od2 != NULL)
1770         val += this->od2->data_size();
1771       break;
1772
1773     case DYNAMIC_SYMBOL:
1774       {
1775         const Sized_symbol<size>* s =
1776           static_cast<const Sized_symbol<size>*>(this->u_.sym);
1777         val = s->value();
1778       }
1779       break;
1780
1781     case DYNAMIC_STRING:
1782       val = pool->get_offset(this->u_.str);
1783       break;
1784
1785     default:
1786       val = this->u_.od->address() + this->offset_;
1787       break;
1788     }
1789
1790   elfcpp::Dyn_write<size, big_endian> dw(pov);
1791   dw.put_d_tag(this->tag_);
1792   dw.put_d_val(val);
1793 }
1794
1795 // Output_data_dynamic methods.
1796
1797 // Adjust the output section to set the entry size.
1798
1799 void
1800 Output_data_dynamic::do_adjust_output_section(Output_section* os)
1801 {
1802   if (parameters->target().get_size() == 32)
1803     os->set_entsize(elfcpp::Elf_sizes<32>::dyn_size);
1804   else if (parameters->target().get_size() == 64)
1805     os->set_entsize(elfcpp::Elf_sizes<64>::dyn_size);
1806   else
1807     gold_unreachable();
1808 }
1809
1810 // Set the final data size.
1811
1812 void
1813 Output_data_dynamic::set_final_data_size()
1814 {
1815   // Add the terminating entry if it hasn't been added.
1816   // Because of relaxation, we can run this multiple times.
1817   if (this->entries_.empty() || this->entries_.back().tag() != elfcpp::DT_NULL)
1818     {
1819       int extra = parameters->options().spare_dynamic_tags();
1820       for (int i = 0; i < extra; ++i)
1821         this->add_constant(elfcpp::DT_NULL, 0);
1822       this->add_constant(elfcpp::DT_NULL, 0);
1823     }
1824
1825   int dyn_size;
1826   if (parameters->target().get_size() == 32)
1827     dyn_size = elfcpp::Elf_sizes<32>::dyn_size;
1828   else if (parameters->target().get_size() == 64)
1829     dyn_size = elfcpp::Elf_sizes<64>::dyn_size;
1830   else
1831     gold_unreachable();
1832   this->set_data_size(this->entries_.size() * dyn_size);
1833 }
1834
1835 // Write out the dynamic entries.
1836
1837 void
1838 Output_data_dynamic::do_write(Output_file* of)
1839 {
1840   switch (parameters->size_and_endianness())
1841     {
1842 #ifdef HAVE_TARGET_32_LITTLE
1843     case Parameters::TARGET_32_LITTLE:
1844       this->sized_write<32, false>(of);
1845       break;
1846 #endif
1847 #ifdef HAVE_TARGET_32_BIG
1848     case Parameters::TARGET_32_BIG:
1849       this->sized_write<32, true>(of);
1850       break;
1851 #endif
1852 #ifdef HAVE_TARGET_64_LITTLE
1853     case Parameters::TARGET_64_LITTLE:
1854       this->sized_write<64, false>(of);
1855       break;
1856 #endif
1857 #ifdef HAVE_TARGET_64_BIG
1858     case Parameters::TARGET_64_BIG:
1859       this->sized_write<64, true>(of);
1860       break;
1861 #endif
1862     default:
1863       gold_unreachable();
1864     }
1865 }
1866
1867 template<int size, bool big_endian>
1868 void
1869 Output_data_dynamic::sized_write(Output_file* of)
1870 {
1871   const int dyn_size = elfcpp::Elf_sizes<size>::dyn_size;
1872
1873   const off_t offset = this->offset();
1874   const off_t oview_size = this->data_size();
1875   unsigned char* const oview = of->get_output_view(offset, oview_size);
1876
1877   unsigned char* pov = oview;
1878   for (typename Dynamic_entries::const_iterator p = this->entries_.begin();
1879        p != this->entries_.end();
1880        ++p)
1881     {
1882       p->write<size, big_endian>(pov, this->pool_);
1883       pov += dyn_size;
1884     }
1885
1886   gold_assert(pov - oview == oview_size);
1887
1888   of->write_output_view(offset, oview_size, oview);
1889
1890   // We no longer need the dynamic entries.
1891   this->entries_.clear();
1892 }
1893
1894 // Class Output_symtab_xindex.
1895
1896 void
1897 Output_symtab_xindex::do_write(Output_file* of)
1898 {
1899   const off_t offset = this->offset();
1900   const off_t oview_size = this->data_size();
1901   unsigned char* const oview = of->get_output_view(offset, oview_size);
1902
1903   memset(oview, 0, oview_size);
1904
1905   if (parameters->target().is_big_endian())
1906     this->endian_do_write<true>(oview);
1907   else
1908     this->endian_do_write<false>(oview);
1909
1910   of->write_output_view(offset, oview_size, oview);
1911
1912   // We no longer need the data.
1913   this->entries_.clear();
1914 }
1915
1916 template<bool big_endian>
1917 void
1918 Output_symtab_xindex::endian_do_write(unsigned char* const oview)
1919 {
1920   for (Xindex_entries::const_iterator p = this->entries_.begin();
1921        p != this->entries_.end();
1922        ++p)
1923     {
1924       unsigned int symndx = p->first;
1925       gold_assert(symndx * 4 < this->data_size());
1926       elfcpp::Swap<32, big_endian>::writeval(oview + symndx * 4, p->second);
1927     }
1928 }
1929
1930 // Output_fill_debug_info methods.
1931
1932 // Return the minimum size needed for a dummy compilation unit header.
1933
1934 size_t
1935 Output_fill_debug_info::do_minimum_hole_size() const
1936 {
1937   // Compile unit header fields: unit_length, version, debug_abbrev_offset,
1938   // address_size.
1939   const size_t len = 4 + 2 + 4 + 1;
1940   // For type units, add type_signature, type_offset.
1941   if (this->is_debug_types_)
1942     return len + 8 + 4;
1943   return len;
1944 }
1945
1946 // Write a dummy compilation unit header to fill a hole in the
1947 // .debug_info or .debug_types section.
1948
1949 void
1950 Output_fill_debug_info::do_write(Output_file* of, off_t off, size_t len) const
1951 {
1952   gold_debug(DEBUG_INCREMENTAL, "fill_debug_info(%08lx, %08lx)",
1953              static_cast<long>(off), static_cast<long>(len));
1954
1955   gold_assert(len >= this->do_minimum_hole_size());
1956
1957   unsigned char* const oview = of->get_output_view(off, len);
1958   unsigned char* pov = oview;
1959
1960   // Write header fields: unit_length, version, debug_abbrev_offset,
1961   // address_size.
1962   if (this->is_big_endian())
1963     {
1964       elfcpp::Swap_unaligned<32, true>::writeval(pov, len - 4);
1965       elfcpp::Swap_unaligned<16, true>::writeval(pov + 4, this->version);
1966       elfcpp::Swap_unaligned<32, true>::writeval(pov + 6, 0);
1967     }
1968   else
1969     {
1970       elfcpp::Swap_unaligned<32, false>::writeval(pov, len - 4);
1971       elfcpp::Swap_unaligned<16, false>::writeval(pov + 4, this->version);
1972       elfcpp::Swap_unaligned<32, false>::writeval(pov + 6, 0);
1973     }
1974   pov += 4 + 2 + 4;
1975   *pov++ = 4;
1976
1977   // For type units, the additional header fields -- type_signature,
1978   // type_offset -- can be filled with zeroes.
1979
1980   // Fill the remainder of the free space with zeroes.  The first
1981   // zero should tell the consumer there are no DIEs to read in this
1982   // compilation unit.
1983   if (pov < oview + len)
1984     memset(pov, 0, oview + len - pov);
1985
1986   of->write_output_view(off, len, oview);
1987 }
1988
1989 // Output_fill_debug_line methods.
1990
1991 // Return the minimum size needed for a dummy line number program header.
1992
1993 size_t
1994 Output_fill_debug_line::do_minimum_hole_size() const
1995 {
1996   // Line number program header fields: unit_length, version, header_length,
1997   // minimum_instruction_length, default_is_stmt, line_base, line_range,
1998   // opcode_base, standard_opcode_lengths[], include_directories, filenames.
1999   const size_t len = 4 + 2 + 4 + this->header_length;
2000   return len;
2001 }
2002
2003 // Write a dummy line number program header to fill a hole in the
2004 // .debug_line section.
2005
2006 void
2007 Output_fill_debug_line::do_write(Output_file* of, off_t off, size_t len) const
2008 {
2009   gold_debug(DEBUG_INCREMENTAL, "fill_debug_line(%08lx, %08lx)",
2010              static_cast<long>(off), static_cast<long>(len));
2011
2012   gold_assert(len >= this->do_minimum_hole_size());
2013
2014   unsigned char* const oview = of->get_output_view(off, len);
2015   unsigned char* pov = oview;
2016
2017   // Write header fields: unit_length, version, header_length,
2018   // minimum_instruction_length, default_is_stmt, line_base, line_range,
2019   // opcode_base, standard_opcode_lengths[], include_directories, filenames.
2020   // We set the header_length field to cover the entire hole, so the
2021   // line number program is empty.
2022   if (this->is_big_endian())
2023     {
2024       elfcpp::Swap_unaligned<32, true>::writeval(pov, len - 4);
2025       elfcpp::Swap_unaligned<16, true>::writeval(pov + 4, this->version);
2026       elfcpp::Swap_unaligned<32, true>::writeval(pov + 6, len - (4 + 2 + 4));
2027     }
2028   else
2029     {
2030       elfcpp::Swap_unaligned<32, false>::writeval(pov, len - 4);
2031       elfcpp::Swap_unaligned<16, false>::writeval(pov + 4, this->version);
2032       elfcpp::Swap_unaligned<32, false>::writeval(pov + 6, len - (4 + 2 + 4));
2033     }
2034   pov += 4 + 2 + 4;
2035   *pov++ = 1;   // minimum_instruction_length
2036   *pov++ = 0;   // default_is_stmt
2037   *pov++ = 0;   // line_base
2038   *pov++ = 5;   // line_range
2039   *pov++ = 13;  // opcode_base
2040   *pov++ = 0;   // standard_opcode_lengths[1]
2041   *pov++ = 1;   // standard_opcode_lengths[2]
2042   *pov++ = 1;   // standard_opcode_lengths[3]
2043   *pov++ = 1;   // standard_opcode_lengths[4]
2044   *pov++ = 1;   // standard_opcode_lengths[5]
2045   *pov++ = 0;   // standard_opcode_lengths[6]
2046   *pov++ = 0;   // standard_opcode_lengths[7]
2047   *pov++ = 0;   // standard_opcode_lengths[8]
2048   *pov++ = 1;   // standard_opcode_lengths[9]
2049   *pov++ = 0;   // standard_opcode_lengths[10]
2050   *pov++ = 0;   // standard_opcode_lengths[11]
2051   *pov++ = 1;   // standard_opcode_lengths[12]
2052   *pov++ = 0;   // include_directories (empty)
2053   *pov++ = 0;   // filenames (empty)
2054
2055   // Some consumers don't check the header_length field, and simply
2056   // start reading the line number program immediately following the
2057   // header.  For those consumers, we fill the remainder of the free
2058   // space with DW_LNS_set_basic_block opcodes.  These are effectively
2059   // no-ops: the resulting line table program will not create any rows.
2060   if (pov < oview + len)
2061     memset(pov, elfcpp::DW_LNS_set_basic_block, oview + len - pov);
2062
2063   of->write_output_view(off, len, oview);
2064 }
2065
2066 // Output_section::Input_section methods.
2067
2068 // Return the current data size.  For an input section we store the size here.
2069 // For an Output_section_data, we have to ask it for the size.
2070
2071 off_t
2072 Output_section::Input_section::current_data_size() const
2073 {
2074   if (this->is_input_section())
2075     return this->u1_.data_size;
2076   else
2077     {
2078       this->u2_.posd->pre_finalize_data_size();
2079       return this->u2_.posd->current_data_size();
2080     }
2081 }
2082
2083 // Return the data size.  For an input section we store the size here.
2084 // For an Output_section_data, we have to ask it for the size.
2085
2086 off_t
2087 Output_section::Input_section::data_size() const
2088 {
2089   if (this->is_input_section())
2090     return this->u1_.data_size;
2091   else
2092     return this->u2_.posd->data_size();
2093 }
2094
2095 // Return the object for an input section.
2096
2097 Relobj*
2098 Output_section::Input_section::relobj() const
2099 {
2100   if (this->is_input_section())
2101     return this->u2_.object;
2102   else if (this->is_merge_section())
2103     {
2104       gold_assert(this->u2_.pomb->first_relobj() != NULL);
2105       return this->u2_.pomb->first_relobj();
2106     }
2107   else if (this->is_relaxed_input_section())
2108     return this->u2_.poris->relobj();
2109   else
2110     gold_unreachable();
2111 }
2112
2113 // Return the input section index for an input section.
2114
2115 unsigned int
2116 Output_section::Input_section::shndx() const
2117 {
2118   if (this->is_input_section())
2119     return this->shndx_;
2120   else if (this->is_merge_section())
2121     {
2122       gold_assert(this->u2_.pomb->first_relobj() != NULL);
2123       return this->u2_.pomb->first_shndx();
2124     }
2125   else if (this->is_relaxed_input_section())
2126     return this->u2_.poris->shndx();
2127   else
2128     gold_unreachable();
2129 }
2130
2131 // Set the address and file offset.
2132
2133 void
2134 Output_section::Input_section::set_address_and_file_offset(
2135     uint64_t address,
2136     off_t file_offset,
2137     off_t section_file_offset)
2138 {
2139   if (this->is_input_section())
2140     this->u2_.object->set_section_offset(this->shndx_,
2141                                          file_offset - section_file_offset);
2142   else
2143     this->u2_.posd->set_address_and_file_offset(address, file_offset);
2144 }
2145
2146 // Reset the address and file offset.
2147
2148 void
2149 Output_section::Input_section::reset_address_and_file_offset()
2150 {
2151   if (!this->is_input_section())
2152     this->u2_.posd->reset_address_and_file_offset();
2153 }
2154
2155 // Finalize the data size.
2156
2157 void
2158 Output_section::Input_section::finalize_data_size()
2159 {
2160   if (!this->is_input_section())
2161     this->u2_.posd->finalize_data_size();
2162 }
2163
2164 // Try to turn an input offset into an output offset.  We want to
2165 // return the output offset relative to the start of this
2166 // Input_section in the output section.
2167
2168 inline bool
2169 Output_section::Input_section::output_offset(
2170     const Relobj* object,
2171     unsigned int shndx,
2172     section_offset_type offset,
2173     section_offset_type* poutput) const
2174 {
2175   if (!this->is_input_section())
2176     return this->u2_.posd->output_offset(object, shndx, offset, poutput);
2177   else
2178     {
2179       if (this->shndx_ != shndx || this->u2_.object != object)
2180         return false;
2181       *poutput = offset;
2182       return true;
2183     }
2184 }
2185
2186 // Return whether this is the merge section for the input section
2187 // SHNDX in OBJECT.
2188
2189 inline bool
2190 Output_section::Input_section::is_merge_section_for(const Relobj* object,
2191                                                     unsigned int shndx) const
2192 {
2193   if (this->is_input_section())
2194     return false;
2195   return this->u2_.posd->is_merge_section_for(object, shndx);
2196 }
2197
2198 // Write out the data.  We don't have to do anything for an input
2199 // section--they are handled via Object::relocate--but this is where
2200 // we write out the data for an Output_section_data.
2201
2202 void
2203 Output_section::Input_section::write(Output_file* of)
2204 {
2205   if (!this->is_input_section())
2206     this->u2_.posd->write(of);
2207 }
2208
2209 // Write the data to a buffer.  As for write(), we don't have to do
2210 // anything for an input section.
2211
2212 void
2213 Output_section::Input_section::write_to_buffer(unsigned char* buffer)
2214 {
2215   if (!this->is_input_section())
2216     this->u2_.posd->write_to_buffer(buffer);
2217 }
2218
2219 // Print to a map file.
2220
2221 void
2222 Output_section::Input_section::print_to_mapfile(Mapfile* mapfile) const
2223 {
2224   switch (this->shndx_)
2225     {
2226     case OUTPUT_SECTION_CODE:
2227     case MERGE_DATA_SECTION_CODE:
2228     case MERGE_STRING_SECTION_CODE:
2229       this->u2_.posd->print_to_mapfile(mapfile);
2230       break;
2231
2232     case RELAXED_INPUT_SECTION_CODE:
2233       {
2234         Output_relaxed_input_section* relaxed_section =
2235           this->relaxed_input_section();
2236         mapfile->print_input_section(relaxed_section->relobj(),
2237                                      relaxed_section->shndx());
2238       }
2239       break;
2240     default:
2241       mapfile->print_input_section(this->u2_.object, this->shndx_);
2242       break;
2243     }
2244 }
2245
2246 // Output_section methods.
2247
2248 // Construct an Output_section.  NAME will point into a Stringpool.
2249
2250 Output_section::Output_section(const char* name, elfcpp::Elf_Word type,
2251                                elfcpp::Elf_Xword flags)
2252   : name_(name),
2253     addralign_(0),
2254     entsize_(0),
2255     load_address_(0),
2256     link_section_(NULL),
2257     link_(0),
2258     info_section_(NULL),
2259     info_symndx_(NULL),
2260     info_(0),
2261     type_(type),
2262     flags_(flags),
2263     order_(ORDER_INVALID),
2264     out_shndx_(-1U),
2265     symtab_index_(0),
2266     dynsym_index_(0),
2267     input_sections_(),
2268     first_input_offset_(0),
2269     fills_(),
2270     postprocessing_buffer_(NULL),
2271     needs_symtab_index_(false),
2272     needs_dynsym_index_(false),
2273     should_link_to_symtab_(false),
2274     should_link_to_dynsym_(false),
2275     after_input_sections_(false),
2276     requires_postprocessing_(false),
2277     found_in_sections_clause_(false),
2278     has_load_address_(false),
2279     info_uses_section_index_(false),
2280     input_section_order_specified_(false),
2281     may_sort_attached_input_sections_(false),
2282     must_sort_attached_input_sections_(false),
2283     attached_input_sections_are_sorted_(false),
2284     is_relro_(false),
2285     is_small_section_(false),
2286     is_large_section_(false),
2287     generate_code_fills_at_write_(false),
2288     is_entsize_zero_(false),
2289     section_offsets_need_adjustment_(false),
2290     is_noload_(false),
2291     always_keeps_input_sections_(false),
2292     has_fixed_layout_(false),
2293     is_patch_space_allowed_(false),
2294     is_unique_segment_(false),
2295     tls_offset_(0),
2296     extra_segment_flags_(0),
2297     segment_alignment_(0),
2298     checkpoint_(NULL),
2299     lookup_maps_(new Output_section_lookup_maps),
2300     free_list_(),
2301     free_space_fill_(NULL),
2302     patch_space_(0)
2303 {
2304   // An unallocated section has no address.  Forcing this means that
2305   // we don't need special treatment for symbols defined in debug
2306   // sections.
2307   if ((flags & elfcpp::SHF_ALLOC) == 0)
2308     this->set_address(0);
2309 }
2310
2311 Output_section::~Output_section()
2312 {
2313   delete this->checkpoint_;
2314 }
2315
2316 // Set the entry size.
2317
2318 void
2319 Output_section::set_entsize(uint64_t v)
2320 {
2321   if (this->is_entsize_zero_)
2322     ;
2323   else if (this->entsize_ == 0)
2324     this->entsize_ = v;
2325   else if (this->entsize_ != v)
2326     {
2327       this->entsize_ = 0;
2328       this->is_entsize_zero_ = 1;
2329     }
2330 }
2331
2332 // Add the input section SHNDX, with header SHDR, named SECNAME, in
2333 // OBJECT, to the Output_section.  RELOC_SHNDX is the index of a
2334 // relocation section which applies to this section, or 0 if none, or
2335 // -1U if more than one.  Return the offset of the input section
2336 // within the output section.  Return -1 if the input section will
2337 // receive special handling.  In the normal case we don't always keep
2338 // track of input sections for an Output_section.  Instead, each
2339 // Object keeps track of the Output_section for each of its input
2340 // sections.  However, if HAVE_SECTIONS_SCRIPT is true, we do keep
2341 // track of input sections here; this is used when SECTIONS appears in
2342 // a linker script.
2343
2344 template<int size, bool big_endian>
2345 off_t
2346 Output_section::add_input_section(Layout* layout,
2347                                   Sized_relobj_file<size, big_endian>* object,
2348                                   unsigned int shndx,
2349                                   const char* secname,
2350                                   const elfcpp::Shdr<size, big_endian>& shdr,
2351                                   unsigned int reloc_shndx,
2352                                   bool have_sections_script)
2353 {
2354   elfcpp::Elf_Xword addralign = shdr.get_sh_addralign();
2355   if ((addralign & (addralign - 1)) != 0)
2356     {
2357       object->error(_("invalid alignment %lu for section \"%s\""),
2358                     static_cast<unsigned long>(addralign), secname);
2359       addralign = 1;
2360     }
2361
2362   if (addralign > this->addralign_)
2363     this->addralign_ = addralign;
2364
2365   typename elfcpp::Elf_types<size>::Elf_WXword sh_flags = shdr.get_sh_flags();
2366   uint64_t entsize = shdr.get_sh_entsize();
2367
2368   // .debug_str is a mergeable string section, but is not always so
2369   // marked by compilers.  Mark manually here so we can optimize.
2370   if (strcmp(secname, ".debug_str") == 0)
2371     {
2372       sh_flags |= (elfcpp::SHF_MERGE | elfcpp::SHF_STRINGS);
2373       entsize = 1;
2374     }
2375
2376   this->update_flags_for_input_section(sh_flags);
2377   this->set_entsize(entsize);
2378
2379   // If this is a SHF_MERGE section, we pass all the input sections to
2380   // a Output_data_merge.  We don't try to handle relocations for such
2381   // a section.  We don't try to handle empty merge sections--they
2382   // mess up the mappings, and are useless anyhow.
2383   // FIXME: Need to handle merge sections during incremental update.
2384   if ((sh_flags & elfcpp::SHF_MERGE) != 0
2385       && reloc_shndx == 0
2386       && shdr.get_sh_size() > 0
2387       && !parameters->incremental())
2388     {
2389       // Keep information about merged input sections for rebuilding fast
2390       // lookup maps if we have sections-script or we do relaxation.
2391       bool keeps_input_sections = (this->always_keeps_input_sections_
2392                                    || have_sections_script
2393                                    || parameters->target().may_relax());
2394
2395       if (this->add_merge_input_section(object, shndx, sh_flags, entsize,
2396                                         addralign, keeps_input_sections))
2397         {
2398           // Tell the relocation routines that they need to call the
2399           // output_offset method to determine the final address.
2400           return -1;
2401         }
2402     }
2403
2404   section_size_type input_section_size = shdr.get_sh_size();
2405   section_size_type uncompressed_size;
2406   if (object->section_is_compressed(shndx, &uncompressed_size))
2407     input_section_size = uncompressed_size;
2408
2409   off_t offset_in_section;
2410   off_t aligned_offset_in_section;
2411   if (this->has_fixed_layout())
2412     {
2413       // For incremental updates, find a chunk of unused space in the section.
2414       offset_in_section = this->free_list_.allocate(input_section_size,
2415                                                     addralign, 0);
2416       if (offset_in_section == -1)
2417         gold_fallback(_("out of patch space in section %s; "
2418                         "relink with --incremental-full"),
2419                       this->name());
2420       aligned_offset_in_section = offset_in_section;
2421     }
2422   else
2423     {
2424       offset_in_section = this->current_data_size_for_child();
2425       aligned_offset_in_section = align_address(offset_in_section,
2426                                                 addralign);
2427       this->set_current_data_size_for_child(aligned_offset_in_section
2428                                             + input_section_size);
2429     }
2430
2431   // Determine if we want to delay code-fill generation until the output
2432   // section is written.  When the target is relaxing, we want to delay fill
2433   // generating to avoid adjusting them during relaxation.  Also, if we are
2434   // sorting input sections we must delay fill generation.
2435   if (!this->generate_code_fills_at_write_
2436       && !have_sections_script
2437       && (sh_flags & elfcpp::SHF_EXECINSTR) != 0
2438       && parameters->target().has_code_fill()
2439       && (parameters->target().may_relax()
2440           || layout->is_section_ordering_specified()))
2441     {
2442       gold_assert(this->fills_.empty());
2443       this->generate_code_fills_at_write_ = true;
2444     }
2445
2446   if (aligned_offset_in_section > offset_in_section
2447       && !this->generate_code_fills_at_write_
2448       && !have_sections_script
2449       && (sh_flags & elfcpp::SHF_EXECINSTR) != 0
2450       && parameters->target().has_code_fill())
2451     {
2452       // We need to add some fill data.  Using fill_list_ when
2453       // possible is an optimization, since we will often have fill
2454       // sections without input sections.
2455       off_t fill_len = aligned_offset_in_section - offset_in_section;
2456       if (this->input_sections_.empty())
2457         this->fills_.push_back(Fill(offset_in_section, fill_len));
2458       else
2459         {
2460           std::string fill_data(parameters->target().code_fill(fill_len));
2461           Output_data_const* odc = new Output_data_const(fill_data, 1);
2462           this->input_sections_.push_back(Input_section(odc));
2463         }
2464     }
2465
2466   // We need to keep track of this section if we are already keeping
2467   // track of sections, or if we are relaxing.  Also, if this is a
2468   // section which requires sorting, or which may require sorting in
2469   // the future, we keep track of the sections.  If the
2470   // --section-ordering-file option is used to specify the order of
2471   // sections, we need to keep track of sections.
2472   if (this->always_keeps_input_sections_
2473       || have_sections_script
2474       || !this->input_sections_.empty()
2475       || this->may_sort_attached_input_sections()
2476       || this->must_sort_attached_input_sections()
2477       || parameters->options().user_set_Map()
2478       || parameters->target().may_relax()
2479       || layout->is_section_ordering_specified())
2480     {
2481       Input_section isecn(object, shndx, input_section_size, addralign);
2482       /* If section ordering is requested by specifying a ordering file,
2483          using --section-ordering-file, match the section name with
2484          a pattern.  */
2485       if (parameters->options().section_ordering_file())
2486         {
2487           unsigned int section_order_index =
2488             layout->find_section_order_index(std::string(secname));
2489           if (section_order_index != 0)
2490             {
2491               isecn.set_section_order_index(section_order_index);
2492               this->set_input_section_order_specified();
2493             }
2494         }
2495       if (this->has_fixed_layout())
2496         {
2497           // For incremental updates, finalize the address and offset now.
2498           uint64_t addr = this->address();
2499           isecn.set_address_and_file_offset(addr + aligned_offset_in_section,
2500                                             aligned_offset_in_section,
2501                                             this->offset());
2502         }
2503       this->input_sections_.push_back(isecn);
2504     }
2505
2506   return aligned_offset_in_section;
2507 }
2508
2509 // Add arbitrary data to an output section.
2510
2511 void
2512 Output_section::add_output_section_data(Output_section_data* posd)
2513 {
2514   Input_section inp(posd);
2515   this->add_output_section_data(&inp);
2516
2517   if (posd->is_data_size_valid())
2518     {
2519       off_t offset_in_section;
2520       if (this->has_fixed_layout())
2521         {
2522           // For incremental updates, find a chunk of unused space.
2523           offset_in_section = this->free_list_.allocate(posd->data_size(),
2524                                                         posd->addralign(), 0);
2525           if (offset_in_section == -1)
2526             gold_fallback(_("out of patch space in section %s; "
2527                             "relink with --incremental-full"),
2528                           this->name());
2529           // Finalize the address and offset now.
2530           uint64_t addr = this->address();
2531           off_t offset = this->offset();
2532           posd->set_address_and_file_offset(addr + offset_in_section,
2533                                             offset + offset_in_section);
2534         }
2535       else
2536         {
2537           offset_in_section = this->current_data_size_for_child();
2538           off_t aligned_offset_in_section = align_address(offset_in_section,
2539                                                           posd->addralign());
2540           this->set_current_data_size_for_child(aligned_offset_in_section
2541                                                 + posd->data_size());
2542         }
2543     }
2544   else if (this->has_fixed_layout())
2545     {
2546       // For incremental updates, arrange for the data to have a fixed layout.
2547       // This will mean that additions to the data must be allocated from
2548       // free space within the containing output section.
2549       uint64_t addr = this->address();
2550       posd->set_address(addr);
2551       posd->set_file_offset(0);
2552       // FIXME: This should eventually be unreachable.
2553       // gold_unreachable();
2554     }
2555 }
2556
2557 // Add a relaxed input section.
2558
2559 void
2560 Output_section::add_relaxed_input_section(Layout* layout,
2561                                           Output_relaxed_input_section* poris,
2562                                           const std::string& name)
2563 {
2564   Input_section inp(poris);
2565
2566   // If the --section-ordering-file option is used to specify the order of
2567   // sections, we need to keep track of sections.
2568   if (layout->is_section_ordering_specified())
2569     {
2570       unsigned int section_order_index =
2571         layout->find_section_order_index(name);
2572       if (section_order_index != 0)
2573         {
2574           inp.set_section_order_index(section_order_index);
2575           this->set_input_section_order_specified();
2576         }
2577     }
2578
2579   this->add_output_section_data(&inp);
2580   if (this->lookup_maps_->is_valid())
2581     this->lookup_maps_->add_relaxed_input_section(poris->relobj(),
2582                                                   poris->shndx(), poris);
2583
2584   // For a relaxed section, we use the current data size.  Linker scripts
2585   // get all the input sections, including relaxed one from an output
2586   // section and add them back to them same output section to compute the
2587   // output section size.  If we do not account for sizes of relaxed input
2588   // sections,  an output section would be incorrectly sized.
2589   off_t offset_in_section = this->current_data_size_for_child();
2590   off_t aligned_offset_in_section = align_address(offset_in_section,
2591                                                   poris->addralign());
2592   this->set_current_data_size_for_child(aligned_offset_in_section
2593                                         + poris->current_data_size());
2594 }
2595
2596 // Add arbitrary data to an output section by Input_section.
2597
2598 void
2599 Output_section::add_output_section_data(Input_section* inp)
2600 {
2601   if (this->input_sections_.empty())
2602     this->first_input_offset_ = this->current_data_size_for_child();
2603
2604   this->input_sections_.push_back(*inp);
2605
2606   uint64_t addralign = inp->addralign();
2607   if (addralign > this->addralign_)
2608     this->addralign_ = addralign;
2609
2610   inp->set_output_section(this);
2611 }
2612
2613 // Add a merge section to an output section.
2614
2615 void
2616 Output_section::add_output_merge_section(Output_section_data* posd,
2617                                          bool is_string, uint64_t entsize)
2618 {
2619   Input_section inp(posd, is_string, entsize);
2620   this->add_output_section_data(&inp);
2621 }
2622
2623 // Add an input section to a SHF_MERGE section.
2624
2625 bool
2626 Output_section::add_merge_input_section(Relobj* object, unsigned int shndx,
2627                                         uint64_t flags, uint64_t entsize,
2628                                         uint64_t addralign,
2629                                         bool keeps_input_sections)
2630 {
2631   bool is_string = (flags & elfcpp::SHF_STRINGS) != 0;
2632
2633   // We only merge strings if the alignment is not more than the
2634   // character size.  This could be handled, but it's unusual.
2635   if (is_string && addralign > entsize)
2636     return false;
2637
2638   // We cannot restore merged input section states.
2639   gold_assert(this->checkpoint_ == NULL);
2640
2641   // Look up merge sections by required properties.
2642   // Currently, we only invalidate the lookup maps in script processing
2643   // and relaxation.  We should not have done either when we reach here.
2644   // So we assume that the lookup maps are valid to simply code.
2645   gold_assert(this->lookup_maps_->is_valid());
2646   Merge_section_properties msp(is_string, entsize, addralign);
2647   Output_merge_base* pomb = this->lookup_maps_->find_merge_section(msp);
2648   bool is_new = false;
2649   if (pomb != NULL)
2650     {
2651       gold_assert(pomb->is_string() == is_string
2652                   && pomb->entsize() == entsize
2653                   && pomb->addralign() == addralign);
2654     }
2655   else
2656     {
2657       // Create a new Output_merge_data or Output_merge_string_data.
2658       if (!is_string)
2659         pomb = new Output_merge_data(entsize, addralign);
2660       else
2661         {
2662           switch (entsize)
2663             {
2664             case 1:
2665               pomb = new Output_merge_string<char>(addralign);
2666               break;
2667             case 2:
2668               pomb = new Output_merge_string<uint16_t>(addralign);
2669               break;
2670             case 4:
2671               pomb = new Output_merge_string<uint32_t>(addralign);
2672               break;
2673             default:
2674               return false;
2675             }
2676         }
2677       // If we need to do script processing or relaxation, we need to keep
2678       // the original input sections to rebuild the fast lookup maps.
2679       if (keeps_input_sections)
2680         pomb->set_keeps_input_sections();
2681       is_new = true;
2682     }
2683
2684   if (pomb->add_input_section(object, shndx))
2685     {
2686       // Add new merge section to this output section and link merge
2687       // section properties to new merge section in map.
2688       if (is_new)
2689         {
2690           this->add_output_merge_section(pomb, is_string, entsize);
2691           this->lookup_maps_->add_merge_section(msp, pomb);
2692         }
2693
2694       // Add input section to new merge section and link input section to new
2695       // merge section in map.
2696       this->lookup_maps_->add_merge_input_section(object, shndx, pomb);
2697       return true;
2698     }
2699   else
2700     {
2701       // If add_input_section failed, delete new merge section to avoid
2702       // exporting empty merge sections in Output_section::get_input_section.
2703       if (is_new)
2704         delete pomb;
2705       return false;
2706     }
2707 }
2708
2709 // Build a relaxation map to speed up relaxation of existing input sections.
2710 // Look up to the first LIMIT elements in INPUT_SECTIONS.
2711
2712 void
2713 Output_section::build_relaxation_map(
2714   const Input_section_list& input_sections,
2715   size_t limit,
2716   Relaxation_map* relaxation_map) const
2717 {
2718   for (size_t i = 0; i < limit; ++i)
2719     {
2720       const Input_section& is(input_sections[i]);
2721       if (is.is_input_section() || is.is_relaxed_input_section())
2722         {
2723           Section_id sid(is.relobj(), is.shndx());
2724           (*relaxation_map)[sid] = i;
2725         }
2726     }
2727 }
2728
2729 // Convert regular input sections in INPUT_SECTIONS into relaxed input
2730 // sections in RELAXED_SECTIONS.  MAP is a prebuilt map from section id
2731 // indices of INPUT_SECTIONS.
2732
2733 void
2734 Output_section::convert_input_sections_in_list_to_relaxed_sections(
2735   const std::vector<Output_relaxed_input_section*>& relaxed_sections,
2736   const Relaxation_map& map,
2737   Input_section_list* input_sections)
2738 {
2739   for (size_t i = 0; i < relaxed_sections.size(); ++i)
2740     {
2741       Output_relaxed_input_section* poris = relaxed_sections[i];
2742       Section_id sid(poris->relobj(), poris->shndx());
2743       Relaxation_map::const_iterator p = map.find(sid);
2744       gold_assert(p != map.end());
2745       gold_assert((*input_sections)[p->second].is_input_section());
2746
2747       // Remember section order index of original input section
2748       // if it is set.  Copy it to the relaxed input section.
2749       unsigned int soi =
2750         (*input_sections)[p->second].section_order_index();
2751       (*input_sections)[p->second] = Input_section(poris);
2752       (*input_sections)[p->second].set_section_order_index(soi);
2753     }
2754 }
2755   
2756 // Convert regular input sections into relaxed input sections. RELAXED_SECTIONS
2757 // is a vector of pointers to Output_relaxed_input_section or its derived
2758 // classes.  The relaxed sections must correspond to existing input sections.
2759
2760 void
2761 Output_section::convert_input_sections_to_relaxed_sections(
2762   const std::vector<Output_relaxed_input_section*>& relaxed_sections)
2763 {
2764   gold_assert(parameters->target().may_relax());
2765
2766   // We want to make sure that restore_states does not undo the effect of
2767   // this.  If there is no checkpoint active, just search the current
2768   // input section list and replace the sections there.  If there is
2769   // a checkpoint, also replace the sections there.
2770   
2771   // By default, we look at the whole list.
2772   size_t limit = this->input_sections_.size();
2773
2774   if (this->checkpoint_ != NULL)
2775     {
2776       // Replace input sections with relaxed input section in the saved
2777       // copy of the input section list.
2778       if (this->checkpoint_->input_sections_saved())
2779         {
2780           Relaxation_map map;
2781           this->build_relaxation_map(
2782                     *(this->checkpoint_->input_sections()),
2783                     this->checkpoint_->input_sections()->size(),
2784                     &map);
2785           this->convert_input_sections_in_list_to_relaxed_sections(
2786                     relaxed_sections,
2787                     map,
2788                     this->checkpoint_->input_sections());
2789         }
2790       else
2791         {
2792           // We have not copied the input section list yet.  Instead, just
2793           // look at the portion that would be saved.
2794           limit = this->checkpoint_->input_sections_size();
2795         }
2796     }
2797
2798   // Convert input sections in input_section_list.
2799   Relaxation_map map;
2800   this->build_relaxation_map(this->input_sections_, limit, &map);
2801   this->convert_input_sections_in_list_to_relaxed_sections(
2802             relaxed_sections,
2803             map,
2804             &this->input_sections_);
2805
2806   // Update fast look-up map.
2807   if (this->lookup_maps_->is_valid())
2808     for (size_t i = 0; i < relaxed_sections.size(); ++i)
2809       {
2810         Output_relaxed_input_section* poris = relaxed_sections[i];
2811         this->lookup_maps_->add_relaxed_input_section(poris->relobj(),
2812                                                       poris->shndx(), poris);
2813       }
2814 }
2815
2816 // Update the output section flags based on input section flags.
2817
2818 void
2819 Output_section::update_flags_for_input_section(elfcpp::Elf_Xword flags)
2820 {
2821   // If we created the section with SHF_ALLOC clear, we set the
2822   // address.  If we are now setting the SHF_ALLOC flag, we need to
2823   // undo that.
2824   if ((this->flags_ & elfcpp::SHF_ALLOC) == 0
2825       && (flags & elfcpp::SHF_ALLOC) != 0)
2826     this->mark_address_invalid();
2827
2828   this->flags_ |= (flags
2829                    & (elfcpp::SHF_WRITE
2830                       | elfcpp::SHF_ALLOC
2831                       | elfcpp::SHF_EXECINSTR));
2832
2833   if ((flags & elfcpp::SHF_MERGE) == 0)
2834     this->flags_ &=~ elfcpp::SHF_MERGE;
2835   else
2836     {
2837       if (this->current_data_size_for_child() == 0)
2838         this->flags_ |= elfcpp::SHF_MERGE;
2839     }
2840
2841   if ((flags & elfcpp::SHF_STRINGS) == 0)
2842     this->flags_ &=~ elfcpp::SHF_STRINGS;
2843   else
2844     {
2845       if (this->current_data_size_for_child() == 0)
2846         this->flags_ |= elfcpp::SHF_STRINGS;
2847     }
2848 }
2849
2850 // Find the merge section into which an input section with index SHNDX in
2851 // OBJECT has been added.  Return NULL if none found.
2852
2853 Output_section_data*
2854 Output_section::find_merge_section(const Relobj* object,
2855                                    unsigned int shndx) const
2856 {
2857   if (!this->lookup_maps_->is_valid())
2858     this->build_lookup_maps();
2859   return this->lookup_maps_->find_merge_section(object, shndx);
2860 }
2861
2862 // Build the lookup maps for merge and relaxed sections.  This is needs
2863 // to be declared as a const methods so that it is callable with a const
2864 // Output_section pointer.  The method only updates states of the maps.
2865
2866 void
2867 Output_section::build_lookup_maps() const
2868 {
2869   this->lookup_maps_->clear();
2870   for (Input_section_list::const_iterator p = this->input_sections_.begin();
2871        p != this->input_sections_.end();
2872        ++p)
2873     {
2874       if (p->is_merge_section())
2875         {
2876           Output_merge_base* pomb = p->output_merge_base();
2877           Merge_section_properties msp(pomb->is_string(), pomb->entsize(),
2878                                        pomb->addralign());
2879           this->lookup_maps_->add_merge_section(msp, pomb);
2880           for (Output_merge_base::Input_sections::const_iterator is =
2881                  pomb->input_sections_begin();
2882                is != pomb->input_sections_end();
2883                ++is) 
2884             {
2885               const Const_section_id& csid = *is;
2886             this->lookup_maps_->add_merge_input_section(csid.first,
2887                                                         csid.second, pomb);
2888             }
2889             
2890         }
2891       else if (p->is_relaxed_input_section())
2892         {
2893           Output_relaxed_input_section* poris = p->relaxed_input_section();
2894           this->lookup_maps_->add_relaxed_input_section(poris->relobj(),
2895                                                         poris->shndx(), poris);
2896         }
2897     }
2898 }
2899
2900 // Find an relaxed input section corresponding to an input section
2901 // in OBJECT with index SHNDX.
2902
2903 const Output_relaxed_input_section*
2904 Output_section::find_relaxed_input_section(const Relobj* object,
2905                                            unsigned int shndx) const
2906 {
2907   if (!this->lookup_maps_->is_valid())
2908     this->build_lookup_maps();
2909   return this->lookup_maps_->find_relaxed_input_section(object, shndx);
2910 }
2911
2912 // Given an address OFFSET relative to the start of input section
2913 // SHNDX in OBJECT, return whether this address is being included in
2914 // the final link.  This should only be called if SHNDX in OBJECT has
2915 // a special mapping.
2916
2917 bool
2918 Output_section::is_input_address_mapped(const Relobj* object,
2919                                         unsigned int shndx,
2920                                         off_t offset) const
2921 {
2922   // Look at the Output_section_data_maps first.
2923   const Output_section_data* posd = this->find_merge_section(object, shndx);
2924   if (posd == NULL)
2925     posd = this->find_relaxed_input_section(object, shndx);
2926
2927   if (posd != NULL)
2928     {
2929       section_offset_type output_offset;
2930       bool found = posd->output_offset(object, shndx, offset, &output_offset);
2931       gold_assert(found);   
2932       return output_offset != -1;
2933     }
2934
2935   // Fall back to the slow look-up.
2936   for (Input_section_list::const_iterator p = this->input_sections_.begin();
2937        p != this->input_sections_.end();
2938        ++p)
2939     {
2940       section_offset_type output_offset;
2941       if (p->output_offset(object, shndx, offset, &output_offset))
2942         return output_offset != -1;
2943     }
2944
2945   // By default we assume that the address is mapped.  This should
2946   // only be called after we have passed all sections to Layout.  At
2947   // that point we should know what we are discarding.
2948   return true;
2949 }
2950
2951 // Given an address OFFSET relative to the start of input section
2952 // SHNDX in object OBJECT, return the output offset relative to the
2953 // start of the input section in the output section.  This should only
2954 // be called if SHNDX in OBJECT has a special mapping.
2955
2956 section_offset_type
2957 Output_section::output_offset(const Relobj* object, unsigned int shndx,
2958                               section_offset_type offset) const
2959 {
2960   // This can only be called meaningfully when we know the data size
2961   // of this.
2962   gold_assert(this->is_data_size_valid());
2963
2964   // Look at the Output_section_data_maps first.
2965   const Output_section_data* posd = this->find_merge_section(object, shndx);
2966   if (posd == NULL) 
2967     posd = this->find_relaxed_input_section(object, shndx);
2968   if (posd != NULL)
2969     {
2970       section_offset_type output_offset;
2971       bool found = posd->output_offset(object, shndx, offset, &output_offset);
2972       gold_assert(found);   
2973       return output_offset;
2974     }
2975
2976   // Fall back to the slow look-up.
2977   for (Input_section_list::const_iterator p = this->input_sections_.begin();
2978        p != this->input_sections_.end();
2979        ++p)
2980     {
2981       section_offset_type output_offset;
2982       if (p->output_offset(object, shndx, offset, &output_offset))
2983         return output_offset;
2984     }
2985   gold_unreachable();
2986 }
2987
2988 // Return the output virtual address of OFFSET relative to the start
2989 // of input section SHNDX in object OBJECT.
2990
2991 uint64_t
2992 Output_section::output_address(const Relobj* object, unsigned int shndx,
2993                                off_t offset) const
2994 {
2995   uint64_t addr = this->address() + this->first_input_offset_;
2996
2997   // Look at the Output_section_data_maps first.
2998   const Output_section_data* posd = this->find_merge_section(object, shndx);
2999   if (posd == NULL) 
3000     posd = this->find_relaxed_input_section(object, shndx);
3001   if (posd != NULL && posd->is_address_valid())
3002     {
3003       section_offset_type output_offset;
3004       bool found = posd->output_offset(object, shndx, offset, &output_offset);
3005       gold_assert(found);
3006       return posd->address() + output_offset;
3007     }
3008
3009   // Fall back to the slow look-up.
3010   for (Input_section_list::const_iterator p = this->input_sections_.begin();
3011        p != this->input_sections_.end();
3012        ++p)
3013     {
3014       addr = align_address(addr, p->addralign());
3015       section_offset_type output_offset;
3016       if (p->output_offset(object, shndx, offset, &output_offset))
3017         {
3018           if (output_offset == -1)
3019             return -1ULL;
3020           return addr + output_offset;
3021         }
3022       addr += p->data_size();
3023     }
3024
3025   // If we get here, it means that we don't know the mapping for this
3026   // input section.  This might happen in principle if
3027   // add_input_section were called before add_output_section_data.
3028   // But it should never actually happen.
3029
3030   gold_unreachable();
3031 }
3032
3033 // Find the output address of the start of the merged section for
3034 // input section SHNDX in object OBJECT.
3035
3036 bool
3037 Output_section::find_starting_output_address(const Relobj* object,
3038                                              unsigned int shndx,
3039                                              uint64_t* paddr) const
3040 {
3041   // FIXME: This becomes a bottle-neck if we have many relaxed sections.
3042   // Looking up the merge section map does not always work as we sometimes
3043   // find a merge section without its address set.
3044   uint64_t addr = this->address() + this->first_input_offset_;
3045   for (Input_section_list::const_iterator p = this->input_sections_.begin();
3046        p != this->input_sections_.end();
3047        ++p)
3048     {
3049       addr = align_address(addr, p->addralign());
3050
3051       // It would be nice if we could use the existing output_offset
3052       // method to get the output offset of input offset 0.
3053       // Unfortunately we don't know for sure that input offset 0 is
3054       // mapped at all.
3055       if (p->is_merge_section_for(object, shndx))
3056         {
3057           *paddr = addr;
3058           return true;
3059         }
3060
3061       addr += p->data_size();
3062     }
3063
3064   // We couldn't find a merge output section for this input section.
3065   return false;
3066 }
3067
3068 // Update the data size of an Output_section.
3069
3070 void
3071 Output_section::update_data_size()
3072 {
3073   if (this->input_sections_.empty())
3074       return;
3075
3076   if (this->must_sort_attached_input_sections()
3077       || this->input_section_order_specified())
3078     this->sort_attached_input_sections();
3079
3080   off_t off = this->first_input_offset_;
3081   for (Input_section_list::iterator p = this->input_sections_.begin();
3082        p != this->input_sections_.end();
3083        ++p)
3084     {
3085       off = align_address(off, p->addralign());
3086       off += p->current_data_size();
3087     }
3088
3089   this->set_current_data_size_for_child(off);
3090 }
3091
3092 // Set the data size of an Output_section.  This is where we handle
3093 // setting the addresses of any Output_section_data objects.
3094
3095 void
3096 Output_section::set_final_data_size()
3097 {
3098   off_t data_size;
3099
3100   if (this->input_sections_.empty())
3101     data_size = this->current_data_size_for_child();
3102   else
3103     {
3104       if (this->must_sort_attached_input_sections()
3105           || this->input_section_order_specified())
3106         this->sort_attached_input_sections();
3107
3108       uint64_t address = this->address();
3109       off_t startoff = this->offset();
3110       off_t off = startoff + this->first_input_offset_;
3111       for (Input_section_list::iterator p = this->input_sections_.begin();
3112            p != this->input_sections_.end();
3113            ++p)
3114         {
3115           off = align_address(off, p->addralign());
3116           p->set_address_and_file_offset(address + (off - startoff), off,
3117                                          startoff);
3118           off += p->data_size();
3119         }
3120       data_size = off - startoff;
3121     }
3122
3123   // For full incremental links, we want to allocate some patch space
3124   // in most sections for subsequent incremental updates.
3125   if (this->is_patch_space_allowed_ && parameters->incremental_full())
3126     {
3127       double pct = parameters->options().incremental_patch();
3128       size_t extra = static_cast<size_t>(data_size * pct);
3129       if (this->free_space_fill_ != NULL
3130           && this->free_space_fill_->minimum_hole_size() > extra)
3131         extra = this->free_space_fill_->minimum_hole_size();
3132       off_t new_size = align_address(data_size + extra, this->addralign());
3133       this->patch_space_ = new_size - data_size;
3134       gold_debug(DEBUG_INCREMENTAL,
3135                  "set_final_data_size: %08lx + %08lx: section %s",
3136                  static_cast<long>(data_size),
3137                  static_cast<long>(this->patch_space_),
3138                  this->name());
3139       data_size = new_size;
3140     }
3141
3142   this->set_data_size(data_size);
3143 }
3144
3145 // Reset the address and file offset.
3146
3147 void
3148 Output_section::do_reset_address_and_file_offset()
3149 {
3150   // An unallocated section has no address.  Forcing this means that
3151   // we don't need special treatment for symbols defined in debug
3152   // sections.  We do the same in the constructor.  This does not
3153   // apply to NOLOAD sections though.
3154   if (((this->flags_ & elfcpp::SHF_ALLOC) == 0) && !this->is_noload_)
3155      this->set_address(0);
3156
3157   for (Input_section_list::iterator p = this->input_sections_.begin();
3158        p != this->input_sections_.end();
3159        ++p)
3160     p->reset_address_and_file_offset();
3161
3162   // Remove any patch space that was added in set_final_data_size.
3163   if (this->patch_space_ > 0)
3164     {
3165       this->set_current_data_size_for_child(this->current_data_size_for_child()
3166                                             - this->patch_space_);
3167       this->patch_space_ = 0;
3168     }
3169 }
3170
3171 // Return true if address and file offset have the values after reset.
3172
3173 bool
3174 Output_section::do_address_and_file_offset_have_reset_values() const
3175 {
3176   if (this->is_offset_valid())
3177     return false;
3178
3179   // An unallocated section has address 0 after its construction or a reset.
3180   if ((this->flags_ & elfcpp::SHF_ALLOC) == 0)
3181     return this->is_address_valid() && this->address() == 0;
3182   else
3183     return !this->is_address_valid();
3184 }
3185
3186 // Set the TLS offset.  Called only for SHT_TLS sections.
3187
3188 void
3189 Output_section::do_set_tls_offset(uint64_t tls_base)
3190 {
3191   this->tls_offset_ = this->address() - tls_base;
3192 }
3193
3194 // In a few cases we need to sort the input sections attached to an
3195 // output section.  This is used to implement the type of constructor
3196 // priority ordering implemented by the GNU linker, in which the
3197 // priority becomes part of the section name and the sections are
3198 // sorted by name.  We only do this for an output section if we see an
3199 // attached input section matching ".ctors.*", ".dtors.*",
3200 // ".init_array.*" or ".fini_array.*".
3201
3202 class Output_section::Input_section_sort_entry
3203 {
3204  public:
3205   Input_section_sort_entry()
3206     : input_section_(), index_(-1U), section_has_name_(false),
3207       section_name_()
3208   { }
3209
3210   Input_section_sort_entry(const Input_section& input_section,
3211                            unsigned int index,
3212                            bool must_sort_attached_input_sections)
3213     : input_section_(input_section), index_(index),
3214       section_has_name_(input_section.is_input_section()
3215                         || input_section.is_relaxed_input_section())
3216   {
3217     if (this->section_has_name_
3218         && must_sort_attached_input_sections)
3219       {
3220         // This is only called single-threaded from Layout::finalize,
3221         // so it is OK to lock.  Unfortunately we have no way to pass
3222         // in a Task token.
3223         const Task* dummy_task = reinterpret_cast<const Task*>(-1);
3224         Object* obj = (input_section.is_input_section()
3225                        ? input_section.relobj()
3226                        : input_section.relaxed_input_section()->relobj());
3227         Task_lock_obj<Object> tl(dummy_task, obj);
3228
3229         // This is a slow operation, which should be cached in
3230         // Layout::layout if this becomes a speed problem.
3231         this->section_name_ = obj->section_name(input_section.shndx());
3232       }
3233   }
3234
3235   // Return the Input_section.
3236   const Input_section&
3237   input_section() const
3238   {
3239     gold_assert(this->index_ != -1U);
3240     return this->input_section_;
3241   }
3242
3243   // The index of this entry in the original list.  This is used to
3244   // make the sort stable.
3245   unsigned int
3246   index() const
3247   {
3248     gold_assert(this->index_ != -1U);
3249     return this->index_;
3250   }
3251
3252   // Whether there is a section name.
3253   bool
3254   section_has_name() const
3255   { return this->section_has_name_; }
3256
3257   // The section name.
3258   const std::string&
3259   section_name() const
3260   {
3261     gold_assert(this->section_has_name_);
3262     return this->section_name_;
3263   }
3264
3265   // Return true if the section name has a priority.  This is assumed
3266   // to be true if it has a dot after the initial dot.
3267   bool
3268   has_priority() const
3269   {
3270     gold_assert(this->section_has_name_);
3271     return this->section_name_.find('.', 1) != std::string::npos;
3272   }
3273
3274   // Return the priority.  Believe it or not, gcc encodes the priority
3275   // differently for .ctors/.dtors and .init_array/.fini_array
3276   // sections.
3277   unsigned int
3278   get_priority() const
3279   {
3280     gold_assert(this->section_has_name_);
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   { return Layout::match_file_name(this->input_section_.relobj(), file_name); }
3312
3313   // Returns 1 if THIS should appear before S in section order, -1 if S
3314   // appears before THIS and 0 if they are not comparable.
3315   int
3316   compare_section_ordering(const Input_section_sort_entry& s) const
3317   {
3318     unsigned int this_secn_index = this->input_section_.section_order_index();
3319     unsigned int s_secn_index = s.input_section().section_order_index();
3320     if (this_secn_index > 0 && s_secn_index > 0)
3321       {
3322         if (this_secn_index < s_secn_index)
3323           return 1;
3324         else if (this_secn_index > s_secn_index)
3325           return -1;
3326       }
3327     return 0;
3328   }
3329
3330  private:
3331   // The Input_section we are sorting.
3332   Input_section input_section_;
3333   // The index of this Input_section in the original list.
3334   unsigned int index_;
3335   // Whether this Input_section has a section name--it won't if this
3336   // is some random Output_section_data.
3337   bool section_has_name_;
3338   // The section name if there is one.
3339   std::string section_name_;
3340 };
3341
3342 // Return true if S1 should come before S2 in the output section.
3343
3344 bool
3345 Output_section::Input_section_sort_compare::operator()(
3346     const Output_section::Input_section_sort_entry& s1,
3347     const Output_section::Input_section_sort_entry& s2) const
3348 {
3349   // crtbegin.o must come first.
3350   bool s1_begin = s1.match_file_name("crtbegin");
3351   bool s2_begin = s2.match_file_name("crtbegin");
3352   if (s1_begin || s2_begin)
3353     {
3354       if (!s1_begin)
3355         return false;
3356       if (!s2_begin)
3357         return true;
3358       return s1.index() < s2.index();
3359     }
3360
3361   // crtend.o must come last.
3362   bool s1_end = s1.match_file_name("crtend");
3363   bool s2_end = s2.match_file_name("crtend");
3364   if (s1_end || s2_end)
3365     {
3366       if (!s1_end)
3367         return true;
3368       if (!s2_end)
3369         return false;
3370       return s1.index() < s2.index();
3371     }
3372
3373   // We sort all the sections with no names to the end.
3374   if (!s1.section_has_name() || !s2.section_has_name())
3375     {
3376       if (s1.section_has_name())
3377         return true;
3378       if (s2.section_has_name())
3379         return false;
3380       return s1.index() < s2.index();
3381     }
3382
3383   // A section with a priority follows a section without a priority.
3384   bool s1_has_priority = s1.has_priority();
3385   bool s2_has_priority = s2.has_priority();
3386   if (s1_has_priority && !s2_has_priority)
3387     return false;
3388   if (!s1_has_priority && s2_has_priority)
3389     return true;
3390
3391   // Check if a section order exists for these sections through a section
3392   // ordering file.  If sequence_num is 0, an order does not exist.
3393   int sequence_num = s1.compare_section_ordering(s2);
3394   if (sequence_num != 0)
3395     return sequence_num == 1;
3396
3397   // Otherwise we sort by name.
3398   int compare = s1.section_name().compare(s2.section_name());
3399   if (compare != 0)
3400     return compare < 0;
3401
3402   // Otherwise we keep the input order.
3403   return s1.index() < s2.index();
3404 }
3405
3406 // Return true if S1 should come before S2 in an .init_array or .fini_array
3407 // output section.
3408
3409 bool
3410 Output_section::Input_section_sort_init_fini_compare::operator()(
3411     const Output_section::Input_section_sort_entry& s1,
3412     const Output_section::Input_section_sort_entry& s2) const
3413 {
3414   // We sort all the sections with no names to the end.
3415   if (!s1.section_has_name() || !s2.section_has_name())
3416     {
3417       if (s1.section_has_name())
3418         return true;
3419       if (s2.section_has_name())
3420         return false;
3421       return s1.index() < s2.index();
3422     }
3423
3424   // A section without a priority follows a section with a priority.
3425   // This is the reverse of .ctors and .dtors sections.
3426   bool s1_has_priority = s1.has_priority();
3427   bool s2_has_priority = s2.has_priority();
3428   if (s1_has_priority && !s2_has_priority)
3429     return true;
3430   if (!s1_has_priority && s2_has_priority)
3431     return false;
3432
3433   // .ctors and .dtors sections without priority come after
3434   // .init_array and .fini_array sections without priority.
3435   if (!s1_has_priority
3436       && (s1.section_name() == ".ctors" || s1.section_name() == ".dtors")
3437       && s1.section_name() != s2.section_name())
3438     return false;
3439   if (!s2_has_priority
3440       && (s2.section_name() == ".ctors" || s2.section_name() == ".dtors")
3441       && s2.section_name() != s1.section_name())
3442     return true;
3443
3444   // Sort by priority if we can.
3445   if (s1_has_priority)
3446     {
3447       unsigned int s1_prio = s1.get_priority();
3448       unsigned int s2_prio = s2.get_priority();
3449       if (s1_prio < s2_prio)
3450         return true;
3451       else if (s1_prio > s2_prio)
3452         return false;
3453     }
3454
3455   // Check if a section order exists for these sections through a section
3456   // ordering file.  If sequence_num is 0, an order does not exist.
3457   int sequence_num = s1.compare_section_ordering(s2);
3458   if (sequence_num != 0)
3459     return sequence_num == 1;
3460
3461   // Otherwise we sort by name.
3462   int compare = s1.section_name().compare(s2.section_name());
3463   if (compare != 0)
3464     return compare < 0;
3465
3466   // Otherwise we keep the input order.
3467   return s1.index() < s2.index();
3468 }
3469
3470 // Return true if S1 should come before S2.  Sections that do not match
3471 // any pattern in the section ordering file are placed ahead of the sections
3472 // that match some pattern.
3473
3474 bool
3475 Output_section::Input_section_sort_section_order_index_compare::operator()(
3476     const Output_section::Input_section_sort_entry& s1,
3477     const Output_section::Input_section_sort_entry& s2) const
3478 {
3479   unsigned int s1_secn_index = s1.input_section().section_order_index();
3480   unsigned int s2_secn_index = s2.input_section().section_order_index();
3481
3482   // Keep input order if section ordering cannot determine order.
3483   if (s1_secn_index == s2_secn_index)
3484     return s1.index() < s2.index();
3485   
3486   return s1_secn_index < s2_secn_index;
3487 }
3488
3489 // This updates the section order index of input sections according to the
3490 // the order specified in the mapping from Section id to order index.
3491
3492 void
3493 Output_section::update_section_layout(
3494   const Section_layout_order* order_map)
3495 {
3496   for (Input_section_list::iterator p = this->input_sections_.begin();
3497        p != this->input_sections_.end();
3498        ++p)
3499     {
3500       if (p->is_input_section()
3501           || p->is_relaxed_input_section())
3502         {
3503           Object* obj = (p->is_input_section()
3504                          ? p->relobj()
3505                          : p->relaxed_input_section()->relobj());
3506           unsigned int shndx = p->shndx();
3507           Section_layout_order::const_iterator it
3508             = order_map->find(Section_id(obj, shndx));
3509           if (it == order_map->end())
3510             continue;
3511           unsigned int section_order_index = it->second;
3512           if (section_order_index != 0)
3513             {
3514               p->set_section_order_index(section_order_index);
3515               this->set_input_section_order_specified();
3516             }
3517         }
3518     }
3519 }
3520
3521 // Sort the input sections attached to an output section.
3522
3523 void
3524 Output_section::sort_attached_input_sections()
3525 {
3526   if (this->attached_input_sections_are_sorted_)
3527     return;
3528
3529   if (this->checkpoint_ != NULL
3530       && !this->checkpoint_->input_sections_saved())
3531     this->checkpoint_->save_input_sections();
3532
3533   // The only thing we know about an input section is the object and
3534   // the section index.  We need the section name.  Recomputing this
3535   // is slow but this is an unusual case.  If this becomes a speed
3536   // problem we can cache the names as required in Layout::layout.
3537
3538   // We start by building a larger vector holding a copy of each
3539   // Input_section, plus its current index in the list and its name.
3540   std::vector<Input_section_sort_entry> sort_list;
3541
3542   unsigned int i = 0;
3543   for (Input_section_list::iterator p = this->input_sections_.begin();
3544        p != this->input_sections_.end();
3545        ++p, ++i)
3546       sort_list.push_back(Input_section_sort_entry(*p, i,
3547                             this->must_sort_attached_input_sections()));
3548
3549   // Sort the input sections.
3550   if (this->must_sort_attached_input_sections())
3551     {
3552       if (this->type() == elfcpp::SHT_PREINIT_ARRAY
3553           || this->type() == elfcpp::SHT_INIT_ARRAY
3554           || this->type() == elfcpp::SHT_FINI_ARRAY)
3555         std::sort(sort_list.begin(), sort_list.end(),
3556                   Input_section_sort_init_fini_compare());
3557       else
3558         std::sort(sort_list.begin(), sort_list.end(),
3559                   Input_section_sort_compare());
3560     }
3561   else
3562     {
3563       gold_assert(this->input_section_order_specified());
3564       std::sort(sort_list.begin(), sort_list.end(),
3565                 Input_section_sort_section_order_index_compare());
3566     }
3567
3568   // Copy the sorted input sections back to our list.
3569   this->input_sections_.clear();
3570   for (std::vector<Input_section_sort_entry>::iterator p = sort_list.begin();
3571        p != sort_list.end();
3572        ++p)
3573     this->input_sections_.push_back(p->input_section());
3574   sort_list.clear();
3575
3576   // Remember that we sorted the input sections, since we might get
3577   // called again.
3578   this->attached_input_sections_are_sorted_ = true;
3579 }
3580
3581 // Write the section header to *OSHDR.
3582
3583 template<int size, bool big_endian>
3584 void
3585 Output_section::write_header(const Layout* layout,
3586                              const Stringpool* secnamepool,
3587                              elfcpp::Shdr_write<size, big_endian>* oshdr) const
3588 {
3589   oshdr->put_sh_name(secnamepool->get_offset(this->name_));
3590   oshdr->put_sh_type(this->type_);
3591
3592   elfcpp::Elf_Xword flags = this->flags_;
3593   if (this->info_section_ != NULL && this->info_uses_section_index_)
3594     flags |= elfcpp::SHF_INFO_LINK;
3595   oshdr->put_sh_flags(flags);
3596
3597   oshdr->put_sh_addr(this->address());
3598   oshdr->put_sh_offset(this->offset());
3599   oshdr->put_sh_size(this->data_size());
3600   if (this->link_section_ != NULL)
3601     oshdr->put_sh_link(this->link_section_->out_shndx());
3602   else if (this->should_link_to_symtab_)
3603     oshdr->put_sh_link(layout->symtab_section_shndx());
3604   else if (this->should_link_to_dynsym_)
3605     oshdr->put_sh_link(layout->dynsym_section()->out_shndx());
3606   else
3607     oshdr->put_sh_link(this->link_);
3608
3609   elfcpp::Elf_Word info;
3610   if (this->info_section_ != NULL)
3611     {
3612       if (this->info_uses_section_index_)
3613         info = this->info_section_->out_shndx();
3614       else
3615         info = this->info_section_->symtab_index();
3616     }
3617   else if (this->info_symndx_ != NULL)
3618     info = this->info_symndx_->symtab_index();
3619   else
3620     info = this->info_;
3621   oshdr->put_sh_info(info);
3622
3623   oshdr->put_sh_addralign(this->addralign_);
3624   oshdr->put_sh_entsize(this->entsize_);
3625 }
3626
3627 // Write out the data.  For input sections the data is written out by
3628 // Object::relocate, but we have to handle Output_section_data objects
3629 // here.
3630
3631 void
3632 Output_section::do_write(Output_file* of)
3633 {
3634   gold_assert(!this->requires_postprocessing());
3635
3636   // If the target performs relaxation, we delay filler generation until now.
3637   gold_assert(!this->generate_code_fills_at_write_ || this->fills_.empty());
3638
3639   off_t output_section_file_offset = this->offset();
3640   for (Fill_list::iterator p = this->fills_.begin();
3641        p != this->fills_.end();
3642        ++p)
3643     {
3644       std::string fill_data(parameters->target().code_fill(p->length()));
3645       of->write(output_section_file_offset + p->section_offset(),
3646                 fill_data.data(), fill_data.size());
3647     }
3648
3649   off_t off = this->offset() + this->first_input_offset_;
3650   for (Input_section_list::iterator p = this->input_sections_.begin();
3651        p != this->input_sections_.end();
3652        ++p)
3653     {
3654       off_t aligned_off = align_address(off, p->addralign());
3655       if (this->generate_code_fills_at_write_ && (off != aligned_off))
3656         {
3657           size_t fill_len = aligned_off - off;
3658           std::string fill_data(parameters->target().code_fill(fill_len));
3659           of->write(off, fill_data.data(), fill_data.size());
3660         }
3661
3662       p->write(of);
3663       off = aligned_off + p->data_size();
3664     }
3665
3666   // For incremental links, fill in unused chunks in debug sections
3667   // with dummy compilation unit headers.
3668   if (this->free_space_fill_ != NULL)
3669     {
3670       for (Free_list::Const_iterator p = this->free_list_.begin();
3671            p != this->free_list_.end();
3672            ++p)
3673         {
3674           off_t off = p->start_;
3675           size_t len = p->end_ - off;
3676           this->free_space_fill_->write(of, this->offset() + off, len);
3677         }
3678       if (this->patch_space_ > 0)
3679         {
3680           off_t off = this->current_data_size_for_child() - this->patch_space_;
3681           this->free_space_fill_->write(of, this->offset() + off,
3682                                         this->patch_space_);
3683         }
3684     }
3685 }
3686
3687 // If a section requires postprocessing, create the buffer to use.
3688
3689 void
3690 Output_section::create_postprocessing_buffer()
3691 {
3692   gold_assert(this->requires_postprocessing());
3693
3694   if (this->postprocessing_buffer_ != NULL)
3695     return;
3696
3697   if (!this->input_sections_.empty())
3698     {
3699       off_t off = this->first_input_offset_;
3700       for (Input_section_list::iterator p = this->input_sections_.begin();
3701            p != this->input_sections_.end();
3702            ++p)
3703         {
3704           off = align_address(off, p->addralign());
3705           p->finalize_data_size();
3706           off += p->data_size();
3707         }
3708       this->set_current_data_size_for_child(off);
3709     }
3710
3711   off_t buffer_size = this->current_data_size_for_child();
3712   this->postprocessing_buffer_ = new unsigned char[buffer_size];
3713 }
3714
3715 // Write all the data of an Output_section into the postprocessing
3716 // buffer.  This is used for sections which require postprocessing,
3717 // such as compression.  Input sections are handled by
3718 // Object::Relocate.
3719
3720 void
3721 Output_section::write_to_postprocessing_buffer()
3722 {
3723   gold_assert(this->requires_postprocessing());
3724
3725   // If the target performs relaxation, we delay filler generation until now.
3726   gold_assert(!this->generate_code_fills_at_write_ || this->fills_.empty());
3727
3728   unsigned char* buffer = this->postprocessing_buffer();
3729   for (Fill_list::iterator p = this->fills_.begin();
3730        p != this->fills_.end();
3731        ++p)
3732     {
3733       std::string fill_data(parameters->target().code_fill(p->length()));
3734       memcpy(buffer + p->section_offset(), fill_data.data(),
3735              fill_data.size());
3736     }
3737
3738   off_t off = this->first_input_offset_;
3739   for (Input_section_list::iterator p = this->input_sections_.begin();
3740        p != this->input_sections_.end();
3741        ++p)
3742     {
3743       off_t aligned_off = align_address(off, p->addralign());
3744       if (this->generate_code_fills_at_write_ && (off != aligned_off))
3745         {
3746           size_t fill_len = aligned_off - off;
3747           std::string fill_data(parameters->target().code_fill(fill_len));
3748           memcpy(buffer + off, fill_data.data(), fill_data.size());
3749         }
3750
3751       p->write_to_buffer(buffer + aligned_off);
3752       off = aligned_off + p->data_size();
3753     }
3754 }
3755
3756 // Get the input sections for linker script processing.  We leave
3757 // behind the Output_section_data entries.  Note that this may be
3758 // slightly incorrect for merge sections.  We will leave them behind,
3759 // but it is possible that the script says that they should follow
3760 // some other input sections, as in:
3761 //    .rodata { *(.rodata) *(.rodata.cst*) }
3762 // For that matter, we don't handle this correctly:
3763 //    .rodata { foo.o(.rodata.cst*) *(.rodata.cst*) }
3764 // With luck this will never matter.
3765
3766 uint64_t
3767 Output_section::get_input_sections(
3768     uint64_t address,
3769     const std::string& fill,
3770     std::list<Input_section>* input_sections)
3771 {
3772   if (this->checkpoint_ != NULL
3773       && !this->checkpoint_->input_sections_saved())
3774     this->checkpoint_->save_input_sections();
3775
3776   // Invalidate fast look-up maps.
3777   this->lookup_maps_->invalidate();
3778
3779   uint64_t orig_address = address;
3780
3781   address = align_address(address, this->addralign());
3782
3783   Input_section_list remaining;
3784   for (Input_section_list::iterator p = this->input_sections_.begin();
3785        p != this->input_sections_.end();
3786        ++p)
3787     {
3788       if (p->is_input_section()
3789           || p->is_relaxed_input_section()
3790           || p->is_merge_section())
3791         input_sections->push_back(*p);
3792       else
3793         {
3794           uint64_t aligned_address = align_address(address, p->addralign());
3795           if (aligned_address != address && !fill.empty())
3796             {
3797               section_size_type length =
3798                 convert_to_section_size_type(aligned_address - address);
3799               std::string this_fill;
3800               this_fill.reserve(length);
3801               while (this_fill.length() + fill.length() <= length)
3802                 this_fill += fill;
3803               if (this_fill.length() < length)
3804                 this_fill.append(fill, 0, length - this_fill.length());
3805
3806               Output_section_data* posd = new Output_data_const(this_fill, 0);
3807               remaining.push_back(Input_section(posd));
3808             }
3809           address = aligned_address;
3810
3811           remaining.push_back(*p);
3812
3813           p->finalize_data_size();
3814           address += p->data_size();
3815         }
3816     }
3817
3818   this->input_sections_.swap(remaining);
3819   this->first_input_offset_ = 0;
3820
3821   uint64_t data_size = address - orig_address;
3822   this->set_current_data_size_for_child(data_size);
3823   return data_size;
3824 }
3825
3826 // Add a script input section.  SIS is an Output_section::Input_section,
3827 // which can be either a plain input section or a special input section like
3828 // a relaxed input section.  For a special input section, its size must be
3829 // finalized.
3830
3831 void
3832 Output_section::add_script_input_section(const Input_section& sis)
3833 {
3834   uint64_t data_size = sis.data_size();
3835   uint64_t addralign = sis.addralign();
3836   if (addralign > this->addralign_)
3837     this->addralign_ = addralign;
3838
3839   off_t offset_in_section = this->current_data_size_for_child();
3840   off_t aligned_offset_in_section = align_address(offset_in_section,
3841                                                   addralign);
3842
3843   this->set_current_data_size_for_child(aligned_offset_in_section
3844                                         + data_size);
3845
3846   this->input_sections_.push_back(sis);
3847
3848   // Update fast lookup maps if necessary. 
3849   if (this->lookup_maps_->is_valid())
3850     {
3851       if (sis.is_merge_section())
3852         {
3853           Output_merge_base* pomb = sis.output_merge_base();
3854           Merge_section_properties msp(pomb->is_string(), pomb->entsize(),
3855                                        pomb->addralign());
3856           this->lookup_maps_->add_merge_section(msp, pomb);
3857           for (Output_merge_base::Input_sections::const_iterator p =
3858                  pomb->input_sections_begin();
3859                p != pomb->input_sections_end();
3860                ++p)
3861             this->lookup_maps_->add_merge_input_section(p->first, p->second,
3862                                                         pomb);
3863         }
3864       else if (sis.is_relaxed_input_section())
3865         {
3866           Output_relaxed_input_section* poris = sis.relaxed_input_section();
3867           this->lookup_maps_->add_relaxed_input_section(poris->relobj(),
3868                                                         poris->shndx(), poris);
3869         }
3870     }
3871 }
3872
3873 // Save states for relaxation.
3874
3875 void
3876 Output_section::save_states()
3877 {
3878   gold_assert(this->checkpoint_ == NULL);
3879   Checkpoint_output_section* checkpoint =
3880     new Checkpoint_output_section(this->addralign_, this->flags_,
3881                                   this->input_sections_,
3882                                   this->first_input_offset_,
3883                                   this->attached_input_sections_are_sorted_);
3884   this->checkpoint_ = checkpoint;
3885   gold_assert(this->fills_.empty());
3886 }
3887
3888 void
3889 Output_section::discard_states()
3890 {
3891   gold_assert(this->checkpoint_ != NULL);
3892   delete this->checkpoint_;
3893   this->checkpoint_ = NULL;
3894   gold_assert(this->fills_.empty());
3895
3896   // Simply invalidate the fast lookup maps since we do not keep
3897   // track of them.
3898   this->lookup_maps_->invalidate();
3899 }
3900
3901 void
3902 Output_section::restore_states()
3903 {
3904   gold_assert(this->checkpoint_ != NULL);
3905   Checkpoint_output_section* checkpoint = this->checkpoint_;
3906
3907   this->addralign_ = checkpoint->addralign();
3908   this->flags_ = checkpoint->flags();
3909   this->first_input_offset_ = checkpoint->first_input_offset();
3910
3911   if (!checkpoint->input_sections_saved())
3912     {
3913       // If we have not copied the input sections, just resize it.
3914       size_t old_size = checkpoint->input_sections_size();
3915       gold_assert(this->input_sections_.size() >= old_size);
3916       this->input_sections_.resize(old_size);
3917     }
3918   else
3919     {
3920       // We need to copy the whole list.  This is not efficient for
3921       // extremely large output with hundreads of thousands of input
3922       // objects.  We may need to re-think how we should pass sections
3923       // to scripts.
3924       this->input_sections_ = *checkpoint->input_sections();
3925     }
3926
3927   this->attached_input_sections_are_sorted_ =
3928     checkpoint->attached_input_sections_are_sorted();
3929
3930   // Simply invalidate the fast lookup maps since we do not keep
3931   // track of them.
3932   this->lookup_maps_->invalidate();
3933 }
3934
3935 // Update the section offsets of input sections in this.  This is required if
3936 // relaxation causes some input sections to change sizes.
3937
3938 void
3939 Output_section::adjust_section_offsets()
3940 {
3941   if (!this->section_offsets_need_adjustment_)
3942     return;
3943
3944   off_t off = 0;
3945   for (Input_section_list::iterator p = this->input_sections_.begin();
3946        p != this->input_sections_.end();
3947        ++p)
3948     {
3949       off = align_address(off, p->addralign());
3950       if (p->is_input_section())
3951         p->relobj()->set_section_offset(p->shndx(), off);
3952       off += p->data_size();
3953     }
3954
3955   this->section_offsets_need_adjustment_ = false;
3956 }
3957
3958 // Print to the map file.
3959
3960 void
3961 Output_section::do_print_to_mapfile(Mapfile* mapfile) const
3962 {
3963   mapfile->print_output_section(this);
3964
3965   for (Input_section_list::const_iterator p = this->input_sections_.begin();
3966        p != this->input_sections_.end();
3967        ++p)
3968     p->print_to_mapfile(mapfile);
3969 }
3970
3971 // Print stats for merge sections to stderr.
3972
3973 void
3974 Output_section::print_merge_stats()
3975 {
3976   Input_section_list::iterator p;
3977   for (p = this->input_sections_.begin();
3978        p != this->input_sections_.end();
3979        ++p)
3980     p->print_merge_stats(this->name_);
3981 }
3982
3983 // Set a fixed layout for the section.  Used for incremental update links.
3984
3985 void
3986 Output_section::set_fixed_layout(uint64_t sh_addr, off_t sh_offset,
3987                                  off_t sh_size, uint64_t sh_addralign)
3988 {
3989   this->addralign_ = sh_addralign;
3990   this->set_current_data_size(sh_size);
3991   if ((this->flags_ & elfcpp::SHF_ALLOC) != 0)
3992     this->set_address(sh_addr);
3993   this->set_file_offset(sh_offset);
3994   this->finalize_data_size();
3995   this->free_list_.init(sh_size, false);
3996   this->has_fixed_layout_ = true;
3997 }
3998
3999 // Reserve space within the fixed layout for the section.  Used for
4000 // incremental update links.
4001
4002 void
4003 Output_section::reserve(uint64_t sh_offset, uint64_t sh_size)
4004 {
4005   this->free_list_.remove(sh_offset, sh_offset + sh_size);
4006 }
4007
4008 // Allocate space from the free list for the section.  Used for
4009 // incremental update links.
4010
4011 off_t
4012 Output_section::allocate(off_t len, uint64_t addralign)
4013 {
4014   return this->free_list_.allocate(len, addralign, 0);
4015 }
4016
4017 // Output segment methods.
4018
4019 Output_segment::Output_segment(elfcpp::Elf_Word type, elfcpp::Elf_Word flags)
4020   : vaddr_(0),
4021     paddr_(0),
4022     memsz_(0),
4023     max_align_(0),
4024     min_p_align_(0),
4025     offset_(0),
4026     filesz_(0),
4027     type_(type),
4028     flags_(flags),
4029     is_max_align_known_(false),
4030     are_addresses_set_(false),
4031     is_large_data_segment_(false),
4032     is_unique_segment_(false)
4033 {
4034   // The ELF ABI specifies that a PT_TLS segment always has PF_R as
4035   // the flags.
4036   if (type == elfcpp::PT_TLS)
4037     this->flags_ = elfcpp::PF_R;
4038 }
4039
4040 // Add an Output_section to a PT_LOAD Output_segment.
4041
4042 void
4043 Output_segment::add_output_section_to_load(Layout* layout,
4044                                            Output_section* os,
4045                                            elfcpp::Elf_Word seg_flags)
4046 {
4047   gold_assert(this->type() == elfcpp::PT_LOAD);
4048   gold_assert((os->flags() & elfcpp::SHF_ALLOC) != 0);
4049   gold_assert(!this->is_max_align_known_);
4050   gold_assert(os->is_large_data_section() == this->is_large_data_segment());
4051
4052   this->update_flags_for_output_section(seg_flags);
4053
4054   // We don't want to change the ordering if we have a linker script
4055   // with a SECTIONS clause.
4056   Output_section_order order = os->order();
4057   if (layout->script_options()->saw_sections_clause())
4058     order = static_cast<Output_section_order>(0);
4059   else
4060     gold_assert(order != ORDER_INVALID);
4061
4062   this->output_lists_[order].push_back(os);
4063 }
4064
4065 // Add an Output_section to a non-PT_LOAD Output_segment.
4066
4067 void
4068 Output_segment::add_output_section_to_nonload(Output_section* os,
4069                                               elfcpp::Elf_Word seg_flags)
4070 {
4071   gold_assert(this->type() != elfcpp::PT_LOAD);
4072   gold_assert((os->flags() & elfcpp::SHF_ALLOC) != 0);
4073   gold_assert(!this->is_max_align_known_);
4074
4075   this->update_flags_for_output_section(seg_flags);
4076
4077   this->output_lists_[0].push_back(os);
4078 }
4079
4080 // Remove an Output_section from this segment.  It is an error if it
4081 // is not present.
4082
4083 void
4084 Output_segment::remove_output_section(Output_section* os)
4085 {
4086   for (int i = 0; i < static_cast<int>(ORDER_MAX); ++i)
4087     {
4088       Output_data_list* pdl = &this->output_lists_[i];
4089       for (Output_data_list::iterator p = pdl->begin(); p != pdl->end(); ++p)
4090         {
4091           if (*p == os)
4092             {
4093               pdl->erase(p);
4094               return;
4095             }
4096         }
4097     }
4098   gold_unreachable();
4099 }
4100
4101 // Add an Output_data (which need not be an Output_section) to the
4102 // start of a segment.
4103
4104 void
4105 Output_segment::add_initial_output_data(Output_data* od)
4106 {
4107   gold_assert(!this->is_max_align_known_);
4108   Output_data_list::iterator p = this->output_lists_[0].begin();
4109   this->output_lists_[0].insert(p, od);
4110 }
4111
4112 // Return true if this segment has any sections which hold actual
4113 // data, rather than being a BSS section.
4114
4115 bool
4116 Output_segment::has_any_data_sections() const
4117 {
4118   for (int i = 0; i < static_cast<int>(ORDER_MAX); ++i)
4119     {
4120       const Output_data_list* pdl = &this->output_lists_[i];
4121       for (Output_data_list::const_iterator p = pdl->begin();
4122            p != pdl->end();
4123            ++p)
4124         {
4125           if (!(*p)->is_section())
4126             return true;
4127           if ((*p)->output_section()->type() != elfcpp::SHT_NOBITS)
4128             return true;
4129         }
4130     }
4131   return false;
4132 }
4133
4134 // Return whether the first data section (not counting TLS sections)
4135 // is a relro section.
4136
4137 bool
4138 Output_segment::is_first_section_relro() const
4139 {
4140   for (int i = 0; i < static_cast<int>(ORDER_MAX); ++i)
4141     {
4142       if (i == static_cast<int>(ORDER_TLS_DATA)
4143           || i == static_cast<int>(ORDER_TLS_BSS))
4144         continue;
4145       const Output_data_list* pdl = &this->output_lists_[i];
4146       if (!pdl->empty())
4147         {
4148           Output_data* p = pdl->front();
4149           return p->is_section() && p->output_section()->is_relro();
4150         }
4151     }
4152   return false;
4153 }
4154
4155 // Return the maximum alignment of the Output_data in Output_segment.
4156
4157 uint64_t
4158 Output_segment::maximum_alignment()
4159 {
4160   if (!this->is_max_align_known_)
4161     {
4162       for (int i = 0; i < static_cast<int>(ORDER_MAX); ++i)
4163         {       
4164           const Output_data_list* pdl = &this->output_lists_[i];
4165           uint64_t addralign = Output_segment::maximum_alignment_list(pdl);
4166           if (addralign > this->max_align_)
4167             this->max_align_ = addralign;
4168         }
4169       this->is_max_align_known_ = true;
4170     }
4171
4172   return this->max_align_;
4173 }
4174
4175 // Return the maximum alignment of a list of Output_data.
4176
4177 uint64_t
4178 Output_segment::maximum_alignment_list(const Output_data_list* pdl)
4179 {
4180   uint64_t ret = 0;
4181   for (Output_data_list::const_iterator p = pdl->begin();
4182        p != pdl->end();
4183        ++p)
4184     {
4185       uint64_t addralign = (*p)->addralign();
4186       if (addralign > ret)
4187         ret = addralign;
4188     }
4189   return ret;
4190 }
4191
4192 // Return whether this segment has any dynamic relocs.
4193
4194 bool
4195 Output_segment::has_dynamic_reloc() const
4196 {
4197   for (int i = 0; i < static_cast<int>(ORDER_MAX); ++i)
4198     if (this->has_dynamic_reloc_list(&this->output_lists_[i]))
4199       return true;
4200   return false;
4201 }
4202
4203 // Return whether this Output_data_list has any dynamic relocs.
4204
4205 bool
4206 Output_segment::has_dynamic_reloc_list(const Output_data_list* pdl) const
4207 {
4208   for (Output_data_list::const_iterator p = pdl->begin();
4209        p != pdl->end();
4210        ++p)
4211     if ((*p)->has_dynamic_reloc())
4212       return true;
4213   return false;
4214 }
4215
4216 // Set the section addresses for an Output_segment.  If RESET is true,
4217 // reset the addresses first.  ADDR is the address and *POFF is the
4218 // file offset.  Set the section indexes starting with *PSHNDX.
4219 // INCREASE_RELRO is the size of the portion of the first non-relro
4220 // section that should be included in the PT_GNU_RELRO segment.
4221 // If this segment has relro sections, and has been aligned for
4222 // that purpose, set *HAS_RELRO to TRUE.  Return the address of
4223 // the immediately following segment.  Update *HAS_RELRO, *POFF,
4224 // and *PSHNDX.
4225
4226 uint64_t
4227 Output_segment::set_section_addresses(Layout* layout, bool reset,
4228                                       uint64_t addr,
4229                                       unsigned int* increase_relro,
4230                                       bool* has_relro,
4231                                       off_t* poff,
4232                                       unsigned int* pshndx)
4233 {
4234   gold_assert(this->type_ == elfcpp::PT_LOAD);
4235
4236   uint64_t last_relro_pad = 0;
4237   off_t orig_off = *poff;
4238
4239   bool in_tls = false;
4240
4241   // If we have relro sections, we need to pad forward now so that the
4242   // relro sections plus INCREASE_RELRO end on an abi page boundary.
4243   if (parameters->options().relro()
4244       && this->is_first_section_relro()
4245       && (!this->are_addresses_set_ || reset))
4246     {
4247       uint64_t relro_size = 0;
4248       off_t off = *poff;
4249       uint64_t max_align = 0;
4250       for (int i = 0; i <= static_cast<int>(ORDER_RELRO_LAST); ++i)
4251         {
4252           Output_data_list* pdl = &this->output_lists_[i];
4253           Output_data_list::iterator p;
4254           for (p = pdl->begin(); p != pdl->end(); ++p)
4255             {
4256               if (!(*p)->is_section())
4257                 break;
4258               uint64_t align = (*p)->addralign();
4259               if (align > max_align)
4260                 max_align = align;
4261               if ((*p)->is_section_flag_set(elfcpp::SHF_TLS))
4262                 in_tls = true;
4263               else if (in_tls)
4264                 {
4265                   // Align the first non-TLS section to the alignment
4266                   // of the TLS segment.
4267                   align = max_align;
4268                   in_tls = false;
4269                 }
4270               relro_size = align_address(relro_size, align);
4271               // Ignore the size of the .tbss section.
4272               if ((*p)->is_section_flag_set(elfcpp::SHF_TLS)
4273                   && (*p)->is_section_type(elfcpp::SHT_NOBITS))
4274                 continue;
4275               if ((*p)->is_address_valid())
4276                 relro_size += (*p)->data_size();
4277               else
4278                 {
4279                   // FIXME: This could be faster.
4280                   (*p)->set_address_and_file_offset(addr + relro_size,
4281                                                     off + relro_size);
4282                   relro_size += (*p)->data_size();
4283                   (*p)->reset_address_and_file_offset();
4284                 }
4285             }
4286           if (p != pdl->end())
4287             break;
4288         }
4289       relro_size += *increase_relro;
4290       // Pad the total relro size to a multiple of the maximum
4291       // section alignment seen.
4292       uint64_t aligned_size = align_address(relro_size, max_align);
4293       // Note the amount of padding added after the last relro section.
4294       last_relro_pad = aligned_size - relro_size;
4295       *has_relro = true;
4296
4297       uint64_t page_align = parameters->target().abi_pagesize();
4298
4299       // Align to offset N such that (N + RELRO_SIZE) % PAGE_ALIGN == 0.
4300       uint64_t desired_align = page_align - (aligned_size % page_align);
4301       if (desired_align < *poff % page_align)
4302         *poff += page_align - *poff % page_align;
4303       *poff += desired_align - *poff % page_align;
4304       addr += *poff - orig_off;
4305       orig_off = *poff;
4306     }
4307
4308   if (!reset && this->are_addresses_set_)
4309     {
4310       gold_assert(this->paddr_ == addr);
4311       addr = this->vaddr_;
4312     }
4313   else
4314     {
4315       this->vaddr_ = addr;
4316       this->paddr_ = addr;
4317       this->are_addresses_set_ = true;
4318     }
4319
4320   in_tls = false;
4321
4322   this->offset_ = orig_off;
4323
4324   off_t off = 0;
4325   uint64_t ret;
4326   for (int i = 0; i < static_cast<int>(ORDER_MAX); ++i)
4327     {
4328       if (i == static_cast<int>(ORDER_RELRO_LAST))
4329         {
4330           *poff += last_relro_pad;
4331           addr += last_relro_pad;
4332           if (this->output_lists_[i].empty())
4333             {
4334               // If there is nothing in the ORDER_RELRO_LAST list,
4335               // the padding will occur at the end of the relro
4336               // segment, and we need to add it to *INCREASE_RELRO.
4337               *increase_relro += last_relro_pad;
4338             }
4339         }
4340       addr = this->set_section_list_addresses(layout, reset,
4341                                               &this->output_lists_[i],
4342                                               addr, poff, pshndx, &in_tls);
4343       if (i < static_cast<int>(ORDER_SMALL_BSS))
4344         {
4345           this->filesz_ = *poff - orig_off;
4346           off = *poff;
4347         }
4348
4349       ret = addr;
4350     }
4351
4352   // If the last section was a TLS section, align upward to the
4353   // alignment of the TLS segment, so that the overall size of the TLS
4354   // segment is aligned.
4355   if (in_tls)
4356     {
4357       uint64_t segment_align = layout->tls_segment()->maximum_alignment();
4358       *poff = align_address(*poff, segment_align);
4359     }
4360
4361   this->memsz_ = *poff - orig_off;
4362
4363   // Ignore the file offset adjustments made by the BSS Output_data
4364   // objects.
4365   *poff = off;
4366
4367   return ret;
4368 }
4369
4370 // Set the addresses and file offsets in a list of Output_data
4371 // structures.
4372
4373 uint64_t
4374 Output_segment::set_section_list_addresses(Layout* layout, bool reset,
4375                                            Output_data_list* pdl,
4376                                            uint64_t addr, off_t* poff,
4377                                            unsigned int* pshndx,
4378                                            bool* in_tls)
4379 {
4380   off_t startoff = *poff;
4381   // For incremental updates, we may allocate non-fixed sections from
4382   // free space in the file.  This keeps track of the high-water mark.
4383   off_t maxoff = startoff;
4384
4385   off_t off = startoff;
4386   for (Output_data_list::iterator p = pdl->begin();
4387        p != pdl->end();
4388        ++p)
4389     {
4390       if (reset)
4391         (*p)->reset_address_and_file_offset();
4392
4393       // When doing an incremental update or when using a linker script,
4394       // the section will most likely already have an address.
4395       if (!(*p)->is_address_valid())
4396         {
4397           uint64_t align = (*p)->addralign();
4398
4399           if ((*p)->is_section_flag_set(elfcpp::SHF_TLS))
4400             {
4401               // Give the first TLS section the alignment of the
4402               // entire TLS segment.  Otherwise the TLS segment as a
4403               // whole may be misaligned.
4404               if (!*in_tls)
4405                 {
4406                   Output_segment* tls_segment = layout->tls_segment();
4407                   gold_assert(tls_segment != NULL);
4408                   uint64_t segment_align = tls_segment->maximum_alignment();
4409                   gold_assert(segment_align >= align);
4410                   align = segment_align;
4411
4412                   *in_tls = true;
4413                 }
4414             }
4415           else
4416             {
4417               // If this is the first section after the TLS segment,
4418               // align it to at least the alignment of the TLS
4419               // segment, so that the size of the overall TLS segment
4420               // is aligned.
4421               if (*in_tls)
4422                 {
4423                   uint64_t segment_align =
4424                       layout->tls_segment()->maximum_alignment();
4425                   if (segment_align > align)
4426                     align = segment_align;
4427
4428                   *in_tls = false;
4429                 }
4430             }
4431
4432           if (!parameters->incremental_update())
4433             {
4434               off = align_address(off, align);
4435               (*p)->set_address_and_file_offset(addr + (off - startoff), off);
4436             }
4437           else
4438             {
4439               // Incremental update: allocate file space from free list.
4440               (*p)->pre_finalize_data_size();
4441               off_t current_size = (*p)->current_data_size();
4442               off = layout->allocate(current_size, align, startoff);
4443               if (off == -1)
4444                 {
4445                   gold_assert((*p)->output_section() != NULL);
4446                   gold_fallback(_("out of patch space for section %s; "
4447                                   "relink with --incremental-full"),
4448                                 (*p)->output_section()->name());
4449                 }
4450               (*p)->set_address_and_file_offset(addr + (off - startoff), off);
4451               if ((*p)->data_size() > current_size)
4452                 {
4453                   gold_assert((*p)->output_section() != NULL);
4454                   gold_fallback(_("%s: section changed size; "
4455                                   "relink with --incremental-full"),
4456                                 (*p)->output_section()->name());
4457                 }
4458             }
4459         }
4460       else if (parameters->incremental_update())
4461         {
4462           // For incremental updates, use the fixed offset for the
4463           // high-water mark computation.
4464           off = (*p)->offset();
4465         }
4466       else
4467         {
4468           // The script may have inserted a skip forward, but it
4469           // better not have moved backward.
4470           if ((*p)->address() >= addr + (off - startoff))
4471             off += (*p)->address() - (addr + (off - startoff));
4472           else
4473             {
4474               if (!layout->script_options()->saw_sections_clause())
4475                 gold_unreachable();
4476               else
4477                 {
4478                   Output_section* os = (*p)->output_section();
4479
4480                   // Cast to unsigned long long to avoid format warnings.
4481                   unsigned long long previous_dot =
4482                     static_cast<unsigned long long>(addr + (off - startoff));
4483                   unsigned long long dot =
4484                     static_cast<unsigned long long>((*p)->address());
4485
4486                   if (os == NULL)
4487                     gold_error(_("dot moves backward in linker script "
4488                                  "from 0x%llx to 0x%llx"), previous_dot, dot);
4489                   else
4490                     gold_error(_("address of section '%s' moves backward "
4491                                  "from 0x%llx to 0x%llx"),
4492                                os->name(), previous_dot, dot);
4493                 }
4494             }
4495           (*p)->set_file_offset(off);
4496           (*p)->finalize_data_size();
4497         }
4498
4499       if (parameters->incremental_update())
4500         gold_debug(DEBUG_INCREMENTAL,
4501                    "set_section_list_addresses: %08lx %08lx %s",
4502                    static_cast<long>(off),
4503                    static_cast<long>((*p)->data_size()),
4504                    ((*p)->output_section() != NULL
4505                     ? (*p)->output_section()->name() : "(special)"));
4506
4507       // We want to ignore the size of a SHF_TLS SHT_NOBITS
4508       // section.  Such a section does not affect the size of a
4509       // PT_LOAD segment.
4510       if (!(*p)->is_section_flag_set(elfcpp::SHF_TLS)
4511           || !(*p)->is_section_type(elfcpp::SHT_NOBITS))
4512         off += (*p)->data_size();
4513
4514       if (off > maxoff)
4515         maxoff = off;
4516
4517       if ((*p)->is_section())
4518         {
4519           (*p)->set_out_shndx(*pshndx);
4520           ++*pshndx;
4521         }
4522     }
4523
4524   *poff = maxoff;
4525   return addr + (maxoff - startoff);
4526 }
4527
4528 // For a non-PT_LOAD segment, set the offset from the sections, if
4529 // any.  Add INCREASE to the file size and the memory size.
4530
4531 void
4532 Output_segment::set_offset(unsigned int increase)
4533 {
4534   gold_assert(this->type_ != elfcpp::PT_LOAD);
4535
4536   gold_assert(!this->are_addresses_set_);
4537
4538   // A non-load section only uses output_lists_[0].
4539
4540   Output_data_list* pdl = &this->output_lists_[0];
4541
4542   if (pdl->empty())
4543     {
4544       gold_assert(increase == 0);
4545       this->vaddr_ = 0;
4546       this->paddr_ = 0;
4547       this->are_addresses_set_ = true;
4548       this->memsz_ = 0;
4549       this->min_p_align_ = 0;
4550       this->offset_ = 0;
4551       this->filesz_ = 0;
4552       return;
4553     }
4554
4555   // Find the first and last section by address.
4556   const Output_data* first = NULL;
4557   const Output_data* last_data = NULL;
4558   const Output_data* last_bss = NULL;
4559   for (Output_data_list::const_iterator p = pdl->begin();
4560        p != pdl->end();
4561        ++p)
4562     {
4563       if (first == NULL
4564           || (*p)->address() < first->address()
4565           || ((*p)->address() == first->address()
4566               && (*p)->data_size() < first->data_size()))
4567         first = *p;
4568       const Output_data** plast;
4569       if ((*p)->is_section()
4570           && (*p)->output_section()->type() == elfcpp::SHT_NOBITS)
4571         plast = &last_bss;
4572       else
4573         plast = &last_data;
4574       if (*plast == NULL
4575           || (*p)->address() > (*plast)->address()
4576           || ((*p)->address() == (*plast)->address()
4577               && (*p)->data_size() > (*plast)->data_size()))
4578         *plast = *p;
4579     }
4580
4581   this->vaddr_ = first->address();
4582   this->paddr_ = (first->has_load_address()
4583                   ? first->load_address()
4584                   : this->vaddr_);
4585   this->are_addresses_set_ = true;
4586   this->offset_ = first->offset();
4587
4588   if (last_data == NULL)
4589     this->filesz_ = 0;
4590   else
4591     this->filesz_ = (last_data->address()
4592                      + last_data->data_size()
4593                      - this->vaddr_);
4594
4595   const Output_data* last = last_bss != NULL ? last_bss : last_data;
4596   this->memsz_ = (last->address()
4597                   + last->data_size()
4598                   - this->vaddr_);
4599
4600   this->filesz_ += increase;
4601   this->memsz_ += increase;
4602
4603   // If this is a RELRO segment, verify that the segment ends at a
4604   // page boundary.
4605   if (this->type_ == elfcpp::PT_GNU_RELRO)
4606     {
4607       uint64_t page_align = parameters->target().abi_pagesize();
4608       uint64_t segment_end = this->vaddr_ + this->memsz_;
4609       if (parameters->incremental_update())
4610         {
4611           // The INCREASE_RELRO calculation is bypassed for an incremental
4612           // update, so we need to adjust the segment size manually here.
4613           segment_end = align_address(segment_end, page_align);
4614           this->memsz_ = segment_end - this->vaddr_;
4615         }
4616       else
4617         gold_assert(segment_end == align_address(segment_end, page_align));
4618     }
4619
4620   // If this is a TLS segment, align the memory size.  The code in
4621   // set_section_list ensures that the section after the TLS segment
4622   // is aligned to give us room.
4623   if (this->type_ == elfcpp::PT_TLS)
4624     {
4625       uint64_t segment_align = this->maximum_alignment();
4626       gold_assert(this->vaddr_ == align_address(this->vaddr_, segment_align));
4627       this->memsz_ = align_address(this->memsz_, segment_align);
4628     }
4629 }
4630
4631 // Set the TLS offsets of the sections in the PT_TLS segment.
4632
4633 void
4634 Output_segment::set_tls_offsets()
4635 {
4636   gold_assert(this->type_ == elfcpp::PT_TLS);
4637
4638   for (Output_data_list::iterator p = this->output_lists_[0].begin();
4639        p != this->output_lists_[0].end();
4640        ++p)
4641     (*p)->set_tls_offset(this->vaddr_);
4642 }
4643
4644 // Return the first section.
4645
4646 Output_section*
4647 Output_segment::first_section() const
4648 {
4649   for (int i = 0; i < static_cast<int>(ORDER_MAX); ++i)
4650     {
4651       const Output_data_list* pdl = &this->output_lists_[i];
4652       for (Output_data_list::const_iterator p = pdl->begin();
4653            p != pdl->end();
4654            ++p)
4655         {
4656           if ((*p)->is_section())
4657             return (*p)->output_section();
4658         }
4659     }
4660   gold_unreachable();
4661 }
4662
4663 // Return the number of Output_sections in an Output_segment.
4664
4665 unsigned int
4666 Output_segment::output_section_count() const
4667 {
4668   unsigned int ret = 0;
4669   for (int i = 0; i < static_cast<int>(ORDER_MAX); ++i)
4670     ret += this->output_section_count_list(&this->output_lists_[i]);
4671   return ret;
4672 }
4673
4674 // Return the number of Output_sections in an Output_data_list.
4675
4676 unsigned int
4677 Output_segment::output_section_count_list(const Output_data_list* pdl) const
4678 {
4679   unsigned int count = 0;
4680   for (Output_data_list::const_iterator p = pdl->begin();
4681        p != pdl->end();
4682        ++p)
4683     {
4684       if ((*p)->is_section())
4685         ++count;
4686     }
4687   return count;
4688 }
4689
4690 // Return the section attached to the list segment with the lowest
4691 // load address.  This is used when handling a PHDRS clause in a
4692 // linker script.
4693
4694 Output_section*
4695 Output_segment::section_with_lowest_load_address() const
4696 {
4697   Output_section* found = NULL;
4698   uint64_t found_lma = 0;
4699   for (int i = 0; i < static_cast<int>(ORDER_MAX); ++i)
4700     this->lowest_load_address_in_list(&this->output_lists_[i], &found,
4701                                       &found_lma);
4702   return found;
4703 }
4704
4705 // Look through a list for a section with a lower load address.
4706
4707 void
4708 Output_segment::lowest_load_address_in_list(const Output_data_list* pdl,
4709                                             Output_section** found,
4710                                             uint64_t* found_lma) const
4711 {
4712   for (Output_data_list::const_iterator p = pdl->begin();
4713        p != pdl->end();
4714        ++p)
4715     {
4716       if (!(*p)->is_section())
4717         continue;
4718       Output_section* os = static_cast<Output_section*>(*p);
4719       uint64_t lma = (os->has_load_address()
4720                       ? os->load_address()
4721                       : os->address());
4722       if (*found == NULL || lma < *found_lma)
4723         {
4724           *found = os;
4725           *found_lma = lma;
4726         }
4727     }
4728 }
4729
4730 // Write the segment data into *OPHDR.
4731
4732 template<int size, bool big_endian>
4733 void
4734 Output_segment::write_header(elfcpp::Phdr_write<size, big_endian>* ophdr)
4735 {
4736   ophdr->put_p_type(this->type_);
4737   ophdr->put_p_offset(this->offset_);
4738   ophdr->put_p_vaddr(this->vaddr_);
4739   ophdr->put_p_paddr(this->paddr_);
4740   ophdr->put_p_filesz(this->filesz_);
4741   ophdr->put_p_memsz(this->memsz_);
4742   ophdr->put_p_flags(this->flags_);
4743   ophdr->put_p_align(std::max(this->min_p_align_, this->maximum_alignment()));
4744 }
4745
4746 // Write the section headers into V.
4747
4748 template<int size, bool big_endian>
4749 unsigned char*
4750 Output_segment::write_section_headers(const Layout* layout,
4751                                       const Stringpool* secnamepool,
4752                                       unsigned char* v,
4753                                       unsigned int* pshndx) const
4754 {
4755   // Every section that is attached to a segment must be attached to a
4756   // PT_LOAD segment, so we only write out section headers for PT_LOAD
4757   // segments.
4758   if (this->type_ != elfcpp::PT_LOAD)
4759     return v;
4760
4761   for (int i = 0; i < static_cast<int>(ORDER_MAX); ++i)
4762     {
4763       const Output_data_list* pdl = &this->output_lists_[i];
4764       v = this->write_section_headers_list<size, big_endian>(layout,
4765                                                              secnamepool,
4766                                                              pdl,
4767                                                              v, pshndx);
4768     }
4769
4770   return v;
4771 }
4772
4773 template<int size, bool big_endian>
4774 unsigned char*
4775 Output_segment::write_section_headers_list(const Layout* layout,
4776                                            const Stringpool* secnamepool,
4777                                            const Output_data_list* pdl,
4778                                            unsigned char* v,
4779                                            unsigned int* pshndx) const
4780 {
4781   const int shdr_size = elfcpp::Elf_sizes<size>::shdr_size;
4782   for (Output_data_list::const_iterator p = pdl->begin();
4783        p != pdl->end();
4784        ++p)
4785     {
4786       if ((*p)->is_section())
4787         {
4788           const Output_section* ps = static_cast<const Output_section*>(*p);
4789           gold_assert(*pshndx == ps->out_shndx());
4790           elfcpp::Shdr_write<size, big_endian> oshdr(v);
4791           ps->write_header(layout, secnamepool, &oshdr);
4792           v += shdr_size;
4793           ++*pshndx;
4794         }
4795     }
4796   return v;
4797 }
4798
4799 // Print the output sections to the map file.
4800
4801 void
4802 Output_segment::print_sections_to_mapfile(Mapfile* mapfile) const
4803 {
4804   if (this->type() != elfcpp::PT_LOAD)
4805     return;
4806   for (int i = 0; i < static_cast<int>(ORDER_MAX); ++i)
4807     this->print_section_list_to_mapfile(mapfile, &this->output_lists_[i]);
4808 }
4809
4810 // Print an output section list to the map file.
4811
4812 void
4813 Output_segment::print_section_list_to_mapfile(Mapfile* mapfile,
4814                                               const Output_data_list* pdl) const
4815 {
4816   for (Output_data_list::const_iterator p = pdl->begin();
4817        p != pdl->end();
4818        ++p)
4819     (*p)->print_to_mapfile(mapfile);
4820 }
4821
4822 // Output_file methods.
4823
4824 Output_file::Output_file(const char* name)
4825   : name_(name),
4826     o_(-1),
4827     file_size_(0),
4828     base_(NULL),
4829     map_is_anonymous_(false),
4830     map_is_allocated_(false),
4831     is_temporary_(false)
4832 {
4833 }
4834
4835 // Try to open an existing file.  Returns false if the file doesn't
4836 // exist, has a size of 0 or can't be mmapped.  If BASE_NAME is not
4837 // NULL, open that file as the base for incremental linking, and
4838 // copy its contents to the new output file.  This routine can
4839 // be called for incremental updates, in which case WRITABLE should
4840 // be true, or by the incremental-dump utility, in which case
4841 // WRITABLE should be false.
4842
4843 bool
4844 Output_file::open_base_file(const char* base_name, bool writable)
4845 {
4846   // The name "-" means "stdout".
4847   if (strcmp(this->name_, "-") == 0)
4848     return false;
4849
4850   bool use_base_file = base_name != NULL;
4851   if (!use_base_file)
4852     base_name = this->name_;
4853   else if (strcmp(base_name, this->name_) == 0)
4854     gold_fatal(_("%s: incremental base and output file name are the same"),
4855                base_name);
4856
4857   // Don't bother opening files with a size of zero.
4858   struct stat s;
4859   if (::stat(base_name, &s) != 0)
4860     {
4861       gold_info(_("%s: stat: %s"), base_name, strerror(errno));
4862       return false;
4863     }
4864   if (s.st_size == 0)
4865     {
4866       gold_info(_("%s: incremental base file is empty"), base_name);
4867       return false;
4868     }
4869
4870   // If we're using a base file, we want to open it read-only.
4871   if (use_base_file)
4872     writable = false;
4873
4874   int oflags = writable ? O_RDWR : O_RDONLY;
4875   int o = open_descriptor(-1, base_name, oflags, 0);
4876   if (o < 0)
4877     {
4878       gold_info(_("%s: open: %s"), base_name, strerror(errno));
4879       return false;
4880     }
4881
4882   // If the base file and the output file are different, open a
4883   // new output file and read the contents from the base file into
4884   // the newly-mapped region.
4885   if (use_base_file)
4886     {
4887       this->open(s.st_size);
4888       ssize_t bytes_to_read = s.st_size;
4889       unsigned char* p = this->base_;
4890       while (bytes_to_read > 0)
4891         {
4892           ssize_t len = ::read(o, p, bytes_to_read);
4893           if (len < 0)
4894             {
4895               gold_info(_("%s: read failed: %s"), base_name, strerror(errno));
4896               return false;
4897             }
4898           if (len == 0)
4899             {
4900               gold_info(_("%s: file too short: read only %lld of %lld bytes"),
4901                         base_name,
4902                         static_cast<long long>(s.st_size - bytes_to_read),
4903                         static_cast<long long>(s.st_size));
4904               return false;
4905             }
4906           p += len;
4907           bytes_to_read -= len;
4908         }
4909       ::close(o);
4910       return true;
4911     }
4912
4913   this->o_ = o;
4914   this->file_size_ = s.st_size;
4915
4916   if (!this->map_no_anonymous(writable))
4917     {
4918       release_descriptor(o, true);
4919       this->o_ = -1;
4920       this->file_size_ = 0;
4921       return false;
4922     }
4923
4924   return true;
4925 }
4926
4927 // Open the output file.
4928
4929 void
4930 Output_file::open(off_t file_size)
4931 {
4932   this->file_size_ = file_size;
4933
4934   // Unlink the file first; otherwise the open() may fail if the file
4935   // is busy (e.g. it's an executable that's currently being executed).
4936   //
4937   // However, the linker may be part of a system where a zero-length
4938   // file is created for it to write to, with tight permissions (gcc
4939   // 2.95 did something like this).  Unlinking the file would work
4940   // around those permission controls, so we only unlink if the file
4941   // has a non-zero size.  We also unlink only regular files to avoid
4942   // trouble with directories/etc.
4943   //
4944   // If we fail, continue; this command is merely a best-effort attempt
4945   // to improve the odds for open().
4946
4947   // We let the name "-" mean "stdout"
4948   if (!this->is_temporary_)
4949     {
4950       if (strcmp(this->name_, "-") == 0)
4951         this->o_ = STDOUT_FILENO;
4952       else
4953         {
4954           struct stat s;
4955           if (::stat(this->name_, &s) == 0
4956               && (S_ISREG (s.st_mode) || S_ISLNK (s.st_mode)))
4957             {
4958               if (s.st_size != 0)
4959                 ::unlink(this->name_);
4960               else if (!parameters->options().relocatable())
4961                 {
4962                   // If we don't unlink the existing file, add execute
4963                   // permission where read permissions already exist
4964                   // and where the umask permits.
4965                   int mask = ::umask(0);
4966                   ::umask(mask);
4967                   s.st_mode |= (s.st_mode & 0444) >> 2;
4968                   ::chmod(this->name_, s.st_mode & ~mask);
4969                 }
4970             }
4971
4972           int mode = parameters->options().relocatable() ? 0666 : 0777;
4973           int o = open_descriptor(-1, this->name_, O_RDWR | O_CREAT | O_TRUNC,
4974                                   mode);
4975           if (o < 0)
4976             gold_fatal(_("%s: open: %s"), this->name_, strerror(errno));
4977           this->o_ = o;
4978         }
4979     }
4980
4981   this->map();
4982 }
4983
4984 // Resize the output file.
4985
4986 void
4987 Output_file::resize(off_t file_size)
4988 {
4989   // If the mmap is mapping an anonymous memory buffer, this is easy:
4990   // just mremap to the new size.  If it's mapping to a file, we want
4991   // to unmap to flush to the file, then remap after growing the file.
4992   if (this->map_is_anonymous_)
4993     {
4994       void* base;
4995       if (!this->map_is_allocated_)
4996         {
4997           base = ::mremap(this->base_, this->file_size_, file_size,
4998                           MREMAP_MAYMOVE);
4999           if (base == MAP_FAILED)
5000             gold_fatal(_("%s: mremap: %s"), this->name_, strerror(errno));
5001         }
5002       else
5003         {
5004           base = realloc(this->base_, file_size);
5005           if (base == NULL)
5006             gold_nomem();
5007           if (file_size > this->file_size_)
5008             memset(static_cast<char*>(base) + this->file_size_, 0,
5009                    file_size - this->file_size_);
5010         }
5011       this->base_ = static_cast<unsigned char*>(base);
5012       this->file_size_ = file_size;
5013     }
5014   else
5015     {
5016       this->unmap();
5017       this->file_size_ = file_size;
5018       if (!this->map_no_anonymous(true))
5019         gold_fatal(_("%s: mmap: %s"), this->name_, strerror(errno));
5020     }
5021 }
5022
5023 // Map an anonymous block of memory which will later be written to the
5024 // file.  Return whether the map succeeded.
5025
5026 bool
5027 Output_file::map_anonymous()
5028 {
5029   void* base = ::mmap(NULL, this->file_size_, PROT_READ | PROT_WRITE,
5030                       MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
5031   if (base == MAP_FAILED)
5032     {
5033       base = malloc(this->file_size_);
5034       if (base == NULL)
5035         return false;
5036       memset(base, 0, this->file_size_);
5037       this->map_is_allocated_ = true;
5038     }
5039   this->base_ = static_cast<unsigned char*>(base);
5040   this->map_is_anonymous_ = true;
5041   return true;
5042 }
5043
5044 // Map the file into memory.  Return whether the mapping succeeded.
5045 // If WRITABLE is true, map with write access.
5046
5047 bool
5048 Output_file::map_no_anonymous(bool writable)
5049 {
5050   const int o = this->o_;
5051
5052   // If the output file is not a regular file, don't try to mmap it;
5053   // instead, we'll mmap a block of memory (an anonymous buffer), and
5054   // then later write the buffer to the file.
5055   void* base;
5056   struct stat statbuf;
5057   if (o == STDOUT_FILENO || o == STDERR_FILENO
5058       || ::fstat(o, &statbuf) != 0
5059       || !S_ISREG(statbuf.st_mode)
5060       || this->is_temporary_)
5061     return false;
5062
5063   // Ensure that we have disk space available for the file.  If we
5064   // don't do this, it is possible that we will call munmap, close,
5065   // and exit with dirty buffers still in the cache with no assigned
5066   // disk blocks.  If the disk is out of space at that point, the
5067   // output file will wind up incomplete, but we will have already
5068   // exited.  The alternative to fallocate would be to use fdatasync,
5069   // but that would be a more significant performance hit.
5070   if (writable)
5071     {
5072       int err = gold_fallocate(o, 0, this->file_size_);
5073       if (err != 0)
5074        gold_fatal(_("%s: %s"), this->name_, strerror(err));
5075     }
5076
5077   // Map the file into memory.
5078   int prot = PROT_READ;
5079   if (writable)
5080     prot |= PROT_WRITE;
5081   base = ::mmap(NULL, this->file_size_, prot, MAP_SHARED, o, 0);
5082
5083   // The mmap call might fail because of file system issues: the file
5084   // system might not support mmap at all, or it might not support
5085   // mmap with PROT_WRITE.
5086   if (base == MAP_FAILED)
5087     return false;
5088
5089   this->map_is_anonymous_ = false;
5090   this->base_ = static_cast<unsigned char*>(base);
5091   return true;
5092 }
5093
5094 // Map the file into memory.
5095
5096 void
5097 Output_file::map()
5098 {
5099   if (parameters->options().mmap_output_file()
5100       && this->map_no_anonymous(true))
5101     return;
5102
5103   // The mmap call might fail because of file system issues: the file
5104   // system might not support mmap at all, or it might not support
5105   // mmap with PROT_WRITE.  I'm not sure which errno values we will
5106   // see in all cases, so if the mmap fails for any reason and we
5107   // don't care about file contents, try for an anonymous map.
5108   if (this->map_anonymous())
5109     return;
5110
5111   gold_fatal(_("%s: mmap: failed to allocate %lu bytes for output file: %s"),
5112              this->name_, static_cast<unsigned long>(this->file_size_),
5113              strerror(errno));
5114 }
5115
5116 // Unmap the file from memory.
5117
5118 void
5119 Output_file::unmap()
5120 {
5121   if (this->map_is_anonymous_)
5122     {
5123       // We've already written out the data, so there is no reason to
5124       // waste time unmapping or freeing the memory.
5125     }
5126   else
5127     {
5128       if (::munmap(this->base_, this->file_size_) < 0)
5129         gold_error(_("%s: munmap: %s"), this->name_, strerror(errno));
5130     }
5131   this->base_ = NULL;
5132 }
5133
5134 // Close the output file.
5135
5136 void
5137 Output_file::close()
5138 {
5139   // If the map isn't file-backed, we need to write it now.
5140   if (this->map_is_anonymous_ && !this->is_temporary_)
5141     {
5142       size_t bytes_to_write = this->file_size_;
5143       size_t offset = 0;
5144       while (bytes_to_write > 0)
5145         {
5146           ssize_t bytes_written = ::write(this->o_, this->base_ + offset,
5147                                           bytes_to_write);
5148           if (bytes_written == 0)
5149             gold_error(_("%s: write: unexpected 0 return-value"), this->name_);
5150           else if (bytes_written < 0)
5151             gold_error(_("%s: write: %s"), this->name_, strerror(errno));
5152           else
5153             {
5154               bytes_to_write -= bytes_written;
5155               offset += bytes_written;
5156             }
5157         }
5158     }
5159   this->unmap();
5160
5161   // We don't close stdout or stderr
5162   if (this->o_ != STDOUT_FILENO
5163       && this->o_ != STDERR_FILENO
5164       && !this->is_temporary_)
5165     if (::close(this->o_) < 0)
5166       gold_error(_("%s: close: %s"), this->name_, strerror(errno));
5167   this->o_ = -1;
5168 }
5169
5170 // Instantiate the templates we need.  We could use the configure
5171 // script to restrict this to only the ones for implemented targets.
5172
5173 #ifdef HAVE_TARGET_32_LITTLE
5174 template
5175 off_t
5176 Output_section::add_input_section<32, false>(
5177     Layout* layout,
5178     Sized_relobj_file<32, false>* object,
5179     unsigned int shndx,
5180     const char* secname,
5181     const elfcpp::Shdr<32, false>& shdr,
5182     unsigned int reloc_shndx,
5183     bool have_sections_script);
5184 #endif
5185
5186 #ifdef HAVE_TARGET_32_BIG
5187 template
5188 off_t
5189 Output_section::add_input_section<32, true>(
5190     Layout* layout,
5191     Sized_relobj_file<32, true>* object,
5192     unsigned int shndx,
5193     const char* secname,
5194     const elfcpp::Shdr<32, true>& shdr,
5195     unsigned int reloc_shndx,
5196     bool have_sections_script);
5197 #endif
5198
5199 #ifdef HAVE_TARGET_64_LITTLE
5200 template
5201 off_t
5202 Output_section::add_input_section<64, false>(
5203     Layout* layout,
5204     Sized_relobj_file<64, false>* object,
5205     unsigned int shndx,
5206     const char* secname,
5207     const elfcpp::Shdr<64, false>& shdr,
5208     unsigned int reloc_shndx,
5209     bool have_sections_script);
5210 #endif
5211
5212 #ifdef HAVE_TARGET_64_BIG
5213 template
5214 off_t
5215 Output_section::add_input_section<64, true>(
5216     Layout* layout,
5217     Sized_relobj_file<64, true>* object,
5218     unsigned int shndx,
5219     const char* secname,
5220     const elfcpp::Shdr<64, true>& shdr,
5221     unsigned int reloc_shndx,
5222     bool have_sections_script);
5223 #endif
5224
5225 #ifdef HAVE_TARGET_32_LITTLE
5226 template
5227 class Output_reloc<elfcpp::SHT_REL, false, 32, false>;
5228 #endif
5229
5230 #ifdef HAVE_TARGET_32_BIG
5231 template
5232 class Output_reloc<elfcpp::SHT_REL, false, 32, true>;
5233 #endif
5234
5235 #ifdef HAVE_TARGET_64_LITTLE
5236 template
5237 class Output_reloc<elfcpp::SHT_REL, false, 64, false>;
5238 #endif
5239
5240 #ifdef HAVE_TARGET_64_BIG
5241 template
5242 class Output_reloc<elfcpp::SHT_REL, false, 64, true>;
5243 #endif
5244
5245 #ifdef HAVE_TARGET_32_LITTLE
5246 template
5247 class Output_reloc<elfcpp::SHT_REL, true, 32, false>;
5248 #endif
5249
5250 #ifdef HAVE_TARGET_32_BIG
5251 template
5252 class Output_reloc<elfcpp::SHT_REL, true, 32, true>;
5253 #endif
5254
5255 #ifdef HAVE_TARGET_64_LITTLE
5256 template
5257 class Output_reloc<elfcpp::SHT_REL, true, 64, false>;
5258 #endif
5259
5260 #ifdef HAVE_TARGET_64_BIG
5261 template
5262 class Output_reloc<elfcpp::SHT_REL, true, 64, true>;
5263 #endif
5264
5265 #ifdef HAVE_TARGET_32_LITTLE
5266 template
5267 class Output_reloc<elfcpp::SHT_RELA, false, 32, false>;
5268 #endif
5269
5270 #ifdef HAVE_TARGET_32_BIG
5271 template
5272 class Output_reloc<elfcpp::SHT_RELA, false, 32, true>;
5273 #endif
5274
5275 #ifdef HAVE_TARGET_64_LITTLE
5276 template
5277 class Output_reloc<elfcpp::SHT_RELA, false, 64, false>;
5278 #endif
5279
5280 #ifdef HAVE_TARGET_64_BIG
5281 template
5282 class Output_reloc<elfcpp::SHT_RELA, false, 64, true>;
5283 #endif
5284
5285 #ifdef HAVE_TARGET_32_LITTLE
5286 template
5287 class Output_reloc<elfcpp::SHT_RELA, true, 32, false>;
5288 #endif
5289
5290 #ifdef HAVE_TARGET_32_BIG
5291 template
5292 class Output_reloc<elfcpp::SHT_RELA, true, 32, true>;
5293 #endif
5294
5295 #ifdef HAVE_TARGET_64_LITTLE
5296 template
5297 class Output_reloc<elfcpp::SHT_RELA, true, 64, false>;
5298 #endif
5299
5300 #ifdef HAVE_TARGET_64_BIG
5301 template
5302 class Output_reloc<elfcpp::SHT_RELA, true, 64, true>;
5303 #endif
5304
5305 #ifdef HAVE_TARGET_32_LITTLE
5306 template
5307 class Output_data_reloc<elfcpp::SHT_REL, false, 32, false>;
5308 #endif
5309
5310 #ifdef HAVE_TARGET_32_BIG
5311 template
5312 class Output_data_reloc<elfcpp::SHT_REL, false, 32, true>;
5313 #endif
5314
5315 #ifdef HAVE_TARGET_64_LITTLE
5316 template
5317 class Output_data_reloc<elfcpp::SHT_REL, false, 64, false>;
5318 #endif
5319
5320 #ifdef HAVE_TARGET_64_BIG
5321 template
5322 class Output_data_reloc<elfcpp::SHT_REL, false, 64, true>;
5323 #endif
5324
5325 #ifdef HAVE_TARGET_32_LITTLE
5326 template
5327 class Output_data_reloc<elfcpp::SHT_REL, true, 32, false>;
5328 #endif
5329
5330 #ifdef HAVE_TARGET_32_BIG
5331 template
5332 class Output_data_reloc<elfcpp::SHT_REL, true, 32, true>;
5333 #endif
5334
5335 #ifdef HAVE_TARGET_64_LITTLE
5336 template
5337 class Output_data_reloc<elfcpp::SHT_REL, true, 64, false>;
5338 #endif
5339
5340 #ifdef HAVE_TARGET_64_BIG
5341 template
5342 class Output_data_reloc<elfcpp::SHT_REL, true, 64, true>;
5343 #endif
5344
5345 #ifdef HAVE_TARGET_32_LITTLE
5346 template
5347 class Output_data_reloc<elfcpp::SHT_RELA, false, 32, false>;
5348 #endif
5349
5350 #ifdef HAVE_TARGET_32_BIG
5351 template
5352 class Output_data_reloc<elfcpp::SHT_RELA, false, 32, true>;
5353 #endif
5354
5355 #ifdef HAVE_TARGET_64_LITTLE
5356 template
5357 class Output_data_reloc<elfcpp::SHT_RELA, false, 64, false>;
5358 #endif
5359
5360 #ifdef HAVE_TARGET_64_BIG
5361 template
5362 class Output_data_reloc<elfcpp::SHT_RELA, false, 64, true>;
5363 #endif
5364
5365 #ifdef HAVE_TARGET_32_LITTLE
5366 template
5367 class Output_data_reloc<elfcpp::SHT_RELA, true, 32, false>;
5368 #endif
5369
5370 #ifdef HAVE_TARGET_32_BIG
5371 template
5372 class Output_data_reloc<elfcpp::SHT_RELA, true, 32, true>;
5373 #endif
5374
5375 #ifdef HAVE_TARGET_64_LITTLE
5376 template
5377 class Output_data_reloc<elfcpp::SHT_RELA, true, 64, false>;
5378 #endif
5379
5380 #ifdef HAVE_TARGET_64_BIG
5381 template
5382 class Output_data_reloc<elfcpp::SHT_RELA, true, 64, true>;
5383 #endif
5384
5385 #ifdef HAVE_TARGET_32_LITTLE
5386 template
5387 class Output_relocatable_relocs<elfcpp::SHT_REL, 32, false>;
5388 #endif
5389
5390 #ifdef HAVE_TARGET_32_BIG
5391 template
5392 class Output_relocatable_relocs<elfcpp::SHT_REL, 32, true>;
5393 #endif
5394
5395 #ifdef HAVE_TARGET_64_LITTLE
5396 template
5397 class Output_relocatable_relocs<elfcpp::SHT_REL, 64, false>;
5398 #endif
5399
5400 #ifdef HAVE_TARGET_64_BIG
5401 template
5402 class Output_relocatable_relocs<elfcpp::SHT_REL, 64, true>;
5403 #endif
5404
5405 #ifdef HAVE_TARGET_32_LITTLE
5406 template
5407 class Output_relocatable_relocs<elfcpp::SHT_RELA, 32, false>;
5408 #endif
5409
5410 #ifdef HAVE_TARGET_32_BIG
5411 template
5412 class Output_relocatable_relocs<elfcpp::SHT_RELA, 32, true>;
5413 #endif
5414
5415 #ifdef HAVE_TARGET_64_LITTLE
5416 template
5417 class Output_relocatable_relocs<elfcpp::SHT_RELA, 64, false>;
5418 #endif
5419
5420 #ifdef HAVE_TARGET_64_BIG
5421 template
5422 class Output_relocatable_relocs<elfcpp::SHT_RELA, 64, true>;
5423 #endif
5424
5425 #ifdef HAVE_TARGET_32_LITTLE
5426 template
5427 class Output_data_group<32, false>;
5428 #endif
5429
5430 #ifdef HAVE_TARGET_32_BIG
5431 template
5432 class Output_data_group<32, true>;
5433 #endif
5434
5435 #ifdef HAVE_TARGET_64_LITTLE
5436 template
5437 class Output_data_group<64, false>;
5438 #endif
5439
5440 #ifdef HAVE_TARGET_64_BIG
5441 template
5442 class Output_data_group<64, true>;
5443 #endif
5444
5445 #ifdef HAVE_TARGET_32_LITTLE
5446 template
5447 class Output_data_got<32, false>;
5448 #endif
5449
5450 #ifdef HAVE_TARGET_32_BIG
5451 template
5452 class Output_data_got<32, true>;
5453 #endif
5454
5455 #ifdef HAVE_TARGET_64_LITTLE
5456 template
5457 class Output_data_got<64, false>;
5458 #endif
5459
5460 #ifdef HAVE_TARGET_64_BIG
5461 template
5462 class Output_data_got<64, true>;
5463 #endif
5464
5465 } // End namespace gold.