PR gold/12880
[platform/upstream/binutils.git] / gold / layout.cc
1 // layout.cc -- lay out output file sections for gold
2
3 // Copyright 2006, 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
4 // Written by Ian Lance Taylor <iant@google.com>.
5
6 // This file is part of gold.
7
8 // This program is free software; you can redistribute it and/or modify
9 // it under the terms of the GNU General Public License as published by
10 // the Free Software Foundation; either version 3 of the License, or
11 // (at your option) any later version.
12
13 // This program is distributed in the hope that it will be useful,
14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 // GNU General Public License for more details.
17
18 // You should have received a copy of the GNU General Public License
19 // along with this program; if not, write to the Free Software
20 // Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 // MA 02110-1301, USA.
22
23 #include "gold.h"
24
25 #include <cerrno>
26 #include <cstring>
27 #include <algorithm>
28 #include <iostream>
29 #include <fstream>
30 #include <utility>
31 #include <fcntl.h>
32 #include <fnmatch.h>
33 #include <unistd.h>
34 #include "libiberty.h"
35 #include "md5.h"
36 #include "sha1.h"
37
38 #include "parameters.h"
39 #include "options.h"
40 #include "mapfile.h"
41 #include "script.h"
42 #include "script-sections.h"
43 #include "output.h"
44 #include "symtab.h"
45 #include "dynobj.h"
46 #include "ehframe.h"
47 #include "compressed_output.h"
48 #include "reduced_debug_output.h"
49 #include "reloc.h"
50 #include "descriptors.h"
51 #include "plugin.h"
52 #include "incremental.h"
53 #include "layout.h"
54
55 namespace gold
56 {
57
58 // Class Free_list.
59
60 // The total number of free lists used.
61 unsigned int Free_list::num_lists = 0;
62 // The total number of free list nodes used.
63 unsigned int Free_list::num_nodes = 0;
64 // The total number of calls to Free_list::remove.
65 unsigned int Free_list::num_removes = 0;
66 // The total number of nodes visited during calls to Free_list::remove.
67 unsigned int Free_list::num_remove_visits = 0;
68 // The total number of calls to Free_list::allocate.
69 unsigned int Free_list::num_allocates = 0;
70 // The total number of nodes visited during calls to Free_list::allocate.
71 unsigned int Free_list::num_allocate_visits = 0;
72
73 // Initialize the free list.  Creates a single free list node that
74 // describes the entire region of length LEN.  If EXTEND is true,
75 // allocate() is allowed to extend the region beyond its initial
76 // length.
77
78 void
79 Free_list::init(off_t len, bool extend)
80 {
81   this->list_.push_front(Free_list_node(0, len));
82   this->last_remove_ = this->list_.begin();
83   this->extend_ = extend;
84   this->length_ = len;
85   ++Free_list::num_lists;
86   ++Free_list::num_nodes;
87 }
88
89 // Remove a chunk from the free list.  Because we start with a single
90 // node that covers the entire section, and remove chunks from it one
91 // at a time, we do not need to coalesce chunks or handle cases that
92 // span more than one free node.  We expect to remove chunks from the
93 // free list in order, and we expect to have only a few chunks of free
94 // space left (corresponding to files that have changed since the last
95 // incremental link), so a simple linear list should provide sufficient
96 // performance.
97
98 void
99 Free_list::remove(off_t start, off_t end)
100 {
101   if (start == end)
102     return;
103   gold_assert(start < end);
104
105   ++Free_list::num_removes;
106
107   Iterator p = this->last_remove_;
108   if (p->start_ > start)
109     p = this->list_.begin();
110
111   for (; p != this->list_.end(); ++p)
112     {
113       ++Free_list::num_remove_visits;
114       // Find a node that wholly contains the indicated region.
115       if (p->start_ <= start && p->end_ >= end)
116         {
117           // Case 1: the indicated region spans the whole node.
118           // Add some fuzz to avoid creating tiny free chunks.
119           if (p->start_ + 3 >= start && p->end_ <= end + 3)
120             p = this->list_.erase(p);
121           // Case 2: remove a chunk from the start of the node.
122           else if (p->start_ + 3 >= start)
123             p->start_ = end;
124           // Case 3: remove a chunk from the end of the node.
125           else if (p->end_ <= end + 3)
126             p->end_ = start;
127           // Case 4: remove a chunk from the middle, and split
128           // the node into two.
129           else
130             {
131               Free_list_node newnode(p->start_, start);
132               p->start_ = end;
133               this->list_.insert(p, newnode);
134               ++Free_list::num_nodes;
135             }
136           this->last_remove_ = p;
137           return;
138         }
139     }
140
141   // Did not find a node containing the given chunk.  This could happen
142   // because a small chunk was already removed due to the fuzz.
143   gold_debug(DEBUG_INCREMENTAL,
144              "Free_list::remove(%d,%d) not found",
145              static_cast<int>(start), static_cast<int>(end));
146 }
147
148 // Allocate a chunk of size LEN from the free list.  Returns -1ULL
149 // if a sufficiently large chunk of free space is not found.
150 // We use a simple first-fit algorithm.
151
152 off_t
153 Free_list::allocate(off_t len, uint64_t align, off_t minoff)
154 {
155   gold_debug(DEBUG_INCREMENTAL,
156              "Free_list::allocate(%08lx, %d, %08lx)",
157              static_cast<long>(len), static_cast<int>(align),
158              static_cast<long>(minoff));
159   if (len == 0)
160     return align_address(minoff, align);
161
162   ++Free_list::num_allocates;
163
164   for (Iterator p = this->list_.begin(); p != this->list_.end(); ++p)
165     {
166       ++Free_list::num_allocate_visits;
167       off_t start = p->start_ > minoff ? p->start_ : minoff;
168       start = align_address(start, align);
169       off_t end = start + len;
170       if (end <= p->end_)
171         {
172           if (p->start_ + 3 >= start && p->end_ <= end + 3)
173             this->list_.erase(p);
174           else if (p->start_ + 3 >= start)
175             p->start_ = end;
176           else if (p->end_ <= end + 3)
177             p->end_ = start;
178           else
179             {
180               Free_list_node newnode(p->start_, start);
181               p->start_ = end;
182               this->list_.insert(p, newnode);
183               ++Free_list::num_nodes;
184             }
185           return start;
186         }
187     }
188   return -1;
189 }
190
191 // Dump the free list (for debugging).
192 void
193 Free_list::dump()
194 {
195   gold_info("Free list:\n     start      end   length\n");
196   for (Iterator p = this->list_.begin(); p != this->list_.end(); ++p)
197     gold_info("  %08lx %08lx %08lx", static_cast<long>(p->start_),
198               static_cast<long>(p->end_),
199               static_cast<long>(p->end_ - p->start_));
200 }
201
202 // Print the statistics for the free lists.
203 void
204 Free_list::print_stats()
205 {
206   fprintf(stderr, _("%s: total free lists: %u\n"),
207           program_name, Free_list::num_lists);
208   fprintf(stderr, _("%s: total free list nodes: %u\n"),
209           program_name, Free_list::num_nodes);
210   fprintf(stderr, _("%s: calls to Free_list::remove: %u\n"),
211           program_name, Free_list::num_removes);
212   fprintf(stderr, _("%s: nodes visited: %u\n"),
213           program_name, Free_list::num_remove_visits);
214   fprintf(stderr, _("%s: calls to Free_list::allocate: %u\n"),
215           program_name, Free_list::num_allocates);
216   fprintf(stderr, _("%s: nodes visited: %u\n"),
217           program_name, Free_list::num_allocate_visits);
218 }
219
220 // Layout::Relaxation_debug_check methods.
221
222 // Check that sections and special data are in reset states.
223 // We do not save states for Output_sections and special Output_data.
224 // So we check that they have not assigned any addresses or offsets.
225 // clean_up_after_relaxation simply resets their addresses and offsets.
226 void
227 Layout::Relaxation_debug_check::check_output_data_for_reset_values(
228     const Layout::Section_list& sections,
229     const Layout::Data_list& special_outputs)
230 {
231   for(Layout::Section_list::const_iterator p = sections.begin();
232       p != sections.end();
233       ++p)
234     gold_assert((*p)->address_and_file_offset_have_reset_values());
235
236   for(Layout::Data_list::const_iterator p = special_outputs.begin();
237       p != special_outputs.end();
238       ++p)
239     gold_assert((*p)->address_and_file_offset_have_reset_values());
240 }
241   
242 // Save information of SECTIONS for checking later.
243
244 void
245 Layout::Relaxation_debug_check::read_sections(
246     const Layout::Section_list& sections)
247 {
248   for(Layout::Section_list::const_iterator p = sections.begin();
249       p != sections.end();
250       ++p)
251     {
252       Output_section* os = *p;
253       Section_info info;
254       info.output_section = os;
255       info.address = os->is_address_valid() ? os->address() : 0;
256       info.data_size = os->is_data_size_valid() ? os->data_size() : -1;
257       info.offset = os->is_offset_valid()? os->offset() : -1 ;
258       this->section_infos_.push_back(info);
259     }
260 }
261
262 // Verify SECTIONS using previously recorded information.
263
264 void
265 Layout::Relaxation_debug_check::verify_sections(
266     const Layout::Section_list& sections)
267 {
268   size_t i = 0;
269   for(Layout::Section_list::const_iterator p = sections.begin();
270       p != sections.end();
271       ++p, ++i)
272     {
273       Output_section* os = *p;
274       uint64_t address = os->is_address_valid() ? os->address() : 0;
275       off_t data_size = os->is_data_size_valid() ? os->data_size() : -1;
276       off_t offset = os->is_offset_valid()? os->offset() : -1 ;
277
278       if (i >= this->section_infos_.size())
279         {
280           gold_fatal("Section_info of %s missing.\n", os->name());
281         }
282       const Section_info& info = this->section_infos_[i];
283       if (os != info.output_section)
284         gold_fatal("Section order changed.  Expecting %s but see %s\n",
285                    info.output_section->name(), os->name());
286       if (address != info.address
287           || data_size != info.data_size
288           || offset != info.offset)
289         gold_fatal("Section %s changed.\n", os->name());
290     }
291 }
292
293 // Layout_task_runner methods.
294
295 // Lay out the sections.  This is called after all the input objects
296 // have been read.
297
298 void
299 Layout_task_runner::run(Workqueue* workqueue, const Task* task)
300 {
301   Layout* layout = this->layout_;
302   off_t file_size = layout->finalize(this->input_objects_,
303                                      this->symtab_,
304                                      this->target_,
305                                      task);
306
307   // Now we know the final size of the output file and we know where
308   // each piece of information goes.
309
310   if (this->mapfile_ != NULL)
311     {
312       this->mapfile_->print_discarded_sections(this->input_objects_);
313       layout->print_to_mapfile(this->mapfile_);
314     }
315
316   Output_file* of;
317   if (layout->incremental_base() == NULL)
318     {
319       of = new Output_file(parameters->options().output_file_name());
320       if (this->options_.oformat_enum() != General_options::OBJECT_FORMAT_ELF)
321         of->set_is_temporary();
322       of->open(file_size);
323     }
324   else
325     {
326       of = layout->incremental_base()->output_file();
327
328       // Apply the incremental relocations for symbols whose values
329       // have changed.  We do this before we resize the file and start
330       // writing anything else to it, so that we can read the old
331       // incremental information from the file before (possibly)
332       // overwriting it.
333       if (parameters->incremental_update())
334         layout->incremental_base()->apply_incremental_relocs(this->symtab_,
335                                                              this->layout_,
336                                                              of);
337
338       of->resize(file_size);
339     }
340
341   // Queue up the final set of tasks.
342   gold::queue_final_tasks(this->options_, this->input_objects_,
343                           this->symtab_, layout, workqueue, of);
344 }
345
346 // Layout methods.
347
348 Layout::Layout(int number_of_input_files, Script_options* script_options)
349   : number_of_input_files_(number_of_input_files),
350     script_options_(script_options),
351     namepool_(),
352     sympool_(),
353     dynpool_(),
354     signatures_(),
355     section_name_map_(),
356     segment_list_(),
357     section_list_(),
358     unattached_section_list_(),
359     special_output_list_(),
360     section_headers_(NULL),
361     tls_segment_(NULL),
362     relro_segment_(NULL),
363     interp_segment_(NULL),
364     increase_relro_(0),
365     symtab_section_(NULL),
366     symtab_xindex_(NULL),
367     dynsym_section_(NULL),
368     dynsym_xindex_(NULL),
369     dynamic_section_(NULL),
370     dynamic_symbol_(NULL),
371     dynamic_data_(NULL),
372     eh_frame_section_(NULL),
373     eh_frame_data_(NULL),
374     added_eh_frame_data_(false),
375     eh_frame_hdr_section_(NULL),
376     build_id_note_(NULL),
377     debug_abbrev_(NULL),
378     debug_info_(NULL),
379     group_signatures_(),
380     output_file_size_(-1),
381     have_added_input_section_(false),
382     sections_are_attached_(false),
383     input_requires_executable_stack_(false),
384     input_with_gnu_stack_note_(false),
385     input_without_gnu_stack_note_(false),
386     has_static_tls_(false),
387     any_postprocessing_sections_(false),
388     resized_signatures_(false),
389     have_stabstr_section_(false),
390     incremental_inputs_(NULL),
391     record_output_section_data_from_script_(false),
392     script_output_section_data_list_(),
393     segment_states_(NULL),
394     relaxation_debug_check_(NULL),
395     incremental_base_(NULL),
396     free_list_()
397 {
398   // Make space for more than enough segments for a typical file.
399   // This is just for efficiency--it's OK if we wind up needing more.
400   this->segment_list_.reserve(12);
401
402   // We expect two unattached Output_data objects: the file header and
403   // the segment headers.
404   this->special_output_list_.reserve(2);
405
406   // Initialize structure needed for an incremental build.
407   if (parameters->incremental())
408     this->incremental_inputs_ = new Incremental_inputs;
409
410   // The section name pool is worth optimizing in all cases, because
411   // it is small, but there are often overlaps due to .rel sections.
412   this->namepool_.set_optimize();
413 }
414
415 // For incremental links, record the base file to be modified.
416
417 void
418 Layout::set_incremental_base(Incremental_binary* base)
419 {
420   this->incremental_base_ = base;
421   this->free_list_.init(base->output_file()->filesize(), true);
422 }
423
424 // Hash a key we use to look up an output section mapping.
425
426 size_t
427 Layout::Hash_key::operator()(const Layout::Key& k) const
428 {
429  return k.first + k.second.first + k.second.second;
430 }
431
432 // Returns whether the given section is in the list of
433 // debug-sections-used-by-some-version-of-gdb.  Currently,
434 // we've checked versions of gdb up to and including 6.7.1.
435
436 static const char* gdb_sections[] =
437 { ".debug_abbrev",
438   // ".debug_aranges",   // not used by gdb as of 6.7.1
439   ".debug_frame",
440   ".debug_info",
441   ".debug_types",
442   ".debug_line",
443   ".debug_loc",
444   ".debug_macinfo",
445   // ".debug_pubnames",  // not used by gdb as of 6.7.1
446   ".debug_ranges",
447   ".debug_str",
448 };
449
450 static const char* lines_only_debug_sections[] =
451 { ".debug_abbrev",
452   // ".debug_aranges",   // not used by gdb as of 6.7.1
453   // ".debug_frame",
454   ".debug_info",
455   // ".debug_types",
456   ".debug_line",
457   // ".debug_loc",
458   // ".debug_macinfo",
459   // ".debug_pubnames",  // not used by gdb as of 6.7.1
460   // ".debug_ranges",
461   ".debug_str",
462 };
463
464 static inline bool
465 is_gdb_debug_section(const char* str)
466 {
467   // We can do this faster: binary search or a hashtable.  But why bother?
468   for (size_t i = 0; i < sizeof(gdb_sections)/sizeof(*gdb_sections); ++i)
469     if (strcmp(str, gdb_sections[i]) == 0)
470       return true;
471   return false;
472 }
473
474 static inline bool
475 is_lines_only_debug_section(const char* str)
476 {
477   // We can do this faster: binary search or a hashtable.  But why bother?
478   for (size_t i = 0;
479        i < sizeof(lines_only_debug_sections)/sizeof(*lines_only_debug_sections);
480        ++i)
481     if (strcmp(str, lines_only_debug_sections[i]) == 0)
482       return true;
483   return false;
484 }
485
486 // Sometimes we compress sections.  This is typically done for
487 // sections that are not part of normal program execution (such as
488 // .debug_* sections), and where the readers of these sections know
489 // how to deal with compressed sections.  This routine doesn't say for
490 // certain whether we'll compress -- it depends on commandline options
491 // as well -- just whether this section is a candidate for compression.
492 // (The Output_compressed_section class decides whether to compress
493 // a given section, and picks the name of the compressed section.)
494
495 static bool
496 is_compressible_debug_section(const char* secname)
497 {
498   return (is_prefix_of(".debug", secname));
499 }
500
501 // We may see compressed debug sections in input files.  Return TRUE
502 // if this is the name of a compressed debug section.
503
504 bool
505 is_compressed_debug_section(const char* secname)
506 {
507   return (is_prefix_of(".zdebug", secname));
508 }
509
510 // Whether to include this section in the link.
511
512 template<int size, bool big_endian>
513 bool
514 Layout::include_section(Sized_relobj_file<size, big_endian>*, const char* name,
515                         const elfcpp::Shdr<size, big_endian>& shdr)
516 {
517   if (shdr.get_sh_flags() & elfcpp::SHF_EXCLUDE)
518     return false;
519
520   switch (shdr.get_sh_type())
521     {
522     case elfcpp::SHT_NULL:
523     case elfcpp::SHT_SYMTAB:
524     case elfcpp::SHT_DYNSYM:
525     case elfcpp::SHT_HASH:
526     case elfcpp::SHT_DYNAMIC:
527     case elfcpp::SHT_SYMTAB_SHNDX:
528       return false;
529
530     case elfcpp::SHT_STRTAB:
531       // Discard the sections which have special meanings in the ELF
532       // ABI.  Keep others (e.g., .stabstr).  We could also do this by
533       // checking the sh_link fields of the appropriate sections.
534       return (strcmp(name, ".dynstr") != 0
535               && strcmp(name, ".strtab") != 0
536               && strcmp(name, ".shstrtab") != 0);
537
538     case elfcpp::SHT_RELA:
539     case elfcpp::SHT_REL:
540     case elfcpp::SHT_GROUP:
541       // If we are emitting relocations these should be handled
542       // elsewhere.
543       gold_assert(!parameters->options().relocatable()
544                   && !parameters->options().emit_relocs());
545       return false;
546
547     case elfcpp::SHT_PROGBITS:
548       if (parameters->options().strip_debug()
549           && (shdr.get_sh_flags() & elfcpp::SHF_ALLOC) == 0)
550         {
551           if (is_debug_info_section(name))
552             return false;
553         }
554       if (parameters->options().strip_debug_non_line()
555           && (shdr.get_sh_flags() & elfcpp::SHF_ALLOC) == 0)
556         {
557           // Debugging sections can only be recognized by name.
558           if (is_prefix_of(".debug", name)
559               && !is_lines_only_debug_section(name))
560             return false;
561         }
562       if (parameters->options().strip_debug_gdb()
563           && (shdr.get_sh_flags() & elfcpp::SHF_ALLOC) == 0)
564         {
565           // Debugging sections can only be recognized by name.
566           if (is_prefix_of(".debug", name)
567               && !is_gdb_debug_section(name))
568             return false;
569         }
570       if (parameters->options().strip_lto_sections()
571           && !parameters->options().relocatable()
572           && (shdr.get_sh_flags() & elfcpp::SHF_ALLOC) == 0)
573         {
574           // Ignore LTO sections containing intermediate code.
575           if (is_prefix_of(".gnu.lto_", name))
576             return false;
577         }
578       // The GNU linker strips .gnu_debuglink sections, so we do too.
579       // This is a feature used to keep debugging information in
580       // separate files.
581       if (strcmp(name, ".gnu_debuglink") == 0)
582         return false;
583       return true;
584
585     default:
586       return true;
587     }
588 }
589
590 // Return an output section named NAME, or NULL if there is none.
591
592 Output_section*
593 Layout::find_output_section(const char* name) const
594 {
595   for (Section_list::const_iterator p = this->section_list_.begin();
596        p != this->section_list_.end();
597        ++p)
598     if (strcmp((*p)->name(), name) == 0)
599       return *p;
600   return NULL;
601 }
602
603 // Return an output segment of type TYPE, with segment flags SET set
604 // and segment flags CLEAR clear.  Return NULL if there is none.
605
606 Output_segment*
607 Layout::find_output_segment(elfcpp::PT type, elfcpp::Elf_Word set,
608                             elfcpp::Elf_Word clear) const
609 {
610   for (Segment_list::const_iterator p = this->segment_list_.begin();
611        p != this->segment_list_.end();
612        ++p)
613     if (static_cast<elfcpp::PT>((*p)->type()) == type
614         && ((*p)->flags() & set) == set
615         && ((*p)->flags() & clear) == 0)
616       return *p;
617   return NULL;
618 }
619
620 // Return the output section to use for section NAME with type TYPE
621 // and section flags FLAGS.  NAME must be canonicalized in the string
622 // pool, and NAME_KEY is the key.  ORDER is where this should appear
623 // in the output sections.  IS_RELRO is true for a relro section.
624
625 Output_section*
626 Layout::get_output_section(const char* name, Stringpool::Key name_key,
627                            elfcpp::Elf_Word type, elfcpp::Elf_Xword flags,
628                            Output_section_order order, bool is_relro)
629 {
630   elfcpp::Elf_Xword lookup_flags = flags;
631
632   // Ignoring SHF_WRITE and SHF_EXECINSTR here means that we combine
633   // read-write with read-only sections.  Some other ELF linkers do
634   // not do this.  FIXME: Perhaps there should be an option
635   // controlling this.
636   lookup_flags &= ~(elfcpp::SHF_WRITE | elfcpp::SHF_EXECINSTR);
637
638   const Key key(name_key, std::make_pair(type, lookup_flags));
639   const std::pair<Key, Output_section*> v(key, NULL);
640   std::pair<Section_name_map::iterator, bool> ins(
641     this->section_name_map_.insert(v));
642
643   if (!ins.second)
644     return ins.first->second;
645   else
646     {
647       // This is the first time we've seen this name/type/flags
648       // combination.  For compatibility with the GNU linker, we
649       // combine sections with contents and zero flags with sections
650       // with non-zero flags.  This is a workaround for cases where
651       // assembler code forgets to set section flags.  FIXME: Perhaps
652       // there should be an option to control this.
653       Output_section* os = NULL;
654
655       if (type == elfcpp::SHT_PROGBITS)
656         {
657           if (flags == 0)
658             {
659               Output_section* same_name = this->find_output_section(name);
660               if (same_name != NULL
661                   && same_name->type() == elfcpp::SHT_PROGBITS
662                   && (same_name->flags() & elfcpp::SHF_TLS) == 0)
663                 os = same_name;
664             }
665           else if ((flags & elfcpp::SHF_TLS) == 0)
666             {
667               elfcpp::Elf_Xword zero_flags = 0;
668               const Key zero_key(name_key, std::make_pair(type, zero_flags));
669               Section_name_map::iterator p =
670                   this->section_name_map_.find(zero_key);
671               if (p != this->section_name_map_.end())
672                 os = p->second;
673             }
674         }
675
676       if (os == NULL)
677         os = this->make_output_section(name, type, flags, order, is_relro);
678
679       ins.first->second = os;
680       return os;
681     }
682 }
683
684 // Pick the output section to use for section NAME, in input file
685 // RELOBJ, with type TYPE and flags FLAGS.  RELOBJ may be NULL for a
686 // linker created section.  IS_INPUT_SECTION is true if we are
687 // choosing an output section for an input section found in a input
688 // file.  ORDER is where this section should appear in the output
689 // sections.  IS_RELRO is true for a relro section.  This will return
690 // NULL if the input section should be discarded.
691
692 Output_section*
693 Layout::choose_output_section(const Relobj* relobj, const char* name,
694                               elfcpp::Elf_Word type, elfcpp::Elf_Xword flags,
695                               bool is_input_section, Output_section_order order,
696                               bool is_relro)
697 {
698   // We should not see any input sections after we have attached
699   // sections to segments.
700   gold_assert(!is_input_section || !this->sections_are_attached_);
701
702   // Some flags in the input section should not be automatically
703   // copied to the output section.
704   flags &= ~ (elfcpp::SHF_INFO_LINK
705               | elfcpp::SHF_GROUP
706               | elfcpp::SHF_MERGE
707               | elfcpp::SHF_STRINGS);
708
709   // We only clear the SHF_LINK_ORDER flag in for
710   // a non-relocatable link.
711   if (!parameters->options().relocatable())
712     flags &= ~elfcpp::SHF_LINK_ORDER;
713
714   if (this->script_options_->saw_sections_clause())
715     {
716       // We are using a SECTIONS clause, so the output section is
717       // chosen based only on the name.
718
719       Script_sections* ss = this->script_options_->script_sections();
720       const char* file_name = relobj == NULL ? NULL : relobj->name().c_str();
721       Output_section** output_section_slot;
722       Script_sections::Section_type script_section_type;
723       const char* orig_name = name;
724       name = ss->output_section_name(file_name, name, &output_section_slot,
725                                      &script_section_type);
726       if (name == NULL)
727         {
728           gold_debug(DEBUG_SCRIPT, _("Unable to create output section '%s' "
729                                      "because it is not allowed by the "
730                                      "SECTIONS clause of the linker script"),
731                      orig_name);
732           // The SECTIONS clause says to discard this input section.
733           return NULL;
734         }
735
736       // We can only handle script section types ST_NONE and ST_NOLOAD.
737       switch (script_section_type)
738         {
739         case Script_sections::ST_NONE:
740           break;
741         case Script_sections::ST_NOLOAD:
742           flags &= elfcpp::SHF_ALLOC;
743           break;
744         default:
745           gold_unreachable();
746         }
747
748       // If this is an orphan section--one not mentioned in the linker
749       // script--then OUTPUT_SECTION_SLOT will be NULL, and we do the
750       // default processing below.
751
752       if (output_section_slot != NULL)
753         {
754           if (*output_section_slot != NULL)
755             {
756               (*output_section_slot)->update_flags_for_input_section(flags);
757               return *output_section_slot;
758             }
759
760           // We don't put sections found in the linker script into
761           // SECTION_NAME_MAP_.  That keeps us from getting confused
762           // if an orphan section is mapped to a section with the same
763           // name as one in the linker script.
764
765           name = this->namepool_.add(name, false, NULL);
766
767           Output_section* os = this->make_output_section(name, type, flags,
768                                                          order, is_relro);
769
770           os->set_found_in_sections_clause();
771
772           // Special handling for NOLOAD sections.
773           if (script_section_type == Script_sections::ST_NOLOAD)
774             {
775               os->set_is_noload();
776
777               // The constructor of Output_section sets addresses of non-ALLOC
778               // sections to 0 by default.  We don't want that for NOLOAD
779               // sections even if they have no SHF_ALLOC flag.
780               if ((os->flags() & elfcpp::SHF_ALLOC) == 0
781                   && os->is_address_valid())
782                 {
783                   gold_assert(os->address() == 0
784                               && !os->is_offset_valid()
785                               && !os->is_data_size_valid());
786                   os->reset_address_and_file_offset();
787                 }
788             }
789
790           *output_section_slot = os;
791           return os;
792         }
793     }
794
795   // FIXME: Handle SHF_OS_NONCONFORMING somewhere.
796
797   size_t len = strlen(name);
798   char* uncompressed_name = NULL;
799
800   // Compressed debug sections should be mapped to the corresponding
801   // uncompressed section.
802   if (is_compressed_debug_section(name))
803     {
804       uncompressed_name = new char[len];
805       uncompressed_name[0] = '.';
806       gold_assert(name[0] == '.' && name[1] == 'z');
807       strncpy(&uncompressed_name[1], &name[2], len - 2);
808       uncompressed_name[len - 1] = '\0';
809       len -= 1;
810       name = uncompressed_name;
811     }
812
813   // Turn NAME from the name of the input section into the name of the
814   // output section.
815   if (is_input_section
816       && !this->script_options_->saw_sections_clause()
817       && !parameters->options().relocatable())
818     name = Layout::output_section_name(name, &len);
819
820   Stringpool::Key name_key;
821   name = this->namepool_.add_with_length(name, len, true, &name_key);
822
823   if (uncompressed_name != NULL)
824     delete[] uncompressed_name;
825
826   // Find or make the output section.  The output section is selected
827   // based on the section name, type, and flags.
828   return this->get_output_section(name, name_key, type, flags, order, is_relro);
829 }
830
831 // For incremental links, record the initial fixed layout of a section
832 // from the base file, and return a pointer to the Output_section.
833
834 template<int size, bool big_endian>
835 Output_section*
836 Layout::init_fixed_output_section(const char* name,
837                                   elfcpp::Shdr<size, big_endian>& shdr)
838 {
839   unsigned int sh_type = shdr.get_sh_type();
840
841   // We preserve the layout of PROGBITS, NOBITS, and NOTE sections.
842   // All others will be created from scratch and reallocated.
843   if (sh_type != elfcpp::SHT_PROGBITS
844       && sh_type != elfcpp::SHT_NOBITS
845       && sh_type != elfcpp::SHT_NOTE)
846     return NULL;
847
848   typename elfcpp::Elf_types<size>::Elf_Addr sh_addr = shdr.get_sh_addr();
849   typename elfcpp::Elf_types<size>::Elf_Off sh_offset = shdr.get_sh_offset();
850   typename elfcpp::Elf_types<size>::Elf_WXword sh_size = shdr.get_sh_size();
851   typename elfcpp::Elf_types<size>::Elf_WXword sh_flags = shdr.get_sh_flags();
852   typename elfcpp::Elf_types<size>::Elf_WXword sh_addralign =
853       shdr.get_sh_addralign();
854
855   // Make the output section.
856   Stringpool::Key name_key;
857   name = this->namepool_.add(name, true, &name_key);
858   Output_section* os = this->get_output_section(name, name_key, sh_type,
859                                                 sh_flags, ORDER_INVALID, false);
860   os->set_fixed_layout(sh_addr, sh_offset, sh_size, sh_addralign);
861   if (sh_type != elfcpp::SHT_NOBITS)
862     this->free_list_.remove(sh_offset, sh_offset + sh_size);
863   return os;
864 }
865
866 // Return the output section to use for input section SHNDX, with name
867 // NAME, with header HEADER, from object OBJECT.  RELOC_SHNDX is the
868 // index of a relocation section which applies to this section, or 0
869 // if none, or -1U if more than one.  RELOC_TYPE is the type of the
870 // relocation section if there is one.  Set *OFF to the offset of this
871 // input section without the output section.  Return NULL if the
872 // section should be discarded.  Set *OFF to -1 if the section
873 // contents should not be written directly to the output file, but
874 // will instead receive special handling.
875
876 template<int size, bool big_endian>
877 Output_section*
878 Layout::layout(Sized_relobj_file<size, big_endian>* object, unsigned int shndx,
879                const char* name, const elfcpp::Shdr<size, big_endian>& shdr,
880                unsigned int reloc_shndx, unsigned int, off_t* off)
881 {
882   *off = 0;
883
884   if (!this->include_section(object, name, shdr))
885     return NULL;
886
887   Output_section* os;
888
889   // Sometimes .init_array*, .preinit_array* and .fini_array* do not have
890   // correct section types.  Force them here.
891   elfcpp::Elf_Word sh_type = shdr.get_sh_type();
892   if (sh_type == elfcpp::SHT_PROGBITS)
893     {
894       static const char init_array_prefix[] = ".init_array";
895       static const char preinit_array_prefix[] = ".preinit_array";
896       static const char fini_array_prefix[] = ".fini_array";
897       static size_t init_array_prefix_size = sizeof(init_array_prefix) - 1;
898       static size_t preinit_array_prefix_size =
899         sizeof(preinit_array_prefix) - 1;
900       static size_t fini_array_prefix_size = sizeof(fini_array_prefix) - 1;
901
902       if (strncmp(name, init_array_prefix, init_array_prefix_size) == 0)
903         sh_type = elfcpp::SHT_INIT_ARRAY;
904       else if (strncmp(name, preinit_array_prefix, preinit_array_prefix_size)
905                == 0)
906         sh_type = elfcpp::SHT_PREINIT_ARRAY;
907       else if (strncmp(name, fini_array_prefix, fini_array_prefix_size) == 0)
908         sh_type = elfcpp::SHT_FINI_ARRAY;
909     }
910
911   // In a relocatable link a grouped section must not be combined with
912   // any other sections.
913   if (parameters->options().relocatable()
914       && (shdr.get_sh_flags() & elfcpp::SHF_GROUP) != 0)
915     {
916       name = this->namepool_.add(name, true, NULL);
917       os = this->make_output_section(name, sh_type, shdr.get_sh_flags(),
918                                      ORDER_INVALID, false);
919     }
920   else
921     {
922       os = this->choose_output_section(object, name, sh_type,
923                                        shdr.get_sh_flags(), true,
924                                        ORDER_INVALID, false);
925       if (os == NULL)
926         return NULL;
927     }
928
929   // By default the GNU linker sorts input sections whose names match
930   // .ctor.*, .dtor.*, .init_array.*, or .fini_array.*.  The sections
931   // are sorted by name.  This is used to implement constructor
932   // priority ordering.  We are compatible.
933   if (!this->script_options_->saw_sections_clause()
934       && (is_prefix_of(".ctors.", name)
935           || is_prefix_of(".dtors.", name)
936           || is_prefix_of(".init_array.", name)
937           || is_prefix_of(".fini_array.", name)))
938     os->set_must_sort_attached_input_sections();
939
940   // FIXME: Handle SHF_LINK_ORDER somewhere.
941
942   elfcpp::Elf_Xword orig_flags = os->flags();
943
944   *off = os->add_input_section(this, object, shndx, name, shdr, reloc_shndx,
945                                this->script_options_->saw_sections_clause());
946
947   // If the flags changed, we may have to change the order.
948   if ((orig_flags & elfcpp::SHF_ALLOC) != 0)
949     {
950       orig_flags &= (elfcpp::SHF_WRITE | elfcpp::SHF_EXECINSTR);
951       elfcpp::Elf_Xword new_flags =
952         os->flags() & (elfcpp::SHF_WRITE | elfcpp::SHF_EXECINSTR);
953       if (orig_flags != new_flags)
954         os->set_order(this->default_section_order(os, false));
955     }
956
957   this->have_added_input_section_ = true;
958
959   return os;
960 }
961
962 // Handle a relocation section when doing a relocatable link.
963
964 template<int size, bool big_endian>
965 Output_section*
966 Layout::layout_reloc(Sized_relobj_file<size, big_endian>* object,
967                      unsigned int,
968                      const elfcpp::Shdr<size, big_endian>& shdr,
969                      Output_section* data_section,
970                      Relocatable_relocs* rr)
971 {
972   gold_assert(parameters->options().relocatable()
973               || parameters->options().emit_relocs());
974
975   int sh_type = shdr.get_sh_type();
976
977   std::string name;
978   if (sh_type == elfcpp::SHT_REL)
979     name = ".rel";
980   else if (sh_type == elfcpp::SHT_RELA)
981     name = ".rela";
982   else
983     gold_unreachable();
984   name += data_section->name();
985
986   // In a relocatable link relocs for a grouped section must not be
987   // combined with other reloc sections.
988   Output_section* os;
989   if (!parameters->options().relocatable()
990       || (data_section->flags() & elfcpp::SHF_GROUP) == 0)
991     os = this->choose_output_section(object, name.c_str(), sh_type,
992                                      shdr.get_sh_flags(), false,
993                                      ORDER_INVALID, false);
994   else
995     {
996       const char* n = this->namepool_.add(name.c_str(), true, NULL);
997       os = this->make_output_section(n, sh_type, shdr.get_sh_flags(),
998                                      ORDER_INVALID, false);
999     }
1000
1001   os->set_should_link_to_symtab();
1002   os->set_info_section(data_section);
1003
1004   Output_section_data* posd;
1005   if (sh_type == elfcpp::SHT_REL)
1006     {
1007       os->set_entsize(elfcpp::Elf_sizes<size>::rel_size);
1008       posd = new Output_relocatable_relocs<elfcpp::SHT_REL,
1009                                            size,
1010                                            big_endian>(rr);
1011     }
1012   else if (sh_type == elfcpp::SHT_RELA)
1013     {
1014       os->set_entsize(elfcpp::Elf_sizes<size>::rela_size);
1015       posd = new Output_relocatable_relocs<elfcpp::SHT_RELA,
1016                                            size,
1017                                            big_endian>(rr);
1018     }
1019   else
1020     gold_unreachable();
1021
1022   os->add_output_section_data(posd);
1023   rr->set_output_data(posd);
1024
1025   return os;
1026 }
1027
1028 // Handle a group section when doing a relocatable link.
1029
1030 template<int size, bool big_endian>
1031 void
1032 Layout::layout_group(Symbol_table* symtab,
1033                      Sized_relobj_file<size, big_endian>* object,
1034                      unsigned int,
1035                      const char* group_section_name,
1036                      const char* signature,
1037                      const elfcpp::Shdr<size, big_endian>& shdr,
1038                      elfcpp::Elf_Word flags,
1039                      std::vector<unsigned int>* shndxes)
1040 {
1041   gold_assert(parameters->options().relocatable());
1042   gold_assert(shdr.get_sh_type() == elfcpp::SHT_GROUP);
1043   group_section_name = this->namepool_.add(group_section_name, true, NULL);
1044   Output_section* os = this->make_output_section(group_section_name,
1045                                                  elfcpp::SHT_GROUP,
1046                                                  shdr.get_sh_flags(),
1047                                                  ORDER_INVALID, false);
1048
1049   // We need to find a symbol with the signature in the symbol table.
1050   // If we don't find one now, we need to look again later.
1051   Symbol* sym = symtab->lookup(signature, NULL);
1052   if (sym != NULL)
1053     os->set_info_symndx(sym);
1054   else
1055     {
1056       // Reserve some space to minimize reallocations.
1057       if (this->group_signatures_.empty())
1058         this->group_signatures_.reserve(this->number_of_input_files_ * 16);
1059
1060       // We will wind up using a symbol whose name is the signature.
1061       // So just put the signature in the symbol name pool to save it.
1062       signature = symtab->canonicalize_name(signature);
1063       this->group_signatures_.push_back(Group_signature(os, signature));
1064     }
1065
1066   os->set_should_link_to_symtab();
1067   os->set_entsize(4);
1068
1069   section_size_type entry_count =
1070     convert_to_section_size_type(shdr.get_sh_size() / 4);
1071   Output_section_data* posd =
1072     new Output_data_group<size, big_endian>(object, entry_count, flags,
1073                                             shndxes);
1074   os->add_output_section_data(posd);
1075 }
1076
1077 // Special GNU handling of sections name .eh_frame.  They will
1078 // normally hold exception frame data as defined by the C++ ABI
1079 // (http://codesourcery.com/cxx-abi/).
1080
1081 template<int size, bool big_endian>
1082 Output_section*
1083 Layout::layout_eh_frame(Sized_relobj_file<size, big_endian>* object,
1084                         const unsigned char* symbols,
1085                         off_t symbols_size,
1086                         const unsigned char* symbol_names,
1087                         off_t symbol_names_size,
1088                         unsigned int shndx,
1089                         const elfcpp::Shdr<size, big_endian>& shdr,
1090                         unsigned int reloc_shndx, unsigned int reloc_type,
1091                         off_t* off)
1092 {
1093   gold_assert(shdr.get_sh_type() == elfcpp::SHT_PROGBITS);
1094   gold_assert((shdr.get_sh_flags() & elfcpp::SHF_ALLOC) != 0);
1095
1096   const char* const name = ".eh_frame";
1097   Output_section* os = this->choose_output_section(object, name,
1098                                                    elfcpp::SHT_PROGBITS,
1099                                                    elfcpp::SHF_ALLOC, false,
1100                                                    ORDER_EHFRAME, false);
1101   if (os == NULL)
1102     return NULL;
1103
1104   if (this->eh_frame_section_ == NULL)
1105     {
1106       this->eh_frame_section_ = os;
1107       this->eh_frame_data_ = new Eh_frame();
1108
1109       // For incremental linking, we do not optimize .eh_frame sections
1110       // or create a .eh_frame_hdr section.
1111       if (parameters->options().eh_frame_hdr() && !parameters->incremental())
1112         {
1113           Output_section* hdr_os =
1114             this->choose_output_section(NULL, ".eh_frame_hdr",
1115                                         elfcpp::SHT_PROGBITS,
1116                                         elfcpp::SHF_ALLOC, false,
1117                                         ORDER_EHFRAME, false);
1118
1119           if (hdr_os != NULL)
1120             {
1121               Eh_frame_hdr* hdr_posd = new Eh_frame_hdr(os,
1122                                                         this->eh_frame_data_);
1123               hdr_os->add_output_section_data(hdr_posd);
1124
1125               hdr_os->set_after_input_sections();
1126
1127               if (!this->script_options_->saw_phdrs_clause())
1128                 {
1129                   Output_segment* hdr_oseg;
1130                   hdr_oseg = this->make_output_segment(elfcpp::PT_GNU_EH_FRAME,
1131                                                        elfcpp::PF_R);
1132                   hdr_oseg->add_output_section_to_nonload(hdr_os,
1133                                                           elfcpp::PF_R);
1134                 }
1135
1136               this->eh_frame_data_->set_eh_frame_hdr(hdr_posd);
1137             }
1138         }
1139     }
1140
1141   gold_assert(this->eh_frame_section_ == os);
1142
1143   if (!parameters->incremental()
1144       && this->eh_frame_data_->add_ehframe_input_section(object,
1145                                                          symbols,
1146                                                          symbols_size,
1147                                                          symbol_names,
1148                                                          symbol_names_size,
1149                                                          shndx,
1150                                                          reloc_shndx,
1151                                                          reloc_type))
1152     {
1153       os->update_flags_for_input_section(shdr.get_sh_flags());
1154
1155       // A writable .eh_frame section is a RELRO section.
1156       if ((shdr.get_sh_flags() & elfcpp::SHF_WRITE) != 0)
1157         os->set_is_relro();
1158
1159       // We found a .eh_frame section we are going to optimize, so now
1160       // we can add the set of optimized sections to the output
1161       // section.  We need to postpone adding this until we've found a
1162       // section we can optimize so that the .eh_frame section in
1163       // crtbegin.o winds up at the start of the output section.
1164       if (!this->added_eh_frame_data_)
1165         {
1166           os->add_output_section_data(this->eh_frame_data_);
1167           this->added_eh_frame_data_ = true;
1168         }
1169       *off = -1;
1170     }
1171   else
1172     {
1173       // We couldn't handle this .eh_frame section for some reason.
1174       // Add it as a normal section.
1175       bool saw_sections_clause = this->script_options_->saw_sections_clause();
1176       *off = os->add_input_section(this, object, shndx, name, shdr, reloc_shndx,
1177                                    saw_sections_clause);
1178       this->have_added_input_section_ = true;
1179     }
1180
1181   return os;
1182 }
1183
1184 // Add POSD to an output section using NAME, TYPE, and FLAGS.  Return
1185 // the output section.
1186
1187 Output_section*
1188 Layout::add_output_section_data(const char* name, elfcpp::Elf_Word type,
1189                                 elfcpp::Elf_Xword flags,
1190                                 Output_section_data* posd,
1191                                 Output_section_order order, bool is_relro)
1192 {
1193   Output_section* os = this->choose_output_section(NULL, name, type, flags,
1194                                                    false, order, is_relro);
1195   if (os != NULL)
1196     os->add_output_section_data(posd);
1197   return os;
1198 }
1199
1200 // Map section flags to segment flags.
1201
1202 elfcpp::Elf_Word
1203 Layout::section_flags_to_segment(elfcpp::Elf_Xword flags)
1204 {
1205   elfcpp::Elf_Word ret = elfcpp::PF_R;
1206   if ((flags & elfcpp::SHF_WRITE) != 0)
1207     ret |= elfcpp::PF_W;
1208   if ((flags & elfcpp::SHF_EXECINSTR) != 0)
1209     ret |= elfcpp::PF_X;
1210   return ret;
1211 }
1212
1213 // Make a new Output_section, and attach it to segments as
1214 // appropriate.  ORDER is the order in which this section should
1215 // appear in the output segment.  IS_RELRO is true if this is a relro
1216 // (read-only after relocations) section.
1217
1218 Output_section*
1219 Layout::make_output_section(const char* name, elfcpp::Elf_Word type,
1220                             elfcpp::Elf_Xword flags,
1221                             Output_section_order order, bool is_relro)
1222 {
1223   Output_section* os;
1224   if ((flags & elfcpp::SHF_ALLOC) == 0
1225       && strcmp(parameters->options().compress_debug_sections(), "none") != 0
1226       && is_compressible_debug_section(name))
1227     os = new Output_compressed_section(&parameters->options(), name, type,
1228                                        flags);
1229   else if ((flags & elfcpp::SHF_ALLOC) == 0
1230            && parameters->options().strip_debug_non_line()
1231            && strcmp(".debug_abbrev", name) == 0)
1232     {
1233       os = this->debug_abbrev_ = new Output_reduced_debug_abbrev_section(
1234           name, type, flags);
1235       if (this->debug_info_)
1236         this->debug_info_->set_abbreviations(this->debug_abbrev_);
1237     }
1238   else if ((flags & elfcpp::SHF_ALLOC) == 0
1239            && parameters->options().strip_debug_non_line()
1240            && strcmp(".debug_info", name) == 0)
1241     {
1242       os = this->debug_info_ = new Output_reduced_debug_info_section(
1243           name, type, flags);
1244       if (this->debug_abbrev_)
1245         this->debug_info_->set_abbreviations(this->debug_abbrev_);
1246     }
1247   else
1248     {
1249       // FIXME: const_cast is ugly.
1250       Target* target = const_cast<Target*>(&parameters->target());
1251       os = target->make_output_section(name, type, flags);
1252     }
1253
1254   // With -z relro, we have to recognize the special sections by name.
1255   // There is no other way.
1256   bool is_relro_local = false;
1257   if (!this->script_options_->saw_sections_clause()
1258       && parameters->options().relro()
1259       && type == elfcpp::SHT_PROGBITS
1260       && (flags & elfcpp::SHF_ALLOC) != 0
1261       && (flags & elfcpp::SHF_WRITE) != 0)
1262     {
1263       if (strcmp(name, ".data.rel.ro") == 0)
1264         is_relro = true;
1265       else if (strcmp(name, ".data.rel.ro.local") == 0)
1266         {
1267           is_relro = true;
1268           is_relro_local = true;
1269         }
1270       else if (type == elfcpp::SHT_INIT_ARRAY
1271                || type == elfcpp::SHT_FINI_ARRAY
1272                || type == elfcpp::SHT_PREINIT_ARRAY)
1273         is_relro = true;
1274       else if (strcmp(name, ".ctors") == 0
1275                || strcmp(name, ".dtors") == 0
1276                || strcmp(name, ".jcr") == 0)
1277         is_relro = true;
1278     }
1279
1280   if (is_relro)
1281     os->set_is_relro();
1282
1283   if (order == ORDER_INVALID && (flags & elfcpp::SHF_ALLOC) != 0)
1284     order = this->default_section_order(os, is_relro_local);
1285
1286   os->set_order(order);
1287
1288   parameters->target().new_output_section(os);
1289
1290   this->section_list_.push_back(os);
1291
1292   // The GNU linker by default sorts some sections by priority, so we
1293   // do the same.  We need to know that this might happen before we
1294   // attach any input sections.
1295   if (!this->script_options_->saw_sections_clause()
1296       && (strcmp(name, ".ctors") == 0
1297           || strcmp(name, ".dtors") == 0
1298           || strcmp(name, ".init_array") == 0
1299           || strcmp(name, ".fini_array") == 0))
1300     os->set_may_sort_attached_input_sections();
1301
1302   // Check for .stab*str sections, as .stab* sections need to link to
1303   // them.
1304   if (type == elfcpp::SHT_STRTAB
1305       && !this->have_stabstr_section_
1306       && strncmp(name, ".stab", 5) == 0
1307       && strcmp(name + strlen(name) - 3, "str") == 0)
1308     this->have_stabstr_section_ = true;
1309
1310   // If we have already attached the sections to segments, then we
1311   // need to attach this one now.  This happens for sections created
1312   // directly by the linker.
1313   if (this->sections_are_attached_)
1314     this->attach_section_to_segment(os);
1315
1316   return os;
1317 }
1318
1319 // Return the default order in which a section should be placed in an
1320 // output segment.  This function captures a lot of the ideas in
1321 // ld/scripttempl/elf.sc in the GNU linker.  Note that the order of a
1322 // linker created section is normally set when the section is created;
1323 // this function is used for input sections.
1324
1325 Output_section_order
1326 Layout::default_section_order(Output_section* os, bool is_relro_local)
1327 {
1328   gold_assert((os->flags() & elfcpp::SHF_ALLOC) != 0);
1329   bool is_write = (os->flags() & elfcpp::SHF_WRITE) != 0;
1330   bool is_execinstr = (os->flags() & elfcpp::SHF_EXECINSTR) != 0;
1331   bool is_bss = false;
1332
1333   switch (os->type())
1334     {
1335     default:
1336     case elfcpp::SHT_PROGBITS:
1337       break;
1338     case elfcpp::SHT_NOBITS:
1339       is_bss = true;
1340       break;
1341     case elfcpp::SHT_RELA:
1342     case elfcpp::SHT_REL:
1343       if (!is_write)
1344         return ORDER_DYNAMIC_RELOCS;
1345       break;
1346     case elfcpp::SHT_HASH:
1347     case elfcpp::SHT_DYNAMIC:
1348     case elfcpp::SHT_SHLIB:
1349     case elfcpp::SHT_DYNSYM:
1350     case elfcpp::SHT_GNU_HASH:
1351     case elfcpp::SHT_GNU_verdef:
1352     case elfcpp::SHT_GNU_verneed:
1353     case elfcpp::SHT_GNU_versym:
1354       if (!is_write)
1355         return ORDER_DYNAMIC_LINKER;
1356       break;
1357     case elfcpp::SHT_NOTE:
1358       return is_write ? ORDER_RW_NOTE : ORDER_RO_NOTE;
1359     }
1360
1361   if ((os->flags() & elfcpp::SHF_TLS) != 0)
1362     return is_bss ? ORDER_TLS_BSS : ORDER_TLS_DATA;
1363
1364   if (!is_bss && !is_write)
1365     {
1366       if (is_execinstr)
1367         {
1368           if (strcmp(os->name(), ".init") == 0)
1369             return ORDER_INIT;
1370           else if (strcmp(os->name(), ".fini") == 0)
1371             return ORDER_FINI;
1372         }
1373       return is_execinstr ? ORDER_TEXT : ORDER_READONLY;
1374     }
1375
1376   if (os->is_relro())
1377     return is_relro_local ? ORDER_RELRO_LOCAL : ORDER_RELRO;
1378
1379   if (os->is_small_section())
1380     return is_bss ? ORDER_SMALL_BSS : ORDER_SMALL_DATA;
1381   if (os->is_large_section())
1382     return is_bss ? ORDER_LARGE_BSS : ORDER_LARGE_DATA;
1383
1384   return is_bss ? ORDER_BSS : ORDER_DATA;
1385 }
1386
1387 // Attach output sections to segments.  This is called after we have
1388 // seen all the input sections.
1389
1390 void
1391 Layout::attach_sections_to_segments()
1392 {
1393   for (Section_list::iterator p = this->section_list_.begin();
1394        p != this->section_list_.end();
1395        ++p)
1396     this->attach_section_to_segment(*p);
1397
1398   this->sections_are_attached_ = true;
1399 }
1400
1401 // Attach an output section to a segment.
1402
1403 void
1404 Layout::attach_section_to_segment(Output_section* os)
1405 {
1406   if ((os->flags() & elfcpp::SHF_ALLOC) == 0)
1407     this->unattached_section_list_.push_back(os);
1408   else
1409     this->attach_allocated_section_to_segment(os);
1410 }
1411
1412 // Attach an allocated output section to a segment.
1413
1414 void
1415 Layout::attach_allocated_section_to_segment(Output_section* os)
1416 {
1417   elfcpp::Elf_Xword flags = os->flags();
1418   gold_assert((flags & elfcpp::SHF_ALLOC) != 0);
1419
1420   if (parameters->options().relocatable())
1421     return;
1422
1423   // If we have a SECTIONS clause, we can't handle the attachment to
1424   // segments until after we've seen all the sections.
1425   if (this->script_options_->saw_sections_clause())
1426     return;
1427
1428   gold_assert(!this->script_options_->saw_phdrs_clause());
1429
1430   // This output section goes into a PT_LOAD segment.
1431
1432   elfcpp::Elf_Word seg_flags = Layout::section_flags_to_segment(flags);
1433
1434   // Check for --section-start.
1435   uint64_t addr;
1436   bool is_address_set = parameters->options().section_start(os->name(), &addr);
1437
1438   // In general the only thing we really care about for PT_LOAD
1439   // segments is whether or not they are writable or executable,
1440   // so that is how we search for them.
1441   // Large data sections also go into their own PT_LOAD segment.
1442   // People who need segments sorted on some other basis will
1443   // have to use a linker script.
1444
1445   Segment_list::const_iterator p;
1446   for (p = this->segment_list_.begin();
1447        p != this->segment_list_.end();
1448        ++p)
1449     {
1450       if ((*p)->type() != elfcpp::PT_LOAD)
1451         continue;
1452       if (!parameters->options().omagic()
1453           && ((*p)->flags() & elfcpp::PF_W) != (seg_flags & elfcpp::PF_W))
1454         continue;
1455       if (parameters->options().rosegment()
1456           && ((*p)->flags() & elfcpp::PF_X) != (seg_flags & elfcpp::PF_X))
1457         continue;
1458       // If -Tbss was specified, we need to separate the data and BSS
1459       // segments.
1460       if (parameters->options().user_set_Tbss())
1461         {
1462           if ((os->type() == elfcpp::SHT_NOBITS)
1463               == (*p)->has_any_data_sections())
1464             continue;
1465         }
1466       if (os->is_large_data_section() && !(*p)->is_large_data_segment())
1467         continue;
1468
1469       if (is_address_set)
1470         {
1471           if ((*p)->are_addresses_set())
1472             continue;
1473
1474           (*p)->add_initial_output_data(os);
1475           (*p)->update_flags_for_output_section(seg_flags);
1476           (*p)->set_addresses(addr, addr);
1477           break;
1478         }
1479
1480       (*p)->add_output_section_to_load(this, os, seg_flags);
1481       break;
1482     }
1483
1484   if (p == this->segment_list_.end())
1485     {
1486       Output_segment* oseg = this->make_output_segment(elfcpp::PT_LOAD,
1487                                                        seg_flags);
1488       if (os->is_large_data_section())
1489         oseg->set_is_large_data_segment();
1490       oseg->add_output_section_to_load(this, os, seg_flags);
1491       if (is_address_set)
1492         oseg->set_addresses(addr, addr);
1493     }
1494
1495   // If we see a loadable SHT_NOTE section, we create a PT_NOTE
1496   // segment.
1497   if (os->type() == elfcpp::SHT_NOTE)
1498     {
1499       // See if we already have an equivalent PT_NOTE segment.
1500       for (p = this->segment_list_.begin();
1501            p != segment_list_.end();
1502            ++p)
1503         {
1504           if ((*p)->type() == elfcpp::PT_NOTE
1505               && (((*p)->flags() & elfcpp::PF_W)
1506                   == (seg_flags & elfcpp::PF_W)))
1507             {
1508               (*p)->add_output_section_to_nonload(os, seg_flags);
1509               break;
1510             }
1511         }
1512
1513       if (p == this->segment_list_.end())
1514         {
1515           Output_segment* oseg = this->make_output_segment(elfcpp::PT_NOTE,
1516                                                            seg_flags);
1517           oseg->add_output_section_to_nonload(os, seg_flags);
1518         }
1519     }
1520
1521   // If we see a loadable SHF_TLS section, we create a PT_TLS
1522   // segment.  There can only be one such segment.
1523   if ((flags & elfcpp::SHF_TLS) != 0)
1524     {
1525       if (this->tls_segment_ == NULL)
1526         this->make_output_segment(elfcpp::PT_TLS, seg_flags);
1527       this->tls_segment_->add_output_section_to_nonload(os, seg_flags);
1528     }
1529
1530   // If -z relro is in effect, and we see a relro section, we create a
1531   // PT_GNU_RELRO segment.  There can only be one such segment.
1532   if (os->is_relro() && parameters->options().relro())
1533     {
1534       gold_assert(seg_flags == (elfcpp::PF_R | elfcpp::PF_W));
1535       if (this->relro_segment_ == NULL)
1536         this->make_output_segment(elfcpp::PT_GNU_RELRO, seg_flags);
1537       this->relro_segment_->add_output_section_to_nonload(os, seg_flags);
1538     }
1539
1540   // If we are making a shared library, and we see a section named
1541   // .interp, and the -dynamic-linker option was not used, then put
1542   // the .interp section into a PT_INTERP segment.  This is for GNU ld
1543   // compatibility.  If making an executable, or if the
1544   // -dynamic-linker option was used, we will create the section and
1545   // segment in Layout::create_interp.
1546   if (strcmp(os->name(), ".interp") == 0
1547       && parameters->options().shared()
1548       && parameters->options().dynamic_linker() == NULL)
1549     {
1550       if (this->interp_segment_ == NULL)
1551         this->make_output_segment(elfcpp::PT_INTERP, seg_flags);
1552       this->interp_segment_->add_output_section_to_nonload(os, seg_flags);
1553     }
1554 }
1555
1556 // Make an output section for a script.
1557
1558 Output_section*
1559 Layout::make_output_section_for_script(
1560     const char* name,
1561     Script_sections::Section_type section_type)
1562 {
1563   name = this->namepool_.add(name, false, NULL);
1564   elfcpp::Elf_Xword sh_flags = elfcpp::SHF_ALLOC;
1565   if (section_type == Script_sections::ST_NOLOAD)
1566     sh_flags = 0;
1567   Output_section* os = this->make_output_section(name, elfcpp::SHT_PROGBITS,
1568                                                  sh_flags, ORDER_INVALID,
1569                                                  false);
1570   os->set_found_in_sections_clause();
1571   if (section_type == Script_sections::ST_NOLOAD)
1572     os->set_is_noload();
1573   return os;
1574 }
1575
1576 // Return the number of segments we expect to see.
1577
1578 size_t
1579 Layout::expected_segment_count() const
1580 {
1581   size_t ret = this->segment_list_.size();
1582
1583   // If we didn't see a SECTIONS clause in a linker script, we should
1584   // already have the complete list of segments.  Otherwise we ask the
1585   // SECTIONS clause how many segments it expects, and add in the ones
1586   // we already have (PT_GNU_STACK, PT_GNU_EH_FRAME, etc.)
1587
1588   if (!this->script_options_->saw_sections_clause())
1589     return ret;
1590   else
1591     {
1592       const Script_sections* ss = this->script_options_->script_sections();
1593       return ret + ss->expected_segment_count(this);
1594     }
1595 }
1596
1597 // Handle the .note.GNU-stack section at layout time.  SEEN_GNU_STACK
1598 // is whether we saw a .note.GNU-stack section in the object file.
1599 // GNU_STACK_FLAGS is the section flags.  The flags give the
1600 // protection required for stack memory.  We record this in an
1601 // executable as a PT_GNU_STACK segment.  If an object file does not
1602 // have a .note.GNU-stack segment, we must assume that it is an old
1603 // object.  On some targets that will force an executable stack.
1604
1605 void
1606 Layout::layout_gnu_stack(bool seen_gnu_stack, uint64_t gnu_stack_flags,
1607                          const Object* obj)
1608 {
1609   if (!seen_gnu_stack)
1610     {
1611       this->input_without_gnu_stack_note_ = true;
1612       if (parameters->options().warn_execstack()
1613           && parameters->target().is_default_stack_executable())
1614         gold_warning(_("%s: missing .note.GNU-stack section"
1615                        " implies executable stack"),
1616                      obj->name().c_str());
1617     }
1618   else
1619     {
1620       this->input_with_gnu_stack_note_ = true;
1621       if ((gnu_stack_flags & elfcpp::SHF_EXECINSTR) != 0)
1622         {
1623           this->input_requires_executable_stack_ = true;
1624           if (parameters->options().warn_execstack()
1625               || parameters->options().is_stack_executable())
1626             gold_warning(_("%s: requires executable stack"),
1627                          obj->name().c_str());
1628         }
1629     }
1630 }
1631
1632 // Create automatic note sections.
1633
1634 void
1635 Layout::create_notes()
1636 {
1637   this->create_gold_note();
1638   this->create_executable_stack_info();
1639   this->create_build_id();
1640 }
1641
1642 // Create the dynamic sections which are needed before we read the
1643 // relocs.
1644
1645 void
1646 Layout::create_initial_dynamic_sections(Symbol_table* symtab)
1647 {
1648   if (parameters->doing_static_link())
1649     return;
1650
1651   this->dynamic_section_ = this->choose_output_section(NULL, ".dynamic",
1652                                                        elfcpp::SHT_DYNAMIC,
1653                                                        (elfcpp::SHF_ALLOC
1654                                                         | elfcpp::SHF_WRITE),
1655                                                        false, ORDER_RELRO,
1656                                                        true);
1657
1658   this->dynamic_symbol_ =
1659     symtab->define_in_output_data("_DYNAMIC", NULL, Symbol_table::PREDEFINED,
1660                                   this->dynamic_section_, 0, 0,
1661                                   elfcpp::STT_OBJECT, elfcpp::STB_LOCAL,
1662                                   elfcpp::STV_HIDDEN, 0, false, false);
1663
1664   this->dynamic_data_ =  new Output_data_dynamic(&this->dynpool_);
1665
1666   this->dynamic_section_->add_output_section_data(this->dynamic_data_);
1667 }
1668
1669 // For each output section whose name can be represented as C symbol,
1670 // define __start and __stop symbols for the section.  This is a GNU
1671 // extension.
1672
1673 void
1674 Layout::define_section_symbols(Symbol_table* symtab)
1675 {
1676   for (Section_list::const_iterator p = this->section_list_.begin();
1677        p != this->section_list_.end();
1678        ++p)
1679     {
1680       const char* const name = (*p)->name();
1681       if (is_cident(name))
1682         {
1683           const std::string name_string(name);
1684           const std::string start_name(cident_section_start_prefix
1685                                        + name_string);
1686           const std::string stop_name(cident_section_stop_prefix
1687                                       + name_string);
1688
1689           symtab->define_in_output_data(start_name.c_str(),
1690                                         NULL, // version
1691                                         Symbol_table::PREDEFINED,
1692                                         *p,
1693                                         0, // value
1694                                         0, // symsize
1695                                         elfcpp::STT_NOTYPE,
1696                                         elfcpp::STB_GLOBAL,
1697                                         elfcpp::STV_DEFAULT,
1698                                         0, // nonvis
1699                                         false, // offset_is_from_end
1700                                         true); // only_if_ref
1701
1702           symtab->define_in_output_data(stop_name.c_str(),
1703                                         NULL, // version
1704                                         Symbol_table::PREDEFINED,
1705                                         *p,
1706                                         0, // value
1707                                         0, // symsize
1708                                         elfcpp::STT_NOTYPE,
1709                                         elfcpp::STB_GLOBAL,
1710                                         elfcpp::STV_DEFAULT,
1711                                         0, // nonvis
1712                                         true, // offset_is_from_end
1713                                         true); // only_if_ref
1714         }
1715     }
1716 }
1717
1718 // Define symbols for group signatures.
1719
1720 void
1721 Layout::define_group_signatures(Symbol_table* symtab)
1722 {
1723   for (Group_signatures::iterator p = this->group_signatures_.begin();
1724        p != this->group_signatures_.end();
1725        ++p)
1726     {
1727       Symbol* sym = symtab->lookup(p->signature, NULL);
1728       if (sym != NULL)
1729         p->section->set_info_symndx(sym);
1730       else
1731         {
1732           // Force the name of the group section to the group
1733           // signature, and use the group's section symbol as the
1734           // signature symbol.
1735           if (strcmp(p->section->name(), p->signature) != 0)
1736             {
1737               const char* name = this->namepool_.add(p->signature,
1738                                                      true, NULL);
1739               p->section->set_name(name);
1740             }
1741           p->section->set_needs_symtab_index();
1742           p->section->set_info_section_symndx(p->section);
1743         }
1744     }
1745
1746   this->group_signatures_.clear();
1747 }
1748
1749 // Find the first read-only PT_LOAD segment, creating one if
1750 // necessary.
1751
1752 Output_segment*
1753 Layout::find_first_load_seg()
1754 {
1755   Output_segment* best = NULL;
1756   for (Segment_list::const_iterator p = this->segment_list_.begin();
1757        p != this->segment_list_.end();
1758        ++p)
1759     {
1760       if ((*p)->type() == elfcpp::PT_LOAD
1761           && ((*p)->flags() & elfcpp::PF_R) != 0
1762           && (parameters->options().omagic()
1763               || ((*p)->flags() & elfcpp::PF_W) == 0))
1764         {
1765           if (best == NULL || this->segment_precedes(*p, best))
1766             best = *p;
1767         }
1768     }
1769   if (best != NULL)
1770     return best;
1771
1772   gold_assert(!this->script_options_->saw_phdrs_clause());
1773
1774   Output_segment* load_seg = this->make_output_segment(elfcpp::PT_LOAD,
1775                                                        elfcpp::PF_R);
1776   return load_seg;
1777 }
1778
1779 // Save states of all current output segments.  Store saved states
1780 // in SEGMENT_STATES.
1781
1782 void
1783 Layout::save_segments(Segment_states* segment_states)
1784 {
1785   for (Segment_list::const_iterator p = this->segment_list_.begin();
1786        p != this->segment_list_.end();
1787        ++p)
1788     {
1789       Output_segment* segment = *p;
1790       // Shallow copy.
1791       Output_segment* copy = new Output_segment(*segment);
1792       (*segment_states)[segment] = copy;
1793     }
1794 }
1795
1796 // Restore states of output segments and delete any segment not found in
1797 // SEGMENT_STATES.
1798
1799 void
1800 Layout::restore_segments(const Segment_states* segment_states)
1801 {
1802   // Go through the segment list and remove any segment added in the
1803   // relaxation loop.
1804   this->tls_segment_ = NULL;
1805   this->relro_segment_ = NULL;
1806   Segment_list::iterator list_iter = this->segment_list_.begin();
1807   while (list_iter != this->segment_list_.end())
1808     {
1809       Output_segment* segment = *list_iter;
1810       Segment_states::const_iterator states_iter =
1811           segment_states->find(segment);
1812       if (states_iter != segment_states->end())
1813         {
1814           const Output_segment* copy = states_iter->second;
1815           // Shallow copy to restore states.
1816           *segment = *copy;
1817
1818           // Also fix up TLS and RELRO segment pointers as appropriate.
1819           if (segment->type() == elfcpp::PT_TLS)
1820             this->tls_segment_ = segment;
1821           else if (segment->type() == elfcpp::PT_GNU_RELRO)
1822             this->relro_segment_ = segment;
1823
1824           ++list_iter;
1825         } 
1826       else
1827         {
1828           list_iter = this->segment_list_.erase(list_iter); 
1829           // This is a segment created during section layout.  It should be
1830           // safe to remove it since we should have removed all pointers to it.
1831           delete segment;
1832         }
1833     }
1834 }
1835
1836 // Clean up after relaxation so that sections can be laid out again.
1837
1838 void
1839 Layout::clean_up_after_relaxation()
1840 {
1841   // Restore the segments to point state just prior to the relaxation loop.
1842   Script_sections* script_section = this->script_options_->script_sections();
1843   script_section->release_segments();
1844   this->restore_segments(this->segment_states_);
1845
1846   // Reset section addresses and file offsets
1847   for (Section_list::iterator p = this->section_list_.begin();
1848        p != this->section_list_.end();
1849        ++p)
1850     {
1851       (*p)->restore_states();
1852
1853       // If an input section changes size because of relaxation,
1854       // we need to adjust the section offsets of all input sections.
1855       // after such a section.
1856       if ((*p)->section_offsets_need_adjustment())
1857         (*p)->adjust_section_offsets();
1858
1859       (*p)->reset_address_and_file_offset();
1860     }
1861   
1862   // Reset special output object address and file offsets.
1863   for (Data_list::iterator p = this->special_output_list_.begin();
1864        p != this->special_output_list_.end();
1865        ++p)
1866     (*p)->reset_address_and_file_offset();
1867
1868   // A linker script may have created some output section data objects.
1869   // They are useless now.
1870   for (Output_section_data_list::const_iterator p =
1871          this->script_output_section_data_list_.begin();
1872        p != this->script_output_section_data_list_.end();
1873        ++p)
1874     delete *p;
1875   this->script_output_section_data_list_.clear(); 
1876 }
1877
1878 // Prepare for relaxation.
1879
1880 void
1881 Layout::prepare_for_relaxation()
1882 {
1883   // Create an relaxation debug check if in debugging mode.
1884   if (is_debugging_enabled(DEBUG_RELAXATION))
1885     this->relaxation_debug_check_ = new Relaxation_debug_check();
1886
1887   // Save segment states.
1888   this->segment_states_ = new Segment_states();
1889   this->save_segments(this->segment_states_);
1890
1891   for(Section_list::const_iterator p = this->section_list_.begin();
1892       p != this->section_list_.end();
1893       ++p)
1894     (*p)->save_states();
1895
1896   if (is_debugging_enabled(DEBUG_RELAXATION))
1897     this->relaxation_debug_check_->check_output_data_for_reset_values(
1898         this->section_list_, this->special_output_list_);
1899
1900   // Also enable recording of output section data from scripts.
1901   this->record_output_section_data_from_script_ = true;
1902 }
1903
1904 // Relaxation loop body:  If target has no relaxation, this runs only once
1905 // Otherwise, the target relaxation hook is called at the end of
1906 // each iteration.  If the hook returns true, it means re-layout of
1907 // section is required.  
1908 //
1909 // The number of segments created by a linking script without a PHDRS
1910 // clause may be affected by section sizes and alignments.  There is
1911 // a remote chance that relaxation causes different number of PT_LOAD
1912 // segments are created and sections are attached to different segments.
1913 // Therefore, we always throw away all segments created during section
1914 // layout.  In order to be able to restart the section layout, we keep
1915 // a copy of the segment list right before the relaxation loop and use
1916 // that to restore the segments.
1917 // 
1918 // PASS is the current relaxation pass number. 
1919 // SYMTAB is a symbol table.
1920 // PLOAD_SEG is the address of a pointer for the load segment.
1921 // PHDR_SEG is a pointer to the PHDR segment.
1922 // SEGMENT_HEADERS points to the output segment header.
1923 // FILE_HEADER points to the output file header.
1924 // PSHNDX is the address to store the output section index.
1925
1926 off_t inline
1927 Layout::relaxation_loop_body(
1928     int pass,
1929     Target* target,
1930     Symbol_table* symtab,
1931     Output_segment** pload_seg,
1932     Output_segment* phdr_seg,
1933     Output_segment_headers* segment_headers,
1934     Output_file_header* file_header,
1935     unsigned int* pshndx)
1936 {
1937   // If this is not the first iteration, we need to clean up after
1938   // relaxation so that we can lay out the sections again.
1939   if (pass != 0)
1940     this->clean_up_after_relaxation();
1941
1942   // If there is a SECTIONS clause, put all the input sections into
1943   // the required order.
1944   Output_segment* load_seg;
1945   if (this->script_options_->saw_sections_clause())
1946     load_seg = this->set_section_addresses_from_script(symtab);
1947   else if (parameters->options().relocatable())
1948     load_seg = NULL;
1949   else
1950     load_seg = this->find_first_load_seg();
1951
1952   if (parameters->options().oformat_enum()
1953       != General_options::OBJECT_FORMAT_ELF)
1954     load_seg = NULL;
1955
1956   // If the user set the address of the text segment, that may not be
1957   // compatible with putting the segment headers and file headers into
1958   // that segment.
1959   if (parameters->options().user_set_Ttext())
1960     load_seg = NULL;
1961
1962   gold_assert(phdr_seg == NULL
1963               || load_seg != NULL
1964               || this->script_options_->saw_sections_clause());
1965
1966   // If the address of the load segment we found has been set by
1967   // --section-start rather than by a script, then adjust the VMA and
1968   // LMA downward if possible to include the file and section headers.
1969   uint64_t header_gap = 0;
1970   if (load_seg != NULL
1971       && load_seg->are_addresses_set()
1972       && !this->script_options_->saw_sections_clause()
1973       && !parameters->options().relocatable())
1974     {
1975       file_header->finalize_data_size();
1976       segment_headers->finalize_data_size();
1977       size_t sizeof_headers = (file_header->data_size()
1978                                + segment_headers->data_size());
1979       const uint64_t abi_pagesize = target->abi_pagesize();
1980       uint64_t hdr_paddr = load_seg->paddr() - sizeof_headers;
1981       hdr_paddr &= ~(abi_pagesize - 1);
1982       uint64_t subtract = load_seg->paddr() - hdr_paddr;
1983       if (load_seg->paddr() < subtract || load_seg->vaddr() < subtract)
1984         load_seg = NULL;
1985       else
1986         {
1987           load_seg->set_addresses(load_seg->vaddr() - subtract,
1988                                   load_seg->paddr() - subtract);
1989           header_gap = subtract - sizeof_headers;
1990         }
1991     }
1992
1993   // Lay out the segment headers.
1994   if (!parameters->options().relocatable())
1995     {
1996       gold_assert(segment_headers != NULL);
1997       if (header_gap != 0 && load_seg != NULL)
1998         {
1999           Output_data_zero_fill* z = new Output_data_zero_fill(header_gap, 1);
2000           load_seg->add_initial_output_data(z);
2001         }
2002       if (load_seg != NULL)
2003         load_seg->add_initial_output_data(segment_headers);
2004       if (phdr_seg != NULL)
2005         phdr_seg->add_initial_output_data(segment_headers);
2006     }
2007
2008   // Lay out the file header.
2009   if (load_seg != NULL)
2010     load_seg->add_initial_output_data(file_header);
2011
2012   if (this->script_options_->saw_phdrs_clause()
2013       && !parameters->options().relocatable())
2014     {
2015       // Support use of FILEHDRS and PHDRS attachments in a PHDRS
2016       // clause in a linker script.
2017       Script_sections* ss = this->script_options_->script_sections();
2018       ss->put_headers_in_phdrs(file_header, segment_headers);
2019     }
2020
2021   // We set the output section indexes in set_segment_offsets and
2022   // set_section_indexes.
2023   *pshndx = 1;
2024
2025   // Set the file offsets of all the segments, and all the sections
2026   // they contain.
2027   off_t off;
2028   if (!parameters->options().relocatable())
2029     off = this->set_segment_offsets(target, load_seg, pshndx);
2030   else
2031     off = this->set_relocatable_section_offsets(file_header, pshndx);
2032
2033    // Verify that the dummy relaxation does not change anything.
2034   if (is_debugging_enabled(DEBUG_RELAXATION))
2035     {
2036       if (pass == 0)
2037         this->relaxation_debug_check_->read_sections(this->section_list_);
2038       else
2039         this->relaxation_debug_check_->verify_sections(this->section_list_);
2040     }
2041
2042   *pload_seg = load_seg;
2043   return off;
2044 }
2045
2046 // Search the list of patterns and find the postion of the given section
2047 // name in the output section.  If the section name matches a glob
2048 // pattern and a non-glob name, then the non-glob position takes
2049 // precedence.  Return 0 if no match is found.
2050
2051 unsigned int
2052 Layout::find_section_order_index(const std::string& section_name)
2053 {
2054   Unordered_map<std::string, unsigned int>::iterator map_it;
2055   map_it = this->input_section_position_.find(section_name);
2056   if (map_it != this->input_section_position_.end())
2057     return map_it->second;
2058
2059   // Absolute match failed.  Linear search the glob patterns.
2060   std::vector<std::string>::iterator it;
2061   for (it = this->input_section_glob_.begin();
2062        it != this->input_section_glob_.end();
2063        ++it)
2064     {
2065        if (fnmatch((*it).c_str(), section_name.c_str(), FNM_NOESCAPE) == 0)
2066          {
2067            map_it = this->input_section_position_.find(*it);
2068            gold_assert(map_it != this->input_section_position_.end());
2069            return map_it->second;
2070          }
2071     }
2072   return 0;
2073 }
2074
2075 // Read the sequence of input sections from the file specified with
2076 // --section-ordering-file.
2077
2078 void
2079 Layout::read_layout_from_file()
2080 {
2081   const char* filename = parameters->options().section_ordering_file();
2082   std::ifstream in;
2083   std::string line;
2084
2085   in.open(filename);
2086   if (!in)
2087     gold_fatal(_("unable to open --section-ordering-file file %s: %s"),
2088                filename, strerror(errno));
2089
2090   std::getline(in, line);   // this chops off the trailing \n, if any
2091   unsigned int position = 1;
2092
2093   while (in)
2094     {
2095       if (!line.empty() && line[line.length() - 1] == '\r')   // Windows
2096         line.resize(line.length() - 1);
2097       // Ignore comments, beginning with '#'
2098       if (line[0] == '#')
2099         {
2100           std::getline(in, line);
2101           continue;
2102         }
2103       this->input_section_position_[line] = position;
2104       // Store all glob patterns in a vector.
2105       if (is_wildcard_string(line.c_str()))
2106         this->input_section_glob_.push_back(line);
2107       position++;
2108       std::getline(in, line);
2109     }
2110 }
2111
2112 // Finalize the layout.  When this is called, we have created all the
2113 // output sections and all the output segments which are based on
2114 // input sections.  We have several things to do, and we have to do
2115 // them in the right order, so that we get the right results correctly
2116 // and efficiently.
2117
2118 // 1) Finalize the list of output segments and create the segment
2119 // table header.
2120
2121 // 2) Finalize the dynamic symbol table and associated sections.
2122
2123 // 3) Determine the final file offset of all the output segments.
2124
2125 // 4) Determine the final file offset of all the SHF_ALLOC output
2126 // sections.
2127
2128 // 5) Create the symbol table sections and the section name table
2129 // section.
2130
2131 // 6) Finalize the symbol table: set symbol values to their final
2132 // value and make a final determination of which symbols are going
2133 // into the output symbol table.
2134
2135 // 7) Create the section table header.
2136
2137 // 8) Determine the final file offset of all the output sections which
2138 // are not SHF_ALLOC, including the section table header.
2139
2140 // 9) Finalize the ELF file header.
2141
2142 // This function returns the size of the output file.
2143
2144 off_t
2145 Layout::finalize(const Input_objects* input_objects, Symbol_table* symtab,
2146                  Target* target, const Task* task)
2147 {
2148   target->finalize_sections(this, input_objects, symtab);
2149
2150   this->count_local_symbols(task, input_objects);
2151
2152   this->link_stabs_sections();
2153
2154   Output_segment* phdr_seg = NULL;
2155   if (!parameters->options().relocatable() && !parameters->doing_static_link())
2156     {
2157       // There was a dynamic object in the link.  We need to create
2158       // some information for the dynamic linker.
2159
2160       // Create the PT_PHDR segment which will hold the program
2161       // headers.
2162       if (!this->script_options_->saw_phdrs_clause())
2163         phdr_seg = this->make_output_segment(elfcpp::PT_PHDR, elfcpp::PF_R);
2164
2165       // Create the dynamic symbol table, including the hash table.
2166       Output_section* dynstr;
2167       std::vector<Symbol*> dynamic_symbols;
2168       unsigned int local_dynamic_count;
2169       Versions versions(*this->script_options()->version_script_info(),
2170                         &this->dynpool_);
2171       this->create_dynamic_symtab(input_objects, symtab, &dynstr,
2172                                   &local_dynamic_count, &dynamic_symbols,
2173                                   &versions);
2174
2175       // Create the .interp section to hold the name of the
2176       // interpreter, and put it in a PT_INTERP segment.
2177       if (!parameters->options().shared()
2178           || parameters->options().dynamic_linker() != NULL)
2179         this->create_interp(target);
2180
2181       // Finish the .dynamic section to hold the dynamic data, and put
2182       // it in a PT_DYNAMIC segment.
2183       this->finish_dynamic_section(input_objects, symtab);
2184
2185       // We should have added everything we need to the dynamic string
2186       // table.
2187       this->dynpool_.set_string_offsets();
2188
2189       // Create the version sections.  We can't do this until the
2190       // dynamic string table is complete.
2191       this->create_version_sections(&versions, symtab, local_dynamic_count,
2192                                     dynamic_symbols, dynstr);
2193
2194       // Set the size of the _DYNAMIC symbol.  We can't do this until
2195       // after we call create_version_sections.
2196       this->set_dynamic_symbol_size(symtab);
2197     }
2198   
2199   // Create segment headers.
2200   Output_segment_headers* segment_headers =
2201     (parameters->options().relocatable()
2202      ? NULL
2203      : new Output_segment_headers(this->segment_list_));
2204
2205   // Lay out the file header.
2206   Output_file_header* file_header = new Output_file_header(target, symtab,
2207                                                            segment_headers);
2208
2209   this->special_output_list_.push_back(file_header);
2210   if (segment_headers != NULL)
2211     this->special_output_list_.push_back(segment_headers);
2212
2213   // Find approriate places for orphan output sections if we are using
2214   // a linker script.
2215   if (this->script_options_->saw_sections_clause())
2216     this->place_orphan_sections_in_script();
2217   
2218   Output_segment* load_seg;
2219   off_t off;
2220   unsigned int shndx;
2221   int pass = 0;
2222
2223   // Take a snapshot of the section layout as needed.
2224   if (target->may_relax())
2225     this->prepare_for_relaxation();
2226   
2227   // Run the relaxation loop to lay out sections.
2228   do
2229     {
2230       off = this->relaxation_loop_body(pass, target, symtab, &load_seg,
2231                                        phdr_seg, segment_headers, file_header,
2232                                        &shndx);
2233       pass++;
2234     }
2235   while (target->may_relax()
2236          && target->relax(pass, input_objects, symtab, this, task));
2237
2238   // Set the file offsets of all the non-data sections we've seen so
2239   // far which don't have to wait for the input sections.  We need
2240   // this in order to finalize local symbols in non-allocated
2241   // sections.
2242   off = this->set_section_offsets(off, BEFORE_INPUT_SECTIONS_PASS);
2243
2244   // Set the section indexes of all unallocated sections seen so far,
2245   // in case any of them are somehow referenced by a symbol.
2246   shndx = this->set_section_indexes(shndx);
2247
2248   // Create the symbol table sections.
2249   this->create_symtab_sections(input_objects, symtab, shndx, &off);
2250   if (!parameters->doing_static_link())
2251     this->assign_local_dynsym_offsets(input_objects);
2252
2253   // Process any symbol assignments from a linker script.  This must
2254   // be called after the symbol table has been finalized.
2255   this->script_options_->finalize_symbols(symtab, this);
2256
2257   // Create the incremental inputs sections.
2258   if (this->incremental_inputs_)
2259     {
2260       this->incremental_inputs_->finalize();
2261       this->create_incremental_info_sections(symtab);
2262     }
2263
2264   // Create the .shstrtab section.
2265   Output_section* shstrtab_section = this->create_shstrtab();
2266
2267   // Set the file offsets of the rest of the non-data sections which
2268   // don't have to wait for the input sections.
2269   off = this->set_section_offsets(off, BEFORE_INPUT_SECTIONS_PASS);
2270
2271   // Now that all sections have been created, set the section indexes
2272   // for any sections which haven't been done yet.
2273   shndx = this->set_section_indexes(shndx);
2274
2275   // Create the section table header.
2276   this->create_shdrs(shstrtab_section, &off);
2277
2278   // If there are no sections which require postprocessing, we can
2279   // handle the section names now, and avoid a resize later.
2280   if (!this->any_postprocessing_sections_)
2281     {
2282       off = this->set_section_offsets(off,
2283                                       POSTPROCESSING_SECTIONS_PASS);
2284       off =
2285           this->set_section_offsets(off,
2286                                     STRTAB_AFTER_POSTPROCESSING_SECTIONS_PASS);
2287     }
2288
2289   file_header->set_section_info(this->section_headers_, shstrtab_section);
2290
2291   // Now we know exactly where everything goes in the output file
2292   // (except for non-allocated sections which require postprocessing).
2293   Output_data::layout_complete();
2294
2295   this->output_file_size_ = off;
2296
2297   return off;
2298 }
2299
2300 // Create a note header following the format defined in the ELF ABI.
2301 // NAME is the name, NOTE_TYPE is the type, SECTION_NAME is the name
2302 // of the section to create, DESCSZ is the size of the descriptor.
2303 // ALLOCATE is true if the section should be allocated in memory.
2304 // This returns the new note section.  It sets *TRAILING_PADDING to
2305 // the number of trailing zero bytes required.
2306
2307 Output_section*
2308 Layout::create_note(const char* name, int note_type,
2309                     const char* section_name, size_t descsz,
2310                     bool allocate, size_t* trailing_padding)
2311 {
2312   // Authorities all agree that the values in a .note field should
2313   // be aligned on 4-byte boundaries for 32-bit binaries.  However,
2314   // they differ on what the alignment is for 64-bit binaries.
2315   // The GABI says unambiguously they take 8-byte alignment:
2316   //    http://sco.com/developers/gabi/latest/ch5.pheader.html#note_section
2317   // Other documentation says alignment should always be 4 bytes:
2318   //    http://www.netbsd.org/docs/kernel/elf-notes.html#note-format
2319   // GNU ld and GNU readelf both support the latter (at least as of
2320   // version 2.16.91), and glibc always generates the latter for
2321   // .note.ABI-tag (as of version 1.6), so that's the one we go with
2322   // here.
2323 #ifdef GABI_FORMAT_FOR_DOTNOTE_SECTION   // This is not defined by default.
2324   const int size = parameters->target().get_size();
2325 #else
2326   const int size = 32;
2327 #endif
2328
2329   // The contents of the .note section.
2330   size_t namesz = strlen(name) + 1;
2331   size_t aligned_namesz = align_address(namesz, size / 8);
2332   size_t aligned_descsz = align_address(descsz, size / 8);
2333
2334   size_t notehdrsz = 3 * (size / 8) + aligned_namesz;
2335
2336   unsigned char* buffer = new unsigned char[notehdrsz];
2337   memset(buffer, 0, notehdrsz);
2338
2339   bool is_big_endian = parameters->target().is_big_endian();
2340
2341   if (size == 32)
2342     {
2343       if (!is_big_endian)
2344         {
2345           elfcpp::Swap<32, false>::writeval(buffer, namesz);
2346           elfcpp::Swap<32, false>::writeval(buffer + 4, descsz);
2347           elfcpp::Swap<32, false>::writeval(buffer + 8, note_type);
2348         }
2349       else
2350         {
2351           elfcpp::Swap<32, true>::writeval(buffer, namesz);
2352           elfcpp::Swap<32, true>::writeval(buffer + 4, descsz);
2353           elfcpp::Swap<32, true>::writeval(buffer + 8, note_type);
2354         }
2355     }
2356   else if (size == 64)
2357     {
2358       if (!is_big_endian)
2359         {
2360           elfcpp::Swap<64, false>::writeval(buffer, namesz);
2361           elfcpp::Swap<64, false>::writeval(buffer + 8, descsz);
2362           elfcpp::Swap<64, false>::writeval(buffer + 16, note_type);
2363         }
2364       else
2365         {
2366           elfcpp::Swap<64, true>::writeval(buffer, namesz);
2367           elfcpp::Swap<64, true>::writeval(buffer + 8, descsz);
2368           elfcpp::Swap<64, true>::writeval(buffer + 16, note_type);
2369         }
2370     }
2371   else
2372     gold_unreachable();
2373
2374   memcpy(buffer + 3 * (size / 8), name, namesz);
2375
2376   elfcpp::Elf_Xword flags = 0;
2377   Output_section_order order = ORDER_INVALID;
2378   if (allocate)
2379     {
2380       flags = elfcpp::SHF_ALLOC;
2381       order = ORDER_RO_NOTE;
2382     }
2383   Output_section* os = this->choose_output_section(NULL, section_name,
2384                                                    elfcpp::SHT_NOTE,
2385                                                    flags, false, order, false);
2386   if (os == NULL)
2387     return NULL;
2388
2389   Output_section_data* posd = new Output_data_const_buffer(buffer, notehdrsz,
2390                                                            size / 8,
2391                                                            "** note header");
2392   os->add_output_section_data(posd);
2393
2394   *trailing_padding = aligned_descsz - descsz;
2395
2396   return os;
2397 }
2398
2399 // For an executable or shared library, create a note to record the
2400 // version of gold used to create the binary.
2401
2402 void
2403 Layout::create_gold_note()
2404 {
2405   if (parameters->options().relocatable()
2406       || parameters->incremental_update())
2407     return;
2408
2409   std::string desc = std::string("gold ") + gold::get_version_string();
2410
2411   size_t trailing_padding;
2412   Output_section* os = this->create_note("GNU", elfcpp::NT_GNU_GOLD_VERSION,
2413                                          ".note.gnu.gold-version", desc.size(),
2414                                          false, &trailing_padding);
2415   if (os == NULL)
2416     return;
2417
2418   Output_section_data* posd = new Output_data_const(desc, 4);
2419   os->add_output_section_data(posd);
2420
2421   if (trailing_padding > 0)
2422     {
2423       posd = new Output_data_zero_fill(trailing_padding, 0);
2424       os->add_output_section_data(posd);
2425     }
2426 }
2427
2428 // Record whether the stack should be executable.  This can be set
2429 // from the command line using the -z execstack or -z noexecstack
2430 // options.  Otherwise, if any input file has a .note.GNU-stack
2431 // section with the SHF_EXECINSTR flag set, the stack should be
2432 // executable.  Otherwise, if at least one input file a
2433 // .note.GNU-stack section, and some input file has no .note.GNU-stack
2434 // section, we use the target default for whether the stack should be
2435 // executable.  Otherwise, we don't generate a stack note.  When
2436 // generating a object file, we create a .note.GNU-stack section with
2437 // the appropriate marking.  When generating an executable or shared
2438 // library, we create a PT_GNU_STACK segment.
2439
2440 void
2441 Layout::create_executable_stack_info()
2442 {
2443   bool is_stack_executable;
2444   if (parameters->options().is_execstack_set())
2445     is_stack_executable = parameters->options().is_stack_executable();
2446   else if (!this->input_with_gnu_stack_note_)
2447     return;
2448   else
2449     {
2450       if (this->input_requires_executable_stack_)
2451         is_stack_executable = true;
2452       else if (this->input_without_gnu_stack_note_)
2453         is_stack_executable =
2454           parameters->target().is_default_stack_executable();
2455       else
2456         is_stack_executable = false;
2457     }
2458
2459   if (parameters->options().relocatable())
2460     {
2461       const char* name = this->namepool_.add(".note.GNU-stack", false, NULL);
2462       elfcpp::Elf_Xword flags = 0;
2463       if (is_stack_executable)
2464         flags |= elfcpp::SHF_EXECINSTR;
2465       this->make_output_section(name, elfcpp::SHT_PROGBITS, flags,
2466                                 ORDER_INVALID, false);
2467     }
2468   else
2469     {
2470       if (this->script_options_->saw_phdrs_clause())
2471         return;
2472       int flags = elfcpp::PF_R | elfcpp::PF_W;
2473       if (is_stack_executable)
2474         flags |= elfcpp::PF_X;
2475       this->make_output_segment(elfcpp::PT_GNU_STACK, flags);
2476     }
2477 }
2478
2479 // If --build-id was used, set up the build ID note.
2480
2481 void
2482 Layout::create_build_id()
2483 {
2484   if (!parameters->options().user_set_build_id())
2485     return;
2486
2487   const char* style = parameters->options().build_id();
2488   if (strcmp(style, "none") == 0)
2489     return;
2490
2491   // Set DESCSZ to the size of the note descriptor.  When possible,
2492   // set DESC to the note descriptor contents.
2493   size_t descsz;
2494   std::string desc;
2495   if (strcmp(style, "md5") == 0)
2496     descsz = 128 / 8;
2497   else if (strcmp(style, "sha1") == 0)
2498     descsz = 160 / 8;
2499   else if (strcmp(style, "uuid") == 0)
2500     {
2501       const size_t uuidsz = 128 / 8;
2502
2503       char buffer[uuidsz];
2504       memset(buffer, 0, uuidsz);
2505
2506       int descriptor = open_descriptor(-1, "/dev/urandom", O_RDONLY);
2507       if (descriptor < 0)
2508         gold_error(_("--build-id=uuid failed: could not open /dev/urandom: %s"),
2509                    strerror(errno));
2510       else
2511         {
2512           ssize_t got = ::read(descriptor, buffer, uuidsz);
2513           release_descriptor(descriptor, true);
2514           if (got < 0)
2515             gold_error(_("/dev/urandom: read failed: %s"), strerror(errno));
2516           else if (static_cast<size_t>(got) != uuidsz)
2517             gold_error(_("/dev/urandom: expected %zu bytes, got %zd bytes"),
2518                        uuidsz, got);
2519         }
2520
2521       desc.assign(buffer, uuidsz);
2522       descsz = uuidsz;
2523     }
2524   else if (strncmp(style, "0x", 2) == 0)
2525     {
2526       hex_init();
2527       const char* p = style + 2;
2528       while (*p != '\0')
2529         {
2530           if (hex_p(p[0]) && hex_p(p[1]))
2531             {
2532               char c = (hex_value(p[0]) << 4) | hex_value(p[1]);
2533               desc += c;
2534               p += 2;
2535             }
2536           else if (*p == '-' || *p == ':')
2537             ++p;
2538           else
2539             gold_fatal(_("--build-id argument '%s' not a valid hex number"),
2540                        style);
2541         }
2542       descsz = desc.size();
2543     }
2544   else
2545     gold_fatal(_("unrecognized --build-id argument '%s'"), style);
2546
2547   // Create the note.
2548   size_t trailing_padding;
2549   Output_section* os = this->create_note("GNU", elfcpp::NT_GNU_BUILD_ID,
2550                                          ".note.gnu.build-id", descsz, true,
2551                                          &trailing_padding);
2552   if (os == NULL)
2553     return;
2554
2555   if (!desc.empty())
2556     {
2557       // We know the value already, so we fill it in now.
2558       gold_assert(desc.size() == descsz);
2559
2560       Output_section_data* posd = new Output_data_const(desc, 4);
2561       os->add_output_section_data(posd);
2562
2563       if (trailing_padding != 0)
2564         {
2565           posd = new Output_data_zero_fill(trailing_padding, 0);
2566           os->add_output_section_data(posd);
2567         }
2568     }
2569   else
2570     {
2571       // We need to compute a checksum after we have completed the
2572       // link.
2573       gold_assert(trailing_padding == 0);
2574       this->build_id_note_ = new Output_data_zero_fill(descsz, 4);
2575       os->add_output_section_data(this->build_id_note_);
2576     }
2577 }
2578
2579 // If we have both .stabXX and .stabXXstr sections, then the sh_link
2580 // field of the former should point to the latter.  I'm not sure who
2581 // started this, but the GNU linker does it, and some tools depend
2582 // upon it.
2583
2584 void
2585 Layout::link_stabs_sections()
2586 {
2587   if (!this->have_stabstr_section_)
2588     return;
2589
2590   for (Section_list::iterator p = this->section_list_.begin();
2591        p != this->section_list_.end();
2592        ++p)
2593     {
2594       if ((*p)->type() != elfcpp::SHT_STRTAB)
2595         continue;
2596
2597       const char* name = (*p)->name();
2598       if (strncmp(name, ".stab", 5) != 0)
2599         continue;
2600
2601       size_t len = strlen(name);
2602       if (strcmp(name + len - 3, "str") != 0)
2603         continue;
2604
2605       std::string stab_name(name, len - 3);
2606       Output_section* stab_sec;
2607       stab_sec = this->find_output_section(stab_name.c_str());
2608       if (stab_sec != NULL)
2609         stab_sec->set_link_section(*p);
2610     }
2611 }
2612
2613 // Create .gnu_incremental_inputs and related sections needed
2614 // for the next run of incremental linking to check what has changed.
2615
2616 void
2617 Layout::create_incremental_info_sections(Symbol_table* symtab)
2618 {
2619   Incremental_inputs* incr = this->incremental_inputs_;
2620
2621   gold_assert(incr != NULL);
2622
2623   // Create the .gnu_incremental_inputs, _symtab, and _relocs input sections.
2624   incr->create_data_sections(symtab);
2625
2626   // Add the .gnu_incremental_inputs section.
2627   const char* incremental_inputs_name =
2628     this->namepool_.add(".gnu_incremental_inputs", false, NULL);
2629   Output_section* incremental_inputs_os =
2630     this->make_output_section(incremental_inputs_name,
2631                               elfcpp::SHT_GNU_INCREMENTAL_INPUTS, 0,
2632                               ORDER_INVALID, false);
2633   incremental_inputs_os->add_output_section_data(incr->inputs_section());
2634
2635   // Add the .gnu_incremental_symtab section.
2636   const char* incremental_symtab_name =
2637     this->namepool_.add(".gnu_incremental_symtab", false, NULL);
2638   Output_section* incremental_symtab_os =
2639     this->make_output_section(incremental_symtab_name,
2640                               elfcpp::SHT_GNU_INCREMENTAL_SYMTAB, 0,
2641                               ORDER_INVALID, false);
2642   incremental_symtab_os->add_output_section_data(incr->symtab_section());
2643   incremental_symtab_os->set_entsize(4);
2644
2645   // Add the .gnu_incremental_relocs section.
2646   const char* incremental_relocs_name =
2647     this->namepool_.add(".gnu_incremental_relocs", false, NULL);
2648   Output_section* incremental_relocs_os =
2649     this->make_output_section(incremental_relocs_name,
2650                               elfcpp::SHT_GNU_INCREMENTAL_RELOCS, 0,
2651                               ORDER_INVALID, false);
2652   incremental_relocs_os->add_output_section_data(incr->relocs_section());
2653   incremental_relocs_os->set_entsize(incr->relocs_entsize());
2654
2655   // Add the .gnu_incremental_got_plt section.
2656   const char* incremental_got_plt_name =
2657     this->namepool_.add(".gnu_incremental_got_plt", false, NULL);
2658   Output_section* incremental_got_plt_os =
2659     this->make_output_section(incremental_got_plt_name,
2660                               elfcpp::SHT_GNU_INCREMENTAL_GOT_PLT, 0,
2661                               ORDER_INVALID, false);
2662   incremental_got_plt_os->add_output_section_data(incr->got_plt_section());
2663
2664   // Add the .gnu_incremental_strtab section.
2665   const char* incremental_strtab_name =
2666     this->namepool_.add(".gnu_incremental_strtab", false, NULL);
2667   Output_section* incremental_strtab_os = this->make_output_section(incremental_strtab_name,
2668                                                         elfcpp::SHT_STRTAB, 0,
2669                                                         ORDER_INVALID, false);
2670   Output_data_strtab* strtab_data =
2671       new Output_data_strtab(incr->get_stringpool());
2672   incremental_strtab_os->add_output_section_data(strtab_data);
2673
2674   incremental_inputs_os->set_after_input_sections();
2675   incremental_symtab_os->set_after_input_sections();
2676   incremental_relocs_os->set_after_input_sections();
2677   incremental_got_plt_os->set_after_input_sections();
2678
2679   incremental_inputs_os->set_link_section(incremental_strtab_os);
2680   incremental_symtab_os->set_link_section(incremental_inputs_os);
2681   incremental_relocs_os->set_link_section(incremental_inputs_os);
2682   incremental_got_plt_os->set_link_section(incremental_inputs_os);
2683 }
2684
2685 // Return whether SEG1 should be before SEG2 in the output file.  This
2686 // is based entirely on the segment type and flags.  When this is
2687 // called the segment addresses has normally not yet been set.
2688
2689 bool
2690 Layout::segment_precedes(const Output_segment* seg1,
2691                          const Output_segment* seg2)
2692 {
2693   elfcpp::Elf_Word type1 = seg1->type();
2694   elfcpp::Elf_Word type2 = seg2->type();
2695
2696   // The single PT_PHDR segment is required to precede any loadable
2697   // segment.  We simply make it always first.
2698   if (type1 == elfcpp::PT_PHDR)
2699     {
2700       gold_assert(type2 != elfcpp::PT_PHDR);
2701       return true;
2702     }
2703   if (type2 == elfcpp::PT_PHDR)
2704     return false;
2705
2706   // The single PT_INTERP segment is required to precede any loadable
2707   // segment.  We simply make it always second.
2708   if (type1 == elfcpp::PT_INTERP)
2709     {
2710       gold_assert(type2 != elfcpp::PT_INTERP);
2711       return true;
2712     }
2713   if (type2 == elfcpp::PT_INTERP)
2714     return false;
2715
2716   // We then put PT_LOAD segments before any other segments.
2717   if (type1 == elfcpp::PT_LOAD && type2 != elfcpp::PT_LOAD)
2718     return true;
2719   if (type2 == elfcpp::PT_LOAD && type1 != elfcpp::PT_LOAD)
2720     return false;
2721
2722   // We put the PT_TLS segment last except for the PT_GNU_RELRO
2723   // segment, because that is where the dynamic linker expects to find
2724   // it (this is just for efficiency; other positions would also work
2725   // correctly).
2726   if (type1 == elfcpp::PT_TLS
2727       && type2 != elfcpp::PT_TLS
2728       && type2 != elfcpp::PT_GNU_RELRO)
2729     return false;
2730   if (type2 == elfcpp::PT_TLS
2731       && type1 != elfcpp::PT_TLS
2732       && type1 != elfcpp::PT_GNU_RELRO)
2733     return true;
2734
2735   // We put the PT_GNU_RELRO segment last, because that is where the
2736   // dynamic linker expects to find it (as with PT_TLS, this is just
2737   // for efficiency).
2738   if (type1 == elfcpp::PT_GNU_RELRO && type2 != elfcpp::PT_GNU_RELRO)
2739     return false;
2740   if (type2 == elfcpp::PT_GNU_RELRO && type1 != elfcpp::PT_GNU_RELRO)
2741     return true;
2742
2743   const elfcpp::Elf_Word flags1 = seg1->flags();
2744   const elfcpp::Elf_Word flags2 = seg2->flags();
2745
2746   // The order of non-PT_LOAD segments is unimportant.  We simply sort
2747   // by the numeric segment type and flags values.  There should not
2748   // be more than one segment with the same type and flags.
2749   if (type1 != elfcpp::PT_LOAD)
2750     {
2751       if (type1 != type2)
2752         return type1 < type2;
2753       gold_assert(flags1 != flags2);
2754       return flags1 < flags2;
2755     }
2756
2757   // If the addresses are set already, sort by load address.
2758   if (seg1->are_addresses_set())
2759     {
2760       if (!seg2->are_addresses_set())
2761         return true;
2762
2763       unsigned int section_count1 = seg1->output_section_count();
2764       unsigned int section_count2 = seg2->output_section_count();
2765       if (section_count1 == 0 && section_count2 > 0)
2766         return true;
2767       if (section_count1 > 0 && section_count2 == 0)
2768         return false;
2769
2770       uint64_t paddr1 = (seg1->are_addresses_set()
2771                          ? seg1->paddr()
2772                          : seg1->first_section_load_address());
2773       uint64_t paddr2 = (seg2->are_addresses_set()
2774                          ? seg2->paddr()
2775                          : seg2->first_section_load_address());
2776
2777       if (paddr1 != paddr2)
2778         return paddr1 < paddr2;
2779     }
2780   else if (seg2->are_addresses_set())
2781     return false;
2782
2783   // A segment which holds large data comes after a segment which does
2784   // not hold large data.
2785   if (seg1->is_large_data_segment())
2786     {
2787       if (!seg2->is_large_data_segment())
2788         return false;
2789     }
2790   else if (seg2->is_large_data_segment())
2791     return true;
2792
2793   // Otherwise, we sort PT_LOAD segments based on the flags.  Readonly
2794   // segments come before writable segments.  Then writable segments
2795   // with data come before writable segments without data.  Then
2796   // executable segments come before non-executable segments.  Then
2797   // the unlikely case of a non-readable segment comes before the
2798   // normal case of a readable segment.  If there are multiple
2799   // segments with the same type and flags, we require that the
2800   // address be set, and we sort by virtual address and then physical
2801   // address.
2802   if ((flags1 & elfcpp::PF_W) != (flags2 & elfcpp::PF_W))
2803     return (flags1 & elfcpp::PF_W) == 0;
2804   if ((flags1 & elfcpp::PF_W) != 0
2805       && seg1->has_any_data_sections() != seg2->has_any_data_sections())
2806     return seg1->has_any_data_sections();
2807   if ((flags1 & elfcpp::PF_X) != (flags2 & elfcpp::PF_X))
2808     return (flags1 & elfcpp::PF_X) != 0;
2809   if ((flags1 & elfcpp::PF_R) != (flags2 & elfcpp::PF_R))
2810     return (flags1 & elfcpp::PF_R) == 0;
2811
2812   // We shouldn't get here--we shouldn't create segments which we
2813   // can't distinguish.
2814   gold_unreachable();
2815 }
2816
2817 // Increase OFF so that it is congruent to ADDR modulo ABI_PAGESIZE.
2818
2819 static off_t
2820 align_file_offset(off_t off, uint64_t addr, uint64_t abi_pagesize)
2821 {
2822   uint64_t unsigned_off = off;
2823   uint64_t aligned_off = ((unsigned_off & ~(abi_pagesize - 1))
2824                           | (addr & (abi_pagesize - 1)));
2825   if (aligned_off < unsigned_off)
2826     aligned_off += abi_pagesize;
2827   return aligned_off;
2828 }
2829
2830 // Set the file offsets of all the segments, and all the sections they
2831 // contain.  They have all been created.  LOAD_SEG must be be laid out
2832 // first.  Return the offset of the data to follow.
2833
2834 off_t
2835 Layout::set_segment_offsets(const Target* target, Output_segment* load_seg,
2836                             unsigned int* pshndx)
2837 {
2838   // Sort them into the final order.
2839   std::sort(this->segment_list_.begin(), this->segment_list_.end(),
2840             Layout::Compare_segments());
2841
2842   // Find the PT_LOAD segments, and set their addresses and offsets
2843   // and their section's addresses and offsets.
2844   uint64_t addr;
2845   if (parameters->options().user_set_Ttext())
2846     addr = parameters->options().Ttext();
2847   else if (parameters->options().output_is_position_independent())
2848     addr = 0;
2849   else
2850     addr = target->default_text_segment_address();
2851   off_t off = 0;
2852
2853   // If LOAD_SEG is NULL, then the file header and segment headers
2854   // will not be loadable.  But they still need to be at offset 0 in
2855   // the file.  Set their offsets now.
2856   if (load_seg == NULL)
2857     {
2858       for (Data_list::iterator p = this->special_output_list_.begin();
2859            p != this->special_output_list_.end();
2860            ++p)
2861         {
2862           off = align_address(off, (*p)->addralign());
2863           (*p)->set_address_and_file_offset(0, off);
2864           off += (*p)->data_size();
2865         }
2866     }
2867
2868   unsigned int increase_relro = this->increase_relro_;
2869   if (this->script_options_->saw_sections_clause())
2870     increase_relro = 0;
2871
2872   const bool check_sections = parameters->options().check_sections();
2873   Output_segment* last_load_segment = NULL;
2874
2875   for (Segment_list::iterator p = this->segment_list_.begin();
2876        p != this->segment_list_.end();
2877        ++p)
2878     {
2879       if ((*p)->type() == elfcpp::PT_LOAD)
2880         {
2881           if (load_seg != NULL && load_seg != *p)
2882             gold_unreachable();
2883           load_seg = NULL;
2884
2885           bool are_addresses_set = (*p)->are_addresses_set();
2886           if (are_addresses_set)
2887             {
2888               // When it comes to setting file offsets, we care about
2889               // the physical address.
2890               addr = (*p)->paddr();
2891             }
2892           else if (parameters->options().user_set_Tdata()
2893                    && ((*p)->flags() & elfcpp::PF_W) != 0
2894                    && (!parameters->options().user_set_Tbss()
2895                        || (*p)->has_any_data_sections()))
2896             {
2897               addr = parameters->options().Tdata();
2898               are_addresses_set = true;
2899             }
2900           else if (parameters->options().user_set_Tbss()
2901                    && ((*p)->flags() & elfcpp::PF_W) != 0
2902                    && !(*p)->has_any_data_sections())
2903             {
2904               addr = parameters->options().Tbss();
2905               are_addresses_set = true;
2906             }
2907
2908           uint64_t orig_addr = addr;
2909           uint64_t orig_off = off;
2910
2911           uint64_t aligned_addr = 0;
2912           uint64_t abi_pagesize = target->abi_pagesize();
2913           uint64_t common_pagesize = target->common_pagesize();
2914
2915           if (!parameters->options().nmagic()
2916               && !parameters->options().omagic())
2917             (*p)->set_minimum_p_align(common_pagesize);
2918
2919           if (!are_addresses_set)
2920             {
2921               // Skip the address forward one page, maintaining the same
2922               // position within the page.  This lets us store both segments
2923               // overlapping on a single page in the file, but the loader will
2924               // put them on different pages in memory. We will revisit this
2925               // decision once we know the size of the segment.
2926
2927               addr = align_address(addr, (*p)->maximum_alignment());
2928               aligned_addr = addr;
2929
2930               if ((addr & (abi_pagesize - 1)) != 0)
2931                 addr = addr + abi_pagesize;
2932
2933               off = orig_off + ((addr - orig_addr) & (abi_pagesize - 1));
2934             }
2935
2936           if (!parameters->options().nmagic()
2937               && !parameters->options().omagic())
2938             off = align_file_offset(off, addr, abi_pagesize);
2939           else if (load_seg == NULL)
2940             {
2941               // This is -N or -n with a section script which prevents
2942               // us from using a load segment.  We need to ensure that
2943               // the file offset is aligned to the alignment of the
2944               // segment.  This is because the linker script
2945               // implicitly assumed a zero offset.  If we don't align
2946               // here, then the alignment of the sections in the
2947               // linker script may not match the alignment of the
2948               // sections in the set_section_addresses call below,
2949               // causing an error about dot moving backward.
2950               off = align_address(off, (*p)->maximum_alignment());
2951             }
2952
2953           unsigned int shndx_hold = *pshndx;
2954           bool has_relro = false;
2955           uint64_t new_addr = (*p)->set_section_addresses(this, false, addr,
2956                                                           &increase_relro,
2957                                                           &has_relro,
2958                                                           &off, pshndx);
2959
2960           // Now that we know the size of this segment, we may be able
2961           // to save a page in memory, at the cost of wasting some
2962           // file space, by instead aligning to the start of a new
2963           // page.  Here we use the real machine page size rather than
2964           // the ABI mandated page size.  If the segment has been
2965           // aligned so that the relro data ends at a page boundary,
2966           // we do not try to realign it.
2967
2968           if (!are_addresses_set
2969               && !has_relro
2970               && aligned_addr != addr
2971               && !parameters->incremental())
2972             {
2973               uint64_t first_off = (common_pagesize
2974                                     - (aligned_addr
2975                                        & (common_pagesize - 1)));
2976               uint64_t last_off = new_addr & (common_pagesize - 1);
2977               if (first_off > 0
2978                   && last_off > 0
2979                   && ((aligned_addr & ~ (common_pagesize - 1))
2980                       != (new_addr & ~ (common_pagesize - 1)))
2981                   && first_off + last_off <= common_pagesize)
2982                 {
2983                   *pshndx = shndx_hold;
2984                   addr = align_address(aligned_addr, common_pagesize);
2985                   addr = align_address(addr, (*p)->maximum_alignment());
2986                   off = orig_off + ((addr - orig_addr) & (abi_pagesize - 1));
2987                   off = align_file_offset(off, addr, abi_pagesize);
2988
2989                   increase_relro = this->increase_relro_;
2990                   if (this->script_options_->saw_sections_clause())
2991                     increase_relro = 0;
2992                   has_relro = false;
2993
2994                   new_addr = (*p)->set_section_addresses(this, true, addr,
2995                                                          &increase_relro,
2996                                                          &has_relro,
2997                                                          &off, pshndx);
2998                 }
2999             }
3000
3001           addr = new_addr;
3002
3003           // Implement --check-sections.  We know that the segments
3004           // are sorted by LMA.
3005           if (check_sections && last_load_segment != NULL)
3006             {
3007               gold_assert(last_load_segment->paddr() <= (*p)->paddr());
3008               if (last_load_segment->paddr() + last_load_segment->memsz()
3009                   > (*p)->paddr())
3010                 {
3011                   unsigned long long lb1 = last_load_segment->paddr();
3012                   unsigned long long le1 = lb1 + last_load_segment->memsz();
3013                   unsigned long long lb2 = (*p)->paddr();
3014                   unsigned long long le2 = lb2 + (*p)->memsz();
3015                   gold_error(_("load segment overlap [0x%llx -> 0x%llx] and "
3016                                "[0x%llx -> 0x%llx]"),
3017                              lb1, le1, lb2, le2);
3018                 }
3019             }
3020           last_load_segment = *p;
3021         }
3022     }
3023
3024   // Handle the non-PT_LOAD segments, setting their offsets from their
3025   // section's offsets.
3026   for (Segment_list::iterator p = this->segment_list_.begin();
3027        p != this->segment_list_.end();
3028        ++p)
3029     {
3030       if ((*p)->type() != elfcpp::PT_LOAD)
3031         (*p)->set_offset((*p)->type() == elfcpp::PT_GNU_RELRO
3032                          ? increase_relro
3033                          : 0);
3034     }
3035
3036   // Set the TLS offsets for each section in the PT_TLS segment.
3037   if (this->tls_segment_ != NULL)
3038     this->tls_segment_->set_tls_offsets();
3039
3040   return off;
3041 }
3042
3043 // Set the offsets of all the allocated sections when doing a
3044 // relocatable link.  This does the same jobs as set_segment_offsets,
3045 // only for a relocatable link.
3046
3047 off_t
3048 Layout::set_relocatable_section_offsets(Output_data* file_header,
3049                                         unsigned int* pshndx)
3050 {
3051   off_t off = 0;
3052
3053   file_header->set_address_and_file_offset(0, 0);
3054   off += file_header->data_size();
3055
3056   for (Section_list::iterator p = this->section_list_.begin();
3057        p != this->section_list_.end();
3058        ++p)
3059     {
3060       // We skip unallocated sections here, except that group sections
3061       // have to come first.
3062       if (((*p)->flags() & elfcpp::SHF_ALLOC) == 0
3063           && (*p)->type() != elfcpp::SHT_GROUP)
3064         continue;
3065
3066       off = align_address(off, (*p)->addralign());
3067
3068       // The linker script might have set the address.
3069       if (!(*p)->is_address_valid())
3070         (*p)->set_address(0);
3071       (*p)->set_file_offset(off);
3072       (*p)->finalize_data_size();
3073       off += (*p)->data_size();
3074
3075       (*p)->set_out_shndx(*pshndx);
3076       ++*pshndx;
3077     }
3078
3079   return off;
3080 }
3081
3082 // Set the file offset of all the sections not associated with a
3083 // segment.
3084
3085 off_t
3086 Layout::set_section_offsets(off_t off, Layout::Section_offset_pass pass)
3087 {
3088   off_t startoff = off;
3089   off_t maxoff = off;
3090
3091   for (Section_list::iterator p = this->unattached_section_list_.begin();
3092        p != this->unattached_section_list_.end();
3093        ++p)
3094     {
3095       // The symtab section is handled in create_symtab_sections.
3096       if (*p == this->symtab_section_)
3097         continue;
3098
3099       // If we've already set the data size, don't set it again.
3100       if ((*p)->is_offset_valid() && (*p)->is_data_size_valid())
3101         continue;
3102
3103       if (pass == BEFORE_INPUT_SECTIONS_PASS
3104           && (*p)->requires_postprocessing())
3105         {
3106           (*p)->create_postprocessing_buffer();
3107           this->any_postprocessing_sections_ = true;
3108         }
3109
3110       if (pass == BEFORE_INPUT_SECTIONS_PASS
3111           && (*p)->after_input_sections())
3112         continue;
3113       else if (pass == POSTPROCESSING_SECTIONS_PASS
3114                && (!(*p)->after_input_sections()
3115                    || (*p)->type() == elfcpp::SHT_STRTAB))
3116         continue;
3117       else if (pass == STRTAB_AFTER_POSTPROCESSING_SECTIONS_PASS
3118                && (!(*p)->after_input_sections()
3119                    || (*p)->type() != elfcpp::SHT_STRTAB))
3120         continue;
3121
3122       if (!parameters->incremental_update())
3123         {
3124           off = align_address(off, (*p)->addralign());
3125           (*p)->set_file_offset(off);
3126           (*p)->finalize_data_size();
3127         }
3128       else
3129         {
3130           // Incremental update: allocate file space from free list.
3131           (*p)->pre_finalize_data_size();
3132           off_t current_size = (*p)->current_data_size();
3133           off = this->allocate(current_size, (*p)->addralign(), startoff);
3134           if (off == -1)
3135             {
3136               if (is_debugging_enabled(DEBUG_INCREMENTAL))
3137                 this->free_list_.dump();
3138               gold_assert((*p)->output_section() != NULL);
3139               gold_fallback(_("out of patch space for section %s; "
3140                               "relink with --incremental-full"),
3141                             (*p)->output_section()->name());
3142             }
3143           (*p)->set_file_offset(off);
3144           (*p)->finalize_data_size();
3145           if ((*p)->data_size() > current_size)
3146             {
3147               gold_assert((*p)->output_section() != NULL);
3148               gold_fallback(_("%s: section changed size; "
3149                               "relink with --incremental-full"),
3150                             (*p)->output_section()->name());
3151             }
3152           gold_debug(DEBUG_INCREMENTAL,
3153                      "set_section_offsets: %08lx %08lx %s",
3154                      static_cast<long>(off),
3155                      static_cast<long>((*p)->data_size()),
3156                      ((*p)->output_section() != NULL
3157                       ? (*p)->output_section()->name() : "(special)"));
3158         }
3159
3160       off += (*p)->data_size();
3161       if (off > maxoff)
3162         maxoff = off;
3163
3164       // At this point the name must be set.
3165       if (pass != STRTAB_AFTER_POSTPROCESSING_SECTIONS_PASS)
3166         this->namepool_.add((*p)->name(), false, NULL);
3167     }
3168   return maxoff;
3169 }
3170
3171 // Set the section indexes of all the sections not associated with a
3172 // segment.
3173
3174 unsigned int
3175 Layout::set_section_indexes(unsigned int shndx)
3176 {
3177   for (Section_list::iterator p = this->unattached_section_list_.begin();
3178        p != this->unattached_section_list_.end();
3179        ++p)
3180     {
3181       if (!(*p)->has_out_shndx())
3182         {
3183           (*p)->set_out_shndx(shndx);
3184           ++shndx;
3185         }
3186     }
3187   return shndx;
3188 }
3189
3190 // Set the section addresses according to the linker script.  This is
3191 // only called when we see a SECTIONS clause.  This returns the
3192 // program segment which should hold the file header and segment
3193 // headers, if any.  It will return NULL if they should not be in a
3194 // segment.
3195
3196 Output_segment*
3197 Layout::set_section_addresses_from_script(Symbol_table* symtab)
3198 {
3199   Script_sections* ss = this->script_options_->script_sections();
3200   gold_assert(ss->saw_sections_clause());
3201   return this->script_options_->set_section_addresses(symtab, this);
3202 }
3203
3204 // Place the orphan sections in the linker script.
3205
3206 void
3207 Layout::place_orphan_sections_in_script()
3208 {
3209   Script_sections* ss = this->script_options_->script_sections();
3210   gold_assert(ss->saw_sections_clause());
3211
3212   // Place each orphaned output section in the script.
3213   for (Section_list::iterator p = this->section_list_.begin();
3214        p != this->section_list_.end();
3215        ++p)
3216     {
3217       if (!(*p)->found_in_sections_clause())
3218         ss->place_orphan(*p);
3219     }
3220 }
3221
3222 // Count the local symbols in the regular symbol table and the dynamic
3223 // symbol table, and build the respective string pools.
3224
3225 void
3226 Layout::count_local_symbols(const Task* task,
3227                             const Input_objects* input_objects)
3228 {
3229   // First, figure out an upper bound on the number of symbols we'll
3230   // be inserting into each pool.  This helps us create the pools with
3231   // the right size, to avoid unnecessary hashtable resizing.
3232   unsigned int symbol_count = 0;
3233   for (Input_objects::Relobj_iterator p = input_objects->relobj_begin();
3234        p != input_objects->relobj_end();
3235        ++p)
3236     symbol_count += (*p)->local_symbol_count();
3237
3238   // Go from "upper bound" to "estimate."  We overcount for two
3239   // reasons: we double-count symbols that occur in more than one
3240   // object file, and we count symbols that are dropped from the
3241   // output.  Add it all together and assume we overcount by 100%.
3242   symbol_count /= 2;
3243
3244   // We assume all symbols will go into both the sympool and dynpool.
3245   this->sympool_.reserve(symbol_count);
3246   this->dynpool_.reserve(symbol_count);
3247
3248   for (Input_objects::Relobj_iterator p = input_objects->relobj_begin();
3249        p != input_objects->relobj_end();
3250        ++p)
3251     {
3252       Task_lock_obj<Object> tlo(task, *p);
3253       (*p)->count_local_symbols(&this->sympool_, &this->dynpool_);
3254     }
3255 }
3256
3257 // Create the symbol table sections.  Here we also set the final
3258 // values of the symbols.  At this point all the loadable sections are
3259 // fully laid out.  SHNUM is the number of sections so far.
3260
3261 void
3262 Layout::create_symtab_sections(const Input_objects* input_objects,
3263                                Symbol_table* symtab,
3264                                unsigned int shnum,
3265                                off_t* poff)
3266 {
3267   int symsize;
3268   unsigned int align;
3269   if (parameters->target().get_size() == 32)
3270     {
3271       symsize = elfcpp::Elf_sizes<32>::sym_size;
3272       align = 4;
3273     }
3274   else if (parameters->target().get_size() == 64)
3275     {
3276       symsize = elfcpp::Elf_sizes<64>::sym_size;
3277       align = 8;
3278     }
3279   else
3280     gold_unreachable();
3281
3282   // Compute file offsets relative to the start of the symtab section.
3283   off_t off = 0;
3284
3285   // Save space for the dummy symbol at the start of the section.  We
3286   // never bother to write this out--it will just be left as zero.
3287   off += symsize;
3288   unsigned int local_symbol_index = 1;
3289
3290   // Add STT_SECTION symbols for each Output section which needs one.
3291   for (Section_list::iterator p = this->section_list_.begin();
3292        p != this->section_list_.end();
3293        ++p)
3294     {
3295       if (!(*p)->needs_symtab_index())
3296         (*p)->set_symtab_index(-1U);
3297       else
3298         {
3299           (*p)->set_symtab_index(local_symbol_index);
3300           ++local_symbol_index;
3301           off += symsize;
3302         }
3303     }
3304
3305   for (Input_objects::Relobj_iterator p = input_objects->relobj_begin();
3306        p != input_objects->relobj_end();
3307        ++p)
3308     {
3309       unsigned int index = (*p)->finalize_local_symbols(local_symbol_index,
3310                                                         off, symtab);
3311       off += (index - local_symbol_index) * symsize;
3312       local_symbol_index = index;
3313     }
3314
3315   unsigned int local_symcount = local_symbol_index;
3316   gold_assert(static_cast<off_t>(local_symcount * symsize) == off);
3317
3318   off_t dynoff;
3319   size_t dyn_global_index;
3320   size_t dyncount;
3321   if (this->dynsym_section_ == NULL)
3322     {
3323       dynoff = 0;
3324       dyn_global_index = 0;
3325       dyncount = 0;
3326     }
3327   else
3328     {
3329       dyn_global_index = this->dynsym_section_->info();
3330       off_t locsize = dyn_global_index * this->dynsym_section_->entsize();
3331       dynoff = this->dynsym_section_->offset() + locsize;
3332       dyncount = (this->dynsym_section_->data_size() - locsize) / symsize;
3333       gold_assert(static_cast<off_t>(dyncount * symsize)
3334                   == this->dynsym_section_->data_size() - locsize);
3335     }
3336
3337   off_t global_off = off;
3338   off = symtab->finalize(off, dynoff, dyn_global_index, dyncount,
3339                          &this->sympool_, &local_symcount);
3340
3341   if (!parameters->options().strip_all())
3342     {
3343       this->sympool_.set_string_offsets();
3344
3345       const char* symtab_name = this->namepool_.add(".symtab", false, NULL);
3346       Output_section* osymtab = this->make_output_section(symtab_name,
3347                                                           elfcpp::SHT_SYMTAB,
3348                                                           0, ORDER_INVALID,
3349                                                           false);
3350       this->symtab_section_ = osymtab;
3351
3352       Output_section_data* pos = new Output_data_fixed_space(off, align,
3353                                                              "** symtab");
3354       osymtab->add_output_section_data(pos);
3355
3356       // We generate a .symtab_shndx section if we have more than
3357       // SHN_LORESERVE sections.  Technically it is possible that we
3358       // don't need one, because it is possible that there are no
3359       // symbols in any of sections with indexes larger than
3360       // SHN_LORESERVE.  That is probably unusual, though, and it is
3361       // easier to always create one than to compute section indexes
3362       // twice (once here, once when writing out the symbols).
3363       if (shnum >= elfcpp::SHN_LORESERVE)
3364         {
3365           const char* symtab_xindex_name = this->namepool_.add(".symtab_shndx",
3366                                                                false, NULL);
3367           Output_section* osymtab_xindex =
3368             this->make_output_section(symtab_xindex_name,
3369                                       elfcpp::SHT_SYMTAB_SHNDX, 0,
3370                                       ORDER_INVALID, false);
3371
3372           size_t symcount = off / symsize;
3373           this->symtab_xindex_ = new Output_symtab_xindex(symcount);
3374
3375           osymtab_xindex->add_output_section_data(this->symtab_xindex_);
3376
3377           osymtab_xindex->set_link_section(osymtab);
3378           osymtab_xindex->set_addralign(4);
3379           osymtab_xindex->set_entsize(4);
3380
3381           osymtab_xindex->set_after_input_sections();
3382
3383           // This tells the driver code to wait until the symbol table
3384           // has written out before writing out the postprocessing
3385           // sections, including the .symtab_shndx section.
3386           this->any_postprocessing_sections_ = true;
3387         }
3388
3389       const char* strtab_name = this->namepool_.add(".strtab", false, NULL);
3390       Output_section* ostrtab = this->make_output_section(strtab_name,
3391                                                           elfcpp::SHT_STRTAB,
3392                                                           0, ORDER_INVALID,
3393                                                           false);
3394
3395       Output_section_data* pstr = new Output_data_strtab(&this->sympool_);
3396       ostrtab->add_output_section_data(pstr);
3397
3398       off_t symtab_off;
3399       if (!parameters->incremental_update())
3400         symtab_off = align_address(*poff, align);
3401       else
3402         {
3403           symtab_off = this->allocate(off, align, *poff);
3404           if (off == -1)
3405             gold_fallback(_("out of patch space for symbol table; "
3406                             "relink with --incremental-full"));
3407           gold_debug(DEBUG_INCREMENTAL,
3408                      "create_symtab_sections: %08lx %08lx .symtab",
3409                      static_cast<long>(symtab_off),
3410                      static_cast<long>(off));
3411         }
3412
3413       symtab->set_file_offset(symtab_off + global_off);
3414       osymtab->set_file_offset(symtab_off);
3415       osymtab->finalize_data_size();
3416       osymtab->set_link_section(ostrtab);
3417       osymtab->set_info(local_symcount);
3418       osymtab->set_entsize(symsize);
3419
3420       if (symtab_off + off > *poff)
3421         *poff = symtab_off + off;
3422     }
3423 }
3424
3425 // Create the .shstrtab section, which holds the names of the
3426 // sections.  At the time this is called, we have created all the
3427 // output sections except .shstrtab itself.
3428
3429 Output_section*
3430 Layout::create_shstrtab()
3431 {
3432   // FIXME: We don't need to create a .shstrtab section if we are
3433   // stripping everything.
3434
3435   const char* name = this->namepool_.add(".shstrtab", false, NULL);
3436
3437   Output_section* os = this->make_output_section(name, elfcpp::SHT_STRTAB, 0,
3438                                                  ORDER_INVALID, false);
3439
3440   if (strcmp(parameters->options().compress_debug_sections(), "none") != 0)
3441     {
3442       // We can't write out this section until we've set all the
3443       // section names, and we don't set the names of compressed
3444       // output sections until relocations are complete.  FIXME: With
3445       // the current names we use, this is unnecessary.
3446       os->set_after_input_sections();
3447     }
3448
3449   Output_section_data* posd = new Output_data_strtab(&this->namepool_);
3450   os->add_output_section_data(posd);
3451
3452   return os;
3453 }
3454
3455 // Create the section headers.  SIZE is 32 or 64.  OFF is the file
3456 // offset.
3457
3458 void
3459 Layout::create_shdrs(const Output_section* shstrtab_section, off_t* poff)
3460 {
3461   Output_section_headers* oshdrs;
3462   oshdrs = new Output_section_headers(this,
3463                                       &this->segment_list_,
3464                                       &this->section_list_,
3465                                       &this->unattached_section_list_,
3466                                       &this->namepool_,
3467                                       shstrtab_section);
3468   off_t off;
3469   if (!parameters->incremental_update())
3470     off = align_address(*poff, oshdrs->addralign());
3471   else
3472     {
3473       oshdrs->pre_finalize_data_size();
3474       off = this->allocate(oshdrs->data_size(), oshdrs->addralign(), *poff);
3475       if (off == -1)
3476           gold_fallback(_("out of patch space for section header table; "
3477                           "relink with --incremental-full"));
3478       gold_debug(DEBUG_INCREMENTAL,
3479                  "create_shdrs: %08lx %08lx (section header table)",
3480                  static_cast<long>(off),
3481                  static_cast<long>(off + oshdrs->data_size()));
3482     }
3483   oshdrs->set_address_and_file_offset(0, off);
3484   off += oshdrs->data_size();
3485   if (off > *poff)
3486     *poff = off;
3487   this->section_headers_ = oshdrs;
3488 }
3489
3490 // Count the allocated sections.
3491
3492 size_t
3493 Layout::allocated_output_section_count() const
3494 {
3495   size_t section_count = 0;
3496   for (Segment_list::const_iterator p = this->segment_list_.begin();
3497        p != this->segment_list_.end();
3498        ++p)
3499     section_count += (*p)->output_section_count();
3500   return section_count;
3501 }
3502
3503 // Create the dynamic symbol table.
3504
3505 void
3506 Layout::create_dynamic_symtab(const Input_objects* input_objects,
3507                               Symbol_table* symtab,
3508                               Output_section** pdynstr,
3509                               unsigned int* plocal_dynamic_count,
3510                               std::vector<Symbol*>* pdynamic_symbols,
3511                               Versions* pversions)
3512 {
3513   // Count all the symbols in the dynamic symbol table, and set the
3514   // dynamic symbol indexes.
3515
3516   // Skip symbol 0, which is always all zeroes.
3517   unsigned int index = 1;
3518
3519   // Add STT_SECTION symbols for each Output section which needs one.
3520   for (Section_list::iterator p = this->section_list_.begin();
3521        p != this->section_list_.end();
3522        ++p)
3523     {
3524       if (!(*p)->needs_dynsym_index())
3525         (*p)->set_dynsym_index(-1U);
3526       else
3527         {
3528           (*p)->set_dynsym_index(index);
3529           ++index;
3530         }
3531     }
3532
3533   // Count the local symbols that need to go in the dynamic symbol table,
3534   // and set the dynamic symbol indexes.
3535   for (Input_objects::Relobj_iterator p = input_objects->relobj_begin();
3536        p != input_objects->relobj_end();
3537        ++p)
3538     {
3539       unsigned int new_index = (*p)->set_local_dynsym_indexes(index);
3540       index = new_index;
3541     }
3542
3543   unsigned int local_symcount = index;
3544   *plocal_dynamic_count = local_symcount;
3545
3546   index = symtab->set_dynsym_indexes(index, pdynamic_symbols,
3547                                      &this->dynpool_, pversions);
3548
3549   int symsize;
3550   unsigned int align;
3551   const int size = parameters->target().get_size();
3552   if (size == 32)
3553     {
3554       symsize = elfcpp::Elf_sizes<32>::sym_size;
3555       align = 4;
3556     }
3557   else if (size == 64)
3558     {
3559       symsize = elfcpp::Elf_sizes<64>::sym_size;
3560       align = 8;
3561     }
3562   else
3563     gold_unreachable();
3564
3565   // Create the dynamic symbol table section.
3566
3567   Output_section* dynsym = this->choose_output_section(NULL, ".dynsym",
3568                                                        elfcpp::SHT_DYNSYM,
3569                                                        elfcpp::SHF_ALLOC,
3570                                                        false,
3571                                                        ORDER_DYNAMIC_LINKER,
3572                                                        false);
3573
3574   Output_section_data* odata = new Output_data_fixed_space(index * symsize,
3575                                                            align,
3576                                                            "** dynsym");
3577   dynsym->add_output_section_data(odata);
3578
3579   dynsym->set_info(local_symcount);
3580   dynsym->set_entsize(symsize);
3581   dynsym->set_addralign(align);
3582
3583   this->dynsym_section_ = dynsym;
3584
3585   Output_data_dynamic* const odyn = this->dynamic_data_;
3586   odyn->add_section_address(elfcpp::DT_SYMTAB, dynsym);
3587   odyn->add_constant(elfcpp::DT_SYMENT, symsize);
3588
3589   // If there are more than SHN_LORESERVE allocated sections, we
3590   // create a .dynsym_shndx section.  It is possible that we don't
3591   // need one, because it is possible that there are no dynamic
3592   // symbols in any of the sections with indexes larger than
3593   // SHN_LORESERVE.  This is probably unusual, though, and at this
3594   // time we don't know the actual section indexes so it is
3595   // inconvenient to check.
3596   if (this->allocated_output_section_count() >= elfcpp::SHN_LORESERVE)
3597     {
3598       Output_section* dynsym_xindex =
3599         this->choose_output_section(NULL, ".dynsym_shndx",
3600                                     elfcpp::SHT_SYMTAB_SHNDX,
3601                                     elfcpp::SHF_ALLOC,
3602                                     false, ORDER_DYNAMIC_LINKER, false);
3603
3604       this->dynsym_xindex_ = new Output_symtab_xindex(index);
3605
3606       dynsym_xindex->add_output_section_data(this->dynsym_xindex_);
3607
3608       dynsym_xindex->set_link_section(dynsym);
3609       dynsym_xindex->set_addralign(4);
3610       dynsym_xindex->set_entsize(4);
3611
3612       dynsym_xindex->set_after_input_sections();
3613
3614       // This tells the driver code to wait until the symbol table has
3615       // written out before writing out the postprocessing sections,
3616       // including the .dynsym_shndx section.
3617       this->any_postprocessing_sections_ = true;
3618     }
3619
3620   // Create the dynamic string table section.
3621
3622   Output_section* dynstr = this->choose_output_section(NULL, ".dynstr",
3623                                                        elfcpp::SHT_STRTAB,
3624                                                        elfcpp::SHF_ALLOC,
3625                                                        false,
3626                                                        ORDER_DYNAMIC_LINKER,
3627                                                        false);
3628
3629   Output_section_data* strdata = new Output_data_strtab(&this->dynpool_);
3630   dynstr->add_output_section_data(strdata);
3631
3632   dynsym->set_link_section(dynstr);
3633   this->dynamic_section_->set_link_section(dynstr);
3634
3635   odyn->add_section_address(elfcpp::DT_STRTAB, dynstr);
3636   odyn->add_section_size(elfcpp::DT_STRSZ, dynstr);
3637
3638   *pdynstr = dynstr;
3639
3640   // Create the hash tables.
3641
3642   if (strcmp(parameters->options().hash_style(), "sysv") == 0
3643       || strcmp(parameters->options().hash_style(), "both") == 0)
3644     {
3645       unsigned char* phash;
3646       unsigned int hashlen;
3647       Dynobj::create_elf_hash_table(*pdynamic_symbols, local_symcount,
3648                                     &phash, &hashlen);
3649
3650       Output_section* hashsec =
3651         this->choose_output_section(NULL, ".hash", elfcpp::SHT_HASH,
3652                                     elfcpp::SHF_ALLOC, false,
3653                                     ORDER_DYNAMIC_LINKER, false);
3654
3655       Output_section_data* hashdata = new Output_data_const_buffer(phash,
3656                                                                    hashlen,
3657                                                                    align,
3658                                                                    "** hash");
3659       hashsec->add_output_section_data(hashdata);
3660
3661       hashsec->set_link_section(dynsym);
3662       hashsec->set_entsize(4);
3663
3664       odyn->add_section_address(elfcpp::DT_HASH, hashsec);
3665     }
3666
3667   if (strcmp(parameters->options().hash_style(), "gnu") == 0
3668       || strcmp(parameters->options().hash_style(), "both") == 0)
3669     {
3670       unsigned char* phash;
3671       unsigned int hashlen;
3672       Dynobj::create_gnu_hash_table(*pdynamic_symbols, local_symcount,
3673                                     &phash, &hashlen);
3674
3675       Output_section* hashsec =
3676         this->choose_output_section(NULL, ".gnu.hash", elfcpp::SHT_GNU_HASH,
3677                                     elfcpp::SHF_ALLOC, false,
3678                                     ORDER_DYNAMIC_LINKER, false);
3679
3680       Output_section_data* hashdata = new Output_data_const_buffer(phash,
3681                                                                    hashlen,
3682                                                                    align,
3683                                                                    "** hash");
3684       hashsec->add_output_section_data(hashdata);
3685
3686       hashsec->set_link_section(dynsym);
3687
3688       // For a 64-bit target, the entries in .gnu.hash do not have a
3689       // uniform size, so we only set the entry size for a 32-bit
3690       // target.
3691       if (parameters->target().get_size() == 32)
3692         hashsec->set_entsize(4);
3693
3694       odyn->add_section_address(elfcpp::DT_GNU_HASH, hashsec);
3695     }
3696 }
3697
3698 // Assign offsets to each local portion of the dynamic symbol table.
3699
3700 void
3701 Layout::assign_local_dynsym_offsets(const Input_objects* input_objects)
3702 {
3703   Output_section* dynsym = this->dynsym_section_;
3704   gold_assert(dynsym != NULL);
3705
3706   off_t off = dynsym->offset();
3707
3708   // Skip the dummy symbol at the start of the section.
3709   off += dynsym->entsize();
3710
3711   for (Input_objects::Relobj_iterator p = input_objects->relobj_begin();
3712        p != input_objects->relobj_end();
3713        ++p)
3714     {
3715       unsigned int count = (*p)->set_local_dynsym_offset(off);
3716       off += count * dynsym->entsize();
3717     }
3718 }
3719
3720 // Create the version sections.
3721
3722 void
3723 Layout::create_version_sections(const Versions* versions,
3724                                 const Symbol_table* symtab,
3725                                 unsigned int local_symcount,
3726                                 const std::vector<Symbol*>& dynamic_symbols,
3727                                 const Output_section* dynstr)
3728 {
3729   if (!versions->any_defs() && !versions->any_needs())
3730     return;
3731
3732   switch (parameters->size_and_endianness())
3733     {
3734 #ifdef HAVE_TARGET_32_LITTLE
3735     case Parameters::TARGET_32_LITTLE:
3736       this->sized_create_version_sections<32, false>(versions, symtab,
3737                                                      local_symcount,
3738                                                      dynamic_symbols, dynstr);
3739       break;
3740 #endif
3741 #ifdef HAVE_TARGET_32_BIG
3742     case Parameters::TARGET_32_BIG:
3743       this->sized_create_version_sections<32, true>(versions, symtab,
3744                                                     local_symcount,
3745                                                     dynamic_symbols, dynstr);
3746       break;
3747 #endif
3748 #ifdef HAVE_TARGET_64_LITTLE
3749     case Parameters::TARGET_64_LITTLE:
3750       this->sized_create_version_sections<64, false>(versions, symtab,
3751                                                      local_symcount,
3752                                                      dynamic_symbols, dynstr);
3753       break;
3754 #endif
3755 #ifdef HAVE_TARGET_64_BIG
3756     case Parameters::TARGET_64_BIG:
3757       this->sized_create_version_sections<64, true>(versions, symtab,
3758                                                     local_symcount,
3759                                                     dynamic_symbols, dynstr);
3760       break;
3761 #endif
3762     default:
3763       gold_unreachable();
3764     }
3765 }
3766
3767 // Create the version sections, sized version.
3768
3769 template<int size, bool big_endian>
3770 void
3771 Layout::sized_create_version_sections(
3772     const Versions* versions,
3773     const Symbol_table* symtab,
3774     unsigned int local_symcount,
3775     const std::vector<Symbol*>& dynamic_symbols,
3776     const Output_section* dynstr)
3777 {
3778   Output_section* vsec = this->choose_output_section(NULL, ".gnu.version",
3779                                                      elfcpp::SHT_GNU_versym,
3780                                                      elfcpp::SHF_ALLOC,
3781                                                      false,
3782                                                      ORDER_DYNAMIC_LINKER,
3783                                                      false);
3784
3785   unsigned char* vbuf;
3786   unsigned int vsize;
3787   versions->symbol_section_contents<size, big_endian>(symtab, &this->dynpool_,
3788                                                       local_symcount,
3789                                                       dynamic_symbols,
3790                                                       &vbuf, &vsize);
3791
3792   Output_section_data* vdata = new Output_data_const_buffer(vbuf, vsize, 2,
3793                                                             "** versions");
3794
3795   vsec->add_output_section_data(vdata);
3796   vsec->set_entsize(2);
3797   vsec->set_link_section(this->dynsym_section_);
3798
3799   Output_data_dynamic* const odyn = this->dynamic_data_;
3800   odyn->add_section_address(elfcpp::DT_VERSYM, vsec);
3801
3802   if (versions->any_defs())
3803     {
3804       Output_section* vdsec;
3805       vdsec= this->choose_output_section(NULL, ".gnu.version_d",
3806                                          elfcpp::SHT_GNU_verdef,
3807                                          elfcpp::SHF_ALLOC,
3808                                          false, ORDER_DYNAMIC_LINKER, false);
3809
3810       unsigned char* vdbuf;
3811       unsigned int vdsize;
3812       unsigned int vdentries;
3813       versions->def_section_contents<size, big_endian>(&this->dynpool_, &vdbuf,
3814                                                        &vdsize, &vdentries);
3815
3816       Output_section_data* vddata =
3817         new Output_data_const_buffer(vdbuf, vdsize, 4, "** version defs");
3818
3819       vdsec->add_output_section_data(vddata);
3820       vdsec->set_link_section(dynstr);
3821       vdsec->set_info(vdentries);
3822
3823       odyn->add_section_address(elfcpp::DT_VERDEF, vdsec);
3824       odyn->add_constant(elfcpp::DT_VERDEFNUM, vdentries);
3825     }
3826
3827   if (versions->any_needs())
3828     {
3829       Output_section* vnsec;
3830       vnsec = this->choose_output_section(NULL, ".gnu.version_r",
3831                                           elfcpp::SHT_GNU_verneed,
3832                                           elfcpp::SHF_ALLOC,
3833                                           false, ORDER_DYNAMIC_LINKER, false);
3834
3835       unsigned char* vnbuf;
3836       unsigned int vnsize;
3837       unsigned int vnentries;
3838       versions->need_section_contents<size, big_endian>(&this->dynpool_,
3839                                                         &vnbuf, &vnsize,
3840                                                         &vnentries);
3841
3842       Output_section_data* vndata =
3843         new Output_data_const_buffer(vnbuf, vnsize, 4, "** version refs");
3844
3845       vnsec->add_output_section_data(vndata);
3846       vnsec->set_link_section(dynstr);
3847       vnsec->set_info(vnentries);
3848
3849       odyn->add_section_address(elfcpp::DT_VERNEED, vnsec);
3850       odyn->add_constant(elfcpp::DT_VERNEEDNUM, vnentries);
3851     }
3852 }
3853
3854 // Create the .interp section and PT_INTERP segment.
3855
3856 void
3857 Layout::create_interp(const Target* target)
3858 {
3859   gold_assert(this->interp_segment_ == NULL);
3860
3861   const char* interp = parameters->options().dynamic_linker();
3862   if (interp == NULL)
3863     {
3864       interp = target->dynamic_linker();
3865       gold_assert(interp != NULL);
3866     }
3867
3868   size_t len = strlen(interp) + 1;
3869
3870   Output_section_data* odata = new Output_data_const(interp, len, 1);
3871
3872   Output_section* osec;
3873
3874   // If we are using a SECTIONS clause, let it decide where the
3875   // .interp section should go.  Otherwise always create a new section
3876   // so that this .interp section does not get confused with any
3877   // section of the same name in the program.
3878   if (this->script_options_->saw_sections_clause())
3879     osec = this->choose_output_section(NULL, ".interp", elfcpp::SHT_PROGBITS,
3880                                        elfcpp::SHF_ALLOC, false, ORDER_INTERP,
3881                                        false);
3882   else
3883     {
3884       const char* n = this->namepool_.add("interp", false, NULL);
3885       osec = this->make_output_section(n, elfcpp::SHT_PROGBITS,
3886                                        elfcpp::SHF_ALLOC, ORDER_INTERP, false);
3887     }
3888
3889   osec->add_output_section_data(odata);
3890
3891   if (!this->script_options_->saw_phdrs_clause())
3892     {
3893       Output_segment* oseg = this->make_output_segment(elfcpp::PT_INTERP,
3894                                                        elfcpp::PF_R);
3895       oseg->add_output_section_to_nonload(osec, elfcpp::PF_R);
3896     }
3897 }
3898
3899 // Add dynamic tags for the PLT and the dynamic relocs.  This is
3900 // called by the target-specific code.  This does nothing if not doing
3901 // a dynamic link.
3902
3903 // USE_REL is true for REL relocs rather than RELA relocs.
3904
3905 // If PLT_GOT is not NULL, then DT_PLTGOT points to it.
3906
3907 // If PLT_REL is not NULL, it is used for DT_PLTRELSZ, and DT_JMPREL,
3908 // and we also set DT_PLTREL.  We use PLT_REL's output section, since
3909 // some targets have multiple reloc sections in PLT_REL.
3910
3911 // If DYN_REL is not NULL, it is used for DT_REL/DT_RELA,
3912 // DT_RELSZ/DT_RELASZ, DT_RELENT/DT_RELAENT.
3913
3914 // If ADD_DEBUG is true, we add a DT_DEBUG entry when generating an
3915 // executable.
3916
3917 void
3918 Layout::add_target_dynamic_tags(bool use_rel, const Output_data* plt_got,
3919                                 const Output_data* plt_rel,
3920                                 const Output_data_reloc_generic* dyn_rel,
3921                                 bool add_debug, bool dynrel_includes_plt)
3922 {
3923   Output_data_dynamic* odyn = this->dynamic_data_;
3924   if (odyn == NULL)
3925     return;
3926
3927   if (plt_got != NULL && plt_got->output_section() != NULL)
3928     odyn->add_section_address(elfcpp::DT_PLTGOT, plt_got);
3929
3930   if (plt_rel != NULL && plt_rel->output_section() != NULL)
3931     {
3932       odyn->add_section_size(elfcpp::DT_PLTRELSZ, plt_rel->output_section());
3933       odyn->add_section_address(elfcpp::DT_JMPREL, plt_rel->output_section());
3934       odyn->add_constant(elfcpp::DT_PLTREL,
3935                          use_rel ? elfcpp::DT_REL : elfcpp::DT_RELA);
3936     }
3937
3938   if (dyn_rel != NULL && dyn_rel->output_section() != NULL)
3939     {
3940       odyn->add_section_address(use_rel ? elfcpp::DT_REL : elfcpp::DT_RELA,
3941                                 dyn_rel);
3942       if (plt_rel != NULL && dynrel_includes_plt)
3943         odyn->add_section_size(use_rel ? elfcpp::DT_RELSZ : elfcpp::DT_RELASZ,
3944                                dyn_rel, plt_rel);
3945       else
3946         odyn->add_section_size(use_rel ? elfcpp::DT_RELSZ : elfcpp::DT_RELASZ,
3947                                dyn_rel);
3948       const int size = parameters->target().get_size();
3949       elfcpp::DT rel_tag;
3950       int rel_size;
3951       if (use_rel)
3952         {
3953           rel_tag = elfcpp::DT_RELENT;
3954           if (size == 32)
3955             rel_size = Reloc_types<elfcpp::SHT_REL, 32, false>::reloc_size;
3956           else if (size == 64)
3957             rel_size = Reloc_types<elfcpp::SHT_REL, 64, false>::reloc_size;
3958           else
3959             gold_unreachable();
3960         }
3961       else
3962         {
3963           rel_tag = elfcpp::DT_RELAENT;
3964           if (size == 32)
3965             rel_size = Reloc_types<elfcpp::SHT_RELA, 32, false>::reloc_size;
3966           else if (size == 64)
3967             rel_size = Reloc_types<elfcpp::SHT_RELA, 64, false>::reloc_size;
3968           else
3969             gold_unreachable();
3970         }
3971       odyn->add_constant(rel_tag, rel_size);
3972
3973       if (parameters->options().combreloc())
3974         {
3975           size_t c = dyn_rel->relative_reloc_count();
3976           if (c > 0)
3977             odyn->add_constant((use_rel
3978                                 ? elfcpp::DT_RELCOUNT
3979                                 : elfcpp::DT_RELACOUNT),
3980                                c);
3981         }
3982     }
3983
3984   if (add_debug && !parameters->options().shared())
3985     {
3986       // The value of the DT_DEBUG tag is filled in by the dynamic
3987       // linker at run time, and used by the debugger.
3988       odyn->add_constant(elfcpp::DT_DEBUG, 0);
3989     }
3990 }
3991
3992 // Finish the .dynamic section and PT_DYNAMIC segment.
3993
3994 void
3995 Layout::finish_dynamic_section(const Input_objects* input_objects,
3996                                const Symbol_table* symtab)
3997 {
3998   if (!this->script_options_->saw_phdrs_clause())
3999     {
4000       Output_segment* oseg = this->make_output_segment(elfcpp::PT_DYNAMIC,
4001                                                        (elfcpp::PF_R
4002                                                         | elfcpp::PF_W));
4003       oseg->add_output_section_to_nonload(this->dynamic_section_,
4004                                           elfcpp::PF_R | elfcpp::PF_W);
4005     }
4006
4007   Output_data_dynamic* const odyn = this->dynamic_data_;
4008
4009   for (Input_objects::Dynobj_iterator p = input_objects->dynobj_begin();
4010        p != input_objects->dynobj_end();
4011        ++p)
4012     {
4013       if (!(*p)->is_needed() && (*p)->as_needed())
4014         {
4015           // This dynamic object was linked with --as-needed, but it
4016           // is not needed.
4017           continue;
4018         }
4019
4020       odyn->add_string(elfcpp::DT_NEEDED, (*p)->soname());
4021     }
4022
4023   if (parameters->options().shared())
4024     {
4025       const char* soname = parameters->options().soname();
4026       if (soname != NULL)
4027         odyn->add_string(elfcpp::DT_SONAME, soname);
4028     }
4029
4030   Symbol* sym = symtab->lookup(parameters->options().init());
4031   if (sym != NULL && sym->is_defined() && !sym->is_from_dynobj())
4032     odyn->add_symbol(elfcpp::DT_INIT, sym);
4033
4034   sym = symtab->lookup(parameters->options().fini());
4035   if (sym != NULL && sym->is_defined() && !sym->is_from_dynobj())
4036     odyn->add_symbol(elfcpp::DT_FINI, sym);
4037
4038   // Look for .init_array, .preinit_array and .fini_array by checking
4039   // section types.
4040   for(Layout::Section_list::const_iterator p = this->section_list_.begin();
4041       p != this->section_list_.end();
4042       ++p)
4043     switch((*p)->type())
4044       {
4045       case elfcpp::SHT_FINI_ARRAY:
4046         odyn->add_section_address(elfcpp::DT_FINI_ARRAY, *p);
4047         odyn->add_section_size(elfcpp::DT_FINI_ARRAYSZ, *p); 
4048         break;
4049       case elfcpp::SHT_INIT_ARRAY:
4050         odyn->add_section_address(elfcpp::DT_INIT_ARRAY, *p);
4051         odyn->add_section_size(elfcpp::DT_INIT_ARRAYSZ, *p); 
4052         break;
4053       case elfcpp::SHT_PREINIT_ARRAY:
4054         odyn->add_section_address(elfcpp::DT_PREINIT_ARRAY, *p);
4055         odyn->add_section_size(elfcpp::DT_PREINIT_ARRAYSZ, *p); 
4056         break;
4057       default:
4058         break;
4059       }
4060   
4061   // Add a DT_RPATH entry if needed.
4062   const General_options::Dir_list& rpath(parameters->options().rpath());
4063   if (!rpath.empty())
4064     {
4065       std::string rpath_val;
4066       for (General_options::Dir_list::const_iterator p = rpath.begin();
4067            p != rpath.end();
4068            ++p)
4069         {
4070           if (rpath_val.empty())
4071             rpath_val = p->name();
4072           else
4073             {
4074               // Eliminate duplicates.
4075               General_options::Dir_list::const_iterator q;
4076               for (q = rpath.begin(); q != p; ++q)
4077                 if (q->name() == p->name())
4078                   break;
4079               if (q == p)
4080                 {
4081                   rpath_val += ':';
4082                   rpath_val += p->name();
4083                 }
4084             }
4085         }
4086
4087       odyn->add_string(elfcpp::DT_RPATH, rpath_val);
4088       if (parameters->options().enable_new_dtags())
4089         odyn->add_string(elfcpp::DT_RUNPATH, rpath_val);
4090     }
4091
4092   // Look for text segments that have dynamic relocations.
4093   bool have_textrel = false;
4094   if (!this->script_options_->saw_sections_clause())
4095     {
4096       for (Segment_list::const_iterator p = this->segment_list_.begin();
4097            p != this->segment_list_.end();
4098            ++p)
4099         {
4100           if (((*p)->flags() & elfcpp::PF_W) == 0
4101               && (*p)->has_dynamic_reloc())
4102             {
4103               have_textrel = true;
4104               break;
4105             }
4106         }
4107     }
4108   else
4109     {
4110       // We don't know the section -> segment mapping, so we are
4111       // conservative and just look for readonly sections with
4112       // relocations.  If those sections wind up in writable segments,
4113       // then we have created an unnecessary DT_TEXTREL entry.
4114       for (Section_list::const_iterator p = this->section_list_.begin();
4115            p != this->section_list_.end();
4116            ++p)
4117         {
4118           if (((*p)->flags() & elfcpp::SHF_ALLOC) != 0
4119               && ((*p)->flags() & elfcpp::SHF_WRITE) == 0
4120               && ((*p)->has_dynamic_reloc()))
4121             {
4122               have_textrel = true;
4123               break;
4124             }
4125         }
4126     }
4127
4128   // Add a DT_FLAGS entry. We add it even if no flags are set so that
4129   // post-link tools can easily modify these flags if desired.
4130   unsigned int flags = 0;
4131   if (have_textrel)
4132     {
4133       // Add a DT_TEXTREL for compatibility with older loaders.
4134       odyn->add_constant(elfcpp::DT_TEXTREL, 0);
4135       flags |= elfcpp::DF_TEXTREL;
4136
4137       if (parameters->options().text())
4138         gold_error(_("read-only segment has dynamic relocations"));
4139       else if (parameters->options().warn_shared_textrel()
4140                && parameters->options().shared())
4141         gold_warning(_("shared library text segment is not shareable"));
4142     }
4143   if (parameters->options().shared() && this->has_static_tls())
4144     flags |= elfcpp::DF_STATIC_TLS;
4145   if (parameters->options().origin())
4146     flags |= elfcpp::DF_ORIGIN;
4147   if (parameters->options().Bsymbolic())
4148     {
4149       flags |= elfcpp::DF_SYMBOLIC;
4150       // Add DT_SYMBOLIC for compatibility with older loaders.
4151       odyn->add_constant(elfcpp::DT_SYMBOLIC, 0);
4152     }
4153   if (parameters->options().now())
4154     flags |= elfcpp::DF_BIND_NOW;
4155   odyn->add_constant(elfcpp::DT_FLAGS, flags);
4156
4157   flags = 0;
4158   if (parameters->options().initfirst())
4159     flags |= elfcpp::DF_1_INITFIRST;
4160   if (parameters->options().interpose())
4161     flags |= elfcpp::DF_1_INTERPOSE;
4162   if (parameters->options().loadfltr())
4163     flags |= elfcpp::DF_1_LOADFLTR;
4164   if (parameters->options().nodefaultlib())
4165     flags |= elfcpp::DF_1_NODEFLIB;
4166   if (parameters->options().nodelete())
4167     flags |= elfcpp::DF_1_NODELETE;
4168   if (parameters->options().nodlopen())
4169     flags |= elfcpp::DF_1_NOOPEN;
4170   if (parameters->options().nodump())
4171     flags |= elfcpp::DF_1_NODUMP;
4172   if (!parameters->options().shared())
4173     flags &= ~(elfcpp::DF_1_INITFIRST
4174                | elfcpp::DF_1_NODELETE
4175                | elfcpp::DF_1_NOOPEN);
4176   if (parameters->options().origin())
4177     flags |= elfcpp::DF_1_ORIGIN;
4178   if (parameters->options().now())
4179     flags |= elfcpp::DF_1_NOW;
4180   if (flags)
4181     odyn->add_constant(elfcpp::DT_FLAGS_1, flags);
4182 }
4183
4184 // Set the size of the _DYNAMIC symbol table to be the size of the
4185 // dynamic data.
4186
4187 void
4188 Layout::set_dynamic_symbol_size(const Symbol_table* symtab)
4189 {
4190   Output_data_dynamic* const odyn = this->dynamic_data_;
4191   odyn->finalize_data_size();
4192   off_t data_size = odyn->data_size();
4193   const int size = parameters->target().get_size();
4194   if (size == 32)
4195     symtab->get_sized_symbol<32>(this->dynamic_symbol_)->set_symsize(data_size);
4196   else if (size == 64)
4197     symtab->get_sized_symbol<64>(this->dynamic_symbol_)->set_symsize(data_size);
4198   else
4199     gold_unreachable();
4200 }
4201
4202 // The mapping of input section name prefixes to output section names.
4203 // In some cases one prefix is itself a prefix of another prefix; in
4204 // such a case the longer prefix must come first.  These prefixes are
4205 // based on the GNU linker default ELF linker script.
4206
4207 #define MAPPING_INIT(f, t) { f, sizeof(f) - 1, t, sizeof(t) - 1 }
4208 const Layout::Section_name_mapping Layout::section_name_mapping[] =
4209 {
4210   MAPPING_INIT(".text.", ".text"),
4211   MAPPING_INIT(".ctors.", ".ctors"),
4212   MAPPING_INIT(".dtors.", ".dtors"),
4213   MAPPING_INIT(".rodata.", ".rodata"),
4214   MAPPING_INIT(".data.rel.ro.local", ".data.rel.ro.local"),
4215   MAPPING_INIT(".data.rel.ro", ".data.rel.ro"),
4216   MAPPING_INIT(".data.", ".data"),
4217   MAPPING_INIT(".bss.", ".bss"),
4218   MAPPING_INIT(".tdata.", ".tdata"),
4219   MAPPING_INIT(".tbss.", ".tbss"),
4220   MAPPING_INIT(".init_array.", ".init_array"),
4221   MAPPING_INIT(".fini_array.", ".fini_array"),
4222   MAPPING_INIT(".sdata.", ".sdata"),
4223   MAPPING_INIT(".sbss.", ".sbss"),
4224   // FIXME: In the GNU linker, .sbss2 and .sdata2 are handled
4225   // differently depending on whether it is creating a shared library.
4226   MAPPING_INIT(".sdata2.", ".sdata"),
4227   MAPPING_INIT(".sbss2.", ".sbss"),
4228   MAPPING_INIT(".lrodata.", ".lrodata"),
4229   MAPPING_INIT(".ldata.", ".ldata"),
4230   MAPPING_INIT(".lbss.", ".lbss"),
4231   MAPPING_INIT(".gcc_except_table.", ".gcc_except_table"),
4232   MAPPING_INIT(".gnu.linkonce.d.rel.ro.local.", ".data.rel.ro.local"),
4233   MAPPING_INIT(".gnu.linkonce.d.rel.ro.", ".data.rel.ro"),
4234   MAPPING_INIT(".gnu.linkonce.t.", ".text"),
4235   MAPPING_INIT(".gnu.linkonce.r.", ".rodata"),
4236   MAPPING_INIT(".gnu.linkonce.d.", ".data"),
4237   MAPPING_INIT(".gnu.linkonce.b.", ".bss"),
4238   MAPPING_INIT(".gnu.linkonce.s.", ".sdata"),
4239   MAPPING_INIT(".gnu.linkonce.sb.", ".sbss"),
4240   MAPPING_INIT(".gnu.linkonce.s2.", ".sdata"),
4241   MAPPING_INIT(".gnu.linkonce.sb2.", ".sbss"),
4242   MAPPING_INIT(".gnu.linkonce.wi.", ".debug_info"),
4243   MAPPING_INIT(".gnu.linkonce.td.", ".tdata"),
4244   MAPPING_INIT(".gnu.linkonce.tb.", ".tbss"),
4245   MAPPING_INIT(".gnu.linkonce.lr.", ".lrodata"),
4246   MAPPING_INIT(".gnu.linkonce.l.", ".ldata"),
4247   MAPPING_INIT(".gnu.linkonce.lb.", ".lbss"),
4248   MAPPING_INIT(".ARM.extab", ".ARM.extab"),
4249   MAPPING_INIT(".gnu.linkonce.armextab.", ".ARM.extab"),
4250   MAPPING_INIT(".ARM.exidx", ".ARM.exidx"),
4251   MAPPING_INIT(".gnu.linkonce.armexidx.", ".ARM.exidx"),
4252 };
4253 #undef MAPPING_INIT
4254
4255 const int Layout::section_name_mapping_count =
4256   (sizeof(Layout::section_name_mapping)
4257    / sizeof(Layout::section_name_mapping[0]));
4258
4259 // Choose the output section name to use given an input section name.
4260 // Set *PLEN to the length of the name.  *PLEN is initialized to the
4261 // length of NAME.
4262
4263 const char*
4264 Layout::output_section_name(const char* name, size_t* plen)
4265 {
4266   // gcc 4.3 generates the following sorts of section names when it
4267   // needs a section name specific to a function:
4268   //   .text.FN
4269   //   .rodata.FN
4270   //   .sdata2.FN
4271   //   .data.FN
4272   //   .data.rel.FN
4273   //   .data.rel.local.FN
4274   //   .data.rel.ro.FN
4275   //   .data.rel.ro.local.FN
4276   //   .sdata.FN
4277   //   .bss.FN
4278   //   .sbss.FN
4279   //   .tdata.FN
4280   //   .tbss.FN
4281
4282   // The GNU linker maps all of those to the part before the .FN,
4283   // except that .data.rel.local.FN is mapped to .data, and
4284   // .data.rel.ro.local.FN is mapped to .data.rel.ro.  The sections
4285   // beginning with .data.rel.ro.local are grouped together.
4286
4287   // For an anonymous namespace, the string FN can contain a '.'.
4288
4289   // Also of interest: .rodata.strN.N, .rodata.cstN, both of which the
4290   // GNU linker maps to .rodata.
4291
4292   // The .data.rel.ro sections are used with -z relro.  The sections
4293   // are recognized by name.  We use the same names that the GNU
4294   // linker does for these sections.
4295
4296   // It is hard to handle this in a principled way, so we don't even
4297   // try.  We use a table of mappings.  If the input section name is
4298   // not found in the table, we simply use it as the output section
4299   // name.
4300
4301   const Section_name_mapping* psnm = section_name_mapping;
4302   for (int i = 0; i < section_name_mapping_count; ++i, ++psnm)
4303     {
4304       if (strncmp(name, psnm->from, psnm->fromlen) == 0)
4305         {
4306           *plen = psnm->tolen;
4307           return psnm->to;
4308         }
4309     }
4310
4311   return name;
4312 }
4313
4314 // Check if a comdat group or .gnu.linkonce section with the given
4315 // NAME is selected for the link.  If there is already a section,
4316 // *KEPT_SECTION is set to point to the existing section and the
4317 // function returns false.  Otherwise, OBJECT, SHNDX, IS_COMDAT, and
4318 // IS_GROUP_NAME are recorded for this NAME in the layout object,
4319 // *KEPT_SECTION is set to the internal copy and the function returns
4320 // true.
4321
4322 bool
4323 Layout::find_or_add_kept_section(const std::string& name,
4324                                  Relobj* object,
4325                                  unsigned int shndx,
4326                                  bool is_comdat,
4327                                  bool is_group_name,
4328                                  Kept_section** kept_section)
4329 {
4330   // It's normal to see a couple of entries here, for the x86 thunk
4331   // sections.  If we see more than a few, we're linking a C++
4332   // program, and we resize to get more space to minimize rehashing.
4333   if (this->signatures_.size() > 4
4334       && !this->resized_signatures_)
4335     {
4336       reserve_unordered_map(&this->signatures_,
4337                             this->number_of_input_files_ * 64);
4338       this->resized_signatures_ = true;
4339     }
4340
4341   Kept_section candidate;
4342   std::pair<Signatures::iterator, bool> ins =
4343     this->signatures_.insert(std::make_pair(name, candidate));
4344
4345   if (kept_section != NULL)
4346     *kept_section = &ins.first->second;
4347   if (ins.second)
4348     {
4349       // This is the first time we've seen this signature.
4350       ins.first->second.set_object(object);
4351       ins.first->second.set_shndx(shndx);
4352       if (is_comdat)
4353         ins.first->second.set_is_comdat();
4354       if (is_group_name)
4355         ins.first->second.set_is_group_name();
4356       return true;
4357     }
4358
4359   // We have already seen this signature.
4360
4361   if (ins.first->second.is_group_name())
4362     {
4363       // We've already seen a real section group with this signature.
4364       // If the kept group is from a plugin object, and we're in the
4365       // replacement phase, accept the new one as a replacement.
4366       if (ins.first->second.object() == NULL
4367           && parameters->options().plugins()->in_replacement_phase())
4368         {
4369           ins.first->second.set_object(object);
4370           ins.first->second.set_shndx(shndx);
4371           return true;
4372         }
4373       return false;
4374     }
4375   else if (is_group_name)
4376     {
4377       // This is a real section group, and we've already seen a
4378       // linkonce section with this signature.  Record that we've seen
4379       // a section group, and don't include this section group.
4380       ins.first->second.set_is_group_name();
4381       return false;
4382     }
4383   else
4384     {
4385       // We've already seen a linkonce section and this is a linkonce
4386       // section.  These don't block each other--this may be the same
4387       // symbol name with different section types.
4388       return true;
4389     }
4390 }
4391
4392 // Store the allocated sections into the section list.
4393
4394 void
4395 Layout::get_allocated_sections(Section_list* section_list) const
4396 {
4397   for (Section_list::const_iterator p = this->section_list_.begin();
4398        p != this->section_list_.end();
4399        ++p)
4400     if (((*p)->flags() & elfcpp::SHF_ALLOC) != 0)
4401       section_list->push_back(*p);
4402 }
4403
4404 // Create an output segment.
4405
4406 Output_segment*
4407 Layout::make_output_segment(elfcpp::Elf_Word type, elfcpp::Elf_Word flags)
4408 {
4409   gold_assert(!parameters->options().relocatable());
4410   Output_segment* oseg = new Output_segment(type, flags);
4411   this->segment_list_.push_back(oseg);
4412
4413   if (type == elfcpp::PT_TLS)
4414     this->tls_segment_ = oseg;
4415   else if (type == elfcpp::PT_GNU_RELRO)
4416     this->relro_segment_ = oseg;
4417   else if (type == elfcpp::PT_INTERP)
4418     this->interp_segment_ = oseg;
4419
4420   return oseg;
4421 }
4422
4423 // Return the file offset of the normal symbol table.
4424
4425 off_t
4426 Layout::symtab_section_offset() const
4427 {
4428   if (this->symtab_section_ != NULL)
4429     return this->symtab_section_->offset();
4430   return 0;
4431 }
4432
4433 // Write out the Output_sections.  Most won't have anything to write,
4434 // since most of the data will come from input sections which are
4435 // handled elsewhere.  But some Output_sections do have Output_data.
4436
4437 void
4438 Layout::write_output_sections(Output_file* of) const
4439 {
4440   for (Section_list::const_iterator p = this->section_list_.begin();
4441        p != this->section_list_.end();
4442        ++p)
4443     {
4444       if (!(*p)->after_input_sections())
4445         (*p)->write(of);
4446     }
4447 }
4448
4449 // Write out data not associated with a section or the symbol table.
4450
4451 void
4452 Layout::write_data(const Symbol_table* symtab, Output_file* of) const
4453 {
4454   if (!parameters->options().strip_all())
4455     {
4456       const Output_section* symtab_section = this->symtab_section_;
4457       for (Section_list::const_iterator p = this->section_list_.begin();
4458            p != this->section_list_.end();
4459            ++p)
4460         {
4461           if ((*p)->needs_symtab_index())
4462             {
4463               gold_assert(symtab_section != NULL);
4464               unsigned int index = (*p)->symtab_index();
4465               gold_assert(index > 0 && index != -1U);
4466               off_t off = (symtab_section->offset()
4467                            + index * symtab_section->entsize());
4468               symtab->write_section_symbol(*p, this->symtab_xindex_, of, off);
4469             }
4470         }
4471     }
4472
4473   const Output_section* dynsym_section = this->dynsym_section_;
4474   for (Section_list::const_iterator p = this->section_list_.begin();
4475        p != this->section_list_.end();
4476        ++p)
4477     {
4478       if ((*p)->needs_dynsym_index())
4479         {
4480           gold_assert(dynsym_section != NULL);
4481           unsigned int index = (*p)->dynsym_index();
4482           gold_assert(index > 0 && index != -1U);
4483           off_t off = (dynsym_section->offset()
4484                        + index * dynsym_section->entsize());
4485           symtab->write_section_symbol(*p, this->dynsym_xindex_, of, off);
4486         }
4487     }
4488
4489   // Write out the Output_data which are not in an Output_section.
4490   for (Data_list::const_iterator p = this->special_output_list_.begin();
4491        p != this->special_output_list_.end();
4492        ++p)
4493     (*p)->write(of);
4494 }
4495
4496 // Write out the Output_sections which can only be written after the
4497 // input sections are complete.
4498
4499 void
4500 Layout::write_sections_after_input_sections(Output_file* of)
4501 {
4502   // Determine the final section offsets, and thus the final output
4503   // file size.  Note we finalize the .shstrab last, to allow the
4504   // after_input_section sections to modify their section-names before
4505   // writing.
4506   if (this->any_postprocessing_sections_)
4507     {
4508       off_t off = this->output_file_size_;
4509       off = this->set_section_offsets(off, POSTPROCESSING_SECTIONS_PASS);
4510
4511       // Now that we've finalized the names, we can finalize the shstrab.
4512       off =
4513         this->set_section_offsets(off,
4514                                   STRTAB_AFTER_POSTPROCESSING_SECTIONS_PASS);
4515
4516       if (off > this->output_file_size_)
4517         {
4518           of->resize(off);
4519           this->output_file_size_ = off;
4520         }
4521     }
4522
4523   for (Section_list::const_iterator p = this->section_list_.begin();
4524        p != this->section_list_.end();
4525        ++p)
4526     {
4527       if ((*p)->after_input_sections())
4528         (*p)->write(of);
4529     }
4530
4531   this->section_headers_->write(of);
4532 }
4533
4534 // If the build ID requires computing a checksum, do so here, and
4535 // write it out.  We compute a checksum over the entire file because
4536 // that is simplest.
4537
4538 void
4539 Layout::write_build_id(Output_file* of) const
4540 {
4541   if (this->build_id_note_ == NULL)
4542     return;
4543
4544   const unsigned char* iv = of->get_input_view(0, this->output_file_size_);
4545
4546   unsigned char* ov = of->get_output_view(this->build_id_note_->offset(),
4547                                           this->build_id_note_->data_size());
4548
4549   const char* style = parameters->options().build_id();
4550   if (strcmp(style, "sha1") == 0)
4551     {
4552       sha1_ctx ctx;
4553       sha1_init_ctx(&ctx);
4554       sha1_process_bytes(iv, this->output_file_size_, &ctx);
4555       sha1_finish_ctx(&ctx, ov);
4556     }
4557   else if (strcmp(style, "md5") == 0)
4558     {
4559       md5_ctx ctx;
4560       md5_init_ctx(&ctx);
4561       md5_process_bytes(iv, this->output_file_size_, &ctx);
4562       md5_finish_ctx(&ctx, ov);
4563     }
4564   else
4565     gold_unreachable();
4566
4567   of->write_output_view(this->build_id_note_->offset(),
4568                         this->build_id_note_->data_size(),
4569                         ov);
4570
4571   of->free_input_view(0, this->output_file_size_, iv);
4572 }
4573
4574 // Write out a binary file.  This is called after the link is
4575 // complete.  IN is the temporary output file we used to generate the
4576 // ELF code.  We simply walk through the segments, read them from
4577 // their file offset in IN, and write them to their load address in
4578 // the output file.  FIXME: with a bit more work, we could support
4579 // S-records and/or Intel hex format here.
4580
4581 void
4582 Layout::write_binary(Output_file* in) const
4583 {
4584   gold_assert(parameters->options().oformat_enum()
4585               == General_options::OBJECT_FORMAT_BINARY);
4586
4587   // Get the size of the binary file.
4588   uint64_t max_load_address = 0;
4589   for (Segment_list::const_iterator p = this->segment_list_.begin();
4590        p != this->segment_list_.end();
4591        ++p)
4592     {
4593       if ((*p)->type() == elfcpp::PT_LOAD && (*p)->filesz() > 0)
4594         {
4595           uint64_t max_paddr = (*p)->paddr() + (*p)->filesz();
4596           if (max_paddr > max_load_address)
4597             max_load_address = max_paddr;
4598         }
4599     }
4600
4601   Output_file out(parameters->options().output_file_name());
4602   out.open(max_load_address);
4603
4604   for (Segment_list::const_iterator p = this->segment_list_.begin();
4605        p != this->segment_list_.end();
4606        ++p)
4607     {
4608       if ((*p)->type() == elfcpp::PT_LOAD && (*p)->filesz() > 0)
4609         {
4610           const unsigned char* vin = in->get_input_view((*p)->offset(),
4611                                                         (*p)->filesz());
4612           unsigned char* vout = out.get_output_view((*p)->paddr(),
4613                                                     (*p)->filesz());
4614           memcpy(vout, vin, (*p)->filesz());
4615           out.write_output_view((*p)->paddr(), (*p)->filesz(), vout);
4616           in->free_input_view((*p)->offset(), (*p)->filesz(), vin);
4617         }
4618     }
4619
4620   out.close();
4621 }
4622
4623 // Print the output sections to the map file.
4624
4625 void
4626 Layout::print_to_mapfile(Mapfile* mapfile) const
4627 {
4628   for (Segment_list::const_iterator p = this->segment_list_.begin();
4629        p != this->segment_list_.end();
4630        ++p)
4631     (*p)->print_sections_to_mapfile(mapfile);
4632 }
4633
4634 // Print statistical information to stderr.  This is used for --stats.
4635
4636 void
4637 Layout::print_stats() const
4638 {
4639   this->namepool_.print_stats("section name pool");
4640   this->sympool_.print_stats("output symbol name pool");
4641   this->dynpool_.print_stats("dynamic name pool");
4642
4643   for (Section_list::const_iterator p = this->section_list_.begin();
4644        p != this->section_list_.end();
4645        ++p)
4646     (*p)->print_merge_stats();
4647 }
4648
4649 // Write_sections_task methods.
4650
4651 // We can always run this task.
4652
4653 Task_token*
4654 Write_sections_task::is_runnable()
4655 {
4656   return NULL;
4657 }
4658
4659 // We need to unlock both OUTPUT_SECTIONS_BLOCKER and FINAL_BLOCKER
4660 // when finished.
4661
4662 void
4663 Write_sections_task::locks(Task_locker* tl)
4664 {
4665   tl->add(this, this->output_sections_blocker_);
4666   tl->add(this, this->final_blocker_);
4667 }
4668
4669 // Run the task--write out the data.
4670
4671 void
4672 Write_sections_task::run(Workqueue*)
4673 {
4674   this->layout_->write_output_sections(this->of_);
4675 }
4676
4677 // Write_data_task methods.
4678
4679 // We can always run this task.
4680
4681 Task_token*
4682 Write_data_task::is_runnable()
4683 {
4684   return NULL;
4685 }
4686
4687 // We need to unlock FINAL_BLOCKER when finished.
4688
4689 void
4690 Write_data_task::locks(Task_locker* tl)
4691 {
4692   tl->add(this, this->final_blocker_);
4693 }
4694
4695 // Run the task--write out the data.
4696
4697 void
4698 Write_data_task::run(Workqueue*)
4699 {
4700   this->layout_->write_data(this->symtab_, this->of_);
4701 }
4702
4703 // Write_symbols_task methods.
4704
4705 // We can always run this task.
4706
4707 Task_token*
4708 Write_symbols_task::is_runnable()
4709 {
4710   return NULL;
4711 }
4712
4713 // We need to unlock FINAL_BLOCKER when finished.
4714
4715 void
4716 Write_symbols_task::locks(Task_locker* tl)
4717 {
4718   tl->add(this, this->final_blocker_);
4719 }
4720
4721 // Run the task--write out the symbols.
4722
4723 void
4724 Write_symbols_task::run(Workqueue*)
4725 {
4726   this->symtab_->write_globals(this->sympool_, this->dynpool_,
4727                                this->layout_->symtab_xindex(),
4728                                this->layout_->dynsym_xindex(), this->of_);
4729 }
4730
4731 // Write_after_input_sections_task methods.
4732
4733 // We can only run this task after the input sections have completed.
4734
4735 Task_token*
4736 Write_after_input_sections_task::is_runnable()
4737 {
4738   if (this->input_sections_blocker_->is_blocked())
4739     return this->input_sections_blocker_;
4740   return NULL;
4741 }
4742
4743 // We need to unlock FINAL_BLOCKER when finished.
4744
4745 void
4746 Write_after_input_sections_task::locks(Task_locker* tl)
4747 {
4748   tl->add(this, this->final_blocker_);
4749 }
4750
4751 // Run the task.
4752
4753 void
4754 Write_after_input_sections_task::run(Workqueue*)
4755 {
4756   this->layout_->write_sections_after_input_sections(this->of_);
4757 }
4758
4759 // Close_task_runner methods.
4760
4761 // Run the task--close the file.
4762
4763 void
4764 Close_task_runner::run(Workqueue*, const Task*)
4765 {
4766   // If we need to compute a checksum for the BUILD if, we do so here.
4767   this->layout_->write_build_id(this->of_);
4768
4769   // If we've been asked to create a binary file, we do so here.
4770   if (this->options_->oformat_enum() != General_options::OBJECT_FORMAT_ELF)
4771     this->layout_->write_binary(this->of_);
4772
4773   this->of_->close();
4774 }
4775
4776 // Instantiate the templates we need.  We could use the configure
4777 // script to restrict this to only the ones for implemented targets.
4778
4779 #ifdef HAVE_TARGET_32_LITTLE
4780 template
4781 Output_section*
4782 Layout::init_fixed_output_section<32, false>(
4783     const char* name,
4784     elfcpp::Shdr<32, false>& shdr);
4785 #endif
4786
4787 #ifdef HAVE_TARGET_32_BIG
4788 template
4789 Output_section*
4790 Layout::init_fixed_output_section<32, true>(
4791     const char* name,
4792     elfcpp::Shdr<32, true>& shdr);
4793 #endif
4794
4795 #ifdef HAVE_TARGET_64_LITTLE
4796 template
4797 Output_section*
4798 Layout::init_fixed_output_section<64, false>(
4799     const char* name,
4800     elfcpp::Shdr<64, false>& shdr);
4801 #endif
4802
4803 #ifdef HAVE_TARGET_64_BIG
4804 template
4805 Output_section*
4806 Layout::init_fixed_output_section<64, true>(
4807     const char* name,
4808     elfcpp::Shdr<64, true>& shdr);
4809 #endif
4810
4811 #ifdef HAVE_TARGET_32_LITTLE
4812 template
4813 Output_section*
4814 Layout::layout<32, false>(Sized_relobj_file<32, false>* object,
4815                           unsigned int shndx,
4816                           const char* name,
4817                           const elfcpp::Shdr<32, false>& shdr,
4818                           unsigned int, unsigned int, off_t*);
4819 #endif
4820
4821 #ifdef HAVE_TARGET_32_BIG
4822 template
4823 Output_section*
4824 Layout::layout<32, true>(Sized_relobj_file<32, true>* object,
4825                          unsigned int shndx,
4826                          const char* name,
4827                          const elfcpp::Shdr<32, true>& shdr,
4828                          unsigned int, unsigned int, off_t*);
4829 #endif
4830
4831 #ifdef HAVE_TARGET_64_LITTLE
4832 template
4833 Output_section*
4834 Layout::layout<64, false>(Sized_relobj_file<64, false>* object,
4835                           unsigned int shndx,
4836                           const char* name,
4837                           const elfcpp::Shdr<64, false>& shdr,
4838                           unsigned int, unsigned int, off_t*);
4839 #endif
4840
4841 #ifdef HAVE_TARGET_64_BIG
4842 template
4843 Output_section*
4844 Layout::layout<64, true>(Sized_relobj_file<64, true>* object,
4845                          unsigned int shndx,
4846                          const char* name,
4847                          const elfcpp::Shdr<64, true>& shdr,
4848                          unsigned int, unsigned int, off_t*);
4849 #endif
4850
4851 #ifdef HAVE_TARGET_32_LITTLE
4852 template
4853 Output_section*
4854 Layout::layout_reloc<32, false>(Sized_relobj_file<32, false>* object,
4855                                 unsigned int reloc_shndx,
4856                                 const elfcpp::Shdr<32, false>& shdr,
4857                                 Output_section* data_section,
4858                                 Relocatable_relocs* rr);
4859 #endif
4860
4861 #ifdef HAVE_TARGET_32_BIG
4862 template
4863 Output_section*
4864 Layout::layout_reloc<32, true>(Sized_relobj_file<32, true>* object,
4865                                unsigned int reloc_shndx,
4866                                const elfcpp::Shdr<32, true>& shdr,
4867                                Output_section* data_section,
4868                                Relocatable_relocs* rr);
4869 #endif
4870
4871 #ifdef HAVE_TARGET_64_LITTLE
4872 template
4873 Output_section*
4874 Layout::layout_reloc<64, false>(Sized_relobj_file<64, false>* object,
4875                                 unsigned int reloc_shndx,
4876                                 const elfcpp::Shdr<64, false>& shdr,
4877                                 Output_section* data_section,
4878                                 Relocatable_relocs* rr);
4879 #endif
4880
4881 #ifdef HAVE_TARGET_64_BIG
4882 template
4883 Output_section*
4884 Layout::layout_reloc<64, true>(Sized_relobj_file<64, true>* object,
4885                                unsigned int reloc_shndx,
4886                                const elfcpp::Shdr<64, true>& shdr,
4887                                Output_section* data_section,
4888                                Relocatable_relocs* rr);
4889 #endif
4890
4891 #ifdef HAVE_TARGET_32_LITTLE
4892 template
4893 void
4894 Layout::layout_group<32, false>(Symbol_table* symtab,
4895                                 Sized_relobj_file<32, false>* object,
4896                                 unsigned int,
4897                                 const char* group_section_name,
4898                                 const char* signature,
4899                                 const elfcpp::Shdr<32, false>& shdr,
4900                                 elfcpp::Elf_Word flags,
4901                                 std::vector<unsigned int>* shndxes);
4902 #endif
4903
4904 #ifdef HAVE_TARGET_32_BIG
4905 template
4906 void
4907 Layout::layout_group<32, true>(Symbol_table* symtab,
4908                                Sized_relobj_file<32, true>* object,
4909                                unsigned int,
4910                                const char* group_section_name,
4911                                const char* signature,
4912                                const elfcpp::Shdr<32, true>& shdr,
4913                                elfcpp::Elf_Word flags,
4914                                std::vector<unsigned int>* shndxes);
4915 #endif
4916
4917 #ifdef HAVE_TARGET_64_LITTLE
4918 template
4919 void
4920 Layout::layout_group<64, false>(Symbol_table* symtab,
4921                                 Sized_relobj_file<64, false>* object,
4922                                 unsigned int,
4923                                 const char* group_section_name,
4924                                 const char* signature,
4925                                 const elfcpp::Shdr<64, false>& shdr,
4926                                 elfcpp::Elf_Word flags,
4927                                 std::vector<unsigned int>* shndxes);
4928 #endif
4929
4930 #ifdef HAVE_TARGET_64_BIG
4931 template
4932 void
4933 Layout::layout_group<64, true>(Symbol_table* symtab,
4934                                Sized_relobj_file<64, true>* object,
4935                                unsigned int,
4936                                const char* group_section_name,
4937                                const char* signature,
4938                                const elfcpp::Shdr<64, true>& shdr,
4939                                elfcpp::Elf_Word flags,
4940                                std::vector<unsigned int>* shndxes);
4941 #endif
4942
4943 #ifdef HAVE_TARGET_32_LITTLE
4944 template
4945 Output_section*
4946 Layout::layout_eh_frame<32, false>(Sized_relobj_file<32, false>* object,
4947                                    const unsigned char* symbols,
4948                                    off_t symbols_size,
4949                                    const unsigned char* symbol_names,
4950                                    off_t symbol_names_size,
4951                                    unsigned int shndx,
4952                                    const elfcpp::Shdr<32, false>& shdr,
4953                                    unsigned int reloc_shndx,
4954                                    unsigned int reloc_type,
4955                                    off_t* off);
4956 #endif
4957
4958 #ifdef HAVE_TARGET_32_BIG
4959 template
4960 Output_section*
4961 Layout::layout_eh_frame<32, true>(Sized_relobj_file<32, true>* object,
4962                                   const unsigned char* symbols,
4963                                   off_t symbols_size,
4964                                   const unsigned char* symbol_names,
4965                                   off_t symbol_names_size,
4966                                   unsigned int shndx,
4967                                   const elfcpp::Shdr<32, true>& shdr,
4968                                   unsigned int reloc_shndx,
4969                                   unsigned int reloc_type,
4970                                   off_t* off);
4971 #endif
4972
4973 #ifdef HAVE_TARGET_64_LITTLE
4974 template
4975 Output_section*
4976 Layout::layout_eh_frame<64, false>(Sized_relobj_file<64, false>* object,
4977                                    const unsigned char* symbols,
4978                                    off_t symbols_size,
4979                                    const unsigned char* symbol_names,
4980                                    off_t symbol_names_size,
4981                                    unsigned int shndx,
4982                                    const elfcpp::Shdr<64, false>& shdr,
4983                                    unsigned int reloc_shndx,
4984                                    unsigned int reloc_type,
4985                                    off_t* off);
4986 #endif
4987
4988 #ifdef HAVE_TARGET_64_BIG
4989 template
4990 Output_section*
4991 Layout::layout_eh_frame<64, true>(Sized_relobj_file<64, true>* object,
4992                                   const unsigned char* symbols,
4993                                   off_t symbols_size,
4994                                   const unsigned char* symbol_names,
4995                                   off_t symbol_names_size,
4996                                   unsigned int shndx,
4997                                   const elfcpp::Shdr<64, true>& shdr,
4998                                   unsigned int reloc_shndx,
4999                                   unsigned int reloc_type,
5000                                   off_t* off);
5001 #endif
5002
5003 } // End namespace gold.