1 // object.cc -- support for an object file for linking in gold
2 
3 // Copyright (C) 2006-2021 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 <cstdarg>
28 #include "demangle.h"
29 #include "libiberty.h"
30 
31 #include "gc.h"
32 #include "target-select.h"
33 #include "dwarf_reader.h"
34 #include "layout.h"
35 #include "output.h"
36 #include "symtab.h"
37 #include "cref.h"
38 #include "reloc.h"
39 #include "object.h"
40 #include "dynobj.h"
41 #include "plugin.h"
42 #include "compressed_output.h"
43 #include "incremental.h"
44 #include "merge.h"
45 
46 namespace gold
47 {
48 
49 // Struct Read_symbols_data.
50 
51 // Destroy any remaining File_view objects and buffers of decompressed
52 // sections.
53 
~Read_symbols_data()54 Read_symbols_data::~Read_symbols_data()
55 {
56   if (this->section_headers != NULL)
57     delete this->section_headers;
58   if (this->section_names != NULL)
59     delete this->section_names;
60   if (this->symbols != NULL)
61     delete this->symbols;
62   if (this->symbol_names != NULL)
63     delete this->symbol_names;
64   if (this->versym != NULL)
65     delete this->versym;
66   if (this->verdef != NULL)
67     delete this->verdef;
68   if (this->verneed != NULL)
69     delete this->verneed;
70 }
71 
72 // Class Xindex.
73 
74 // Initialize the symtab_xindex_ array.  Find the SHT_SYMTAB_SHNDX
75 // section and read it in.  SYMTAB_SHNDX is the index of the symbol
76 // table we care about.
77 
78 template<int size, bool big_endian>
79 void
initialize_symtab_xindex(Object * object,unsigned int symtab_shndx)80 Xindex::initialize_symtab_xindex(Object* object, unsigned int symtab_shndx)
81 {
82   if (!this->symtab_xindex_.empty())
83     return;
84 
85   gold_assert(symtab_shndx != 0);
86 
87   // Look through the sections in reverse order, on the theory that it
88   // is more likely to be near the end than the beginning.
89   unsigned int i = object->shnum();
90   while (i > 0)
91     {
92       --i;
93       if (object->section_type(i) == elfcpp::SHT_SYMTAB_SHNDX
94 	  && this->adjust_shndx(object->section_link(i)) == symtab_shndx)
95 	{
96 	  this->read_symtab_xindex<size, big_endian>(object, i, NULL);
97 	  return;
98 	}
99     }
100 
101   object->error(_("missing SHT_SYMTAB_SHNDX section"));
102 }
103 
104 // Read in the symtab_xindex_ array, given the section index of the
105 // SHT_SYMTAB_SHNDX section.  If PSHDRS is not NULL, it points at the
106 // section headers.
107 
108 template<int size, bool big_endian>
109 void
read_symtab_xindex(Object * object,unsigned int xindex_shndx,const unsigned char * pshdrs)110 Xindex::read_symtab_xindex(Object* object, unsigned int xindex_shndx,
111 			   const unsigned char* pshdrs)
112 {
113   section_size_type bytecount;
114   const unsigned char* contents;
115   if (pshdrs == NULL)
116     contents = object->section_contents(xindex_shndx, &bytecount, false);
117   else
118     {
119       const unsigned char* p = (pshdrs
120 				+ (xindex_shndx
121 				   * elfcpp::Elf_sizes<size>::shdr_size));
122       typename elfcpp::Shdr<size, big_endian> shdr(p);
123       bytecount = convert_to_section_size_type(shdr.get_sh_size());
124       contents = object->get_view(shdr.get_sh_offset(), bytecount, true, false);
125     }
126 
127   gold_assert(this->symtab_xindex_.empty());
128   this->symtab_xindex_.reserve(bytecount / 4);
129   for (section_size_type i = 0; i < bytecount; i += 4)
130     {
131       unsigned int shndx = elfcpp::Swap<32, big_endian>::readval(contents + i);
132       // We preadjust the section indexes we save.
133       this->symtab_xindex_.push_back(this->adjust_shndx(shndx));
134     }
135 }
136 
137 // Symbol symndx has a section of SHN_XINDEX; return the real section
138 // index.
139 
140 unsigned int
sym_xindex_to_shndx(Object * object,unsigned int symndx)141 Xindex::sym_xindex_to_shndx(Object* object, unsigned int symndx)
142 {
143   if (symndx >= this->symtab_xindex_.size())
144     {
145       object->error(_("symbol %u out of range for SHT_SYMTAB_SHNDX section"),
146 		    symndx);
147       return elfcpp::SHN_UNDEF;
148     }
149   unsigned int shndx = this->symtab_xindex_[symndx];
150   if (shndx < elfcpp::SHN_LORESERVE || shndx >= object->shnum())
151     {
152       object->error(_("extended index for symbol %u out of range: %u"),
153 		    symndx, shndx);
154       return elfcpp::SHN_UNDEF;
155     }
156   return shndx;
157 }
158 
159 // Class Object.
160 
161 // Report an error for this object file.  This is used by the
162 // elfcpp::Elf_file interface, and also called by the Object code
163 // itself.
164 
165 void
error(const char * format,...) const166 Object::error(const char* format, ...) const
167 {
168   va_list args;
169   va_start(args, format);
170   char* buf = NULL;
171   if (vasprintf(&buf, format, args) < 0)
172     gold_nomem();
173   va_end(args);
174   gold_error(_("%s: %s"), this->name().c_str(), buf);
175   free(buf);
176 }
177 
178 // Return a view of the contents of a section.
179 
180 const unsigned char*
section_contents(unsigned int shndx,section_size_type * plen,bool cache)181 Object::section_contents(unsigned int shndx, section_size_type* plen,
182 			 bool cache)
183 { return this->do_section_contents(shndx, plen, cache); }
184 
185 // Read the section data into SD.  This is code common to Sized_relobj_file
186 // and Sized_dynobj, so we put it into Object.
187 
188 template<int size, bool big_endian>
189 void
read_section_data(elfcpp::Elf_file<size,big_endian,Object> * elf_file,Read_symbols_data * sd)190 Object::read_section_data(elfcpp::Elf_file<size, big_endian, Object>* elf_file,
191 			  Read_symbols_data* sd)
192 {
193   const int shdr_size = elfcpp::Elf_sizes<size>::shdr_size;
194 
195   // Read the section headers.
196   const off_t shoff = elf_file->shoff();
197   const unsigned int shnum = this->shnum();
198   sd->section_headers = this->get_lasting_view(shoff, shnum * shdr_size,
199 					       true, true);
200 
201   // Read the section names.
202   const unsigned char* pshdrs = sd->section_headers->data();
203   const unsigned char* pshdrnames = pshdrs + elf_file->shstrndx() * shdr_size;
204   typename elfcpp::Shdr<size, big_endian> shdrnames(pshdrnames);
205 
206   if (shdrnames.get_sh_type() != elfcpp::SHT_STRTAB)
207     this->error(_("section name section has wrong type: %u"),
208 		static_cast<unsigned int>(shdrnames.get_sh_type()));
209 
210   sd->section_names_size =
211     convert_to_section_size_type(shdrnames.get_sh_size());
212   sd->section_names = this->get_lasting_view(shdrnames.get_sh_offset(),
213 					     sd->section_names_size, false,
214 					     false);
215 }
216 
217 // If NAME is the name of a special .gnu.warning section, arrange for
218 // the warning to be issued.  SHNDX is the section index.  Return
219 // whether it is a warning section.
220 
221 bool
handle_gnu_warning_section(const char * name,unsigned int shndx,Symbol_table * symtab)222 Object::handle_gnu_warning_section(const char* name, unsigned int shndx,
223 				   Symbol_table* symtab)
224 {
225   const char warn_prefix[] = ".gnu.warning.";
226   const int warn_prefix_len = sizeof warn_prefix - 1;
227   if (strncmp(name, warn_prefix, warn_prefix_len) == 0)
228     {
229       // Read the section contents to get the warning text.  It would
230       // be nicer if we only did this if we have to actually issue a
231       // warning.  Unfortunately, warnings are issued as we relocate
232       // sections.  That means that we can not lock the object then,
233       // as we might try to issue the same warning multiple times
234       // simultaneously.
235       section_size_type len;
236       const unsigned char* contents = this->section_contents(shndx, &len,
237 							     false);
238       if (len == 0)
239 	{
240 	  const char* warning = name + warn_prefix_len;
241 	  contents = reinterpret_cast<const unsigned char*>(warning);
242 	  len = strlen(warning);
243 	}
244       std::string warning(reinterpret_cast<const char*>(contents), len);
245       symtab->add_warning(name + warn_prefix_len, this, warning);
246       return true;
247     }
248   return false;
249 }
250 
251 // If NAME is the name of the special section which indicates that
252 // this object was compiled with -fsplit-stack, mark it accordingly.
253 
254 bool
handle_split_stack_section(const char * name)255 Object::handle_split_stack_section(const char* name)
256 {
257   if (strcmp(name, ".note.GNU-split-stack") == 0)
258     {
259       this->uses_split_stack_ = true;
260       return true;
261     }
262   if (strcmp(name, ".note.GNU-no-split-stack") == 0)
263     {
264       this->has_no_split_stack_ = true;
265       return true;
266     }
267   return false;
268 }
269 
270 // Class Relobj
271 
272 template<int size>
273 void
initialize_input_to_output_map(unsigned int shndx,typename elfcpp::Elf_types<size>::Elf_Addr starting_address,Unordered_map<section_offset_type,typename elfcpp::Elf_types<size>::Elf_Addr> * output_addresses) const274 Relobj::initialize_input_to_output_map(unsigned int shndx,
275 	  typename elfcpp::Elf_types<size>::Elf_Addr starting_address,
276 	  Unordered_map<section_offset_type,
277 	  typename elfcpp::Elf_types<size>::Elf_Addr>* output_addresses) const {
278   Object_merge_map *map = this->object_merge_map_;
279   map->initialize_input_to_output_map<size>(shndx, starting_address,
280 					    output_addresses);
281 }
282 
283 void
add_merge_mapping(Output_section_data * output_data,unsigned int shndx,section_offset_type offset,section_size_type length,section_offset_type output_offset)284 Relobj::add_merge_mapping(Output_section_data *output_data,
285                           unsigned int shndx, section_offset_type offset,
286                           section_size_type length,
287                           section_offset_type output_offset) {
288   Object_merge_map* object_merge_map = this->get_or_create_merge_map();
289   object_merge_map->add_mapping(output_data, shndx, offset, length, output_offset);
290 }
291 
292 bool
merge_output_offset(unsigned int shndx,section_offset_type offset,section_offset_type * poutput) const293 Relobj::merge_output_offset(unsigned int shndx, section_offset_type offset,
294                             section_offset_type *poutput) const {
295   Object_merge_map* object_merge_map = this->object_merge_map_;
296   if (object_merge_map == NULL)
297     return false;
298   return object_merge_map->get_output_offset(shndx, offset, poutput);
299 }
300 
301 const Output_section_data*
find_merge_section(unsigned int shndx) const302 Relobj::find_merge_section(unsigned int shndx) const {
303   Object_merge_map* object_merge_map = this->object_merge_map_;
304   if (object_merge_map == NULL)
305     return NULL;
306   return object_merge_map->find_merge_section(shndx);
307 }
308 
309 // To copy the symbols data read from the file to a local data structure.
310 // This function is called from do_layout only while doing garbage
311 // collection.
312 
313 void
copy_symbols_data(Symbols_data * gc_sd,Read_symbols_data * sd,unsigned int section_header_size)314 Relobj::copy_symbols_data(Symbols_data* gc_sd, Read_symbols_data* sd,
315 			  unsigned int section_header_size)
316 {
317   gc_sd->section_headers_data =
318 	 new unsigned char[(section_header_size)];
319   memcpy(gc_sd->section_headers_data, sd->section_headers->data(),
320 	 section_header_size);
321   gc_sd->section_names_data =
322 	 new unsigned char[sd->section_names_size];
323   memcpy(gc_sd->section_names_data, sd->section_names->data(),
324 	 sd->section_names_size);
325   gc_sd->section_names_size = sd->section_names_size;
326   if (sd->symbols != NULL)
327     {
328       gc_sd->symbols_data =
329 	     new unsigned char[sd->symbols_size];
330       memcpy(gc_sd->symbols_data, sd->symbols->data(),
331 	    sd->symbols_size);
332     }
333   else
334     {
335       gc_sd->symbols_data = NULL;
336     }
337   gc_sd->symbols_size = sd->symbols_size;
338   gc_sd->external_symbols_offset = sd->external_symbols_offset;
339   if (sd->symbol_names != NULL)
340     {
341       gc_sd->symbol_names_data =
342 	     new unsigned char[sd->symbol_names_size];
343       memcpy(gc_sd->symbol_names_data, sd->symbol_names->data(),
344 	    sd->symbol_names_size);
345     }
346   else
347     {
348       gc_sd->symbol_names_data = NULL;
349     }
350   gc_sd->symbol_names_size = sd->symbol_names_size;
351 }
352 
353 // This function determines if a particular section name must be included
354 // in the link.  This is used during garbage collection to determine the
355 // roots of the worklist.
356 
357 bool
is_section_name_included(const char * name)358 Relobj::is_section_name_included(const char* name)
359 {
360   if (is_prefix_of(".ctors", name)
361       || is_prefix_of(".dtors", name)
362       || is_prefix_of(".note", name)
363       || is_prefix_of(".init", name)
364       || is_prefix_of(".fini", name)
365       || is_prefix_of(".gcc_except_table", name)
366       || is_prefix_of(".jcr", name)
367       || is_prefix_of(".preinit_array", name)
368       || (is_prefix_of(".text", name)
369 	  && strstr(name, "personality"))
370       || (is_prefix_of(".data", name)
371 	  && strstr(name, "personality"))
372       || (is_prefix_of(".sdata", name)
373 	  && strstr(name, "personality"))
374       || (is_prefix_of(".gnu.linkonce.d", name)
375 	  && strstr(name, "personality"))
376       || (is_prefix_of(".rodata", name)
377 	  && strstr(name, "nptl_version")))
378     {
379       return true;
380     }
381   return false;
382 }
383 
384 // Finalize the incremental relocation information.  Allocates a block
385 // of relocation entries for each symbol, and sets the reloc_bases_
386 // array to point to the first entry in each block.  If CLEAR_COUNTS
387 // is TRUE, also clear the per-symbol relocation counters.
388 
389 void
finalize_incremental_relocs(Layout * layout,bool clear_counts)390 Relobj::finalize_incremental_relocs(Layout* layout, bool clear_counts)
391 {
392   unsigned int nsyms = this->get_global_symbols()->size();
393   this->reloc_bases_ = new unsigned int[nsyms];
394 
395   gold_assert(this->reloc_bases_ != NULL);
396   gold_assert(layout->incremental_inputs() != NULL);
397 
398   unsigned int rindex = layout->incremental_inputs()->get_reloc_count();
399   for (unsigned int i = 0; i < nsyms; ++i)
400     {
401       this->reloc_bases_[i] = rindex;
402       rindex += this->reloc_counts_[i];
403       if (clear_counts)
404 	this->reloc_counts_[i] = 0;
405     }
406   layout->incremental_inputs()->set_reloc_count(rindex);
407 }
408 
409 Object_merge_map*
get_or_create_merge_map()410 Relobj::get_or_create_merge_map()
411 {
412   if (!this->object_merge_map_)
413     this->object_merge_map_ = new Object_merge_map();
414   return this->object_merge_map_;
415 }
416 
417 // Class Sized_relobj.
418 
419 // Iterate over local symbols, calling a visitor class V for each GOT offset
420 // associated with a local symbol.
421 
422 template<int size, bool big_endian>
423 void
do_for_all_local_got_entries(Got_offset_list::Visitor * v) const424 Sized_relobj<size, big_endian>::do_for_all_local_got_entries(
425     Got_offset_list::Visitor* v) const
426 {
427   unsigned int nsyms = this->local_symbol_count();
428   for (unsigned int i = 0; i < nsyms; i++)
429     {
430       Local_got_entry_key key(i, 0);
431       Local_got_offsets::const_iterator p = this->local_got_offsets_.find(key);
432       if (p != this->local_got_offsets_.end())
433 	{
434 	  const Got_offset_list* got_offsets = p->second;
435 	  got_offsets->for_all_got_offsets(v);
436 	}
437     }
438 }
439 
440 // Get the address of an output section.
441 
442 template<int size, bool big_endian>
443 uint64_t
do_output_section_address(unsigned int shndx)444 Sized_relobj<size, big_endian>::do_output_section_address(
445     unsigned int shndx)
446 {
447   // If the input file is linked as --just-symbols, the output
448   // section address is the input section address.
449   if (this->just_symbols())
450     return this->section_address(shndx);
451 
452   const Output_section* os = this->do_output_section(shndx);
453   gold_assert(os != NULL);
454   return os->address();
455 }
456 
457 // Class Sized_relobj_file.
458 
459 template<int size, bool big_endian>
Sized_relobj_file(const std::string & name,Input_file * input_file,off_t offset,const elfcpp::Ehdr<size,big_endian> & ehdr)460 Sized_relobj_file<size, big_endian>::Sized_relobj_file(
461     const std::string& name,
462     Input_file* input_file,
463     off_t offset,
464     const elfcpp::Ehdr<size, big_endian>& ehdr)
465   : Sized_relobj<size, big_endian>(name, input_file, offset),
466     elf_file_(this, ehdr),
467     osabi_(ehdr.get_ei_osabi()),
468     e_type_(ehdr.get_e_type()),
469     symtab_shndx_(-1U),
470     local_symbol_count_(0),
471     output_local_symbol_count_(0),
472     output_local_dynsym_count_(0),
473     symbols_(),
474     defined_count_(0),
475     local_symbol_offset_(0),
476     local_dynsym_offset_(0),
477     local_values_(),
478     local_plt_offsets_(),
479     kept_comdat_sections_(),
480     has_eh_frame_(false),
481     is_deferred_layout_(false),
482     deferred_layout_(),
483     deferred_layout_relocs_(),
484     output_views_(NULL)
485 {
486 }
487 
488 template<int size, bool big_endian>
~Sized_relobj_file()489 Sized_relobj_file<size, big_endian>::~Sized_relobj_file()
490 {
491 }
492 
493 // Set up an object file based on the file header.  This sets up the
494 // section information.
495 
496 template<int size, bool big_endian>
497 void
do_setup()498 Sized_relobj_file<size, big_endian>::do_setup()
499 {
500   const unsigned int shnum = this->elf_file_.shnum();
501   this->set_shnum(shnum);
502 }
503 
504 // Find the SHT_SYMTAB section, given the section headers.  The ELF
505 // standard says that maybe in the future there can be more than one
506 // SHT_SYMTAB section.  Until somebody figures out how that could
507 // work, we assume there is only one.
508 
509 template<int size, bool big_endian>
510 void
find_symtab(const unsigned char * pshdrs)511 Sized_relobj_file<size, big_endian>::find_symtab(const unsigned char* pshdrs)
512 {
513   const unsigned int shnum = this->shnum();
514   this->symtab_shndx_ = 0;
515   if (shnum > 0)
516     {
517       // Look through the sections in reverse order, since gas tends
518       // to put the symbol table at the end.
519       const unsigned char* p = pshdrs + shnum * This::shdr_size;
520       unsigned int i = shnum;
521       unsigned int xindex_shndx = 0;
522       unsigned int xindex_link = 0;
523       while (i > 0)
524 	{
525 	  --i;
526 	  p -= This::shdr_size;
527 	  typename This::Shdr shdr(p);
528 	  if (shdr.get_sh_type() == elfcpp::SHT_SYMTAB)
529 	    {
530 	      this->symtab_shndx_ = i;
531 	      if (xindex_shndx > 0 && xindex_link == i)
532 		{
533 		  Xindex* xindex =
534 		    new Xindex(this->elf_file_.large_shndx_offset());
535 		  xindex->read_symtab_xindex<size, big_endian>(this,
536 							       xindex_shndx,
537 							       pshdrs);
538 		  this->set_xindex(xindex);
539 		}
540 	      break;
541 	    }
542 
543 	  // Try to pick up the SHT_SYMTAB_SHNDX section, if there is
544 	  // one.  This will work if it follows the SHT_SYMTAB
545 	  // section.
546 	  if (shdr.get_sh_type() == elfcpp::SHT_SYMTAB_SHNDX)
547 	    {
548 	      xindex_shndx = i;
549 	      xindex_link = this->adjust_shndx(shdr.get_sh_link());
550 	    }
551 	}
552     }
553 }
554 
555 // Return the Xindex structure to use for object with lots of
556 // sections.
557 
558 template<int size, bool big_endian>
559 Xindex*
do_initialize_xindex()560 Sized_relobj_file<size, big_endian>::do_initialize_xindex()
561 {
562   gold_assert(this->symtab_shndx_ != -1U);
563   Xindex* xindex = new Xindex(this->elf_file_.large_shndx_offset());
564   xindex->initialize_symtab_xindex<size, big_endian>(this, this->symtab_shndx_);
565   return xindex;
566 }
567 
568 // Return whether SHDR has the right type and flags to be a GNU
569 // .eh_frame section.
570 
571 template<int size, bool big_endian>
572 bool
check_eh_frame_flags(const elfcpp::Shdr<size,big_endian> * shdr) const573 Sized_relobj_file<size, big_endian>::check_eh_frame_flags(
574     const elfcpp::Shdr<size, big_endian>* shdr) const
575 {
576   elfcpp::Elf_Word sh_type = shdr->get_sh_type();
577   return ((sh_type == elfcpp::SHT_PROGBITS
578 	   || sh_type == parameters->target().unwind_section_type())
579 	  && (shdr->get_sh_flags() & elfcpp::SHF_ALLOC) != 0);
580 }
581 
582 // Find the section header with the given name.
583 
584 template<int size, bool big_endian>
585 const unsigned char*
find_shdr(const unsigned char * pshdrs,const char * name,const char * names,section_size_type names_size,const unsigned char * hdr) const586 Object::find_shdr(
587     const unsigned char* pshdrs,
588     const char* name,
589     const char* names,
590     section_size_type names_size,
591     const unsigned char* hdr) const
592 {
593   const int shdr_size = elfcpp::Elf_sizes<size>::shdr_size;
594   const unsigned int shnum = this->shnum();
595   const unsigned char* hdr_end = pshdrs + shdr_size * shnum;
596   size_t sh_name = 0;
597 
598   while (1)
599     {
600       if (hdr)
601 	{
602 	  // We found HDR last time we were called, continue looking.
603 	  typename elfcpp::Shdr<size, big_endian> shdr(hdr);
604 	  sh_name = shdr.get_sh_name();
605 	}
606       else
607 	{
608 	  // Look for the next occurrence of NAME in NAMES.
609 	  // The fact that .shstrtab produced by current GNU tools is
610 	  // string merged means we shouldn't have both .not.foo and
611 	  // .foo in .shstrtab, and multiple .foo sections should all
612 	  // have the same sh_name.  However, this is not guaranteed
613 	  // by the ELF spec and not all ELF object file producers may
614 	  // be so clever.
615 	  size_t len = strlen(name) + 1;
616 	  const char *p = sh_name ? names + sh_name + len : names;
617 	  p = reinterpret_cast<const char*>(memmem(p, names_size - (p - names),
618 						   name, len));
619 	  if (p == NULL)
620 	    return NULL;
621 	  sh_name = p - names;
622 	  hdr = pshdrs;
623 	  if (sh_name == 0)
624 	    return hdr;
625 	}
626 
627       hdr += shdr_size;
628       while (hdr < hdr_end)
629 	{
630 	  typename elfcpp::Shdr<size, big_endian> shdr(hdr);
631 	  if (shdr.get_sh_name() == sh_name)
632 	    return hdr;
633 	  hdr += shdr_size;
634 	}
635       hdr = NULL;
636       if (sh_name == 0)
637 	return hdr;
638     }
639 }
640 
641 // Return whether there is a GNU .eh_frame section, given the section
642 // headers and the section names.
643 
644 template<int size, bool big_endian>
645 bool
find_eh_frame(const unsigned char * pshdrs,const char * names,section_size_type names_size) const646 Sized_relobj_file<size, big_endian>::find_eh_frame(
647     const unsigned char* pshdrs,
648     const char* names,
649     section_size_type names_size) const
650 {
651   const unsigned char* s = NULL;
652 
653   while (1)
654     {
655       s = this->template find_shdr<size, big_endian>(pshdrs, ".eh_frame",
656 						     names, names_size, s);
657       if (s == NULL)
658 	return false;
659 
660       typename This::Shdr shdr(s);
661       if (this->check_eh_frame_flags(&shdr))
662 	return true;
663     }
664 }
665 
666 // Return TRUE if this is a section whose contents will be needed in the
667 // Add_symbols task.  This function is only called for sections that have
668 // already passed the test in is_compressed_debug_section() and the debug
669 // section name prefix, ".debug"/".zdebug", has been skipped.
670 
671 static bool
need_decompressed_section(const char * name)672 need_decompressed_section(const char* name)
673 {
674   if (*name++ != '_')
675     return false;
676 
677 #ifdef ENABLE_THREADS
678   // Decompressing these sections now will help only if we're
679   // multithreaded.
680   if (parameters->options().threads())
681     {
682       // We will need .zdebug_str if this is not an incremental link
683       // (i.e., we are processing string merge sections) or if we need
684       // to build a gdb index.
685       if ((!parameters->incremental() || parameters->options().gdb_index())
686 	  && strcmp(name, "str") == 0)
687 	return true;
688 
689       // We will need these other sections when building a gdb index.
690       if (parameters->options().gdb_index()
691 	  && (strcmp(name, "info") == 0
692 	      || strcmp(name, "types") == 0
693 	      || strcmp(name, "pubnames") == 0
694 	      || strcmp(name, "pubtypes") == 0
695 	      || strcmp(name, "ranges") == 0
696 	      || strcmp(name, "abbrev") == 0))
697 	return true;
698     }
699 #endif
700 
701   // Even when single-threaded, we will need .zdebug_str if this is
702   // not an incremental link and we are building a gdb index.
703   // Otherwise, we would decompress the section twice: once for
704   // string merge processing, and once for building the gdb index.
705   if (!parameters->incremental()
706       && parameters->options().gdb_index()
707       && strcmp(name, "str") == 0)
708     return true;
709 
710   return false;
711 }
712 
713 // Build a table for any compressed debug sections, mapping each section index
714 // to the uncompressed size and (if needed) the decompressed contents.
715 
716 template<int size, bool big_endian>
717 Compressed_section_map*
build_compressed_section_map(const unsigned char * pshdrs,unsigned int shnum,const char * names,section_size_type names_size,Object * obj,bool decompress_if_needed)718 build_compressed_section_map(
719     const unsigned char* pshdrs,
720     unsigned int shnum,
721     const char* names,
722     section_size_type names_size,
723     Object* obj,
724     bool decompress_if_needed)
725 {
726   Compressed_section_map* uncompressed_map = new Compressed_section_map();
727   const unsigned int shdr_size = elfcpp::Elf_sizes<size>::shdr_size;
728   const unsigned char* p = pshdrs + shdr_size;
729 
730   for (unsigned int i = 1; i < shnum; ++i, p += shdr_size)
731     {
732       typename elfcpp::Shdr<size, big_endian> shdr(p);
733       if (shdr.get_sh_type() == elfcpp::SHT_PROGBITS
734 	  && (shdr.get_sh_flags() & elfcpp::SHF_ALLOC) == 0)
735 	{
736 	  if (shdr.get_sh_name() >= names_size)
737 	    {
738 	      obj->error(_("bad section name offset for section %u: %lu"),
739 			 i, static_cast<unsigned long>(shdr.get_sh_name()));
740 	      continue;
741 	    }
742 
743 	  const char* name = names + shdr.get_sh_name();
744 	  bool is_compressed = ((shdr.get_sh_flags()
745 				 & elfcpp::SHF_COMPRESSED) != 0);
746 	  bool is_zcompressed = (!is_compressed
747 				 && is_compressed_debug_section(name));
748 
749 	  if (is_zcompressed || is_compressed)
750 	    {
751 	      section_size_type len;
752 	      const unsigned char* contents =
753 		  obj->section_contents(i, &len, false);
754 	      uint64_t uncompressed_size;
755 	      Compressed_section_info info;
756 	      if (is_zcompressed)
757 		{
758 		  // Skip over the ".zdebug" prefix.
759 		  name += 7;
760 		  uncompressed_size = get_uncompressed_size(contents, len);
761 		  info.addralign = shdr.get_sh_addralign();
762 		}
763 	      else
764 		{
765 		  // Skip over the ".debug" prefix.
766 		  name += 6;
767 		  elfcpp::Chdr<size, big_endian> chdr(contents);
768 		  uncompressed_size = chdr.get_ch_size();
769 		  info.addralign = chdr.get_ch_addralign();
770 		}
771 	      info.size = convert_to_section_size_type(uncompressed_size);
772 	      info.flag = shdr.get_sh_flags();
773 	      info.contents = NULL;
774 	      if (uncompressed_size != -1ULL)
775 		{
776 		  unsigned char* uncompressed_data = NULL;
777 		  if (decompress_if_needed && need_decompressed_section(name))
778 		    {
779 		      uncompressed_data = new unsigned char[uncompressed_size];
780 		      if (decompress_input_section(contents, len,
781 						   uncompressed_data,
782 						   uncompressed_size,
783 						   size, big_endian,
784 						   shdr.get_sh_flags()))
785 			info.contents = uncompressed_data;
786 		      else
787 			delete[] uncompressed_data;
788 		    }
789 		  (*uncompressed_map)[i] = info;
790 		}
791 	    }
792 	}
793     }
794   return uncompressed_map;
795 }
796 
797 // Stash away info for a number of special sections.
798 // Return true if any of the sections found require local symbols to be read.
799 
800 template<int size, bool big_endian>
801 bool
do_find_special_sections(Read_symbols_data * sd)802 Sized_relobj_file<size, big_endian>::do_find_special_sections(
803     Read_symbols_data* sd)
804 {
805   const unsigned char* const pshdrs = sd->section_headers->data();
806   const unsigned char* namesu = sd->section_names->data();
807   const char* names = reinterpret_cast<const char*>(namesu);
808 
809   if (this->find_eh_frame(pshdrs, names, sd->section_names_size))
810     this->has_eh_frame_ = true;
811 
812   Compressed_section_map* compressed_sections =
813     build_compressed_section_map<size, big_endian>(
814       pshdrs, this->shnum(), names, sd->section_names_size, this, true);
815   if (compressed_sections != NULL)
816     this->set_compressed_sections(compressed_sections);
817 
818   return (this->has_eh_frame_
819 	  || (!parameters->options().relocatable()
820 	      && parameters->options().gdb_index()
821 	      && (memmem(names, sd->section_names_size, "debug_info", 11) != NULL
822 		  || memmem(names, sd->section_names_size,
823 			    "debug_types", 12) != NULL)));
824 }
825 
826 // Read the sections and symbols from an object file.
827 
828 template<int size, bool big_endian>
829 void
do_read_symbols(Read_symbols_data * sd)830 Sized_relobj_file<size, big_endian>::do_read_symbols(Read_symbols_data* sd)
831 {
832   this->base_read_symbols(sd);
833 }
834 
835 // Read the sections and symbols from an object file.  This is common
836 // code for all target-specific overrides of do_read_symbols().
837 
838 template<int size, bool big_endian>
839 void
base_read_symbols(Read_symbols_data * sd)840 Sized_relobj_file<size, big_endian>::base_read_symbols(Read_symbols_data* sd)
841 {
842   this->read_section_data(&this->elf_file_, sd);
843 
844   const unsigned char* const pshdrs = sd->section_headers->data();
845 
846   this->find_symtab(pshdrs);
847 
848   bool need_local_symbols = this->do_find_special_sections(sd);
849 
850   sd->symbols = NULL;
851   sd->symbols_size = 0;
852   sd->external_symbols_offset = 0;
853   sd->symbol_names = NULL;
854   sd->symbol_names_size = 0;
855 
856   if (this->symtab_shndx_ == 0)
857     {
858       // No symbol table.  Weird but legal.
859       return;
860     }
861 
862   // Get the symbol table section header.
863   typename This::Shdr symtabshdr(pshdrs
864 				 + this->symtab_shndx_ * This::shdr_size);
865   gold_assert(symtabshdr.get_sh_type() == elfcpp::SHT_SYMTAB);
866 
867   // If this object has a .eh_frame section, or if building a .gdb_index
868   // section and there is debug info, we need all the symbols.
869   // Otherwise we only need the external symbols.  While it would be
870   // simpler to just always read all the symbols, I've seen object
871   // files with well over 2000 local symbols, which for a 64-bit
872   // object file format is over 5 pages that we don't need to read
873   // now.
874 
875   const int sym_size = This::sym_size;
876   const unsigned int loccount = symtabshdr.get_sh_info();
877   this->local_symbol_count_ = loccount;
878   this->local_values_.resize(loccount);
879   section_offset_type locsize = loccount * sym_size;
880   off_t dataoff = symtabshdr.get_sh_offset();
881   section_size_type datasize =
882     convert_to_section_size_type(symtabshdr.get_sh_size());
883   off_t extoff = dataoff + locsize;
884   section_size_type extsize = datasize - locsize;
885 
886   off_t readoff = need_local_symbols ? dataoff : extoff;
887   section_size_type readsize = need_local_symbols ? datasize : extsize;
888 
889   if (readsize == 0)
890     {
891       // No external symbols.  Also weird but also legal.
892       return;
893     }
894 
895   File_view* fvsymtab = this->get_lasting_view(readoff, readsize, true, false);
896 
897   // Read the section header for the symbol names.
898   unsigned int strtab_shndx = this->adjust_shndx(symtabshdr.get_sh_link());
899   if (strtab_shndx >= this->shnum())
900     {
901       this->error(_("invalid symbol table name index: %u"), strtab_shndx);
902       return;
903     }
904   typename This::Shdr strtabshdr(pshdrs + strtab_shndx * This::shdr_size);
905   if (strtabshdr.get_sh_type() != elfcpp::SHT_STRTAB)
906     {
907       this->error(_("symbol table name section has wrong type: %u"),
908 		  static_cast<unsigned int>(strtabshdr.get_sh_type()));
909       return;
910     }
911 
912   // Read the symbol names.
913   File_view* fvstrtab = this->get_lasting_view(strtabshdr.get_sh_offset(),
914 					       strtabshdr.get_sh_size(),
915 					       false, true);
916 
917   sd->symbols = fvsymtab;
918   sd->symbols_size = readsize;
919   sd->external_symbols_offset = need_local_symbols ? locsize : 0;
920   sd->symbol_names = fvstrtab;
921   sd->symbol_names_size =
922     convert_to_section_size_type(strtabshdr.get_sh_size());
923 }
924 
925 // Return the section index of symbol SYM.  Set *VALUE to its value in
926 // the object file.  Set *IS_ORDINARY if this is an ordinary section
927 // index, not a special code between SHN_LORESERVE and SHN_HIRESERVE.
928 // Note that for a symbol which is not defined in this object file,
929 // this will set *VALUE to 0 and return SHN_UNDEF; it will not return
930 // the final value of the symbol in the link.
931 
932 template<int size, bool big_endian>
933 unsigned int
symbol_section_and_value(unsigned int sym,Address * value,bool * is_ordinary)934 Sized_relobj_file<size, big_endian>::symbol_section_and_value(unsigned int sym,
935 							      Address* value,
936 							      bool* is_ordinary)
937 {
938   section_size_type symbols_size;
939   const unsigned char* symbols = this->section_contents(this->symtab_shndx_,
940 							&symbols_size,
941 							false);
942 
943   const size_t count = symbols_size / This::sym_size;
944   gold_assert(sym < count);
945 
946   elfcpp::Sym<size, big_endian> elfsym(symbols + sym * This::sym_size);
947   *value = elfsym.get_st_value();
948 
949   return this->adjust_sym_shndx(sym, elfsym.get_st_shndx(), is_ordinary);
950 }
951 
952 // Return whether to include a section group in the link.  LAYOUT is
953 // used to keep track of which section groups we have already seen.
954 // INDEX is the index of the section group and SHDR is the section
955 // header.  If we do not want to include this group, we set bits in
956 // OMIT for each section which should be discarded.
957 
958 template<int size, bool big_endian>
959 bool
include_section_group(Symbol_table * symtab,Layout * layout,unsigned int index,const char * name,const unsigned char * shdrs,const char * section_names,section_size_type section_names_size,std::vector<bool> * omit)960 Sized_relobj_file<size, big_endian>::include_section_group(
961     Symbol_table* symtab,
962     Layout* layout,
963     unsigned int index,
964     const char* name,
965     const unsigned char* shdrs,
966     const char* section_names,
967     section_size_type section_names_size,
968     std::vector<bool>* omit)
969 {
970   // Read the section contents.
971   typename This::Shdr shdr(shdrs + index * This::shdr_size);
972   const unsigned char* pcon = this->get_view(shdr.get_sh_offset(),
973 					     shdr.get_sh_size(), true, false);
974   const elfcpp::Elf_Word* pword =
975     reinterpret_cast<const elfcpp::Elf_Word*>(pcon);
976 
977   // The first word contains flags.  We only care about COMDAT section
978   // groups.  Other section groups are always included in the link
979   // just like ordinary sections.
980   elfcpp::Elf_Word flags = elfcpp::Swap<32, big_endian>::readval(pword);
981 
982   // Look up the group signature, which is the name of a symbol.  ELF
983   // uses a symbol name because some group signatures are long, and
984   // the name is generally already in the symbol table, so it makes
985   // sense to put the long string just once in .strtab rather than in
986   // both .strtab and .shstrtab.
987 
988   // Get the appropriate symbol table header (this will normally be
989   // the single SHT_SYMTAB section, but in principle it need not be).
990   const unsigned int link = this->adjust_shndx(shdr.get_sh_link());
991   typename This::Shdr symshdr(this, this->elf_file_.section_header(link));
992 
993   // Read the symbol table entry.
994   unsigned int symndx = shdr.get_sh_info();
995   if (symndx >= symshdr.get_sh_size() / This::sym_size)
996     {
997       this->error(_("section group %u info %u out of range"),
998 		  index, symndx);
999       return false;
1000     }
1001   off_t symoff = symshdr.get_sh_offset() + symndx * This::sym_size;
1002   const unsigned char* psym = this->get_view(symoff, This::sym_size, true,
1003 					     false);
1004   elfcpp::Sym<size, big_endian> sym(psym);
1005 
1006   // Read the symbol table names.
1007   section_size_type symnamelen;
1008   const unsigned char* psymnamesu;
1009   psymnamesu = this->section_contents(this->adjust_shndx(symshdr.get_sh_link()),
1010 				      &symnamelen, true);
1011   const char* psymnames = reinterpret_cast<const char*>(psymnamesu);
1012 
1013   // Get the section group signature.
1014   if (sym.get_st_name() >= symnamelen)
1015     {
1016       this->error(_("symbol %u name offset %u out of range"),
1017 		  symndx, sym.get_st_name());
1018       return false;
1019     }
1020 
1021   std::string signature(psymnames + sym.get_st_name());
1022 
1023   // It seems that some versions of gas will create a section group
1024   // associated with a section symbol, and then fail to give a name to
1025   // the section symbol.  In such a case, use the name of the section.
1026   if (signature[0] == '\0' && sym.get_st_type() == elfcpp::STT_SECTION)
1027     {
1028       bool is_ordinary;
1029       unsigned int sym_shndx = this->adjust_sym_shndx(symndx,
1030 						      sym.get_st_shndx(),
1031 						      &is_ordinary);
1032       if (!is_ordinary || sym_shndx >= this->shnum())
1033 	{
1034 	  this->error(_("symbol %u invalid section index %u"),
1035 		      symndx, sym_shndx);
1036 	  return false;
1037 	}
1038       typename This::Shdr member_shdr(shdrs + sym_shndx * This::shdr_size);
1039       if (member_shdr.get_sh_name() < section_names_size)
1040 	signature = section_names + member_shdr.get_sh_name();
1041     }
1042 
1043   // Record this section group in the layout, and see whether we've already
1044   // seen one with the same signature.
1045   bool include_group;
1046   bool is_comdat;
1047   Kept_section* kept_section = NULL;
1048 
1049   if ((flags & elfcpp::GRP_COMDAT) == 0)
1050     {
1051       include_group = true;
1052       is_comdat = false;
1053     }
1054   else
1055     {
1056       include_group = layout->find_or_add_kept_section(signature,
1057 						       this, index, true,
1058 						       true, &kept_section);
1059       is_comdat = true;
1060     }
1061 
1062   if (is_comdat && include_group)
1063     {
1064       Incremental_inputs* incremental_inputs = layout->incremental_inputs();
1065       if (incremental_inputs != NULL)
1066 	incremental_inputs->report_comdat_group(this, signature.c_str());
1067     }
1068 
1069   size_t count = shdr.get_sh_size() / sizeof(elfcpp::Elf_Word);
1070 
1071   std::vector<unsigned int> shndxes;
1072   bool relocate_group = include_group && parameters->options().relocatable();
1073   if (relocate_group)
1074     shndxes.reserve(count - 1);
1075 
1076   for (size_t i = 1; i < count; ++i)
1077     {
1078       elfcpp::Elf_Word shndx =
1079 	this->adjust_shndx(elfcpp::Swap<32, big_endian>::readval(pword + i));
1080 
1081       if (relocate_group)
1082 	shndxes.push_back(shndx);
1083 
1084       if (shndx >= this->shnum())
1085 	{
1086 	  this->error(_("section %u in section group %u out of range"),
1087 		      shndx, index);
1088 	  continue;
1089 	}
1090 
1091       // Check for an earlier section number, since we're going to get
1092       // it wrong--we may have already decided to include the section.
1093       if (shndx < index)
1094 	this->error(_("invalid section group %u refers to earlier section %u"),
1095 		    index, shndx);
1096 
1097       // Get the name of the member section.
1098       typename This::Shdr member_shdr(shdrs + shndx * This::shdr_size);
1099       if (member_shdr.get_sh_name() >= section_names_size)
1100 	{
1101 	  // This is an error, but it will be diagnosed eventually
1102 	  // in do_layout, so we don't need to do anything here but
1103 	  // ignore it.
1104 	  continue;
1105 	}
1106       std::string mname(section_names + member_shdr.get_sh_name());
1107 
1108       if (include_group)
1109 	{
1110 	  if (is_comdat)
1111 	    kept_section->add_comdat_section(mname, shndx,
1112 					     member_shdr.get_sh_size());
1113 	}
1114       else
1115 	{
1116 	  (*omit)[shndx] = true;
1117 
1118 	  // Store a mapping from this section to the Kept_section
1119 	  // information for the group.  This mapping is used for
1120 	  // relocation processing and diagnostics.
1121 	  // If the kept section is a linkonce section, we don't
1122 	  // bother with it unless the comdat group contains just
1123 	  // a single section, making it easy to match up.
1124 	  if (is_comdat
1125 	      && (kept_section->is_comdat() || count == 2))
1126 	    this->set_kept_comdat_section(shndx, true, symndx,
1127 					  member_shdr.get_sh_size(),
1128 					  kept_section);
1129 	}
1130     }
1131 
1132   if (relocate_group)
1133     layout->layout_group(symtab, this, index, name, signature.c_str(),
1134 			 shdr, flags, &shndxes);
1135 
1136   return include_group;
1137 }
1138 
1139 // Whether to include a linkonce section in the link.  NAME is the
1140 // name of the section and SHDR is the section header.
1141 
1142 // Linkonce sections are a GNU extension implemented in the original
1143 // GNU linker before section groups were defined.  The semantics are
1144 // that we only include one linkonce section with a given name.  The
1145 // name of a linkonce section is normally .gnu.linkonce.T.SYMNAME,
1146 // where T is the type of section and SYMNAME is the name of a symbol.
1147 // In an attempt to make linkonce sections interact well with section
1148 // groups, we try to identify SYMNAME and use it like a section group
1149 // signature.  We want to block section groups with that signature,
1150 // but not other linkonce sections with that signature.  We also use
1151 // the full name of the linkonce section as a normal section group
1152 // signature.
1153 
1154 template<int size, bool big_endian>
1155 bool
include_linkonce_section(Layout * layout,unsigned int index,const char * name,const elfcpp::Shdr<size,big_endian> & shdr)1156 Sized_relobj_file<size, big_endian>::include_linkonce_section(
1157     Layout* layout,
1158     unsigned int index,
1159     const char* name,
1160     const elfcpp::Shdr<size, big_endian>& shdr)
1161 {
1162   typename elfcpp::Elf_types<size>::Elf_WXword sh_size = shdr.get_sh_size();
1163   // In general the symbol name we want will be the string following
1164   // the last '.'.  However, we have to handle the case of
1165   // .gnu.linkonce.t.__i686.get_pc_thunk.bx, which was generated by
1166   // some versions of gcc.  So we use a heuristic: if the name starts
1167   // with ".gnu.linkonce.t.", we use everything after that.  Otherwise
1168   // we look for the last '.'.  We can't always simply skip
1169   // ".gnu.linkonce.X", because we have to deal with cases like
1170   // ".gnu.linkonce.d.rel.ro.local".
1171   const char* const linkonce_t = ".gnu.linkonce.t.";
1172   const char* symname;
1173   if (strncmp(name, linkonce_t, strlen(linkonce_t)) == 0)
1174     symname = name + strlen(linkonce_t);
1175   else
1176     symname = strrchr(name, '.') + 1;
1177   std::string sig1(symname);
1178   std::string sig2(name);
1179   Kept_section* kept1;
1180   Kept_section* kept2;
1181   bool include1 = layout->find_or_add_kept_section(sig1, this, index, false,
1182 						   false, &kept1);
1183   bool include2 = layout->find_or_add_kept_section(sig2, this, index, false,
1184 						   true, &kept2);
1185 
1186   if (!include2)
1187     {
1188       // We are not including this section because we already saw the
1189       // name of the section as a signature.  This normally implies
1190       // that the kept section is another linkonce section.  If it is
1191       // the same size, record it as the section which corresponds to
1192       // this one.
1193       if (kept2->object() != NULL && !kept2->is_comdat())
1194 	this->set_kept_comdat_section(index, false, 0, sh_size, kept2);
1195     }
1196   else if (!include1)
1197     {
1198       // The section is being discarded on the basis of its symbol
1199       // name.  This means that the corresponding kept section was
1200       // part of a comdat group, and it will be difficult to identify
1201       // the specific section within that group that corresponds to
1202       // this linkonce section.  We'll handle the simple case where
1203       // the group has only one member section.  Otherwise, it's not
1204       // worth the effort.
1205       if (kept1->object() != NULL && kept1->is_comdat())
1206 	this->set_kept_comdat_section(index, false, 0, sh_size, kept1);
1207     }
1208   else
1209     {
1210       kept1->set_linkonce_size(sh_size);
1211       kept2->set_linkonce_size(sh_size);
1212     }
1213 
1214   return include1 && include2;
1215 }
1216 
1217 // Layout an input section.
1218 
1219 template<int size, bool big_endian>
1220 inline void
layout_section(Layout * layout,unsigned int shndx,const char * name,const typename This::Shdr & shdr,unsigned int sh_type,unsigned int reloc_shndx,unsigned int reloc_type)1221 Sized_relobj_file<size, big_endian>::layout_section(
1222     Layout* layout,
1223     unsigned int shndx,
1224     const char* name,
1225     const typename This::Shdr& shdr,
1226     unsigned int sh_type,
1227     unsigned int reloc_shndx,
1228     unsigned int reloc_type)
1229 {
1230   off_t offset;
1231   Output_section* os = layout->layout(this, shndx, name, shdr, sh_type,
1232 				      reloc_shndx, reloc_type, &offset);
1233 
1234   this->output_sections()[shndx] = os;
1235   if (offset == -1)
1236     this->section_offsets()[shndx] = invalid_address;
1237   else
1238     this->section_offsets()[shndx] = convert_types<Address, off_t>(offset);
1239 
1240   // If this section requires special handling, and if there are
1241   // relocs that apply to it, then we must do the special handling
1242   // before we apply the relocs.
1243   if (offset == -1 && reloc_shndx != 0)
1244     this->set_relocs_must_follow_section_writes();
1245 }
1246 
1247 // Layout an input .eh_frame section.
1248 
1249 template<int size, bool big_endian>
1250 void
layout_eh_frame_section(Layout * layout,const unsigned char * symbols_data,section_size_type symbols_size,const unsigned char * symbol_names_data,section_size_type symbol_names_size,unsigned int shndx,const typename This::Shdr & shdr,unsigned int reloc_shndx,unsigned int reloc_type)1251 Sized_relobj_file<size, big_endian>::layout_eh_frame_section(
1252     Layout* layout,
1253     const unsigned char* symbols_data,
1254     section_size_type symbols_size,
1255     const unsigned char* symbol_names_data,
1256     section_size_type symbol_names_size,
1257     unsigned int shndx,
1258     const typename This::Shdr& shdr,
1259     unsigned int reloc_shndx,
1260     unsigned int reloc_type)
1261 {
1262   gold_assert(this->has_eh_frame_);
1263 
1264   off_t offset;
1265   Output_section* os = layout->layout_eh_frame(this,
1266 					       symbols_data,
1267 					       symbols_size,
1268 					       symbol_names_data,
1269 					       symbol_names_size,
1270 					       shndx,
1271 					       shdr,
1272 					       reloc_shndx,
1273 					       reloc_type,
1274 					       &offset);
1275   this->output_sections()[shndx] = os;
1276   if (os == NULL || offset == -1)
1277     this->section_offsets()[shndx] = invalid_address;
1278   else
1279     this->section_offsets()[shndx] = convert_types<Address, off_t>(offset);
1280 
1281   // If this section requires special handling, and if there are
1282   // relocs that aply to it, then we must do the special handling
1283   // before we apply the relocs.
1284   if (os != NULL && offset == -1 && reloc_shndx != 0)
1285     this->set_relocs_must_follow_section_writes();
1286 }
1287 
1288 // Layout an input .note.gnu.property section.
1289 
1290 // This note section has an *extremely* non-standard layout.
1291 // The gABI spec says that ELF-64 files should have 8-byte fields and
1292 // 8-byte alignment in the note section, but the Gnu tools generally
1293 // use 4-byte fields and 4-byte alignment (see the comment for
1294 // Layout::create_note).  This section uses 4-byte fields (i.e.,
1295 // namesz, descsz, and type are always 4 bytes), the name field is
1296 // padded to a multiple of 4 bytes, but the desc field is padded
1297 // to a multiple of 4 or 8 bytes, depending on the ELF class.
1298 // The individual properties within the desc field always use
1299 // 4-byte pr_type and pr_datasz fields, but pr_data is padded to
1300 // a multiple of 4 or 8 bytes, depending on the ELF class.
1301 
1302 template<int size, bool big_endian>
1303 void
layout_gnu_property_section(Layout * layout,unsigned int shndx)1304 Sized_relobj_file<size, big_endian>::layout_gnu_property_section(
1305     Layout* layout,
1306     unsigned int shndx)
1307 {
1308   // We ignore Gnu property sections on incremental links.
1309   if (parameters->incremental())
1310     return;
1311 
1312   section_size_type contents_len;
1313   const unsigned char* pcontents = this->section_contents(shndx,
1314 							  &contents_len,
1315 							  false);
1316   const unsigned char* pcontents_end = pcontents + contents_len;
1317 
1318   // Loop over all the notes in this section.
1319   while (pcontents < pcontents_end)
1320     {
1321       if (pcontents + 16 > pcontents_end)
1322 	{
1323 	  gold_warning(_("%s: corrupt .note.gnu.property section "
1324 			 "(note too short)"),
1325 		       this->name().c_str());
1326 	  return;
1327 	}
1328 
1329       size_t namesz = elfcpp::Swap<32, big_endian>::readval(pcontents);
1330       size_t descsz = elfcpp::Swap<32, big_endian>::readval(pcontents + 4);
1331       unsigned int ntype = elfcpp::Swap<32, big_endian>::readval(pcontents + 8);
1332       const unsigned char* pname = pcontents + 12;
1333 
1334       if (namesz != 4 || strcmp(reinterpret_cast<const char*>(pname), "GNU") != 0)
1335 	{
1336 	  gold_warning(_("%s: corrupt .note.gnu.property section "
1337 			 "(name is not 'GNU')"),
1338 		       this->name().c_str());
1339 	  return;
1340 	}
1341 
1342       if (ntype != elfcpp::NT_GNU_PROPERTY_TYPE_0)
1343 	{
1344 	  gold_warning(_("%s: unsupported note type %d "
1345 			 "in .note.gnu.property section"),
1346 		       this->name().c_str(), ntype);
1347 	  return;
1348 	}
1349 
1350       size_t aligned_namesz = align_address(namesz, 4);
1351       const unsigned char* pdesc = pname + aligned_namesz;
1352 
1353       if (pdesc + descsz > pcontents + contents_len)
1354 	{
1355 	  gold_warning(_("%s: corrupt .note.gnu.property section"),
1356 		       this->name().c_str());
1357 	  return;
1358 	}
1359 
1360       const unsigned char* pprop = pdesc;
1361 
1362       // Loop over the program properties in this note.
1363       while (pprop < pdesc + descsz)
1364 	{
1365 	  if (pprop + 8 > pdesc + descsz)
1366 	    {
1367 	      gold_warning(_("%s: corrupt .note.gnu.property section"),
1368 			   this->name().c_str());
1369 	      return;
1370 	    }
1371 	  unsigned int pr_type = elfcpp::Swap<32, big_endian>::readval(pprop);
1372 	  size_t pr_datasz = elfcpp::Swap<32, big_endian>::readval(pprop + 4);
1373 	  pprop += 8;
1374 	  if (pprop + pr_datasz > pdesc + descsz)
1375 	    {
1376 	      gold_warning(_("%s: corrupt .note.gnu.property section"),
1377 			   this->name().c_str());
1378 	      return;
1379 	    }
1380 	  layout->layout_gnu_property(ntype, pr_type, pr_datasz, pprop, this);
1381 	  pprop += align_address(pr_datasz, size / 8);
1382 	}
1383 
1384       pcontents = pdesc + align_address(descsz, size / 8);
1385     }
1386 }
1387 
1388 // This a copy of lto_section defined in GCC (lto-streamer.h)
1389 
1390 struct lto_section
1391 {
1392   int16_t major_version;
1393   int16_t minor_version;
1394   unsigned char slim_object;
1395 
1396   /* Flags is a private field that is not defined publicly.  */
1397   uint16_t flags;
1398 };
1399 
1400 // Lay out the input sections.  We walk through the sections and check
1401 // whether they should be included in the link.  If they should, we
1402 // pass them to the Layout object, which will return an output section
1403 // and an offset.
1404 // This function is called twice sometimes, two passes, when mapping
1405 // of input sections to output sections must be delayed.
1406 // This is true for the following :
1407 // * Garbage collection (--gc-sections): Some input sections will be
1408 // discarded and hence the assignment must wait until the second pass.
1409 // In the first pass,  it is for setting up some sections as roots to
1410 // a work-list for --gc-sections and to do comdat processing.
1411 // * Identical Code Folding (--icf=<safe,all>): Some input sections
1412 // will be folded and hence the assignment must wait.
1413 // * Using plugins to map some sections to unique segments: Mapping
1414 // some sections to unique segments requires mapping them to unique
1415 // output sections too.  This can be done via plugins now and this
1416 // information is not available in the first pass.
1417 
1418 template<int size, bool big_endian>
1419 void
do_layout(Symbol_table * symtab,Layout * layout,Read_symbols_data * sd)1420 Sized_relobj_file<size, big_endian>::do_layout(Symbol_table* symtab,
1421 					       Layout* layout,
1422 					       Read_symbols_data* sd)
1423 {
1424   const unsigned int unwind_section_type =
1425       parameters->target().unwind_section_type();
1426   const unsigned int shnum = this->shnum();
1427 
1428   /* Should this function be called twice?  */
1429   bool is_two_pass = (parameters->options().gc_sections()
1430 		      || parameters->options().icf_enabled()
1431 		      || layout->is_unique_segment_for_sections_specified());
1432 
1433   /* Only one of is_pass_one and is_pass_two is true.  Both are false when
1434      a two-pass approach is not needed.  */
1435   bool is_pass_one = false;
1436   bool is_pass_two = false;
1437 
1438   Symbols_data* gc_sd = NULL;
1439 
1440   /* Check if do_layout needs to be two-pass.  If so, find out which pass
1441      should happen.  In the first pass, the data in sd is saved to be used
1442      later in the second pass.  */
1443   if (is_two_pass)
1444     {
1445       gc_sd = this->get_symbols_data();
1446       if (gc_sd == NULL)
1447 	{
1448 	  gold_assert(sd != NULL);
1449 	  is_pass_one = true;
1450 	}
1451       else
1452 	{
1453 	  if (parameters->options().gc_sections())
1454 	    gold_assert(symtab->gc()->is_worklist_ready());
1455 	  if (parameters->options().icf_enabled())
1456 	    gold_assert(symtab->icf()->is_icf_ready());
1457 	  is_pass_two = true;
1458 	}
1459     }
1460 
1461   if (shnum == 0)
1462     return;
1463 
1464   if (is_pass_one)
1465     {
1466       // During garbage collection save the symbols data to use it when
1467       // re-entering this function.
1468       gc_sd = new Symbols_data;
1469       this->copy_symbols_data(gc_sd, sd, This::shdr_size * shnum);
1470       this->set_symbols_data(gc_sd);
1471     }
1472 
1473   const unsigned char* section_headers_data = NULL;
1474   section_size_type section_names_size;
1475   const unsigned char* symbols_data = NULL;
1476   section_size_type symbols_size;
1477   const unsigned char* symbol_names_data = NULL;
1478   section_size_type symbol_names_size;
1479 
1480   if (is_two_pass)
1481     {
1482       section_headers_data = gc_sd->section_headers_data;
1483       section_names_size = gc_sd->section_names_size;
1484       symbols_data = gc_sd->symbols_data;
1485       symbols_size = gc_sd->symbols_size;
1486       symbol_names_data = gc_sd->symbol_names_data;
1487       symbol_names_size = gc_sd->symbol_names_size;
1488     }
1489   else
1490     {
1491       section_headers_data = sd->section_headers->data();
1492       section_names_size = sd->section_names_size;
1493       if (sd->symbols != NULL)
1494 	symbols_data = sd->symbols->data();
1495       symbols_size = sd->symbols_size;
1496       if (sd->symbol_names != NULL)
1497 	symbol_names_data = sd->symbol_names->data();
1498       symbol_names_size = sd->symbol_names_size;
1499     }
1500 
1501   // Get the section headers.
1502   const unsigned char* shdrs = section_headers_data;
1503   const unsigned char* pshdrs;
1504 
1505   // Get the section names.
1506   const unsigned char* pnamesu = (is_two_pass
1507 				  ? gc_sd->section_names_data
1508 				  : sd->section_names->data());
1509 
1510   const char* pnames = reinterpret_cast<const char*>(pnamesu);
1511 
1512   // If any input files have been claimed by plugins, we need to defer
1513   // actual layout until the replacement files have arrived.
1514   const bool should_defer_layout =
1515       (parameters->options().has_plugins()
1516        && parameters->options().plugins()->should_defer_layout());
1517   unsigned int num_sections_to_defer = 0;
1518 
1519   // For each section, record the index of the reloc section if any.
1520   // Use 0 to mean that there is no reloc section, -1U to mean that
1521   // there is more than one.
1522   std::vector<unsigned int> reloc_shndx(shnum, 0);
1523   std::vector<unsigned int> reloc_type(shnum, elfcpp::SHT_NULL);
1524   // Skip the first, dummy, section.
1525   pshdrs = shdrs + This::shdr_size;
1526   for (unsigned int i = 1; i < shnum; ++i, pshdrs += This::shdr_size)
1527     {
1528       typename This::Shdr shdr(pshdrs);
1529 
1530       // Count the number of sections whose layout will be deferred.
1531       if (should_defer_layout && (shdr.get_sh_flags() & elfcpp::SHF_ALLOC))
1532 	++num_sections_to_defer;
1533 
1534       unsigned int sh_type = shdr.get_sh_type();
1535       if (sh_type == elfcpp::SHT_REL || sh_type == elfcpp::SHT_RELA)
1536 	{
1537 	  unsigned int target_shndx = this->adjust_shndx(shdr.get_sh_info());
1538 	  if (target_shndx == 0 || target_shndx >= shnum)
1539 	    {
1540 	      this->error(_("relocation section %u has bad info %u"),
1541 			  i, target_shndx);
1542 	      continue;
1543 	    }
1544 
1545 	  if (reloc_shndx[target_shndx] != 0)
1546 	    reloc_shndx[target_shndx] = -1U;
1547 	  else
1548 	    {
1549 	      reloc_shndx[target_shndx] = i;
1550 	      reloc_type[target_shndx] = sh_type;
1551 	    }
1552 	}
1553     }
1554 
1555   Output_sections& out_sections(this->output_sections());
1556   std::vector<Address>& out_section_offsets(this->section_offsets());
1557 
1558   if (!is_pass_two)
1559     {
1560       out_sections.resize(shnum);
1561       out_section_offsets.resize(shnum);
1562     }
1563 
1564   // If we are only linking for symbols, then there is nothing else to
1565   // do here.
1566   if (this->input_file()->just_symbols())
1567     {
1568       if (!is_pass_two)
1569 	{
1570 	  delete sd->section_headers;
1571 	  sd->section_headers = NULL;
1572 	  delete sd->section_names;
1573 	  sd->section_names = NULL;
1574 	}
1575       return;
1576     }
1577 
1578   if (num_sections_to_defer > 0)
1579     {
1580       parameters->options().plugins()->add_deferred_layout_object(this);
1581       this->deferred_layout_.reserve(num_sections_to_defer);
1582       this->is_deferred_layout_ = true;
1583     }
1584 
1585   // Whether we've seen a .note.GNU-stack section.
1586   bool seen_gnu_stack = false;
1587   // The flags of a .note.GNU-stack section.
1588   uint64_t gnu_stack_flags = 0;
1589 
1590   // Keep track of which sections to omit.
1591   std::vector<bool> omit(shnum, false);
1592 
1593   // Keep track of reloc sections when emitting relocations.
1594   const bool relocatable = parameters->options().relocatable();
1595   const bool emit_relocs = (relocatable
1596 			    || parameters->options().emit_relocs());
1597   std::vector<unsigned int> reloc_sections;
1598 
1599   // Keep track of .eh_frame sections.
1600   std::vector<unsigned int> eh_frame_sections;
1601 
1602   // Keep track of .debug_info and .debug_types sections.
1603   std::vector<unsigned int> debug_info_sections;
1604   std::vector<unsigned int> debug_types_sections;
1605 
1606   // Skip the first, dummy, section.
1607   pshdrs = shdrs + This::shdr_size;
1608   for (unsigned int i = 1; i < shnum; ++i, pshdrs += This::shdr_size)
1609     {
1610       typename This::Shdr shdr(pshdrs);
1611       const unsigned int sh_name = shdr.get_sh_name();
1612       unsigned int sh_type = shdr.get_sh_type();
1613 
1614       if (sh_name >= section_names_size)
1615 	{
1616 	  this->error(_("bad section name offset for section %u: %lu"),
1617 		      i, static_cast<unsigned long>(sh_name));
1618 	  return;
1619 	}
1620 
1621       const char* name = pnames + sh_name;
1622 
1623       if (!is_pass_two)
1624 	{
1625 	  if (this->handle_gnu_warning_section(name, i, symtab))
1626 	    {
1627 	      if (!relocatable && !parameters->options().shared())
1628 		omit[i] = true;
1629 	    }
1630 
1631 	  // The .note.GNU-stack section is special.  It gives the
1632 	  // protection flags that this object file requires for the stack
1633 	  // in memory.
1634 	  if (strcmp(name, ".note.GNU-stack") == 0)
1635 	    {
1636 	      seen_gnu_stack = true;
1637 	      gnu_stack_flags |= shdr.get_sh_flags();
1638 	      omit[i] = true;
1639 	    }
1640 
1641 	  // The .note.GNU-split-stack section is also special.  It
1642 	  // indicates that the object was compiled with
1643 	  // -fsplit-stack.
1644 	  if (this->handle_split_stack_section(name))
1645 	    {
1646 	      if (!relocatable && !parameters->options().shared())
1647 		omit[i] = true;
1648 	    }
1649 
1650 	  // Skip attributes section.
1651 	  if (parameters->target().is_attributes_section(name))
1652 	    {
1653 	      omit[i] = true;
1654 	    }
1655 
1656 	  // Handle .note.gnu.property sections.
1657 	  if (sh_type == elfcpp::SHT_NOTE
1658 	      && strcmp(name, ".note.gnu.property") == 0)
1659 	    {
1660 	      this->layout_gnu_property_section(layout, i);
1661 	      omit[i] = true;
1662 	    }
1663 
1664 	  bool discard = omit[i];
1665 	  if (!discard)
1666 	    {
1667 	      if (sh_type == elfcpp::SHT_GROUP)
1668 		{
1669 		  if (!this->include_section_group(symtab, layout, i, name,
1670 						   shdrs, pnames,
1671 						   section_names_size,
1672 						   &omit))
1673 		    discard = true;
1674 		}
1675 	      else if ((shdr.get_sh_flags() & elfcpp::SHF_GROUP) == 0
1676 		       && Layout::is_linkonce(name))
1677 		{
1678 		  if (!this->include_linkonce_section(layout, i, name, shdr))
1679 		    discard = true;
1680 		}
1681 	    }
1682 
1683 	  // Add the section to the incremental inputs layout.
1684 	  Incremental_inputs* incremental_inputs = layout->incremental_inputs();
1685 	  if (incremental_inputs != NULL
1686 	      && !discard
1687 	      && can_incremental_update(sh_type))
1688 	    {
1689 	      off_t sh_size = shdr.get_sh_size();
1690 	      section_size_type uncompressed_size;
1691 	      if (this->section_is_compressed(i, &uncompressed_size))
1692 		sh_size = uncompressed_size;
1693 	      incremental_inputs->report_input_section(this, i, name, sh_size);
1694 	    }
1695 
1696 	  if (discard)
1697 	    {
1698 	      // Do not include this section in the link.
1699 	      out_sections[i] = NULL;
1700 	      out_section_offsets[i] = invalid_address;
1701 	      continue;
1702 	    }
1703 	}
1704 
1705       if (is_pass_one && parameters->options().gc_sections())
1706 	{
1707 	  if (this->is_section_name_included(name)
1708 	      || layout->keep_input_section (this, name)
1709 	      || sh_type == elfcpp::SHT_INIT_ARRAY
1710 	      || sh_type == elfcpp::SHT_FINI_ARRAY
1711 	      || this->osabi().has_shf_retain(shdr.get_sh_flags()))
1712 	    {
1713 	      symtab->gc()->worklist().push_back(Section_id(this, i));
1714 	    }
1715 	  // If the section name XXX can be represented as a C identifier
1716 	  // it cannot be discarded if there are references to
1717 	  // __start_XXX and __stop_XXX symbols.  These need to be
1718 	  // specially handled.
1719 	  if (is_cident(name))
1720 	    {
1721 	      symtab->gc()->add_cident_section(name, Section_id(this, i));
1722 	    }
1723 	}
1724 
1725       // When doing a relocatable link we are going to copy input
1726       // reloc sections into the output.  We only want to copy the
1727       // ones associated with sections which are not being discarded.
1728       // However, we don't know that yet for all sections.  So save
1729       // reloc sections and process them later. Garbage collection is
1730       // not triggered when relocatable code is desired.
1731       if (emit_relocs
1732 	  && (sh_type == elfcpp::SHT_REL
1733 	      || sh_type == elfcpp::SHT_RELA))
1734 	{
1735 	  reloc_sections.push_back(i);
1736 	  continue;
1737 	}
1738 
1739       if (relocatable && sh_type == elfcpp::SHT_GROUP)
1740 	continue;
1741 
1742       // The .eh_frame section is special.  It holds exception frame
1743       // information that we need to read in order to generate the
1744       // exception frame header.  We process these after all the other
1745       // sections so that the exception frame reader can reliably
1746       // determine which sections are being discarded, and discard the
1747       // corresponding information.
1748       if (this->check_eh_frame_flags(&shdr)
1749 	  && strcmp(name, ".eh_frame") == 0)
1750 	{
1751 	  // If the target has a special unwind section type, let's
1752 	  // canonicalize it here.
1753 	  sh_type = unwind_section_type;
1754 	  if (!relocatable)
1755 	    {
1756 	      if (is_pass_one)
1757 		{
1758 		  if (this->is_deferred_layout())
1759 		    out_sections[i] = reinterpret_cast<Output_section*>(2);
1760 		  else
1761 		    out_sections[i] = reinterpret_cast<Output_section*>(1);
1762 		  out_section_offsets[i] = invalid_address;
1763 		}
1764 	      else if (this->is_deferred_layout())
1765 		{
1766 		  out_sections[i] = reinterpret_cast<Output_section*>(2);
1767 		  out_section_offsets[i] = invalid_address;
1768 		  this->deferred_layout_.push_back(
1769 		      Deferred_layout(i, name, sh_type, pshdrs,
1770 				      reloc_shndx[i], reloc_type[i]));
1771 		}
1772 	      else
1773 		eh_frame_sections.push_back(i);
1774 	      continue;
1775 	    }
1776 	}
1777 
1778       if (is_pass_two && parameters->options().gc_sections())
1779 	{
1780 	  // This is executed during the second pass of garbage
1781 	  // collection. do_layout has been called before and some
1782 	  // sections have been already discarded. Simply ignore
1783 	  // such sections this time around.
1784 	  if (out_sections[i] == NULL)
1785 	    {
1786 	      gold_assert(out_section_offsets[i] == invalid_address);
1787 	      continue;
1788 	    }
1789 	  if (((shdr.get_sh_flags() & elfcpp::SHF_ALLOC) != 0)
1790 	      && symtab->gc()->is_section_garbage(this, i))
1791 	      {
1792 		if (parameters->options().print_gc_sections())
1793 		  gold_info(_("%s: removing unused section from '%s'"
1794 			      " in file '%s'"),
1795 			    program_name, this->section_name(i).c_str(),
1796 			    this->name().c_str());
1797 		out_sections[i] = NULL;
1798 		out_section_offsets[i] = invalid_address;
1799 		continue;
1800 	      }
1801 	}
1802 
1803       if (is_pass_two && parameters->options().icf_enabled())
1804 	{
1805 	  if (out_sections[i] == NULL)
1806 	    {
1807 	      gold_assert(out_section_offsets[i] == invalid_address);
1808 	      continue;
1809 	    }
1810 	  if (((shdr.get_sh_flags() & elfcpp::SHF_ALLOC) != 0)
1811 	      && symtab->icf()->is_section_folded(this, i))
1812 	      {
1813 		if (parameters->options().print_icf_sections())
1814 		  {
1815 		    Section_id folded =
1816 				symtab->icf()->get_folded_section(this, i);
1817 		    Relobj* folded_obj =
1818 				reinterpret_cast<Relobj*>(folded.first);
1819 		    gold_info(_("%s: ICF folding section '%s' in file '%s' "
1820 				"into '%s' in file '%s'"),
1821 			      program_name, this->section_name(i).c_str(),
1822 			      this->name().c_str(),
1823 			      folded_obj->section_name(folded.second).c_str(),
1824 			      folded_obj->name().c_str());
1825 		  }
1826 		out_sections[i] = NULL;
1827 		out_section_offsets[i] = invalid_address;
1828 		continue;
1829 	      }
1830 	}
1831 
1832       // Defer layout here if input files are claimed by plugins.  When gc
1833       // is turned on this function is called twice; we only want to do this
1834       // on the first pass.
1835       if (!is_pass_two
1836           && this->is_deferred_layout()
1837           && (shdr.get_sh_flags() & elfcpp::SHF_ALLOC))
1838 	{
1839 	  this->deferred_layout_.push_back(Deferred_layout(i, name, sh_type,
1840 							   pshdrs,
1841 							   reloc_shndx[i],
1842 							   reloc_type[i]));
1843 	  // Put dummy values here; real values will be supplied by
1844 	  // do_layout_deferred_sections.
1845 	  out_sections[i] = reinterpret_cast<Output_section*>(2);
1846 	  out_section_offsets[i] = invalid_address;
1847 	  continue;
1848 	}
1849 
1850       // During gc_pass_two if a section that was previously deferred is
1851       // found, do not layout the section as layout_deferred_sections will
1852       // do it later from gold.cc.
1853       if (is_pass_two
1854 	  && (out_sections[i] == reinterpret_cast<Output_section*>(2)))
1855 	continue;
1856 
1857       if (is_pass_one)
1858 	{
1859 	  // This is during garbage collection. The out_sections are
1860 	  // assigned in the second call to this function.
1861 	  out_sections[i] = reinterpret_cast<Output_section*>(1);
1862 	  out_section_offsets[i] = invalid_address;
1863 	}
1864       else
1865 	{
1866 	  // When garbage collection is switched on the actual layout
1867 	  // only happens in the second call.
1868 	  this->layout_section(layout, i, name, shdr, sh_type, reloc_shndx[i],
1869 			       reloc_type[i]);
1870 
1871 	  // When generating a .gdb_index section, we do additional
1872 	  // processing of .debug_info and .debug_types sections after all
1873 	  // the other sections for the same reason as above.
1874 	  if (!relocatable
1875 	      && parameters->options().gdb_index()
1876 	      && !(shdr.get_sh_flags() & elfcpp::SHF_ALLOC))
1877 	    {
1878 	      if (strcmp(name, ".debug_info") == 0
1879 		  || strcmp(name, ".zdebug_info") == 0)
1880 		debug_info_sections.push_back(i);
1881 	      else if (strcmp(name, ".debug_types") == 0
1882 		       || strcmp(name, ".zdebug_types") == 0)
1883 		debug_types_sections.push_back(i);
1884 	    }
1885 	}
1886 
1887       /* GCC uses .gnu.lto_.lto.<some_hash> as a LTO bytecode information
1888 	 section.  */
1889       const char *lto_section_name = ".gnu.lto_.lto.";
1890       if (strncmp (name, lto_section_name, strlen (lto_section_name)) == 0)
1891 	{
1892 	  section_size_type contents_len;
1893 	  const unsigned char* pcontents
1894 	    = this->section_contents(i, &contents_len, false);
1895 	  if (contents_len >= sizeof(lto_section))
1896 	    {
1897 	      const lto_section* lsection
1898 		= reinterpret_cast<const lto_section*>(pcontents);
1899 	      if (lsection->slim_object)
1900 		layout->set_lto_slim_object();
1901 	    }
1902 	}
1903     }
1904 
1905   if (!is_pass_two)
1906     {
1907       layout->merge_gnu_properties(this);
1908       layout->layout_gnu_stack(seen_gnu_stack, gnu_stack_flags, this);
1909     }
1910 
1911   // Handle the .eh_frame sections after the other sections.
1912   gold_assert(!is_pass_one || eh_frame_sections.empty());
1913   for (std::vector<unsigned int>::const_iterator p = eh_frame_sections.begin();
1914        p != eh_frame_sections.end();
1915        ++p)
1916     {
1917       unsigned int i = *p;
1918       const unsigned char* pshdr;
1919       pshdr = section_headers_data + i * This::shdr_size;
1920       typename This::Shdr shdr(pshdr);
1921 
1922       this->layout_eh_frame_section(layout,
1923 				    symbols_data,
1924 				    symbols_size,
1925 				    symbol_names_data,
1926 				    symbol_names_size,
1927 				    i,
1928 				    shdr,
1929 				    reloc_shndx[i],
1930 				    reloc_type[i]);
1931     }
1932 
1933   // When doing a relocatable link handle the reloc sections at the
1934   // end.  Garbage collection  and Identical Code Folding is not
1935   // turned on for relocatable code.
1936   if (emit_relocs)
1937     this->size_relocatable_relocs();
1938 
1939   gold_assert(!is_two_pass || reloc_sections.empty());
1940 
1941   for (std::vector<unsigned int>::const_iterator p = reloc_sections.begin();
1942        p != reloc_sections.end();
1943        ++p)
1944     {
1945       unsigned int i = *p;
1946       const unsigned char* pshdr;
1947       pshdr = section_headers_data + i * This::shdr_size;
1948       typename This::Shdr shdr(pshdr);
1949 
1950       unsigned int data_shndx = this->adjust_shndx(shdr.get_sh_info());
1951       if (data_shndx >= shnum)
1952 	{
1953 	  // We already warned about this above.
1954 	  continue;
1955 	}
1956 
1957       Output_section* data_section = out_sections[data_shndx];
1958       if (data_section == reinterpret_cast<Output_section*>(2))
1959 	{
1960 	  if (is_pass_two)
1961 	    continue;
1962 	  // The layout for the data section was deferred, so we need
1963 	  // to defer the relocation section, too.
1964 	  const char* name = pnames + shdr.get_sh_name();
1965 	  this->deferred_layout_relocs_.push_back(
1966 	      Deferred_layout(i, name, shdr.get_sh_type(), pshdr, 0,
1967 			      elfcpp::SHT_NULL));
1968 	  out_sections[i] = reinterpret_cast<Output_section*>(2);
1969 	  out_section_offsets[i] = invalid_address;
1970 	  continue;
1971 	}
1972       if (data_section == NULL)
1973 	{
1974 	  out_sections[i] = NULL;
1975 	  out_section_offsets[i] = invalid_address;
1976 	  continue;
1977 	}
1978 
1979       Relocatable_relocs* rr = new Relocatable_relocs();
1980       this->set_relocatable_relocs(i, rr);
1981 
1982       Output_section* os = layout->layout_reloc(this, i, shdr, data_section,
1983 						rr);
1984       out_sections[i] = os;
1985       out_section_offsets[i] = invalid_address;
1986     }
1987 
1988   // When building a .gdb_index section, scan the .debug_info and
1989   // .debug_types sections.
1990   gold_assert(!is_pass_one
1991 	      || (debug_info_sections.empty() && debug_types_sections.empty()));
1992   for (std::vector<unsigned int>::const_iterator p
1993 	   = debug_info_sections.begin();
1994        p != debug_info_sections.end();
1995        ++p)
1996     {
1997       unsigned int i = *p;
1998       layout->add_to_gdb_index(false, this, symbols_data, symbols_size,
1999 			       i, reloc_shndx[i], reloc_type[i]);
2000     }
2001   for (std::vector<unsigned int>::const_iterator p
2002 	   = debug_types_sections.begin();
2003        p != debug_types_sections.end();
2004        ++p)
2005     {
2006       unsigned int i = *p;
2007       layout->add_to_gdb_index(true, this, symbols_data, symbols_size,
2008 			       i, reloc_shndx[i], reloc_type[i]);
2009     }
2010 
2011   if (is_pass_two)
2012     {
2013       delete[] gc_sd->section_headers_data;
2014       delete[] gc_sd->section_names_data;
2015       delete[] gc_sd->symbols_data;
2016       delete[] gc_sd->symbol_names_data;
2017       this->set_symbols_data(NULL);
2018     }
2019   else
2020     {
2021       delete sd->section_headers;
2022       sd->section_headers = NULL;
2023       delete sd->section_names;
2024       sd->section_names = NULL;
2025     }
2026 }
2027 
2028 // Layout sections whose layout was deferred while waiting for
2029 // input files from a plugin.
2030 
2031 template<int size, bool big_endian>
2032 void
do_layout_deferred_sections(Layout * layout)2033 Sized_relobj_file<size, big_endian>::do_layout_deferred_sections(Layout* layout)
2034 {
2035   typename std::vector<Deferred_layout>::iterator deferred;
2036 
2037   for (deferred = this->deferred_layout_.begin();
2038        deferred != this->deferred_layout_.end();
2039        ++deferred)
2040     {
2041       typename This::Shdr shdr(deferred->shdr_data_);
2042 
2043       if (!parameters->options().relocatable()
2044 	  && deferred->name_ == ".eh_frame"
2045 	  && this->check_eh_frame_flags(&shdr))
2046 	{
2047 	  // Checking is_section_included is not reliable for
2048 	  // .eh_frame sections, because they do not have an output
2049 	  // section.  This is not a problem normally because we call
2050 	  // layout_eh_frame_section unconditionally, but when
2051 	  // deferring sections that is not true.  We don't want to
2052 	  // keep all .eh_frame sections because that will cause us to
2053 	  // keep all sections that they refer to, which is the wrong
2054 	  // way around.  Instead, the eh_frame code will discard
2055 	  // .eh_frame sections that refer to discarded sections.
2056 
2057 	  // Reading the symbols again here may be slow.
2058 	  Read_symbols_data sd;
2059 	  this->base_read_symbols(&sd);
2060 	  this->layout_eh_frame_section(layout,
2061 					sd.symbols->data(),
2062 					sd.symbols_size,
2063 					sd.symbol_names->data(),
2064 					sd.symbol_names_size,
2065 					deferred->shndx_,
2066 					shdr,
2067 					deferred->reloc_shndx_,
2068 					deferred->reloc_type_);
2069 	  continue;
2070 	}
2071 
2072       // If the section is not included, it is because the garbage collector
2073       // decided it is not needed.  Avoid reverting that decision.
2074       if (!this->is_section_included(deferred->shndx_))
2075 	continue;
2076 
2077       this->layout_section(layout, deferred->shndx_, deferred->name_.c_str(),
2078 			   shdr, shdr.get_sh_type(), deferred->reloc_shndx_,
2079 			   deferred->reloc_type_);
2080     }
2081 
2082   this->deferred_layout_.clear();
2083 
2084   // Now handle the deferred relocation sections.
2085 
2086   Output_sections& out_sections(this->output_sections());
2087   std::vector<Address>& out_section_offsets(this->section_offsets());
2088 
2089   for (deferred = this->deferred_layout_relocs_.begin();
2090        deferred != this->deferred_layout_relocs_.end();
2091        ++deferred)
2092     {
2093       unsigned int shndx = deferred->shndx_;
2094       typename This::Shdr shdr(deferred->shdr_data_);
2095       unsigned int data_shndx = this->adjust_shndx(shdr.get_sh_info());
2096 
2097       Output_section* data_section = out_sections[data_shndx];
2098       if (data_section == NULL)
2099 	{
2100 	  out_sections[shndx] = NULL;
2101 	  out_section_offsets[shndx] = invalid_address;
2102 	  continue;
2103 	}
2104 
2105       Relocatable_relocs* rr = new Relocatable_relocs();
2106       this->set_relocatable_relocs(shndx, rr);
2107 
2108       Output_section* os = layout->layout_reloc(this, shndx, shdr,
2109 						data_section, rr);
2110       out_sections[shndx] = os;
2111       out_section_offsets[shndx] = invalid_address;
2112     }
2113 }
2114 
2115 // Add the symbols to the symbol table.
2116 
2117 template<int size, bool big_endian>
2118 void
do_add_symbols(Symbol_table * symtab,Read_symbols_data * sd,Layout * layout)2119 Sized_relobj_file<size, big_endian>::do_add_symbols(Symbol_table* symtab,
2120 						    Read_symbols_data* sd,
2121 						    Layout* layout)
2122 {
2123   if (sd->symbols == NULL)
2124     {
2125       gold_assert(sd->symbol_names == NULL);
2126       return;
2127     }
2128 
2129   const int sym_size = This::sym_size;
2130   size_t symcount = ((sd->symbols_size - sd->external_symbols_offset)
2131 		     / sym_size);
2132   if (symcount * sym_size != sd->symbols_size - sd->external_symbols_offset)
2133     {
2134       this->error(_("size of symbols is not multiple of symbol size"));
2135       return;
2136     }
2137 
2138   this->symbols_.resize(symcount);
2139 
2140   if (!parameters->options().relocatable()
2141       && layout->is_lto_slim_object ())
2142     gold_info(_("%s: plugin needed to handle lto object"),
2143 	      this->name().c_str());
2144 
2145   const char* sym_names =
2146     reinterpret_cast<const char*>(sd->symbol_names->data());
2147   symtab->add_from_relobj(this,
2148 			  sd->symbols->data() + sd->external_symbols_offset,
2149 			  symcount, this->local_symbol_count_,
2150 			  sym_names, sd->symbol_names_size,
2151 			  &this->symbols_,
2152 			  &this->defined_count_);
2153 
2154   delete sd->symbols;
2155   sd->symbols = NULL;
2156   delete sd->symbol_names;
2157   sd->symbol_names = NULL;
2158 }
2159 
2160 // Find out if this object, that is a member of a lib group, should be included
2161 // in the link. We check every symbol defined by this object. If the symbol
2162 // table has a strong undefined reference to that symbol, we have to include
2163 // the object.
2164 
2165 template<int size, bool big_endian>
2166 Archive::Should_include
do_should_include_member(Symbol_table * symtab,Layout * layout,Read_symbols_data * sd,std::string * why)2167 Sized_relobj_file<size, big_endian>::do_should_include_member(
2168     Symbol_table* symtab,
2169     Layout* layout,
2170     Read_symbols_data* sd,
2171     std::string* why)
2172 {
2173   char* tmpbuf = NULL;
2174   size_t tmpbuflen = 0;
2175   const char* sym_names =
2176       reinterpret_cast<const char*>(sd->symbol_names->data());
2177   const unsigned char* syms =
2178       sd->symbols->data() + sd->external_symbols_offset;
2179   const int sym_size = elfcpp::Elf_sizes<size>::sym_size;
2180   size_t symcount = ((sd->symbols_size - sd->external_symbols_offset)
2181 			 / sym_size);
2182 
2183   const unsigned char* p = syms;
2184 
2185   for (size_t i = 0; i < symcount; ++i, p += sym_size)
2186     {
2187       elfcpp::Sym<size, big_endian> sym(p);
2188       unsigned int st_shndx = sym.get_st_shndx();
2189       if (st_shndx == elfcpp::SHN_UNDEF)
2190 	continue;
2191 
2192       unsigned int st_name = sym.get_st_name();
2193       const char* name = sym_names + st_name;
2194       Symbol* symbol;
2195       Archive::Should_include t = Archive::should_include_member(symtab,
2196 								 layout,
2197 								 name,
2198 								 &symbol, why,
2199 								 &tmpbuf,
2200 								 &tmpbuflen);
2201       if (t == Archive::SHOULD_INCLUDE_YES)
2202 	{
2203 	  if (tmpbuf != NULL)
2204 	    free(tmpbuf);
2205 	  return t;
2206 	}
2207     }
2208   if (tmpbuf != NULL)
2209     free(tmpbuf);
2210   return Archive::SHOULD_INCLUDE_UNKNOWN;
2211 }
2212 
2213 // Iterate over global defined symbols, calling a visitor class V for each.
2214 
2215 template<int size, bool big_endian>
2216 void
do_for_all_global_symbols(Read_symbols_data * sd,Library_base::Symbol_visitor_base * v)2217 Sized_relobj_file<size, big_endian>::do_for_all_global_symbols(
2218     Read_symbols_data* sd,
2219     Library_base::Symbol_visitor_base* v)
2220 {
2221   const char* sym_names =
2222       reinterpret_cast<const char*>(sd->symbol_names->data());
2223   const unsigned char* syms =
2224       sd->symbols->data() + sd->external_symbols_offset;
2225   const int sym_size = elfcpp::Elf_sizes<size>::sym_size;
2226   size_t symcount = ((sd->symbols_size - sd->external_symbols_offset)
2227 		     / sym_size);
2228   const unsigned char* p = syms;
2229 
2230   for (size_t i = 0; i < symcount; ++i, p += sym_size)
2231     {
2232       elfcpp::Sym<size, big_endian> sym(p);
2233       if (sym.get_st_shndx() != elfcpp::SHN_UNDEF)
2234 	v->visit(sym_names + sym.get_st_name());
2235     }
2236 }
2237 
2238 // Return whether the local symbol SYMNDX has a PLT offset.
2239 
2240 template<int size, bool big_endian>
2241 bool
local_has_plt_offset(unsigned int symndx) const2242 Sized_relobj_file<size, big_endian>::local_has_plt_offset(
2243     unsigned int symndx) const
2244 {
2245   typename Local_plt_offsets::const_iterator p =
2246     this->local_plt_offsets_.find(symndx);
2247   return p != this->local_plt_offsets_.end();
2248 }
2249 
2250 // Get the PLT offset of a local symbol.
2251 
2252 template<int size, bool big_endian>
2253 unsigned int
do_local_plt_offset(unsigned int symndx) const2254 Sized_relobj_file<size, big_endian>::do_local_plt_offset(
2255     unsigned int symndx) const
2256 {
2257   typename Local_plt_offsets::const_iterator p =
2258     this->local_plt_offsets_.find(symndx);
2259   gold_assert(p != this->local_plt_offsets_.end());
2260   return p->second;
2261 }
2262 
2263 // Set the PLT offset of a local symbol.
2264 
2265 template<int size, bool big_endian>
2266 void
set_local_plt_offset(unsigned int symndx,unsigned int plt_offset)2267 Sized_relobj_file<size, big_endian>::set_local_plt_offset(
2268     unsigned int symndx, unsigned int plt_offset)
2269 {
2270   std::pair<typename Local_plt_offsets::iterator, bool> ins =
2271     this->local_plt_offsets_.insert(std::make_pair(symndx, plt_offset));
2272   gold_assert(ins.second);
2273 }
2274 
2275 // First pass over the local symbols.  Here we add their names to
2276 // *POOL and *DYNPOOL, and we store the symbol value in
2277 // THIS->LOCAL_VALUES_.  This function is always called from a
2278 // singleton thread.  This is followed by a call to
2279 // finalize_local_symbols.
2280 
2281 template<int size, bool big_endian>
2282 void
do_count_local_symbols(Stringpool * pool,Stringpool * dynpool)2283 Sized_relobj_file<size, big_endian>::do_count_local_symbols(Stringpool* pool,
2284 							    Stringpool* dynpool)
2285 {
2286   gold_assert(this->symtab_shndx_ != -1U);
2287   if (this->symtab_shndx_ == 0)
2288     {
2289       // This object has no symbols.  Weird but legal.
2290       return;
2291     }
2292 
2293   // Read the symbol table section header.
2294   const unsigned int symtab_shndx = this->symtab_shndx_;
2295   typename This::Shdr symtabshdr(this,
2296 				 this->elf_file_.section_header(symtab_shndx));
2297   gold_assert(symtabshdr.get_sh_type() == elfcpp::SHT_SYMTAB);
2298 
2299   // Read the local symbols.
2300   const int sym_size = This::sym_size;
2301   const unsigned int loccount = this->local_symbol_count_;
2302   gold_assert(loccount == symtabshdr.get_sh_info());
2303   off_t locsize = loccount * sym_size;
2304   const unsigned char* psyms = this->get_view(symtabshdr.get_sh_offset(),
2305 					      locsize, true, true);
2306 
2307   // Read the symbol names.
2308   const unsigned int strtab_shndx =
2309     this->adjust_shndx(symtabshdr.get_sh_link());
2310   section_size_type strtab_size;
2311   const unsigned char* pnamesu = this->section_contents(strtab_shndx,
2312 							&strtab_size,
2313 							true);
2314   const char* pnames = reinterpret_cast<const char*>(pnamesu);
2315 
2316   // Loop over the local symbols.
2317 
2318   const Output_sections& out_sections(this->output_sections());
2319   std::vector<Address>& out_section_offsets(this->section_offsets());
2320   unsigned int shnum = this->shnum();
2321   unsigned int count = 0;
2322   unsigned int dyncount = 0;
2323   // Skip the first, dummy, symbol.
2324   psyms += sym_size;
2325   bool strip_all = parameters->options().strip_all();
2326   bool discard_all = parameters->options().discard_all();
2327   bool discard_locals = parameters->options().discard_locals();
2328   bool discard_sec_merge = parameters->options().discard_sec_merge();
2329   for (unsigned int i = 1; i < loccount; ++i, psyms += sym_size)
2330     {
2331       elfcpp::Sym<size, big_endian> sym(psyms);
2332 
2333       Symbol_value<size>& lv(this->local_values_[i]);
2334 
2335       bool is_ordinary;
2336       unsigned int shndx = this->adjust_sym_shndx(i, sym.get_st_shndx(),
2337 						  &is_ordinary);
2338       lv.set_input_shndx(shndx, is_ordinary);
2339 
2340       if (sym.get_st_type() == elfcpp::STT_SECTION)
2341 	lv.set_is_section_symbol();
2342       else if (sym.get_st_type() == elfcpp::STT_TLS)
2343 	lv.set_is_tls_symbol();
2344       else if (sym.get_st_type() == elfcpp::STT_GNU_IFUNC)
2345 	lv.set_is_ifunc_symbol();
2346 
2347       // Save the input symbol value for use in do_finalize_local_symbols().
2348       lv.set_input_value(sym.get_st_value());
2349 
2350       // Decide whether this symbol should go into the output file.
2351 
2352       if (is_ordinary
2353 	  && shndx < shnum
2354 	  && (out_sections[shndx] == NULL
2355 	      || (out_sections[shndx]->order() == ORDER_EHFRAME
2356 		  && out_section_offsets[shndx] == invalid_address)))
2357 	{
2358 	  // This is either a discarded section or an optimized .eh_frame
2359 	  // section.
2360 	  lv.set_no_output_symtab_entry();
2361 	  gold_assert(!lv.needs_output_dynsym_entry());
2362 	  continue;
2363 	}
2364 
2365       if (sym.get_st_type() == elfcpp::STT_SECTION
2366 	  || !this->adjust_local_symbol(&lv))
2367 	{
2368 	  lv.set_no_output_symtab_entry();
2369 	  gold_assert(!lv.needs_output_dynsym_entry());
2370 	  continue;
2371 	}
2372 
2373       if (sym.get_st_name() >= strtab_size)
2374 	{
2375 	  this->error(_("local symbol %u section name out of range: %u >= %u"),
2376 		      i, sym.get_st_name(),
2377 		      static_cast<unsigned int>(strtab_size));
2378 	  lv.set_no_output_symtab_entry();
2379 	  continue;
2380 	}
2381 
2382       const char* name = pnames + sym.get_st_name();
2383 
2384       // If needed, add the symbol to the dynamic symbol table string pool.
2385       if (lv.needs_output_dynsym_entry())
2386 	{
2387 	  dynpool->add(name, true, NULL);
2388 	  ++dyncount;
2389 	}
2390 
2391       if (strip_all
2392 	  || (discard_all && lv.may_be_discarded_from_output_symtab()))
2393 	{
2394 	  lv.set_no_output_symtab_entry();
2395 	  continue;
2396 	}
2397 
2398       // By default, discard temporary local symbols in merge sections.
2399       // If --discard-locals option is used, discard all temporary local
2400       // symbols.  These symbols start with system-specific local label
2401       // prefixes, typically .L for ELF system.  We want to be compatible
2402       // with GNU ld so here we essentially use the same check in
2403       // bfd_is_local_label().  The code is different because we already
2404       // know that:
2405       //
2406       //   - the symbol is local and thus cannot have global or weak binding.
2407       //   - the symbol is not a section symbol.
2408       //   - the symbol has a name.
2409       //
2410       // We do not discard a symbol if it needs a dynamic symbol entry.
2411       if ((discard_locals
2412 	   || (discard_sec_merge
2413 	       && is_ordinary
2414 	       && out_section_offsets[shndx] == invalid_address))
2415 	  && sym.get_st_type() != elfcpp::STT_FILE
2416 	  && !lv.needs_output_dynsym_entry()
2417 	  && lv.may_be_discarded_from_output_symtab()
2418 	  && parameters->target().is_local_label_name(name))
2419 	{
2420 	  lv.set_no_output_symtab_entry();
2421 	  continue;
2422 	}
2423 
2424       // Discard the local symbol if -retain_symbols_file is specified
2425       // and the local symbol is not in that file.
2426       if (!parameters->options().should_retain_symbol(name))
2427 	{
2428 	  lv.set_no_output_symtab_entry();
2429 	  continue;
2430 	}
2431 
2432       // Add the symbol to the symbol table string pool.
2433       pool->add(name, true, NULL);
2434       ++count;
2435     }
2436 
2437   this->output_local_symbol_count_ = count;
2438   this->output_local_dynsym_count_ = dyncount;
2439 }
2440 
2441 // Compute the final value of a local symbol.
2442 
2443 template<int size, bool big_endian>
2444 typename Sized_relobj_file<size, big_endian>::Compute_final_local_value_status
compute_final_local_value_internal(unsigned int r_sym,const Symbol_value<size> * lv_in,Symbol_value<size> * lv_out,bool relocatable,const Output_sections & out_sections,const std::vector<Address> & out_offsets,const Symbol_table * symtab)2445 Sized_relobj_file<size, big_endian>::compute_final_local_value_internal(
2446     unsigned int r_sym,
2447     const Symbol_value<size>* lv_in,
2448     Symbol_value<size>* lv_out,
2449     bool relocatable,
2450     const Output_sections& out_sections,
2451     const std::vector<Address>& out_offsets,
2452     const Symbol_table* symtab)
2453 {
2454   // We are going to overwrite *LV_OUT, if it has a merged symbol value,
2455   // we may have a memory leak.
2456   gold_assert(lv_out->has_output_value());
2457 
2458   bool is_ordinary;
2459   unsigned int shndx = lv_in->input_shndx(&is_ordinary);
2460 
2461   // Set the output symbol value.
2462 
2463   if (!is_ordinary)
2464     {
2465       if (shndx == elfcpp::SHN_ABS || Symbol::is_common_shndx(shndx))
2466 	lv_out->set_output_value(lv_in->input_value());
2467       else
2468 	{
2469 	  this->error(_("unknown section index %u for local symbol %u"),
2470 		      shndx, r_sym);
2471 	  lv_out->set_output_value(0);
2472 	  return This::CFLV_ERROR;
2473 	}
2474     }
2475   else
2476     {
2477       if (shndx >= this->shnum())
2478 	{
2479 	  this->error(_("local symbol %u section index %u out of range"),
2480 		      r_sym, shndx);
2481 	  lv_out->set_output_value(0);
2482 	  return This::CFLV_ERROR;
2483 	}
2484 
2485       Output_section* os = out_sections[shndx];
2486       Address secoffset = out_offsets[shndx];
2487       if (symtab->is_section_folded(this, shndx))
2488 	{
2489 	  gold_assert(os == NULL && secoffset == invalid_address);
2490 	  // Get the os of the section it is folded onto.
2491 	  Section_id folded = symtab->icf()->get_folded_section(this,
2492 								shndx);
2493 	  gold_assert(folded.first != NULL);
2494 	  Sized_relobj_file<size, big_endian>* folded_obj = reinterpret_cast
2495 	    <Sized_relobj_file<size, big_endian>*>(folded.first);
2496 	  os = folded_obj->output_section(folded.second);
2497 	  gold_assert(os != NULL);
2498 	  secoffset = folded_obj->get_output_section_offset(folded.second);
2499 
2500 	  // This could be a relaxed input section.
2501 	  if (secoffset == invalid_address)
2502 	    {
2503 	      const Output_relaxed_input_section* relaxed_section =
2504 		os->find_relaxed_input_section(folded_obj, folded.second);
2505 	      gold_assert(relaxed_section != NULL);
2506 	      secoffset = relaxed_section->address() - os->address();
2507 	    }
2508 	}
2509 
2510       if (os == NULL)
2511 	{
2512 	  // This local symbol belongs to a section we are discarding.
2513 	  // In some cases when applying relocations later, we will
2514 	  // attempt to match it to the corresponding kept section,
2515 	  // so we leave the input value unchanged here.
2516 	  return This::CFLV_DISCARDED;
2517 	}
2518       else if (secoffset == invalid_address)
2519 	{
2520 	  uint64_t start;
2521 
2522 	  // This is a SHF_MERGE section or one which otherwise
2523 	  // requires special handling.
2524 	  if (os->order() == ORDER_EHFRAME)
2525 	    {
2526 	      // This local symbol belongs to a discarded or optimized
2527 	      // .eh_frame section.  Just treat it like the case in which
2528 	      // os == NULL above.
2529 	      gold_assert(this->has_eh_frame_);
2530 	      return This::CFLV_DISCARDED;
2531 	    }
2532 	  else if (!lv_in->is_section_symbol())
2533 	    {
2534 	      // This is not a section symbol.  We can determine
2535 	      // the final value now.
2536 	      uint64_t value =
2537 		os->output_address(this, shndx, lv_in->input_value());
2538 	      if (relocatable)
2539 		value -= os->address();
2540 	      lv_out->set_output_value(value);
2541 	    }
2542 	  else if (!os->find_starting_output_address(this, shndx, &start))
2543 	    {
2544 	      // This is a section symbol, but apparently not one in a
2545 	      // merged section.  First check to see if this is a relaxed
2546 	      // input section.  If so, use its address.  Otherwise just
2547 	      // use the start of the output section.  This happens with
2548 	      // relocatable links when the input object has section
2549 	      // symbols for arbitrary non-merge sections.
2550 	      const Output_section_data* posd =
2551 		os->find_relaxed_input_section(this, shndx);
2552 	      if (posd != NULL)
2553 		{
2554 		  uint64_t value = posd->address();
2555 		  if (relocatable)
2556 		    value -= os->address();
2557 		  lv_out->set_output_value(value);
2558 		}
2559 	      else
2560 		lv_out->set_output_value(os->address());
2561 	    }
2562 	  else
2563 	    {
2564 	      // We have to consider the addend to determine the
2565 	      // value to use in a relocation.  START is the start
2566 	      // of this input section.  If we are doing a relocatable
2567 	      // link, use offset from start output section instead of
2568 	      // address.
2569 	      Address adjusted_start =
2570 		relocatable ? start - os->address() : start;
2571 	      Merged_symbol_value<size>* msv =
2572 		new Merged_symbol_value<size>(lv_in->input_value(),
2573 					      adjusted_start);
2574 	      lv_out->set_merged_symbol_value(msv);
2575 	    }
2576 	}
2577       else if (lv_in->is_tls_symbol()
2578                || (lv_in->is_section_symbol()
2579                    && (os->flags() & elfcpp::SHF_TLS)))
2580 	lv_out->set_output_value(os->tls_offset()
2581 				 + secoffset
2582 				 + lv_in->input_value());
2583       else
2584 	lv_out->set_output_value((relocatable ? 0 : os->address())
2585 				 + secoffset
2586 				 + lv_in->input_value());
2587     }
2588   return This::CFLV_OK;
2589 }
2590 
2591 // Compute final local symbol value.  R_SYM is the index of a local
2592 // symbol in symbol table.  LV points to a symbol value, which is
2593 // expected to hold the input value and to be over-written by the
2594 // final value.  SYMTAB points to a symbol table.  Some targets may want
2595 // to know would-be-finalized local symbol values in relaxation.
2596 // Hence we provide this method.  Since this method updates *LV, a
2597 // callee should make a copy of the original local symbol value and
2598 // use the copy instead of modifying an object's local symbols before
2599 // everything is finalized.  The caller should also free up any allocated
2600 // memory in the return value in *LV.
2601 template<int size, bool big_endian>
2602 typename Sized_relobj_file<size, big_endian>::Compute_final_local_value_status
compute_final_local_value(unsigned int r_sym,const Symbol_value<size> * lv_in,Symbol_value<size> * lv_out,const Symbol_table * symtab)2603 Sized_relobj_file<size, big_endian>::compute_final_local_value(
2604     unsigned int r_sym,
2605     const Symbol_value<size>* lv_in,
2606     Symbol_value<size>* lv_out,
2607     const Symbol_table* symtab)
2608 {
2609   // This is just a wrapper of compute_final_local_value_internal.
2610   const bool relocatable = parameters->options().relocatable();
2611   const Output_sections& out_sections(this->output_sections());
2612   const std::vector<Address>& out_offsets(this->section_offsets());
2613   return this->compute_final_local_value_internal(r_sym, lv_in, lv_out,
2614 						  relocatable, out_sections,
2615 						  out_offsets, symtab);
2616 }
2617 
2618 // Finalize the local symbols.  Here we set the final value in
2619 // THIS->LOCAL_VALUES_ and set their output symbol table indexes.
2620 // This function is always called from a singleton thread.  The actual
2621 // output of the local symbols will occur in a separate task.
2622 
2623 template<int size, bool big_endian>
2624 unsigned int
do_finalize_local_symbols(unsigned int index,off_t off,Symbol_table * symtab)2625 Sized_relobj_file<size, big_endian>::do_finalize_local_symbols(
2626     unsigned int index,
2627     off_t off,
2628     Symbol_table* symtab)
2629 {
2630   gold_assert(off == static_cast<off_t>(align_address(off, size >> 3)));
2631 
2632   const unsigned int loccount = this->local_symbol_count_;
2633   this->local_symbol_offset_ = off;
2634 
2635   const bool relocatable = parameters->options().relocatable();
2636   const Output_sections& out_sections(this->output_sections());
2637   const std::vector<Address>& out_offsets(this->section_offsets());
2638 
2639   for (unsigned int i = 1; i < loccount; ++i)
2640     {
2641       Symbol_value<size>* lv = &this->local_values_[i];
2642 
2643       Compute_final_local_value_status cflv_status =
2644 	this->compute_final_local_value_internal(i, lv, lv, relocatable,
2645 						 out_sections, out_offsets,
2646 						 symtab);
2647       switch (cflv_status)
2648 	{
2649 	case CFLV_OK:
2650 	  if (!lv->is_output_symtab_index_set())
2651 	    {
2652 	      lv->set_output_symtab_index(index);
2653 	      ++index;
2654 	    }
2655 	  if (lv->is_ifunc_symbol()
2656 	      && (lv->has_output_symtab_entry()
2657 		  || lv->needs_output_dynsym_entry()))
2658 	    symtab->set_has_gnu_output();
2659 	  break;
2660 	case CFLV_DISCARDED:
2661 	case CFLV_ERROR:
2662 	  // Do nothing.
2663 	  break;
2664 	default:
2665 	  gold_unreachable();
2666 	}
2667     }
2668   return index;
2669 }
2670 
2671 // Set the output dynamic symbol table indexes for the local variables.
2672 
2673 template<int size, bool big_endian>
2674 unsigned int
do_set_local_dynsym_indexes(unsigned int index)2675 Sized_relobj_file<size, big_endian>::do_set_local_dynsym_indexes(
2676     unsigned int index)
2677 {
2678   const unsigned int loccount = this->local_symbol_count_;
2679   for (unsigned int i = 1; i < loccount; ++i)
2680     {
2681       Symbol_value<size>& lv(this->local_values_[i]);
2682       if (lv.needs_output_dynsym_entry())
2683 	{
2684 	  lv.set_output_dynsym_index(index);
2685 	  ++index;
2686 	}
2687     }
2688   return index;
2689 }
2690 
2691 // Set the offset where local dynamic symbol information will be stored.
2692 // Returns the count of local symbols contributed to the symbol table by
2693 // this object.
2694 
2695 template<int size, bool big_endian>
2696 unsigned int
do_set_local_dynsym_offset(off_t off)2697 Sized_relobj_file<size, big_endian>::do_set_local_dynsym_offset(off_t off)
2698 {
2699   gold_assert(off == static_cast<off_t>(align_address(off, size >> 3)));
2700   this->local_dynsym_offset_ = off;
2701   return this->output_local_dynsym_count_;
2702 }
2703 
2704 // If Symbols_data is not NULL get the section flags from here otherwise
2705 // get it from the file.
2706 
2707 template<int size, bool big_endian>
2708 uint64_t
do_section_flags(unsigned int shndx)2709 Sized_relobj_file<size, big_endian>::do_section_flags(unsigned int shndx)
2710 {
2711   Symbols_data* sd = this->get_symbols_data();
2712   if (sd != NULL)
2713     {
2714       const unsigned char* pshdrs = sd->section_headers_data
2715 				    + This::shdr_size * shndx;
2716       typename This::Shdr shdr(pshdrs);
2717       return shdr.get_sh_flags();
2718     }
2719   // If sd is NULL, read the section header from the file.
2720   return this->elf_file_.section_flags(shndx);
2721 }
2722 
2723 // Get the section's ent size from Symbols_data.  Called by get_section_contents
2724 // in icf.cc
2725 
2726 template<int size, bool big_endian>
2727 uint64_t
do_section_entsize(unsigned int shndx)2728 Sized_relobj_file<size, big_endian>::do_section_entsize(unsigned int shndx)
2729 {
2730   Symbols_data* sd = this->get_symbols_data();
2731   gold_assert(sd != NULL);
2732 
2733   const unsigned char* pshdrs = sd->section_headers_data
2734 				+ This::shdr_size * shndx;
2735   typename This::Shdr shdr(pshdrs);
2736   return shdr.get_sh_entsize();
2737 }
2738 
2739 // Write out the local symbols.
2740 
2741 template<int size, bool big_endian>
2742 void
write_local_symbols(Output_file * of,const Stringpool * sympool,const Stringpool * dynpool,Output_symtab_xindex * symtab_xindex,Output_symtab_xindex * dynsym_xindex,off_t symtab_off)2743 Sized_relobj_file<size, big_endian>::write_local_symbols(
2744     Output_file* of,
2745     const Stringpool* sympool,
2746     const Stringpool* dynpool,
2747     Output_symtab_xindex* symtab_xindex,
2748     Output_symtab_xindex* dynsym_xindex,
2749     off_t symtab_off)
2750 {
2751   const bool strip_all = parameters->options().strip_all();
2752   if (strip_all)
2753     {
2754       if (this->output_local_dynsym_count_ == 0)
2755 	return;
2756       this->output_local_symbol_count_ = 0;
2757     }
2758 
2759   gold_assert(this->symtab_shndx_ != -1U);
2760   if (this->symtab_shndx_ == 0)
2761     {
2762       // This object has no symbols.  Weird but legal.
2763       return;
2764     }
2765 
2766   // Read the symbol table section header.
2767   const unsigned int symtab_shndx = this->symtab_shndx_;
2768   typename This::Shdr symtabshdr(this,
2769 				 this->elf_file_.section_header(symtab_shndx));
2770   gold_assert(symtabshdr.get_sh_type() == elfcpp::SHT_SYMTAB);
2771   const unsigned int loccount = this->local_symbol_count_;
2772   gold_assert(loccount == symtabshdr.get_sh_info());
2773 
2774   // Read the local symbols.
2775   const int sym_size = This::sym_size;
2776   off_t locsize = loccount * sym_size;
2777   const unsigned char* psyms = this->get_view(symtabshdr.get_sh_offset(),
2778 					      locsize, true, false);
2779 
2780   // Read the symbol names.
2781   const unsigned int strtab_shndx =
2782     this->adjust_shndx(symtabshdr.get_sh_link());
2783   section_size_type strtab_size;
2784   const unsigned char* pnamesu = this->section_contents(strtab_shndx,
2785 							&strtab_size,
2786 							false);
2787   const char* pnames = reinterpret_cast<const char*>(pnamesu);
2788 
2789   // Get views into the output file for the portions of the symbol table
2790   // and the dynamic symbol table that we will be writing.
2791   off_t output_size = this->output_local_symbol_count_ * sym_size;
2792   unsigned char* oview = NULL;
2793   if (output_size > 0)
2794     oview = of->get_output_view(symtab_off + this->local_symbol_offset_,
2795 				output_size);
2796 
2797   off_t dyn_output_size = this->output_local_dynsym_count_ * sym_size;
2798   unsigned char* dyn_oview = NULL;
2799   if (dyn_output_size > 0)
2800     dyn_oview = of->get_output_view(this->local_dynsym_offset_,
2801 				    dyn_output_size);
2802 
2803   const Output_sections& out_sections(this->output_sections());
2804 
2805   gold_assert(this->local_values_.size() == loccount);
2806 
2807   unsigned char* ov = oview;
2808   unsigned char* dyn_ov = dyn_oview;
2809   psyms += sym_size;
2810   for (unsigned int i = 1; i < loccount; ++i, psyms += sym_size)
2811     {
2812       elfcpp::Sym<size, big_endian> isym(psyms);
2813 
2814       Symbol_value<size>& lv(this->local_values_[i]);
2815 
2816       bool is_ordinary;
2817       unsigned int st_shndx = this->adjust_sym_shndx(i, isym.get_st_shndx(),
2818 						     &is_ordinary);
2819       if (is_ordinary)
2820 	{
2821 	  gold_assert(st_shndx < out_sections.size());
2822 	  if (out_sections[st_shndx] == NULL)
2823 	    continue;
2824 	  st_shndx = out_sections[st_shndx]->out_shndx();
2825 	  if (st_shndx >= elfcpp::SHN_LORESERVE)
2826 	    {
2827 	      if (lv.has_output_symtab_entry())
2828 		symtab_xindex->add(lv.output_symtab_index(), st_shndx);
2829 	      if (lv.has_output_dynsym_entry())
2830 		dynsym_xindex->add(lv.output_dynsym_index(), st_shndx);
2831 	      st_shndx = elfcpp::SHN_XINDEX;
2832 	    }
2833 	}
2834 
2835       // Write the symbol to the output symbol table.
2836       if (lv.has_output_symtab_entry())
2837 	{
2838 	  elfcpp::Sym_write<size, big_endian> osym(ov);
2839 
2840 	  gold_assert(isym.get_st_name() < strtab_size);
2841 	  const char* name = pnames + isym.get_st_name();
2842 	  osym.put_st_name(sympool->get_offset(name));
2843 	  osym.put_st_value(lv.value(this, 0));
2844 	  osym.put_st_size(isym.get_st_size());
2845 	  osym.put_st_info(isym.get_st_info());
2846 	  osym.put_st_other(isym.get_st_other());
2847 	  osym.put_st_shndx(st_shndx);
2848 
2849 	  ov += sym_size;
2850 	}
2851 
2852       // Write the symbol to the output dynamic symbol table.
2853       if (lv.has_output_dynsym_entry())
2854 	{
2855 	  gold_assert(dyn_ov < dyn_oview + dyn_output_size);
2856 	  elfcpp::Sym_write<size, big_endian> osym(dyn_ov);
2857 
2858 	  gold_assert(isym.get_st_name() < strtab_size);
2859 	  const char* name = pnames + isym.get_st_name();
2860 	  osym.put_st_name(dynpool->get_offset(name));
2861 	  osym.put_st_value(lv.value(this, 0));
2862 	  osym.put_st_size(isym.get_st_size());
2863 	  osym.put_st_info(isym.get_st_info());
2864 	  osym.put_st_other(isym.get_st_other());
2865 	  osym.put_st_shndx(st_shndx);
2866 
2867 	  dyn_ov += sym_size;
2868 	}
2869     }
2870 
2871 
2872   if (output_size > 0)
2873     {
2874       gold_assert(ov - oview == output_size);
2875       of->write_output_view(symtab_off + this->local_symbol_offset_,
2876 			    output_size, oview);
2877     }
2878 
2879   if (dyn_output_size > 0)
2880     {
2881       gold_assert(dyn_ov - dyn_oview == dyn_output_size);
2882       of->write_output_view(this->local_dynsym_offset_, dyn_output_size,
2883 			    dyn_oview);
2884     }
2885 }
2886 
2887 // Set *INFO to symbolic information about the offset OFFSET in the
2888 // section SHNDX.  Return true if we found something, false if we
2889 // found nothing.
2890 
2891 template<int size, bool big_endian>
2892 bool
get_symbol_location_info(unsigned int shndx,off_t offset,Symbol_location_info * info)2893 Sized_relobj_file<size, big_endian>::get_symbol_location_info(
2894     unsigned int shndx,
2895     off_t offset,
2896     Symbol_location_info* info)
2897 {
2898   if (this->symtab_shndx_ == 0)
2899     return false;
2900 
2901   section_size_type symbols_size;
2902   const unsigned char* symbols = this->section_contents(this->symtab_shndx_,
2903 							&symbols_size,
2904 							false);
2905 
2906   unsigned int symbol_names_shndx =
2907     this->adjust_shndx(this->section_link(this->symtab_shndx_));
2908   section_size_type names_size;
2909   const unsigned char* symbol_names_u =
2910     this->section_contents(symbol_names_shndx, &names_size, false);
2911   const char* symbol_names = reinterpret_cast<const char*>(symbol_names_u);
2912 
2913   const int sym_size = This::sym_size;
2914   const size_t count = symbols_size / sym_size;
2915 
2916   const unsigned char* p = symbols;
2917   for (size_t i = 0; i < count; ++i, p += sym_size)
2918     {
2919       elfcpp::Sym<size, big_endian> sym(p);
2920 
2921       if (sym.get_st_type() == elfcpp::STT_FILE)
2922 	{
2923 	  if (sym.get_st_name() >= names_size)
2924 	    info->source_file = "(invalid)";
2925 	  else
2926 	    info->source_file = symbol_names + sym.get_st_name();
2927 	  continue;
2928 	}
2929 
2930       bool is_ordinary;
2931       unsigned int st_shndx = this->adjust_sym_shndx(i, sym.get_st_shndx(),
2932 						     &is_ordinary);
2933       if (is_ordinary
2934 	  && st_shndx == shndx
2935 	  && static_cast<off_t>(sym.get_st_value()) <= offset
2936 	  && (static_cast<off_t>(sym.get_st_value() + sym.get_st_size())
2937 	      > offset))
2938 	{
2939 	  info->enclosing_symbol_type = sym.get_st_type();
2940 	  if (sym.get_st_name() > names_size)
2941 	    info->enclosing_symbol_name = "(invalid)";
2942 	  else
2943 	    {
2944 	      info->enclosing_symbol_name = symbol_names + sym.get_st_name();
2945 	      if (parameters->options().do_demangle())
2946 		{
2947 		  char* demangled_name = cplus_demangle(
2948 		      info->enclosing_symbol_name.c_str(),
2949 		      DMGL_ANSI | DMGL_PARAMS);
2950 		  if (demangled_name != NULL)
2951 		    {
2952 		      info->enclosing_symbol_name.assign(demangled_name);
2953 		      free(demangled_name);
2954 		    }
2955 		}
2956 	    }
2957 	  return true;
2958 	}
2959     }
2960 
2961   return false;
2962 }
2963 
2964 // Look for a kept section corresponding to the given discarded section,
2965 // and return its output address.  This is used only for relocations in
2966 // debugging sections.  If we can't find the kept section, return 0.
2967 
2968 template<int size, bool big_endian>
2969 typename Sized_relobj_file<size, big_endian>::Address
map_to_kept_section(unsigned int shndx,std::string & section_name,bool * pfound) const2970 Sized_relobj_file<size, big_endian>::map_to_kept_section(
2971     unsigned int shndx,
2972     std::string& section_name,
2973     bool* pfound) const
2974 {
2975   Kept_section* kept_section;
2976   bool is_comdat;
2977   uint64_t sh_size;
2978   unsigned int symndx;
2979   bool found = false;
2980 
2981   if (this->get_kept_comdat_section(shndx, &is_comdat, &symndx, &sh_size,
2982 				    &kept_section))
2983     {
2984       Relobj* kept_object = kept_section->object();
2985       unsigned int kept_shndx = 0;
2986       if (!kept_section->is_comdat())
2987         {
2988 	  // The kept section is a linkonce section.
2989 	  if (sh_size == kept_section->linkonce_size())
2990 	    {
2991 	      kept_shndx = kept_section->shndx();
2992 	      found = true;
2993 	    }
2994         }
2995       else
2996 	{
2997 	  uint64_t kept_size = 0;
2998 	  if (is_comdat)
2999 	    {
3000 	      // Find the corresponding kept section.
3001 	      // Since we're using this mapping for relocation processing,
3002 	      // we don't want to match sections unless they have the same
3003 	      // size.
3004 	      if (kept_section->find_comdat_section(section_name, &kept_shndx,
3005 						    &kept_size))
3006 		{
3007 		  if (sh_size == kept_size)
3008 		    found = true;
3009 		}
3010 	    }
3011 	  if (!found)
3012 	    {
3013 	      if (kept_section->find_single_comdat_section(&kept_shndx,
3014 							   &kept_size)
3015 		  && sh_size == kept_size)
3016 		found = true;
3017 	    }
3018 	}
3019 
3020       if (found)
3021 	{
3022 	  Sized_relobj_file<size, big_endian>* kept_relobj =
3023 	    static_cast<Sized_relobj_file<size, big_endian>*>(kept_object);
3024 	  Output_section* os = kept_relobj->output_section(kept_shndx);
3025 	  Address offset = kept_relobj->get_output_section_offset(kept_shndx);
3026 	  if (os != NULL && offset != invalid_address)
3027 	    {
3028 	      *pfound = true;
3029 	      return os->address() + offset;
3030 	    }
3031 	}
3032     }
3033   *pfound = false;
3034   return 0;
3035 }
3036 
3037 // Look for a kept section corresponding to the given discarded section,
3038 // and return its object file.
3039 
3040 template<int size, bool big_endian>
3041 Relobj*
find_kept_section_object(unsigned int shndx,unsigned int * symndx_p) const3042 Sized_relobj_file<size, big_endian>::find_kept_section_object(
3043     unsigned int shndx, unsigned int *symndx_p) const
3044 {
3045   Kept_section* kept_section;
3046   bool is_comdat;
3047   uint64_t sh_size;
3048   if (this->get_kept_comdat_section(shndx, &is_comdat, symndx_p, &sh_size,
3049 				    &kept_section))
3050     return kept_section->object();
3051   return NULL;
3052 }
3053 
3054 // Return the name of symbol SYMNDX.
3055 
3056 template<int size, bool big_endian>
3057 const char*
get_symbol_name(unsigned int symndx)3058 Sized_relobj_file<size, big_endian>::get_symbol_name(unsigned int symndx)
3059 {
3060   if (this->symtab_shndx_ == 0)
3061     return NULL;
3062 
3063   section_size_type symbols_size;
3064   const unsigned char* symbols = this->section_contents(this->symtab_shndx_,
3065 							&symbols_size,
3066 							false);
3067 
3068   unsigned int symbol_names_shndx =
3069     this->adjust_shndx(this->section_link(this->symtab_shndx_));
3070   section_size_type names_size;
3071   const unsigned char* symbol_names_u =
3072     this->section_contents(symbol_names_shndx, &names_size, false);
3073   const char* symbol_names = reinterpret_cast<const char*>(symbol_names_u);
3074 
3075   const unsigned char* p = symbols + symndx * This::sym_size;
3076 
3077   if (p >= symbols + symbols_size)
3078     return NULL;
3079 
3080   elfcpp::Sym<size, big_endian> sym(p);
3081 
3082   return symbol_names + sym.get_st_name();
3083 }
3084 
3085 // Get symbol counts.
3086 
3087 template<int size, bool big_endian>
3088 void
do_get_global_symbol_counts(const Symbol_table *,size_t * defined,size_t * used) const3089 Sized_relobj_file<size, big_endian>::do_get_global_symbol_counts(
3090     const Symbol_table*,
3091     size_t* defined,
3092     size_t* used) const
3093 {
3094   *defined = this->defined_count_;
3095   size_t count = 0;
3096   for (typename Symbols::const_iterator p = this->symbols_.begin();
3097        p != this->symbols_.end();
3098        ++p)
3099     if (*p != NULL
3100 	&& (*p)->source() == Symbol::FROM_OBJECT
3101 	&& (*p)->object() == this
3102 	&& (*p)->is_defined())
3103       ++count;
3104   *used = count;
3105 }
3106 
3107 // Return a view of the decompressed contents of a section.  Set *PLEN
3108 // to the size.  Set *IS_NEW to true if the contents need to be freed
3109 // by the caller.
3110 
3111 const unsigned char*
decompressed_section_contents(unsigned int shndx,section_size_type * plen,bool * is_new,uint64_t * palign)3112 Object::decompressed_section_contents(
3113     unsigned int shndx,
3114     section_size_type* plen,
3115     bool* is_new,
3116     uint64_t* palign)
3117 {
3118   section_size_type buffer_size;
3119   const unsigned char* buffer = this->do_section_contents(shndx, &buffer_size,
3120 							  false);
3121 
3122   if (this->compressed_sections_ == NULL)
3123     {
3124       *plen = buffer_size;
3125       *is_new = false;
3126       return buffer;
3127     }
3128 
3129   Compressed_section_map::const_iterator p =
3130       this->compressed_sections_->find(shndx);
3131   if (p == this->compressed_sections_->end())
3132     {
3133       *plen = buffer_size;
3134       *is_new = false;
3135       return buffer;
3136     }
3137 
3138   section_size_type uncompressed_size = p->second.size;
3139   if (p->second.contents != NULL)
3140     {
3141       *plen = uncompressed_size;
3142       *is_new = false;
3143       if (palign != NULL)
3144 	*palign = p->second.addralign;
3145       return p->second.contents;
3146     }
3147 
3148   unsigned char* uncompressed_data = new unsigned char[uncompressed_size];
3149   if (!decompress_input_section(buffer,
3150 				buffer_size,
3151 				uncompressed_data,
3152 				uncompressed_size,
3153 				elfsize(),
3154 				is_big_endian(),
3155 				p->second.flag))
3156     this->error(_("could not decompress section %s"),
3157 		this->do_section_name(shndx).c_str());
3158 
3159   // We could cache the results in p->second.contents and store
3160   // false in *IS_NEW, but build_compressed_section_map() would
3161   // have done so if it had expected it to be profitable.  If
3162   // we reach this point, we expect to need the contents only
3163   // once in this pass.
3164   *plen = uncompressed_size;
3165   *is_new = true;
3166   if (palign != NULL)
3167     *palign = p->second.addralign;
3168   return uncompressed_data;
3169 }
3170 
3171 // Discard any buffers of uncompressed sections.  This is done
3172 // at the end of the Add_symbols task.
3173 
3174 void
discard_decompressed_sections()3175 Object::discard_decompressed_sections()
3176 {
3177   if (this->compressed_sections_ == NULL)
3178     return;
3179 
3180   for (Compressed_section_map::iterator p = this->compressed_sections_->begin();
3181        p != this->compressed_sections_->end();
3182        ++p)
3183     {
3184       if (p->second.contents != NULL)
3185 	{
3186 	  delete[] p->second.contents;
3187 	  p->second.contents = NULL;
3188 	}
3189     }
3190 }
3191 
3192 // Input_objects methods.
3193 
3194 // Add a regular relocatable object to the list.  Return false if this
3195 // object should be ignored.
3196 
3197 bool
add_object(Object * obj)3198 Input_objects::add_object(Object* obj)
3199 {
3200   // Print the filename if the -t/--trace option is selected.
3201   if (parameters->options().trace())
3202     gold_trace("%s", obj->name().c_str());
3203 
3204   if (!obj->is_dynamic())
3205     this->relobj_list_.push_back(static_cast<Relobj*>(obj));
3206   else
3207     {
3208       // See if this is a duplicate SONAME.
3209       Dynobj* dynobj = static_cast<Dynobj*>(obj);
3210       const char* soname = dynobj->soname();
3211 
3212       Unordered_map<std::string, Object*>::value_type val(soname, obj);
3213       std::pair<Unordered_map<std::string, Object*>::iterator, bool> ins =
3214 	this->sonames_.insert(val);
3215       if (!ins.second)
3216 	{
3217 	  // We have already seen a dynamic object with this soname.
3218 	  // If any instances of this object on the command line have
3219 	  // the --no-as-needed flag, make sure the one we keep is
3220 	  // marked so.
3221 	  if (!obj->as_needed())
3222 	    {
3223 	      gold_assert(ins.first->second != NULL);
3224 	      ins.first->second->clear_as_needed();
3225 	    }
3226 	  return false;
3227 	}
3228 
3229       this->dynobj_list_.push_back(dynobj);
3230     }
3231 
3232   // Add this object to the cross-referencer if requested.
3233   if (parameters->options().user_set_print_symbol_counts()
3234       || parameters->options().cref())
3235     {
3236       if (this->cref_ == NULL)
3237 	this->cref_ = new Cref();
3238       this->cref_->add_object(obj);
3239     }
3240 
3241   return true;
3242 }
3243 
3244 // For each dynamic object, record whether we've seen all of its
3245 // explicit dependencies.
3246 
3247 void
check_dynamic_dependencies() const3248 Input_objects::check_dynamic_dependencies() const
3249 {
3250   bool issued_copy_dt_needed_error = false;
3251   for (Dynobj_list::const_iterator p = this->dynobj_list_.begin();
3252        p != this->dynobj_list_.end();
3253        ++p)
3254     {
3255       const Dynobj::Needed& needed((*p)->needed());
3256       bool found_all = true;
3257       Dynobj::Needed::const_iterator pneeded;
3258       for (pneeded = needed.begin(); pneeded != needed.end(); ++pneeded)
3259 	{
3260 	  if (this->sonames_.find(*pneeded) == this->sonames_.end())
3261 	    {
3262 	      found_all = false;
3263 	      break;
3264 	    }
3265 	}
3266       (*p)->set_has_unknown_needed_entries(!found_all);
3267 
3268       // --copy-dt-needed-entries aka --add-needed is a GNU ld option
3269       // that gold does not support.  However, they cause no trouble
3270       // unless there is a DT_NEEDED entry that we don't know about;
3271       // warn only in that case.
3272       if (!found_all
3273 	  && !issued_copy_dt_needed_error
3274 	  && (parameters->options().copy_dt_needed_entries()
3275 	      || parameters->options().add_needed()))
3276 	{
3277 	  const char* optname;
3278 	  if (parameters->options().copy_dt_needed_entries())
3279 	    optname = "--copy-dt-needed-entries";
3280 	  else
3281 	    optname = "--add-needed";
3282 	  gold_error(_("%s is not supported but is required for %s in %s"),
3283 		     optname, (*pneeded).c_str(), (*p)->name().c_str());
3284 	  issued_copy_dt_needed_error = true;
3285 	}
3286     }
3287 }
3288 
3289 // Start processing an archive.
3290 
3291 void
archive_start(Archive * archive)3292 Input_objects::archive_start(Archive* archive)
3293 {
3294   if (parameters->options().user_set_print_symbol_counts()
3295       || parameters->options().cref())
3296     {
3297       if (this->cref_ == NULL)
3298 	this->cref_ = new Cref();
3299       this->cref_->add_archive_start(archive);
3300     }
3301 }
3302 
3303 // Stop processing an archive.
3304 
3305 void
archive_stop(Archive * archive)3306 Input_objects::archive_stop(Archive* archive)
3307 {
3308   if (parameters->options().user_set_print_symbol_counts()
3309       || parameters->options().cref())
3310     this->cref_->add_archive_stop(archive);
3311 }
3312 
3313 // Print symbol counts
3314 
3315 void
print_symbol_counts(const Symbol_table * symtab) const3316 Input_objects::print_symbol_counts(const Symbol_table* symtab) const
3317 {
3318   if (parameters->options().user_set_print_symbol_counts()
3319       && this->cref_ != NULL)
3320     this->cref_->print_symbol_counts(symtab);
3321 }
3322 
3323 // Print a cross reference table.
3324 
3325 void
print_cref(const Symbol_table * symtab,FILE * f) const3326 Input_objects::print_cref(const Symbol_table* symtab, FILE* f) const
3327 {
3328   if (parameters->options().cref() && this->cref_ != NULL)
3329     this->cref_->print_cref(symtab, f);
3330 }
3331 
3332 // Relocate_info methods.
3333 
3334 // Return a string describing the location of a relocation when file
3335 // and lineno information is not available.  This is only used in
3336 // error messages.
3337 
3338 template<int size, bool big_endian>
3339 std::string
location(size_t,off_t offset) const3340 Relocate_info<size, big_endian>::location(size_t, off_t offset) const
3341 {
3342   Sized_dwarf_line_info<size, big_endian> line_info(this->object);
3343   std::string ret = line_info.addr2line(this->data_shndx, offset, NULL);
3344   if (!ret.empty())
3345     return ret;
3346 
3347   ret = this->object->name();
3348 
3349   Symbol_location_info info;
3350   if (this->object->get_symbol_location_info(this->data_shndx, offset, &info))
3351     {
3352       if (!info.source_file.empty())
3353 	{
3354 	  ret += ":";
3355 	  ret += info.source_file;
3356 	}
3357       ret += ":";
3358       if (info.enclosing_symbol_type == elfcpp::STT_FUNC)
3359 	ret += _("function ");
3360       ret += info.enclosing_symbol_name;
3361       return ret;
3362     }
3363 
3364   ret += "(";
3365   ret += this->object->section_name(this->data_shndx);
3366   char buf[100];
3367   snprintf(buf, sizeof buf, "+0x%lx)", static_cast<long>(offset));
3368   ret += buf;
3369   return ret;
3370 }
3371 
3372 } // End namespace gold.
3373 
3374 namespace
3375 {
3376 
3377 using namespace gold;
3378 
3379 // Read an ELF file with the header and return the appropriate
3380 // instance of Object.
3381 
3382 template<int size, bool big_endian>
3383 Object*
make_elf_sized_object(const std::string & name,Input_file * input_file,off_t offset,const elfcpp::Ehdr<size,big_endian> & ehdr,bool * punconfigured)3384 make_elf_sized_object(const std::string& name, Input_file* input_file,
3385 		      off_t offset, const elfcpp::Ehdr<size, big_endian>& ehdr,
3386 		      bool* punconfigured)
3387 {
3388   Target* target = select_target(input_file, offset,
3389 				 ehdr.get_e_machine(), size, big_endian,
3390 				 ehdr.get_ei_osabi(),
3391 				 ehdr.get_ei_abiversion());
3392   if (target == NULL)
3393     gold_fatal(_("%s: unsupported ELF machine number %d"),
3394 	       name.c_str(), ehdr.get_e_machine());
3395 
3396   if (!parameters->target_valid())
3397     set_parameters_target(target);
3398   else if (target != &parameters->target())
3399     {
3400       if (punconfigured != NULL)
3401 	*punconfigured = true;
3402       else
3403 	gold_error(_("%s: incompatible target"), name.c_str());
3404       return NULL;
3405     }
3406 
3407   return target->make_elf_object<size, big_endian>(name, input_file, offset,
3408 						   ehdr);
3409 }
3410 
3411 } // End anonymous namespace.
3412 
3413 namespace gold
3414 {
3415 
3416 // Return whether INPUT_FILE is an ELF object.
3417 
3418 bool
is_elf_object(Input_file * input_file,off_t offset,const unsigned char ** start,int * read_size)3419 is_elf_object(Input_file* input_file, off_t offset,
3420 	      const unsigned char** start, int* read_size)
3421 {
3422   off_t filesize = input_file->file().filesize();
3423   int want = elfcpp::Elf_recognizer::max_header_size;
3424   if (filesize - offset < want)
3425     want = filesize - offset;
3426 
3427   const unsigned char* p = input_file->file().get_view(offset, 0, want,
3428 						       true, false);
3429   *start = p;
3430   *read_size = want;
3431 
3432   return elfcpp::Elf_recognizer::is_elf_file(p, want);
3433 }
3434 
3435 // Read an ELF file and return the appropriate instance of Object.
3436 
3437 Object*
make_elf_object(const std::string & name,Input_file * input_file,off_t offset,const unsigned char * p,section_offset_type bytes,bool * punconfigured)3438 make_elf_object(const std::string& name, Input_file* input_file, off_t offset,
3439 		const unsigned char* p, section_offset_type bytes,
3440 		bool* punconfigured)
3441 {
3442   if (punconfigured != NULL)
3443     *punconfigured = false;
3444 
3445   std::string error;
3446   bool big_endian = false;
3447   int size = 0;
3448   if (!elfcpp::Elf_recognizer::is_valid_header(p, bytes, &size,
3449 					       &big_endian, &error))
3450     {
3451       gold_error(_("%s: %s"), name.c_str(), error.c_str());
3452       return NULL;
3453     }
3454 
3455   if (size == 32)
3456     {
3457       if (big_endian)
3458 	{
3459 #ifdef HAVE_TARGET_32_BIG
3460 	  elfcpp::Ehdr<32, true> ehdr(p);
3461 	  return make_elf_sized_object<32, true>(name, input_file,
3462 						 offset, ehdr, punconfigured);
3463 #else
3464 	  if (punconfigured != NULL)
3465 	    *punconfigured = true;
3466 	  else
3467 	    gold_error(_("%s: not configured to support "
3468 			 "32-bit big-endian object"),
3469 		       name.c_str());
3470 	  return NULL;
3471 #endif
3472 	}
3473       else
3474 	{
3475 #ifdef HAVE_TARGET_32_LITTLE
3476 	  elfcpp::Ehdr<32, false> ehdr(p);
3477 	  return make_elf_sized_object<32, false>(name, input_file,
3478 						  offset, ehdr, punconfigured);
3479 #else
3480 	  if (punconfigured != NULL)
3481 	    *punconfigured = true;
3482 	  else
3483 	    gold_error(_("%s: not configured to support "
3484 			 "32-bit little-endian object"),
3485 		       name.c_str());
3486 	  return NULL;
3487 #endif
3488 	}
3489     }
3490   else if (size == 64)
3491     {
3492       if (big_endian)
3493 	{
3494 #ifdef HAVE_TARGET_64_BIG
3495 	  elfcpp::Ehdr<64, true> ehdr(p);
3496 	  return make_elf_sized_object<64, true>(name, input_file,
3497 						 offset, ehdr, punconfigured);
3498 #else
3499 	  if (punconfigured != NULL)
3500 	    *punconfigured = true;
3501 	  else
3502 	    gold_error(_("%s: not configured to support "
3503 			 "64-bit big-endian object"),
3504 		       name.c_str());
3505 	  return NULL;
3506 #endif
3507 	}
3508       else
3509 	{
3510 #ifdef HAVE_TARGET_64_LITTLE
3511 	  elfcpp::Ehdr<64, false> ehdr(p);
3512 	  return make_elf_sized_object<64, false>(name, input_file,
3513 						  offset, ehdr, punconfigured);
3514 #else
3515 	  if (punconfigured != NULL)
3516 	    *punconfigured = true;
3517 	  else
3518 	    gold_error(_("%s: not configured to support "
3519 			 "64-bit little-endian object"),
3520 		       name.c_str());
3521 	  return NULL;
3522 #endif
3523 	}
3524     }
3525   else
3526     gold_unreachable();
3527 }
3528 
3529 // Instantiate the templates we need.
3530 
3531 #if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG)
3532 template
3533 void
3534 Relobj::initialize_input_to_output_map<64>(unsigned int shndx,
3535       elfcpp::Elf_types<64>::Elf_Addr starting_address,
3536       Unordered_map<section_offset_type,
3537       elfcpp::Elf_types<64>::Elf_Addr>* output_addresses) const;
3538 #endif
3539 
3540 #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG)
3541 template
3542 void
3543 Relobj::initialize_input_to_output_map<32>(unsigned int shndx,
3544       elfcpp::Elf_types<32>::Elf_Addr starting_address,
3545       Unordered_map<section_offset_type,
3546       elfcpp::Elf_types<32>::Elf_Addr>* output_addresses) const;
3547 #endif
3548 
3549 #ifdef HAVE_TARGET_32_LITTLE
3550 template
3551 void
3552 Object::read_section_data<32, false>(elfcpp::Elf_file<32, false, Object>*,
3553 				     Read_symbols_data*);
3554 template
3555 const unsigned char*
3556 Object::find_shdr<32,false>(const unsigned char*, const char*, const char*,
3557 			    section_size_type, const unsigned char*) const;
3558 #endif
3559 
3560 #ifdef HAVE_TARGET_32_BIG
3561 template
3562 void
3563 Object::read_section_data<32, true>(elfcpp::Elf_file<32, true, Object>*,
3564 				    Read_symbols_data*);
3565 template
3566 const unsigned char*
3567 Object::find_shdr<32,true>(const unsigned char*, const char*, const char*,
3568 			   section_size_type, const unsigned char*) const;
3569 #endif
3570 
3571 #ifdef HAVE_TARGET_64_LITTLE
3572 template
3573 void
3574 Object::read_section_data<64, false>(elfcpp::Elf_file<64, false, Object>*,
3575 				     Read_symbols_data*);
3576 template
3577 const unsigned char*
3578 Object::find_shdr<64,false>(const unsigned char*, const char*, const char*,
3579 			    section_size_type, const unsigned char*) const;
3580 #endif
3581 
3582 #ifdef HAVE_TARGET_64_BIG
3583 template
3584 void
3585 Object::read_section_data<64, true>(elfcpp::Elf_file<64, true, Object>*,
3586 				    Read_symbols_data*);
3587 template
3588 const unsigned char*
3589 Object::find_shdr<64,true>(const unsigned char*, const char*, const char*,
3590 			   section_size_type, const unsigned char*) const;
3591 #endif
3592 
3593 #ifdef HAVE_TARGET_32_LITTLE
3594 template
3595 class Sized_relobj<32, false>;
3596 
3597 template
3598 class Sized_relobj_file<32, false>;
3599 #endif
3600 
3601 #ifdef HAVE_TARGET_32_BIG
3602 template
3603 class Sized_relobj<32, true>;
3604 
3605 template
3606 class Sized_relobj_file<32, true>;
3607 #endif
3608 
3609 #ifdef HAVE_TARGET_64_LITTLE
3610 template
3611 class Sized_relobj<64, false>;
3612 
3613 template
3614 class Sized_relobj_file<64, false>;
3615 #endif
3616 
3617 #ifdef HAVE_TARGET_64_BIG
3618 template
3619 class Sized_relobj<64, true>;
3620 
3621 template
3622 class Sized_relobj_file<64, true>;
3623 #endif
3624 
3625 #ifdef HAVE_TARGET_32_LITTLE
3626 template
3627 struct Relocate_info<32, false>;
3628 #endif
3629 
3630 #ifdef HAVE_TARGET_32_BIG
3631 template
3632 struct Relocate_info<32, true>;
3633 #endif
3634 
3635 #ifdef HAVE_TARGET_64_LITTLE
3636 template
3637 struct Relocate_info<64, false>;
3638 #endif
3639 
3640 #ifdef HAVE_TARGET_64_BIG
3641 template
3642 struct Relocate_info<64, true>;
3643 #endif
3644 
3645 #ifdef HAVE_TARGET_32_LITTLE
3646 template
3647 void
3648 Xindex::initialize_symtab_xindex<32, false>(Object*, unsigned int);
3649 
3650 template
3651 void
3652 Xindex::read_symtab_xindex<32, false>(Object*, unsigned int,
3653 				      const unsigned char*);
3654 #endif
3655 
3656 #ifdef HAVE_TARGET_32_BIG
3657 template
3658 void
3659 Xindex::initialize_symtab_xindex<32, true>(Object*, unsigned int);
3660 
3661 template
3662 void
3663 Xindex::read_symtab_xindex<32, true>(Object*, unsigned int,
3664 				     const unsigned char*);
3665 #endif
3666 
3667 #ifdef HAVE_TARGET_64_LITTLE
3668 template
3669 void
3670 Xindex::initialize_symtab_xindex<64, false>(Object*, unsigned int);
3671 
3672 template
3673 void
3674 Xindex::read_symtab_xindex<64, false>(Object*, unsigned int,
3675 				      const unsigned char*);
3676 #endif
3677 
3678 #ifdef HAVE_TARGET_64_BIG
3679 template
3680 void
3681 Xindex::initialize_symtab_xindex<64, true>(Object*, unsigned int);
3682 
3683 template
3684 void
3685 Xindex::read_symtab_xindex<64, true>(Object*, unsigned int,
3686 				     const unsigned char*);
3687 #endif
3688 
3689 #ifdef HAVE_TARGET_32_LITTLE
3690 template
3691 Compressed_section_map*
3692 build_compressed_section_map<32, false>(const unsigned char*, unsigned int,
3693 					const char*, section_size_type,
3694 					Object*, bool);
3695 #endif
3696 
3697 #ifdef HAVE_TARGET_32_BIG
3698 template
3699 Compressed_section_map*
3700 build_compressed_section_map<32, true>(const unsigned char*, unsigned int,
3701 					const char*, section_size_type,
3702 					Object*, bool);
3703 #endif
3704 
3705 #ifdef HAVE_TARGET_64_LITTLE
3706 template
3707 Compressed_section_map*
3708 build_compressed_section_map<64, false>(const unsigned char*, unsigned int,
3709 					const char*, section_size_type,
3710 					Object*, bool);
3711 #endif
3712 
3713 #ifdef HAVE_TARGET_64_BIG
3714 template
3715 Compressed_section_map*
3716 build_compressed_section_map<64, true>(const unsigned char*, unsigned int,
3717 					const char*, section_size_type,
3718 					Object*, bool);
3719 #endif
3720 
3721 } // End namespace gold.
3722