1 // layout.cc -- lay out output file sections for gold
2 
3 // Copyright (C) 2006-2020 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 #ifdef __MINGW32__
38 #include <windows.h>
39 #include <rpcdce.h>
40 #endif
41 
42 #include "parameters.h"
43 #include "options.h"
44 #include "mapfile.h"
45 #include "script.h"
46 #include "script-sections.h"
47 #include "output.h"
48 #include "symtab.h"
49 #include "dynobj.h"
50 #include "ehframe.h"
51 #include "gdb-index.h"
52 #include "compressed_output.h"
53 #include "reduced_debug_output.h"
54 #include "object.h"
55 #include "reloc.h"
56 #include "descriptors.h"
57 #include "plugin.h"
58 #include "incremental.h"
59 #include "layout.h"
60 
61 namespace gold
62 {
63 
64 // Class Free_list.
65 
66 // The total number of free lists used.
67 unsigned int Free_list::num_lists = 0;
68 // The total number of free list nodes used.
69 unsigned int Free_list::num_nodes = 0;
70 // The total number of calls to Free_list::remove.
71 unsigned int Free_list::num_removes = 0;
72 // The total number of nodes visited during calls to Free_list::remove.
73 unsigned int Free_list::num_remove_visits = 0;
74 // The total number of calls to Free_list::allocate.
75 unsigned int Free_list::num_allocates = 0;
76 // The total number of nodes visited during calls to Free_list::allocate.
77 unsigned int Free_list::num_allocate_visits = 0;
78 
79 // Initialize the free list.  Creates a single free list node that
80 // describes the entire region of length LEN.  If EXTEND is true,
81 // allocate() is allowed to extend the region beyond its initial
82 // length.
83 
84 void
init(off_t len,bool extend)85 Free_list::init(off_t len, bool extend)
86 {
87   this->list_.push_front(Free_list_node(0, len));
88   this->last_remove_ = this->list_.begin();
89   this->extend_ = extend;
90   this->length_ = len;
91   ++Free_list::num_lists;
92   ++Free_list::num_nodes;
93 }
94 
95 // Remove a chunk from the free list.  Because we start with a single
96 // node that covers the entire section, and remove chunks from it one
97 // at a time, we do not need to coalesce chunks or handle cases that
98 // span more than one free node.  We expect to remove chunks from the
99 // free list in order, and we expect to have only a few chunks of free
100 // space left (corresponding to files that have changed since the last
101 // incremental link), so a simple linear list should provide sufficient
102 // performance.
103 
104 void
remove(off_t start,off_t end)105 Free_list::remove(off_t start, off_t end)
106 {
107   if (start == end)
108     return;
109   gold_assert(start < end);
110 
111   ++Free_list::num_removes;
112 
113   Iterator p = this->last_remove_;
114   if (p->start_ > start)
115     p = this->list_.begin();
116 
117   for (; p != this->list_.end(); ++p)
118     {
119       ++Free_list::num_remove_visits;
120       // Find a node that wholly contains the indicated region.
121       if (p->start_ <= start && p->end_ >= end)
122 	{
123 	  // Case 1: the indicated region spans the whole node.
124 	  // Add some fuzz to avoid creating tiny free chunks.
125 	  if (p->start_ + 3 >= start && p->end_ <= end + 3)
126 	    p = this->list_.erase(p);
127 	  // Case 2: remove a chunk from the start of the node.
128 	  else if (p->start_ + 3 >= start)
129 	    p->start_ = end;
130 	  // Case 3: remove a chunk from the end of the node.
131 	  else if (p->end_ <= end + 3)
132 	    p->end_ = start;
133 	  // Case 4: remove a chunk from the middle, and split
134 	  // the node into two.
135 	  else
136 	    {
137 	      Free_list_node newnode(p->start_, start);
138 	      p->start_ = end;
139 	      this->list_.insert(p, newnode);
140 	      ++Free_list::num_nodes;
141 	    }
142 	  this->last_remove_ = p;
143 	  return;
144 	}
145     }
146 
147   // Did not find a node containing the given chunk.  This could happen
148   // because a small chunk was already removed due to the fuzz.
149   gold_debug(DEBUG_INCREMENTAL,
150 	     "Free_list::remove(%d,%d) not found",
151 	     static_cast<int>(start), static_cast<int>(end));
152 }
153 
154 // Allocate a chunk of size LEN from the free list.  Returns -1ULL
155 // if a sufficiently large chunk of free space is not found.
156 // We use a simple first-fit algorithm.
157 
158 off_t
allocate(off_t len,uint64_t align,off_t minoff)159 Free_list::allocate(off_t len, uint64_t align, off_t minoff)
160 {
161   gold_debug(DEBUG_INCREMENTAL,
162 	     "Free_list::allocate(%08lx, %d, %08lx)",
163 	     static_cast<long>(len), static_cast<int>(align),
164 	     static_cast<long>(minoff));
165   if (len == 0)
166     return align_address(minoff, align);
167 
168   ++Free_list::num_allocates;
169 
170   // We usually want to drop free chunks smaller than 4 bytes.
171   // If we need to guarantee a minimum hole size, though, we need
172   // to keep track of all free chunks.
173   const int fuzz = this->min_hole_ > 0 ? 0 : 3;
174 
175   for (Iterator p = this->list_.begin(); p != this->list_.end(); ++p)
176     {
177       ++Free_list::num_allocate_visits;
178       off_t start = p->start_ > minoff ? p->start_ : minoff;
179       start = align_address(start, align);
180       off_t end = start + len;
181       if (end > p->end_ && p->end_ == this->length_ && this->extend_)
182 	{
183 	  this->length_ = end;
184 	  p->end_ = end;
185 	}
186       if (end == p->end_ || (end <= p->end_ - this->min_hole_))
187 	{
188 	  if (p->start_ + fuzz >= start && p->end_ <= end + fuzz)
189 	    this->list_.erase(p);
190 	  else if (p->start_ + fuzz >= start)
191 	    p->start_ = end;
192 	  else if (p->end_ <= end + fuzz)
193 	    p->end_ = start;
194 	  else
195 	    {
196 	      Free_list_node newnode(p->start_, start);
197 	      p->start_ = end;
198 	      this->list_.insert(p, newnode);
199 	      ++Free_list::num_nodes;
200 	    }
201 	  return start;
202 	}
203     }
204   if (this->extend_)
205     {
206       off_t start = align_address(this->length_, align);
207       this->length_ = start + len;
208       return start;
209     }
210   return -1;
211 }
212 
213 // Dump the free list (for debugging).
214 void
dump()215 Free_list::dump()
216 {
217   gold_info("Free list:\n     start      end   length\n");
218   for (Iterator p = this->list_.begin(); p != this->list_.end(); ++p)
219     gold_info("  %08lx %08lx %08lx", static_cast<long>(p->start_),
220 	      static_cast<long>(p->end_),
221 	      static_cast<long>(p->end_ - p->start_));
222 }
223 
224 // Print the statistics for the free lists.
225 void
print_stats()226 Free_list::print_stats()
227 {
228   fprintf(stderr, _("%s: total free lists: %u\n"),
229 	  program_name, Free_list::num_lists);
230   fprintf(stderr, _("%s: total free list nodes: %u\n"),
231 	  program_name, Free_list::num_nodes);
232   fprintf(stderr, _("%s: calls to Free_list::remove: %u\n"),
233 	  program_name, Free_list::num_removes);
234   fprintf(stderr, _("%s: nodes visited: %u\n"),
235 	  program_name, Free_list::num_remove_visits);
236   fprintf(stderr, _("%s: calls to Free_list::allocate: %u\n"),
237 	  program_name, Free_list::num_allocates);
238   fprintf(stderr, _("%s: nodes visited: %u\n"),
239 	  program_name, Free_list::num_allocate_visits);
240 }
241 
242 // A Hash_task computes the MD5 checksum of an array of char.
243 
244 class Hash_task : public Task
245 {
246  public:
Hash_task(Output_file * of,size_t offset,size_t size,unsigned char * dst,Task_token * final_blocker)247   Hash_task(Output_file* of,
248 	    size_t offset,
249 	    size_t size,
250 	    unsigned char* dst,
251 	    Task_token* final_blocker)
252     : of_(of), offset_(offset), size_(size), dst_(dst),
253       final_blocker_(final_blocker)
254   { }
255 
256   void
run(Workqueue *)257   run(Workqueue*)
258   {
259     const unsigned char* iv =
260 	this->of_->get_input_view(this->offset_, this->size_);
261     md5_buffer(reinterpret_cast<const char*>(iv), this->size_, this->dst_);
262     this->of_->free_input_view(this->offset_, this->size_, iv);
263   }
264 
265   Task_token*
is_runnable()266   is_runnable()
267   { return NULL; }
268 
269   // Unblock FINAL_BLOCKER_ when done.
270   void
locks(Task_locker * tl)271   locks(Task_locker* tl)
272   { tl->add(this, this->final_blocker_); }
273 
274   std::string
get_name() const275   get_name() const
276   { return "Hash_task"; }
277 
278  private:
279   Output_file* of_;
280   const size_t offset_;
281   const size_t size_;
282   unsigned char* const dst_;
283   Task_token* const final_blocker_;
284 };
285 
286 // Layout::Relaxation_debug_check methods.
287 
288 // Check that sections and special data are in reset states.
289 // We do not save states for Output_sections and special Output_data.
290 // So we check that they have not assigned any addresses or offsets.
291 // clean_up_after_relaxation simply resets their addresses and offsets.
292 void
check_output_data_for_reset_values(const Layout::Section_list & sections,const Layout::Data_list & special_outputs,const Layout::Data_list & relax_outputs)293 Layout::Relaxation_debug_check::check_output_data_for_reset_values(
294     const Layout::Section_list& sections,
295     const Layout::Data_list& special_outputs,
296     const Layout::Data_list& relax_outputs)
297 {
298   for(Layout::Section_list::const_iterator p = sections.begin();
299       p != sections.end();
300       ++p)
301     gold_assert((*p)->address_and_file_offset_have_reset_values());
302 
303   for(Layout::Data_list::const_iterator p = special_outputs.begin();
304       p != special_outputs.end();
305       ++p)
306     gold_assert((*p)->address_and_file_offset_have_reset_values());
307 
308   gold_assert(relax_outputs.empty());
309 }
310 
311 // Save information of SECTIONS for checking later.
312 
313 void
read_sections(const Layout::Section_list & sections)314 Layout::Relaxation_debug_check::read_sections(
315     const Layout::Section_list& sections)
316 {
317   for(Layout::Section_list::const_iterator p = sections.begin();
318       p != sections.end();
319       ++p)
320     {
321       Output_section* os = *p;
322       Section_info info;
323       info.output_section = os;
324       info.address = os->is_address_valid() ? os->address() : 0;
325       info.data_size = os->is_data_size_valid() ? os->data_size() : -1;
326       info.offset = os->is_offset_valid()? os->offset() : -1 ;
327       this->section_infos_.push_back(info);
328     }
329 }
330 
331 // Verify SECTIONS using previously recorded information.
332 
333 void
verify_sections(const Layout::Section_list & sections)334 Layout::Relaxation_debug_check::verify_sections(
335     const Layout::Section_list& sections)
336 {
337   size_t i = 0;
338   for(Layout::Section_list::const_iterator p = sections.begin();
339       p != sections.end();
340       ++p, ++i)
341     {
342       Output_section* os = *p;
343       uint64_t address = os->is_address_valid() ? os->address() : 0;
344       off_t data_size = os->is_data_size_valid() ? os->data_size() : -1;
345       off_t offset = os->is_offset_valid()? os->offset() : -1 ;
346 
347       if (i >= this->section_infos_.size())
348 	{
349 	  gold_fatal("Section_info of %s missing.\n", os->name());
350 	}
351       const Section_info& info = this->section_infos_[i];
352       if (os != info.output_section)
353 	gold_fatal("Section order changed.  Expecting %s but see %s\n",
354 		   info.output_section->name(), os->name());
355       if (address != info.address
356 	  || data_size != info.data_size
357 	  || offset != info.offset)
358 	gold_fatal("Section %s changed.\n", os->name());
359     }
360 }
361 
362 // Layout_task_runner methods.
363 
364 // Lay out the sections.  This is called after all the input objects
365 // have been read.
366 
367 void
run(Workqueue * workqueue,const Task * task)368 Layout_task_runner::run(Workqueue* workqueue, const Task* task)
369 {
370   // See if any of the input definitions violate the One Definition Rule.
371   // TODO: if this is too slow, do this as a task, rather than inline.
372   this->symtab_->detect_odr_violations(task, this->options_.output_file_name());
373 
374   Layout* layout = this->layout_;
375   off_t file_size = layout->finalize(this->input_objects_,
376 				     this->symtab_,
377 				     this->target_,
378 				     task);
379 
380   // Now we know the final size of the output file and we know where
381   // each piece of information goes.
382 
383   if (this->mapfile_ != NULL)
384     {
385       this->mapfile_->print_discarded_sections(this->input_objects_);
386       layout->print_to_mapfile(this->mapfile_);
387     }
388 
389   Output_file* of;
390   if (layout->incremental_base() == NULL)
391     {
392       of = new Output_file(parameters->options().output_file_name());
393       if (this->options_.oformat_enum() != General_options::OBJECT_FORMAT_ELF)
394 	of->set_is_temporary();
395       of->open(file_size);
396     }
397   else
398     {
399       of = layout->incremental_base()->output_file();
400 
401       // Apply the incremental relocations for symbols whose values
402       // have changed.  We do this before we resize the file and start
403       // writing anything else to it, so that we can read the old
404       // incremental information from the file before (possibly)
405       // overwriting it.
406       if (parameters->incremental_update())
407 	layout->incremental_base()->apply_incremental_relocs(this->symtab_,
408 							     this->layout_,
409 							     of);
410 
411       of->resize(file_size);
412     }
413 
414   // Queue up the final set of tasks.
415   gold::queue_final_tasks(this->options_, this->input_objects_,
416 			  this->symtab_, layout, workqueue, of);
417 }
418 
419 // Layout methods.
420 
Layout(int number_of_input_files,Script_options * script_options)421 Layout::Layout(int number_of_input_files, Script_options* script_options)
422   : number_of_input_files_(number_of_input_files),
423     script_options_(script_options),
424     namepool_(),
425     sympool_(),
426     dynpool_(),
427     signatures_(),
428     section_name_map_(),
429     segment_list_(),
430     section_list_(),
431     unattached_section_list_(),
432     special_output_list_(),
433     relax_output_list_(),
434     section_headers_(NULL),
435     tls_segment_(NULL),
436     relro_segment_(NULL),
437     interp_segment_(NULL),
438     increase_relro_(0),
439     symtab_section_(NULL),
440     symtab_xindex_(NULL),
441     dynsym_section_(NULL),
442     dynsym_xindex_(NULL),
443     dynamic_section_(NULL),
444     dynamic_symbol_(NULL),
445     dynamic_data_(NULL),
446     eh_frame_section_(NULL),
447     eh_frame_data_(NULL),
448     added_eh_frame_data_(false),
449     eh_frame_hdr_section_(NULL),
450     gdb_index_data_(NULL),
451     build_id_note_(NULL),
452     debug_abbrev_(NULL),
453     debug_info_(NULL),
454     group_signatures_(),
455     output_file_size_(-1),
456     have_added_input_section_(false),
457     sections_are_attached_(false),
458     input_requires_executable_stack_(false),
459     input_with_gnu_stack_note_(false),
460     input_without_gnu_stack_note_(false),
461     has_static_tls_(false),
462     any_postprocessing_sections_(false),
463     resized_signatures_(false),
464     have_stabstr_section_(false),
465     section_ordering_specified_(false),
466     unique_segment_for_sections_specified_(false),
467     incremental_inputs_(NULL),
468     record_output_section_data_from_script_(false),
469     lto_slim_object_(false),
470     script_output_section_data_list_(),
471     segment_states_(NULL),
472     relaxation_debug_check_(NULL),
473     section_order_map_(),
474     section_segment_map_(),
475     input_section_position_(),
476     input_section_glob_(),
477     incremental_base_(NULL),
478     free_list_(),
479     gnu_properties_()
480 {
481   // Make space for more than enough segments for a typical file.
482   // This is just for efficiency--it's OK if we wind up needing more.
483   this->segment_list_.reserve(12);
484 
485   // We expect two unattached Output_data objects: the file header and
486   // the segment headers.
487   this->special_output_list_.reserve(2);
488 
489   // Initialize structure needed for an incremental build.
490   if (parameters->incremental())
491     this->incremental_inputs_ = new Incremental_inputs;
492 
493   // The section name pool is worth optimizing in all cases, because
494   // it is small, but there are often overlaps due to .rel sections.
495   this->namepool_.set_optimize();
496 }
497 
498 // For incremental links, record the base file to be modified.
499 
500 void
set_incremental_base(Incremental_binary * base)501 Layout::set_incremental_base(Incremental_binary* base)
502 {
503   this->incremental_base_ = base;
504   this->free_list_.init(base->output_file()->filesize(), true);
505 }
506 
507 // Hash a key we use to look up an output section mapping.
508 
509 size_t
operator ()(const Layout::Key & k) const510 Layout::Hash_key::operator()(const Layout::Key& k) const
511 {
512  return k.first + k.second.first + k.second.second;
513 }
514 
515 // These are the debug sections that are actually used by gdb.
516 // Currently, we've checked versions of gdb up to and including 7.4.
517 // We only check the part of the name that follows ".debug_" or
518 // ".zdebug_".
519 
520 static const char* gdb_sections[] =
521 {
522   "abbrev",
523   "addr",         // Fission extension
524   // "aranges",   // not used by gdb as of 7.4
525   "frame",
526   "gdb_scripts",
527   "info",
528   "types",
529   "line",
530   "loc",
531   "macinfo",
532   "macro",
533   // "pubnames",  // not used by gdb as of 7.4
534   // "pubtypes",  // not used by gdb as of 7.4
535   // "gnu_pubnames",  // Fission extension
536   // "gnu_pubtypes",  // Fission extension
537   "ranges",
538   "str",
539   "str_offsets",
540 };
541 
542 // This is the minimum set of sections needed for line numbers.
543 
544 static const char* lines_only_debug_sections[] =
545 {
546   "abbrev",
547   // "addr",      // Fission extension
548   // "aranges",   // not used by gdb as of 7.4
549   // "frame",
550   // "gdb_scripts",
551   "info",
552   // "types",
553   "line",
554   // "loc",
555   // "macinfo",
556   // "macro",
557   // "pubnames",  // not used by gdb as of 7.4
558   // "pubtypes",  // not used by gdb as of 7.4
559   // "gnu_pubnames",  // Fission extension
560   // "gnu_pubtypes",  // Fission extension
561   // "ranges",
562   "str",
563   "str_offsets",  // Fission extension
564 };
565 
566 // These sections are the DWARF fast-lookup tables, and are not needed
567 // when building a .gdb_index section.
568 
569 static const char* gdb_fast_lookup_sections[] =
570 {
571   "aranges",
572   "pubnames",
573   "gnu_pubnames",
574   "pubtypes",
575   "gnu_pubtypes",
576 };
577 
578 // Returns whether the given debug section is in the list of
579 // debug-sections-used-by-some-version-of-gdb.  SUFFIX is the
580 // portion of the name following ".debug_" or ".zdebug_".
581 
582 static inline bool
is_gdb_debug_section(const char * suffix)583 is_gdb_debug_section(const char* suffix)
584 {
585   // We can do this faster: binary search or a hashtable.  But why bother?
586   for (size_t i = 0; i < sizeof(gdb_sections)/sizeof(*gdb_sections); ++i)
587     if (strcmp(suffix, gdb_sections[i]) == 0)
588       return true;
589   return false;
590 }
591 
592 // Returns whether the given section is needed for lines-only debugging.
593 
594 static inline bool
is_lines_only_debug_section(const char * suffix)595 is_lines_only_debug_section(const char* suffix)
596 {
597   // We can do this faster: binary search or a hashtable.  But why bother?
598   for (size_t i = 0;
599        i < sizeof(lines_only_debug_sections)/sizeof(*lines_only_debug_sections);
600        ++i)
601     if (strcmp(suffix, lines_only_debug_sections[i]) == 0)
602       return true;
603   return false;
604 }
605 
606 // Returns whether the given section is a fast-lookup section that
607 // will not be needed when building a .gdb_index section.
608 
609 static inline bool
is_gdb_fast_lookup_section(const char * suffix)610 is_gdb_fast_lookup_section(const char* suffix)
611 {
612   // We can do this faster: binary search or a hashtable.  But why bother?
613   for (size_t i = 0;
614        i < sizeof(gdb_fast_lookup_sections)/sizeof(*gdb_fast_lookup_sections);
615        ++i)
616     if (strcmp(suffix, gdb_fast_lookup_sections[i]) == 0)
617       return true;
618   return false;
619 }
620 
621 // Sometimes we compress sections.  This is typically done for
622 // sections that are not part of normal program execution (such as
623 // .debug_* sections), and where the readers of these sections know
624 // how to deal with compressed sections.  This routine doesn't say for
625 // certain whether we'll compress -- it depends on commandline options
626 // as well -- just whether this section is a candidate for compression.
627 // (The Output_compressed_section class decides whether to compress
628 // a given section, and picks the name of the compressed section.)
629 
630 static bool
is_compressible_debug_section(const char * secname)631 is_compressible_debug_section(const char* secname)
632 {
633   return (is_prefix_of(".debug", secname));
634 }
635 
636 // We may see compressed debug sections in input files.  Return TRUE
637 // if this is the name of a compressed debug section.
638 
639 bool
is_compressed_debug_section(const char * secname)640 is_compressed_debug_section(const char* secname)
641 {
642   return (is_prefix_of(".zdebug", secname));
643 }
644 
645 std::string
corresponding_uncompressed_section_name(std::string secname)646 corresponding_uncompressed_section_name(std::string secname)
647 {
648   gold_assert(secname[0] == '.' && secname[1] == 'z');
649   std::string ret(".");
650   ret.append(secname, 2, std::string::npos);
651   return ret;
652 }
653 
654 // Whether to include this section in the link.
655 
656 template<int size, bool big_endian>
657 bool
include_section(Sized_relobj_file<size,big_endian> *,const char * name,const elfcpp::Shdr<size,big_endian> & shdr)658 Layout::include_section(Sized_relobj_file<size, big_endian>*, const char* name,
659 			const elfcpp::Shdr<size, big_endian>& shdr)
660 {
661   if (!parameters->options().relocatable()
662       && (shdr.get_sh_flags() & elfcpp::SHF_EXCLUDE))
663     return false;
664 
665   elfcpp::Elf_Word sh_type = shdr.get_sh_type();
666 
667   if ((sh_type >= elfcpp::SHT_LOOS && sh_type <= elfcpp::SHT_HIOS)
668       || (sh_type >= elfcpp::SHT_LOPROC && sh_type <= elfcpp::SHT_HIPROC))
669     return parameters->target().should_include_section(sh_type);
670 
671   switch (sh_type)
672     {
673     case elfcpp::SHT_NULL:
674     case elfcpp::SHT_SYMTAB:
675     case elfcpp::SHT_DYNSYM:
676     case elfcpp::SHT_HASH:
677     case elfcpp::SHT_DYNAMIC:
678     case elfcpp::SHT_SYMTAB_SHNDX:
679       return false;
680 
681     case elfcpp::SHT_STRTAB:
682       // Discard the sections which have special meanings in the ELF
683       // ABI.  Keep others (e.g., .stabstr).  We could also do this by
684       // checking the sh_link fields of the appropriate sections.
685       return (strcmp(name, ".dynstr") != 0
686 	      && strcmp(name, ".strtab") != 0
687 	      && strcmp(name, ".shstrtab") != 0);
688 
689     case elfcpp::SHT_RELA:
690     case elfcpp::SHT_REL:
691     case elfcpp::SHT_GROUP:
692       // If we are emitting relocations these should be handled
693       // elsewhere.
694       gold_assert(!parameters->options().relocatable());
695       return false;
696 
697     case elfcpp::SHT_PROGBITS:
698       if (parameters->options().strip_debug()
699 	  && (shdr.get_sh_flags() & elfcpp::SHF_ALLOC) == 0)
700 	{
701 	  if (is_debug_info_section(name))
702 	    return false;
703 	}
704       if (parameters->options().strip_debug_non_line()
705 	  && (shdr.get_sh_flags() & elfcpp::SHF_ALLOC) == 0)
706 	{
707 	  // Debugging sections can only be recognized by name.
708 	  if (is_prefix_of(".debug_", name)
709 	      && !is_lines_only_debug_section(name + 7))
710 	    return false;
711 	  if (is_prefix_of(".zdebug_", name)
712 	      && !is_lines_only_debug_section(name + 8))
713 	    return false;
714 	}
715       if (parameters->options().strip_debug_gdb()
716 	  && (shdr.get_sh_flags() & elfcpp::SHF_ALLOC) == 0)
717 	{
718 	  // Debugging sections can only be recognized by name.
719 	  if (is_prefix_of(".debug_", name)
720 	      && !is_gdb_debug_section(name + 7))
721 	    return false;
722 	  if (is_prefix_of(".zdebug_", name)
723 	      && !is_gdb_debug_section(name + 8))
724 	    return false;
725 	}
726       if (parameters->options().gdb_index()
727 	  && (shdr.get_sh_flags() & elfcpp::SHF_ALLOC) == 0)
728 	{
729 	  // When building .gdb_index, we can strip .debug_pubnames,
730 	  // .debug_pubtypes, and .debug_aranges sections.
731 	  if (is_prefix_of(".debug_", name)
732 	      && is_gdb_fast_lookup_section(name + 7))
733 	    return false;
734 	  if (is_prefix_of(".zdebug_", name)
735 	      && is_gdb_fast_lookup_section(name + 8))
736 	    return false;
737 	}
738       if (parameters->options().strip_lto_sections()
739 	  && !parameters->options().relocatable()
740 	  && (shdr.get_sh_flags() & elfcpp::SHF_ALLOC) == 0)
741 	{
742 	  // Ignore LTO sections containing intermediate code.
743 	  if (is_prefix_of(".gnu.lto_", name))
744 	    return false;
745 	}
746       // The GNU linker strips .gnu_debuglink sections, so we do too.
747       // This is a feature used to keep debugging information in
748       // separate files.
749       if (strcmp(name, ".gnu_debuglink") == 0)
750 	return false;
751       return true;
752 
753     default:
754       return true;
755     }
756 }
757 
758 // Return an output section named NAME, or NULL if there is none.
759 
760 Output_section*
find_output_section(const char * name) const761 Layout::find_output_section(const char* name) const
762 {
763   for (Section_list::const_iterator p = this->section_list_.begin();
764        p != this->section_list_.end();
765        ++p)
766     if (strcmp((*p)->name(), name) == 0)
767       return *p;
768   return NULL;
769 }
770 
771 // Return an output segment of type TYPE, with segment flags SET set
772 // and segment flags CLEAR clear.  Return NULL if there is none.
773 
774 Output_segment*
find_output_segment(elfcpp::PT type,elfcpp::Elf_Word set,elfcpp::Elf_Word clear) const775 Layout::find_output_segment(elfcpp::PT type, elfcpp::Elf_Word set,
776 			    elfcpp::Elf_Word clear) const
777 {
778   for (Segment_list::const_iterator p = this->segment_list_.begin();
779        p != this->segment_list_.end();
780        ++p)
781     if (static_cast<elfcpp::PT>((*p)->type()) == type
782 	&& ((*p)->flags() & set) == set
783 	&& ((*p)->flags() & clear) == 0)
784       return *p;
785   return NULL;
786 }
787 
788 // When we put a .ctors or .dtors section with more than one word into
789 // a .init_array or .fini_array section, we need to reverse the words
790 // in the .ctors/.dtors section.  This is because .init_array executes
791 // constructors front to back, where .ctors executes them back to
792 // front, and vice-versa for .fini_array/.dtors.  Although we do want
793 // to remap .ctors/.dtors into .init_array/.fini_array because it can
794 // be more efficient, we don't want to change the order in which
795 // constructors/destructors are run.  This set just keeps track of
796 // these sections which need to be reversed.  It is only changed by
797 // Layout::layout.  It should be a private member of Layout, but that
798 // would require layout.h to #include object.h to get the definition
799 // of Section_id.
800 static Unordered_set<Section_id, Section_id_hash> ctors_sections_in_init_array;
801 
802 // Return whether OBJECT/SHNDX is a .ctors/.dtors section mapped to a
803 // .init_array/.fini_array section.
804 
805 bool
is_ctors_in_init_array(Relobj * relobj,unsigned int shndx) const806 Layout::is_ctors_in_init_array(Relobj* relobj, unsigned int shndx) const
807 {
808   return (ctors_sections_in_init_array.find(Section_id(relobj, shndx))
809 	  != ctors_sections_in_init_array.end());
810 }
811 
812 // Return the output section to use for section NAME with type TYPE
813 // and section flags FLAGS.  NAME must be canonicalized in the string
814 // pool, and NAME_KEY is the key.  ORDER is where this should appear
815 // in the output sections.  IS_RELRO is true for a relro section.
816 
817 Output_section*
get_output_section(const char * name,Stringpool::Key name_key,elfcpp::Elf_Word type,elfcpp::Elf_Xword flags,Output_section_order order,bool is_relro)818 Layout::get_output_section(const char* name, Stringpool::Key name_key,
819 			   elfcpp::Elf_Word type, elfcpp::Elf_Xword flags,
820 			   Output_section_order order, bool is_relro)
821 {
822   elfcpp::Elf_Word lookup_type = type;
823 
824   // For lookup purposes, treat INIT_ARRAY, FINI_ARRAY, and
825   // PREINIT_ARRAY like PROGBITS.  This ensures that we combine
826   // .init_array, .fini_array, and .preinit_array sections by name
827   // whatever their type in the input file.  We do this because the
828   // types are not always right in the input files.
829   if (lookup_type == elfcpp::SHT_INIT_ARRAY
830       || lookup_type == elfcpp::SHT_FINI_ARRAY
831       || lookup_type == elfcpp::SHT_PREINIT_ARRAY)
832     lookup_type = elfcpp::SHT_PROGBITS;
833 
834   elfcpp::Elf_Xword lookup_flags = flags;
835 
836   // Ignoring SHF_WRITE and SHF_EXECINSTR here means that we combine
837   // read-write with read-only sections.  Some other ELF linkers do
838   // not do this.  FIXME: Perhaps there should be an option
839   // controlling this.
840   lookup_flags &= ~(elfcpp::SHF_WRITE | elfcpp::SHF_EXECINSTR);
841 
842   const Key key(name_key, std::make_pair(lookup_type, lookup_flags));
843   const std::pair<Key, Output_section*> v(key, NULL);
844   std::pair<Section_name_map::iterator, bool> ins(
845     this->section_name_map_.insert(v));
846 
847   if (!ins.second)
848     return ins.first->second;
849   else
850     {
851       // This is the first time we've seen this name/type/flags
852       // combination.  For compatibility with the GNU linker, we
853       // combine sections with contents and zero flags with sections
854       // with non-zero flags.  This is a workaround for cases where
855       // assembler code forgets to set section flags.  FIXME: Perhaps
856       // there should be an option to control this.
857       Output_section* os = NULL;
858 
859       if (lookup_type == elfcpp::SHT_PROGBITS)
860 	{
861 	  if (flags == 0)
862 	    {
863 	      Output_section* same_name = this->find_output_section(name);
864 	      if (same_name != NULL
865 		  && (same_name->type() == elfcpp::SHT_PROGBITS
866 		      || same_name->type() == elfcpp::SHT_INIT_ARRAY
867 		      || same_name->type() == elfcpp::SHT_FINI_ARRAY
868 		      || same_name->type() == elfcpp::SHT_PREINIT_ARRAY)
869 		  && (same_name->flags() & elfcpp::SHF_TLS) == 0)
870 		os = same_name;
871 	    }
872 	  else if ((flags & elfcpp::SHF_TLS) == 0)
873 	    {
874 	      elfcpp::Elf_Xword zero_flags = 0;
875 	      const Key zero_key(name_key, std::make_pair(lookup_type,
876 							  zero_flags));
877 	      Section_name_map::iterator p =
878 		  this->section_name_map_.find(zero_key);
879 	      if (p != this->section_name_map_.end())
880 		os = p->second;
881 	    }
882 	}
883 
884       if (os == NULL)
885 	os = this->make_output_section(name, type, flags, order, is_relro);
886 
887       ins.first->second = os;
888       return os;
889     }
890 }
891 
892 // Returns TRUE iff NAME (an input section from RELOBJ) will
893 // be mapped to an output section that should be KEPT.
894 
895 bool
keep_input_section(const Relobj * relobj,const char * name)896 Layout::keep_input_section(const Relobj* relobj, const char* name)
897 {
898   if (! this->script_options_->saw_sections_clause())
899     return false;
900 
901   Script_sections* ss = this->script_options_->script_sections();
902   const char* file_name = relobj == NULL ? NULL : relobj->name().c_str();
903   Output_section** output_section_slot;
904   Script_sections::Section_type script_section_type;
905   bool keep;
906 
907   name = ss->output_section_name(file_name, name, &output_section_slot,
908 				 &script_section_type, &keep, true);
909   return name != NULL && keep;
910 }
911 
912 // Clear the input section flags that should not be copied to the
913 // output section.
914 
915 elfcpp::Elf_Xword
get_output_section_flags(elfcpp::Elf_Xword input_section_flags)916 Layout::get_output_section_flags(elfcpp::Elf_Xword input_section_flags)
917 {
918   // Some flags in the input section should not be automatically
919   // copied to the output section.
920   input_section_flags &= ~ (elfcpp::SHF_INFO_LINK
921 			    | elfcpp::SHF_GROUP
922 			    | elfcpp::SHF_COMPRESSED
923 			    | elfcpp::SHF_MERGE
924 			    | elfcpp::SHF_STRINGS);
925 
926   // We only clear the SHF_LINK_ORDER flag in for
927   // a non-relocatable link.
928   if (!parameters->options().relocatable())
929     input_section_flags &= ~elfcpp::SHF_LINK_ORDER;
930 
931   return input_section_flags;
932 }
933 
934 // Pick the output section to use for section NAME, in input file
935 // RELOBJ, with type TYPE and flags FLAGS.  RELOBJ may be NULL for a
936 // linker created section.  IS_INPUT_SECTION is true if we are
937 // choosing an output section for an input section found in a input
938 // file.  ORDER is where this section should appear in the output
939 // sections.  IS_RELRO is true for a relro section.  This will return
940 // NULL if the input section should be discarded.  MATCH_INPUT_SPEC
941 // is true if the section name should be matched against input specs
942 // in a linker script.
943 
944 Output_section*
choose_output_section(const Relobj * relobj,const char * name,elfcpp::Elf_Word type,elfcpp::Elf_Xword flags,bool is_input_section,Output_section_order order,bool is_relro,bool is_reloc,bool match_input_spec)945 Layout::choose_output_section(const Relobj* relobj, const char* name,
946 			      elfcpp::Elf_Word type, elfcpp::Elf_Xword flags,
947 			      bool is_input_section, Output_section_order order,
948 			      bool is_relro, bool is_reloc,
949 			      bool match_input_spec)
950 {
951   // We should not see any input sections after we have attached
952   // sections to segments.
953   gold_assert(!is_input_section || !this->sections_are_attached_);
954 
955   flags = this->get_output_section_flags(flags);
956 
957   if (this->script_options_->saw_sections_clause() && !is_reloc)
958     {
959       // We are using a SECTIONS clause, so the output section is
960       // chosen based only on the name.
961 
962       Script_sections* ss = this->script_options_->script_sections();
963       const char* file_name = relobj == NULL ? NULL : relobj->name().c_str();
964       Output_section** output_section_slot;
965       Script_sections::Section_type script_section_type;
966       const char* orig_name = name;
967       bool keep;
968       name = ss->output_section_name(file_name, name, &output_section_slot,
969 				     &script_section_type, &keep,
970 				     match_input_spec);
971 
972       if (name == NULL)
973 	{
974 	  gold_debug(DEBUG_SCRIPT, _("Unable to create output section '%s' "
975 				     "because it is not allowed by the "
976 				     "SECTIONS clause of the linker script"),
977 		     orig_name);
978 	  // The SECTIONS clause says to discard this input section.
979 	  return NULL;
980 	}
981 
982       // We can only handle script section types ST_NONE and ST_NOLOAD.
983       switch (script_section_type)
984 	{
985 	case Script_sections::ST_NONE:
986 	  break;
987 	case Script_sections::ST_NOLOAD:
988 	  flags &= elfcpp::SHF_ALLOC;
989 	  break;
990 	default:
991 	  gold_unreachable();
992 	}
993 
994       // If this is an orphan section--one not mentioned in the linker
995       // script--then OUTPUT_SECTION_SLOT will be NULL, and we do the
996       // default processing below.
997 
998       if (output_section_slot != NULL)
999 	{
1000 	  if (*output_section_slot != NULL)
1001 	    {
1002 	      (*output_section_slot)->update_flags_for_input_section(flags);
1003 	      return *output_section_slot;
1004 	    }
1005 
1006 	  // We don't put sections found in the linker script into
1007 	  // SECTION_NAME_MAP_.  That keeps us from getting confused
1008 	  // if an orphan section is mapped to a section with the same
1009 	  // name as one in the linker script.
1010 
1011 	  name = this->namepool_.add(name, false, NULL);
1012 
1013 	  Output_section* os = this->make_output_section(name, type, flags,
1014 							 order, is_relro);
1015 
1016 	  os->set_found_in_sections_clause();
1017 
1018 	  // Special handling for NOLOAD sections.
1019 	  if (script_section_type == Script_sections::ST_NOLOAD)
1020 	    {
1021 	      os->set_is_noload();
1022 
1023 	      // The constructor of Output_section sets addresses of non-ALLOC
1024 	      // sections to 0 by default.  We don't want that for NOLOAD
1025 	      // sections even if they have no SHF_ALLOC flag.
1026 	      if ((os->flags() & elfcpp::SHF_ALLOC) == 0
1027 		  && os->is_address_valid())
1028 		{
1029 		  gold_assert(os->address() == 0
1030 			      && !os->is_offset_valid()
1031 			      && !os->is_data_size_valid());
1032 		  os->reset_address_and_file_offset();
1033 		}
1034 	    }
1035 
1036 	  *output_section_slot = os;
1037 	  return os;
1038 	}
1039     }
1040 
1041   // FIXME: Handle SHF_OS_NONCONFORMING somewhere.
1042 
1043   size_t len = strlen(name);
1044   std::string uncompressed_name;
1045 
1046   // Compressed debug sections should be mapped to the corresponding
1047   // uncompressed section.
1048   if (is_compressed_debug_section(name))
1049     {
1050       uncompressed_name =
1051 	  corresponding_uncompressed_section_name(std::string(name, len));
1052       name = uncompressed_name.c_str();
1053       len = uncompressed_name.length();
1054     }
1055 
1056   // Turn NAME from the name of the input section into the name of the
1057   // output section.
1058   if (is_input_section
1059       && !this->script_options_->saw_sections_clause()
1060       && !parameters->options().relocatable())
1061     {
1062       const char *orig_name = name;
1063       name = parameters->target().output_section_name(relobj, name, &len);
1064       if (name == NULL)
1065 	name = Layout::output_section_name(relobj, orig_name, &len);
1066     }
1067 
1068   Stringpool::Key name_key;
1069   name = this->namepool_.add_with_length(name, len, true, &name_key);
1070 
1071   // Find or make the output section.  The output section is selected
1072   // based on the section name, type, and flags.
1073   return this->get_output_section(name, name_key, type, flags, order, is_relro);
1074 }
1075 
1076 // For incremental links, record the initial fixed layout of a section
1077 // from the base file, and return a pointer to the Output_section.
1078 
1079 template<int size, bool big_endian>
1080 Output_section*
init_fixed_output_section(const char * name,elfcpp::Shdr<size,big_endian> & shdr)1081 Layout::init_fixed_output_section(const char* name,
1082 				  elfcpp::Shdr<size, big_endian>& shdr)
1083 {
1084   unsigned int sh_type = shdr.get_sh_type();
1085 
1086   // We preserve the layout of PROGBITS, NOBITS, INIT_ARRAY, FINI_ARRAY,
1087   // PRE_INIT_ARRAY, and NOTE sections.
1088   // All others will be created from scratch and reallocated.
1089   if (!can_incremental_update(sh_type))
1090     return NULL;
1091 
1092   // If we're generating a .gdb_index section, we need to regenerate
1093   // it from scratch.
1094   if (parameters->options().gdb_index()
1095       && sh_type == elfcpp::SHT_PROGBITS
1096       && strcmp(name, ".gdb_index") == 0)
1097     return NULL;
1098 
1099   typename elfcpp::Elf_types<size>::Elf_Addr sh_addr = shdr.get_sh_addr();
1100   typename elfcpp::Elf_types<size>::Elf_Off sh_offset = shdr.get_sh_offset();
1101   typename elfcpp::Elf_types<size>::Elf_WXword sh_size = shdr.get_sh_size();
1102   typename elfcpp::Elf_types<size>::Elf_WXword sh_flags = shdr.get_sh_flags();
1103   typename elfcpp::Elf_types<size>::Elf_WXword sh_addralign =
1104       shdr.get_sh_addralign();
1105 
1106   // Make the output section.
1107   Stringpool::Key name_key;
1108   name = this->namepool_.add(name, true, &name_key);
1109   Output_section* os = this->get_output_section(name, name_key, sh_type,
1110 						sh_flags, ORDER_INVALID, false);
1111   os->set_fixed_layout(sh_addr, sh_offset, sh_size, sh_addralign);
1112   if (sh_type != elfcpp::SHT_NOBITS)
1113     this->free_list_.remove(sh_offset, sh_offset + sh_size);
1114   return os;
1115 }
1116 
1117 // Return the index by which an input section should be ordered.  This
1118 // is used to sort some .text sections, for compatibility with GNU ld.
1119 
1120 int
special_ordering_of_input_section(const char * name)1121 Layout::special_ordering_of_input_section(const char* name)
1122 {
1123   // The GNU linker has some special handling for some sections that
1124   // wind up in the .text section.  Sections that start with these
1125   // prefixes must appear first, and must appear in the order listed
1126   // here.
1127   static const char* const text_section_sort[] =
1128   {
1129     ".text.unlikely",
1130     ".text.exit",
1131     ".text.startup",
1132     ".text.hot",
1133     ".text.sorted"
1134   };
1135 
1136   for (size_t i = 0;
1137        i < sizeof(text_section_sort) / sizeof(text_section_sort[0]);
1138        i++)
1139     if (is_prefix_of(text_section_sort[i], name))
1140       return i;
1141 
1142   return -1;
1143 }
1144 
1145 // Return the output section to use for input section SHNDX, with name
1146 // NAME, with header HEADER, from object OBJECT.  RELOC_SHNDX is the
1147 // index of a relocation section which applies to this section, or 0
1148 // if none, or -1U if more than one.  RELOC_TYPE is the type of the
1149 // relocation section if there is one.  Set *OFF to the offset of this
1150 // input section without the output section.  Return NULL if the
1151 // section should be discarded.  Set *OFF to -1 if the section
1152 // contents should not be written directly to the output file, but
1153 // will instead receive special handling.
1154 
1155 template<int size, bool big_endian>
1156 Output_section*
layout(Sized_relobj_file<size,big_endian> * object,unsigned int shndx,const char * name,const elfcpp::Shdr<size,big_endian> & shdr,unsigned int sh_type,unsigned int reloc_shndx,unsigned int,off_t * off)1157 Layout::layout(Sized_relobj_file<size, big_endian>* object, unsigned int shndx,
1158 	       const char* name, const elfcpp::Shdr<size, big_endian>& shdr,
1159 	       unsigned int sh_type, unsigned int reloc_shndx,
1160 	       unsigned int, off_t* off)
1161 {
1162   *off = 0;
1163 
1164   if (!this->include_section(object, name, shdr))
1165     return NULL;
1166 
1167   // In a relocatable link a grouped section must not be combined with
1168   // any other sections.
1169   Output_section* os;
1170   if (parameters->options().relocatable()
1171       && (shdr.get_sh_flags() & elfcpp::SHF_GROUP) != 0)
1172     {
1173       // Some flags in the input section should not be automatically
1174       // copied to the output section.
1175       elfcpp::Elf_Xword flags = (shdr.get_sh_flags()
1176 				 & ~ elfcpp::SHF_COMPRESSED);
1177       name = this->namepool_.add(name, true, NULL);
1178       os = this->make_output_section(name, sh_type, flags,
1179 				     ORDER_INVALID, false);
1180     }
1181   else
1182     {
1183       // All ".text.unlikely.*" sections can be moved to a unique
1184       // segment with --text-unlikely-segment option.
1185       bool text_unlikely_segment
1186           = (parameters->options().text_unlikely_segment()
1187              && is_prefix_of(".text.unlikely",
1188                              object->section_name(shndx).c_str()));
1189       if (text_unlikely_segment)
1190         {
1191 	  elfcpp::Elf_Xword flags
1192 	    = this->get_output_section_flags(shdr.get_sh_flags());
1193 
1194 	  Stringpool::Key name_key;
1195 	  const char* os_name = this->namepool_.add(".text.unlikely", true,
1196 						    &name_key);
1197 	  os = this->get_output_section(os_name, name_key, sh_type, flags,
1198 					ORDER_INVALID, false);
1199           // Map this output section to a unique segment.  This is done to
1200           // separate "text" that is not likely to be executed from "text"
1201           // that is likely executed.
1202 	  os->set_is_unique_segment();
1203         }
1204       else
1205 	{
1206 	  // Plugins can choose to place one or more subsets of sections in
1207 	  // unique segments and this is done by mapping these section subsets
1208 	  // to unique output sections.  Check if this section needs to be
1209 	  // remapped to a unique output section.
1210 	  Section_segment_map::iterator it
1211 	    = this->section_segment_map_.find(Const_section_id(object, shndx));
1212 	  if (it == this->section_segment_map_.end())
1213 	    {
1214 	      os = this->choose_output_section(object, name, sh_type,
1215 					       shdr.get_sh_flags(), true,
1216 					       ORDER_INVALID, false, false,
1217 					       true);
1218 	    }
1219 	  else
1220 	    {
1221 	      // We know the name of the output section, directly call
1222 	      // get_output_section here by-passing choose_output_section.
1223 	      elfcpp::Elf_Xword flags
1224 	        = this->get_output_section_flags(shdr.get_sh_flags());
1225 
1226 	      const char* os_name = it->second->name;
1227 	      Stringpool::Key name_key;
1228 	      os_name = this->namepool_.add(os_name, true, &name_key);
1229 	      os = this->get_output_section(os_name, name_key, sh_type, flags,
1230 					ORDER_INVALID, false);
1231 	      if (!os->is_unique_segment())
1232 	        {
1233 	          os->set_is_unique_segment();
1234 	          os->set_extra_segment_flags(it->second->flags);
1235 	          os->set_segment_alignment(it->second->align);
1236 	        }
1237 	    }
1238 	  }
1239       if (os == NULL)
1240 	return NULL;
1241     }
1242 
1243   // By default the GNU linker sorts input sections whose names match
1244   // .ctors.*, .dtors.*, .init_array.*, or .fini_array.*.  The
1245   // sections are sorted by name.  This is used to implement
1246   // constructor priority ordering.  We are compatible.  When we put
1247   // .ctor sections in .init_array and .dtor sections in .fini_array,
1248   // we must also sort plain .ctor and .dtor sections.
1249   if (!this->script_options_->saw_sections_clause()
1250       && !parameters->options().relocatable()
1251       && (is_prefix_of(".ctors.", name)
1252 	  || is_prefix_of(".dtors.", name)
1253 	  || is_prefix_of(".init_array.", name)
1254 	  || is_prefix_of(".fini_array.", name)
1255 	  || (parameters->options().ctors_in_init_array()
1256 	      && (strcmp(name, ".ctors") == 0
1257 		  || strcmp(name, ".dtors") == 0))))
1258     os->set_must_sort_attached_input_sections();
1259 
1260   // By default the GNU linker sorts some special text sections ahead
1261   // of others.  We are compatible.
1262   if (parameters->options().text_reorder()
1263       && !this->script_options_->saw_sections_clause()
1264       && !this->is_section_ordering_specified()
1265       && !parameters->options().relocatable()
1266       && Layout::special_ordering_of_input_section(name) >= 0)
1267     os->set_must_sort_attached_input_sections();
1268 
1269   // If this is a .ctors or .ctors.* section being mapped to a
1270   // .init_array section, or a .dtors or .dtors.* section being mapped
1271   // to a .fini_array section, we will need to reverse the words if
1272   // there is more than one.  Record this section for later.  See
1273   // ctors_sections_in_init_array above.
1274   if (!this->script_options_->saw_sections_clause()
1275       && !parameters->options().relocatable()
1276       && shdr.get_sh_size() > size / 8
1277       && (((strcmp(name, ".ctors") == 0
1278 	    || is_prefix_of(".ctors.", name))
1279 	   && strcmp(os->name(), ".init_array") == 0)
1280 	  || ((strcmp(name, ".dtors") == 0
1281 	       || is_prefix_of(".dtors.", name))
1282 	      && strcmp(os->name(), ".fini_array") == 0)))
1283     ctors_sections_in_init_array.insert(Section_id(object, shndx));
1284 
1285   // FIXME: Handle SHF_LINK_ORDER somewhere.
1286 
1287   elfcpp::Elf_Xword orig_flags = os->flags();
1288 
1289   *off = os->add_input_section(this, object, shndx, name, shdr, reloc_shndx,
1290 			       this->script_options_->saw_sections_clause());
1291 
1292   // If the flags changed, we may have to change the order.
1293   if ((orig_flags & elfcpp::SHF_ALLOC) != 0)
1294     {
1295       orig_flags &= (elfcpp::SHF_WRITE | elfcpp::SHF_EXECINSTR);
1296       elfcpp::Elf_Xword new_flags =
1297 	os->flags() & (elfcpp::SHF_WRITE | elfcpp::SHF_EXECINSTR);
1298       if (orig_flags != new_flags)
1299 	os->set_order(this->default_section_order(os, false));
1300     }
1301 
1302   this->have_added_input_section_ = true;
1303 
1304   return os;
1305 }
1306 
1307 // Maps section SECN to SEGMENT s.
1308 void
insert_section_segment_map(Const_section_id secn,Unique_segment_info * s)1309 Layout::insert_section_segment_map(Const_section_id secn,
1310 				   Unique_segment_info *s)
1311 {
1312   gold_assert(this->unique_segment_for_sections_specified_);
1313   this->section_segment_map_[secn] = s;
1314 }
1315 
1316 // Handle a relocation section when doing a relocatable link.
1317 
1318 template<int size, bool big_endian>
1319 Output_section*
layout_reloc(Sized_relobj_file<size,big_endian> *,unsigned int,const elfcpp::Shdr<size,big_endian> & shdr,Output_section * data_section,Relocatable_relocs * rr)1320 Layout::layout_reloc(Sized_relobj_file<size, big_endian>*,
1321 		     unsigned int,
1322 		     const elfcpp::Shdr<size, big_endian>& shdr,
1323 		     Output_section* data_section,
1324 		     Relocatable_relocs* rr)
1325 {
1326   gold_assert(parameters->options().relocatable()
1327 	      || parameters->options().emit_relocs());
1328 
1329   int sh_type = shdr.get_sh_type();
1330 
1331   std::string name;
1332   if (sh_type == elfcpp::SHT_REL)
1333     name = ".rel";
1334   else if (sh_type == elfcpp::SHT_RELA)
1335     name = ".rela";
1336   else
1337     gold_unreachable();
1338   name += data_section->name();
1339 
1340   // If the output data section already has a reloc section, use that;
1341   // otherwise, make a new one.
1342   Output_section* os = data_section->reloc_section();
1343   if (os == NULL)
1344     {
1345       const char* n = this->namepool_.add(name.c_str(), true, NULL);
1346       os = this->make_output_section(n, sh_type, shdr.get_sh_flags(),
1347 				     ORDER_INVALID, false);
1348       os->set_should_link_to_symtab();
1349       os->set_info_section(data_section);
1350       data_section->set_reloc_section(os);
1351     }
1352 
1353   Output_section_data* posd;
1354   if (sh_type == elfcpp::SHT_REL)
1355     {
1356       os->set_entsize(elfcpp::Elf_sizes<size>::rel_size);
1357       posd = new Output_relocatable_relocs<elfcpp::SHT_REL,
1358 					   size,
1359 					   big_endian>(rr);
1360     }
1361   else if (sh_type == elfcpp::SHT_RELA)
1362     {
1363       os->set_entsize(elfcpp::Elf_sizes<size>::rela_size);
1364       posd = new Output_relocatable_relocs<elfcpp::SHT_RELA,
1365 					   size,
1366 					   big_endian>(rr);
1367     }
1368   else
1369     gold_unreachable();
1370 
1371   os->add_output_section_data(posd);
1372   rr->set_output_data(posd);
1373 
1374   return os;
1375 }
1376 
1377 // Handle a group section when doing a relocatable link.
1378 
1379 template<int size, bool big_endian>
1380 void
layout_group(Symbol_table * symtab,Sized_relobj_file<size,big_endian> * object,unsigned int,const char * group_section_name,const char * signature,const elfcpp::Shdr<size,big_endian> & shdr,elfcpp::Elf_Word flags,std::vector<unsigned int> * shndxes)1381 Layout::layout_group(Symbol_table* symtab,
1382 		     Sized_relobj_file<size, big_endian>* object,
1383 		     unsigned int,
1384 		     const char* group_section_name,
1385 		     const char* signature,
1386 		     const elfcpp::Shdr<size, big_endian>& shdr,
1387 		     elfcpp::Elf_Word flags,
1388 		     std::vector<unsigned int>* shndxes)
1389 {
1390   gold_assert(parameters->options().relocatable());
1391   gold_assert(shdr.get_sh_type() == elfcpp::SHT_GROUP);
1392   group_section_name = this->namepool_.add(group_section_name, true, NULL);
1393   Output_section* os = this->make_output_section(group_section_name,
1394 						 elfcpp::SHT_GROUP,
1395 						 shdr.get_sh_flags(),
1396 						 ORDER_INVALID, false);
1397 
1398   // We need to find a symbol with the signature in the symbol table.
1399   // If we don't find one now, we need to look again later.
1400   Symbol* sym = symtab->lookup(signature, NULL);
1401   if (sym != NULL)
1402     os->set_info_symndx(sym);
1403   else
1404     {
1405       // Reserve some space to minimize reallocations.
1406       if (this->group_signatures_.empty())
1407 	this->group_signatures_.reserve(this->number_of_input_files_ * 16);
1408 
1409       // We will wind up using a symbol whose name is the signature.
1410       // So just put the signature in the symbol name pool to save it.
1411       signature = symtab->canonicalize_name(signature);
1412       this->group_signatures_.push_back(Group_signature(os, signature));
1413     }
1414 
1415   os->set_should_link_to_symtab();
1416   os->set_entsize(4);
1417 
1418   section_size_type entry_count =
1419     convert_to_section_size_type(shdr.get_sh_size() / 4);
1420   Output_section_data* posd =
1421     new Output_data_group<size, big_endian>(object, entry_count, flags,
1422 					    shndxes);
1423   os->add_output_section_data(posd);
1424 }
1425 
1426 // Special GNU handling of sections name .eh_frame.  They will
1427 // normally hold exception frame data as defined by the C++ ABI
1428 // (http://codesourcery.com/cxx-abi/).
1429 
1430 template<int size, bool big_endian>
1431 Output_section*
layout_eh_frame(Sized_relobj_file<size,big_endian> * object,const unsigned char * symbols,off_t symbols_size,const unsigned char * symbol_names,off_t symbol_names_size,unsigned int shndx,const elfcpp::Shdr<size,big_endian> & shdr,unsigned int reloc_shndx,unsigned int reloc_type,off_t * off)1432 Layout::layout_eh_frame(Sized_relobj_file<size, big_endian>* object,
1433 			const unsigned char* symbols,
1434 			off_t symbols_size,
1435 			const unsigned char* symbol_names,
1436 			off_t symbol_names_size,
1437 			unsigned int shndx,
1438 			const elfcpp::Shdr<size, big_endian>& shdr,
1439 			unsigned int reloc_shndx, unsigned int reloc_type,
1440 			off_t* off)
1441 {
1442   const unsigned int unwind_section_type =
1443       parameters->target().unwind_section_type();
1444 
1445   gold_assert(shdr.get_sh_type() == elfcpp::SHT_PROGBITS
1446 	      || shdr.get_sh_type() == unwind_section_type);
1447   gold_assert((shdr.get_sh_flags() & elfcpp::SHF_ALLOC) != 0);
1448 
1449   Output_section* os = this->make_eh_frame_section(object);
1450   if (os == NULL)
1451     return NULL;
1452 
1453   gold_assert(this->eh_frame_section_ == os);
1454 
1455   elfcpp::Elf_Xword orig_flags = os->flags();
1456 
1457   Eh_frame::Eh_frame_section_disposition disp =
1458       Eh_frame::EH_UNRECOGNIZED_SECTION;
1459   if (!parameters->incremental())
1460     {
1461       disp = this->eh_frame_data_->add_ehframe_input_section(object,
1462 							     symbols,
1463 							     symbols_size,
1464 							     symbol_names,
1465 							     symbol_names_size,
1466 							     shndx,
1467 							     reloc_shndx,
1468 							     reloc_type);
1469     }
1470 
1471   if (disp == Eh_frame::EH_OPTIMIZABLE_SECTION)
1472     {
1473       os->update_flags_for_input_section(shdr.get_sh_flags());
1474 
1475       // A writable .eh_frame section is a RELRO section.
1476       if ((orig_flags & (elfcpp::SHF_WRITE | elfcpp::SHF_EXECINSTR))
1477 	  != (os->flags() & (elfcpp::SHF_WRITE | elfcpp::SHF_EXECINSTR)))
1478 	{
1479 	  os->set_is_relro();
1480 	  os->set_order(ORDER_RELRO);
1481 	}
1482 
1483       *off = -1;
1484       return os;
1485     }
1486 
1487   if (disp == Eh_frame::EH_END_MARKER_SECTION && !this->added_eh_frame_data_)
1488     {
1489       // We found the end marker section, so now we can add the set of
1490       // optimized sections to the output section.  We need to postpone
1491       // adding this until we've found a section we can optimize so that
1492       // the .eh_frame section in crtbeginT.o winds up at the start of
1493       // the output section.
1494       os->add_output_section_data(this->eh_frame_data_);
1495       this->added_eh_frame_data_ = true;
1496      }
1497 
1498   // We couldn't handle this .eh_frame section for some reason.
1499   // Add it as a normal section.
1500   bool saw_sections_clause = this->script_options_->saw_sections_clause();
1501   *off = os->add_input_section(this, object, shndx, ".eh_frame", shdr,
1502 			       reloc_shndx, saw_sections_clause);
1503   this->have_added_input_section_ = true;
1504 
1505   if ((orig_flags & (elfcpp::SHF_WRITE | elfcpp::SHF_EXECINSTR))
1506       != (os->flags() & (elfcpp::SHF_WRITE | elfcpp::SHF_EXECINSTR)))
1507     os->set_order(this->default_section_order(os, false));
1508 
1509   return os;
1510 }
1511 
1512 void
finalize_eh_frame_section()1513 Layout::finalize_eh_frame_section()
1514 {
1515   // If we never found an end marker section, we need to add the
1516   // optimized eh sections to the output section now.
1517   if (!parameters->incremental()
1518       && this->eh_frame_section_ != NULL
1519       && !this->added_eh_frame_data_)
1520     {
1521       this->eh_frame_section_->add_output_section_data(this->eh_frame_data_);
1522       this->added_eh_frame_data_ = true;
1523     }
1524 }
1525 
1526 // Create and return the magic .eh_frame section.  Create
1527 // .eh_frame_hdr also if appropriate.  OBJECT is the object with the
1528 // input .eh_frame section; it may be NULL.
1529 
1530 Output_section*
make_eh_frame_section(const Relobj * object)1531 Layout::make_eh_frame_section(const Relobj* object)
1532 {
1533   const unsigned int unwind_section_type =
1534       parameters->target().unwind_section_type();
1535 
1536   Output_section* os = this->choose_output_section(object, ".eh_frame",
1537 						   unwind_section_type,
1538 						   elfcpp::SHF_ALLOC, false,
1539 						   ORDER_EHFRAME, false, false,
1540 						   false);
1541   if (os == NULL)
1542     return NULL;
1543 
1544   if (this->eh_frame_section_ == NULL)
1545     {
1546       this->eh_frame_section_ = os;
1547       this->eh_frame_data_ = new Eh_frame();
1548 
1549       // For incremental linking, we do not optimize .eh_frame sections
1550       // or create a .eh_frame_hdr section.
1551       if (parameters->options().eh_frame_hdr() && !parameters->incremental())
1552 	{
1553 	  Output_section* hdr_os =
1554 	    this->choose_output_section(NULL, ".eh_frame_hdr",
1555 					unwind_section_type,
1556 					elfcpp::SHF_ALLOC, false,
1557 					ORDER_EHFRAME, false, false,
1558 					false);
1559 
1560 	  if (hdr_os != NULL)
1561 	    {
1562 	      Eh_frame_hdr* hdr_posd = new Eh_frame_hdr(os,
1563 							this->eh_frame_data_);
1564 	      hdr_os->add_output_section_data(hdr_posd);
1565 
1566 	      hdr_os->set_after_input_sections();
1567 
1568 	      if (!this->script_options_->saw_phdrs_clause())
1569 		{
1570 		  Output_segment* hdr_oseg;
1571 		  hdr_oseg = this->make_output_segment(elfcpp::PT_GNU_EH_FRAME,
1572 						       elfcpp::PF_R);
1573 		  hdr_oseg->add_output_section_to_nonload(hdr_os,
1574 							  elfcpp::PF_R);
1575 		}
1576 
1577 	      this->eh_frame_data_->set_eh_frame_hdr(hdr_posd);
1578 	    }
1579 	}
1580     }
1581 
1582   return os;
1583 }
1584 
1585 // Add an exception frame for a PLT.  This is called from target code.
1586 
1587 void
add_eh_frame_for_plt(Output_data * plt,const unsigned char * cie_data,size_t cie_length,const unsigned char * fde_data,size_t fde_length)1588 Layout::add_eh_frame_for_plt(Output_data* plt, const unsigned char* cie_data,
1589 			     size_t cie_length, const unsigned char* fde_data,
1590 			     size_t fde_length)
1591 {
1592   if (parameters->incremental())
1593     {
1594       // FIXME: Maybe this could work some day....
1595       return;
1596     }
1597   Output_section* os = this->make_eh_frame_section(NULL);
1598   if (os == NULL)
1599     return;
1600   this->eh_frame_data_->add_ehframe_for_plt(plt, cie_data, cie_length,
1601 					    fde_data, fde_length);
1602   if (!this->added_eh_frame_data_)
1603     {
1604       os->add_output_section_data(this->eh_frame_data_);
1605       this->added_eh_frame_data_ = true;
1606     }
1607 }
1608 
1609 // Remove all post-map .eh_frame information for a PLT.
1610 
1611 void
remove_eh_frame_for_plt(Output_data * plt,const unsigned char * cie_data,size_t cie_length)1612 Layout::remove_eh_frame_for_plt(Output_data* plt, const unsigned char* cie_data,
1613 				size_t cie_length)
1614 {
1615   if (parameters->incremental())
1616     {
1617       // FIXME: Maybe this could work some day....
1618       return;
1619     }
1620   this->eh_frame_data_->remove_ehframe_for_plt(plt, cie_data, cie_length);
1621 }
1622 
1623 // Scan a .debug_info or .debug_types section, and add summary
1624 // information to the .gdb_index section.
1625 
1626 template<int size, bool big_endian>
1627 void
add_to_gdb_index(bool is_type_unit,Sized_relobj<size,big_endian> * object,const unsigned char * symbols,off_t symbols_size,unsigned int shndx,unsigned int reloc_shndx,unsigned int reloc_type)1628 Layout::add_to_gdb_index(bool is_type_unit,
1629 			 Sized_relobj<size, big_endian>* object,
1630 			 const unsigned char* symbols,
1631 			 off_t symbols_size,
1632 			 unsigned int shndx,
1633 			 unsigned int reloc_shndx,
1634 			 unsigned int reloc_type)
1635 {
1636   if (this->gdb_index_data_ == NULL)
1637     {
1638       Output_section* os = this->choose_output_section(NULL, ".gdb_index",
1639 						       elfcpp::SHT_PROGBITS, 0,
1640 						       false, ORDER_INVALID,
1641 						       false, false, false);
1642       if (os == NULL)
1643 	return;
1644 
1645       this->gdb_index_data_ = new Gdb_index(os);
1646       os->add_output_section_data(this->gdb_index_data_);
1647       os->set_after_input_sections();
1648     }
1649 
1650   this->gdb_index_data_->scan_debug_info(is_type_unit, object, symbols,
1651 					 symbols_size, shndx, reloc_shndx,
1652 					 reloc_type);
1653 }
1654 
1655 // Add POSD to an output section using NAME, TYPE, and FLAGS.  Return
1656 // the output section.
1657 
1658 Output_section*
add_output_section_data(const char * name,elfcpp::Elf_Word type,elfcpp::Elf_Xword flags,Output_section_data * posd,Output_section_order order,bool is_relro)1659 Layout::add_output_section_data(const char* name, elfcpp::Elf_Word type,
1660 				elfcpp::Elf_Xword flags,
1661 				Output_section_data* posd,
1662 				Output_section_order order, bool is_relro)
1663 {
1664   Output_section* os = this->choose_output_section(NULL, name, type, flags,
1665 						   false, order, is_relro,
1666 						   false, false);
1667   if (os != NULL)
1668     os->add_output_section_data(posd);
1669   return os;
1670 }
1671 
1672 // Map section flags to segment flags.
1673 
1674 elfcpp::Elf_Word
section_flags_to_segment(elfcpp::Elf_Xword flags)1675 Layout::section_flags_to_segment(elfcpp::Elf_Xword flags)
1676 {
1677   elfcpp::Elf_Word ret = elfcpp::PF_R;
1678   if ((flags & elfcpp::SHF_WRITE) != 0)
1679     ret |= elfcpp::PF_W;
1680   if ((flags & elfcpp::SHF_EXECINSTR) != 0)
1681     ret |= elfcpp::PF_X;
1682   return ret;
1683 }
1684 
1685 // Make a new Output_section, and attach it to segments as
1686 // appropriate.  ORDER is the order in which this section should
1687 // appear in the output segment.  IS_RELRO is true if this is a relro
1688 // (read-only after relocations) section.
1689 
1690 Output_section*
make_output_section(const char * name,elfcpp::Elf_Word type,elfcpp::Elf_Xword flags,Output_section_order order,bool is_relro)1691 Layout::make_output_section(const char* name, elfcpp::Elf_Word type,
1692 			    elfcpp::Elf_Xword flags,
1693 			    Output_section_order order, bool is_relro)
1694 {
1695   Output_section* os;
1696   if ((flags & elfcpp::SHF_ALLOC) == 0
1697       && strcmp(parameters->options().compress_debug_sections(), "none") != 0
1698       && is_compressible_debug_section(name))
1699     os = new Output_compressed_section(&parameters->options(), name, type,
1700 				       flags);
1701   else if ((flags & elfcpp::SHF_ALLOC) == 0
1702 	   && parameters->options().strip_debug_non_line()
1703 	   && strcmp(".debug_abbrev", name) == 0)
1704     {
1705       os = this->debug_abbrev_ = new Output_reduced_debug_abbrev_section(
1706 	  name, type, flags);
1707       if (this->debug_info_)
1708 	this->debug_info_->set_abbreviations(this->debug_abbrev_);
1709     }
1710   else if ((flags & elfcpp::SHF_ALLOC) == 0
1711 	   && parameters->options().strip_debug_non_line()
1712 	   && strcmp(".debug_info", name) == 0)
1713     {
1714       os = this->debug_info_ = new Output_reduced_debug_info_section(
1715 	  name, type, flags);
1716       if (this->debug_abbrev_)
1717 	this->debug_info_->set_abbreviations(this->debug_abbrev_);
1718     }
1719   else
1720     {
1721       // Sometimes .init_array*, .preinit_array* and .fini_array* do
1722       // not have correct section types.  Force them here.
1723       if (type == elfcpp::SHT_PROGBITS)
1724 	{
1725 	  if (is_prefix_of(".init_array", name))
1726 	    type = elfcpp::SHT_INIT_ARRAY;
1727 	  else if (is_prefix_of(".preinit_array", name))
1728 	    type = elfcpp::SHT_PREINIT_ARRAY;
1729 	  else if (is_prefix_of(".fini_array", name))
1730 	    type = elfcpp::SHT_FINI_ARRAY;
1731 	}
1732 
1733       // FIXME: const_cast is ugly.
1734       Target* target = const_cast<Target*>(&parameters->target());
1735       os = target->make_output_section(name, type, flags);
1736     }
1737 
1738   // With -z relro, we have to recognize the special sections by name.
1739   // There is no other way.
1740   bool is_relro_local = false;
1741   if (!this->script_options_->saw_sections_clause()
1742       && parameters->options().relro()
1743       && (flags & elfcpp::SHF_ALLOC) != 0
1744       && (flags & elfcpp::SHF_WRITE) != 0)
1745     {
1746       if (type == elfcpp::SHT_PROGBITS)
1747 	{
1748 	  if ((flags & elfcpp::SHF_TLS) != 0)
1749 	    is_relro = true;
1750 	  else if (strcmp(name, ".data.rel.ro") == 0)
1751 	    is_relro = true;
1752 	  else if (strcmp(name, ".data.rel.ro.local") == 0)
1753 	    {
1754 	      is_relro = true;
1755 	      is_relro_local = true;
1756 	    }
1757 	  else if (strcmp(name, ".ctors") == 0
1758 		   || strcmp(name, ".dtors") == 0
1759 		   || strcmp(name, ".jcr") == 0)
1760 	    is_relro = true;
1761 	}
1762       else if (type == elfcpp::SHT_INIT_ARRAY
1763 	       || type == elfcpp::SHT_FINI_ARRAY
1764 	       || type == elfcpp::SHT_PREINIT_ARRAY)
1765 	is_relro = true;
1766     }
1767 
1768   if (is_relro)
1769     os->set_is_relro();
1770 
1771   if (order == ORDER_INVALID && (flags & elfcpp::SHF_ALLOC) != 0)
1772     order = this->default_section_order(os, is_relro_local);
1773 
1774   os->set_order(order);
1775 
1776   parameters->target().new_output_section(os);
1777 
1778   this->section_list_.push_back(os);
1779 
1780   // The GNU linker by default sorts some sections by priority, so we
1781   // do the same.  We need to know that this might happen before we
1782   // attach any input sections.
1783   if (!this->script_options_->saw_sections_clause()
1784       && !parameters->options().relocatable()
1785       && (strcmp(name, ".init_array") == 0
1786 	  || strcmp(name, ".fini_array") == 0
1787 	  || (!parameters->options().ctors_in_init_array()
1788 	      && (strcmp(name, ".ctors") == 0
1789 		  || strcmp(name, ".dtors") == 0))))
1790     os->set_may_sort_attached_input_sections();
1791 
1792   // The GNU linker by default sorts .text.{unlikely,exit,startup,hot}
1793   // sections before other .text sections.  We are compatible.  We
1794   // need to know that this might happen before we attach any input
1795   // sections.
1796   if (parameters->options().text_reorder()
1797       && !this->script_options_->saw_sections_clause()
1798       && !this->is_section_ordering_specified()
1799       && !parameters->options().relocatable()
1800       && strcmp(name, ".text") == 0)
1801     os->set_may_sort_attached_input_sections();
1802 
1803   // GNU linker sorts section by name with --sort-section=name.
1804   if (strcmp(parameters->options().sort_section(), "name") == 0)
1805       os->set_must_sort_attached_input_sections();
1806 
1807   // Check for .stab*str sections, as .stab* sections need to link to
1808   // them.
1809   if (type == elfcpp::SHT_STRTAB
1810       && !this->have_stabstr_section_
1811       && strncmp(name, ".stab", 5) == 0
1812       && strcmp(name + strlen(name) - 3, "str") == 0)
1813     this->have_stabstr_section_ = true;
1814 
1815   // During a full incremental link, we add patch space to most
1816   // PROGBITS and NOBITS sections.  Flag those that may be
1817   // arbitrarily padded.
1818   if ((type == elfcpp::SHT_PROGBITS || type == elfcpp::SHT_NOBITS)
1819       && order != ORDER_INTERP
1820       && order != ORDER_INIT
1821       && order != ORDER_PLT
1822       && order != ORDER_FINI
1823       && order != ORDER_RELRO_LAST
1824       && order != ORDER_NON_RELRO_FIRST
1825       && strcmp(name, ".eh_frame") != 0
1826       && strcmp(name, ".ctors") != 0
1827       && strcmp(name, ".dtors") != 0
1828       && strcmp(name, ".jcr") != 0)
1829     {
1830       os->set_is_patch_space_allowed();
1831 
1832       // Certain sections require "holes" to be filled with
1833       // specific fill patterns.  These fill patterns may have
1834       // a minimum size, so we must prevent allocations from the
1835       // free list that leave a hole smaller than the minimum.
1836       if (strcmp(name, ".debug_info") == 0)
1837 	os->set_free_space_fill(new Output_fill_debug_info(false));
1838       else if (strcmp(name, ".debug_types") == 0)
1839 	os->set_free_space_fill(new Output_fill_debug_info(true));
1840       else if (strcmp(name, ".debug_line") == 0)
1841 	os->set_free_space_fill(new Output_fill_debug_line());
1842     }
1843 
1844   // If we have already attached the sections to segments, then we
1845   // need to attach this one now.  This happens for sections created
1846   // directly by the linker.
1847   if (this->sections_are_attached_)
1848     this->attach_section_to_segment(&parameters->target(), os);
1849 
1850   return os;
1851 }
1852 
1853 // Return the default order in which a section should be placed in an
1854 // output segment.  This function captures a lot of the ideas in
1855 // ld/scripttempl/elf.sc in the GNU linker.  Note that the order of a
1856 // linker created section is normally set when the section is created;
1857 // this function is used for input sections.
1858 
1859 Output_section_order
default_section_order(Output_section * os,bool is_relro_local)1860 Layout::default_section_order(Output_section* os, bool is_relro_local)
1861 {
1862   gold_assert((os->flags() & elfcpp::SHF_ALLOC) != 0);
1863   bool is_write = (os->flags() & elfcpp::SHF_WRITE) != 0;
1864   bool is_execinstr = (os->flags() & elfcpp::SHF_EXECINSTR) != 0;
1865   bool is_bss = false;
1866 
1867   switch (os->type())
1868     {
1869     default:
1870     case elfcpp::SHT_PROGBITS:
1871       break;
1872     case elfcpp::SHT_NOBITS:
1873       is_bss = true;
1874       break;
1875     case elfcpp::SHT_RELA:
1876     case elfcpp::SHT_REL:
1877       if (!is_write)
1878 	return ORDER_DYNAMIC_RELOCS;
1879       break;
1880     case elfcpp::SHT_HASH:
1881     case elfcpp::SHT_DYNAMIC:
1882     case elfcpp::SHT_SHLIB:
1883     case elfcpp::SHT_DYNSYM:
1884     case elfcpp::SHT_GNU_HASH:
1885     case elfcpp::SHT_GNU_verdef:
1886     case elfcpp::SHT_GNU_verneed:
1887     case elfcpp::SHT_GNU_versym:
1888       if (!is_write)
1889 	return ORDER_DYNAMIC_LINKER;
1890       break;
1891     case elfcpp::SHT_NOTE:
1892       return is_write ? ORDER_RW_NOTE : ORDER_RO_NOTE;
1893     }
1894 
1895   if ((os->flags() & elfcpp::SHF_TLS) != 0)
1896     return is_bss ? ORDER_TLS_BSS : ORDER_TLS_DATA;
1897 
1898   if (!is_bss && !is_write)
1899     {
1900       if (is_execinstr)
1901 	{
1902 	  if (strcmp(os->name(), ".init") == 0)
1903 	    return ORDER_INIT;
1904 	  else if (strcmp(os->name(), ".fini") == 0)
1905 	    return ORDER_FINI;
1906 	  else if (parameters->options().keep_text_section_prefix())
1907 	    {
1908 	      // -z,keep-text-section-prefix introduces additional
1909 	      // output sections.
1910 	      if (strcmp(os->name(), ".text.hot") == 0)
1911 		return ORDER_TEXT_HOT;
1912 	      else if (strcmp(os->name(), ".text.startup") == 0)
1913 		return ORDER_TEXT_STARTUP;
1914 	      else if (strcmp(os->name(), ".text.exit") == 0)
1915 		return ORDER_TEXT_EXIT;
1916 	      else if (strcmp(os->name(), ".text.unlikely") == 0)
1917 		return ORDER_TEXT_UNLIKELY;
1918 	    }
1919 	}
1920       return is_execinstr ? ORDER_TEXT : ORDER_READONLY;
1921     }
1922 
1923   if (os->is_relro())
1924     return is_relro_local ? ORDER_RELRO_LOCAL : ORDER_RELRO;
1925 
1926   if (os->is_small_section())
1927     return is_bss ? ORDER_SMALL_BSS : ORDER_SMALL_DATA;
1928   if (os->is_large_section())
1929     return is_bss ? ORDER_LARGE_BSS : ORDER_LARGE_DATA;
1930 
1931   return is_bss ? ORDER_BSS : ORDER_DATA;
1932 }
1933 
1934 // Attach output sections to segments.  This is called after we have
1935 // seen all the input sections.
1936 
1937 void
attach_sections_to_segments(const Target * target)1938 Layout::attach_sections_to_segments(const Target* target)
1939 {
1940   for (Section_list::iterator p = this->section_list_.begin();
1941        p != this->section_list_.end();
1942        ++p)
1943     this->attach_section_to_segment(target, *p);
1944 
1945   this->sections_are_attached_ = true;
1946 }
1947 
1948 // Attach an output section to a segment.
1949 
1950 void
attach_section_to_segment(const Target * target,Output_section * os)1951 Layout::attach_section_to_segment(const Target* target, Output_section* os)
1952 {
1953   if ((os->flags() & elfcpp::SHF_ALLOC) == 0)
1954     this->unattached_section_list_.push_back(os);
1955   else
1956     this->attach_allocated_section_to_segment(target, os);
1957 }
1958 
1959 // Attach an allocated output section to a segment.
1960 
1961 void
attach_allocated_section_to_segment(const Target * target,Output_section * os)1962 Layout::attach_allocated_section_to_segment(const Target* target,
1963 					    Output_section* os)
1964 {
1965   elfcpp::Elf_Xword flags = os->flags();
1966   gold_assert((flags & elfcpp::SHF_ALLOC) != 0);
1967 
1968   if (parameters->options().relocatable())
1969     return;
1970 
1971   // If we have a SECTIONS clause, we can't handle the attachment to
1972   // segments until after we've seen all the sections.
1973   if (this->script_options_->saw_sections_clause())
1974     return;
1975 
1976   gold_assert(!this->script_options_->saw_phdrs_clause());
1977 
1978   // This output section goes into a PT_LOAD segment.
1979 
1980   elfcpp::Elf_Word seg_flags = Layout::section_flags_to_segment(flags);
1981 
1982   // If this output section's segment has extra flags that need to be set,
1983   // coming from a linker plugin, do that.
1984   seg_flags |= os->extra_segment_flags();
1985 
1986   // Check for --section-start.
1987   uint64_t addr;
1988   bool is_address_set = parameters->options().section_start(os->name(), &addr);
1989 
1990   // In general the only thing we really care about for PT_LOAD
1991   // segments is whether or not they are writable or executable,
1992   // so that is how we search for them.
1993   // Large data sections also go into their own PT_LOAD segment.
1994   // People who need segments sorted on some other basis will
1995   // have to use a linker script.
1996 
1997   Segment_list::const_iterator p;
1998   if (!os->is_unique_segment())
1999     {
2000       for (p = this->segment_list_.begin();
2001 	   p != this->segment_list_.end();
2002 	   ++p)
2003 	{
2004 	  if ((*p)->type() != elfcpp::PT_LOAD)
2005 	    continue;
2006 	  if ((*p)->is_unique_segment())
2007 	    continue;
2008 	  if (!parameters->options().omagic()
2009 	      && ((*p)->flags() & elfcpp::PF_W) != (seg_flags & elfcpp::PF_W))
2010 	    continue;
2011 	  if ((target->isolate_execinstr() || parameters->options().rosegment())
2012 	      && ((*p)->flags() & elfcpp::PF_X) != (seg_flags & elfcpp::PF_X))
2013 	    continue;
2014 	  // If -Tbss was specified, we need to separate the data and BSS
2015 	  // segments.
2016 	  if (parameters->options().user_set_Tbss())
2017 	    {
2018 	      if ((os->type() == elfcpp::SHT_NOBITS)
2019 		  == (*p)->has_any_data_sections())
2020 		continue;
2021 	    }
2022 	  if (os->is_large_data_section() && !(*p)->is_large_data_segment())
2023 	    continue;
2024 
2025 	  if (is_address_set)
2026 	    {
2027 	      if ((*p)->are_addresses_set())
2028 		continue;
2029 
2030 	      (*p)->add_initial_output_data(os);
2031 	      (*p)->update_flags_for_output_section(seg_flags);
2032 	      (*p)->set_addresses(addr, addr);
2033 	      break;
2034 	    }
2035 
2036 	  (*p)->add_output_section_to_load(this, os, seg_flags);
2037 	  break;
2038 	}
2039     }
2040 
2041   if (p == this->segment_list_.end()
2042       || os->is_unique_segment())
2043     {
2044       Output_segment* oseg = this->make_output_segment(elfcpp::PT_LOAD,
2045 						       seg_flags);
2046       if (os->is_large_data_section())
2047 	oseg->set_is_large_data_segment();
2048       oseg->add_output_section_to_load(this, os, seg_flags);
2049       if (is_address_set)
2050 	oseg->set_addresses(addr, addr);
2051       // Check if segment should be marked unique.  For segments marked
2052       // unique by linker plugins, set the new alignment if specified.
2053       if (os->is_unique_segment())
2054 	{
2055 	  oseg->set_is_unique_segment();
2056 	  if (os->segment_alignment() != 0)
2057 	    oseg->set_minimum_p_align(os->segment_alignment());
2058 	}
2059     }
2060 
2061   // If we see a loadable SHT_NOTE section, we create a PT_NOTE
2062   // segment.
2063   if (os->type() == elfcpp::SHT_NOTE)
2064     {
2065       // See if we already have an equivalent PT_NOTE segment.
2066       for (p = this->segment_list_.begin();
2067 	   p != segment_list_.end();
2068 	   ++p)
2069 	{
2070 	  if ((*p)->type() == elfcpp::PT_NOTE
2071 	      && (((*p)->flags() & elfcpp::PF_W)
2072 		  == (seg_flags & elfcpp::PF_W)))
2073 	    {
2074 	      (*p)->add_output_section_to_nonload(os, seg_flags);
2075 	      break;
2076 	    }
2077 	}
2078 
2079       if (p == this->segment_list_.end())
2080 	{
2081 	  Output_segment* oseg = this->make_output_segment(elfcpp::PT_NOTE,
2082 							   seg_flags);
2083 	  oseg->add_output_section_to_nonload(os, seg_flags);
2084 	}
2085     }
2086 
2087   // If we see a loadable SHF_TLS section, we create a PT_TLS
2088   // segment.  There can only be one such segment.
2089   if ((flags & elfcpp::SHF_TLS) != 0)
2090     {
2091       if (this->tls_segment_ == NULL)
2092 	this->make_output_segment(elfcpp::PT_TLS, seg_flags);
2093       this->tls_segment_->add_output_section_to_nonload(os, seg_flags);
2094     }
2095 
2096   // If -z relro is in effect, and we see a relro section, we create a
2097   // PT_GNU_RELRO segment.  There can only be one such segment.
2098   if (os->is_relro() && parameters->options().relro())
2099     {
2100       gold_assert(seg_flags == (elfcpp::PF_R | elfcpp::PF_W));
2101       if (this->relro_segment_ == NULL)
2102 	this->make_output_segment(elfcpp::PT_GNU_RELRO, seg_flags);
2103       this->relro_segment_->add_output_section_to_nonload(os, seg_flags);
2104     }
2105 
2106   // If we see a section named .interp, put it into a PT_INTERP
2107   // segment.  This seems broken to me, but this is what GNU ld does,
2108   // and glibc expects it.
2109   if (strcmp(os->name(), ".interp") == 0
2110       && !this->script_options_->saw_phdrs_clause())
2111     {
2112       if (this->interp_segment_ == NULL)
2113 	this->make_output_segment(elfcpp::PT_INTERP, seg_flags);
2114       else
2115 	gold_warning(_("multiple '.interp' sections in input files "
2116 		       "may cause confusing PT_INTERP segment"));
2117       this->interp_segment_->add_output_section_to_nonload(os, seg_flags);
2118     }
2119 }
2120 
2121 // Make an output section for a script.
2122 
2123 Output_section*
make_output_section_for_script(const char * name,Script_sections::Section_type section_type)2124 Layout::make_output_section_for_script(
2125     const char* name,
2126     Script_sections::Section_type section_type)
2127 {
2128   name = this->namepool_.add(name, false, NULL);
2129   elfcpp::Elf_Xword sh_flags = elfcpp::SHF_ALLOC;
2130   if (section_type == Script_sections::ST_NOLOAD)
2131     sh_flags = 0;
2132   Output_section* os = this->make_output_section(name, elfcpp::SHT_PROGBITS,
2133 						 sh_flags, ORDER_INVALID,
2134 						 false);
2135   os->set_found_in_sections_clause();
2136   if (section_type == Script_sections::ST_NOLOAD)
2137     os->set_is_noload();
2138   return os;
2139 }
2140 
2141 // Return the number of segments we expect to see.
2142 
2143 size_t
expected_segment_count() const2144 Layout::expected_segment_count() const
2145 {
2146   size_t ret = this->segment_list_.size();
2147 
2148   // If we didn't see a SECTIONS clause in a linker script, we should
2149   // already have the complete list of segments.  Otherwise we ask the
2150   // SECTIONS clause how many segments it expects, and add in the ones
2151   // we already have (PT_GNU_STACK, PT_GNU_EH_FRAME, etc.)
2152 
2153   if (!this->script_options_->saw_sections_clause())
2154     return ret;
2155   else
2156     {
2157       const Script_sections* ss = this->script_options_->script_sections();
2158       return ret + ss->expected_segment_count(this);
2159     }
2160 }
2161 
2162 // Handle the .note.GNU-stack section at layout time.  SEEN_GNU_STACK
2163 // is whether we saw a .note.GNU-stack section in the object file.
2164 // GNU_STACK_FLAGS is the section flags.  The flags give the
2165 // protection required for stack memory.  We record this in an
2166 // executable as a PT_GNU_STACK segment.  If an object file does not
2167 // have a .note.GNU-stack segment, we must assume that it is an old
2168 // object.  On some targets that will force an executable stack.
2169 
2170 void
layout_gnu_stack(bool seen_gnu_stack,uint64_t gnu_stack_flags,const Object * obj)2171 Layout::layout_gnu_stack(bool seen_gnu_stack, uint64_t gnu_stack_flags,
2172 			 const Object* obj)
2173 {
2174   if (!seen_gnu_stack)
2175     {
2176       this->input_without_gnu_stack_note_ = true;
2177       if (parameters->options().warn_execstack()
2178 	  && parameters->target().is_default_stack_executable())
2179 	gold_warning(_("%s: missing .note.GNU-stack section"
2180 		       " implies executable stack"),
2181 		     obj->name().c_str());
2182     }
2183   else
2184     {
2185       this->input_with_gnu_stack_note_ = true;
2186       if ((gnu_stack_flags & elfcpp::SHF_EXECINSTR) != 0)
2187 	{
2188 	  this->input_requires_executable_stack_ = true;
2189 	  if (parameters->options().warn_execstack())
2190 	    gold_warning(_("%s: requires executable stack"),
2191 			 obj->name().c_str());
2192 	}
2193     }
2194 }
2195 
2196 // Read a value with given size and endianness.
2197 
2198 static inline uint64_t
read_sized_value(size_t size,const unsigned char * buf,bool is_big_endian,const Object * object)2199 read_sized_value(size_t size, const unsigned char* buf, bool is_big_endian,
2200 		 const Object* object)
2201 {
2202   uint64_t val = 0;
2203   if (size == 4)
2204     {
2205       if (is_big_endian)
2206 	val = elfcpp::Swap<32, true>::readval(buf);
2207       else
2208 	val = elfcpp::Swap<32, false>::readval(buf);
2209     }
2210   else if (size == 8)
2211     {
2212       if (is_big_endian)
2213 	val = elfcpp::Swap<64, true>::readval(buf);
2214       else
2215 	val = elfcpp::Swap<64, false>::readval(buf);
2216     }
2217   else
2218     {
2219       gold_warning(_("%s: in .note.gnu.property section, "
2220 		     "pr_datasz must be 4 or 8"),
2221 		   object->name().c_str());
2222     }
2223   return val;
2224 }
2225 
2226 // Write a value with given size and endianness.
2227 
2228 static inline void
write_sized_value(uint64_t value,size_t size,unsigned char * buf,bool is_big_endian)2229 write_sized_value(uint64_t value, size_t size, unsigned char* buf,
2230 		  bool is_big_endian)
2231 {
2232   if (size == 4)
2233     {
2234       if (is_big_endian)
2235 	elfcpp::Swap<32, true>::writeval(buf, static_cast<uint32_t>(value));
2236       else
2237 	elfcpp::Swap<32, false>::writeval(buf, static_cast<uint32_t>(value));
2238     }
2239   else if (size == 8)
2240     {
2241       if (is_big_endian)
2242 	elfcpp::Swap<64, true>::writeval(buf, value);
2243       else
2244 	elfcpp::Swap<64, false>::writeval(buf, value);
2245     }
2246   else
2247     {
2248       // We will have already complained about this.
2249     }
2250 }
2251 
2252 // Handle the .note.gnu.property section at layout time.
2253 
2254 void
layout_gnu_property(unsigned int note_type,unsigned int pr_type,size_t pr_datasz,const unsigned char * pr_data,const Object * object)2255 Layout::layout_gnu_property(unsigned int note_type,
2256 			    unsigned int pr_type,
2257 			    size_t pr_datasz,
2258 			    const unsigned char* pr_data,
2259 			    const Object* object)
2260 {
2261   // We currently support only the one note type.
2262   gold_assert(note_type == elfcpp::NT_GNU_PROPERTY_TYPE_0);
2263 
2264   if (pr_type >= elfcpp::GNU_PROPERTY_LOPROC
2265       && pr_type < elfcpp::GNU_PROPERTY_HIPROC)
2266     {
2267       // Target-dependent property value; call the target to record.
2268       const int size = parameters->target().get_size();
2269       const bool is_big_endian = parameters->target().is_big_endian();
2270       if (size == 32)
2271         {
2272           if (is_big_endian)
2273             {
2274 #ifdef HAVE_TARGET_32_BIG
2275 	      parameters->sized_target<32, true>()->
2276 		  record_gnu_property(note_type, pr_type, pr_datasz, pr_data,
2277 				      object);
2278 #else
2279 	      gold_unreachable();
2280 #endif
2281             }
2282           else
2283             {
2284 #ifdef HAVE_TARGET_32_LITTLE
2285 	      parameters->sized_target<32, false>()->
2286 		  record_gnu_property(note_type, pr_type, pr_datasz, pr_data,
2287 				      object);
2288 #else
2289 	      gold_unreachable();
2290 #endif
2291             }
2292         }
2293       else if (size == 64)
2294         {
2295           if (is_big_endian)
2296             {
2297 #ifdef HAVE_TARGET_64_BIG
2298 	      parameters->sized_target<64, true>()->
2299 		  record_gnu_property(note_type, pr_type, pr_datasz, pr_data,
2300 				      object);
2301 #else
2302 	      gold_unreachable();
2303 #endif
2304             }
2305           else
2306             {
2307 #ifdef HAVE_TARGET_64_LITTLE
2308 	      parameters->sized_target<64, false>()->
2309 		  record_gnu_property(note_type, pr_type, pr_datasz, pr_data,
2310 				      object);
2311 #else
2312 	      gold_unreachable();
2313 #endif
2314             }
2315         }
2316       else
2317         gold_unreachable();
2318       return;
2319     }
2320 
2321   Gnu_properties::iterator pprop = this->gnu_properties_.find(pr_type);
2322   if (pprop == this->gnu_properties_.end())
2323     {
2324       Gnu_property prop;
2325       prop.pr_datasz = pr_datasz;
2326       prop.pr_data = new unsigned char[pr_datasz];
2327       memcpy(prop.pr_data, pr_data, pr_datasz);
2328       this->gnu_properties_[pr_type] = prop;
2329     }
2330   else
2331     {
2332       const bool is_big_endian = parameters->target().is_big_endian();
2333       switch (pr_type)
2334 	{
2335 	case elfcpp::GNU_PROPERTY_STACK_SIZE:
2336 	  // Record the maximum value seen.
2337 	  {
2338 	    uint64_t val1 = read_sized_value(pprop->second.pr_datasz,
2339 					     pprop->second.pr_data,
2340 					     is_big_endian, object);
2341 	    uint64_t val2 = read_sized_value(pr_datasz, pr_data,
2342 					     is_big_endian, object);
2343 	    if (val2 > val1)
2344 	      write_sized_value(val2, pprop->second.pr_datasz,
2345 				pprop->second.pr_data, is_big_endian);
2346 	  }
2347 	  break;
2348 	case elfcpp::GNU_PROPERTY_NO_COPY_ON_PROTECTED:
2349 	  // No data to merge.
2350 	  break;
2351 	default:
2352 	  gold_warning(_("%s: unknown program property type %d "
2353 			 "in .note.gnu.property section"),
2354 		       object->name().c_str(), pr_type);
2355 	}
2356     }
2357 }
2358 
2359 // Merge per-object properties with program properties.
2360 // This lets the target identify objects that are missing certain
2361 // properties, in cases where properties must be ANDed together.
2362 
2363 void
merge_gnu_properties(const Object * object)2364 Layout::merge_gnu_properties(const Object* object)
2365 {
2366   const int size = parameters->target().get_size();
2367   const bool is_big_endian = parameters->target().is_big_endian();
2368   if (size == 32)
2369     {
2370       if (is_big_endian)
2371 	{
2372 #ifdef HAVE_TARGET_32_BIG
2373 	  parameters->sized_target<32, true>()->merge_gnu_properties(object);
2374 #else
2375 	  gold_unreachable();
2376 #endif
2377 	}
2378       else
2379 	{
2380 #ifdef HAVE_TARGET_32_LITTLE
2381 	  parameters->sized_target<32, false>()->merge_gnu_properties(object);
2382 #else
2383 	  gold_unreachable();
2384 #endif
2385 	}
2386     }
2387   else if (size == 64)
2388     {
2389       if (is_big_endian)
2390 	{
2391 #ifdef HAVE_TARGET_64_BIG
2392 	  parameters->sized_target<64, true>()->merge_gnu_properties(object);
2393 #else
2394 	  gold_unreachable();
2395 #endif
2396 	}
2397       else
2398 	{
2399 #ifdef HAVE_TARGET_64_LITTLE
2400 	  parameters->sized_target<64, false>()->merge_gnu_properties(object);
2401 #else
2402 	  gold_unreachable();
2403 #endif
2404 	}
2405     }
2406   else
2407     gold_unreachable();
2408 }
2409 
2410 // Add a target-specific property for the output .note.gnu.property section.
2411 
2412 void
add_gnu_property(unsigned int note_type,unsigned int pr_type,size_t pr_datasz,const unsigned char * pr_data)2413 Layout::add_gnu_property(unsigned int note_type,
2414 			 unsigned int pr_type,
2415 			 size_t pr_datasz,
2416 			 const unsigned char* pr_data)
2417 {
2418   gold_assert(note_type == elfcpp::NT_GNU_PROPERTY_TYPE_0);
2419 
2420   Gnu_property prop;
2421   prop.pr_datasz = pr_datasz;
2422   prop.pr_data = new unsigned char[pr_datasz];
2423   memcpy(prop.pr_data, pr_data, pr_datasz);
2424   this->gnu_properties_[pr_type] = prop;
2425 }
2426 
2427 // Create automatic note sections.
2428 
2429 void
create_notes()2430 Layout::create_notes()
2431 {
2432   this->create_gnu_properties_note();
2433   this->create_gold_note();
2434   this->create_stack_segment();
2435   this->create_build_id();
2436 }
2437 
2438 // Create the dynamic sections which are needed before we read the
2439 // relocs.
2440 
2441 void
create_initial_dynamic_sections(Symbol_table * symtab)2442 Layout::create_initial_dynamic_sections(Symbol_table* symtab)
2443 {
2444   if (parameters->doing_static_link())
2445     return;
2446 
2447   this->dynamic_section_ = this->choose_output_section(NULL, ".dynamic",
2448 						       elfcpp::SHT_DYNAMIC,
2449 						       (elfcpp::SHF_ALLOC
2450 							| elfcpp::SHF_WRITE),
2451 						       false, ORDER_RELRO,
2452 						       true, false, false);
2453 
2454   // A linker script may discard .dynamic, so check for NULL.
2455   if (this->dynamic_section_ != NULL)
2456     {
2457       this->dynamic_symbol_ =
2458 	symtab->define_in_output_data("_DYNAMIC", NULL,
2459 				      Symbol_table::PREDEFINED,
2460 				      this->dynamic_section_, 0, 0,
2461 				      elfcpp::STT_OBJECT, elfcpp::STB_LOCAL,
2462 				      elfcpp::STV_HIDDEN, 0, false, false);
2463 
2464       this->dynamic_data_ =  new Output_data_dynamic(&this->dynpool_);
2465 
2466       this->dynamic_section_->add_output_section_data(this->dynamic_data_);
2467     }
2468 }
2469 
2470 // For each output section whose name can be represented as C symbol,
2471 // define __start and __stop symbols for the section.  This is a GNU
2472 // extension.
2473 
2474 void
define_section_symbols(Symbol_table * symtab)2475 Layout::define_section_symbols(Symbol_table* symtab)
2476 {
2477   for (Section_list::const_iterator p = this->section_list_.begin();
2478        p != this->section_list_.end();
2479        ++p)
2480     {
2481       const char* const name = (*p)->name();
2482       if (is_cident(name))
2483 	{
2484 	  const std::string name_string(name);
2485 	  const std::string start_name(cident_section_start_prefix
2486 				       + name_string);
2487 	  const std::string stop_name(cident_section_stop_prefix
2488 				      + name_string);
2489 
2490 	  symtab->define_in_output_data(start_name.c_str(),
2491 					NULL, // version
2492 					Symbol_table::PREDEFINED,
2493 					*p,
2494 					0, // value
2495 					0, // symsize
2496 					elfcpp::STT_NOTYPE,
2497 					elfcpp::STB_GLOBAL,
2498 					elfcpp::STV_PROTECTED,
2499 					0, // nonvis
2500 					false, // offset_is_from_end
2501 					true); // only_if_ref
2502 
2503 	  symtab->define_in_output_data(stop_name.c_str(),
2504 					NULL, // version
2505 					Symbol_table::PREDEFINED,
2506 					*p,
2507 					0, // value
2508 					0, // symsize
2509 					elfcpp::STT_NOTYPE,
2510 					elfcpp::STB_GLOBAL,
2511 					elfcpp::STV_PROTECTED,
2512 					0, // nonvis
2513 					true, // offset_is_from_end
2514 					true); // only_if_ref
2515 	}
2516     }
2517 }
2518 
2519 // Define symbols for group signatures.
2520 
2521 void
define_group_signatures(Symbol_table * symtab)2522 Layout::define_group_signatures(Symbol_table* symtab)
2523 {
2524   for (Group_signatures::iterator p = this->group_signatures_.begin();
2525        p != this->group_signatures_.end();
2526        ++p)
2527     {
2528       Symbol* sym = symtab->lookup(p->signature, NULL);
2529       if (sym != NULL)
2530 	p->section->set_info_symndx(sym);
2531       else
2532 	{
2533 	  // Force the name of the group section to the group
2534 	  // signature, and use the group's section symbol as the
2535 	  // signature symbol.
2536 	  if (strcmp(p->section->name(), p->signature) != 0)
2537 	    {
2538 	      const char* name = this->namepool_.add(p->signature,
2539 						     true, NULL);
2540 	      p->section->set_name(name);
2541 	    }
2542 	  p->section->set_needs_symtab_index();
2543 	  p->section->set_info_section_symndx(p->section);
2544 	}
2545     }
2546 
2547   this->group_signatures_.clear();
2548 }
2549 
2550 // Find the first read-only PT_LOAD segment, creating one if
2551 // necessary.
2552 
2553 Output_segment*
find_first_load_seg(const Target * target)2554 Layout::find_first_load_seg(const Target* target)
2555 {
2556   Output_segment* best = NULL;
2557   for (Segment_list::const_iterator p = this->segment_list_.begin();
2558        p != this->segment_list_.end();
2559        ++p)
2560     {
2561       if ((*p)->type() == elfcpp::PT_LOAD
2562 	  && ((*p)->flags() & elfcpp::PF_R) != 0
2563 	  && (parameters->options().omagic()
2564 	      || ((*p)->flags() & elfcpp::PF_W) == 0)
2565 	  && (!target->isolate_execinstr()
2566 	      || ((*p)->flags() & elfcpp::PF_X) == 0))
2567 	{
2568 	  if (best == NULL || this->segment_precedes(*p, best))
2569 	    best = *p;
2570 	}
2571     }
2572   if (best != NULL)
2573     return best;
2574 
2575   gold_assert(!this->script_options_->saw_phdrs_clause());
2576 
2577   Output_segment* load_seg = this->make_output_segment(elfcpp::PT_LOAD,
2578 						       elfcpp::PF_R);
2579   return load_seg;
2580 }
2581 
2582 // Save states of all current output segments.  Store saved states
2583 // in SEGMENT_STATES.
2584 
2585 void
save_segments(Segment_states * segment_states)2586 Layout::save_segments(Segment_states* segment_states)
2587 {
2588   for (Segment_list::const_iterator p = this->segment_list_.begin();
2589        p != this->segment_list_.end();
2590        ++p)
2591     {
2592       Output_segment* segment = *p;
2593       // Shallow copy.
2594       Output_segment* copy = new Output_segment(*segment);
2595       (*segment_states)[segment] = copy;
2596     }
2597 }
2598 
2599 // Restore states of output segments and delete any segment not found in
2600 // SEGMENT_STATES.
2601 
2602 void
restore_segments(const Segment_states * segment_states)2603 Layout::restore_segments(const Segment_states* segment_states)
2604 {
2605   // Go through the segment list and remove any segment added in the
2606   // relaxation loop.
2607   this->tls_segment_ = NULL;
2608   this->relro_segment_ = NULL;
2609   Segment_list::iterator list_iter = this->segment_list_.begin();
2610   while (list_iter != this->segment_list_.end())
2611     {
2612       Output_segment* segment = *list_iter;
2613       Segment_states::const_iterator states_iter =
2614 	  segment_states->find(segment);
2615       if (states_iter != segment_states->end())
2616 	{
2617 	  const Output_segment* copy = states_iter->second;
2618 	  // Shallow copy to restore states.
2619 	  *segment = *copy;
2620 
2621 	  // Also fix up TLS and RELRO segment pointers as appropriate.
2622 	  if (segment->type() == elfcpp::PT_TLS)
2623 	    this->tls_segment_ = segment;
2624 	  else if (segment->type() == elfcpp::PT_GNU_RELRO)
2625 	    this->relro_segment_ = segment;
2626 
2627 	  ++list_iter;
2628 	}
2629       else
2630 	{
2631 	  list_iter = this->segment_list_.erase(list_iter);
2632 	  // This is a segment created during section layout.  It should be
2633 	  // safe to remove it since we should have removed all pointers to it.
2634 	  delete segment;
2635 	}
2636     }
2637 }
2638 
2639 // Clean up after relaxation so that sections can be laid out again.
2640 
2641 void
clean_up_after_relaxation()2642 Layout::clean_up_after_relaxation()
2643 {
2644   // Restore the segments to point state just prior to the relaxation loop.
2645   Script_sections* script_section = this->script_options_->script_sections();
2646   script_section->release_segments();
2647   this->restore_segments(this->segment_states_);
2648 
2649   // Reset section addresses and file offsets
2650   for (Section_list::iterator p = this->section_list_.begin();
2651        p != this->section_list_.end();
2652        ++p)
2653     {
2654       (*p)->restore_states();
2655 
2656       // If an input section changes size because of relaxation,
2657       // we need to adjust the section offsets of all input sections.
2658       // after such a section.
2659       if ((*p)->section_offsets_need_adjustment())
2660 	(*p)->adjust_section_offsets();
2661 
2662       (*p)->reset_address_and_file_offset();
2663     }
2664 
2665   // Reset special output object address and file offsets.
2666   for (Data_list::iterator p = this->special_output_list_.begin();
2667        p != this->special_output_list_.end();
2668        ++p)
2669     (*p)->reset_address_and_file_offset();
2670 
2671   // A linker script may have created some output section data objects.
2672   // They are useless now.
2673   for (Output_section_data_list::const_iterator p =
2674 	 this->script_output_section_data_list_.begin();
2675        p != this->script_output_section_data_list_.end();
2676        ++p)
2677     delete *p;
2678   this->script_output_section_data_list_.clear();
2679 
2680   // Special-case fill output objects are recreated each time through
2681   // the relaxation loop.
2682   this->reset_relax_output();
2683 }
2684 
2685 void
reset_relax_output()2686 Layout::reset_relax_output()
2687 {
2688   for (Data_list::const_iterator p = this->relax_output_list_.begin();
2689        p != this->relax_output_list_.end();
2690        ++p)
2691     delete *p;
2692   this->relax_output_list_.clear();
2693 }
2694 
2695 // Prepare for relaxation.
2696 
2697 void
prepare_for_relaxation()2698 Layout::prepare_for_relaxation()
2699 {
2700   // Create an relaxation debug check if in debugging mode.
2701   if (is_debugging_enabled(DEBUG_RELAXATION))
2702     this->relaxation_debug_check_ = new Relaxation_debug_check();
2703 
2704   // Save segment states.
2705   this->segment_states_ = new Segment_states();
2706   this->save_segments(this->segment_states_);
2707 
2708   for(Section_list::const_iterator p = this->section_list_.begin();
2709       p != this->section_list_.end();
2710       ++p)
2711     (*p)->save_states();
2712 
2713   if (is_debugging_enabled(DEBUG_RELAXATION))
2714     this->relaxation_debug_check_->check_output_data_for_reset_values(
2715 	this->section_list_, this->special_output_list_,
2716 	this->relax_output_list_);
2717 
2718   // Also enable recording of output section data from scripts.
2719   this->record_output_section_data_from_script_ = true;
2720 }
2721 
2722 // If the user set the address of the text segment, that may not be
2723 // compatible with putting the segment headers and file headers into
2724 // that segment.  For isolate_execinstr() targets, it's the rodata
2725 // segment rather than text where we might put the headers.
2726 static inline bool
load_seg_unusable_for_headers(const Target * target)2727 load_seg_unusable_for_headers(const Target* target)
2728 {
2729   const General_options& options = parameters->options();
2730   if (target->isolate_execinstr())
2731     return (options.user_set_Trodata_segment()
2732 	    && options.Trodata_segment() % target->abi_pagesize() != 0);
2733   else
2734     return (options.user_set_Ttext()
2735 	    && options.Ttext() % target->abi_pagesize() != 0);
2736 }
2737 
2738 // Relaxation loop body:  If target has no relaxation, this runs only once
2739 // Otherwise, the target relaxation hook is called at the end of
2740 // each iteration.  If the hook returns true, it means re-layout of
2741 // section is required.
2742 //
2743 // The number of segments created by a linking script without a PHDRS
2744 // clause may be affected by section sizes and alignments.  There is
2745 // a remote chance that relaxation causes different number of PT_LOAD
2746 // segments are created and sections are attached to different segments.
2747 // Therefore, we always throw away all segments created during section
2748 // layout.  In order to be able to restart the section layout, we keep
2749 // a copy of the segment list right before the relaxation loop and use
2750 // that to restore the segments.
2751 //
2752 // PASS is the current relaxation pass number.
2753 // SYMTAB is a symbol table.
2754 // PLOAD_SEG is the address of a pointer for the load segment.
2755 // PHDR_SEG is a pointer to the PHDR segment.
2756 // SEGMENT_HEADERS points to the output segment header.
2757 // FILE_HEADER points to the output file header.
2758 // PSHNDX is the address to store the output section index.
2759 
2760 off_t inline
relaxation_loop_body(int pass,Target * target,Symbol_table * symtab,Output_segment ** pload_seg,Output_segment * phdr_seg,Output_segment_headers * segment_headers,Output_file_header * file_header,unsigned int * pshndx)2761 Layout::relaxation_loop_body(
2762     int pass,
2763     Target* target,
2764     Symbol_table* symtab,
2765     Output_segment** pload_seg,
2766     Output_segment* phdr_seg,
2767     Output_segment_headers* segment_headers,
2768     Output_file_header* file_header,
2769     unsigned int* pshndx)
2770 {
2771   // If this is not the first iteration, we need to clean up after
2772   // relaxation so that we can lay out the sections again.
2773   if (pass != 0)
2774     this->clean_up_after_relaxation();
2775 
2776   // If there is a SECTIONS clause, put all the input sections into
2777   // the required order.
2778   Output_segment* load_seg;
2779   if (this->script_options_->saw_sections_clause())
2780     load_seg = this->set_section_addresses_from_script(symtab);
2781   else if (parameters->options().relocatable())
2782     load_seg = NULL;
2783   else
2784     load_seg = this->find_first_load_seg(target);
2785 
2786   if (parameters->options().oformat_enum()
2787       != General_options::OBJECT_FORMAT_ELF)
2788     load_seg = NULL;
2789 
2790   if (load_seg_unusable_for_headers(target))
2791     {
2792       load_seg = NULL;
2793       phdr_seg = NULL;
2794     }
2795 
2796   gold_assert(phdr_seg == NULL
2797 	      || load_seg != NULL
2798 	      || this->script_options_->saw_sections_clause());
2799 
2800   // If the address of the load segment we found has been set by
2801   // --section-start rather than by a script, then adjust the VMA and
2802   // LMA downward if possible to include the file and section headers.
2803   uint64_t header_gap = 0;
2804   if (load_seg != NULL
2805       && load_seg->are_addresses_set()
2806       && !this->script_options_->saw_sections_clause()
2807       && !parameters->options().relocatable())
2808     {
2809       file_header->finalize_data_size();
2810       segment_headers->finalize_data_size();
2811       size_t sizeof_headers = (file_header->data_size()
2812 			       + segment_headers->data_size());
2813       const uint64_t abi_pagesize = target->abi_pagesize();
2814       uint64_t hdr_paddr = load_seg->paddr() - sizeof_headers;
2815       hdr_paddr &= ~(abi_pagesize - 1);
2816       uint64_t subtract = load_seg->paddr() - hdr_paddr;
2817       if (load_seg->paddr() < subtract || load_seg->vaddr() < subtract)
2818 	load_seg = NULL;
2819       else
2820 	{
2821 	  load_seg->set_addresses(load_seg->vaddr() - subtract,
2822 				  load_seg->paddr() - subtract);
2823 	  header_gap = subtract - sizeof_headers;
2824 	}
2825     }
2826 
2827   // Lay out the segment headers.
2828   if (!parameters->options().relocatable())
2829     {
2830       gold_assert(segment_headers != NULL);
2831       if (header_gap != 0 && load_seg != NULL)
2832 	{
2833 	  Output_data_zero_fill* z = new Output_data_zero_fill(header_gap, 1);
2834 	  load_seg->add_initial_output_data(z);
2835 	}
2836       if (load_seg != NULL)
2837 	load_seg->add_initial_output_data(segment_headers);
2838       if (phdr_seg != NULL)
2839 	phdr_seg->add_initial_output_data(segment_headers);
2840     }
2841 
2842   // Lay out the file header.
2843   if (load_seg != NULL)
2844     load_seg->add_initial_output_data(file_header);
2845 
2846   if (this->script_options_->saw_phdrs_clause()
2847       && !parameters->options().relocatable())
2848     {
2849       // Support use of FILEHDRS and PHDRS attachments in a PHDRS
2850       // clause in a linker script.
2851       Script_sections* ss = this->script_options_->script_sections();
2852       ss->put_headers_in_phdrs(file_header, segment_headers);
2853     }
2854 
2855   // We set the output section indexes in set_segment_offsets and
2856   // set_section_indexes.
2857   *pshndx = 1;
2858 
2859   // Set the file offsets of all the segments, and all the sections
2860   // they contain.
2861   off_t off;
2862   if (!parameters->options().relocatable())
2863     off = this->set_segment_offsets(target, load_seg, pshndx);
2864   else
2865     off = this->set_relocatable_section_offsets(file_header, pshndx);
2866 
2867    // Verify that the dummy relaxation does not change anything.
2868   if (is_debugging_enabled(DEBUG_RELAXATION))
2869     {
2870       if (pass == 0)
2871 	this->relaxation_debug_check_->read_sections(this->section_list_);
2872       else
2873 	this->relaxation_debug_check_->verify_sections(this->section_list_);
2874     }
2875 
2876   *pload_seg = load_seg;
2877   return off;
2878 }
2879 
2880 // Search the list of patterns and find the position of the given section
2881 // name in the output section.  If the section name matches a glob
2882 // pattern and a non-glob name, then the non-glob position takes
2883 // precedence.  Return 0 if no match is found.
2884 
2885 unsigned int
find_section_order_index(const std::string & section_name)2886 Layout::find_section_order_index(const std::string& section_name)
2887 {
2888   Unordered_map<std::string, unsigned int>::iterator map_it;
2889   map_it = this->input_section_position_.find(section_name);
2890   if (map_it != this->input_section_position_.end())
2891     return map_it->second;
2892 
2893   // Absolute match failed.  Linear search the glob patterns.
2894   std::vector<std::string>::iterator it;
2895   for (it = this->input_section_glob_.begin();
2896        it != this->input_section_glob_.end();
2897        ++it)
2898     {
2899        if (fnmatch((*it).c_str(), section_name.c_str(), FNM_NOESCAPE) == 0)
2900 	 {
2901 	   map_it = this->input_section_position_.find(*it);
2902 	   gold_assert(map_it != this->input_section_position_.end());
2903 	   return map_it->second;
2904 	 }
2905     }
2906   return 0;
2907 }
2908 
2909 // Read the sequence of input sections from the file specified with
2910 // option --section-ordering-file.
2911 
2912 void
read_layout_from_file()2913 Layout::read_layout_from_file()
2914 {
2915   const char* filename = parameters->options().section_ordering_file();
2916   std::ifstream in;
2917   std::string line;
2918 
2919   in.open(filename);
2920   if (!in)
2921     gold_fatal(_("unable to open --section-ordering-file file %s: %s"),
2922 	       filename, strerror(errno));
2923 
2924   std::getline(in, line);   // this chops off the trailing \n, if any
2925   unsigned int position = 1;
2926   this->set_section_ordering_specified();
2927 
2928   while (in)
2929     {
2930       if (!line.empty() && line[line.length() - 1] == '\r')   // Windows
2931 	line.resize(line.length() - 1);
2932       // Ignore comments, beginning with '#'
2933       if (line[0] == '#')
2934 	{
2935 	  std::getline(in, line);
2936 	  continue;
2937 	}
2938       this->input_section_position_[line] = position;
2939       // Store all glob patterns in a vector.
2940       if (is_wildcard_string(line.c_str()))
2941 	this->input_section_glob_.push_back(line);
2942       position++;
2943       std::getline(in, line);
2944     }
2945 }
2946 
2947 // Finalize the layout.  When this is called, we have created all the
2948 // output sections and all the output segments which are based on
2949 // input sections.  We have several things to do, and we have to do
2950 // them in the right order, so that we get the right results correctly
2951 // and efficiently.
2952 
2953 // 1) Finalize the list of output segments and create the segment
2954 // table header.
2955 
2956 // 2) Finalize the dynamic symbol table and associated sections.
2957 
2958 // 3) Determine the final file offset of all the output segments.
2959 
2960 // 4) Determine the final file offset of all the SHF_ALLOC output
2961 // sections.
2962 
2963 // 5) Create the symbol table sections and the section name table
2964 // section.
2965 
2966 // 6) Finalize the symbol table: set symbol values to their final
2967 // value and make a final determination of which symbols are going
2968 // into the output symbol table.
2969 
2970 // 7) Create the section table header.
2971 
2972 // 8) Determine the final file offset of all the output sections which
2973 // are not SHF_ALLOC, including the section table header.
2974 
2975 // 9) Finalize the ELF file header.
2976 
2977 // This function returns the size of the output file.
2978 
2979 off_t
finalize(const Input_objects * input_objects,Symbol_table * symtab,Target * target,const Task * task)2980 Layout::finalize(const Input_objects* input_objects, Symbol_table* symtab,
2981 		 Target* target, const Task* task)
2982 {
2983   unsigned int local_dynamic_count = 0;
2984   unsigned int forced_local_dynamic_count = 0;
2985 
2986   target->finalize_sections(this, input_objects, symtab);
2987 
2988   this->count_local_symbols(task, input_objects);
2989 
2990   this->link_stabs_sections();
2991 
2992   Output_segment* phdr_seg = NULL;
2993   if (!parameters->options().relocatable() && !parameters->doing_static_link())
2994     {
2995       // There was a dynamic object in the link.  We need to create
2996       // some information for the dynamic linker.
2997 
2998       // Create the PT_PHDR segment which will hold the program
2999       // headers.
3000       if (!this->script_options_->saw_phdrs_clause())
3001 	phdr_seg = this->make_output_segment(elfcpp::PT_PHDR, elfcpp::PF_R);
3002 
3003       // Create the dynamic symbol table, including the hash table.
3004       Output_section* dynstr;
3005       std::vector<Symbol*> dynamic_symbols;
3006       Versions versions(*this->script_options()->version_script_info(),
3007 			&this->dynpool_);
3008       this->create_dynamic_symtab(input_objects, symtab, &dynstr,
3009 				  &local_dynamic_count,
3010 				  &forced_local_dynamic_count,
3011 				  &dynamic_symbols,
3012 				  &versions);
3013 
3014       // Create the .interp section to hold the name of the
3015       // interpreter, and put it in a PT_INTERP segment.  Don't do it
3016       // if we saw a .interp section in an input file.
3017       if ((!parameters->options().shared()
3018 	   || parameters->options().dynamic_linker() != NULL)
3019 	  && this->interp_segment_ == NULL)
3020 	this->create_interp(target);
3021 
3022       // Finish the .dynamic section to hold the dynamic data, and put
3023       // it in a PT_DYNAMIC segment.
3024       this->finish_dynamic_section(input_objects, symtab);
3025 
3026       // We should have added everything we need to the dynamic string
3027       // table.
3028       this->dynpool_.set_string_offsets();
3029 
3030       // Create the version sections.  We can't do this until the
3031       // dynamic string table is complete.
3032       this->create_version_sections(&versions, symtab,
3033 				    (local_dynamic_count
3034 				     + forced_local_dynamic_count),
3035 				    dynamic_symbols, dynstr);
3036 
3037       // Set the size of the _DYNAMIC symbol.  We can't do this until
3038       // after we call create_version_sections.
3039       this->set_dynamic_symbol_size(symtab);
3040     }
3041 
3042   // Create segment headers.
3043   Output_segment_headers* segment_headers =
3044     (parameters->options().relocatable()
3045      ? NULL
3046      : new Output_segment_headers(this->segment_list_));
3047 
3048   // Lay out the file header.
3049   Output_file_header* file_header = new Output_file_header(target, symtab,
3050 							   segment_headers);
3051 
3052   this->special_output_list_.push_back(file_header);
3053   if (segment_headers != NULL)
3054     this->special_output_list_.push_back(segment_headers);
3055 
3056   // Find approriate places for orphan output sections if we are using
3057   // a linker script.
3058   if (this->script_options_->saw_sections_clause())
3059     this->place_orphan_sections_in_script();
3060 
3061   Output_segment* load_seg;
3062   off_t off;
3063   unsigned int shndx;
3064   int pass = 0;
3065 
3066   // Take a snapshot of the section layout as needed.
3067   if (target->may_relax())
3068     this->prepare_for_relaxation();
3069 
3070   // Run the relaxation loop to lay out sections.
3071   do
3072     {
3073       off = this->relaxation_loop_body(pass, target, symtab, &load_seg,
3074 				       phdr_seg, segment_headers, file_header,
3075 				       &shndx);
3076       pass++;
3077     }
3078   while (target->may_relax()
3079 	 && target->relax(pass, input_objects, symtab, this, task));
3080 
3081   // If there is a load segment that contains the file and program headers,
3082   // provide a symbol __ehdr_start pointing there.
3083   // A program can use this to examine itself robustly.
3084   Symbol *ehdr_start = symtab->lookup("__ehdr_start");
3085   if (ehdr_start != NULL && ehdr_start->is_predefined())
3086     {
3087       if (load_seg != NULL)
3088 	ehdr_start->set_output_segment(load_seg, Symbol::SEGMENT_START);
3089       else
3090 	ehdr_start->set_undefined();
3091     }
3092 
3093   // Set the file offsets of all the non-data sections we've seen so
3094   // far which don't have to wait for the input sections.  We need
3095   // this in order to finalize local symbols in non-allocated
3096   // sections.
3097   off = this->set_section_offsets(off, BEFORE_INPUT_SECTIONS_PASS);
3098 
3099   // Set the section indexes of all unallocated sections seen so far,
3100   // in case any of them are somehow referenced by a symbol.
3101   shndx = this->set_section_indexes(shndx);
3102 
3103   // Create the symbol table sections.
3104   this->create_symtab_sections(input_objects, symtab, shndx, &off,
3105 			       local_dynamic_count);
3106   if (!parameters->doing_static_link())
3107     this->assign_local_dynsym_offsets(input_objects);
3108 
3109   // Process any symbol assignments from a linker script.  This must
3110   // be called after the symbol table has been finalized.
3111   this->script_options_->finalize_symbols(symtab, this);
3112 
3113   // Create the incremental inputs sections.
3114   if (this->incremental_inputs_)
3115     {
3116       this->incremental_inputs_->finalize();
3117       this->create_incremental_info_sections(symtab);
3118     }
3119 
3120   // Create the .shstrtab section.
3121   Output_section* shstrtab_section = this->create_shstrtab();
3122 
3123   // Set the file offsets of the rest of the non-data sections which
3124   // don't have to wait for the input sections.
3125   off = this->set_section_offsets(off, BEFORE_INPUT_SECTIONS_PASS);
3126 
3127   // Now that all sections have been created, set the section indexes
3128   // for any sections which haven't been done yet.
3129   shndx = this->set_section_indexes(shndx);
3130 
3131   // Create the section table header.
3132   this->create_shdrs(shstrtab_section, &off);
3133 
3134   // If there are no sections which require postprocessing, we can
3135   // handle the section names now, and avoid a resize later.
3136   if (!this->any_postprocessing_sections_)
3137     {
3138       off = this->set_section_offsets(off,
3139 				      POSTPROCESSING_SECTIONS_PASS);
3140       off =
3141 	  this->set_section_offsets(off,
3142 				    STRTAB_AFTER_POSTPROCESSING_SECTIONS_PASS);
3143     }
3144 
3145   file_header->set_section_info(this->section_headers_, shstrtab_section);
3146 
3147   // Now we know exactly where everything goes in the output file
3148   // (except for non-allocated sections which require postprocessing).
3149   Output_data::layout_complete();
3150 
3151   this->output_file_size_ = off;
3152 
3153   return off;
3154 }
3155 
3156 // Create a note header following the format defined in the ELF ABI.
3157 // NAME is the name, NOTE_TYPE is the type, SECTION_NAME is the name
3158 // of the section to create, DESCSZ is the size of the descriptor.
3159 // ALLOCATE is true if the section should be allocated in memory.
3160 // This returns the new note section.  It sets *TRAILING_PADDING to
3161 // the number of trailing zero bytes required.
3162 
3163 Output_section*
create_note(const char * name,int note_type,const char * section_name,size_t descsz,bool allocate,size_t * trailing_padding)3164 Layout::create_note(const char* name, int note_type,
3165 		    const char* section_name, size_t descsz,
3166 		    bool allocate, size_t* trailing_padding)
3167 {
3168   // Authorities all agree that the values in a .note field should
3169   // be aligned on 4-byte boundaries for 32-bit binaries.  However,
3170   // they differ on what the alignment is for 64-bit binaries.
3171   // The GABI says unambiguously they take 8-byte alignment:
3172   //    http://sco.com/developers/gabi/latest/ch5.pheader.html#note_section
3173   // Other documentation says alignment should always be 4 bytes:
3174   //    http://www.netbsd.org/docs/kernel/elf-notes.html#note-format
3175   // GNU ld and GNU readelf both support the latter (at least as of
3176   // version 2.16.91), and glibc always generates the latter for
3177   // .note.ABI-tag (as of version 1.6), so that's the one we go with
3178   // here.
3179 #ifdef GABI_FORMAT_FOR_DOTNOTE_SECTION   // This is not defined by default.
3180   const int size = parameters->target().get_size();
3181 #else
3182   const int size = 32;
3183 #endif
3184 
3185   // The contents of the .note section.
3186   size_t namesz = strlen(name) + 1;
3187   size_t aligned_namesz = align_address(namesz, size / 8);
3188   size_t aligned_descsz = align_address(descsz, size / 8);
3189 
3190   size_t notehdrsz = 3 * (size / 8) + aligned_namesz;
3191 
3192   unsigned char* buffer = new unsigned char[notehdrsz];
3193   memset(buffer, 0, notehdrsz);
3194 
3195   bool is_big_endian = parameters->target().is_big_endian();
3196 
3197   if (size == 32)
3198     {
3199       if (!is_big_endian)
3200 	{
3201 	  elfcpp::Swap<32, false>::writeval(buffer, namesz);
3202 	  elfcpp::Swap<32, false>::writeval(buffer + 4, descsz);
3203 	  elfcpp::Swap<32, false>::writeval(buffer + 8, note_type);
3204 	}
3205       else
3206 	{
3207 	  elfcpp::Swap<32, true>::writeval(buffer, namesz);
3208 	  elfcpp::Swap<32, true>::writeval(buffer + 4, descsz);
3209 	  elfcpp::Swap<32, true>::writeval(buffer + 8, note_type);
3210 	}
3211     }
3212   else if (size == 64)
3213     {
3214       if (!is_big_endian)
3215 	{
3216 	  elfcpp::Swap<64, false>::writeval(buffer, namesz);
3217 	  elfcpp::Swap<64, false>::writeval(buffer + 8, descsz);
3218 	  elfcpp::Swap<64, false>::writeval(buffer + 16, note_type);
3219 	}
3220       else
3221 	{
3222 	  elfcpp::Swap<64, true>::writeval(buffer, namesz);
3223 	  elfcpp::Swap<64, true>::writeval(buffer + 8, descsz);
3224 	  elfcpp::Swap<64, true>::writeval(buffer + 16, note_type);
3225 	}
3226     }
3227   else
3228     gold_unreachable();
3229 
3230   memcpy(buffer + 3 * (size / 8), name, namesz);
3231 
3232   elfcpp::Elf_Xword flags = 0;
3233   Output_section_order order = ORDER_INVALID;
3234   if (allocate)
3235     {
3236       flags = elfcpp::SHF_ALLOC;
3237       order = ORDER_RO_NOTE;
3238     }
3239   Output_section* os = this->choose_output_section(NULL, section_name,
3240 						   elfcpp::SHT_NOTE,
3241 						   flags, false, order, false,
3242 						   false, true);
3243   if (os == NULL)
3244     return NULL;
3245 
3246   Output_section_data* posd = new Output_data_const_buffer(buffer, notehdrsz,
3247 							   size / 8,
3248 							   "** note header");
3249   os->add_output_section_data(posd);
3250 
3251   *trailing_padding = aligned_descsz - descsz;
3252 
3253   return os;
3254 }
3255 
3256 // Create a .note.gnu.property section to record program properties
3257 // accumulated from the input files.
3258 
3259 void
create_gnu_properties_note()3260 Layout::create_gnu_properties_note()
3261 {
3262   parameters->target().finalize_gnu_properties(this);
3263 
3264   if (this->gnu_properties_.empty())
3265     return;
3266 
3267   const unsigned int size = parameters->target().get_size();
3268   const bool is_big_endian = parameters->target().is_big_endian();
3269 
3270   // Compute the total size of the properties array.
3271   size_t descsz = 0;
3272   for (Gnu_properties::const_iterator prop = this->gnu_properties_.begin();
3273        prop != this->gnu_properties_.end();
3274        ++prop)
3275     {
3276       descsz = align_address(descsz + 8 + prop->second.pr_datasz, size / 8);
3277     }
3278 
3279   // Create the note section.
3280   size_t trailing_padding;
3281   Output_section* os = this->create_note("GNU", elfcpp::NT_GNU_PROPERTY_TYPE_0,
3282 					 ".note.gnu.property", descsz,
3283 					 true, &trailing_padding);
3284   if (os == NULL)
3285     return;
3286   gold_assert(trailing_padding == 0);
3287 
3288   // Allocate and fill the properties array.
3289   unsigned char* desc = new unsigned char[descsz];
3290   unsigned char* p = desc;
3291   for (Gnu_properties::const_iterator prop = this->gnu_properties_.begin();
3292        prop != this->gnu_properties_.end();
3293        ++prop)
3294     {
3295       size_t datasz = prop->second.pr_datasz;
3296       size_t aligned_datasz = align_address(prop->second.pr_datasz, size / 8);
3297       write_sized_value(prop->first, 4, p, is_big_endian);
3298       write_sized_value(datasz, 4, p + 4, is_big_endian);
3299       memcpy(p + 8, prop->second.pr_data, datasz);
3300       if (aligned_datasz > datasz)
3301         memset(p + 8 + datasz, 0, aligned_datasz - datasz);
3302       p += 8 + aligned_datasz;
3303     }
3304   Output_section_data* posd = new Output_data_const(desc, descsz, 4);
3305   os->add_output_section_data(posd);
3306 }
3307 
3308 // For an executable or shared library, create a note to record the
3309 // version of gold used to create the binary.
3310 
3311 void
create_gold_note()3312 Layout::create_gold_note()
3313 {
3314   if (parameters->options().relocatable()
3315       || parameters->incremental_update())
3316     return;
3317 
3318   std::string desc = std::string("gold ") + gold::get_version_string();
3319 
3320   size_t trailing_padding;
3321   Output_section* os = this->create_note("GNU", elfcpp::NT_GNU_GOLD_VERSION,
3322 					 ".note.gnu.gold-version", desc.size(),
3323 					 false, &trailing_padding);
3324   if (os == NULL)
3325     return;
3326 
3327   Output_section_data* posd = new Output_data_const(desc, 4);
3328   os->add_output_section_data(posd);
3329 
3330   if (trailing_padding > 0)
3331     {
3332       posd = new Output_data_zero_fill(trailing_padding, 0);
3333       os->add_output_section_data(posd);
3334     }
3335 }
3336 
3337 // Record whether the stack should be executable.  This can be set
3338 // from the command line using the -z execstack or -z noexecstack
3339 // options.  Otherwise, if any input file has a .note.GNU-stack
3340 // section with the SHF_EXECINSTR flag set, the stack should be
3341 // executable.  Otherwise, if at least one input file a
3342 // .note.GNU-stack section, and some input file has no .note.GNU-stack
3343 // section, we use the target default for whether the stack should be
3344 // executable.  If -z stack-size was used to set a p_memsz value for
3345 // PT_GNU_STACK, we generate the segment regardless.  Otherwise, we
3346 // don't generate a stack note.  When generating a object file, we
3347 // create a .note.GNU-stack section with the appropriate marking.
3348 // When generating an executable or shared library, we create a
3349 // PT_GNU_STACK segment.
3350 
3351 void
create_stack_segment()3352 Layout::create_stack_segment()
3353 {
3354   bool is_stack_executable;
3355   if (parameters->options().is_execstack_set())
3356     {
3357       is_stack_executable = parameters->options().is_stack_executable();
3358       if (!is_stack_executable
3359 	  && this->input_requires_executable_stack_
3360 	  && parameters->options().warn_execstack())
3361 	gold_warning(_("one or more inputs require executable stack, "
3362 		       "but -z noexecstack was given"));
3363     }
3364   else if (!this->input_with_gnu_stack_note_
3365 	   && (!parameters->options().user_set_stack_size()
3366 	       || parameters->options().relocatable()))
3367     return;
3368   else
3369     {
3370       if (this->input_requires_executable_stack_)
3371 	is_stack_executable = true;
3372       else if (this->input_without_gnu_stack_note_)
3373 	is_stack_executable =
3374 	  parameters->target().is_default_stack_executable();
3375       else
3376 	is_stack_executable = false;
3377     }
3378 
3379   if (parameters->options().relocatable())
3380     {
3381       const char* name = this->namepool_.add(".note.GNU-stack", false, NULL);
3382       elfcpp::Elf_Xword flags = 0;
3383       if (is_stack_executable)
3384 	flags |= elfcpp::SHF_EXECINSTR;
3385       this->make_output_section(name, elfcpp::SHT_PROGBITS, flags,
3386 				ORDER_INVALID, false);
3387     }
3388   else
3389     {
3390       if (this->script_options_->saw_phdrs_clause())
3391 	return;
3392       int flags = elfcpp::PF_R | elfcpp::PF_W;
3393       if (is_stack_executable)
3394 	flags |= elfcpp::PF_X;
3395       Output_segment* seg =
3396 	this->make_output_segment(elfcpp::PT_GNU_STACK, flags);
3397       seg->set_size(parameters->options().stack_size());
3398       // BFD lets targets override this default alignment, but the only
3399       // targets that do so are ones that Gold does not support so far.
3400       seg->set_minimum_p_align(16);
3401     }
3402 }
3403 
3404 // If --build-id was used, set up the build ID note.
3405 
3406 void
create_build_id()3407 Layout::create_build_id()
3408 {
3409   if (!parameters->options().user_set_build_id())
3410     return;
3411 
3412   const char* style = parameters->options().build_id();
3413   if (strcmp(style, "none") == 0)
3414     return;
3415 
3416   // Set DESCSZ to the size of the note descriptor.  When possible,
3417   // set DESC to the note descriptor contents.
3418   size_t descsz;
3419   std::string desc;
3420   if (strcmp(style, "md5") == 0)
3421     descsz = 128 / 8;
3422   else if ((strcmp(style, "sha1") == 0) || (strcmp(style, "tree") == 0))
3423     descsz = 160 / 8;
3424   else if (strcmp(style, "uuid") == 0)
3425     {
3426 #ifndef __MINGW32__
3427       const size_t uuidsz = 128 / 8;
3428 
3429       char buffer[uuidsz];
3430       memset(buffer, 0, uuidsz);
3431 
3432       int descriptor = open_descriptor(-1, "/dev/urandom", O_RDONLY);
3433       if (descriptor < 0)
3434 	gold_error(_("--build-id=uuid failed: could not open /dev/urandom: %s"),
3435 		   strerror(errno));
3436       else
3437 	{
3438 	  ssize_t got = ::read(descriptor, buffer, uuidsz);
3439 	  release_descriptor(descriptor, true);
3440 	  if (got < 0)
3441 	    gold_error(_("/dev/urandom: read failed: %s"), strerror(errno));
3442 	  else if (static_cast<size_t>(got) != uuidsz)
3443 	    gold_error(_("/dev/urandom: expected %zu bytes, got %zd bytes"),
3444 		       uuidsz, got);
3445 	}
3446 
3447       desc.assign(buffer, uuidsz);
3448       descsz = uuidsz;
3449 #else // __MINGW32__
3450       UUID uuid;
3451       typedef RPC_STATUS (RPC_ENTRY *UuidCreateFn)(UUID *Uuid);
3452 
3453       HMODULE rpc_library = LoadLibrary("rpcrt4.dll");
3454       if (!rpc_library)
3455 	gold_error(_("--build-id=uuid failed: could not load rpcrt4.dll"));
3456       else
3457 	{
3458 	  UuidCreateFn uuid_create = reinterpret_cast<UuidCreateFn>(
3459 	      GetProcAddress(rpc_library, "UuidCreate"));
3460 	  if (!uuid_create)
3461 	    gold_error(_("--build-id=uuid failed: could not find UuidCreate"));
3462 	  else if (uuid_create(&uuid) != RPC_S_OK)
3463 	    gold_error(_("__build_id=uuid failed: call UuidCreate() failed"));
3464 	  FreeLibrary(rpc_library);
3465 	}
3466       desc.assign(reinterpret_cast<const char *>(&uuid), sizeof(UUID));
3467       descsz = sizeof(UUID);
3468 #endif // __MINGW32__
3469     }
3470   else if (strncmp(style, "0x", 2) == 0)
3471     {
3472       hex_init();
3473       const char* p = style + 2;
3474       while (*p != '\0')
3475 	{
3476 	  if (hex_p(p[0]) && hex_p(p[1]))
3477 	    {
3478 	      char c = (hex_value(p[0]) << 4) | hex_value(p[1]);
3479 	      desc += c;
3480 	      p += 2;
3481 	    }
3482 	  else if (*p == '-' || *p == ':')
3483 	    ++p;
3484 	  else
3485 	    gold_fatal(_("--build-id argument '%s' not a valid hex number"),
3486 		       style);
3487 	}
3488       descsz = desc.size();
3489     }
3490   else
3491     gold_fatal(_("unrecognized --build-id argument '%s'"), style);
3492 
3493   // Create the note.
3494   size_t trailing_padding;
3495   Output_section* os = this->create_note("GNU", elfcpp::NT_GNU_BUILD_ID,
3496 					 ".note.gnu.build-id", descsz, true,
3497 					 &trailing_padding);
3498   if (os == NULL)
3499     return;
3500 
3501   if (!desc.empty())
3502     {
3503       // We know the value already, so we fill it in now.
3504       gold_assert(desc.size() == descsz);
3505 
3506       Output_section_data* posd = new Output_data_const(desc, 4);
3507       os->add_output_section_data(posd);
3508 
3509       if (trailing_padding != 0)
3510 	{
3511 	  posd = new Output_data_zero_fill(trailing_padding, 0);
3512 	  os->add_output_section_data(posd);
3513 	}
3514     }
3515   else
3516     {
3517       // We need to compute a checksum after we have completed the
3518       // link.
3519       gold_assert(trailing_padding == 0);
3520       this->build_id_note_ = new Output_data_zero_fill(descsz, 4);
3521       os->add_output_section_data(this->build_id_note_);
3522     }
3523 }
3524 
3525 // If we have both .stabXX and .stabXXstr sections, then the sh_link
3526 // field of the former should point to the latter.  I'm not sure who
3527 // started this, but the GNU linker does it, and some tools depend
3528 // upon it.
3529 
3530 void
link_stabs_sections()3531 Layout::link_stabs_sections()
3532 {
3533   if (!this->have_stabstr_section_)
3534     return;
3535 
3536   for (Section_list::iterator p = this->section_list_.begin();
3537        p != this->section_list_.end();
3538        ++p)
3539     {
3540       if ((*p)->type() != elfcpp::SHT_STRTAB)
3541 	continue;
3542 
3543       const char* name = (*p)->name();
3544       if (strncmp(name, ".stab", 5) != 0)
3545 	continue;
3546 
3547       size_t len = strlen(name);
3548       if (strcmp(name + len - 3, "str") != 0)
3549 	continue;
3550 
3551       std::string stab_name(name, len - 3);
3552       Output_section* stab_sec;
3553       stab_sec = this->find_output_section(stab_name.c_str());
3554       if (stab_sec != NULL)
3555 	stab_sec->set_link_section(*p);
3556     }
3557 }
3558 
3559 // Create .gnu_incremental_inputs and related sections needed
3560 // for the next run of incremental linking to check what has changed.
3561 
3562 void
create_incremental_info_sections(Symbol_table * symtab)3563 Layout::create_incremental_info_sections(Symbol_table* symtab)
3564 {
3565   Incremental_inputs* incr = this->incremental_inputs_;
3566 
3567   gold_assert(incr != NULL);
3568 
3569   // Create the .gnu_incremental_inputs, _symtab, and _relocs input sections.
3570   incr->create_data_sections(symtab);
3571 
3572   // Add the .gnu_incremental_inputs section.
3573   const char* incremental_inputs_name =
3574     this->namepool_.add(".gnu_incremental_inputs", false, NULL);
3575   Output_section* incremental_inputs_os =
3576     this->make_output_section(incremental_inputs_name,
3577 			      elfcpp::SHT_GNU_INCREMENTAL_INPUTS, 0,
3578 			      ORDER_INVALID, false);
3579   incremental_inputs_os->add_output_section_data(incr->inputs_section());
3580 
3581   // Add the .gnu_incremental_symtab section.
3582   const char* incremental_symtab_name =
3583     this->namepool_.add(".gnu_incremental_symtab", false, NULL);
3584   Output_section* incremental_symtab_os =
3585     this->make_output_section(incremental_symtab_name,
3586 			      elfcpp::SHT_GNU_INCREMENTAL_SYMTAB, 0,
3587 			      ORDER_INVALID, false);
3588   incremental_symtab_os->add_output_section_data(incr->symtab_section());
3589   incremental_symtab_os->set_entsize(4);
3590 
3591   // Add the .gnu_incremental_relocs section.
3592   const char* incremental_relocs_name =
3593     this->namepool_.add(".gnu_incremental_relocs", false, NULL);
3594   Output_section* incremental_relocs_os =
3595     this->make_output_section(incremental_relocs_name,
3596 			      elfcpp::SHT_GNU_INCREMENTAL_RELOCS, 0,
3597 			      ORDER_INVALID, false);
3598   incremental_relocs_os->add_output_section_data(incr->relocs_section());
3599   incremental_relocs_os->set_entsize(incr->relocs_entsize());
3600 
3601   // Add the .gnu_incremental_got_plt section.
3602   const char* incremental_got_plt_name =
3603     this->namepool_.add(".gnu_incremental_got_plt", false, NULL);
3604   Output_section* incremental_got_plt_os =
3605     this->make_output_section(incremental_got_plt_name,
3606 			      elfcpp::SHT_GNU_INCREMENTAL_GOT_PLT, 0,
3607 			      ORDER_INVALID, false);
3608   incremental_got_plt_os->add_output_section_data(incr->got_plt_section());
3609 
3610   // Add the .gnu_incremental_strtab section.
3611   const char* incremental_strtab_name =
3612     this->namepool_.add(".gnu_incremental_strtab", false, NULL);
3613   Output_section* incremental_strtab_os = this->make_output_section(incremental_strtab_name,
3614 							elfcpp::SHT_STRTAB, 0,
3615 							ORDER_INVALID, false);
3616   Output_data_strtab* strtab_data =
3617       new Output_data_strtab(incr->get_stringpool());
3618   incremental_strtab_os->add_output_section_data(strtab_data);
3619 
3620   incremental_inputs_os->set_after_input_sections();
3621   incremental_symtab_os->set_after_input_sections();
3622   incremental_relocs_os->set_after_input_sections();
3623   incremental_got_plt_os->set_after_input_sections();
3624 
3625   incremental_inputs_os->set_link_section(incremental_strtab_os);
3626   incremental_symtab_os->set_link_section(incremental_inputs_os);
3627   incremental_relocs_os->set_link_section(incremental_inputs_os);
3628   incremental_got_plt_os->set_link_section(incremental_inputs_os);
3629 }
3630 
3631 // Return whether SEG1 should be before SEG2 in the output file.  This
3632 // is based entirely on the segment type and flags.  When this is
3633 // called the segment addresses have normally not yet been set.
3634 
3635 bool
segment_precedes(const Output_segment * seg1,const Output_segment * seg2)3636 Layout::segment_precedes(const Output_segment* seg1,
3637 			 const Output_segment* seg2)
3638 {
3639   // In order to produce a stable ordering if we're called with the same pointer
3640   // return false.
3641   if (seg1 == seg2)
3642     return false;
3643 
3644   elfcpp::Elf_Word type1 = seg1->type();
3645   elfcpp::Elf_Word type2 = seg2->type();
3646 
3647   // The single PT_PHDR segment is required to precede any loadable
3648   // segment.  We simply make it always first.
3649   if (type1 == elfcpp::PT_PHDR)
3650     {
3651       gold_assert(type2 != elfcpp::PT_PHDR);
3652       return true;
3653     }
3654   if (type2 == elfcpp::PT_PHDR)
3655     return false;
3656 
3657   // The single PT_INTERP segment is required to precede any loadable
3658   // segment.  We simply make it always second.
3659   if (type1 == elfcpp::PT_INTERP)
3660     {
3661       gold_assert(type2 != elfcpp::PT_INTERP);
3662       return true;
3663     }
3664   if (type2 == elfcpp::PT_INTERP)
3665     return false;
3666 
3667   // We then put PT_LOAD segments before any other segments.
3668   if (type1 == elfcpp::PT_LOAD && type2 != elfcpp::PT_LOAD)
3669     return true;
3670   if (type2 == elfcpp::PT_LOAD && type1 != elfcpp::PT_LOAD)
3671     return false;
3672 
3673   // We put the PT_TLS segment last except for the PT_GNU_RELRO
3674   // segment, because that is where the dynamic linker expects to find
3675   // it (this is just for efficiency; other positions would also work
3676   // correctly).
3677   if (type1 == elfcpp::PT_TLS
3678       && type2 != elfcpp::PT_TLS
3679       && type2 != elfcpp::PT_GNU_RELRO)
3680     return false;
3681   if (type2 == elfcpp::PT_TLS
3682       && type1 != elfcpp::PT_TLS
3683       && type1 != elfcpp::PT_GNU_RELRO)
3684     return true;
3685 
3686   // We put the PT_GNU_RELRO segment last, because that is where the
3687   // dynamic linker expects to find it (as with PT_TLS, this is just
3688   // for efficiency).
3689   if (type1 == elfcpp::PT_GNU_RELRO && type2 != elfcpp::PT_GNU_RELRO)
3690     return false;
3691   if (type2 == elfcpp::PT_GNU_RELRO && type1 != elfcpp::PT_GNU_RELRO)
3692     return true;
3693 
3694   const elfcpp::Elf_Word flags1 = seg1->flags();
3695   const elfcpp::Elf_Word flags2 = seg2->flags();
3696 
3697   // The order of non-PT_LOAD segments is unimportant.  We simply sort
3698   // by the numeric segment type and flags values.  There should not
3699   // be more than one segment with the same type and flags, except
3700   // when a linker script specifies such.
3701   if (type1 != elfcpp::PT_LOAD)
3702     {
3703       if (type1 != type2)
3704 	return type1 < type2;
3705       gold_assert(flags1 != flags2
3706 		  || this->script_options_->saw_phdrs_clause());
3707       return flags1 < flags2;
3708     }
3709 
3710   // If the addresses are set already, sort by load address.
3711   if (seg1->are_addresses_set())
3712     {
3713       if (!seg2->are_addresses_set())
3714 	return true;
3715 
3716       unsigned int section_count1 = seg1->output_section_count();
3717       unsigned int section_count2 = seg2->output_section_count();
3718       if (section_count1 == 0 && section_count2 > 0)
3719 	return true;
3720       if (section_count1 > 0 && section_count2 == 0)
3721 	return false;
3722 
3723       uint64_t paddr1 =	(seg1->are_addresses_set()
3724 			 ? seg1->paddr()
3725 			 : seg1->first_section_load_address());
3726       uint64_t paddr2 =	(seg2->are_addresses_set()
3727 			 ? seg2->paddr()
3728 			 : seg2->first_section_load_address());
3729 
3730       if (paddr1 != paddr2)
3731 	return paddr1 < paddr2;
3732     }
3733   else if (seg2->are_addresses_set())
3734     return false;
3735 
3736   // A segment which holds large data comes after a segment which does
3737   // not hold large data.
3738   if (seg1->is_large_data_segment())
3739     {
3740       if (!seg2->is_large_data_segment())
3741 	return false;
3742     }
3743   else if (seg2->is_large_data_segment())
3744     return true;
3745 
3746   // Otherwise, we sort PT_LOAD segments based on the flags.  Readonly
3747   // segments come before writable segments.  Then writable segments
3748   // with data come before writable segments without data.  Then
3749   // executable segments come before non-executable segments.  Then
3750   // the unlikely case of a non-readable segment comes before the
3751   // normal case of a readable segment.  If there are multiple
3752   // segments with the same type and flags, we require that the
3753   // address be set, and we sort by virtual address and then physical
3754   // address.
3755   if ((flags1 & elfcpp::PF_W) != (flags2 & elfcpp::PF_W))
3756     return (flags1 & elfcpp::PF_W) == 0;
3757   if ((flags1 & elfcpp::PF_W) != 0
3758       && seg1->has_any_data_sections() != seg2->has_any_data_sections())
3759     return seg1->has_any_data_sections();
3760   if ((flags1 & elfcpp::PF_X) != (flags2 & elfcpp::PF_X))
3761     return (flags1 & elfcpp::PF_X) != 0;
3762   if ((flags1 & elfcpp::PF_R) != (flags2 & elfcpp::PF_R))
3763     return (flags1 & elfcpp::PF_R) == 0;
3764 
3765   // We shouldn't get here--we shouldn't create segments which we
3766   // can't distinguish.  Unless of course we are using a weird linker
3767   // script or overlapping --section-start options.  We could also get
3768   // here if plugins want unique segments for subsets of sections.
3769   gold_assert(this->script_options_->saw_phdrs_clause()
3770 	      || parameters->options().any_section_start()
3771 	      || this->is_unique_segment_for_sections_specified()
3772 	      || parameters->options().text_unlikely_segment());
3773   return false;
3774 }
3775 
3776 // Increase OFF so that it is congruent to ADDR modulo ABI_PAGESIZE.
3777 
3778 static off_t
align_file_offset(off_t off,uint64_t addr,uint64_t abi_pagesize)3779 align_file_offset(off_t off, uint64_t addr, uint64_t abi_pagesize)
3780 {
3781   uint64_t unsigned_off = off;
3782   uint64_t aligned_off = ((unsigned_off & ~(abi_pagesize - 1))
3783 			  | (addr & (abi_pagesize - 1)));
3784   if (aligned_off < unsigned_off)
3785     aligned_off += abi_pagesize;
3786   return aligned_off;
3787 }
3788 
3789 // On targets where the text segment contains only executable code,
3790 // a non-executable segment is never the text segment.
3791 
3792 static inline bool
is_text_segment(const Target * target,const Output_segment * seg)3793 is_text_segment(const Target* target, const Output_segment* seg)
3794 {
3795   elfcpp::Elf_Xword flags = seg->flags();
3796   if ((flags & elfcpp::PF_W) != 0)
3797     return false;
3798   if ((flags & elfcpp::PF_X) == 0)
3799     return !target->isolate_execinstr();
3800   return true;
3801 }
3802 
3803 // Set the file offsets of all the segments, and all the sections they
3804 // contain.  They have all been created.  LOAD_SEG must be laid out
3805 // first.  Return the offset of the data to follow.
3806 
3807 off_t
set_segment_offsets(const Target * target,Output_segment * load_seg,unsigned int * pshndx)3808 Layout::set_segment_offsets(const Target* target, Output_segment* load_seg,
3809 			    unsigned int* pshndx)
3810 {
3811   // Sort them into the final order.  We use a stable sort so that we
3812   // don't randomize the order of indistinguishable segments created
3813   // by linker scripts.
3814   std::stable_sort(this->segment_list_.begin(), this->segment_list_.end(),
3815 		   Layout::Compare_segments(this));
3816 
3817   // Find the PT_LOAD segments, and set their addresses and offsets
3818   // and their section's addresses and offsets.
3819   uint64_t start_addr;
3820   if (parameters->options().user_set_Ttext())
3821     start_addr = parameters->options().Ttext();
3822   else if (parameters->options().output_is_position_independent())
3823     start_addr = 0;
3824   else
3825     start_addr = target->default_text_segment_address();
3826 
3827   uint64_t addr = start_addr;
3828   off_t off = 0;
3829 
3830   // If LOAD_SEG is NULL, then the file header and segment headers
3831   // will not be loadable.  But they still need to be at offset 0 in
3832   // the file.  Set their offsets now.
3833   if (load_seg == NULL)
3834     {
3835       for (Data_list::iterator p = this->special_output_list_.begin();
3836 	   p != this->special_output_list_.end();
3837 	   ++p)
3838 	{
3839 	  off = align_address(off, (*p)->addralign());
3840 	  (*p)->set_address_and_file_offset(0, off);
3841 	  off += (*p)->data_size();
3842 	}
3843     }
3844 
3845   unsigned int increase_relro = this->increase_relro_;
3846   if (this->script_options_->saw_sections_clause())
3847     increase_relro = 0;
3848 
3849   const bool check_sections = parameters->options().check_sections();
3850   Output_segment* last_load_segment = NULL;
3851 
3852   unsigned int shndx_begin = *pshndx;
3853   unsigned int shndx_load_seg = *pshndx;
3854 
3855   for (Segment_list::iterator p = this->segment_list_.begin();
3856        p != this->segment_list_.end();
3857        ++p)
3858     {
3859       if ((*p)->type() == elfcpp::PT_LOAD)
3860 	{
3861 	  if (target->isolate_execinstr())
3862 	    {
3863 	      // When we hit the segment that should contain the
3864 	      // file headers, reset the file offset so we place
3865 	      // it and subsequent segments appropriately.
3866 	      // We'll fix up the preceding segments below.
3867 	      if (load_seg == *p)
3868 		{
3869 		  if (off == 0)
3870 		    load_seg = NULL;
3871 		  else
3872 		    {
3873 		      off = 0;
3874 		      shndx_load_seg = *pshndx;
3875 		    }
3876 		}
3877 	    }
3878 	  else
3879 	    {
3880 	      // Verify that the file headers fall into the first segment.
3881 	      if (load_seg != NULL && load_seg != *p)
3882 		gold_unreachable();
3883 	      load_seg = NULL;
3884 	    }
3885 
3886 	  bool are_addresses_set = (*p)->are_addresses_set();
3887 	  if (are_addresses_set)
3888 	    {
3889 	      // When it comes to setting file offsets, we care about
3890 	      // the physical address.
3891 	      addr = (*p)->paddr();
3892 	    }
3893 	  else if (parameters->options().user_set_Ttext()
3894 		   && (parameters->options().omagic()
3895 		       || is_text_segment(target, *p)))
3896 	    {
3897 	      are_addresses_set = true;
3898 	    }
3899 	  else if (parameters->options().user_set_Trodata_segment()
3900 		   && ((*p)->flags() & (elfcpp::PF_W | elfcpp::PF_X)) == 0)
3901 	    {
3902 	      addr = parameters->options().Trodata_segment();
3903 	      are_addresses_set = true;
3904 	    }
3905 	  else if (parameters->options().user_set_Tdata()
3906 		   && ((*p)->flags() & elfcpp::PF_W) != 0
3907 		   && (!parameters->options().user_set_Tbss()
3908 		       || (*p)->has_any_data_sections()))
3909 	    {
3910 	      addr = parameters->options().Tdata();
3911 	      are_addresses_set = true;
3912 	    }
3913 	  else if (parameters->options().user_set_Tbss()
3914 		   && ((*p)->flags() & elfcpp::PF_W) != 0
3915 		   && !(*p)->has_any_data_sections())
3916 	    {
3917 	      addr = parameters->options().Tbss();
3918 	      are_addresses_set = true;
3919 	    }
3920 
3921 	  uint64_t orig_addr = addr;
3922 	  uint64_t orig_off = off;
3923 
3924 	  uint64_t aligned_addr = 0;
3925 	  uint64_t abi_pagesize = target->abi_pagesize();
3926 	  uint64_t common_pagesize = target->common_pagesize();
3927 
3928 	  if (!parameters->options().nmagic()
3929 	      && !parameters->options().omagic())
3930 	    (*p)->set_minimum_p_align(abi_pagesize);
3931 
3932 	  if (!are_addresses_set)
3933 	    {
3934 	      // Skip the address forward one page, maintaining the same
3935 	      // position within the page.  This lets us store both segments
3936 	      // overlapping on a single page in the file, but the loader will
3937 	      // put them on different pages in memory. We will revisit this
3938 	      // decision once we know the size of the segment.
3939 
3940 	      uint64_t max_align = (*p)->maximum_alignment();
3941 	      if (max_align > abi_pagesize)
3942 		addr = align_address(addr, max_align);
3943 	      aligned_addr = addr;
3944 
3945 	      if (load_seg == *p)
3946 		{
3947 		  // This is the segment that will contain the file
3948 		  // headers, so its offset will have to be exactly zero.
3949 		  gold_assert(orig_off == 0);
3950 
3951 		  // If the target wants a fixed minimum distance from the
3952 		  // text segment to the read-only segment, move up now.
3953 		  uint64_t min_addr =
3954 		    start_addr + (parameters->options().user_set_rosegment_gap()
3955 				  ? parameters->options().rosegment_gap()
3956 				  : target->rosegment_gap());
3957 		  if (addr < min_addr)
3958 		    addr = min_addr;
3959 
3960 		  // But this is not the first segment!  To make its
3961 		  // address congruent with its offset, that address better
3962 		  // be aligned to the ABI-mandated page size.
3963 		  addr = align_address(addr, abi_pagesize);
3964 		  aligned_addr = addr;
3965 		}
3966 	      else
3967 		{
3968 		  if ((addr & (abi_pagesize - 1)) != 0)
3969 		    addr = addr + abi_pagesize;
3970 
3971 		  off = orig_off + ((addr - orig_addr) & (abi_pagesize - 1));
3972 		}
3973 	    }
3974 
3975 	  if (!parameters->options().nmagic()
3976 	      && !parameters->options().omagic())
3977 	    {
3978 	      // Here we are also taking care of the case when
3979 	      // the maximum segment alignment is larger than the page size.
3980 	      off = align_file_offset(off, addr,
3981 				      std::max(abi_pagesize,
3982 					       (*p)->maximum_alignment()));
3983 	    }
3984 	  else
3985 	    {
3986 	      // This is -N or -n with a section script which prevents
3987 	      // us from using a load segment.  We need to ensure that
3988 	      // the file offset is aligned to the alignment of the
3989 	      // segment.  This is because the linker script
3990 	      // implicitly assumed a zero offset.  If we don't align
3991 	      // here, then the alignment of the sections in the
3992 	      // linker script may not match the alignment of the
3993 	      // sections in the set_section_addresses call below,
3994 	      // causing an error about dot moving backward.
3995 	      off = align_address(off, (*p)->maximum_alignment());
3996 	    }
3997 
3998 	  unsigned int shndx_hold = *pshndx;
3999 	  bool has_relro = false;
4000 	  uint64_t new_addr = (*p)->set_section_addresses(target, this,
4001 							  false, addr,
4002 							  &increase_relro,
4003 							  &has_relro,
4004 							  &off, pshndx);
4005 
4006 	  // Now that we know the size of this segment, we may be able
4007 	  // to save a page in memory, at the cost of wasting some
4008 	  // file space, by instead aligning to the start of a new
4009 	  // page.  Here we use the real machine page size rather than
4010 	  // the ABI mandated page size.  If the segment has been
4011 	  // aligned so that the relro data ends at a page boundary,
4012 	  // we do not try to realign it.
4013 
4014 	  if (!are_addresses_set
4015 	      && !has_relro
4016 	      && aligned_addr != addr
4017 	      && !parameters->incremental())
4018 	    {
4019 	      uint64_t first_off = (common_pagesize
4020 				    - (aligned_addr
4021 				       & (common_pagesize - 1)));
4022 	      uint64_t last_off = new_addr & (common_pagesize - 1);
4023 	      if (first_off > 0
4024 		  && last_off > 0
4025 		  && ((aligned_addr & ~ (common_pagesize - 1))
4026 		      != (new_addr & ~ (common_pagesize - 1)))
4027 		  && first_off + last_off <= common_pagesize)
4028 		{
4029 		  *pshndx = shndx_hold;
4030 		  addr = align_address(aligned_addr, common_pagesize);
4031 		  addr = align_address(addr, (*p)->maximum_alignment());
4032 		  if ((addr & (abi_pagesize - 1)) != 0)
4033 		    addr = addr + abi_pagesize;
4034 		  off = orig_off + ((addr - orig_addr) & (abi_pagesize - 1));
4035 		  off = align_file_offset(off, addr, abi_pagesize);
4036 
4037 		  increase_relro = this->increase_relro_;
4038 		  if (this->script_options_->saw_sections_clause())
4039 		    increase_relro = 0;
4040 		  has_relro = false;
4041 
4042 		  new_addr = (*p)->set_section_addresses(target, this,
4043 							 true, addr,
4044 							 &increase_relro,
4045 							 &has_relro,
4046 							 &off, pshndx);
4047 		}
4048 	    }
4049 
4050 	  addr = new_addr;
4051 
4052 	  // Implement --check-sections.  We know that the segments
4053 	  // are sorted by LMA.
4054 	  if (check_sections && last_load_segment != NULL)
4055 	    {
4056 	      gold_assert(last_load_segment->paddr() <= (*p)->paddr());
4057 	      if (last_load_segment->paddr() + last_load_segment->memsz()
4058 		  > (*p)->paddr())
4059 		{
4060 		  unsigned long long lb1 = last_load_segment->paddr();
4061 		  unsigned long long le1 = lb1 + last_load_segment->memsz();
4062 		  unsigned long long lb2 = (*p)->paddr();
4063 		  unsigned long long le2 = lb2 + (*p)->memsz();
4064 		  gold_error(_("load segment overlap [0x%llx -> 0x%llx] and "
4065 			       "[0x%llx -> 0x%llx]"),
4066 			     lb1, le1, lb2, le2);
4067 		}
4068 	    }
4069 	  last_load_segment = *p;
4070 	}
4071     }
4072 
4073   if (load_seg != NULL && target->isolate_execinstr())
4074     {
4075       // Process the early segments again, setting their file offsets
4076       // so they land after the segments starting at LOAD_SEG.
4077       off = align_file_offset(off, 0, target->abi_pagesize());
4078 
4079       this->reset_relax_output();
4080 
4081       for (Segment_list::iterator p = this->segment_list_.begin();
4082 	   *p != load_seg;
4083 	   ++p)
4084 	{
4085 	  if ((*p)->type() == elfcpp::PT_LOAD)
4086 	    {
4087 	      // We repeat the whole job of assigning addresses and
4088 	      // offsets, but we really only want to change the offsets and
4089 	      // must ensure that the addresses all come out the same as
4090 	      // they did the first time through.
4091 	      bool has_relro = false;
4092 	      const uint64_t old_addr = (*p)->vaddr();
4093 	      const uint64_t old_end = old_addr + (*p)->memsz();
4094 	      uint64_t new_addr = (*p)->set_section_addresses(target, this,
4095 							      true, old_addr,
4096 							      &increase_relro,
4097 							      &has_relro,
4098 							      &off,
4099 							      &shndx_begin);
4100 	      gold_assert(new_addr == old_end);
4101 	    }
4102 	}
4103 
4104       gold_assert(shndx_begin == shndx_load_seg);
4105     }
4106 
4107   // Handle the non-PT_LOAD segments, setting their offsets from their
4108   // section's offsets.
4109   for (Segment_list::iterator p = this->segment_list_.begin();
4110        p != this->segment_list_.end();
4111        ++p)
4112     {
4113       // PT_GNU_STACK was set up correctly when it was created.
4114       if ((*p)->type() != elfcpp::PT_LOAD
4115 	  && (*p)->type() != elfcpp::PT_GNU_STACK)
4116 	(*p)->set_offset((*p)->type() == elfcpp::PT_GNU_RELRO
4117 			 ? increase_relro
4118 			 : 0);
4119     }
4120 
4121   // Set the TLS offsets for each section in the PT_TLS segment.
4122   if (this->tls_segment_ != NULL)
4123     this->tls_segment_->set_tls_offsets();
4124 
4125   return off;
4126 }
4127 
4128 // Set the offsets of all the allocated sections when doing a
4129 // relocatable link.  This does the same jobs as set_segment_offsets,
4130 // only for a relocatable link.
4131 
4132 off_t
set_relocatable_section_offsets(Output_data * file_header,unsigned int * pshndx)4133 Layout::set_relocatable_section_offsets(Output_data* file_header,
4134 					unsigned int* pshndx)
4135 {
4136   off_t off = 0;
4137 
4138   file_header->set_address_and_file_offset(0, 0);
4139   off += file_header->data_size();
4140 
4141   for (Section_list::iterator p = this->section_list_.begin();
4142        p != this->section_list_.end();
4143        ++p)
4144     {
4145       // We skip unallocated sections here, except that group sections
4146       // have to come first.
4147       if (((*p)->flags() & elfcpp::SHF_ALLOC) == 0
4148 	  && (*p)->type() != elfcpp::SHT_GROUP)
4149 	continue;
4150 
4151       off = align_address(off, (*p)->addralign());
4152 
4153       // The linker script might have set the address.
4154       if (!(*p)->is_address_valid())
4155 	(*p)->set_address(0);
4156       (*p)->set_file_offset(off);
4157       (*p)->finalize_data_size();
4158       if ((*p)->type() != elfcpp::SHT_NOBITS)
4159 	off += (*p)->data_size();
4160 
4161       (*p)->set_out_shndx(*pshndx);
4162       ++*pshndx;
4163     }
4164 
4165   return off;
4166 }
4167 
4168 // Set the file offset of all the sections not associated with a
4169 // segment.
4170 
4171 off_t
set_section_offsets(off_t off,Layout::Section_offset_pass pass)4172 Layout::set_section_offsets(off_t off, Layout::Section_offset_pass pass)
4173 {
4174   off_t startoff = off;
4175   off_t maxoff = off;
4176 
4177   for (Section_list::iterator p = this->unattached_section_list_.begin();
4178        p != this->unattached_section_list_.end();
4179        ++p)
4180     {
4181       // The symtab section is handled in create_symtab_sections.
4182       if (*p == this->symtab_section_)
4183 	continue;
4184 
4185       // If we've already set the data size, don't set it again.
4186       if ((*p)->is_offset_valid() && (*p)->is_data_size_valid())
4187 	continue;
4188 
4189       if (pass == BEFORE_INPUT_SECTIONS_PASS
4190 	  && (*p)->requires_postprocessing())
4191 	{
4192 	  (*p)->create_postprocessing_buffer();
4193 	  this->any_postprocessing_sections_ = true;
4194 	}
4195 
4196       if (pass == BEFORE_INPUT_SECTIONS_PASS
4197 	  && (*p)->after_input_sections())
4198 	continue;
4199       else if (pass == POSTPROCESSING_SECTIONS_PASS
4200 	       && (!(*p)->after_input_sections()
4201 		   || (*p)->type() == elfcpp::SHT_STRTAB))
4202 	continue;
4203       else if (pass == STRTAB_AFTER_POSTPROCESSING_SECTIONS_PASS
4204 	       && (!(*p)->after_input_sections()
4205 		   || (*p)->type() != elfcpp::SHT_STRTAB))
4206 	continue;
4207 
4208       if (!parameters->incremental_update())
4209 	{
4210 	  off = align_address(off, (*p)->addralign());
4211 	  (*p)->set_file_offset(off);
4212 	  (*p)->finalize_data_size();
4213 	}
4214       else
4215 	{
4216 	  // Incremental update: allocate file space from free list.
4217 	  (*p)->pre_finalize_data_size();
4218 	  off_t current_size = (*p)->current_data_size();
4219 	  off = this->allocate(current_size, (*p)->addralign(), startoff);
4220 	  if (off == -1)
4221 	    {
4222 	      if (is_debugging_enabled(DEBUG_INCREMENTAL))
4223 		this->free_list_.dump();
4224 	      gold_assert((*p)->output_section() != NULL);
4225 	      gold_fallback(_("out of patch space for section %s; "
4226 			      "relink with --incremental-full"),
4227 			    (*p)->output_section()->name());
4228 	    }
4229 	  (*p)->set_file_offset(off);
4230 	  (*p)->finalize_data_size();
4231 	  if ((*p)->data_size() > current_size)
4232 	    {
4233 	      gold_assert((*p)->output_section() != NULL);
4234 	      gold_fallback(_("%s: section changed size; "
4235 			      "relink with --incremental-full"),
4236 			    (*p)->output_section()->name());
4237 	    }
4238 	  gold_debug(DEBUG_INCREMENTAL,
4239 		     "set_section_offsets: %08lx %08lx %s",
4240 		     static_cast<long>(off),
4241 		     static_cast<long>((*p)->data_size()),
4242 		     ((*p)->output_section() != NULL
4243 		      ? (*p)->output_section()->name() : "(special)"));
4244 	}
4245 
4246       off += (*p)->data_size();
4247       if (off > maxoff)
4248 	maxoff = off;
4249 
4250       // At this point the name must be set.
4251       if (pass != STRTAB_AFTER_POSTPROCESSING_SECTIONS_PASS)
4252 	this->namepool_.add((*p)->name(), false, NULL);
4253     }
4254   return maxoff;
4255 }
4256 
4257 // Set the section indexes of all the sections not associated with a
4258 // segment.
4259 
4260 unsigned int
set_section_indexes(unsigned int shndx)4261 Layout::set_section_indexes(unsigned int shndx)
4262 {
4263   for (Section_list::iterator p = this->unattached_section_list_.begin();
4264        p != this->unattached_section_list_.end();
4265        ++p)
4266     {
4267       if (!(*p)->has_out_shndx())
4268 	{
4269 	  (*p)->set_out_shndx(shndx);
4270 	  ++shndx;
4271 	}
4272     }
4273   return shndx;
4274 }
4275 
4276 // Set the section addresses according to the linker script.  This is
4277 // only called when we see a SECTIONS clause.  This returns the
4278 // program segment which should hold the file header and segment
4279 // headers, if any.  It will return NULL if they should not be in a
4280 // segment.
4281 
4282 Output_segment*
set_section_addresses_from_script(Symbol_table * symtab)4283 Layout::set_section_addresses_from_script(Symbol_table* symtab)
4284 {
4285   Script_sections* ss = this->script_options_->script_sections();
4286   gold_assert(ss->saw_sections_clause());
4287   return this->script_options_->set_section_addresses(symtab, this);
4288 }
4289 
4290 // Place the orphan sections in the linker script.
4291 
4292 void
place_orphan_sections_in_script()4293 Layout::place_orphan_sections_in_script()
4294 {
4295   Script_sections* ss = this->script_options_->script_sections();
4296   gold_assert(ss->saw_sections_clause());
4297 
4298   // Place each orphaned output section in the script.
4299   for (Section_list::iterator p = this->section_list_.begin();
4300        p != this->section_list_.end();
4301        ++p)
4302     {
4303       if (!(*p)->found_in_sections_clause())
4304 	ss->place_orphan(*p);
4305     }
4306 }
4307 
4308 // Count the local symbols in the regular symbol table and the dynamic
4309 // symbol table, and build the respective string pools.
4310 
4311 void
count_local_symbols(const Task * task,const Input_objects * input_objects)4312 Layout::count_local_symbols(const Task* task,
4313 			    const Input_objects* input_objects)
4314 {
4315   // First, figure out an upper bound on the number of symbols we'll
4316   // be inserting into each pool.  This helps us create the pools with
4317   // the right size, to avoid unnecessary hashtable resizing.
4318   unsigned int symbol_count = 0;
4319   for (Input_objects::Relobj_iterator p = input_objects->relobj_begin();
4320        p != input_objects->relobj_end();
4321        ++p)
4322     symbol_count += (*p)->local_symbol_count();
4323 
4324   // Go from "upper bound" to "estimate."  We overcount for two
4325   // reasons: we double-count symbols that occur in more than one
4326   // object file, and we count symbols that are dropped from the
4327   // output.  Add it all together and assume we overcount by 100%.
4328   symbol_count /= 2;
4329 
4330   // We assume all symbols will go into both the sympool and dynpool.
4331   this->sympool_.reserve(symbol_count);
4332   this->dynpool_.reserve(symbol_count);
4333 
4334   for (Input_objects::Relobj_iterator p = input_objects->relobj_begin();
4335        p != input_objects->relobj_end();
4336        ++p)
4337     {
4338       Task_lock_obj<Object> tlo(task, *p);
4339       (*p)->count_local_symbols(&this->sympool_, &this->dynpool_);
4340     }
4341 }
4342 
4343 // Create the symbol table sections.  Here we also set the final
4344 // values of the symbols.  At this point all the loadable sections are
4345 // fully laid out.  SHNUM is the number of sections so far.
4346 
4347 void
create_symtab_sections(const Input_objects * input_objects,Symbol_table * symtab,unsigned int shnum,off_t * poff,unsigned int local_dynamic_count)4348 Layout::create_symtab_sections(const Input_objects* input_objects,
4349 			       Symbol_table* symtab,
4350 			       unsigned int shnum,
4351 			       off_t* poff,
4352 			       unsigned int local_dynamic_count)
4353 {
4354   int symsize;
4355   unsigned int align;
4356   if (parameters->target().get_size() == 32)
4357     {
4358       symsize = elfcpp::Elf_sizes<32>::sym_size;
4359       align = 4;
4360     }
4361   else if (parameters->target().get_size() == 64)
4362     {
4363       symsize = elfcpp::Elf_sizes<64>::sym_size;
4364       align = 8;
4365     }
4366   else
4367     gold_unreachable();
4368 
4369   // Compute file offsets relative to the start of the symtab section.
4370   off_t off = 0;
4371 
4372   // Save space for the dummy symbol at the start of the section.  We
4373   // never bother to write this out--it will just be left as zero.
4374   off += symsize;
4375   unsigned int local_symbol_index = 1;
4376 
4377   // Add STT_SECTION symbols for each Output section which needs one.
4378   for (Section_list::iterator p = this->section_list_.begin();
4379        p != this->section_list_.end();
4380        ++p)
4381     {
4382       if (!(*p)->needs_symtab_index())
4383 	(*p)->set_symtab_index(-1U);
4384       else
4385 	{
4386 	  (*p)->set_symtab_index(local_symbol_index);
4387 	  ++local_symbol_index;
4388 	  off += symsize;
4389 	}
4390     }
4391 
4392   for (Input_objects::Relobj_iterator p = input_objects->relobj_begin();
4393        p != input_objects->relobj_end();
4394        ++p)
4395     {
4396       unsigned int index = (*p)->finalize_local_symbols(local_symbol_index,
4397 							off, symtab);
4398       off += (index - local_symbol_index) * symsize;
4399       local_symbol_index = index;
4400     }
4401 
4402   unsigned int local_symcount = local_symbol_index;
4403   gold_assert(static_cast<off_t>(local_symcount * symsize) == off);
4404 
4405   off_t dynoff;
4406   size_t dyncount;
4407   if (this->dynsym_section_ == NULL)
4408     {
4409       dynoff = 0;
4410       dyncount = 0;
4411     }
4412   else
4413     {
4414       off_t locsize = local_dynamic_count * this->dynsym_section_->entsize();
4415       dynoff = this->dynsym_section_->offset() + locsize;
4416       dyncount = (this->dynsym_section_->data_size() - locsize) / symsize;
4417       gold_assert(static_cast<off_t>(dyncount * symsize)
4418 		  == this->dynsym_section_->data_size() - locsize);
4419     }
4420 
4421   off_t global_off = off;
4422   off = symtab->finalize(off, dynoff, local_dynamic_count, dyncount,
4423 			 &this->sympool_, &local_symcount);
4424 
4425   if (!parameters->options().strip_all())
4426     {
4427       this->sympool_.set_string_offsets();
4428 
4429       const char* symtab_name = this->namepool_.add(".symtab", false, NULL);
4430       Output_section* osymtab = this->make_output_section(symtab_name,
4431 							  elfcpp::SHT_SYMTAB,
4432 							  0, ORDER_INVALID,
4433 							  false);
4434       this->symtab_section_ = osymtab;
4435 
4436       Output_section_data* pos = new Output_data_fixed_space(off, align,
4437 							     "** symtab");
4438       osymtab->add_output_section_data(pos);
4439 
4440       // We generate a .symtab_shndx section if we have more than
4441       // SHN_LORESERVE sections.  Technically it is possible that we
4442       // don't need one, because it is possible that there are no
4443       // symbols in any of sections with indexes larger than
4444       // SHN_LORESERVE.  That is probably unusual, though, and it is
4445       // easier to always create one than to compute section indexes
4446       // twice (once here, once when writing out the symbols).
4447       if (shnum >= elfcpp::SHN_LORESERVE)
4448 	{
4449 	  const char* symtab_xindex_name = this->namepool_.add(".symtab_shndx",
4450 							       false, NULL);
4451 	  Output_section* osymtab_xindex =
4452 	    this->make_output_section(symtab_xindex_name,
4453 				      elfcpp::SHT_SYMTAB_SHNDX, 0,
4454 				      ORDER_INVALID, false);
4455 
4456 	  size_t symcount = off / symsize;
4457 	  this->symtab_xindex_ = new Output_symtab_xindex(symcount);
4458 
4459 	  osymtab_xindex->add_output_section_data(this->symtab_xindex_);
4460 
4461 	  osymtab_xindex->set_link_section(osymtab);
4462 	  osymtab_xindex->set_addralign(4);
4463 	  osymtab_xindex->set_entsize(4);
4464 
4465 	  osymtab_xindex->set_after_input_sections();
4466 
4467 	  // This tells the driver code to wait until the symbol table
4468 	  // has written out before writing out the postprocessing
4469 	  // sections, including the .symtab_shndx section.
4470 	  this->any_postprocessing_sections_ = true;
4471 	}
4472 
4473       const char* strtab_name = this->namepool_.add(".strtab", false, NULL);
4474       Output_section* ostrtab = this->make_output_section(strtab_name,
4475 							  elfcpp::SHT_STRTAB,
4476 							  0, ORDER_INVALID,
4477 							  false);
4478 
4479       Output_section_data* pstr = new Output_data_strtab(&this->sympool_);
4480       ostrtab->add_output_section_data(pstr);
4481 
4482       off_t symtab_off;
4483       if (!parameters->incremental_update())
4484 	symtab_off = align_address(*poff, align);
4485       else
4486 	{
4487 	  symtab_off = this->allocate(off, align, *poff);
4488 	  if (off == -1)
4489 	    gold_fallback(_("out of patch space for symbol table; "
4490 			    "relink with --incremental-full"));
4491 	  gold_debug(DEBUG_INCREMENTAL,
4492 		     "create_symtab_sections: %08lx %08lx .symtab",
4493 		     static_cast<long>(symtab_off),
4494 		     static_cast<long>(off));
4495 	}
4496 
4497       symtab->set_file_offset(symtab_off + global_off);
4498       osymtab->set_file_offset(symtab_off);
4499       osymtab->finalize_data_size();
4500       osymtab->set_link_section(ostrtab);
4501       osymtab->set_info(local_symcount);
4502       osymtab->set_entsize(symsize);
4503 
4504       if (symtab_off + off > *poff)
4505 	*poff = symtab_off + off;
4506     }
4507 }
4508 
4509 // Create the .shstrtab section, which holds the names of the
4510 // sections.  At the time this is called, we have created all the
4511 // output sections except .shstrtab itself.
4512 
4513 Output_section*
create_shstrtab()4514 Layout::create_shstrtab()
4515 {
4516   // FIXME: We don't need to create a .shstrtab section if we are
4517   // stripping everything.
4518 
4519   const char* name = this->namepool_.add(".shstrtab", false, NULL);
4520 
4521   Output_section* os = this->make_output_section(name, elfcpp::SHT_STRTAB, 0,
4522 						 ORDER_INVALID, false);
4523 
4524   if (strcmp(parameters->options().compress_debug_sections(), "none") != 0)
4525     {
4526       // We can't write out this section until we've set all the
4527       // section names, and we don't set the names of compressed
4528       // output sections until relocations are complete.  FIXME: With
4529       // the current names we use, this is unnecessary.
4530       os->set_after_input_sections();
4531     }
4532 
4533   Output_section_data* posd = new Output_data_strtab(&this->namepool_);
4534   os->add_output_section_data(posd);
4535 
4536   return os;
4537 }
4538 
4539 // Create the section headers.  SIZE is 32 or 64.  OFF is the file
4540 // offset.
4541 
4542 void
create_shdrs(const Output_section * shstrtab_section,off_t * poff)4543 Layout::create_shdrs(const Output_section* shstrtab_section, off_t* poff)
4544 {
4545   Output_section_headers* oshdrs;
4546   oshdrs = new Output_section_headers(this,
4547 				      &this->segment_list_,
4548 				      &this->section_list_,
4549 				      &this->unattached_section_list_,
4550 				      &this->namepool_,
4551 				      shstrtab_section);
4552   off_t off;
4553   if (!parameters->incremental_update())
4554     off = align_address(*poff, oshdrs->addralign());
4555   else
4556     {
4557       oshdrs->pre_finalize_data_size();
4558       off = this->allocate(oshdrs->data_size(), oshdrs->addralign(), *poff);
4559       if (off == -1)
4560 	  gold_fallback(_("out of patch space for section header table; "
4561 			  "relink with --incremental-full"));
4562       gold_debug(DEBUG_INCREMENTAL,
4563 		 "create_shdrs: %08lx %08lx (section header table)",
4564 		 static_cast<long>(off),
4565 		 static_cast<long>(off + oshdrs->data_size()));
4566     }
4567   oshdrs->set_address_and_file_offset(0, off);
4568   off += oshdrs->data_size();
4569   if (off > *poff)
4570     *poff = off;
4571   this->section_headers_ = oshdrs;
4572 }
4573 
4574 // Count the allocated sections.
4575 
4576 size_t
allocated_output_section_count() const4577 Layout::allocated_output_section_count() const
4578 {
4579   size_t section_count = 0;
4580   for (Segment_list::const_iterator p = this->segment_list_.begin();
4581        p != this->segment_list_.end();
4582        ++p)
4583     section_count += (*p)->output_section_count();
4584   return section_count;
4585 }
4586 
4587 // Create the dynamic symbol table.
4588 // *PLOCAL_DYNAMIC_COUNT will be set to the number of local symbols
4589 // from input objects, and *PFORCED_LOCAL_DYNAMIC_COUNT will be set
4590 // to the number of global symbols that have been forced local.
4591 // We need to remember the former because the forced-local symbols are
4592 // written along with the global symbols in Symtab::write_globals().
4593 
4594 void
create_dynamic_symtab(const Input_objects * input_objects,Symbol_table * symtab,Output_section ** pdynstr,unsigned int * plocal_dynamic_count,unsigned int * pforced_local_dynamic_count,std::vector<Symbol * > * pdynamic_symbols,Versions * pversions)4595 Layout::create_dynamic_symtab(const Input_objects* input_objects,
4596 			      Symbol_table* symtab,
4597 			      Output_section** pdynstr,
4598 			      unsigned int* plocal_dynamic_count,
4599 			      unsigned int* pforced_local_dynamic_count,
4600 			      std::vector<Symbol*>* pdynamic_symbols,
4601 			      Versions* pversions)
4602 {
4603   // Count all the symbols in the dynamic symbol table, and set the
4604   // dynamic symbol indexes.
4605 
4606   // Skip symbol 0, which is always all zeroes.
4607   unsigned int index = 1;
4608 
4609   // Add STT_SECTION symbols for each Output section which needs one.
4610   for (Section_list::iterator p = this->section_list_.begin();
4611        p != this->section_list_.end();
4612        ++p)
4613     {
4614       if (!(*p)->needs_dynsym_index())
4615 	(*p)->set_dynsym_index(-1U);
4616       else
4617 	{
4618 	  (*p)->set_dynsym_index(index);
4619 	  ++index;
4620 	}
4621     }
4622 
4623   // Count the local symbols that need to go in the dynamic symbol table,
4624   // and set the dynamic symbol indexes.
4625   for (Input_objects::Relobj_iterator p = input_objects->relobj_begin();
4626        p != input_objects->relobj_end();
4627        ++p)
4628     {
4629       unsigned int new_index = (*p)->set_local_dynsym_indexes(index);
4630       index = new_index;
4631     }
4632 
4633   unsigned int local_symcount = index;
4634   unsigned int forced_local_count = 0;
4635 
4636   index = symtab->set_dynsym_indexes(index, &forced_local_count,
4637 				     pdynamic_symbols, &this->dynpool_,
4638 				     pversions);
4639 
4640   *plocal_dynamic_count = local_symcount;
4641   *pforced_local_dynamic_count = forced_local_count;
4642 
4643   int symsize;
4644   unsigned int align;
4645   const int size = parameters->target().get_size();
4646   if (size == 32)
4647     {
4648       symsize = elfcpp::Elf_sizes<32>::sym_size;
4649       align = 4;
4650     }
4651   else if (size == 64)
4652     {
4653       symsize = elfcpp::Elf_sizes<64>::sym_size;
4654       align = 8;
4655     }
4656   else
4657     gold_unreachable();
4658 
4659   // Create the dynamic symbol table section.
4660 
4661   Output_section* dynsym = this->choose_output_section(NULL, ".dynsym",
4662 						       elfcpp::SHT_DYNSYM,
4663 						       elfcpp::SHF_ALLOC,
4664 						       false,
4665 						       ORDER_DYNAMIC_LINKER,
4666 						       false, false, false);
4667 
4668   // Check for NULL as a linker script may discard .dynsym.
4669   if (dynsym != NULL)
4670     {
4671       Output_section_data* odata = new Output_data_fixed_space(index * symsize,
4672 							       align,
4673 							       "** dynsym");
4674       dynsym->add_output_section_data(odata);
4675 
4676       dynsym->set_info(local_symcount + forced_local_count);
4677       dynsym->set_entsize(symsize);
4678       dynsym->set_addralign(align);
4679 
4680       this->dynsym_section_ = dynsym;
4681     }
4682 
4683   Output_data_dynamic* const odyn = this->dynamic_data_;
4684   if (odyn != NULL)
4685     {
4686       odyn->add_section_address(elfcpp::DT_SYMTAB, dynsym);
4687       odyn->add_constant(elfcpp::DT_SYMENT, symsize);
4688     }
4689 
4690   // If there are more than SHN_LORESERVE allocated sections, we
4691   // create a .dynsym_shndx section.  It is possible that we don't
4692   // need one, because it is possible that there are no dynamic
4693   // symbols in any of the sections with indexes larger than
4694   // SHN_LORESERVE.  This is probably unusual, though, and at this
4695   // time we don't know the actual section indexes so it is
4696   // inconvenient to check.
4697   if (this->allocated_output_section_count() >= elfcpp::SHN_LORESERVE)
4698     {
4699       Output_section* dynsym_xindex =
4700 	this->choose_output_section(NULL, ".dynsym_shndx",
4701 				    elfcpp::SHT_SYMTAB_SHNDX,
4702 				    elfcpp::SHF_ALLOC,
4703 				    false, ORDER_DYNAMIC_LINKER, false, false,
4704 				    false);
4705 
4706       if (dynsym_xindex != NULL)
4707 	{
4708 	  this->dynsym_xindex_ = new Output_symtab_xindex(index);
4709 
4710 	  dynsym_xindex->add_output_section_data(this->dynsym_xindex_);
4711 
4712 	  dynsym_xindex->set_link_section(dynsym);
4713 	  dynsym_xindex->set_addralign(4);
4714 	  dynsym_xindex->set_entsize(4);
4715 
4716 	  dynsym_xindex->set_after_input_sections();
4717 
4718 	  // This tells the driver code to wait until the symbol table
4719 	  // has written out before writing out the postprocessing
4720 	  // sections, including the .dynsym_shndx section.
4721 	  this->any_postprocessing_sections_ = true;
4722 	}
4723     }
4724 
4725   // Create the dynamic string table section.
4726 
4727   Output_section* dynstr = this->choose_output_section(NULL, ".dynstr",
4728 						       elfcpp::SHT_STRTAB,
4729 						       elfcpp::SHF_ALLOC,
4730 						       false,
4731 						       ORDER_DYNAMIC_LINKER,
4732 						       false, false, false);
4733   *pdynstr = dynstr;
4734   if (dynstr != NULL)
4735     {
4736       Output_section_data* strdata = new Output_data_strtab(&this->dynpool_);
4737       dynstr->add_output_section_data(strdata);
4738 
4739       if (dynsym != NULL)
4740 	dynsym->set_link_section(dynstr);
4741       if (this->dynamic_section_ != NULL)
4742 	this->dynamic_section_->set_link_section(dynstr);
4743 
4744       if (odyn != NULL)
4745 	{
4746 	  odyn->add_section_address(elfcpp::DT_STRTAB, dynstr);
4747 	  odyn->add_section_size(elfcpp::DT_STRSZ, dynstr);
4748 	}
4749     }
4750 
4751   // Create the hash tables.  The Gnu-style hash table must be
4752   // built first, because it changes the order of the symbols
4753   // in the dynamic symbol table.
4754 
4755   if (strcmp(parameters->options().hash_style(), "gnu") == 0
4756       || strcmp(parameters->options().hash_style(), "both") == 0)
4757     {
4758       unsigned char* phash;
4759       unsigned int hashlen;
4760       Dynobj::create_gnu_hash_table(*pdynamic_symbols,
4761 				    local_symcount + forced_local_count,
4762 				    &phash, &hashlen);
4763 
4764       Output_section* hashsec =
4765 	this->choose_output_section(NULL, ".gnu.hash", elfcpp::SHT_GNU_HASH,
4766 				    elfcpp::SHF_ALLOC, false,
4767 				    ORDER_DYNAMIC_LINKER, false, false,
4768 				    false);
4769 
4770       Output_section_data* hashdata = new Output_data_const_buffer(phash,
4771 								   hashlen,
4772 								   align,
4773 								   "** hash");
4774       if (hashsec != NULL && hashdata != NULL)
4775 	hashsec->add_output_section_data(hashdata);
4776 
4777       if (hashsec != NULL)
4778 	{
4779 	  if (dynsym != NULL)
4780 	    hashsec->set_link_section(dynsym);
4781 
4782 	  // For a 64-bit target, the entries in .gnu.hash do not have
4783 	  // a uniform size, so we only set the entry size for a
4784 	  // 32-bit target.
4785 	  if (parameters->target().get_size() == 32)
4786 	    hashsec->set_entsize(4);
4787 
4788 	  if (odyn != NULL)
4789 	    odyn->add_section_address(elfcpp::DT_GNU_HASH, hashsec);
4790 	}
4791     }
4792 
4793   if (strcmp(parameters->options().hash_style(), "sysv") == 0
4794       || strcmp(parameters->options().hash_style(), "both") == 0)
4795     {
4796       unsigned char* phash;
4797       unsigned int hashlen;
4798       Dynobj::create_elf_hash_table(*pdynamic_symbols,
4799 				    local_symcount + forced_local_count,
4800 				    &phash, &hashlen);
4801 
4802       Output_section* hashsec =
4803 	this->choose_output_section(NULL, ".hash", elfcpp::SHT_HASH,
4804 				    elfcpp::SHF_ALLOC, false,
4805 				    ORDER_DYNAMIC_LINKER, false, false,
4806 				    false);
4807 
4808       Output_section_data* hashdata = new Output_data_const_buffer(phash,
4809 								   hashlen,
4810 								   align,
4811 								   "** hash");
4812       if (hashsec != NULL && hashdata != NULL)
4813 	hashsec->add_output_section_data(hashdata);
4814 
4815       if (hashsec != NULL)
4816 	{
4817 	  if (dynsym != NULL)
4818 	    hashsec->set_link_section(dynsym);
4819 	  hashsec->set_entsize(parameters->target().hash_entry_size() / 8);
4820 	}
4821 
4822       if (odyn != NULL)
4823 	odyn->add_section_address(elfcpp::DT_HASH, hashsec);
4824     }
4825 }
4826 
4827 // Assign offsets to each local portion of the dynamic symbol table.
4828 
4829 void
assign_local_dynsym_offsets(const Input_objects * input_objects)4830 Layout::assign_local_dynsym_offsets(const Input_objects* input_objects)
4831 {
4832   Output_section* dynsym = this->dynsym_section_;
4833   if (dynsym == NULL)
4834     return;
4835 
4836   off_t off = dynsym->offset();
4837 
4838   // Skip the dummy symbol at the start of the section.
4839   off += dynsym->entsize();
4840 
4841   for (Input_objects::Relobj_iterator p = input_objects->relobj_begin();
4842        p != input_objects->relobj_end();
4843        ++p)
4844     {
4845       unsigned int count = (*p)->set_local_dynsym_offset(off);
4846       off += count * dynsym->entsize();
4847     }
4848 }
4849 
4850 // Create the version sections.
4851 
4852 void
create_version_sections(const Versions * versions,const Symbol_table * symtab,unsigned int local_symcount,const std::vector<Symbol * > & dynamic_symbols,const Output_section * dynstr)4853 Layout::create_version_sections(const Versions* versions,
4854 				const Symbol_table* symtab,
4855 				unsigned int local_symcount,
4856 				const std::vector<Symbol*>& dynamic_symbols,
4857 				const Output_section* dynstr)
4858 {
4859   if (!versions->any_defs() && !versions->any_needs())
4860     return;
4861 
4862   switch (parameters->size_and_endianness())
4863     {
4864 #ifdef HAVE_TARGET_32_LITTLE
4865     case Parameters::TARGET_32_LITTLE:
4866       this->sized_create_version_sections<32, false>(versions, symtab,
4867 						     local_symcount,
4868 						     dynamic_symbols, dynstr);
4869       break;
4870 #endif
4871 #ifdef HAVE_TARGET_32_BIG
4872     case Parameters::TARGET_32_BIG:
4873       this->sized_create_version_sections<32, true>(versions, symtab,
4874 						    local_symcount,
4875 						    dynamic_symbols, dynstr);
4876       break;
4877 #endif
4878 #ifdef HAVE_TARGET_64_LITTLE
4879     case Parameters::TARGET_64_LITTLE:
4880       this->sized_create_version_sections<64, false>(versions, symtab,
4881 						     local_symcount,
4882 						     dynamic_symbols, dynstr);
4883       break;
4884 #endif
4885 #ifdef HAVE_TARGET_64_BIG
4886     case Parameters::TARGET_64_BIG:
4887       this->sized_create_version_sections<64, true>(versions, symtab,
4888 						    local_symcount,
4889 						    dynamic_symbols, dynstr);
4890       break;
4891 #endif
4892     default:
4893       gold_unreachable();
4894     }
4895 }
4896 
4897 // Create the version sections, sized version.
4898 
4899 template<int size, bool big_endian>
4900 void
sized_create_version_sections(const Versions * versions,const Symbol_table * symtab,unsigned int local_symcount,const std::vector<Symbol * > & dynamic_symbols,const Output_section * dynstr)4901 Layout::sized_create_version_sections(
4902     const Versions* versions,
4903     const Symbol_table* symtab,
4904     unsigned int local_symcount,
4905     const std::vector<Symbol*>& dynamic_symbols,
4906     const Output_section* dynstr)
4907 {
4908   Output_section* vsec = this->choose_output_section(NULL, ".gnu.version",
4909 						     elfcpp::SHT_GNU_versym,
4910 						     elfcpp::SHF_ALLOC,
4911 						     false,
4912 						     ORDER_DYNAMIC_LINKER,
4913 						     false, false, false);
4914 
4915   // Check for NULL since a linker script may discard this section.
4916   if (vsec != NULL)
4917     {
4918       unsigned char* vbuf;
4919       unsigned int vsize;
4920       versions->symbol_section_contents<size, big_endian>(symtab,
4921 							  &this->dynpool_,
4922 							  local_symcount,
4923 							  dynamic_symbols,
4924 							  &vbuf, &vsize);
4925 
4926       Output_section_data* vdata = new Output_data_const_buffer(vbuf, vsize, 2,
4927 								"** versions");
4928 
4929       vsec->add_output_section_data(vdata);
4930       vsec->set_entsize(2);
4931       vsec->set_link_section(this->dynsym_section_);
4932     }
4933 
4934   Output_data_dynamic* const odyn = this->dynamic_data_;
4935   if (odyn != NULL && vsec != NULL)
4936     odyn->add_section_address(elfcpp::DT_VERSYM, vsec);
4937 
4938   if (versions->any_defs())
4939     {
4940       Output_section* vdsec;
4941       vdsec = this->choose_output_section(NULL, ".gnu.version_d",
4942 					  elfcpp::SHT_GNU_verdef,
4943 					  elfcpp::SHF_ALLOC,
4944 					  false, ORDER_DYNAMIC_LINKER, false,
4945 					  false, false);
4946 
4947       if (vdsec != NULL)
4948 	{
4949 	  unsigned char* vdbuf;
4950 	  unsigned int vdsize;
4951 	  unsigned int vdentries;
4952 	  versions->def_section_contents<size, big_endian>(&this->dynpool_,
4953 							   &vdbuf, &vdsize,
4954 							   &vdentries);
4955 
4956 	  Output_section_data* vddata =
4957 	    new Output_data_const_buffer(vdbuf, vdsize, 4, "** version defs");
4958 
4959 	  vdsec->add_output_section_data(vddata);
4960 	  vdsec->set_link_section(dynstr);
4961 	  vdsec->set_info(vdentries);
4962 
4963 	  if (odyn != NULL)
4964 	    {
4965 	      odyn->add_section_address(elfcpp::DT_VERDEF, vdsec);
4966 	      odyn->add_constant(elfcpp::DT_VERDEFNUM, vdentries);
4967 	    }
4968 	}
4969     }
4970 
4971   if (versions->any_needs())
4972     {
4973       Output_section* vnsec;
4974       vnsec = this->choose_output_section(NULL, ".gnu.version_r",
4975 					  elfcpp::SHT_GNU_verneed,
4976 					  elfcpp::SHF_ALLOC,
4977 					  false, ORDER_DYNAMIC_LINKER, false,
4978 					  false, false);
4979 
4980       if (vnsec != NULL)
4981 	{
4982 	  unsigned char* vnbuf;
4983 	  unsigned int vnsize;
4984 	  unsigned int vnentries;
4985 	  versions->need_section_contents<size, big_endian>(&this->dynpool_,
4986 							    &vnbuf, &vnsize,
4987 							    &vnentries);
4988 
4989 	  Output_section_data* vndata =
4990 	    new Output_data_const_buffer(vnbuf, vnsize, 4, "** version refs");
4991 
4992 	  vnsec->add_output_section_data(vndata);
4993 	  vnsec->set_link_section(dynstr);
4994 	  vnsec->set_info(vnentries);
4995 
4996 	  if (odyn != NULL)
4997 	    {
4998 	      odyn->add_section_address(elfcpp::DT_VERNEED, vnsec);
4999 	      odyn->add_constant(elfcpp::DT_VERNEEDNUM, vnentries);
5000 	    }
5001 	}
5002     }
5003 }
5004 
5005 // Create the .interp section and PT_INTERP segment.
5006 
5007 void
create_interp(const Target * target)5008 Layout::create_interp(const Target* target)
5009 {
5010   gold_assert(this->interp_segment_ == NULL);
5011 
5012   const char* interp = parameters->options().dynamic_linker();
5013   if (interp == NULL)
5014     {
5015       interp = target->dynamic_linker();
5016       gold_assert(interp != NULL);
5017     }
5018 
5019   size_t len = strlen(interp) + 1;
5020 
5021   Output_section_data* odata = new Output_data_const(interp, len, 1);
5022 
5023   Output_section* osec = this->choose_output_section(NULL, ".interp",
5024 						     elfcpp::SHT_PROGBITS,
5025 						     elfcpp::SHF_ALLOC,
5026 						     false, ORDER_INTERP,
5027 						     false, false, false);
5028   if (osec != NULL)
5029     osec->add_output_section_data(odata);
5030 }
5031 
5032 // Add dynamic tags for the PLT and the dynamic relocs.  This is
5033 // called by the target-specific code.  This does nothing if not doing
5034 // a dynamic link.
5035 
5036 // USE_REL is true for REL relocs rather than RELA relocs.
5037 
5038 // If PLT_GOT is not NULL, then DT_PLTGOT points to it.
5039 
5040 // If PLT_REL is not NULL, it is used for DT_PLTRELSZ, and DT_JMPREL,
5041 // and we also set DT_PLTREL.  We use PLT_REL's output section, since
5042 // some targets have multiple reloc sections in PLT_REL.
5043 
5044 // If DYN_REL is not NULL, it is used for DT_REL/DT_RELA,
5045 // DT_RELSZ/DT_RELASZ, DT_RELENT/DT_RELAENT.  Again we use the output
5046 // section.
5047 
5048 // If ADD_DEBUG is true, we add a DT_DEBUG entry when generating an
5049 // executable.
5050 
5051 void
add_target_dynamic_tags(bool use_rel,const Output_data * plt_got,const Output_data * plt_rel,const Output_data_reloc_generic * dyn_rel,bool add_debug,bool dynrel_includes_plt)5052 Layout::add_target_dynamic_tags(bool use_rel, const Output_data* plt_got,
5053 				const Output_data* plt_rel,
5054 				const Output_data_reloc_generic* dyn_rel,
5055 				bool add_debug, bool dynrel_includes_plt)
5056 {
5057   Output_data_dynamic* odyn = this->dynamic_data_;
5058   if (odyn == NULL)
5059     return;
5060 
5061   if (plt_got != NULL && plt_got->output_section() != NULL)
5062     odyn->add_section_address(elfcpp::DT_PLTGOT, plt_got);
5063 
5064   if (plt_rel != NULL && plt_rel->output_section() != NULL)
5065     {
5066       odyn->add_section_size(elfcpp::DT_PLTRELSZ, plt_rel->output_section());
5067       odyn->add_section_address(elfcpp::DT_JMPREL, plt_rel->output_section());
5068       odyn->add_constant(elfcpp::DT_PLTREL,
5069 			 use_rel ? elfcpp::DT_REL : elfcpp::DT_RELA);
5070     }
5071 
5072   if ((dyn_rel != NULL && dyn_rel->output_section() != NULL)
5073       || (dynrel_includes_plt
5074 	  && plt_rel != NULL
5075 	  && plt_rel->output_section() != NULL))
5076     {
5077       bool have_dyn_rel = dyn_rel != NULL && dyn_rel->output_section() != NULL;
5078       bool have_plt_rel = plt_rel != NULL && plt_rel->output_section() != NULL;
5079       odyn->add_section_address(use_rel ? elfcpp::DT_REL : elfcpp::DT_RELA,
5080 				(have_dyn_rel
5081 				 ? dyn_rel->output_section()
5082 				 : plt_rel->output_section()));
5083       elfcpp::DT size_tag = use_rel ? elfcpp::DT_RELSZ : elfcpp::DT_RELASZ;
5084       if (have_dyn_rel && have_plt_rel && dynrel_includes_plt)
5085 	odyn->add_section_size(size_tag,
5086 			       dyn_rel->output_section(),
5087 			       plt_rel->output_section());
5088       else if (have_dyn_rel)
5089 	odyn->add_section_size(size_tag, dyn_rel->output_section());
5090       else
5091 	odyn->add_section_size(size_tag, plt_rel->output_section());
5092       const int size = parameters->target().get_size();
5093       elfcpp::DT rel_tag;
5094       int rel_size;
5095       if (use_rel)
5096 	{
5097 	  rel_tag = elfcpp::DT_RELENT;
5098 	  if (size == 32)
5099 	    rel_size = Reloc_types<elfcpp::SHT_REL, 32, false>::reloc_size;
5100 	  else if (size == 64)
5101 	    rel_size = Reloc_types<elfcpp::SHT_REL, 64, false>::reloc_size;
5102 	  else
5103 	    gold_unreachable();
5104 	}
5105       else
5106 	{
5107 	  rel_tag = elfcpp::DT_RELAENT;
5108 	  if (size == 32)
5109 	    rel_size = Reloc_types<elfcpp::SHT_RELA, 32, false>::reloc_size;
5110 	  else if (size == 64)
5111 	    rel_size = Reloc_types<elfcpp::SHT_RELA, 64, false>::reloc_size;
5112 	  else
5113 	    gold_unreachable();
5114 	}
5115       odyn->add_constant(rel_tag, rel_size);
5116 
5117       if (parameters->options().combreloc() && have_dyn_rel)
5118 	{
5119 	  size_t c = dyn_rel->relative_reloc_count();
5120 	  if (c > 0)
5121 	    odyn->add_constant((use_rel
5122 				? elfcpp::DT_RELCOUNT
5123 				: elfcpp::DT_RELACOUNT),
5124 			       c);
5125 	}
5126     }
5127 
5128   if (add_debug && !parameters->options().shared())
5129     {
5130       // The value of the DT_DEBUG tag is filled in by the dynamic
5131       // linker at run time, and used by the debugger.
5132       odyn->add_constant(elfcpp::DT_DEBUG, 0);
5133     }
5134 }
5135 
5136 void
add_target_specific_dynamic_tag(elfcpp::DT tag,unsigned int val)5137 Layout::add_target_specific_dynamic_tag(elfcpp::DT tag, unsigned int val)
5138 {
5139   Output_data_dynamic* odyn = this->dynamic_data_;
5140   if (odyn == NULL)
5141     return;
5142   odyn->add_constant(tag, val);
5143 }
5144 
5145 // Finish the .dynamic section and PT_DYNAMIC segment.
5146 
5147 void
finish_dynamic_section(const Input_objects * input_objects,const Symbol_table * symtab)5148 Layout::finish_dynamic_section(const Input_objects* input_objects,
5149 			       const Symbol_table* symtab)
5150 {
5151   if (!this->script_options_->saw_phdrs_clause()
5152       && this->dynamic_section_ != NULL)
5153     {
5154       Output_segment* oseg = this->make_output_segment(elfcpp::PT_DYNAMIC,
5155 						       (elfcpp::PF_R
5156 							| elfcpp::PF_W));
5157       oseg->add_output_section_to_nonload(this->dynamic_section_,
5158 					  elfcpp::PF_R | elfcpp::PF_W);
5159     }
5160 
5161   Output_data_dynamic* const odyn = this->dynamic_data_;
5162   if (odyn == NULL)
5163     return;
5164 
5165   for (Input_objects::Dynobj_iterator p = input_objects->dynobj_begin();
5166        p != input_objects->dynobj_end();
5167        ++p)
5168     {
5169       if (!(*p)->is_needed() && (*p)->as_needed())
5170 	{
5171 	  // This dynamic object was linked with --as-needed, but it
5172 	  // is not needed.
5173 	  continue;
5174 	}
5175 
5176       odyn->add_string(elfcpp::DT_NEEDED, (*p)->soname());
5177     }
5178 
5179   if (parameters->options().shared())
5180     {
5181       const char* soname = parameters->options().soname();
5182       if (soname != NULL)
5183 	odyn->add_string(elfcpp::DT_SONAME, soname);
5184     }
5185 
5186   Symbol* sym = symtab->lookup(parameters->options().init());
5187   if (sym != NULL && sym->is_defined() && !sym->is_from_dynobj())
5188     odyn->add_symbol(elfcpp::DT_INIT, sym);
5189 
5190   sym = symtab->lookup(parameters->options().fini());
5191   if (sym != NULL && sym->is_defined() && !sym->is_from_dynobj())
5192     odyn->add_symbol(elfcpp::DT_FINI, sym);
5193 
5194   // Look for .init_array, .preinit_array and .fini_array by checking
5195   // section types.
5196   for(Layout::Section_list::const_iterator p = this->section_list_.begin();
5197       p != this->section_list_.end();
5198       ++p)
5199     switch((*p)->type())
5200       {
5201       case elfcpp::SHT_FINI_ARRAY:
5202 	odyn->add_section_address(elfcpp::DT_FINI_ARRAY, *p);
5203 	odyn->add_section_size(elfcpp::DT_FINI_ARRAYSZ, *p);
5204 	break;
5205       case elfcpp::SHT_INIT_ARRAY:
5206 	odyn->add_section_address(elfcpp::DT_INIT_ARRAY, *p);
5207 	odyn->add_section_size(elfcpp::DT_INIT_ARRAYSZ, *p);
5208 	break;
5209       case elfcpp::SHT_PREINIT_ARRAY:
5210 	odyn->add_section_address(elfcpp::DT_PREINIT_ARRAY, *p);
5211 	odyn->add_section_size(elfcpp::DT_PREINIT_ARRAYSZ, *p);
5212 	break;
5213       default:
5214 	break;
5215       }
5216 
5217   // Add a DT_RPATH entry if needed.
5218   const General_options::Dir_list& rpath(parameters->options().rpath());
5219   if (!rpath.empty())
5220     {
5221       std::string rpath_val;
5222       for (General_options::Dir_list::const_iterator p = rpath.begin();
5223 	   p != rpath.end();
5224 	   ++p)
5225 	{
5226 	  if (rpath_val.empty())
5227 	    rpath_val = p->name();
5228 	  else
5229 	    {
5230 	      // Eliminate duplicates.
5231 	      General_options::Dir_list::const_iterator q;
5232 	      for (q = rpath.begin(); q != p; ++q)
5233 		if (q->name() == p->name())
5234 		  break;
5235 	      if (q == p)
5236 		{
5237 		  rpath_val += ':';
5238 		  rpath_val += p->name();
5239 		}
5240 	    }
5241 	}
5242 
5243       if (!parameters->options().enable_new_dtags())
5244 	odyn->add_string(elfcpp::DT_RPATH, rpath_val);
5245       else
5246 	odyn->add_string(elfcpp::DT_RUNPATH, rpath_val);
5247     }
5248 
5249   // Look for text segments that have dynamic relocations.
5250   bool have_textrel = false;
5251   if (!this->script_options_->saw_sections_clause())
5252     {
5253       for (Segment_list::const_iterator p = this->segment_list_.begin();
5254 	   p != this->segment_list_.end();
5255 	   ++p)
5256 	{
5257 	  if ((*p)->type() == elfcpp::PT_LOAD
5258 	      && ((*p)->flags() & elfcpp::PF_W) == 0
5259 	      && (*p)->has_dynamic_reloc())
5260 	    {
5261 	      have_textrel = true;
5262 	      break;
5263 	    }
5264 	}
5265     }
5266   else
5267     {
5268       // We don't know the section -> segment mapping, so we are
5269       // conservative and just look for readonly sections with
5270       // relocations.  If those sections wind up in writable segments,
5271       // then we have created an unnecessary DT_TEXTREL entry.
5272       for (Section_list::const_iterator p = this->section_list_.begin();
5273 	   p != this->section_list_.end();
5274 	   ++p)
5275 	{
5276 	  if (((*p)->flags() & elfcpp::SHF_ALLOC) != 0
5277 	      && ((*p)->flags() & elfcpp::SHF_WRITE) == 0
5278 	      && (*p)->has_dynamic_reloc())
5279 	    {
5280 	      have_textrel = true;
5281 	      break;
5282 	    }
5283 	}
5284     }
5285 
5286   if (parameters->options().filter() != NULL)
5287     odyn->add_string(elfcpp::DT_FILTER, parameters->options().filter());
5288   if (parameters->options().any_auxiliary())
5289     {
5290       for (options::String_set::const_iterator p =
5291 	     parameters->options().auxiliary_begin();
5292 	   p != parameters->options().auxiliary_end();
5293 	   ++p)
5294 	odyn->add_string(elfcpp::DT_AUXILIARY, *p);
5295     }
5296 
5297   // Add a DT_FLAGS entry if necessary.
5298   unsigned int flags = 0;
5299   if (have_textrel)
5300     {
5301       // Add a DT_TEXTREL for compatibility with older loaders.
5302       odyn->add_constant(elfcpp::DT_TEXTREL, 0);
5303       flags |= elfcpp::DF_TEXTREL;
5304 
5305       if (parameters->options().text())
5306 	gold_error(_("read-only segment has dynamic relocations"));
5307       else if (parameters->options().warn_shared_textrel()
5308 	       && parameters->options().shared())
5309 	gold_warning(_("shared library text segment is not shareable"));
5310     }
5311   if (parameters->options().shared() && this->has_static_tls())
5312     flags |= elfcpp::DF_STATIC_TLS;
5313   if (parameters->options().origin())
5314     flags |= elfcpp::DF_ORIGIN;
5315   if (parameters->options().Bsymbolic()
5316       && !parameters->options().have_dynamic_list())
5317     {
5318       flags |= elfcpp::DF_SYMBOLIC;
5319       // Add DT_SYMBOLIC for compatibility with older loaders.
5320       odyn->add_constant(elfcpp::DT_SYMBOLIC, 0);
5321     }
5322   if (parameters->options().now())
5323     flags |= elfcpp::DF_BIND_NOW;
5324   if (flags != 0)
5325     odyn->add_constant(elfcpp::DT_FLAGS, flags);
5326 
5327   flags = 0;
5328   if (parameters->options().global())
5329     flags |= elfcpp::DF_1_GLOBAL;
5330   if (parameters->options().initfirst())
5331     flags |= elfcpp::DF_1_INITFIRST;
5332   if (parameters->options().interpose())
5333     flags |= elfcpp::DF_1_INTERPOSE;
5334   if (parameters->options().loadfltr())
5335     flags |= elfcpp::DF_1_LOADFLTR;
5336   if (parameters->options().nodefaultlib())
5337     flags |= elfcpp::DF_1_NODEFLIB;
5338   if (parameters->options().nodelete())
5339     flags |= elfcpp::DF_1_NODELETE;
5340   if (parameters->options().nodlopen())
5341     flags |= elfcpp::DF_1_NOOPEN;
5342   if (parameters->options().nodump())
5343     flags |= elfcpp::DF_1_NODUMP;
5344   if (!parameters->options().shared())
5345     flags &= ~(elfcpp::DF_1_INITFIRST
5346 	       | elfcpp::DF_1_NODELETE
5347 	       | elfcpp::DF_1_NOOPEN);
5348   if (parameters->options().origin())
5349     flags |= elfcpp::DF_1_ORIGIN;
5350   if (parameters->options().now())
5351     flags |= elfcpp::DF_1_NOW;
5352   if (parameters->options().Bgroup())
5353     flags |= elfcpp::DF_1_GROUP;
5354   if (flags != 0)
5355     odyn->add_constant(elfcpp::DT_FLAGS_1, flags);
5356 }
5357 
5358 // Set the size of the _DYNAMIC symbol table to be the size of the
5359 // dynamic data.
5360 
5361 void
set_dynamic_symbol_size(const Symbol_table * symtab)5362 Layout::set_dynamic_symbol_size(const Symbol_table* symtab)
5363 {
5364   Output_data_dynamic* const odyn = this->dynamic_data_;
5365   if (odyn == NULL)
5366     return;
5367   odyn->finalize_data_size();
5368   if (this->dynamic_symbol_ == NULL)
5369     return;
5370   off_t data_size = odyn->data_size();
5371   const int size = parameters->target().get_size();
5372   if (size == 32)
5373     symtab->get_sized_symbol<32>(this->dynamic_symbol_)->set_symsize(data_size);
5374   else if (size == 64)
5375     symtab->get_sized_symbol<64>(this->dynamic_symbol_)->set_symsize(data_size);
5376   else
5377     gold_unreachable();
5378 }
5379 
5380 // The mapping of input section name prefixes to output section names.
5381 // In some cases one prefix is itself a prefix of another prefix; in
5382 // such a case the longer prefix must come first.  These prefixes are
5383 // based on the GNU linker default ELF linker script.
5384 
5385 #define MAPPING_INIT(f, t) { f, sizeof(f) - 1, t, sizeof(t) - 1 }
5386 #define MAPPING_INIT_EXACT(f, t) { f, 0, t, sizeof(t) - 1 }
5387 const Layout::Section_name_mapping Layout::section_name_mapping[] =
5388 {
5389   MAPPING_INIT(".text.", ".text"),
5390   MAPPING_INIT(".rodata.", ".rodata"),
5391   MAPPING_INIT(".data.rel.ro.local.", ".data.rel.ro.local"),
5392   MAPPING_INIT_EXACT(".data.rel.ro.local", ".data.rel.ro.local"),
5393   MAPPING_INIT(".data.rel.ro.", ".data.rel.ro"),
5394   MAPPING_INIT_EXACT(".data.rel.ro", ".data.rel.ro"),
5395   MAPPING_INIT(".data.", ".data"),
5396   MAPPING_INIT(".bss.", ".bss"),
5397   MAPPING_INIT(".tdata.", ".tdata"),
5398   MAPPING_INIT(".tbss.", ".tbss"),
5399   MAPPING_INIT(".init_array.", ".init_array"),
5400   MAPPING_INIT(".fini_array.", ".fini_array"),
5401   MAPPING_INIT(".sdata.", ".sdata"),
5402   MAPPING_INIT(".sbss.", ".sbss"),
5403   // FIXME: In the GNU linker, .sbss2 and .sdata2 are handled
5404   // differently depending on whether it is creating a shared library.
5405   MAPPING_INIT(".sdata2.", ".sdata"),
5406   MAPPING_INIT(".sbss2.", ".sbss"),
5407   MAPPING_INIT(".lrodata.", ".lrodata"),
5408   MAPPING_INIT(".ldata.", ".ldata"),
5409   MAPPING_INIT(".lbss.", ".lbss"),
5410   MAPPING_INIT(".gcc_except_table.", ".gcc_except_table"),
5411   MAPPING_INIT(".gnu.linkonce.d.rel.ro.local.", ".data.rel.ro.local"),
5412   MAPPING_INIT(".gnu.linkonce.d.rel.ro.", ".data.rel.ro"),
5413   MAPPING_INIT(".gnu.linkonce.t.", ".text"),
5414   MAPPING_INIT(".gnu.linkonce.r.", ".rodata"),
5415   MAPPING_INIT(".gnu.linkonce.d.", ".data"),
5416   MAPPING_INIT(".gnu.linkonce.b.", ".bss"),
5417   MAPPING_INIT(".gnu.linkonce.s.", ".sdata"),
5418   MAPPING_INIT(".gnu.linkonce.sb.", ".sbss"),
5419   MAPPING_INIT(".gnu.linkonce.s2.", ".sdata"),
5420   MAPPING_INIT(".gnu.linkonce.sb2.", ".sbss"),
5421   MAPPING_INIT(".gnu.linkonce.wi.", ".debug_info"),
5422   MAPPING_INIT(".gnu.linkonce.td.", ".tdata"),
5423   MAPPING_INIT(".gnu.linkonce.tb.", ".tbss"),
5424   MAPPING_INIT(".gnu.linkonce.lr.", ".lrodata"),
5425   MAPPING_INIT(".gnu.linkonce.l.", ".ldata"),
5426   MAPPING_INIT(".gnu.linkonce.lb.", ".lbss"),
5427   MAPPING_INIT(".ARM.extab", ".ARM.extab"),
5428   MAPPING_INIT(".gnu.linkonce.armextab.", ".ARM.extab"),
5429   MAPPING_INIT(".ARM.exidx", ".ARM.exidx"),
5430   MAPPING_INIT(".gnu.linkonce.armexidx.", ".ARM.exidx"),
5431   MAPPING_INIT(".gnu.build.attributes.", ".gnu.build.attributes"),
5432 };
5433 
5434 // Mapping for ".text" section prefixes with -z,keep-text-section-prefix.
5435 const Layout::Section_name_mapping Layout::text_section_name_mapping[] =
5436 {
5437   MAPPING_INIT(".text.hot.", ".text.hot"),
5438   MAPPING_INIT_EXACT(".text.hot", ".text.hot"),
5439   MAPPING_INIT(".text.unlikely.", ".text.unlikely"),
5440   MAPPING_INIT_EXACT(".text.unlikely", ".text.unlikely"),
5441   MAPPING_INIT(".text.startup.", ".text.startup"),
5442   MAPPING_INIT_EXACT(".text.startup", ".text.startup"),
5443   MAPPING_INIT(".text.exit.", ".text.exit"),
5444   MAPPING_INIT_EXACT(".text.exit", ".text.exit"),
5445   MAPPING_INIT(".text.", ".text"),
5446 };
5447 #undef MAPPING_INIT
5448 #undef MAPPING_INIT_EXACT
5449 
5450 const int Layout::section_name_mapping_count =
5451   (sizeof(Layout::section_name_mapping)
5452    / sizeof(Layout::section_name_mapping[0]));
5453 
5454 const int Layout::text_section_name_mapping_count =
5455   (sizeof(Layout::text_section_name_mapping)
5456    / sizeof(Layout::text_section_name_mapping[0]));
5457 
5458 // Find section name NAME in PSNM and return the mapped name if found
5459 // with the length set in PLEN.
5460 const char *
match_section_name(const Layout::Section_name_mapping * psnm,const int count,const char * name,size_t * plen)5461 Layout::match_section_name(const Layout::Section_name_mapping* psnm,
5462 			   const int count,
5463 			   const char* name, size_t* plen)
5464 {
5465   for (int i = 0; i < count; ++i, ++psnm)
5466     {
5467       if (psnm->fromlen > 0)
5468 	{
5469 	  if (strncmp(name, psnm->from, psnm->fromlen) == 0)
5470 	    {
5471 	      *plen = psnm->tolen;
5472 	      return psnm->to;
5473 	    }
5474 	}
5475       else
5476 	{
5477 	  if (strcmp(name, psnm->from) == 0)
5478 	    {
5479 	      *plen = psnm->tolen;
5480 	      return psnm->to;
5481 	    }
5482 	}
5483     }
5484   return NULL;
5485 }
5486 
5487 // Choose the output section name to use given an input section name.
5488 // Set *PLEN to the length of the name.  *PLEN is initialized to the
5489 // length of NAME.
5490 
5491 const char*
output_section_name(const Relobj * relobj,const char * name,size_t * plen)5492 Layout::output_section_name(const Relobj* relobj, const char* name,
5493 			    size_t* plen)
5494 {
5495   // gcc 4.3 generates the following sorts of section names when it
5496   // needs a section name specific to a function:
5497   //   .text.FN
5498   //   .rodata.FN
5499   //   .sdata2.FN
5500   //   .data.FN
5501   //   .data.rel.FN
5502   //   .data.rel.local.FN
5503   //   .data.rel.ro.FN
5504   //   .data.rel.ro.local.FN
5505   //   .sdata.FN
5506   //   .bss.FN
5507   //   .sbss.FN
5508   //   .tdata.FN
5509   //   .tbss.FN
5510 
5511   // The GNU linker maps all of those to the part before the .FN,
5512   // except that .data.rel.local.FN is mapped to .data, and
5513   // .data.rel.ro.local.FN is mapped to .data.rel.ro.  The sections
5514   // beginning with .data.rel.ro.local are grouped together.
5515 
5516   // For an anonymous namespace, the string FN can contain a '.'.
5517 
5518   // Also of interest: .rodata.strN.N, .rodata.cstN, both of which the
5519   // GNU linker maps to .rodata.
5520 
5521   // The .data.rel.ro sections are used with -z relro.  The sections
5522   // are recognized by name.  We use the same names that the GNU
5523   // linker does for these sections.
5524 
5525   // It is hard to handle this in a principled way, so we don't even
5526   // try.  We use a table of mappings.  If the input section name is
5527   // not found in the table, we simply use it as the output section
5528   // name.
5529 
5530   if (parameters->options().keep_text_section_prefix()
5531       && is_prefix_of(".text", name))
5532     {
5533       const char* match = match_section_name(text_section_name_mapping,
5534 					     text_section_name_mapping_count,
5535 					     name, plen);
5536       if (match != NULL)
5537 	return match;
5538     }
5539 
5540   const char* match = match_section_name(section_name_mapping,
5541 					 section_name_mapping_count, name, plen);
5542   if (match != NULL)
5543     return match;
5544 
5545   // As an additional complication, .ctors sections are output in
5546   // either .ctors or .init_array sections, and .dtors sections are
5547   // output in either .dtors or .fini_array sections.
5548   if (is_prefix_of(".ctors.", name) || is_prefix_of(".dtors.", name))
5549     {
5550       if (parameters->options().ctors_in_init_array())
5551 	{
5552 	  *plen = 11;
5553 	  return name[1] == 'c' ? ".init_array" : ".fini_array";
5554 	}
5555       else
5556 	{
5557 	  *plen = 6;
5558 	  return name[1] == 'c' ? ".ctors" : ".dtors";
5559 	}
5560     }
5561   if (parameters->options().ctors_in_init_array()
5562       && (strcmp(name, ".ctors") == 0 || strcmp(name, ".dtors") == 0))
5563     {
5564       // To make .init_array/.fini_array work with gcc we must exclude
5565       // .ctors and .dtors sections from the crtbegin and crtend
5566       // files.
5567       if (relobj == NULL
5568 	  || (!Layout::match_file_name(relobj, "crtbegin")
5569 	      && !Layout::match_file_name(relobj, "crtend")))
5570 	{
5571 	  *plen = 11;
5572 	  return name[1] == 'c' ? ".init_array" : ".fini_array";
5573 	}
5574     }
5575 
5576   return name;
5577 }
5578 
5579 // Return true if RELOBJ is an input file whose base name matches
5580 // FILE_NAME.  The base name must have an extension of ".o", and must
5581 // be exactly FILE_NAME.o or FILE_NAME, one character, ".o".  This is
5582 // to match crtbegin.o as well as crtbeginS.o without getting confused
5583 // by other possibilities.  Overall matching the file name this way is
5584 // a dreadful hack, but the GNU linker does it in order to better
5585 // support gcc, and we need to be compatible.
5586 
5587 bool
match_file_name(const Relobj * relobj,const char * match)5588 Layout::match_file_name(const Relobj* relobj, const char* match)
5589 {
5590   const std::string& file_name(relobj->name());
5591   const char* base_name = lbasename(file_name.c_str());
5592   size_t match_len = strlen(match);
5593   if (strncmp(base_name, match, match_len) != 0)
5594     return false;
5595   size_t base_len = strlen(base_name);
5596   if (base_len != match_len + 2 && base_len != match_len + 3)
5597     return false;
5598   return memcmp(base_name + base_len - 2, ".o", 2) == 0;
5599 }
5600 
5601 // Check if a comdat group or .gnu.linkonce section with the given
5602 // NAME is selected for the link.  If there is already a section,
5603 // *KEPT_SECTION is set to point to the existing section and the
5604 // function returns false.  Otherwise, OBJECT, SHNDX, IS_COMDAT, and
5605 // IS_GROUP_NAME are recorded for this NAME in the layout object,
5606 // *KEPT_SECTION is set to the internal copy and the function returns
5607 // true.
5608 
5609 bool
find_or_add_kept_section(const std::string & name,Relobj * object,unsigned int shndx,bool is_comdat,bool is_group_name,Kept_section ** kept_section)5610 Layout::find_or_add_kept_section(const std::string& name,
5611 				 Relobj* object,
5612 				 unsigned int shndx,
5613 				 bool is_comdat,
5614 				 bool is_group_name,
5615 				 Kept_section** kept_section)
5616 {
5617   // It's normal to see a couple of entries here, for the x86 thunk
5618   // sections.  If we see more than a few, we're linking a C++
5619   // program, and we resize to get more space to minimize rehashing.
5620   if (this->signatures_.size() > 4
5621       && !this->resized_signatures_)
5622     {
5623       reserve_unordered_map(&this->signatures_,
5624 			    this->number_of_input_files_ * 64);
5625       this->resized_signatures_ = true;
5626     }
5627 
5628   Kept_section candidate;
5629   std::pair<Signatures::iterator, bool> ins =
5630     this->signatures_.insert(std::make_pair(name, candidate));
5631 
5632   if (kept_section != NULL)
5633     *kept_section = &ins.first->second;
5634   if (ins.second)
5635     {
5636       // This is the first time we've seen this signature.
5637       ins.first->second.set_object(object);
5638       ins.first->second.set_shndx(shndx);
5639       if (is_comdat)
5640 	ins.first->second.set_is_comdat();
5641       if (is_group_name)
5642 	ins.first->second.set_is_group_name();
5643       return true;
5644     }
5645 
5646   // We have already seen this signature.
5647 
5648   if (ins.first->second.is_group_name())
5649     {
5650       // We've already seen a real section group with this signature.
5651       // If the kept group is from a plugin object, and we're in the
5652       // replacement phase, accept the new one as a replacement.
5653       if (ins.first->second.object() == NULL
5654 	  && parameters->options().plugins()->in_replacement_phase())
5655 	{
5656 	  ins.first->second.set_object(object);
5657 	  ins.first->second.set_shndx(shndx);
5658 	  return true;
5659 	}
5660       return false;
5661     }
5662   else if (is_group_name)
5663     {
5664       // This is a real section group, and we've already seen a
5665       // linkonce section with this signature.  Record that we've seen
5666       // a section group, and don't include this section group.
5667       ins.first->second.set_is_group_name();
5668       return false;
5669     }
5670   else
5671     {
5672       // We've already seen a linkonce section and this is a linkonce
5673       // section.  These don't block each other--this may be the same
5674       // symbol name with different section types.
5675       return true;
5676     }
5677 }
5678 
5679 // Store the allocated sections into the section list.
5680 
5681 void
get_allocated_sections(Section_list * section_list) const5682 Layout::get_allocated_sections(Section_list* section_list) const
5683 {
5684   for (Section_list::const_iterator p = this->section_list_.begin();
5685        p != this->section_list_.end();
5686        ++p)
5687     if (((*p)->flags() & elfcpp::SHF_ALLOC) != 0)
5688       section_list->push_back(*p);
5689 }
5690 
5691 // Store the executable sections into the section list.
5692 
5693 void
get_executable_sections(Section_list * section_list) const5694 Layout::get_executable_sections(Section_list* section_list) const
5695 {
5696   for (Section_list::const_iterator p = this->section_list_.begin();
5697        p != this->section_list_.end();
5698        ++p)
5699     if (((*p)->flags() & (elfcpp::SHF_ALLOC | elfcpp::SHF_EXECINSTR))
5700 	== (elfcpp::SHF_ALLOC | elfcpp::SHF_EXECINSTR))
5701       section_list->push_back(*p);
5702 }
5703 
5704 // Create an output segment.
5705 
5706 Output_segment*
make_output_segment(elfcpp::Elf_Word type,elfcpp::Elf_Word flags)5707 Layout::make_output_segment(elfcpp::Elf_Word type, elfcpp::Elf_Word flags)
5708 {
5709   gold_assert(!parameters->options().relocatable());
5710   Output_segment* oseg = new Output_segment(type, flags);
5711   this->segment_list_.push_back(oseg);
5712 
5713   if (type == elfcpp::PT_TLS)
5714     this->tls_segment_ = oseg;
5715   else if (type == elfcpp::PT_GNU_RELRO)
5716     this->relro_segment_ = oseg;
5717   else if (type == elfcpp::PT_INTERP)
5718     this->interp_segment_ = oseg;
5719 
5720   return oseg;
5721 }
5722 
5723 // Return the file offset of the normal symbol table.
5724 
5725 off_t
symtab_section_offset() const5726 Layout::symtab_section_offset() const
5727 {
5728   if (this->symtab_section_ != NULL)
5729     return this->symtab_section_->offset();
5730   return 0;
5731 }
5732 
5733 // Return the section index of the normal symbol table.  It may have
5734 // been stripped by the -s/--strip-all option.
5735 
5736 unsigned int
symtab_section_shndx() const5737 Layout::symtab_section_shndx() const
5738 {
5739   if (this->symtab_section_ != NULL)
5740     return this->symtab_section_->out_shndx();
5741   return 0;
5742 }
5743 
5744 // Write out the Output_sections.  Most won't have anything to write,
5745 // since most of the data will come from input sections which are
5746 // handled elsewhere.  But some Output_sections do have Output_data.
5747 
5748 void
write_output_sections(Output_file * of) const5749 Layout::write_output_sections(Output_file* of) const
5750 {
5751   for (Section_list::const_iterator p = this->section_list_.begin();
5752        p != this->section_list_.end();
5753        ++p)
5754     {
5755       if (!(*p)->after_input_sections())
5756 	(*p)->write(of);
5757     }
5758 }
5759 
5760 // Write out data not associated with a section or the symbol table.
5761 
5762 void
write_data(const Symbol_table * symtab,Output_file * of) const5763 Layout::write_data(const Symbol_table* symtab, Output_file* of) const
5764 {
5765   if (!parameters->options().strip_all())
5766     {
5767       const Output_section* symtab_section = this->symtab_section_;
5768       for (Section_list::const_iterator p = this->section_list_.begin();
5769 	   p != this->section_list_.end();
5770 	   ++p)
5771 	{
5772 	  if ((*p)->needs_symtab_index())
5773 	    {
5774 	      gold_assert(symtab_section != NULL);
5775 	      unsigned int index = (*p)->symtab_index();
5776 	      gold_assert(index > 0 && index != -1U);
5777 	      off_t off = (symtab_section->offset()
5778 			   + index * symtab_section->entsize());
5779 	      symtab->write_section_symbol(*p, this->symtab_xindex_, of, off);
5780 	    }
5781 	}
5782     }
5783 
5784   const Output_section* dynsym_section = this->dynsym_section_;
5785   for (Section_list::const_iterator p = this->section_list_.begin();
5786        p != this->section_list_.end();
5787        ++p)
5788     {
5789       if ((*p)->needs_dynsym_index())
5790 	{
5791 	  gold_assert(dynsym_section != NULL);
5792 	  unsigned int index = (*p)->dynsym_index();
5793 	  gold_assert(index > 0 && index != -1U);
5794 	  off_t off = (dynsym_section->offset()
5795 		       + index * dynsym_section->entsize());
5796 	  symtab->write_section_symbol(*p, this->dynsym_xindex_, of, off);
5797 	}
5798     }
5799 
5800   // Write out the Output_data which are not in an Output_section.
5801   for (Data_list::const_iterator p = this->special_output_list_.begin();
5802        p != this->special_output_list_.end();
5803        ++p)
5804     (*p)->write(of);
5805 
5806   // Write out the Output_data which are not in an Output_section
5807   // and are regenerated in each iteration of relaxation.
5808   for (Data_list::const_iterator p = this->relax_output_list_.begin();
5809        p != this->relax_output_list_.end();
5810        ++p)
5811     (*p)->write(of);
5812 }
5813 
5814 // Write out the Output_sections which can only be written after the
5815 // input sections are complete.
5816 
5817 void
write_sections_after_input_sections(Output_file * of)5818 Layout::write_sections_after_input_sections(Output_file* of)
5819 {
5820   // Determine the final section offsets, and thus the final output
5821   // file size.  Note we finalize the .shstrab last, to allow the
5822   // after_input_section sections to modify their section-names before
5823   // writing.
5824   if (this->any_postprocessing_sections_)
5825     {
5826       off_t off = this->output_file_size_;
5827       off = this->set_section_offsets(off, POSTPROCESSING_SECTIONS_PASS);
5828 
5829       // Now that we've finalized the names, we can finalize the shstrab.
5830       off =
5831 	this->set_section_offsets(off,
5832 				  STRTAB_AFTER_POSTPROCESSING_SECTIONS_PASS);
5833 
5834       if (off > this->output_file_size_)
5835 	{
5836 	  of->resize(off);
5837 	  this->output_file_size_ = off;
5838 	}
5839     }
5840 
5841   for (Section_list::const_iterator p = this->section_list_.begin();
5842        p != this->section_list_.end();
5843        ++p)
5844     {
5845       if ((*p)->after_input_sections())
5846 	(*p)->write(of);
5847     }
5848 
5849   this->section_headers_->write(of);
5850 }
5851 
5852 // If a tree-style build ID was requested, the parallel part of that computation
5853 // is already done, and the final hash-of-hashes is computed here.  For other
5854 // types of build IDs, all the work is done here.
5855 
5856 void
write_build_id(Output_file * of,unsigned char * array_of_hashes,size_t size_of_hashes) const5857 Layout::write_build_id(Output_file* of, unsigned char* array_of_hashes,
5858 		       size_t size_of_hashes) const
5859 {
5860   if (this->build_id_note_ == NULL)
5861     return;
5862 
5863   unsigned char* ov = of->get_output_view(this->build_id_note_->offset(),
5864 					  this->build_id_note_->data_size());
5865 
5866   if (array_of_hashes == NULL)
5867     {
5868       const size_t output_file_size = this->output_file_size();
5869       const unsigned char* iv = of->get_input_view(0, output_file_size);
5870       const char* style = parameters->options().build_id();
5871 
5872       // If we get here with style == "tree" then the output must be
5873       // too small for chunking, and we use SHA-1 in that case.
5874       if ((strcmp(style, "sha1") == 0) || (strcmp(style, "tree") == 0))
5875 	sha1_buffer(reinterpret_cast<const char*>(iv), output_file_size, ov);
5876       else if (strcmp(style, "md5") == 0)
5877 	md5_buffer(reinterpret_cast<const char*>(iv), output_file_size, ov);
5878       else
5879 	gold_unreachable();
5880 
5881       of->free_input_view(0, output_file_size, iv);
5882     }
5883   else
5884     {
5885       // Non-overlapping substrings of the output file have been hashed.
5886       // Compute SHA-1 hash of the hashes.
5887       sha1_buffer(reinterpret_cast<const char*>(array_of_hashes),
5888 		  size_of_hashes, ov);
5889       delete[] array_of_hashes;
5890     }
5891 
5892   of->write_output_view(this->build_id_note_->offset(),
5893 			this->build_id_note_->data_size(),
5894 			ov);
5895 }
5896 
5897 // Write out a binary file.  This is called after the link is
5898 // complete.  IN is the temporary output file we used to generate the
5899 // ELF code.  We simply walk through the segments, read them from
5900 // their file offset in IN, and write them to their load address in
5901 // the output file.  FIXME: with a bit more work, we could support
5902 // S-records and/or Intel hex format here.
5903 
5904 void
write_binary(Output_file * in) const5905 Layout::write_binary(Output_file* in) const
5906 {
5907   gold_assert(parameters->options().oformat_enum()
5908 	      == General_options::OBJECT_FORMAT_BINARY);
5909 
5910   // Get the size of the binary file.
5911   uint64_t max_load_address = 0;
5912   for (Segment_list::const_iterator p = this->segment_list_.begin();
5913        p != this->segment_list_.end();
5914        ++p)
5915     {
5916       if ((*p)->type() == elfcpp::PT_LOAD && (*p)->filesz() > 0)
5917 	{
5918 	  uint64_t max_paddr = (*p)->paddr() + (*p)->filesz();
5919 	  if (max_paddr > max_load_address)
5920 	    max_load_address = max_paddr;
5921 	}
5922     }
5923 
5924   Output_file out(parameters->options().output_file_name());
5925   out.open(max_load_address);
5926 
5927   for (Segment_list::const_iterator p = this->segment_list_.begin();
5928        p != this->segment_list_.end();
5929        ++p)
5930     {
5931       if ((*p)->type() == elfcpp::PT_LOAD && (*p)->filesz() > 0)
5932 	{
5933 	  const unsigned char* vin = in->get_input_view((*p)->offset(),
5934 							(*p)->filesz());
5935 	  unsigned char* vout = out.get_output_view((*p)->paddr(),
5936 						    (*p)->filesz());
5937 	  memcpy(vout, vin, (*p)->filesz());
5938 	  out.write_output_view((*p)->paddr(), (*p)->filesz(), vout);
5939 	  in->free_input_view((*p)->offset(), (*p)->filesz(), vin);
5940 	}
5941     }
5942 
5943   out.close();
5944 }
5945 
5946 // Print the output sections to the map file.
5947 
5948 void
print_to_mapfile(Mapfile * mapfile) const5949 Layout::print_to_mapfile(Mapfile* mapfile) const
5950 {
5951   for (Segment_list::const_iterator p = this->segment_list_.begin();
5952        p != this->segment_list_.end();
5953        ++p)
5954     (*p)->print_sections_to_mapfile(mapfile);
5955   for (Section_list::const_iterator p = this->unattached_section_list_.begin();
5956        p != this->unattached_section_list_.end();
5957        ++p)
5958     (*p)->print_to_mapfile(mapfile);
5959 }
5960 
5961 // Print statistical information to stderr.  This is used for --stats.
5962 
5963 void
print_stats() const5964 Layout::print_stats() const
5965 {
5966   this->namepool_.print_stats("section name pool");
5967   this->sympool_.print_stats("output symbol name pool");
5968   this->dynpool_.print_stats("dynamic name pool");
5969 
5970   for (Section_list::const_iterator p = this->section_list_.begin();
5971        p != this->section_list_.end();
5972        ++p)
5973     (*p)->print_merge_stats();
5974 }
5975 
5976 // Write_sections_task methods.
5977 
5978 // We can always run this task.
5979 
5980 Task_token*
is_runnable()5981 Write_sections_task::is_runnable()
5982 {
5983   return NULL;
5984 }
5985 
5986 // We need to unlock both OUTPUT_SECTIONS_BLOCKER and FINAL_BLOCKER
5987 // when finished.
5988 
5989 void
locks(Task_locker * tl)5990 Write_sections_task::locks(Task_locker* tl)
5991 {
5992   tl->add(this, this->output_sections_blocker_);
5993   if (this->input_sections_blocker_ != NULL)
5994     tl->add(this, this->input_sections_blocker_);
5995   tl->add(this, this->final_blocker_);
5996 }
5997 
5998 // Run the task--write out the data.
5999 
6000 void
run(Workqueue *)6001 Write_sections_task::run(Workqueue*)
6002 {
6003   this->layout_->write_output_sections(this->of_);
6004 }
6005 
6006 // Write_data_task methods.
6007 
6008 // We can always run this task.
6009 
6010 Task_token*
is_runnable()6011 Write_data_task::is_runnable()
6012 {
6013   return NULL;
6014 }
6015 
6016 // We need to unlock FINAL_BLOCKER when finished.
6017 
6018 void
locks(Task_locker * tl)6019 Write_data_task::locks(Task_locker* tl)
6020 {
6021   tl->add(this, this->final_blocker_);
6022 }
6023 
6024 // Run the task--write out the data.
6025 
6026 void
run(Workqueue *)6027 Write_data_task::run(Workqueue*)
6028 {
6029   this->layout_->write_data(this->symtab_, this->of_);
6030 }
6031 
6032 // Write_symbols_task methods.
6033 
6034 // We can always run this task.
6035 
6036 Task_token*
is_runnable()6037 Write_symbols_task::is_runnable()
6038 {
6039   return NULL;
6040 }
6041 
6042 // We need to unlock FINAL_BLOCKER when finished.
6043 
6044 void
locks(Task_locker * tl)6045 Write_symbols_task::locks(Task_locker* tl)
6046 {
6047   tl->add(this, this->final_blocker_);
6048 }
6049 
6050 // Run the task--write out the symbols.
6051 
6052 void
run(Workqueue *)6053 Write_symbols_task::run(Workqueue*)
6054 {
6055   this->symtab_->write_globals(this->sympool_, this->dynpool_,
6056 			       this->layout_->symtab_xindex(),
6057 			       this->layout_->dynsym_xindex(), this->of_);
6058 }
6059 
6060 // Write_after_input_sections_task methods.
6061 
6062 // We can only run this task after the input sections have completed.
6063 
6064 Task_token*
is_runnable()6065 Write_after_input_sections_task::is_runnable()
6066 {
6067   if (this->input_sections_blocker_->is_blocked())
6068     return this->input_sections_blocker_;
6069   return NULL;
6070 }
6071 
6072 // We need to unlock FINAL_BLOCKER when finished.
6073 
6074 void
locks(Task_locker * tl)6075 Write_after_input_sections_task::locks(Task_locker* tl)
6076 {
6077   tl->add(this, this->final_blocker_);
6078 }
6079 
6080 // Run the task.
6081 
6082 void
run(Workqueue *)6083 Write_after_input_sections_task::run(Workqueue*)
6084 {
6085   this->layout_->write_sections_after_input_sections(this->of_);
6086 }
6087 
6088 // Build IDs can be computed as a "flat" sha1 or md5 of a string of bytes,
6089 // or as a "tree" where each chunk of the string is hashed and then those
6090 // hashes are put into a (much smaller) string which is hashed with sha1.
6091 // We compute a checksum over the entire file because that is simplest.
6092 
6093 void
run(Workqueue * workqueue,const Task *)6094 Build_id_task_runner::run(Workqueue* workqueue, const Task*)
6095 {
6096   Task_token* post_hash_tasks_blocker = new Task_token(true);
6097   const Layout* layout = this->layout_;
6098   Output_file* of = this->of_;
6099   const size_t filesize = (layout->output_file_size() <= 0 ? 0
6100 			   : static_cast<size_t>(layout->output_file_size()));
6101   unsigned char* array_of_hashes = NULL;
6102   size_t size_of_hashes = 0;
6103 
6104   if (strcmp(this->options_->build_id(), "tree") == 0
6105       && this->options_->build_id_chunk_size_for_treehash() > 0
6106       && filesize > 0
6107       && (filesize >= this->options_->build_id_min_file_size_for_treehash()))
6108     {
6109       static const size_t MD5_OUTPUT_SIZE_IN_BYTES = 16;
6110       const size_t chunk_size =
6111 	  this->options_->build_id_chunk_size_for_treehash();
6112       const size_t num_hashes = ((filesize - 1) / chunk_size) + 1;
6113       post_hash_tasks_blocker->add_blockers(num_hashes);
6114       size_of_hashes = num_hashes * MD5_OUTPUT_SIZE_IN_BYTES;
6115       array_of_hashes = new unsigned char[size_of_hashes];
6116       unsigned char *dst = array_of_hashes;
6117       for (size_t i = 0, src_offset = 0; i < num_hashes;
6118 	   i++, dst += MD5_OUTPUT_SIZE_IN_BYTES, src_offset += chunk_size)
6119 	{
6120 	  size_t size = std::min(chunk_size, filesize - src_offset);
6121 	  workqueue->queue(new Hash_task(of,
6122 					 src_offset,
6123 					 size,
6124 					 dst,
6125 					 post_hash_tasks_blocker));
6126 	}
6127     }
6128 
6129   // Queue the final task to write the build id and close the output file.
6130   workqueue->queue(new Task_function(new Close_task_runner(this->options_,
6131 							   layout,
6132 							   of,
6133 							   array_of_hashes,
6134 							   size_of_hashes),
6135 				     post_hash_tasks_blocker,
6136 				     "Task_function Close_task_runner"));
6137 }
6138 
6139 // Close_task_runner methods.
6140 
6141 // Finish up the build ID computation, if necessary, and write a binary file,
6142 // if necessary.  Then close the output file.
6143 
6144 void
run(Workqueue *,const Task *)6145 Close_task_runner::run(Workqueue*, const Task*)
6146 {
6147   // At this point the multi-threaded part of the build ID computation,
6148   // if any, is done.  See Build_id_task_runner.
6149   this->layout_->write_build_id(this->of_, this->array_of_hashes_,
6150 				this->size_of_hashes_);
6151 
6152   // If we've been asked to create a binary file, we do so here.
6153   if (this->options_->oformat_enum() != General_options::OBJECT_FORMAT_ELF)
6154     this->layout_->write_binary(this->of_);
6155 
6156   this->of_->close();
6157 }
6158 
6159 // Instantiate the templates we need.  We could use the configure
6160 // script to restrict this to only the ones for implemented targets.
6161 
6162 #ifdef HAVE_TARGET_32_LITTLE
6163 template
6164 Output_section*
6165 Layout::init_fixed_output_section<32, false>(
6166     const char* name,
6167     elfcpp::Shdr<32, false>& shdr);
6168 #endif
6169 
6170 #ifdef HAVE_TARGET_32_BIG
6171 template
6172 Output_section*
6173 Layout::init_fixed_output_section<32, true>(
6174     const char* name,
6175     elfcpp::Shdr<32, true>& shdr);
6176 #endif
6177 
6178 #ifdef HAVE_TARGET_64_LITTLE
6179 template
6180 Output_section*
6181 Layout::init_fixed_output_section<64, false>(
6182     const char* name,
6183     elfcpp::Shdr<64, false>& shdr);
6184 #endif
6185 
6186 #ifdef HAVE_TARGET_64_BIG
6187 template
6188 Output_section*
6189 Layout::init_fixed_output_section<64, true>(
6190     const char* name,
6191     elfcpp::Shdr<64, true>& shdr);
6192 #endif
6193 
6194 #ifdef HAVE_TARGET_32_LITTLE
6195 template
6196 Output_section*
6197 Layout::layout<32, false>(Sized_relobj_file<32, false>* object,
6198 			  unsigned int shndx,
6199 			  const char* name,
6200 			  const elfcpp::Shdr<32, false>& shdr,
6201 			  unsigned int, unsigned int, unsigned int, off_t*);
6202 #endif
6203 
6204 #ifdef HAVE_TARGET_32_BIG
6205 template
6206 Output_section*
6207 Layout::layout<32, true>(Sized_relobj_file<32, true>* object,
6208 			 unsigned int shndx,
6209 			 const char* name,
6210 			 const elfcpp::Shdr<32, true>& shdr,
6211 			 unsigned int, unsigned int, unsigned int, off_t*);
6212 #endif
6213 
6214 #ifdef HAVE_TARGET_64_LITTLE
6215 template
6216 Output_section*
6217 Layout::layout<64, false>(Sized_relobj_file<64, false>* object,
6218 			  unsigned int shndx,
6219 			  const char* name,
6220 			  const elfcpp::Shdr<64, false>& shdr,
6221 			  unsigned int, unsigned int, unsigned int, off_t*);
6222 #endif
6223 
6224 #ifdef HAVE_TARGET_64_BIG
6225 template
6226 Output_section*
6227 Layout::layout<64, true>(Sized_relobj_file<64, true>* object,
6228 			 unsigned int shndx,
6229 			 const char* name,
6230 			 const elfcpp::Shdr<64, true>& shdr,
6231 			 unsigned int, unsigned int, unsigned int, off_t*);
6232 #endif
6233 
6234 #ifdef HAVE_TARGET_32_LITTLE
6235 template
6236 Output_section*
6237 Layout::layout_reloc<32, false>(Sized_relobj_file<32, false>* object,
6238 				unsigned int reloc_shndx,
6239 				const elfcpp::Shdr<32, false>& shdr,
6240 				Output_section* data_section,
6241 				Relocatable_relocs* rr);
6242 #endif
6243 
6244 #ifdef HAVE_TARGET_32_BIG
6245 template
6246 Output_section*
6247 Layout::layout_reloc<32, true>(Sized_relobj_file<32, true>* object,
6248 			       unsigned int reloc_shndx,
6249 			       const elfcpp::Shdr<32, true>& shdr,
6250 			       Output_section* data_section,
6251 			       Relocatable_relocs* rr);
6252 #endif
6253 
6254 #ifdef HAVE_TARGET_64_LITTLE
6255 template
6256 Output_section*
6257 Layout::layout_reloc<64, false>(Sized_relobj_file<64, false>* object,
6258 				unsigned int reloc_shndx,
6259 				const elfcpp::Shdr<64, false>& shdr,
6260 				Output_section* data_section,
6261 				Relocatable_relocs* rr);
6262 #endif
6263 
6264 #ifdef HAVE_TARGET_64_BIG
6265 template
6266 Output_section*
6267 Layout::layout_reloc<64, true>(Sized_relobj_file<64, true>* object,
6268 			       unsigned int reloc_shndx,
6269 			       const elfcpp::Shdr<64, true>& shdr,
6270 			       Output_section* data_section,
6271 			       Relocatable_relocs* rr);
6272 #endif
6273 
6274 #ifdef HAVE_TARGET_32_LITTLE
6275 template
6276 void
6277 Layout::layout_group<32, false>(Symbol_table* symtab,
6278 				Sized_relobj_file<32, false>* object,
6279 				unsigned int,
6280 				const char* group_section_name,
6281 				const char* signature,
6282 				const elfcpp::Shdr<32, false>& shdr,
6283 				elfcpp::Elf_Word flags,
6284 				std::vector<unsigned int>* shndxes);
6285 #endif
6286 
6287 #ifdef HAVE_TARGET_32_BIG
6288 template
6289 void
6290 Layout::layout_group<32, true>(Symbol_table* symtab,
6291 			       Sized_relobj_file<32, true>* object,
6292 			       unsigned int,
6293 			       const char* group_section_name,
6294 			       const char* signature,
6295 			       const elfcpp::Shdr<32, true>& shdr,
6296 			       elfcpp::Elf_Word flags,
6297 			       std::vector<unsigned int>* shndxes);
6298 #endif
6299 
6300 #ifdef HAVE_TARGET_64_LITTLE
6301 template
6302 void
6303 Layout::layout_group<64, false>(Symbol_table* symtab,
6304 				Sized_relobj_file<64, false>* object,
6305 				unsigned int,
6306 				const char* group_section_name,
6307 				const char* signature,
6308 				const elfcpp::Shdr<64, false>& shdr,
6309 				elfcpp::Elf_Word flags,
6310 				std::vector<unsigned int>* shndxes);
6311 #endif
6312 
6313 #ifdef HAVE_TARGET_64_BIG
6314 template
6315 void
6316 Layout::layout_group<64, true>(Symbol_table* symtab,
6317 			       Sized_relobj_file<64, true>* object,
6318 			       unsigned int,
6319 			       const char* group_section_name,
6320 			       const char* signature,
6321 			       const elfcpp::Shdr<64, true>& shdr,
6322 			       elfcpp::Elf_Word flags,
6323 			       std::vector<unsigned int>* shndxes);
6324 #endif
6325 
6326 #ifdef HAVE_TARGET_32_LITTLE
6327 template
6328 Output_section*
6329 Layout::layout_eh_frame<32, false>(Sized_relobj_file<32, false>* object,
6330 				   const unsigned char* symbols,
6331 				   off_t symbols_size,
6332 				   const unsigned char* symbol_names,
6333 				   off_t symbol_names_size,
6334 				   unsigned int shndx,
6335 				   const elfcpp::Shdr<32, false>& shdr,
6336 				   unsigned int reloc_shndx,
6337 				   unsigned int reloc_type,
6338 				   off_t* off);
6339 #endif
6340 
6341 #ifdef HAVE_TARGET_32_BIG
6342 template
6343 Output_section*
6344 Layout::layout_eh_frame<32, true>(Sized_relobj_file<32, true>* object,
6345 				  const unsigned char* symbols,
6346 				  off_t symbols_size,
6347 				  const unsigned char* symbol_names,
6348 				  off_t symbol_names_size,
6349 				  unsigned int shndx,
6350 				  const elfcpp::Shdr<32, true>& shdr,
6351 				  unsigned int reloc_shndx,
6352 				  unsigned int reloc_type,
6353 				  off_t* off);
6354 #endif
6355 
6356 #ifdef HAVE_TARGET_64_LITTLE
6357 template
6358 Output_section*
6359 Layout::layout_eh_frame<64, false>(Sized_relobj_file<64, false>* object,
6360 				   const unsigned char* symbols,
6361 				   off_t symbols_size,
6362 				   const unsigned char* symbol_names,
6363 				   off_t symbol_names_size,
6364 				   unsigned int shndx,
6365 				   const elfcpp::Shdr<64, false>& shdr,
6366 				   unsigned int reloc_shndx,
6367 				   unsigned int reloc_type,
6368 				   off_t* off);
6369 #endif
6370 
6371 #ifdef HAVE_TARGET_64_BIG
6372 template
6373 Output_section*
6374 Layout::layout_eh_frame<64, true>(Sized_relobj_file<64, true>* object,
6375 				  const unsigned char* symbols,
6376 				  off_t symbols_size,
6377 				  const unsigned char* symbol_names,
6378 				  off_t symbol_names_size,
6379 				  unsigned int shndx,
6380 				  const elfcpp::Shdr<64, true>& shdr,
6381 				  unsigned int reloc_shndx,
6382 				  unsigned int reloc_type,
6383 				  off_t* off);
6384 #endif
6385 
6386 #ifdef HAVE_TARGET_32_LITTLE
6387 template
6388 void
6389 Layout::add_to_gdb_index(bool is_type_unit,
6390 			 Sized_relobj<32, false>* object,
6391 			 const unsigned char* symbols,
6392 			 off_t symbols_size,
6393 			 unsigned int shndx,
6394 			 unsigned int reloc_shndx,
6395 			 unsigned int reloc_type);
6396 #endif
6397 
6398 #ifdef HAVE_TARGET_32_BIG
6399 template
6400 void
6401 Layout::add_to_gdb_index(bool is_type_unit,
6402 			 Sized_relobj<32, true>* object,
6403 			 const unsigned char* symbols,
6404 			 off_t symbols_size,
6405 			 unsigned int shndx,
6406 			 unsigned int reloc_shndx,
6407 			 unsigned int reloc_type);
6408 #endif
6409 
6410 #ifdef HAVE_TARGET_64_LITTLE
6411 template
6412 void
6413 Layout::add_to_gdb_index(bool is_type_unit,
6414 			 Sized_relobj<64, false>* object,
6415 			 const unsigned char* symbols,
6416 			 off_t symbols_size,
6417 			 unsigned int shndx,
6418 			 unsigned int reloc_shndx,
6419 			 unsigned int reloc_type);
6420 #endif
6421 
6422 #ifdef HAVE_TARGET_64_BIG
6423 template
6424 void
6425 Layout::add_to_gdb_index(bool is_type_unit,
6426 			 Sized_relobj<64, true>* object,
6427 			 const unsigned char* symbols,
6428 			 off_t symbols_size,
6429 			 unsigned int shndx,
6430 			 unsigned int reloc_shndx,
6431 			 unsigned int reloc_type);
6432 #endif
6433 
6434 } // End namespace gold.
6435