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