1 // object.cc -- support for an object file for linking in gold
3 // Copyright 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
4 // Written by Ian Lance Taylor <iant@google.com>.
6 // This file is part of gold.
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.
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.
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.
29 #include "libiberty.h"
32 #include "target-select.h"
33 #include "dwarf_reader.h"
48 // Initialize the symtab_xindex_ array. Find the SHT_SYMTAB_SHNDX
49 // section and read it in. SYMTAB_SHNDX is the index of the symbol
50 // table we care about.
52 template<int size, bool big_endian>
54 Xindex::initialize_symtab_xindex(Object* object, unsigned int symtab_shndx)
56 if (!this->symtab_xindex_.empty())
59 gold_assert(symtab_shndx != 0);
61 // Look through the sections in reverse order, on the theory that it
62 // is more likely to be near the end than the beginning.
63 unsigned int i = object->shnum();
67 if (object->section_type(i) == elfcpp::SHT_SYMTAB_SHNDX
68 && this->adjust_shndx(object->section_link(i)) == symtab_shndx)
70 this->read_symtab_xindex<size, big_endian>(object, i, NULL);
75 object->error(_("missing SHT_SYMTAB_SHNDX section"));
78 // Read in the symtab_xindex_ array, given the section index of the
79 // SHT_SYMTAB_SHNDX section. If PSHDRS is not NULL, it points at the
82 template<int size, bool big_endian>
84 Xindex::read_symtab_xindex(Object* object, unsigned int xindex_shndx,
85 const unsigned char* pshdrs)
87 section_size_type bytecount;
88 const unsigned char* contents;
90 contents = object->section_contents(xindex_shndx, &bytecount, false);
93 const unsigned char* p = (pshdrs
95 * elfcpp::Elf_sizes<size>::shdr_size));
96 typename elfcpp::Shdr<size, big_endian> shdr(p);
97 bytecount = convert_to_section_size_type(shdr.get_sh_size());
98 contents = object->get_view(shdr.get_sh_offset(), bytecount, true, false);
101 gold_assert(this->symtab_xindex_.empty());
102 this->symtab_xindex_.reserve(bytecount / 4);
103 for (section_size_type i = 0; i < bytecount; i += 4)
105 unsigned int shndx = elfcpp::Swap<32, big_endian>::readval(contents + i);
106 // We preadjust the section indexes we save.
107 this->symtab_xindex_.push_back(this->adjust_shndx(shndx));
111 // Symbol symndx has a section of SHN_XINDEX; return the real section
115 Xindex::sym_xindex_to_shndx(Object* object, unsigned int symndx)
117 if (symndx >= this->symtab_xindex_.size())
119 object->error(_("symbol %u out of range for SHT_SYMTAB_SHNDX section"),
121 return elfcpp::SHN_UNDEF;
123 unsigned int shndx = this->symtab_xindex_[symndx];
124 if (shndx < elfcpp::SHN_LORESERVE || shndx >= object->shnum())
126 object->error(_("extended index for symbol %u out of range: %u"),
128 return elfcpp::SHN_UNDEF;
135 // Report an error for this object file. This is used by the
136 // elfcpp::Elf_file interface, and also called by the Object code
140 Object::error(const char* format, ...) const
143 va_start(args, format);
145 if (vasprintf(&buf, format, args) < 0)
148 gold_error(_("%s: %s"), this->name().c_str(), buf);
152 // Return a view of the contents of a section.
155 Object::section_contents(unsigned int shndx, section_size_type* plen,
158 Location loc(this->do_section_contents(shndx));
159 *plen = convert_to_section_size_type(loc.data_size);
162 static const unsigned char empty[1] = { '\0' };
165 return this->get_view(loc.file_offset, *plen, true, cache);
168 // Read the section data into SD. This is code common to Sized_relobj
169 // and Sized_dynobj, so we put it into Object.
171 template<int size, bool big_endian>
173 Object::read_section_data(elfcpp::Elf_file<size, big_endian, Object>* elf_file,
174 Read_symbols_data* sd)
176 const int shdr_size = elfcpp::Elf_sizes<size>::shdr_size;
178 // Read the section headers.
179 const off_t shoff = elf_file->shoff();
180 const unsigned int shnum = this->shnum();
181 sd->section_headers = this->get_lasting_view(shoff, shnum * shdr_size,
184 // Read the section names.
185 const unsigned char* pshdrs = sd->section_headers->data();
186 const unsigned char* pshdrnames = pshdrs + elf_file->shstrndx() * shdr_size;
187 typename elfcpp::Shdr<size, big_endian> shdrnames(pshdrnames);
189 if (shdrnames.get_sh_type() != elfcpp::SHT_STRTAB)
190 this->error(_("section name section has wrong type: %u"),
191 static_cast<unsigned int>(shdrnames.get_sh_type()));
193 sd->section_names_size =
194 convert_to_section_size_type(shdrnames.get_sh_size());
195 sd->section_names = this->get_lasting_view(shdrnames.get_sh_offset(),
196 sd->section_names_size, false,
200 // If NAME is the name of a special .gnu.warning section, arrange for
201 // the warning to be issued. SHNDX is the section index. Return
202 // whether it is a warning section.
205 Object::handle_gnu_warning_section(const char* name, unsigned int shndx,
206 Symbol_table* symtab)
208 const char warn_prefix[] = ".gnu.warning.";
209 const int warn_prefix_len = sizeof warn_prefix - 1;
210 if (strncmp(name, warn_prefix, warn_prefix_len) == 0)
212 // Read the section contents to get the warning text. It would
213 // be nicer if we only did this if we have to actually issue a
214 // warning. Unfortunately, warnings are issued as we relocate
215 // sections. That means that we can not lock the object then,
216 // as we might try to issue the same warning multiple times
218 section_size_type len;
219 const unsigned char* contents = this->section_contents(shndx, &len,
223 const char* warning = name + warn_prefix_len;
224 contents = reinterpret_cast<const unsigned char*>(warning);
225 len = strlen(warning);
227 std::string warning(reinterpret_cast<const char*>(contents), len);
228 symtab->add_warning(name + warn_prefix_len, this, warning);
234 // If NAME is the name of the special section which indicates that
235 // this object was compiled with -fstack-split, mark it accordingly.
238 Object::handle_split_stack_section(const char* name)
240 if (strcmp(name, ".note.GNU-split-stack") == 0)
242 this->uses_split_stack_ = true;
245 if (strcmp(name, ".note.GNU-no-split-stack") == 0)
247 this->has_no_split_stack_ = true;
255 // To copy the symbols data read from the file to a local data structure.
256 // This function is called from do_layout only while doing garbage
260 Relobj::copy_symbols_data(Symbols_data* gc_sd, Read_symbols_data* sd,
261 unsigned int section_header_size)
263 gc_sd->section_headers_data =
264 new unsigned char[(section_header_size)];
265 memcpy(gc_sd->section_headers_data, sd->section_headers->data(),
266 section_header_size);
267 gc_sd->section_names_data =
268 new unsigned char[sd->section_names_size];
269 memcpy(gc_sd->section_names_data, sd->section_names->data(),
270 sd->section_names_size);
271 gc_sd->section_names_size = sd->section_names_size;
272 if (sd->symbols != NULL)
274 gc_sd->symbols_data =
275 new unsigned char[sd->symbols_size];
276 memcpy(gc_sd->symbols_data, sd->symbols->data(),
281 gc_sd->symbols_data = NULL;
283 gc_sd->symbols_size = sd->symbols_size;
284 gc_sd->external_symbols_offset = sd->external_symbols_offset;
285 if (sd->symbol_names != NULL)
287 gc_sd->symbol_names_data =
288 new unsigned char[sd->symbol_names_size];
289 memcpy(gc_sd->symbol_names_data, sd->symbol_names->data(),
290 sd->symbol_names_size);
294 gc_sd->symbol_names_data = NULL;
296 gc_sd->symbol_names_size = sd->symbol_names_size;
299 // This function determines if a particular section name must be included
300 // in the link. This is used during garbage collection to determine the
301 // roots of the worklist.
304 Relobj::is_section_name_included(const char* name)
306 if (is_prefix_of(".ctors", name)
307 || is_prefix_of(".dtors", name)
308 || is_prefix_of(".note", name)
309 || is_prefix_of(".init", name)
310 || is_prefix_of(".fini", name)
311 || is_prefix_of(".gcc_except_table", name)
312 || is_prefix_of(".jcr", name)
313 || is_prefix_of(".preinit_array", name)
314 || (is_prefix_of(".text", name)
315 && strstr(name, "personality"))
316 || (is_prefix_of(".data", name)
317 && strstr(name, "personality"))
318 || (is_prefix_of(".gnu.linkonce.d", name)
319 && strstr(name, "personality")))
326 // Class Sized_relobj.
328 template<int size, bool big_endian>
329 Sized_relobj<size, big_endian>::Sized_relobj(
330 const std::string& name,
331 Input_file* input_file,
333 const elfcpp::Ehdr<size, big_endian>& ehdr)
334 : Relobj(name, input_file, offset),
335 elf_file_(this, ehdr),
337 local_symbol_count_(0),
338 output_local_symbol_count_(0),
339 output_local_dynsym_count_(0),
342 local_symbol_offset_(0),
343 local_dynsym_offset_(0),
345 local_got_offsets_(),
346 kept_comdat_sections_(),
347 has_eh_frame_(false),
348 discarded_eh_frame_shndx_(-1U)
352 template<int size, bool big_endian>
353 Sized_relobj<size, big_endian>::~Sized_relobj()
357 // Set up an object file based on the file header. This sets up the
358 // section information.
360 template<int size, bool big_endian>
362 Sized_relobj<size, big_endian>::do_setup()
364 const unsigned int shnum = this->elf_file_.shnum();
365 this->set_shnum(shnum);
368 // Find the SHT_SYMTAB section, given the section headers. The ELF
369 // standard says that maybe in the future there can be more than one
370 // SHT_SYMTAB section. Until somebody figures out how that could
371 // work, we assume there is only one.
373 template<int size, bool big_endian>
375 Sized_relobj<size, big_endian>::find_symtab(const unsigned char* pshdrs)
377 const unsigned int shnum = this->shnum();
378 this->symtab_shndx_ = 0;
381 // Look through the sections in reverse order, since gas tends
382 // to put the symbol table at the end.
383 const unsigned char* p = pshdrs + shnum * This::shdr_size;
384 unsigned int i = shnum;
385 unsigned int xindex_shndx = 0;
386 unsigned int xindex_link = 0;
390 p -= This::shdr_size;
391 typename This::Shdr shdr(p);
392 if (shdr.get_sh_type() == elfcpp::SHT_SYMTAB)
394 this->symtab_shndx_ = i;
395 if (xindex_shndx > 0 && xindex_link == i)
398 new Xindex(this->elf_file_.large_shndx_offset());
399 xindex->read_symtab_xindex<size, big_endian>(this,
402 this->set_xindex(xindex);
407 // Try to pick up the SHT_SYMTAB_SHNDX section, if there is
408 // one. This will work if it follows the SHT_SYMTAB
410 if (shdr.get_sh_type() == elfcpp::SHT_SYMTAB_SHNDX)
413 xindex_link = this->adjust_shndx(shdr.get_sh_link());
419 // Return the Xindex structure to use for object with lots of
422 template<int size, bool big_endian>
424 Sized_relobj<size, big_endian>::do_initialize_xindex()
426 gold_assert(this->symtab_shndx_ != -1U);
427 Xindex* xindex = new Xindex(this->elf_file_.large_shndx_offset());
428 xindex->initialize_symtab_xindex<size, big_endian>(this, this->symtab_shndx_);
432 // Return whether SHDR has the right type and flags to be a GNU
433 // .eh_frame section.
435 template<int size, bool big_endian>
437 Sized_relobj<size, big_endian>::check_eh_frame_flags(
438 const elfcpp::Shdr<size, big_endian>* shdr) const
440 return (shdr->get_sh_type() == elfcpp::SHT_PROGBITS
441 && (shdr->get_sh_flags() & elfcpp::SHF_ALLOC) != 0);
444 // Return whether there is a GNU .eh_frame section, given the section
445 // headers and the section names.
447 template<int size, bool big_endian>
449 Sized_relobj<size, big_endian>::find_eh_frame(
450 const unsigned char* pshdrs,
452 section_size_type names_size) const
454 const unsigned int shnum = this->shnum();
455 const unsigned char* p = pshdrs + This::shdr_size;
456 for (unsigned int i = 1; i < shnum; ++i, p += This::shdr_size)
458 typename This::Shdr shdr(p);
459 if (this->check_eh_frame_flags(&shdr))
461 if (shdr.get_sh_name() >= names_size)
463 this->error(_("bad section name offset for section %u: %lu"),
464 i, static_cast<unsigned long>(shdr.get_sh_name()));
468 const char* name = names + shdr.get_sh_name();
469 if (strcmp(name, ".eh_frame") == 0)
476 // Read the sections and symbols from an object file.
478 template<int size, bool big_endian>
480 Sized_relobj<size, big_endian>::do_read_symbols(Read_symbols_data* sd)
482 this->read_section_data(&this->elf_file_, sd);
484 const unsigned char* const pshdrs = sd->section_headers->data();
486 this->find_symtab(pshdrs);
488 const unsigned char* namesu = sd->section_names->data();
489 const char* names = reinterpret_cast<const char*>(namesu);
490 if (memmem(names, sd->section_names_size, ".eh_frame", 10) != NULL)
492 if (this->find_eh_frame(pshdrs, names, sd->section_names_size))
493 this->has_eh_frame_ = true;
497 sd->symbols_size = 0;
498 sd->external_symbols_offset = 0;
499 sd->symbol_names = NULL;
500 sd->symbol_names_size = 0;
502 if (this->symtab_shndx_ == 0)
504 // No symbol table. Weird but legal.
508 // Get the symbol table section header.
509 typename This::Shdr symtabshdr(pshdrs
510 + this->symtab_shndx_ * This::shdr_size);
511 gold_assert(symtabshdr.get_sh_type() == elfcpp::SHT_SYMTAB);
513 // If this object has a .eh_frame section, we need all the symbols.
514 // Otherwise we only need the external symbols. While it would be
515 // simpler to just always read all the symbols, I've seen object
516 // files with well over 2000 local symbols, which for a 64-bit
517 // object file format is over 5 pages that we don't need to read
520 const int sym_size = This::sym_size;
521 const unsigned int loccount = symtabshdr.get_sh_info();
522 this->local_symbol_count_ = loccount;
523 this->local_values_.resize(loccount);
524 section_offset_type locsize = loccount * sym_size;
525 off_t dataoff = symtabshdr.get_sh_offset();
526 section_size_type datasize =
527 convert_to_section_size_type(symtabshdr.get_sh_size());
528 off_t extoff = dataoff + locsize;
529 section_size_type extsize = datasize - locsize;
531 off_t readoff = this->has_eh_frame_ ? dataoff : extoff;
532 section_size_type readsize = this->has_eh_frame_ ? datasize : extsize;
536 // No external symbols. Also weird but also legal.
540 File_view* fvsymtab = this->get_lasting_view(readoff, readsize, true, false);
542 // Read the section header for the symbol names.
543 unsigned int strtab_shndx = this->adjust_shndx(symtabshdr.get_sh_link());
544 if (strtab_shndx >= this->shnum())
546 this->error(_("invalid symbol table name index: %u"), strtab_shndx);
549 typename This::Shdr strtabshdr(pshdrs + strtab_shndx * This::shdr_size);
550 if (strtabshdr.get_sh_type() != elfcpp::SHT_STRTAB)
552 this->error(_("symbol table name section has wrong type: %u"),
553 static_cast<unsigned int>(strtabshdr.get_sh_type()));
557 // Read the symbol names.
558 File_view* fvstrtab = this->get_lasting_view(strtabshdr.get_sh_offset(),
559 strtabshdr.get_sh_size(),
562 sd->symbols = fvsymtab;
563 sd->symbols_size = readsize;
564 sd->external_symbols_offset = this->has_eh_frame_ ? locsize : 0;
565 sd->symbol_names = fvstrtab;
566 sd->symbol_names_size =
567 convert_to_section_size_type(strtabshdr.get_sh_size());
570 // Return the section index of symbol SYM. Set *VALUE to its value in
571 // the object file. Set *IS_ORDINARY if this is an ordinary section
572 // index. not a special cod between SHN_LORESERVE and SHN_HIRESERVE.
573 // Note that for a symbol which is not defined in this object file,
574 // this will set *VALUE to 0 and return SHN_UNDEF; it will not return
575 // the final value of the symbol in the link.
577 template<int size, bool big_endian>
579 Sized_relobj<size, big_endian>::symbol_section_and_value(unsigned int sym,
583 section_size_type symbols_size;
584 const unsigned char* symbols = this->section_contents(this->symtab_shndx_,
588 const size_t count = symbols_size / This::sym_size;
589 gold_assert(sym < count);
591 elfcpp::Sym<size, big_endian> elfsym(symbols + sym * This::sym_size);
592 *value = elfsym.get_st_value();
594 return this->adjust_sym_shndx(sym, elfsym.get_st_shndx(), is_ordinary);
597 // Return whether to include a section group in the link. LAYOUT is
598 // used to keep track of which section groups we have already seen.
599 // INDEX is the index of the section group and SHDR is the section
600 // header. If we do not want to include this group, we set bits in
601 // OMIT for each section which should be discarded.
603 template<int size, bool big_endian>
605 Sized_relobj<size, big_endian>::include_section_group(
606 Symbol_table* symtab,
610 const unsigned char* shdrs,
611 const char* section_names,
612 section_size_type section_names_size,
613 std::vector<bool>* omit)
615 // Read the section contents.
616 typename This::Shdr shdr(shdrs + index * This::shdr_size);
617 const unsigned char* pcon = this->get_view(shdr.get_sh_offset(),
618 shdr.get_sh_size(), true, false);
619 const elfcpp::Elf_Word* pword =
620 reinterpret_cast<const elfcpp::Elf_Word*>(pcon);
622 // The first word contains flags. We only care about COMDAT section
623 // groups. Other section groups are always included in the link
624 // just like ordinary sections.
625 elfcpp::Elf_Word flags = elfcpp::Swap<32, big_endian>::readval(pword);
627 // Look up the group signature, which is the name of a symbol. This
628 // is a lot of effort to go to to read a string. Why didn't they
629 // just have the group signature point into the string table, rather
630 // than indirect through a symbol?
632 // Get the appropriate symbol table header (this will normally be
633 // the single SHT_SYMTAB section, but in principle it need not be).
634 const unsigned int link = this->adjust_shndx(shdr.get_sh_link());
635 typename This::Shdr symshdr(this, this->elf_file_.section_header(link));
637 // Read the symbol table entry.
638 unsigned int symndx = shdr.get_sh_info();
639 if (symndx >= symshdr.get_sh_size() / This::sym_size)
641 this->error(_("section group %u info %u out of range"),
645 off_t symoff = symshdr.get_sh_offset() + symndx * This::sym_size;
646 const unsigned char* psym = this->get_view(symoff, This::sym_size, true,
648 elfcpp::Sym<size, big_endian> sym(psym);
650 // Read the symbol table names.
651 section_size_type symnamelen;
652 const unsigned char* psymnamesu;
653 psymnamesu = this->section_contents(this->adjust_shndx(symshdr.get_sh_link()),
655 const char* psymnames = reinterpret_cast<const char*>(psymnamesu);
657 // Get the section group signature.
658 if (sym.get_st_name() >= symnamelen)
660 this->error(_("symbol %u name offset %u out of range"),
661 symndx, sym.get_st_name());
665 std::string signature(psymnames + sym.get_st_name());
667 // It seems that some versions of gas will create a section group
668 // associated with a section symbol, and then fail to give a name to
669 // the section symbol. In such a case, use the name of the section.
670 if (signature[0] == '\0' && sym.get_st_type() == elfcpp::STT_SECTION)
673 unsigned int sym_shndx = this->adjust_sym_shndx(symndx,
676 if (!is_ordinary || sym_shndx >= this->shnum())
678 this->error(_("symbol %u invalid section index %u"),
682 typename This::Shdr member_shdr(shdrs + sym_shndx * This::shdr_size);
683 if (member_shdr.get_sh_name() < section_names_size)
684 signature = section_names + member_shdr.get_sh_name();
687 // Record this section group in the layout, and see whether we've already
688 // seen one with the same signature.
691 Kept_section* kept_section = NULL;
693 if ((flags & elfcpp::GRP_COMDAT) == 0)
695 include_group = true;
700 include_group = layout->find_or_add_kept_section(signature,
702 true, &kept_section);
706 size_t count = shdr.get_sh_size() / sizeof(elfcpp::Elf_Word);
708 std::vector<unsigned int> shndxes;
709 bool relocate_group = include_group && parameters->options().relocatable();
711 shndxes.reserve(count - 1);
713 for (size_t i = 1; i < count; ++i)
715 elfcpp::Elf_Word shndx =
716 this->adjust_shndx(elfcpp::Swap<32, big_endian>::readval(pword + i));
719 shndxes.push_back(shndx);
721 if (shndx >= this->shnum())
723 this->error(_("section %u in section group %u out of range"),
728 // Check for an earlier section number, since we're going to get
729 // it wrong--we may have already decided to include the section.
731 this->error(_("invalid section group %u refers to earlier section %u"),
734 // Get the name of the member section.
735 typename This::Shdr member_shdr(shdrs + shndx * This::shdr_size);
736 if (member_shdr.get_sh_name() >= section_names_size)
738 // This is an error, but it will be diagnosed eventually
739 // in do_layout, so we don't need to do anything here but
743 std::string mname(section_names + member_shdr.get_sh_name());
748 kept_section->add_comdat_section(mname, shndx,
749 member_shdr.get_sh_size());
753 (*omit)[shndx] = true;
757 Relobj* kept_object = kept_section->object();
758 if (kept_section->is_comdat())
760 // Find the corresponding kept section, and store
761 // that info in the discarded section table.
762 unsigned int kept_shndx;
764 if (kept_section->find_comdat_section(mname, &kept_shndx,
767 // We don't keep a mapping for this section if
768 // it has a different size. The mapping is only
769 // used for relocation processing, and we don't
770 // want to treat the sections as similar if the
771 // sizes are different. Checking the section
772 // size is the approach used by the GNU linker.
773 if (kept_size == member_shdr.get_sh_size())
774 this->set_kept_comdat_section(shndx, kept_object,
780 // The existing section is a linkonce section. Add
781 // a mapping if there is exactly one section in the
782 // group (which is true when COUNT == 2) and if it
785 && (kept_section->linkonce_size()
786 == member_shdr.get_sh_size()))
787 this->set_kept_comdat_section(shndx, kept_object,
788 kept_section->shndx());
795 layout->layout_group(symtab, this, index, name, signature.c_str(),
796 shdr, flags, &shndxes);
798 return include_group;
801 // Whether to include a linkonce section in the link. NAME is the
802 // name of the section and SHDR is the section header.
804 // Linkonce sections are a GNU extension implemented in the original
805 // GNU linker before section groups were defined. The semantics are
806 // that we only include one linkonce section with a given name. The
807 // name of a linkonce section is normally .gnu.linkonce.T.SYMNAME,
808 // where T is the type of section and SYMNAME is the name of a symbol.
809 // In an attempt to make linkonce sections interact well with section
810 // groups, we try to identify SYMNAME and use it like a section group
811 // signature. We want to block section groups with that signature,
812 // but not other linkonce sections with that signature. We also use
813 // the full name of the linkonce section as a normal section group
816 template<int size, bool big_endian>
818 Sized_relobj<size, big_endian>::include_linkonce_section(
822 const elfcpp::Shdr<size, big_endian>& shdr)
824 typename elfcpp::Elf_types<size>::Elf_WXword sh_size = shdr.get_sh_size();
825 // In general the symbol name we want will be the string following
826 // the last '.'. However, we have to handle the case of
827 // .gnu.linkonce.t.__i686.get_pc_thunk.bx, which was generated by
828 // some versions of gcc. So we use a heuristic: if the name starts
829 // with ".gnu.linkonce.t.", we use everything after that. Otherwise
830 // we look for the last '.'. We can't always simply skip
831 // ".gnu.linkonce.X", because we have to deal with cases like
832 // ".gnu.linkonce.d.rel.ro.local".
833 const char* const linkonce_t = ".gnu.linkonce.t.";
835 if (strncmp(name, linkonce_t, strlen(linkonce_t)) == 0)
836 symname = name + strlen(linkonce_t);
838 symname = strrchr(name, '.') + 1;
839 std::string sig1(symname);
840 std::string sig2(name);
843 bool include1 = layout->find_or_add_kept_section(sig1, this, index, false,
845 bool include2 = layout->find_or_add_kept_section(sig2, this, index, false,
850 // We are not including this section because we already saw the
851 // name of the section as a signature. This normally implies
852 // that the kept section is another linkonce section. If it is
853 // the same size, record it as the section which corresponds to
855 if (kept2->object() != NULL
856 && !kept2->is_comdat()
857 && kept2->linkonce_size() == sh_size)
858 this->set_kept_comdat_section(index, kept2->object(), kept2->shndx());
862 // The section is being discarded on the basis of its symbol
863 // name. This means that the corresponding kept section was
864 // part of a comdat group, and it will be difficult to identify
865 // the specific section within that group that corresponds to
866 // this linkonce section. We'll handle the simple case where
867 // the group has only one member section. Otherwise, it's not
869 unsigned int kept_shndx;
871 if (kept1->object() != NULL
872 && kept1->is_comdat()
873 && kept1->find_single_comdat_section(&kept_shndx, &kept_size)
874 && kept_size == sh_size)
875 this->set_kept_comdat_section(index, kept1->object(), kept_shndx);
879 kept1->set_linkonce_size(sh_size);
880 kept2->set_linkonce_size(sh_size);
883 return include1 && include2;
886 // Layout an input section.
888 template<int size, bool big_endian>
890 Sized_relobj<size, big_endian>::layout_section(Layout* layout,
893 typename This::Shdr& shdr,
894 unsigned int reloc_shndx,
895 unsigned int reloc_type)
898 Output_section* os = layout->layout(this, shndx, name, shdr,
899 reloc_shndx, reloc_type, &offset);
901 this->output_sections()[shndx] = os;
903 this->section_offsets_[shndx] = invalid_address;
905 this->section_offsets_[shndx] = convert_types<Address, off_t>(offset);
907 // If this section requires special handling, and if there are
908 // relocs that apply to it, then we must do the special handling
909 // before we apply the relocs.
910 if (offset == -1 && reloc_shndx != 0)
911 this->set_relocs_must_follow_section_writes();
914 // Lay out the input sections. We walk through the sections and check
915 // whether they should be included in the link. If they should, we
916 // pass them to the Layout object, which will return an output section
918 // During garbage collection (--gc-sections) and identical code folding
919 // (--icf), this function is called twice. When it is called the first
920 // time, it is for setting up some sections as roots to a work-list for
921 // --gc-sections and to do comdat processing. Actual layout happens the
922 // second time around after all the relevant sections have been determined.
923 // The first time, is_worklist_ready or is_icf_ready is false. It is then
924 // set to true after the garbage collection worklist or identical code
925 // folding is processed and the relevant sections to be kept are
926 // determined. Then, this function is called again to layout the sections.
928 template<int size, bool big_endian>
930 Sized_relobj<size, big_endian>::do_layout(Symbol_table* symtab,
932 Read_symbols_data* sd)
934 const unsigned int shnum = this->shnum();
935 bool is_gc_pass_one = ((parameters->options().gc_sections()
936 && !symtab->gc()->is_worklist_ready())
937 || (parameters->options().icf_enabled()
938 && !symtab->icf()->is_icf_ready()));
940 bool is_gc_pass_two = ((parameters->options().gc_sections()
941 && symtab->gc()->is_worklist_ready())
942 || (parameters->options().icf_enabled()
943 && symtab->icf()->is_icf_ready()));
945 bool is_gc_or_icf = (parameters->options().gc_sections()
946 || parameters->options().icf_enabled());
948 // Both is_gc_pass_one and is_gc_pass_two should not be true.
949 gold_assert(!(is_gc_pass_one && is_gc_pass_two));
953 Symbols_data* gc_sd = NULL;
956 // During garbage collection save the symbols data to use it when
957 // re-entering this function.
958 gc_sd = new Symbols_data;
959 this->copy_symbols_data(gc_sd, sd, This::shdr_size * shnum);
960 this->set_symbols_data(gc_sd);
962 else if (is_gc_pass_two)
964 gc_sd = this->get_symbols_data();
967 const unsigned char* section_headers_data = NULL;
968 section_size_type section_names_size;
969 const unsigned char* symbols_data = NULL;
970 section_size_type symbols_size;
971 section_offset_type external_symbols_offset;
972 const unsigned char* symbol_names_data = NULL;
973 section_size_type symbol_names_size;
977 section_headers_data = gc_sd->section_headers_data;
978 section_names_size = gc_sd->section_names_size;
979 symbols_data = gc_sd->symbols_data;
980 symbols_size = gc_sd->symbols_size;
981 external_symbols_offset = gc_sd->external_symbols_offset;
982 symbol_names_data = gc_sd->symbol_names_data;
983 symbol_names_size = gc_sd->symbol_names_size;
987 section_headers_data = sd->section_headers->data();
988 section_names_size = sd->section_names_size;
989 if (sd->symbols != NULL)
990 symbols_data = sd->symbols->data();
991 symbols_size = sd->symbols_size;
992 external_symbols_offset = sd->external_symbols_offset;
993 if (sd->symbol_names != NULL)
994 symbol_names_data = sd->symbol_names->data();
995 symbol_names_size = sd->symbol_names_size;
998 // Get the section headers.
999 const unsigned char* shdrs = section_headers_data;
1000 const unsigned char* pshdrs;
1002 // Get the section names.
1003 const unsigned char* pnamesu = (is_gc_or_icf)
1004 ? gc_sd->section_names_data
1005 : sd->section_names->data();
1007 const char* pnames = reinterpret_cast<const char*>(pnamesu);
1009 // If any input files have been claimed by plugins, we need to defer
1010 // actual layout until the replacement files have arrived.
1011 const bool should_defer_layout =
1012 (parameters->options().has_plugins()
1013 && parameters->options().plugins()->should_defer_layout());
1014 unsigned int num_sections_to_defer = 0;
1016 // For each section, record the index of the reloc section if any.
1017 // Use 0 to mean that there is no reloc section, -1U to mean that
1018 // there is more than one.
1019 std::vector<unsigned int> reloc_shndx(shnum, 0);
1020 std::vector<unsigned int> reloc_type(shnum, elfcpp::SHT_NULL);
1021 // Skip the first, dummy, section.
1022 pshdrs = shdrs + This::shdr_size;
1023 for (unsigned int i = 1; i < shnum; ++i, pshdrs += This::shdr_size)
1025 typename This::Shdr shdr(pshdrs);
1027 // Count the number of sections whose layout will be deferred.
1028 if (should_defer_layout && (shdr.get_sh_flags() & elfcpp::SHF_ALLOC))
1029 ++num_sections_to_defer;
1031 unsigned int sh_type = shdr.get_sh_type();
1032 if (sh_type == elfcpp::SHT_REL || sh_type == elfcpp::SHT_RELA)
1034 unsigned int target_shndx = this->adjust_shndx(shdr.get_sh_info());
1035 if (target_shndx == 0 || target_shndx >= shnum)
1037 this->error(_("relocation section %u has bad info %u"),
1042 if (reloc_shndx[target_shndx] != 0)
1043 reloc_shndx[target_shndx] = -1U;
1046 reloc_shndx[target_shndx] = i;
1047 reloc_type[target_shndx] = sh_type;
1052 Output_sections& out_sections(this->output_sections());
1053 std::vector<Address>& out_section_offsets(this->section_offsets_);
1055 if (!is_gc_pass_two)
1057 out_sections.resize(shnum);
1058 out_section_offsets.resize(shnum);
1061 // If we are only linking for symbols, then there is nothing else to
1063 if (this->input_file()->just_symbols())
1065 if (!is_gc_pass_two)
1067 delete sd->section_headers;
1068 sd->section_headers = NULL;
1069 delete sd->section_names;
1070 sd->section_names = NULL;
1075 if (num_sections_to_defer > 0)
1077 parameters->options().plugins()->add_deferred_layout_object(this);
1078 this->deferred_layout_.reserve(num_sections_to_defer);
1081 // Whether we've seen a .note.GNU-stack section.
1082 bool seen_gnu_stack = false;
1083 // The flags of a .note.GNU-stack section.
1084 uint64_t gnu_stack_flags = 0;
1086 // Keep track of which sections to omit.
1087 std::vector<bool> omit(shnum, false);
1089 // Keep track of reloc sections when emitting relocations.
1090 const bool relocatable = parameters->options().relocatable();
1091 const bool emit_relocs = (relocatable
1092 || parameters->options().emit_relocs());
1093 std::vector<unsigned int> reloc_sections;
1095 // Keep track of .eh_frame sections.
1096 std::vector<unsigned int> eh_frame_sections;
1098 // Skip the first, dummy, section.
1099 pshdrs = shdrs + This::shdr_size;
1100 for (unsigned int i = 1; i < shnum; ++i, pshdrs += This::shdr_size)
1102 typename This::Shdr shdr(pshdrs);
1104 if (shdr.get_sh_name() >= section_names_size)
1106 this->error(_("bad section name offset for section %u: %lu"),
1107 i, static_cast<unsigned long>(shdr.get_sh_name()));
1111 const char* name = pnames + shdr.get_sh_name();
1113 if (!is_gc_pass_two)
1115 if (this->handle_gnu_warning_section(name, i, symtab))
1121 // The .note.GNU-stack section is special. It gives the
1122 // protection flags that this object file requires for the stack
1124 if (strcmp(name, ".note.GNU-stack") == 0)
1126 seen_gnu_stack = true;
1127 gnu_stack_flags |= shdr.get_sh_flags();
1131 // The .note.GNU-split-stack section is also special. It
1132 // indicates that the object was compiled with
1134 if (this->handle_split_stack_section(name))
1136 if (!parameters->options().relocatable()
1137 && !parameters->options().shared())
1141 // Skip attributes section.
1142 if (parameters->target().is_attributes_section(name))
1147 bool discard = omit[i];
1150 if (shdr.get_sh_type() == elfcpp::SHT_GROUP)
1152 if (!this->include_section_group(symtab, layout, i, name,
1158 else if ((shdr.get_sh_flags() & elfcpp::SHF_GROUP) == 0
1159 && Layout::is_linkonce(name))
1161 if (!this->include_linkonce_section(layout, i, name, shdr))
1168 // Do not include this section in the link.
1169 out_sections[i] = NULL;
1170 out_section_offsets[i] = invalid_address;
1175 if (is_gc_pass_one && parameters->options().gc_sections())
1177 if (is_section_name_included(name)
1178 || shdr.get_sh_type() == elfcpp::SHT_INIT_ARRAY
1179 || shdr.get_sh_type() == elfcpp::SHT_FINI_ARRAY)
1181 symtab->gc()->worklist().push(Section_id(this, i));
1185 // When doing a relocatable link we are going to copy input
1186 // reloc sections into the output. We only want to copy the
1187 // ones associated with sections which are not being discarded.
1188 // However, we don't know that yet for all sections. So save
1189 // reloc sections and process them later. Garbage collection is
1190 // not triggered when relocatable code is desired.
1192 && (shdr.get_sh_type() == elfcpp::SHT_REL
1193 || shdr.get_sh_type() == elfcpp::SHT_RELA))
1195 reloc_sections.push_back(i);
1199 if (relocatable && shdr.get_sh_type() == elfcpp::SHT_GROUP)
1202 // The .eh_frame section is special. It holds exception frame
1203 // information that we need to read in order to generate the
1204 // exception frame header. We process these after all the other
1205 // sections so that the exception frame reader can reliably
1206 // determine which sections are being discarded, and discard the
1207 // corresponding information.
1209 && strcmp(name, ".eh_frame") == 0
1210 && this->check_eh_frame_flags(&shdr))
1214 out_sections[i] = reinterpret_cast<Output_section*>(1);
1215 out_section_offsets[i] = invalid_address;
1218 eh_frame_sections.push_back(i);
1222 if (is_gc_pass_two && parameters->options().gc_sections())
1224 // This is executed during the second pass of garbage
1225 // collection. do_layout has been called before and some
1226 // sections have been already discarded. Simply ignore
1227 // such sections this time around.
1228 if (out_sections[i] == NULL)
1230 gold_assert(out_section_offsets[i] == invalid_address);
1233 if (((shdr.get_sh_flags() & elfcpp::SHF_ALLOC) != 0)
1234 && symtab->gc()->is_section_garbage(this, i))
1236 if (parameters->options().print_gc_sections())
1237 gold_info(_("%s: removing unused section from '%s'"
1239 program_name, this->section_name(i).c_str(),
1240 this->name().c_str());
1241 out_sections[i] = NULL;
1242 out_section_offsets[i] = invalid_address;
1247 if (is_gc_pass_two && parameters->options().icf_enabled())
1249 if (out_sections[i] == NULL)
1251 gold_assert(out_section_offsets[i] == invalid_address);
1254 if (((shdr.get_sh_flags() & elfcpp::SHF_ALLOC) != 0)
1255 && symtab->icf()->is_section_folded(this, i))
1257 if (parameters->options().print_icf_sections())
1260 symtab->icf()->get_folded_section(this, i);
1261 Relobj* folded_obj =
1262 reinterpret_cast<Relobj*>(folded.first);
1263 gold_info(_("%s: ICF folding section '%s' in file '%s'"
1264 "into '%s' in file '%s'"),
1265 program_name, this->section_name(i).c_str(),
1266 this->name().c_str(),
1267 folded_obj->section_name(folded.second).c_str(),
1268 folded_obj->name().c_str());
1270 out_sections[i] = NULL;
1271 out_section_offsets[i] = invalid_address;
1276 // Defer layout here if input files are claimed by plugins. When gc
1277 // is turned on this function is called twice. For the second call
1278 // should_defer_layout should be false.
1279 if (should_defer_layout && (shdr.get_sh_flags() & elfcpp::SHF_ALLOC))
1281 gold_assert(!is_gc_pass_two);
1282 this->deferred_layout_.push_back(Deferred_layout(i, name,
1286 // Put dummy values here; real values will be supplied by
1287 // do_layout_deferred_sections.
1288 out_sections[i] = reinterpret_cast<Output_section*>(2);
1289 out_section_offsets[i] = invalid_address;
1293 // During gc_pass_two if a section that was previously deferred is
1294 // found, do not layout the section as layout_deferred_sections will
1295 // do it later from gold.cc.
1297 && (out_sections[i] == reinterpret_cast<Output_section*>(2)))
1302 // This is during garbage collection. The out_sections are
1303 // assigned in the second call to this function.
1304 out_sections[i] = reinterpret_cast<Output_section*>(1);
1305 out_section_offsets[i] = invalid_address;
1309 // When garbage collection is switched on the actual layout
1310 // only happens in the second call.
1311 this->layout_section(layout, i, name, shdr, reloc_shndx[i],
1316 if (!is_gc_pass_one)
1317 layout->layout_gnu_stack(seen_gnu_stack, gnu_stack_flags);
1319 // When doing a relocatable link handle the reloc sections at the
1320 // end. Garbage collection and Identical Code Folding is not
1321 // turned on for relocatable code.
1323 this->size_relocatable_relocs();
1325 gold_assert(!(is_gc_or_icf) || reloc_sections.empty());
1327 for (std::vector<unsigned int>::const_iterator p = reloc_sections.begin();
1328 p != reloc_sections.end();
1331 unsigned int i = *p;
1332 const unsigned char* pshdr;
1333 pshdr = section_headers_data + i * This::shdr_size;
1334 typename This::Shdr shdr(pshdr);
1336 unsigned int data_shndx = this->adjust_shndx(shdr.get_sh_info());
1337 if (data_shndx >= shnum)
1339 // We already warned about this above.
1343 Output_section* data_section = out_sections[data_shndx];
1344 if (data_section == NULL)
1346 out_sections[i] = NULL;
1347 out_section_offsets[i] = invalid_address;
1351 Relocatable_relocs* rr = new Relocatable_relocs();
1352 this->set_relocatable_relocs(i, rr);
1354 Output_section* os = layout->layout_reloc(this, i, shdr, data_section,
1356 out_sections[i] = os;
1357 out_section_offsets[i] = invalid_address;
1360 // Handle the .eh_frame sections at the end.
1361 gold_assert(!is_gc_pass_one || eh_frame_sections.empty());
1362 for (std::vector<unsigned int>::const_iterator p = eh_frame_sections.begin();
1363 p != eh_frame_sections.end();
1366 gold_assert(this->has_eh_frame_);
1367 gold_assert(external_symbols_offset != 0);
1369 unsigned int i = *p;
1370 const unsigned char *pshdr;
1371 pshdr = section_headers_data + i * This::shdr_size;
1372 typename This::Shdr shdr(pshdr);
1375 Output_section* os = layout->layout_eh_frame(this,
1384 out_sections[i] = os;
1387 // An object can contain at most one section holding exception
1388 // frame information.
1389 gold_assert(this->discarded_eh_frame_shndx_ == -1U);
1390 this->discarded_eh_frame_shndx_ = i;
1391 out_section_offsets[i] = invalid_address;
1394 out_section_offsets[i] = convert_types<Address, off_t>(offset);
1396 // If this section requires special handling, and if there are
1397 // relocs that apply to it, then we must do the special handling
1398 // before we apply the relocs.
1399 if (offset == -1 && reloc_shndx[i] != 0)
1400 this->set_relocs_must_follow_section_writes();
1405 delete[] gc_sd->section_headers_data;
1406 delete[] gc_sd->section_names_data;
1407 delete[] gc_sd->symbols_data;
1408 delete[] gc_sd->symbol_names_data;
1409 this->set_symbols_data(NULL);
1413 delete sd->section_headers;
1414 sd->section_headers = NULL;
1415 delete sd->section_names;
1416 sd->section_names = NULL;
1420 // Layout sections whose layout was deferred while waiting for
1421 // input files from a plugin.
1423 template<int size, bool big_endian>
1425 Sized_relobj<size, big_endian>::do_layout_deferred_sections(Layout* layout)
1427 typename std::vector<Deferred_layout>::iterator deferred;
1429 for (deferred = this->deferred_layout_.begin();
1430 deferred != this->deferred_layout_.end();
1433 typename This::Shdr shdr(deferred->shdr_data_);
1434 this->layout_section(layout, deferred->shndx_, deferred->name_.c_str(),
1435 shdr, deferred->reloc_shndx_, deferred->reloc_type_);
1438 this->deferred_layout_.clear();
1441 // Add the symbols to the symbol table.
1443 template<int size, bool big_endian>
1445 Sized_relobj<size, big_endian>::do_add_symbols(Symbol_table* symtab,
1446 Read_symbols_data* sd,
1449 if (sd->symbols == NULL)
1451 gold_assert(sd->symbol_names == NULL);
1455 const int sym_size = This::sym_size;
1456 size_t symcount = ((sd->symbols_size - sd->external_symbols_offset)
1458 if (symcount * sym_size != sd->symbols_size - sd->external_symbols_offset)
1460 this->error(_("size of symbols is not multiple of symbol size"));
1464 this->symbols_.resize(symcount);
1466 const char* sym_names =
1467 reinterpret_cast<const char*>(sd->symbol_names->data());
1468 symtab->add_from_relobj(this,
1469 sd->symbols->data() + sd->external_symbols_offset,
1470 symcount, this->local_symbol_count_,
1471 sym_names, sd->symbol_names_size,
1473 &this->defined_count_);
1477 delete sd->symbol_names;
1478 sd->symbol_names = NULL;
1481 // First pass over the local symbols. Here we add their names to
1482 // *POOL and *DYNPOOL, and we store the symbol value in
1483 // THIS->LOCAL_VALUES_. This function is always called from a
1484 // singleton thread. This is followed by a call to
1485 // finalize_local_symbols.
1487 template<int size, bool big_endian>
1489 Sized_relobj<size, big_endian>::do_count_local_symbols(Stringpool* pool,
1490 Stringpool* dynpool)
1492 gold_assert(this->symtab_shndx_ != -1U);
1493 if (this->symtab_shndx_ == 0)
1495 // This object has no symbols. Weird but legal.
1499 // Read the symbol table section header.
1500 const unsigned int symtab_shndx = this->symtab_shndx_;
1501 typename This::Shdr symtabshdr(this,
1502 this->elf_file_.section_header(symtab_shndx));
1503 gold_assert(symtabshdr.get_sh_type() == elfcpp::SHT_SYMTAB);
1505 // Read the local symbols.
1506 const int sym_size = This::sym_size;
1507 const unsigned int loccount = this->local_symbol_count_;
1508 gold_assert(loccount == symtabshdr.get_sh_info());
1509 off_t locsize = loccount * sym_size;
1510 const unsigned char* psyms = this->get_view(symtabshdr.get_sh_offset(),
1511 locsize, true, true);
1513 // Read the symbol names.
1514 const unsigned int strtab_shndx =
1515 this->adjust_shndx(symtabshdr.get_sh_link());
1516 section_size_type strtab_size;
1517 const unsigned char* pnamesu = this->section_contents(strtab_shndx,
1520 const char* pnames = reinterpret_cast<const char*>(pnamesu);
1522 // Loop over the local symbols.
1524 const Output_sections& out_sections(this->output_sections());
1525 unsigned int shnum = this->shnum();
1526 unsigned int count = 0;
1527 unsigned int dyncount = 0;
1528 // Skip the first, dummy, symbol.
1530 bool discard_all = parameters->options().discard_all();
1531 bool discard_locals = parameters->options().discard_locals();
1532 for (unsigned int i = 1; i < loccount; ++i, psyms += sym_size)
1534 elfcpp::Sym<size, big_endian> sym(psyms);
1536 Symbol_value<size>& lv(this->local_values_[i]);
1539 unsigned int shndx = this->adjust_sym_shndx(i, sym.get_st_shndx(),
1541 lv.set_input_shndx(shndx, is_ordinary);
1543 if (sym.get_st_type() == elfcpp::STT_SECTION)
1544 lv.set_is_section_symbol();
1545 else if (sym.get_st_type() == elfcpp::STT_TLS)
1546 lv.set_is_tls_symbol();
1548 // Save the input symbol value for use in do_finalize_local_symbols().
1549 lv.set_input_value(sym.get_st_value());
1551 // Decide whether this symbol should go into the output file.
1553 if ((shndx < shnum && out_sections[shndx] == NULL)
1554 || shndx == this->discarded_eh_frame_shndx_)
1556 lv.set_no_output_symtab_entry();
1557 gold_assert(!lv.needs_output_dynsym_entry());
1561 if (sym.get_st_type() == elfcpp::STT_SECTION)
1563 lv.set_no_output_symtab_entry();
1564 gold_assert(!lv.needs_output_dynsym_entry());
1568 if (sym.get_st_name() >= strtab_size)
1570 this->error(_("local symbol %u section name out of range: %u >= %u"),
1571 i, sym.get_st_name(),
1572 static_cast<unsigned int>(strtab_size));
1573 lv.set_no_output_symtab_entry();
1577 const char* name = pnames + sym.get_st_name();
1579 // If needed, add the symbol to the dynamic symbol table string pool.
1580 if (lv.needs_output_dynsym_entry())
1582 dynpool->add(name, true, NULL);
1588 lv.set_no_output_symtab_entry();
1592 // If --discard-locals option is used, discard all temporary local
1593 // symbols. These symbols start with system-specific local label
1594 // prefixes, typically .L for ELF system. We want to be compatible
1595 // with GNU ld so here we essentially use the same check in
1596 // bfd_is_local_label(). The code is different because we already
1599 // - the symbol is local and thus cannot have global or weak binding.
1600 // - the symbol is not a section symbol.
1601 // - the symbol has a name.
1603 // We do not discard a symbol if it needs a dynamic symbol entry.
1605 && sym.get_st_type() != elfcpp::STT_FILE
1606 && !lv.needs_output_dynsym_entry()
1607 && parameters->target().is_local_label_name(name))
1609 lv.set_no_output_symtab_entry();
1613 // Discard the local symbol if -retain_symbols_file is specified
1614 // and the local symbol is not in that file.
1615 if (!parameters->options().should_retain_symbol(name))
1617 lv.set_no_output_symtab_entry();
1621 // Add the symbol to the symbol table string pool.
1622 pool->add(name, true, NULL);
1626 this->output_local_symbol_count_ = count;
1627 this->output_local_dynsym_count_ = dyncount;
1630 // Finalize the local symbols. Here we set the final value in
1631 // THIS->LOCAL_VALUES_ and set their output symbol table indexes.
1632 // This function is always called from a singleton thread. The actual
1633 // output of the local symbols will occur in a separate task.
1635 template<int size, bool big_endian>
1637 Sized_relobj<size, big_endian>::do_finalize_local_symbols(unsigned int index,
1639 Symbol_table* symtab)
1641 gold_assert(off == static_cast<off_t>(align_address(off, size >> 3)));
1643 const unsigned int loccount = this->local_symbol_count_;
1644 this->local_symbol_offset_ = off;
1646 const bool relocatable = parameters->options().relocatable();
1647 const Output_sections& out_sections(this->output_sections());
1648 const std::vector<Address>& out_offsets(this->section_offsets_);
1649 unsigned int shnum = this->shnum();
1651 for (unsigned int i = 1; i < loccount; ++i)
1653 Symbol_value<size>& lv(this->local_values_[i]);
1656 unsigned int shndx = lv.input_shndx(&is_ordinary);
1658 // Set the output symbol value.
1662 if (shndx == elfcpp::SHN_ABS || Symbol::is_common_shndx(shndx))
1663 lv.set_output_value(lv.input_value());
1666 this->error(_("unknown section index %u for local symbol %u"),
1668 lv.set_output_value(0);
1675 this->error(_("local symbol %u section index %u out of range"),
1680 Output_section* os = out_sections[shndx];
1681 Address secoffset = out_offsets[shndx];
1682 if (symtab->is_section_folded(this, shndx))
1684 gold_assert (os == NULL && secoffset == invalid_address);
1685 // Get the os of the section it is folded onto.
1686 Section_id folded = symtab->icf()->get_folded_section(this,
1688 gold_assert(folded.first != NULL);
1689 Sized_relobj<size, big_endian>* folded_obj = reinterpret_cast
1690 <Sized_relobj<size, big_endian>*>(folded.first);
1691 os = folded_obj->output_section(folded.second);
1692 gold_assert(os != NULL);
1693 secoffset = folded_obj->get_output_section_offset(folded.second);
1695 // This could be a relaxed input section.
1696 if (secoffset == invalid_address)
1698 const Output_relaxed_input_section* relaxed_section =
1699 os->find_relaxed_input_section(folded_obj, folded.second);
1700 gold_assert(relaxed_section != NULL);
1701 secoffset = relaxed_section->address() - os->address();
1707 // This local symbol belongs to a section we are discarding.
1708 // In some cases when applying relocations later, we will
1709 // attempt to match it to the corresponding kept section,
1710 // so we leave the input value unchanged here.
1713 else if (secoffset == invalid_address)
1717 // This is a SHF_MERGE section or one which otherwise
1718 // requires special handling.
1719 if (shndx == this->discarded_eh_frame_shndx_)
1721 // This local symbol belongs to a discarded .eh_frame
1722 // section. Just treat it like the case in which
1723 // os == NULL above.
1724 gold_assert(this->has_eh_frame_);
1727 else if (!lv.is_section_symbol())
1729 // This is not a section symbol. We can determine
1730 // the final value now.
1731 lv.set_output_value(os->output_address(this, shndx,
1734 else if (!os->find_starting_output_address(this, shndx, &start))
1736 // This is a section symbol, but apparently not one in a
1737 // merged section. First check to see if this is a relaxed
1738 // input section. If so, use its address. Otherwise just
1739 // use the start of the output section. This happens with
1740 // relocatable links when the input object has section
1741 // symbols for arbitrary non-merge sections.
1742 const Output_section_data* posd =
1743 os->find_relaxed_input_section(this, shndx);
1745 lv.set_output_value(posd->address());
1747 lv.set_output_value(os->address());
1751 // We have to consider the addend to determine the
1752 // value to use in a relocation. START is the start
1753 // of this input section.
1754 Merged_symbol_value<size>* msv =
1755 new Merged_symbol_value<size>(lv.input_value(), start);
1756 lv.set_merged_symbol_value(msv);
1759 else if (lv.is_tls_symbol())
1760 lv.set_output_value(os->tls_offset()
1762 + lv.input_value());
1764 lv.set_output_value((relocatable ? 0 : os->address())
1766 + lv.input_value());
1769 if (lv.needs_output_symtab_entry())
1771 lv.set_output_symtab_index(index);
1778 // Set the output dynamic symbol table indexes for the local variables.
1780 template<int size, bool big_endian>
1782 Sized_relobj<size, big_endian>::do_set_local_dynsym_indexes(unsigned int index)
1784 const unsigned int loccount = this->local_symbol_count_;
1785 for (unsigned int i = 1; i < loccount; ++i)
1787 Symbol_value<size>& lv(this->local_values_[i]);
1788 if (lv.needs_output_dynsym_entry())
1790 lv.set_output_dynsym_index(index);
1797 // Set the offset where local dynamic symbol information will be stored.
1798 // Returns the count of local symbols contributed to the symbol table by
1801 template<int size, bool big_endian>
1803 Sized_relobj<size, big_endian>::do_set_local_dynsym_offset(off_t off)
1805 gold_assert(off == static_cast<off_t>(align_address(off, size >> 3)));
1806 this->local_dynsym_offset_ = off;
1807 return this->output_local_dynsym_count_;
1810 // If Symbols_data is not NULL get the section flags from here otherwise
1811 // get it from the file.
1813 template<int size, bool big_endian>
1815 Sized_relobj<size, big_endian>::do_section_flags(unsigned int shndx)
1817 Symbols_data* sd = this->get_symbols_data();
1820 const unsigned char* pshdrs = sd->section_headers_data
1821 + This::shdr_size * shndx;
1822 typename This::Shdr shdr(pshdrs);
1823 return shdr.get_sh_flags();
1825 // If sd is NULL, read the section header from the file.
1826 return this->elf_file_.section_flags(shndx);
1829 // Get the section's ent size from Symbols_data. Called by get_section_contents
1832 template<int size, bool big_endian>
1834 Sized_relobj<size, big_endian>::do_section_entsize(unsigned int shndx)
1836 Symbols_data* sd = this->get_symbols_data();
1837 gold_assert (sd != NULL);
1839 const unsigned char* pshdrs = sd->section_headers_data
1840 + This::shdr_size * shndx;
1841 typename This::Shdr shdr(pshdrs);
1842 return shdr.get_sh_entsize();
1846 // Write out the local symbols.
1848 template<int size, bool big_endian>
1850 Sized_relobj<size, big_endian>::write_local_symbols(
1852 const Stringpool* sympool,
1853 const Stringpool* dynpool,
1854 Output_symtab_xindex* symtab_xindex,
1855 Output_symtab_xindex* dynsym_xindex)
1857 const bool strip_all = parameters->options().strip_all();
1860 if (this->output_local_dynsym_count_ == 0)
1862 this->output_local_symbol_count_ = 0;
1865 gold_assert(this->symtab_shndx_ != -1U);
1866 if (this->symtab_shndx_ == 0)
1868 // This object has no symbols. Weird but legal.
1872 // Read the symbol table section header.
1873 const unsigned int symtab_shndx = this->symtab_shndx_;
1874 typename This::Shdr symtabshdr(this,
1875 this->elf_file_.section_header(symtab_shndx));
1876 gold_assert(symtabshdr.get_sh_type() == elfcpp::SHT_SYMTAB);
1877 const unsigned int loccount = this->local_symbol_count_;
1878 gold_assert(loccount == symtabshdr.get_sh_info());
1880 // Read the local symbols.
1881 const int sym_size = This::sym_size;
1882 off_t locsize = loccount * sym_size;
1883 const unsigned char* psyms = this->get_view(symtabshdr.get_sh_offset(),
1884 locsize, true, false);
1886 // Read the symbol names.
1887 const unsigned int strtab_shndx =
1888 this->adjust_shndx(symtabshdr.get_sh_link());
1889 section_size_type strtab_size;
1890 const unsigned char* pnamesu = this->section_contents(strtab_shndx,
1893 const char* pnames = reinterpret_cast<const char*>(pnamesu);
1895 // Get views into the output file for the portions of the symbol table
1896 // and the dynamic symbol table that we will be writing.
1897 off_t output_size = this->output_local_symbol_count_ * sym_size;
1898 unsigned char* oview = NULL;
1899 if (output_size > 0)
1900 oview = of->get_output_view(this->local_symbol_offset_, output_size);
1902 off_t dyn_output_size = this->output_local_dynsym_count_ * sym_size;
1903 unsigned char* dyn_oview = NULL;
1904 if (dyn_output_size > 0)
1905 dyn_oview = of->get_output_view(this->local_dynsym_offset_,
1908 const Output_sections out_sections(this->output_sections());
1910 gold_assert(this->local_values_.size() == loccount);
1912 unsigned char* ov = oview;
1913 unsigned char* dyn_ov = dyn_oview;
1915 for (unsigned int i = 1; i < loccount; ++i, psyms += sym_size)
1917 elfcpp::Sym<size, big_endian> isym(psyms);
1919 Symbol_value<size>& lv(this->local_values_[i]);
1922 unsigned int st_shndx = this->adjust_sym_shndx(i, isym.get_st_shndx(),
1926 gold_assert(st_shndx < out_sections.size());
1927 if (out_sections[st_shndx] == NULL)
1929 st_shndx = out_sections[st_shndx]->out_shndx();
1930 if (st_shndx >= elfcpp::SHN_LORESERVE)
1932 if (lv.needs_output_symtab_entry() && !strip_all)
1933 symtab_xindex->add(lv.output_symtab_index(), st_shndx);
1934 if (lv.needs_output_dynsym_entry())
1935 dynsym_xindex->add(lv.output_dynsym_index(), st_shndx);
1936 st_shndx = elfcpp::SHN_XINDEX;
1940 // Write the symbol to the output symbol table.
1941 if (!strip_all && lv.needs_output_symtab_entry())
1943 elfcpp::Sym_write<size, big_endian> osym(ov);
1945 gold_assert(isym.get_st_name() < strtab_size);
1946 const char* name = pnames + isym.get_st_name();
1947 osym.put_st_name(sympool->get_offset(name));
1948 osym.put_st_value(this->local_values_[i].value(this, 0));
1949 osym.put_st_size(isym.get_st_size());
1950 osym.put_st_info(isym.get_st_info());
1951 osym.put_st_other(isym.get_st_other());
1952 osym.put_st_shndx(st_shndx);
1957 // Write the symbol to the output dynamic symbol table.
1958 if (lv.needs_output_dynsym_entry())
1960 gold_assert(dyn_ov < dyn_oview + dyn_output_size);
1961 elfcpp::Sym_write<size, big_endian> osym(dyn_ov);
1963 gold_assert(isym.get_st_name() < strtab_size);
1964 const char* name = pnames + isym.get_st_name();
1965 osym.put_st_name(dynpool->get_offset(name));
1966 osym.put_st_value(this->local_values_[i].value(this, 0));
1967 osym.put_st_size(isym.get_st_size());
1968 osym.put_st_info(isym.get_st_info());
1969 osym.put_st_other(isym.get_st_other());
1970 osym.put_st_shndx(st_shndx);
1977 if (output_size > 0)
1979 gold_assert(ov - oview == output_size);
1980 of->write_output_view(this->local_symbol_offset_, output_size, oview);
1983 if (dyn_output_size > 0)
1985 gold_assert(dyn_ov - dyn_oview == dyn_output_size);
1986 of->write_output_view(this->local_dynsym_offset_, dyn_output_size,
1991 // Set *INFO to symbolic information about the offset OFFSET in the
1992 // section SHNDX. Return true if we found something, false if we
1995 template<int size, bool big_endian>
1997 Sized_relobj<size, big_endian>::get_symbol_location_info(
2000 Symbol_location_info* info)
2002 if (this->symtab_shndx_ == 0)
2005 section_size_type symbols_size;
2006 const unsigned char* symbols = this->section_contents(this->symtab_shndx_,
2010 unsigned int symbol_names_shndx =
2011 this->adjust_shndx(this->section_link(this->symtab_shndx_));
2012 section_size_type names_size;
2013 const unsigned char* symbol_names_u =
2014 this->section_contents(symbol_names_shndx, &names_size, false);
2015 const char* symbol_names = reinterpret_cast<const char*>(symbol_names_u);
2017 const int sym_size = This::sym_size;
2018 const size_t count = symbols_size / sym_size;
2020 const unsigned char* p = symbols;
2021 for (size_t i = 0; i < count; ++i, p += sym_size)
2023 elfcpp::Sym<size, big_endian> sym(p);
2025 if (sym.get_st_type() == elfcpp::STT_FILE)
2027 if (sym.get_st_name() >= names_size)
2028 info->source_file = "(invalid)";
2030 info->source_file = symbol_names + sym.get_st_name();
2035 unsigned int st_shndx = this->adjust_sym_shndx(i, sym.get_st_shndx(),
2038 && st_shndx == shndx
2039 && static_cast<off_t>(sym.get_st_value()) <= offset
2040 && (static_cast<off_t>(sym.get_st_value() + sym.get_st_size())
2043 if (sym.get_st_name() > names_size)
2044 info->enclosing_symbol_name = "(invalid)";
2047 info->enclosing_symbol_name = symbol_names + sym.get_st_name();
2048 if (parameters->options().do_demangle())
2050 char* demangled_name = cplus_demangle(
2051 info->enclosing_symbol_name.c_str(),
2052 DMGL_ANSI | DMGL_PARAMS);
2053 if (demangled_name != NULL)
2055 info->enclosing_symbol_name.assign(demangled_name);
2056 free(demangled_name);
2067 // Look for a kept section corresponding to the given discarded section,
2068 // and return its output address. This is used only for relocations in
2069 // debugging sections. If we can't find the kept section, return 0.
2071 template<int size, bool big_endian>
2072 typename Sized_relobj<size, big_endian>::Address
2073 Sized_relobj<size, big_endian>::map_to_kept_section(
2077 Relobj* kept_object;
2078 unsigned int kept_shndx;
2079 if (this->get_kept_comdat_section(shndx, &kept_object, &kept_shndx))
2081 Sized_relobj<size, big_endian>* kept_relobj =
2082 static_cast<Sized_relobj<size, big_endian>*>(kept_object);
2083 Output_section* os = kept_relobj->output_section(kept_shndx);
2084 Address offset = kept_relobj->get_output_section_offset(kept_shndx);
2085 if (os != NULL && offset != invalid_address)
2088 return os->address() + offset;
2095 // Get symbol counts.
2097 template<int size, bool big_endian>
2099 Sized_relobj<size, big_endian>::do_get_global_symbol_counts(
2100 const Symbol_table*,
2104 *defined = this->defined_count_;
2106 for (Symbols::const_iterator p = this->symbols_.begin();
2107 p != this->symbols_.end();
2110 && (*p)->source() == Symbol::FROM_OBJECT
2111 && (*p)->object() == this
2112 && (*p)->is_defined())
2117 // Input_objects methods.
2119 // Add a regular relocatable object to the list. Return false if this
2120 // object should be ignored.
2123 Input_objects::add_object(Object* obj)
2125 // Print the filename if the -t/--trace option is selected.
2126 if (parameters->options().trace())
2127 gold_info("%s", obj->name().c_str());
2129 if (!obj->is_dynamic())
2130 this->relobj_list_.push_back(static_cast<Relobj*>(obj));
2133 // See if this is a duplicate SONAME.
2134 Dynobj* dynobj = static_cast<Dynobj*>(obj);
2135 const char* soname = dynobj->soname();
2137 std::pair<Unordered_set<std::string>::iterator, bool> ins =
2138 this->sonames_.insert(soname);
2141 // We have already seen a dynamic object with this soname.
2145 this->dynobj_list_.push_back(dynobj);
2148 // Add this object to the cross-referencer if requested.
2149 if (parameters->options().user_set_print_symbol_counts()
2150 || parameters->options().cref())
2152 if (this->cref_ == NULL)
2153 this->cref_ = new Cref();
2154 this->cref_->add_object(obj);
2160 // For each dynamic object, record whether we've seen all of its
2161 // explicit dependencies.
2164 Input_objects::check_dynamic_dependencies() const
2166 bool issued_copy_dt_needed_error = false;
2167 for (Dynobj_list::const_iterator p = this->dynobj_list_.begin();
2168 p != this->dynobj_list_.end();
2171 const Dynobj::Needed& needed((*p)->needed());
2172 bool found_all = true;
2173 Dynobj::Needed::const_iterator pneeded;
2174 for (pneeded = needed.begin(); pneeded != needed.end(); ++pneeded)
2176 if (this->sonames_.find(*pneeded) == this->sonames_.end())
2182 (*p)->set_has_unknown_needed_entries(!found_all);
2184 // --copy-dt-needed-entries aka --add-needed is a GNU ld option
2185 // --that gold does not support. However, they cause no trouble
2186 // --unless there is a DT_NEEDED entry that we don't know about;
2187 // --warn only in that case.
2189 && !issued_copy_dt_needed_error
2190 && (parameters->options().copy_dt_needed_entries()
2191 || parameters->options().add_needed()))
2193 const char* optname;
2194 if (parameters->options().copy_dt_needed_entries())
2195 optname = "--copy-dt-needed-entries";
2197 optname = "--add-needed";
2198 gold_error(_("%s is not supported but is required for %s in %s"),
2199 optname, (*pneeded).c_str(), (*p)->name().c_str());
2200 issued_copy_dt_needed_error = true;
2205 // Start processing an archive.
2208 Input_objects::archive_start(Archive* archive)
2210 if (parameters->options().user_set_print_symbol_counts()
2211 || parameters->options().cref())
2213 if (this->cref_ == NULL)
2214 this->cref_ = new Cref();
2215 this->cref_->add_archive_start(archive);
2219 // Stop processing an archive.
2222 Input_objects::archive_stop(Archive* archive)
2224 if (parameters->options().user_set_print_symbol_counts()
2225 || parameters->options().cref())
2226 this->cref_->add_archive_stop(archive);
2229 // Print symbol counts
2232 Input_objects::print_symbol_counts(const Symbol_table* symtab) const
2234 if (parameters->options().user_set_print_symbol_counts()
2235 && this->cref_ != NULL)
2236 this->cref_->print_symbol_counts(symtab);
2239 // Print a cross reference table.
2242 Input_objects::print_cref(const Symbol_table* symtab, FILE* f) const
2244 if (parameters->options().cref() && this->cref_ != NULL)
2245 this->cref_->print_cref(symtab, f);
2248 // Relocate_info methods.
2250 // Return a string describing the location of a relocation. This is
2251 // only used in error messages.
2253 template<int size, bool big_endian>
2255 Relocate_info<size, big_endian>::location(size_t, off_t offset) const
2257 // See if we can get line-number information from debugging sections.
2258 std::string filename;
2259 std::string file_and_lineno; // Better than filename-only, if available.
2261 Sized_dwarf_line_info<size, big_endian> line_info(this->object);
2262 // This will be "" if we failed to parse the debug info for any reason.
2263 file_and_lineno = line_info.addr2line(this->data_shndx, offset);
2265 std::string ret(this->object->name());
2267 Symbol_location_info info;
2268 if (this->object->get_symbol_location_info(this->data_shndx, offset, &info))
2270 ret += " in function ";
2271 ret += info.enclosing_symbol_name;
2273 filename = info.source_file;
2276 if (!file_and_lineno.empty())
2277 ret += file_and_lineno;
2280 if (!filename.empty())
2283 ret += this->object->section_name(this->data_shndx);
2285 // Offsets into sections have to be positive.
2286 snprintf(buf, sizeof(buf), "+0x%lx", static_cast<long>(offset));
2293 } // End namespace gold.
2298 using namespace gold;
2300 // Read an ELF file with the header and return the appropriate
2301 // instance of Object.
2303 template<int size, bool big_endian>
2305 make_elf_sized_object(const std::string& name, Input_file* input_file,
2306 off_t offset, const elfcpp::Ehdr<size, big_endian>& ehdr,
2307 bool* punconfigured)
2309 Target* target = select_target(ehdr.get_e_machine(), size, big_endian,
2310 ehdr.get_e_ident()[elfcpp::EI_OSABI],
2311 ehdr.get_e_ident()[elfcpp::EI_ABIVERSION]);
2313 gold_fatal(_("%s: unsupported ELF machine number %d"),
2314 name.c_str(), ehdr.get_e_machine());
2316 if (!parameters->target_valid())
2317 set_parameters_target(target);
2318 else if (target != ¶meters->target())
2320 if (punconfigured != NULL)
2321 *punconfigured = true;
2323 gold_error(_("%s: incompatible target"), name.c_str());
2327 return target->make_elf_object<size, big_endian>(name, input_file, offset,
2331 } // End anonymous namespace.
2336 // Return whether INPUT_FILE is an ELF object.
2339 is_elf_object(Input_file* input_file, off_t offset,
2340 const unsigned char** start, int *read_size)
2342 off_t filesize = input_file->file().filesize();
2343 int want = elfcpp::Elf_recognizer::max_header_size;
2344 if (filesize - offset < want)
2345 want = filesize - offset;
2347 const unsigned char* p = input_file->file().get_view(offset, 0, want,
2352 return elfcpp::Elf_recognizer::is_elf_file(p, want);
2355 // Read an ELF file and return the appropriate instance of Object.
2358 make_elf_object(const std::string& name, Input_file* input_file, off_t offset,
2359 const unsigned char* p, section_offset_type bytes,
2360 bool* punconfigured)
2362 if (punconfigured != NULL)
2363 *punconfigured = false;
2366 bool big_endian = false;
2368 if (!elfcpp::Elf_recognizer::is_valid_header(p, bytes, &size,
2369 &big_endian, &error))
2371 gold_error(_("%s: %s"), name.c_str(), error.c_str());
2379 #ifdef HAVE_TARGET_32_BIG
2380 elfcpp::Ehdr<32, true> ehdr(p);
2381 return make_elf_sized_object<32, true>(name, input_file,
2382 offset, ehdr, punconfigured);
2384 if (punconfigured != NULL)
2385 *punconfigured = true;
2387 gold_error(_("%s: not configured to support "
2388 "32-bit big-endian object"),
2395 #ifdef HAVE_TARGET_32_LITTLE
2396 elfcpp::Ehdr<32, false> ehdr(p);
2397 return make_elf_sized_object<32, false>(name, input_file,
2398 offset, ehdr, punconfigured);
2400 if (punconfigured != NULL)
2401 *punconfigured = true;
2403 gold_error(_("%s: not configured to support "
2404 "32-bit little-endian object"),
2410 else if (size == 64)
2414 #ifdef HAVE_TARGET_64_BIG
2415 elfcpp::Ehdr<64, true> ehdr(p);
2416 return make_elf_sized_object<64, true>(name, input_file,
2417 offset, ehdr, punconfigured);
2419 if (punconfigured != NULL)
2420 *punconfigured = true;
2422 gold_error(_("%s: not configured to support "
2423 "64-bit big-endian object"),
2430 #ifdef HAVE_TARGET_64_LITTLE
2431 elfcpp::Ehdr<64, false> ehdr(p);
2432 return make_elf_sized_object<64, false>(name, input_file,
2433 offset, ehdr, punconfigured);
2435 if (punconfigured != NULL)
2436 *punconfigured = true;
2438 gold_error(_("%s: not configured to support "
2439 "64-bit little-endian object"),
2449 // Instantiate the templates we need.
2451 #ifdef HAVE_TARGET_32_LITTLE
2454 Object::read_section_data<32, false>(elfcpp::Elf_file<32, false, Object>*,
2455 Read_symbols_data*);
2458 #ifdef HAVE_TARGET_32_BIG
2461 Object::read_section_data<32, true>(elfcpp::Elf_file<32, true, Object>*,
2462 Read_symbols_data*);
2465 #ifdef HAVE_TARGET_64_LITTLE
2468 Object::read_section_data<64, false>(elfcpp::Elf_file<64, false, Object>*,
2469 Read_symbols_data*);
2472 #ifdef HAVE_TARGET_64_BIG
2475 Object::read_section_data<64, true>(elfcpp::Elf_file<64, true, Object>*,
2476 Read_symbols_data*);
2479 #ifdef HAVE_TARGET_32_LITTLE
2481 class Sized_relobj<32, false>;
2484 #ifdef HAVE_TARGET_32_BIG
2486 class Sized_relobj<32, true>;
2489 #ifdef HAVE_TARGET_64_LITTLE
2491 class Sized_relobj<64, false>;
2494 #ifdef HAVE_TARGET_64_BIG
2496 class Sized_relobj<64, true>;
2499 #ifdef HAVE_TARGET_32_LITTLE
2501 struct Relocate_info<32, false>;
2504 #ifdef HAVE_TARGET_32_BIG
2506 struct Relocate_info<32, true>;
2509 #ifdef HAVE_TARGET_64_LITTLE
2511 struct Relocate_info<64, false>;
2514 #ifdef HAVE_TARGET_64_BIG
2516 struct Relocate_info<64, true>;
2519 } // End namespace gold.