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