1 // object.cc -- support for an object file for linking in gold
3 // Copyright 2006, 2007, 2008, 2009 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 // Set the target based on fields in the ELF file header.
138 Object::set_target(int machine, int size, bool big_endian, int osabi,
141 Target* target = select_target(machine, size, big_endian, osabi, abiversion);
143 gold_fatal(_("%s: unsupported ELF machine number %d"),
144 this->name().c_str(), machine);
145 this->target_ = target;
148 // Report an error for this object file. This is used by the
149 // elfcpp::Elf_file interface, and also called by the Object code
153 Object::error(const char* format, ...) const
156 va_start(args, format);
158 if (vasprintf(&buf, format, args) < 0)
161 gold_error(_("%s: %s"), this->name().c_str(), buf);
165 // Return a view of the contents of a section.
168 Object::section_contents(unsigned int shndx, section_size_type* plen,
171 Location loc(this->do_section_contents(shndx));
172 *plen = convert_to_section_size_type(loc.data_size);
175 static const unsigned char empty[1] = { '\0' };
178 return this->get_view(loc.file_offset, *plen, true, cache);
181 // Read the section data into SD. This is code common to Sized_relobj
182 // and Sized_dynobj, so we put it into Object.
184 template<int size, bool big_endian>
186 Object::read_section_data(elfcpp::Elf_file<size, big_endian, Object>* elf_file,
187 Read_symbols_data* sd)
189 const int shdr_size = elfcpp::Elf_sizes<size>::shdr_size;
191 // Read the section headers.
192 const off_t shoff = elf_file->shoff();
193 const unsigned int shnum = this->shnum();
194 sd->section_headers = this->get_lasting_view(shoff, shnum * shdr_size,
197 // Read the section names.
198 const unsigned char* pshdrs = sd->section_headers->data();
199 const unsigned char* pshdrnames = pshdrs + elf_file->shstrndx() * shdr_size;
200 typename elfcpp::Shdr<size, big_endian> shdrnames(pshdrnames);
202 if (shdrnames.get_sh_type() != elfcpp::SHT_STRTAB)
203 this->error(_("section name section has wrong type: %u"),
204 static_cast<unsigned int>(shdrnames.get_sh_type()));
206 sd->section_names_size =
207 convert_to_section_size_type(shdrnames.get_sh_size());
208 sd->section_names = this->get_lasting_view(shdrnames.get_sh_offset(),
209 sd->section_names_size, false,
213 // If NAME is the name of a special .gnu.warning section, arrange for
214 // the warning to be issued. SHNDX is the section index. Return
215 // whether it is a warning section.
218 Object::handle_gnu_warning_section(const char* name, unsigned int shndx,
219 Symbol_table* symtab)
221 const char warn_prefix[] = ".gnu.warning.";
222 const int warn_prefix_len = sizeof warn_prefix - 1;
223 if (strncmp(name, warn_prefix, warn_prefix_len) == 0)
225 // Read the section contents to get the warning text. It would
226 // be nicer if we only did this if we have to actually issue a
227 // warning. Unfortunately, warnings are issued as we relocate
228 // sections. That means that we can not lock the object then,
229 // as we might try to issue the same warning multiple times
231 section_size_type len;
232 const unsigned char* contents = this->section_contents(shndx, &len,
236 const char* warning = name + warn_prefix_len;
237 contents = reinterpret_cast<const unsigned char*>(warning);
238 len = strlen(warning);
240 std::string warning(reinterpret_cast<const char*>(contents), len);
241 symtab->add_warning(name + warn_prefix_len, this, warning);
249 // To copy the symbols data read from the file to a local data structure.
250 // This function is called from do_layout only while doing garbage
254 Relobj::copy_symbols_data(Symbols_data* gc_sd, Read_symbols_data* sd,
255 unsigned int section_header_size)
257 gc_sd->section_headers_data =
258 new unsigned char[(section_header_size)];
259 memcpy(gc_sd->section_headers_data, sd->section_headers->data(),
260 section_header_size);
261 gc_sd->section_names_data =
262 new unsigned char[sd->section_names_size];
263 memcpy(gc_sd->section_names_data, sd->section_names->data(),
264 sd->section_names_size);
265 gc_sd->section_names_size = sd->section_names_size;
266 if (sd->symbols != NULL)
268 gc_sd->symbols_data =
269 new unsigned char[sd->symbols_size];
270 memcpy(gc_sd->symbols_data, sd->symbols->data(),
275 gc_sd->symbols_data = NULL;
277 gc_sd->symbols_size = sd->symbols_size;
278 gc_sd->external_symbols_offset = sd->external_symbols_offset;
279 if (sd->symbol_names != NULL)
281 gc_sd->symbol_names_data =
282 new unsigned char[sd->symbol_names_size];
283 memcpy(gc_sd->symbol_names_data, sd->symbol_names->data(),
284 sd->symbol_names_size);
288 gc_sd->symbol_names_data = NULL;
290 gc_sd->symbol_names_size = sd->symbol_names_size;
293 // This function determines if a particular section name must be included
294 // in the link. This is used during garbage collection to determine the
295 // roots of the worklist.
298 Relobj::is_section_name_included(const char* name)
300 if (is_prefix_of(".ctors", name)
301 || is_prefix_of(".dtors", name)
302 || is_prefix_of(".note", name)
303 || is_prefix_of(".init", name)
304 || is_prefix_of(".fini", name)
305 || is_prefix_of(".gcc_except_table", name)
306 || is_prefix_of(".jcr", name)
307 || is_prefix_of(".preinit_array", name)
308 || (is_prefix_of(".text", name)
309 && strstr(name, "personality"))
310 || (is_prefix_of(".data", name)
311 && strstr(name, "personality"))
312 || (is_prefix_of(".gnu.linkonce.d", name) &&
313 strstr(name, "personality")))
320 // Class Sized_relobj.
322 template<int size, bool big_endian>
323 Sized_relobj<size, big_endian>::Sized_relobj(
324 const std::string& name,
325 Input_file* input_file,
327 const elfcpp::Ehdr<size, big_endian>& ehdr)
328 : Relobj(name, input_file, offset),
329 elf_file_(this, ehdr),
331 local_symbol_count_(0),
332 output_local_symbol_count_(0),
333 output_local_dynsym_count_(0),
336 local_symbol_offset_(0),
337 local_dynsym_offset_(0),
339 local_got_offsets_(),
340 kept_comdat_sections_(),
341 has_eh_frame_(false),
342 discarded_eh_frame_shndx_(-1U)
346 template<int size, bool big_endian>
347 Sized_relobj<size, big_endian>::~Sized_relobj()
351 // Set up an object file based on the file header. This sets up the
352 // target and reads the section information.
354 template<int size, bool big_endian>
356 Sized_relobj<size, big_endian>::setup(
357 const elfcpp::Ehdr<size, big_endian>& ehdr)
359 this->set_target(ehdr.get_e_machine(), size, big_endian,
360 ehdr.get_e_ident()[elfcpp::EI_OSABI],
361 ehdr.get_e_ident()[elfcpp::EI_ABIVERSION]);
363 const unsigned int shnum = this->elf_file_.shnum();
364 this->set_shnum(shnum);
367 // Find the SHT_SYMTAB section, given the section headers. The ELF
368 // standard says that maybe in the future there can be more than one
369 // SHT_SYMTAB section. Until somebody figures out how that could
370 // work, we assume there is only one.
372 template<int size, bool big_endian>
374 Sized_relobj<size, big_endian>::find_symtab(const unsigned char* pshdrs)
376 const unsigned int shnum = this->shnum();
377 this->symtab_shndx_ = 0;
380 // Look through the sections in reverse order, since gas tends
381 // to put the symbol table at the end.
382 const unsigned char* p = pshdrs + shnum * This::shdr_size;
383 unsigned int i = shnum;
384 unsigned int xindex_shndx = 0;
385 unsigned int xindex_link = 0;
389 p -= This::shdr_size;
390 typename This::Shdr shdr(p);
391 if (shdr.get_sh_type() == elfcpp::SHT_SYMTAB)
393 this->symtab_shndx_ = i;
394 if (xindex_shndx > 0 && xindex_link == i)
397 new Xindex(this->elf_file_.large_shndx_offset());
398 xindex->read_symtab_xindex<size, big_endian>(this,
401 this->set_xindex(xindex);
406 // Try to pick up the SHT_SYMTAB_SHNDX section, if there is
407 // one. This will work if it follows the SHT_SYMTAB
409 if (shdr.get_sh_type() == elfcpp::SHT_SYMTAB_SHNDX)
412 xindex_link = this->adjust_shndx(shdr.get_sh_link());
418 // Return the Xindex structure to use for object with lots of
421 template<int size, bool big_endian>
423 Sized_relobj<size, big_endian>::do_initialize_xindex()
425 gold_assert(this->symtab_shndx_ != -1U);
426 Xindex* xindex = new Xindex(this->elf_file_.large_shndx_offset());
427 xindex->initialize_symtab_xindex<size, big_endian>(this, this->symtab_shndx_);
431 // Return whether SHDR has the right type and flags to be a GNU
432 // .eh_frame section.
434 template<int size, bool big_endian>
436 Sized_relobj<size, big_endian>::check_eh_frame_flags(
437 const elfcpp::Shdr<size, big_endian>* shdr) const
439 return (shdr->get_sh_type() == elfcpp::SHT_PROGBITS
440 && (shdr->get_sh_flags() & elfcpp::SHF_ALLOC) != 0);
443 // Return whether there is a GNU .eh_frame section, given the section
444 // headers and the section names.
446 template<int size, bool big_endian>
448 Sized_relobj<size, big_endian>::find_eh_frame(
449 const unsigned char* pshdrs,
451 section_size_type names_size) const
453 const unsigned int shnum = this->shnum();
454 const unsigned char* p = pshdrs + This::shdr_size;
455 for (unsigned int i = 1; i < shnum; ++i, p += This::shdr_size)
457 typename This::Shdr shdr(p);
458 if (this->check_eh_frame_flags(&shdr))
460 if (shdr.get_sh_name() >= names_size)
462 this->error(_("bad section name offset for section %u: %lu"),
463 i, static_cast<unsigned long>(shdr.get_sh_name()));
467 const char* name = names + shdr.get_sh_name();
468 if (strcmp(name, ".eh_frame") == 0)
475 // Read the sections and symbols from an object file.
477 template<int size, bool big_endian>
479 Sized_relobj<size, big_endian>::do_read_symbols(Read_symbols_data* sd)
481 this->read_section_data(&this->elf_file_, sd);
483 const unsigned char* const pshdrs = sd->section_headers->data();
485 this->find_symtab(pshdrs);
487 const unsigned char* namesu = sd->section_names->data();
488 const char* names = reinterpret_cast<const char*>(namesu);
489 if (memmem(names, sd->section_names_size, ".eh_frame", 10) != NULL)
491 if (this->find_eh_frame(pshdrs, names, sd->section_names_size))
492 this->has_eh_frame_ = true;
496 sd->symbols_size = 0;
497 sd->external_symbols_offset = 0;
498 sd->symbol_names = NULL;
499 sd->symbol_names_size = 0;
501 if (this->symtab_shndx_ == 0)
503 // No symbol table. Weird but legal.
507 // Get the symbol table section header.
508 typename This::Shdr symtabshdr(pshdrs
509 + this->symtab_shndx_ * This::shdr_size);
510 gold_assert(symtabshdr.get_sh_type() == elfcpp::SHT_SYMTAB);
512 // If this object has a .eh_frame section, we need all the symbols.
513 // Otherwise we only need the external symbols. While it would be
514 // simpler to just always read all the symbols, I've seen object
515 // files with well over 2000 local symbols, which for a 64-bit
516 // object file format is over 5 pages that we don't need to read
519 const int sym_size = This::sym_size;
520 const unsigned int loccount = symtabshdr.get_sh_info();
521 this->local_symbol_count_ = loccount;
522 this->local_values_.resize(loccount);
523 section_offset_type locsize = loccount * sym_size;
524 off_t dataoff = symtabshdr.get_sh_offset();
525 section_size_type datasize =
526 convert_to_section_size_type(symtabshdr.get_sh_size());
527 off_t extoff = dataoff + locsize;
528 section_size_type extsize = datasize - locsize;
530 off_t readoff = this->has_eh_frame_ ? dataoff : extoff;
531 section_size_type readsize = this->has_eh_frame_ ? datasize : extsize;
535 // No external symbols. Also weird but also legal.
539 File_view* fvsymtab = this->get_lasting_view(readoff, readsize, true, false);
541 // Read the section header for the symbol names.
542 unsigned int strtab_shndx = this->adjust_shndx(symtabshdr.get_sh_link());
543 if (strtab_shndx >= this->shnum())
545 this->error(_("invalid symbol table name index: %u"), strtab_shndx);
548 typename This::Shdr strtabshdr(pshdrs + strtab_shndx * This::shdr_size);
549 if (strtabshdr.get_sh_type() != elfcpp::SHT_STRTAB)
551 this->error(_("symbol table name section has wrong type: %u"),
552 static_cast<unsigned int>(strtabshdr.get_sh_type()));
556 // Read the symbol names.
557 File_view* fvstrtab = this->get_lasting_view(strtabshdr.get_sh_offset(),
558 strtabshdr.get_sh_size(),
561 sd->symbols = fvsymtab;
562 sd->symbols_size = readsize;
563 sd->external_symbols_offset = this->has_eh_frame_ ? locsize : 0;
564 sd->symbol_names = fvstrtab;
565 sd->symbol_names_size =
566 convert_to_section_size_type(strtabshdr.get_sh_size());
569 // Return the section index of symbol SYM. Set *VALUE to its value in
570 // the object file. Set *IS_ORDINARY if this is an ordinary section
571 // index. not a special cod between SHN_LORESERVE and SHN_HIRESERVE.
572 // Note that for a symbol which is not defined in this object file,
573 // this will set *VALUE to 0 and return SHN_UNDEF; it will not return
574 // the final value of the symbol in the link.
576 template<int size, bool big_endian>
578 Sized_relobj<size, big_endian>::symbol_section_and_value(unsigned int sym,
582 section_size_type symbols_size;
583 const unsigned char* symbols = this->section_contents(this->symtab_shndx_,
587 const size_t count = symbols_size / This::sym_size;
588 gold_assert(sym < count);
590 elfcpp::Sym<size, big_endian> elfsym(symbols + sym * This::sym_size);
591 *value = elfsym.get_st_value();
593 return this->adjust_sym_shndx(sym, elfsym.get_st_shndx(), is_ordinary);
596 // Return whether to include a section group in the link. LAYOUT is
597 // used to keep track of which section groups we have already seen.
598 // INDEX is the index of the section group and SHDR is the section
599 // header. If we do not want to include this group, we set bits in
600 // OMIT for each section which should be discarded.
602 template<int size, bool big_endian>
604 Sized_relobj<size, big_endian>::include_section_group(
605 Symbol_table* symtab,
609 const unsigned char* shdrs,
610 const char* section_names,
611 section_size_type section_names_size,
612 std::vector<bool>* omit)
614 // Read the section contents.
615 typename This::Shdr shdr(shdrs + index * This::shdr_size);
616 const unsigned char* pcon = this->get_view(shdr.get_sh_offset(),
617 shdr.get_sh_size(), true, false);
618 const elfcpp::Elf_Word* pword =
619 reinterpret_cast<const elfcpp::Elf_Word*>(pcon);
621 // The first word contains flags. We only care about COMDAT section
622 // groups. Other section groups are always included in the link
623 // just like ordinary sections.
624 elfcpp::Elf_Word flags = elfcpp::Swap<32, big_endian>::readval(pword);
626 // Look up the group signature, which is the name of a symbol. This
627 // is a lot of effort to go to to read a string. Why didn't they
628 // just have the group signature point into the string table, rather
629 // than indirect through a symbol?
631 // Get the appropriate symbol table header (this will normally be
632 // the single SHT_SYMTAB section, but in principle it need not be).
633 const unsigned int link = this->adjust_shndx(shdr.get_sh_link());
634 typename This::Shdr symshdr(this, this->elf_file_.section_header(link));
636 // Read the symbol table entry.
637 unsigned int symndx = shdr.get_sh_info();
638 if (symndx >= symshdr.get_sh_size() / This::sym_size)
640 this->error(_("section group %u info %u out of range"),
644 off_t symoff = symshdr.get_sh_offset() + symndx * This::sym_size;
645 const unsigned char* psym = this->get_view(symoff, This::sym_size, true,
647 elfcpp::Sym<size, big_endian> sym(psym);
649 // Read the symbol table names.
650 section_size_type symnamelen;
651 const unsigned char* psymnamesu;
652 psymnamesu = this->section_contents(this->adjust_shndx(symshdr.get_sh_link()),
654 const char* psymnames = reinterpret_cast<const char*>(psymnamesu);
656 // Get the section group signature.
657 if (sym.get_st_name() >= symnamelen)
659 this->error(_("symbol %u name offset %u out of range"),
660 symndx, sym.get_st_name());
664 std::string signature(psymnames + sym.get_st_name());
666 // It seems that some versions of gas will create a section group
667 // associated with a section symbol, and then fail to give a name to
668 // the section symbol. In such a case, use the name of the section.
669 if (signature[0] == '\0' && sym.get_st_type() == elfcpp::STT_SECTION)
672 unsigned int sym_shndx = this->adjust_sym_shndx(symndx,
675 if (!is_ordinary || sym_shndx >= this->shnum())
677 this->error(_("symbol %u invalid section index %u"),
681 typename This::Shdr member_shdr(shdrs + sym_shndx * This::shdr_size);
682 if (member_shdr.get_sh_name() < section_names_size)
683 signature = section_names + member_shdr.get_sh_name();
686 // Record this section group in the layout, and see whether we've already
687 // seen one with the same signature.
690 Kept_section* kept_section = NULL;
692 if ((flags & elfcpp::GRP_COMDAT) == 0)
694 include_group = true;
699 include_group = layout->find_or_add_kept_section(signature,
701 true, &kept_section);
705 size_t count = shdr.get_sh_size() / sizeof(elfcpp::Elf_Word);
707 std::vector<unsigned int> shndxes;
708 bool relocate_group = include_group && parameters->options().relocatable();
710 shndxes.reserve(count - 1);
712 for (size_t i = 1; i < count; ++i)
714 elfcpp::Elf_Word shndx =
715 this->adjust_shndx(elfcpp::Swap<32, big_endian>::readval(pword + i));
718 shndxes.push_back(shndx);
720 if (shndx >= this->shnum())
722 this->error(_("section %u in section group %u out of range"),
727 // Check for an earlier section number, since we're going to get
728 // it wrong--we may have already decided to include the section.
730 this->error(_("invalid section group %u refers to earlier section %u"),
733 // Get the name of the member section.
734 typename This::Shdr member_shdr(shdrs + shndx * This::shdr_size);
735 if (member_shdr.get_sh_name() >= section_names_size)
737 // This is an error, but it will be diagnosed eventually
738 // in do_layout, so we don't need to do anything here but
742 std::string mname(section_names + member_shdr.get_sh_name());
747 kept_section->add_comdat_section(mname, shndx,
748 member_shdr.get_sh_size());
752 (*omit)[shndx] = true;
756 Relobj* kept_object = kept_section->object();
757 if (kept_section->is_comdat())
759 // Find the corresponding kept section, and store
760 // that info in the discarded section table.
761 unsigned int kept_shndx;
763 if (kept_section->find_comdat_section(mname, &kept_shndx,
766 // We don't keep a mapping for this section if
767 // it has a different size. The mapping is only
768 // used for relocation processing, and we don't
769 // want to treat the sections as similar if the
770 // sizes are different. Checking the section
771 // size is the approach used by the GNU linker.
772 if (kept_size == member_shdr.get_sh_size())
773 this->set_kept_comdat_section(shndx, kept_object,
779 // The existing section is a linkonce section. Add
780 // a mapping if there is exactly one section in the
781 // group (which is true when COUNT == 2) and if it
784 && (kept_section->linkonce_size()
785 == member_shdr.get_sh_size()))
786 this->set_kept_comdat_section(shndx, kept_object,
787 kept_section->shndx());
794 layout->layout_group(symtab, this, index, name, signature.c_str(),
795 shdr, flags, &shndxes);
797 return include_group;
800 // Whether to include a linkonce section in the link. NAME is the
801 // name of the section and SHDR is the section header.
803 // Linkonce sections are a GNU extension implemented in the original
804 // GNU linker before section groups were defined. The semantics are
805 // that we only include one linkonce section with a given name. The
806 // name of a linkonce section is normally .gnu.linkonce.T.SYMNAME,
807 // where T is the type of section and SYMNAME is the name of a symbol.
808 // In an attempt to make linkonce sections interact well with section
809 // groups, we try to identify SYMNAME and use it like a section group
810 // signature. We want to block section groups with that signature,
811 // but not other linkonce sections with that signature. We also use
812 // the full name of the linkonce section as a normal section group
815 template<int size, bool big_endian>
817 Sized_relobj<size, big_endian>::include_linkonce_section(
821 const elfcpp::Shdr<size, big_endian>& shdr)
823 typename elfcpp::Elf_types<size>::Elf_WXword sh_size = shdr.get_sh_size();
824 // In general the symbol name we want will be the string following
825 // the last '.'. However, we have to handle the case of
826 // .gnu.linkonce.t.__i686.get_pc_thunk.bx, which was generated by
827 // some versions of gcc. So we use a heuristic: if the name starts
828 // with ".gnu.linkonce.t.", we use everything after that. Otherwise
829 // we look for the last '.'. We can't always simply skip
830 // ".gnu.linkonce.X", because we have to deal with cases like
831 // ".gnu.linkonce.d.rel.ro.local".
832 const char* const linkonce_t = ".gnu.linkonce.t.";
834 if (strncmp(name, linkonce_t, strlen(linkonce_t)) == 0)
835 symname = name + strlen(linkonce_t);
837 symname = strrchr(name, '.') + 1;
838 std::string sig1(symname);
839 std::string sig2(name);
842 bool include1 = layout->find_or_add_kept_section(sig1, this, index, false,
844 bool include2 = layout->find_or_add_kept_section(sig2, this, index, false,
849 // We are not including this section because we already saw the
850 // name of the section as a signature. This normally implies
851 // that the kept section is another linkonce section. If it is
852 // the same size, record it as the section which corresponds to
854 if (kept2->object() != NULL
855 && !kept2->is_comdat()
856 && kept2->linkonce_size() == sh_size)
857 this->set_kept_comdat_section(index, kept2->object(), kept2->shndx());
861 // The section is being discarded on the basis of its symbol
862 // name. This means that the corresponding kept section was
863 // part of a comdat group, and it will be difficult to identify
864 // the specific section within that group that corresponds to
865 // this linkonce section. We'll handle the simple case where
866 // the group has only one member section. Otherwise, it's not
868 unsigned int kept_shndx;
870 if (kept1->object() != NULL
871 && kept1->is_comdat()
872 && kept1->find_single_comdat_section(&kept_shndx, &kept_size)
873 && kept_size == sh_size)
874 this->set_kept_comdat_section(index, kept1->object(), kept_shndx);
878 kept1->set_linkonce_size(sh_size);
879 kept2->set_linkonce_size(sh_size);
882 return include1 && include2;
885 // Layout an input section.
887 template<int size, bool big_endian>
889 Sized_relobj<size, big_endian>::layout_section(Layout* layout,
892 typename This::Shdr& shdr,
893 unsigned int reloc_shndx,
894 unsigned int reloc_type)
897 Output_section* os = layout->layout(this, shndx, name, shdr,
898 reloc_shndx, reloc_type, &offset);
900 this->output_sections()[shndx] = os;
902 this->section_offsets_[shndx] = invalid_address;
904 this->section_offsets_[shndx] = convert_types<Address, off_t>(offset);
906 // If this section requires special handling, and if there are
907 // relocs that apply to it, then we must do the special handling
908 // before we apply the relocs.
909 if (offset == -1 && reloc_shndx != 0)
910 this->set_relocs_must_follow_section_writes();
913 // Lay out the input sections. We walk through the sections and check
914 // whether they should be included in the link. If they should, we
915 // pass them to the Layout object, which will return an output section
917 // During garbage collection (--gc-sections) and identical code folding
918 // (--icf), this function is called twice. When it is called the first
919 // time, it is for setting up some sections as roots to a work-list for
920 // --gc-sections and to do comdat processing. Actual layout happens the
921 // second time around after all the relevant sections have been determined.
922 // The first time, is_worklist_ready or is_icf_ready is false. It is then
923 // set to true after the garbage collection worklist or identical code
924 // folding is processed and the relevant sections to be kept are
925 // determined. Then, this function is called again to layout the sections.
927 template<int size, bool big_endian>
929 Sized_relobj<size, big_endian>::do_layout(Symbol_table* symtab,
931 Read_symbols_data* sd)
933 const unsigned int shnum = this->shnum();
934 bool is_gc_pass_one = ((parameters->options().gc_sections()
935 && !symtab->gc()->is_worklist_ready())
936 || (parameters->options().icf()
937 && !symtab->icf()->is_icf_ready()));
939 bool is_gc_pass_two = ((parameters->options().gc_sections()
940 && symtab->gc()->is_worklist_ready())
941 || (parameters->options().icf()
942 && symtab->icf()->is_icf_ready()));
944 bool is_gc_or_icf = (parameters->options().gc_sections()
945 || parameters->options().icf());
947 // Both is_gc_pass_one and is_gc_pass_two should not be true.
948 gold_assert(!(is_gc_pass_one && is_gc_pass_two));
952 Symbols_data* gc_sd = NULL;
955 // During garbage collection save the symbols data to use it when
956 // re-entering this function.
957 gc_sd = new Symbols_data;
958 this->copy_symbols_data(gc_sd, sd, This::shdr_size * shnum);
959 this->set_symbols_data(gc_sd);
961 else if (is_gc_pass_two)
963 gc_sd = this->get_symbols_data();
966 const unsigned char* section_headers_data = NULL;
967 section_size_type section_names_size;
968 const unsigned char* symbols_data = NULL;
969 section_size_type symbols_size;
970 section_offset_type external_symbols_offset;
971 const unsigned char* symbol_names_data = NULL;
972 section_size_type symbol_names_size;
976 section_headers_data = gc_sd->section_headers_data;
977 section_names_size = gc_sd->section_names_size;
978 symbols_data = gc_sd->symbols_data;
979 symbols_size = gc_sd->symbols_size;
980 external_symbols_offset = gc_sd->external_symbols_offset;
981 symbol_names_data = gc_sd->symbol_names_data;
982 symbol_names_size = gc_sd->symbol_names_size;
986 section_headers_data = sd->section_headers->data();
987 section_names_size = sd->section_names_size;
988 if (sd->symbols != NULL)
989 symbols_data = sd->symbols->data();
990 symbols_size = sd->symbols_size;
991 external_symbols_offset = sd->external_symbols_offset;
992 if (sd->symbol_names != NULL)
993 symbol_names_data = sd->symbol_names->data();
994 symbol_names_size = sd->symbol_names_size;
997 // Get the section headers.
998 const unsigned char* shdrs = section_headers_data;
999 const unsigned char* pshdrs;
1001 // Get the section names.
1002 const unsigned char* pnamesu = (is_gc_or_icf)
1003 ? gc_sd->section_names_data
1004 : sd->section_names->data();
1006 const char* pnames = reinterpret_cast<const char*>(pnamesu);
1008 // If any input files have been claimed by plugins, we need to defer
1009 // actual layout until the replacement files have arrived.
1010 const bool should_defer_layout =
1011 (parameters->options().has_plugins()
1012 && parameters->options().plugins()->should_defer_layout());
1013 unsigned int num_sections_to_defer = 0;
1015 // For each section, record the index of the reloc section if any.
1016 // Use 0 to mean that there is no reloc section, -1U to mean that
1017 // there is more than one.
1018 std::vector<unsigned int> reloc_shndx(shnum, 0);
1019 std::vector<unsigned int> reloc_type(shnum, elfcpp::SHT_NULL);
1020 // Skip the first, dummy, section.
1021 pshdrs = shdrs + This::shdr_size;
1022 for (unsigned int i = 1; i < shnum; ++i, pshdrs += This::shdr_size)
1024 typename This::Shdr shdr(pshdrs);
1026 // Count the number of sections whose layout will be deferred.
1027 if (should_defer_layout && (shdr.get_sh_flags() & elfcpp::SHF_ALLOC))
1028 ++num_sections_to_defer;
1030 unsigned int sh_type = shdr.get_sh_type();
1031 if (sh_type == elfcpp::SHT_REL || sh_type == elfcpp::SHT_RELA)
1033 unsigned int target_shndx = this->adjust_shndx(shdr.get_sh_info());
1034 if (target_shndx == 0 || target_shndx >= shnum)
1036 this->error(_("relocation section %u has bad info %u"),
1041 if (reloc_shndx[target_shndx] != 0)
1042 reloc_shndx[target_shndx] = -1U;
1045 reloc_shndx[target_shndx] = i;
1046 reloc_type[target_shndx] = sh_type;
1051 Output_sections& out_sections(this->output_sections());
1052 std::vector<Address>& out_section_offsets(this->section_offsets_);
1054 if (!is_gc_pass_two)
1056 out_sections.resize(shnum);
1057 out_section_offsets.resize(shnum);
1060 // If we are only linking for symbols, then there is nothing else to
1062 if (this->input_file()->just_symbols())
1064 if (!is_gc_pass_two)
1066 delete sd->section_headers;
1067 sd->section_headers = NULL;
1068 delete sd->section_names;
1069 sd->section_names = NULL;
1074 if (num_sections_to_defer > 0)
1076 parameters->options().plugins()->add_deferred_layout_object(this);
1077 this->deferred_layout_.reserve(num_sections_to_defer);
1080 // Whether we've seen a .note.GNU-stack section.
1081 bool seen_gnu_stack = false;
1082 // The flags of a .note.GNU-stack section.
1083 uint64_t gnu_stack_flags = 0;
1085 // Keep track of which sections to omit.
1086 std::vector<bool> omit(shnum, false);
1088 // Keep track of reloc sections when emitting relocations.
1089 const bool relocatable = parameters->options().relocatable();
1090 const bool emit_relocs = (relocatable
1091 || parameters->options().emit_relocs());
1092 std::vector<unsigned int> reloc_sections;
1094 // Keep track of .eh_frame sections.
1095 std::vector<unsigned int> eh_frame_sections;
1097 // Skip the first, dummy, section.
1098 pshdrs = shdrs + This::shdr_size;
1099 for (unsigned int i = 1; i < shnum; ++i, pshdrs += This::shdr_size)
1101 typename This::Shdr shdr(pshdrs);
1103 if (shdr.get_sh_name() >= section_names_size)
1105 this->error(_("bad section name offset for section %u: %lu"),
1106 i, static_cast<unsigned long>(shdr.get_sh_name()));
1110 const char* name = pnames + shdr.get_sh_name();
1112 if (!is_gc_pass_two)
1114 if (this->handle_gnu_warning_section(name, i, symtab))
1120 // The .note.GNU-stack section is special. It gives the
1121 // protection flags that this object file requires for the stack
1123 if (strcmp(name, ".note.GNU-stack") == 0)
1125 seen_gnu_stack = true;
1126 gnu_stack_flags |= shdr.get_sh_flags();
1130 bool discard = omit[i];
1133 if (shdr.get_sh_type() == elfcpp::SHT_GROUP)
1135 if (!this->include_section_group(symtab, layout, i, name,
1141 else if ((shdr.get_sh_flags() & elfcpp::SHF_GROUP) == 0
1142 && Layout::is_linkonce(name))
1144 if (!this->include_linkonce_section(layout, i, name, shdr))
1151 // Do not include this section in the link.
1152 out_sections[i] = NULL;
1153 out_section_offsets[i] = invalid_address;
1158 if (is_gc_pass_one && parameters->options().gc_sections())
1160 if (is_section_name_included(name)
1161 || shdr.get_sh_type() == elfcpp::SHT_INIT_ARRAY
1162 || shdr.get_sh_type() == elfcpp::SHT_FINI_ARRAY)
1164 symtab->gc()->worklist().push(Section_id(this, i));
1168 // When doing a relocatable link we are going to copy input
1169 // reloc sections into the output. We only want to copy the
1170 // ones associated with sections which are not being discarded.
1171 // However, we don't know that yet for all sections. So save
1172 // reloc sections and process them later. Garbage collection is
1173 // not triggered when relocatable code is desired.
1175 && (shdr.get_sh_type() == elfcpp::SHT_REL
1176 || shdr.get_sh_type() == elfcpp::SHT_RELA))
1178 reloc_sections.push_back(i);
1182 if (relocatable && shdr.get_sh_type() == elfcpp::SHT_GROUP)
1185 // The .eh_frame section is special. It holds exception frame
1186 // information that we need to read in order to generate the
1187 // exception frame header. We process these after all the other
1188 // sections so that the exception frame reader can reliably
1189 // determine which sections are being discarded, and discard the
1190 // corresponding information.
1192 && strcmp(name, ".eh_frame") == 0
1193 && this->check_eh_frame_flags(&shdr))
1197 out_sections[i] = reinterpret_cast<Output_section*>(1);
1198 out_section_offsets[i] = invalid_address;
1201 eh_frame_sections.push_back(i);
1205 if (is_gc_pass_two && parameters->options().gc_sections())
1207 // This is executed during the second pass of garbage
1208 // collection. do_layout has been called before and some
1209 // sections have been already discarded. Simply ignore
1210 // such sections this time around.
1211 if (out_sections[i] == NULL)
1213 gold_assert(out_section_offsets[i] == invalid_address);
1216 if (((shdr.get_sh_flags() & elfcpp::SHF_ALLOC) != 0)
1217 && symtab->gc()->is_section_garbage(this, i))
1219 if (parameters->options().print_gc_sections())
1220 gold_info(_("%s: removing unused section from '%s'"
1222 program_name, this->section_name(i).c_str(),
1223 this->name().c_str());
1224 out_sections[i] = NULL;
1225 out_section_offsets[i] = invalid_address;
1230 if (is_gc_pass_two && parameters->options().icf())
1232 if (out_sections[i] == NULL)
1234 gold_assert(out_section_offsets[i] == invalid_address);
1237 if (((shdr.get_sh_flags() & elfcpp::SHF_ALLOC) != 0)
1238 && symtab->icf()->is_section_folded(this, i))
1240 if (parameters->options().print_icf_sections())
1243 symtab->icf()->get_folded_section(this, i);
1244 Relobj* folded_obj =
1245 reinterpret_cast<Relobj*>(folded.first);
1246 gold_info(_("%s: ICF folding section '%s' in file '%s'"
1247 "into '%s' in file '%s'"),
1248 program_name, this->section_name(i).c_str(),
1249 this->name().c_str(),
1250 folded_obj->section_name(folded.second).c_str(),
1251 folded_obj->name().c_str());
1253 out_sections[i] = NULL;
1254 out_section_offsets[i] = invalid_address;
1259 // Defer layout here if input files are claimed by plugins. When gc
1260 // is turned on this function is called twice. For the second call
1261 // should_defer_layout should be false.
1262 if (should_defer_layout && (shdr.get_sh_flags() & elfcpp::SHF_ALLOC))
1264 gold_assert(!is_gc_pass_two);
1265 this->deferred_layout_.push_back(Deferred_layout(i, name,
1269 // Put dummy values here; real values will be supplied by
1270 // do_layout_deferred_sections.
1271 out_sections[i] = reinterpret_cast<Output_section*>(2);
1272 out_section_offsets[i] = invalid_address;
1276 // During gc_pass_two if a section that was previously deferred is
1277 // found, do not layout the section as layout_deferred_sections will
1278 // do it later from gold.cc.
1280 && (out_sections[i] == reinterpret_cast<Output_section*>(2)))
1285 // This is during garbage collection. The out_sections are
1286 // assigned in the second call to this function.
1287 out_sections[i] = reinterpret_cast<Output_section*>(1);
1288 out_section_offsets[i] = invalid_address;
1292 // When garbage collection is switched on the actual layout
1293 // only happens in the second call.
1294 this->layout_section(layout, i, name, shdr, reloc_shndx[i],
1299 if (!is_gc_pass_one)
1300 layout->layout_gnu_stack(seen_gnu_stack, gnu_stack_flags);
1302 // When doing a relocatable link handle the reloc sections at the
1303 // end. Garbage collection and Identical Code Folding is not
1304 // turned on for relocatable code.
1306 this->size_relocatable_relocs();
1308 gold_assert(!(is_gc_or_icf) || reloc_sections.empty());
1310 for (std::vector<unsigned int>::const_iterator p = reloc_sections.begin();
1311 p != reloc_sections.end();
1314 unsigned int i = *p;
1315 const unsigned char* pshdr;
1316 pshdr = section_headers_data + i * This::shdr_size;
1317 typename This::Shdr shdr(pshdr);
1319 unsigned int data_shndx = this->adjust_shndx(shdr.get_sh_info());
1320 if (data_shndx >= shnum)
1322 // We already warned about this above.
1326 Output_section* data_section = out_sections[data_shndx];
1327 if (data_section == NULL)
1329 out_sections[i] = NULL;
1330 out_section_offsets[i] = invalid_address;
1334 Relocatable_relocs* rr = new Relocatable_relocs();
1335 this->set_relocatable_relocs(i, rr);
1337 Output_section* os = layout->layout_reloc(this, i, shdr, data_section,
1339 out_sections[i] = os;
1340 out_section_offsets[i] = invalid_address;
1343 // Handle the .eh_frame sections at the end.
1344 gold_assert(!is_gc_pass_one || eh_frame_sections.empty());
1345 for (std::vector<unsigned int>::const_iterator p = eh_frame_sections.begin();
1346 p != eh_frame_sections.end();
1349 gold_assert(this->has_eh_frame_);
1350 gold_assert(external_symbols_offset != 0);
1352 unsigned int i = *p;
1353 const unsigned char *pshdr;
1354 pshdr = section_headers_data + i * This::shdr_size;
1355 typename This::Shdr shdr(pshdr);
1358 Output_section* os = layout->layout_eh_frame(this,
1367 out_sections[i] = os;
1370 // An object can contain at most one section holding exception
1371 // frame information.
1372 gold_assert(this->discarded_eh_frame_shndx_ == -1U);
1373 this->discarded_eh_frame_shndx_ = i;
1374 out_section_offsets[i] = invalid_address;
1377 out_section_offsets[i] = convert_types<Address, off_t>(offset);
1379 // If this section requires special handling, and if there are
1380 // relocs that apply to it, then we must do the special handling
1381 // before we apply the relocs.
1382 if (offset == -1 && reloc_shndx[i] != 0)
1383 this->set_relocs_must_follow_section_writes();
1388 delete[] gc_sd->section_headers_data;
1389 delete[] gc_sd->section_names_data;
1390 delete[] gc_sd->symbols_data;
1391 delete[] gc_sd->symbol_names_data;
1392 this->set_symbols_data(NULL);
1396 delete sd->section_headers;
1397 sd->section_headers = NULL;
1398 delete sd->section_names;
1399 sd->section_names = NULL;
1403 // Layout sections whose layout was deferred while waiting for
1404 // input files from a plugin.
1406 template<int size, bool big_endian>
1408 Sized_relobj<size, big_endian>::do_layout_deferred_sections(Layout* layout)
1410 typename std::vector<Deferred_layout>::iterator deferred;
1412 for (deferred = this->deferred_layout_.begin();
1413 deferred != this->deferred_layout_.end();
1416 typename This::Shdr shdr(deferred->shdr_data_);
1417 this->layout_section(layout, deferred->shndx_, deferred->name_.c_str(),
1418 shdr, deferred->reloc_shndx_, deferred->reloc_type_);
1421 this->deferred_layout_.clear();
1424 // Add the symbols to the symbol table.
1426 template<int size, bool big_endian>
1428 Sized_relobj<size, big_endian>::do_add_symbols(Symbol_table* symtab,
1429 Read_symbols_data* sd,
1432 if (sd->symbols == NULL)
1434 gold_assert(sd->symbol_names == NULL);
1438 const int sym_size = This::sym_size;
1439 size_t symcount = ((sd->symbols_size - sd->external_symbols_offset)
1441 if (symcount * sym_size != sd->symbols_size - sd->external_symbols_offset)
1443 this->error(_("size of symbols is not multiple of symbol size"));
1447 this->symbols_.resize(symcount);
1449 const char* sym_names =
1450 reinterpret_cast<const char*>(sd->symbol_names->data());
1451 symtab->add_from_relobj(this,
1452 sd->symbols->data() + sd->external_symbols_offset,
1453 symcount, this->local_symbol_count_,
1454 sym_names, sd->symbol_names_size,
1456 &this->defined_count_);
1460 delete sd->symbol_names;
1461 sd->symbol_names = NULL;
1464 // First pass over the local symbols. Here we add their names to
1465 // *POOL and *DYNPOOL, and we store the symbol value in
1466 // THIS->LOCAL_VALUES_. This function is always called from a
1467 // singleton thread. This is followed by a call to
1468 // finalize_local_symbols.
1470 template<int size, bool big_endian>
1472 Sized_relobj<size, big_endian>::do_count_local_symbols(Stringpool* pool,
1473 Stringpool* dynpool)
1475 gold_assert(this->symtab_shndx_ != -1U);
1476 if (this->symtab_shndx_ == 0)
1478 // This object has no symbols. Weird but legal.
1482 // Read the symbol table section header.
1483 const unsigned int symtab_shndx = this->symtab_shndx_;
1484 typename This::Shdr symtabshdr(this,
1485 this->elf_file_.section_header(symtab_shndx));
1486 gold_assert(symtabshdr.get_sh_type() == elfcpp::SHT_SYMTAB);
1488 // Read the local symbols.
1489 const int sym_size = This::sym_size;
1490 const unsigned int loccount = this->local_symbol_count_;
1491 gold_assert(loccount == symtabshdr.get_sh_info());
1492 off_t locsize = loccount * sym_size;
1493 const unsigned char* psyms = this->get_view(symtabshdr.get_sh_offset(),
1494 locsize, true, true);
1496 // Read the symbol names.
1497 const unsigned int strtab_shndx =
1498 this->adjust_shndx(symtabshdr.get_sh_link());
1499 section_size_type strtab_size;
1500 const unsigned char* pnamesu = this->section_contents(strtab_shndx,
1503 const char* pnames = reinterpret_cast<const char*>(pnamesu);
1505 // Loop over the local symbols.
1507 const Output_sections& out_sections(this->output_sections());
1508 unsigned int shnum = this->shnum();
1509 unsigned int count = 0;
1510 unsigned int dyncount = 0;
1511 // Skip the first, dummy, symbol.
1513 bool discard_locals = parameters->options().discard_locals();
1514 for (unsigned int i = 1; i < loccount; ++i, psyms += sym_size)
1516 elfcpp::Sym<size, big_endian> sym(psyms);
1518 Symbol_value<size>& lv(this->local_values_[i]);
1521 unsigned int shndx = this->adjust_sym_shndx(i, sym.get_st_shndx(),
1523 lv.set_input_shndx(shndx, is_ordinary);
1525 if (sym.get_st_type() == elfcpp::STT_SECTION)
1526 lv.set_is_section_symbol();
1527 else if (sym.get_st_type() == elfcpp::STT_TLS)
1528 lv.set_is_tls_symbol();
1530 // Save the input symbol value for use in do_finalize_local_symbols().
1531 lv.set_input_value(sym.get_st_value());
1533 // Decide whether this symbol should go into the output file.
1535 if ((shndx < shnum && out_sections[shndx] == NULL)
1536 || (shndx == this->discarded_eh_frame_shndx_))
1538 lv.set_no_output_symtab_entry();
1539 gold_assert(!lv.needs_output_dynsym_entry());
1543 if (sym.get_st_type() == elfcpp::STT_SECTION)
1545 lv.set_no_output_symtab_entry();
1546 gold_assert(!lv.needs_output_dynsym_entry());
1550 if (sym.get_st_name() >= strtab_size)
1552 this->error(_("local symbol %u section name out of range: %u >= %u"),
1553 i, sym.get_st_name(),
1554 static_cast<unsigned int>(strtab_size));
1555 lv.set_no_output_symtab_entry();
1559 // If --discard-locals option is used, discard all temporary local
1560 // symbols. These symbols start with system-specific local label
1561 // prefixes, typically .L for ELF system. We want to be compatible
1562 // with GNU ld so here we essentially use the same check in
1563 // bfd_is_local_label(). The code is different because we already
1566 // - the symbol is local and thus cannot have global or weak binding.
1567 // - the symbol is not a section symbol.
1568 // - the symbol has a name.
1570 // We do not discard a symbol if it needs a dynamic symbol entry.
1571 const char* name = pnames + sym.get_st_name();
1573 && sym.get_st_type() != elfcpp::STT_FILE
1574 && !lv.needs_output_dynsym_entry()
1575 && parameters->target().is_local_label_name(name))
1577 lv.set_no_output_symtab_entry();
1581 // Add the symbol to the symbol table string pool.
1582 pool->add(name, true, NULL);
1585 // If needed, add the symbol to the dynamic symbol table string pool.
1586 if (lv.needs_output_dynsym_entry())
1588 dynpool->add(name, true, NULL);
1593 this->output_local_symbol_count_ = count;
1594 this->output_local_dynsym_count_ = dyncount;
1597 // Finalize the local symbols. Here we set the final value in
1598 // THIS->LOCAL_VALUES_ and set their output symbol table indexes.
1599 // This function is always called from a singleton thread. The actual
1600 // output of the local symbols will occur in a separate task.
1602 template<int size, bool big_endian>
1604 Sized_relobj<size, big_endian>::do_finalize_local_symbols(unsigned int index,
1606 Symbol_table* symtab)
1608 gold_assert(off == static_cast<off_t>(align_address(off, size >> 3)));
1610 const unsigned int loccount = this->local_symbol_count_;
1611 this->local_symbol_offset_ = off;
1613 const bool relocatable = parameters->options().relocatable();
1614 const Output_sections& out_sections(this->output_sections());
1615 const std::vector<Address>& out_offsets(this->section_offsets_);
1616 unsigned int shnum = this->shnum();
1618 for (unsigned int i = 1; i < loccount; ++i)
1620 Symbol_value<size>& lv(this->local_values_[i]);
1623 unsigned int shndx = lv.input_shndx(&is_ordinary);
1625 // Set the output symbol value.
1629 if (shndx == elfcpp::SHN_ABS || Symbol::is_common_shndx(shndx))
1630 lv.set_output_value(lv.input_value());
1633 this->error(_("unknown section index %u for local symbol %u"),
1635 lv.set_output_value(0);
1642 this->error(_("local symbol %u section index %u out of range"),
1647 Output_section* os = out_sections[shndx];
1648 Address secoffset = out_offsets[shndx];
1649 if (symtab->is_section_folded(this, shndx))
1651 gold_assert (os == NULL && secoffset == invalid_address);
1652 // Get the os of the section it is folded onto.
1653 Section_id folded = symtab->icf()->get_folded_section(this,
1655 gold_assert(folded.first != NULL);
1656 Sized_relobj<size, big_endian>* folded_obj = reinterpret_cast
1657 <Sized_relobj<size, big_endian>*>(folded.first);
1658 os = folded_obj->output_section(folded.second);
1659 gold_assert(os != NULL);
1660 secoffset = folded_obj->get_output_section_offset(folded.second);
1661 gold_assert(secoffset != invalid_address);
1666 // This local symbol belongs to a section we are discarding.
1667 // In some cases when applying relocations later, we will
1668 // attempt to match it to the corresponding kept section,
1669 // so we leave the input value unchanged here.
1672 else if (secoffset == invalid_address)
1676 // This is a SHF_MERGE section or one which otherwise
1677 // requires special handling.
1678 if (shndx == this->discarded_eh_frame_shndx_)
1680 // This local symbol belongs to a discarded .eh_frame
1681 // section. Just treat it like the case in which
1682 // os == NULL above.
1683 gold_assert(this->has_eh_frame_);
1686 else if (!lv.is_section_symbol())
1688 // This is not a section symbol. We can determine
1689 // the final value now.
1690 lv.set_output_value(os->output_address(this, shndx,
1693 else if (!os->find_starting_output_address(this, shndx, &start))
1695 // This is a section symbol, but apparently not one
1696 // in a merged section. Just use the start of the
1697 // output section. This happens with relocatable
1698 // links when the input object has section symbols
1699 // for arbitrary non-merge sections.
1700 lv.set_output_value(os->address());
1704 // We have to consider the addend to determine the
1705 // value to use in a relocation. START is the start
1706 // of this input section.
1707 Merged_symbol_value<size>* msv =
1708 new Merged_symbol_value<size>(lv.input_value(), start);
1709 lv.set_merged_symbol_value(msv);
1712 else if (lv.is_tls_symbol())
1713 lv.set_output_value(os->tls_offset()
1715 + lv.input_value());
1717 lv.set_output_value((relocatable ? 0 : os->address())
1719 + lv.input_value());
1722 if (lv.needs_output_symtab_entry())
1724 lv.set_output_symtab_index(index);
1731 // Set the output dynamic symbol table indexes for the local variables.
1733 template<int size, bool big_endian>
1735 Sized_relobj<size, big_endian>::do_set_local_dynsym_indexes(unsigned int index)
1737 const unsigned int loccount = this->local_symbol_count_;
1738 for (unsigned int i = 1; i < loccount; ++i)
1740 Symbol_value<size>& lv(this->local_values_[i]);
1741 if (lv.needs_output_dynsym_entry())
1743 lv.set_output_dynsym_index(index);
1750 // Set the offset where local dynamic symbol information will be stored.
1751 // Returns the count of local symbols contributed to the symbol table by
1754 template<int size, bool big_endian>
1756 Sized_relobj<size, big_endian>::do_set_local_dynsym_offset(off_t off)
1758 gold_assert(off == static_cast<off_t>(align_address(off, size >> 3)));
1759 this->local_dynsym_offset_ = off;
1760 return this->output_local_dynsym_count_;
1763 // If Symbols_data is not NULL get the section flags from here otherwise
1764 // get it from the file.
1766 template<int size, bool big_endian>
1768 Sized_relobj<size, big_endian>::do_section_flags(unsigned int shndx)
1770 Symbols_data* sd = this->get_symbols_data();
1773 const unsigned char* pshdrs = sd->section_headers_data
1774 + This::shdr_size * shndx;
1775 typename This::Shdr shdr(pshdrs);
1776 return shdr.get_sh_flags();
1778 // If sd is NULL, read the section header from the file.
1779 return this->elf_file_.section_flags(shndx);
1782 // Get the section's ent size from Symbols_data. Called by get_section_contents
1785 template<int size, bool big_endian>
1787 Sized_relobj<size, big_endian>::do_section_entsize(unsigned int shndx)
1789 Symbols_data* sd = this->get_symbols_data();
1790 gold_assert (sd != NULL);
1792 const unsigned char* pshdrs = sd->section_headers_data
1793 + This::shdr_size * shndx;
1794 typename This::Shdr shdr(pshdrs);
1795 return shdr.get_sh_entsize();
1799 // Write out the local symbols.
1801 template<int size, bool big_endian>
1803 Sized_relobj<size, big_endian>::write_local_symbols(
1805 const Stringpool* sympool,
1806 const Stringpool* dynpool,
1807 Output_symtab_xindex* symtab_xindex,
1808 Output_symtab_xindex* dynsym_xindex)
1810 const bool strip_all = parameters->options().strip_all();
1813 if (this->output_local_dynsym_count_ == 0)
1815 this->output_local_symbol_count_ = 0;
1818 gold_assert(this->symtab_shndx_ != -1U);
1819 if (this->symtab_shndx_ == 0)
1821 // This object has no symbols. Weird but legal.
1825 // Read the symbol table section header.
1826 const unsigned int symtab_shndx = this->symtab_shndx_;
1827 typename This::Shdr symtabshdr(this,
1828 this->elf_file_.section_header(symtab_shndx));
1829 gold_assert(symtabshdr.get_sh_type() == elfcpp::SHT_SYMTAB);
1830 const unsigned int loccount = this->local_symbol_count_;
1831 gold_assert(loccount == symtabshdr.get_sh_info());
1833 // Read the local symbols.
1834 const int sym_size = This::sym_size;
1835 off_t locsize = loccount * sym_size;
1836 const unsigned char* psyms = this->get_view(symtabshdr.get_sh_offset(),
1837 locsize, true, false);
1839 // Read the symbol names.
1840 const unsigned int strtab_shndx =
1841 this->adjust_shndx(symtabshdr.get_sh_link());
1842 section_size_type strtab_size;
1843 const unsigned char* pnamesu = this->section_contents(strtab_shndx,
1846 const char* pnames = reinterpret_cast<const char*>(pnamesu);
1848 // Get views into the output file for the portions of the symbol table
1849 // and the dynamic symbol table that we will be writing.
1850 off_t output_size = this->output_local_symbol_count_ * sym_size;
1851 unsigned char* oview = NULL;
1852 if (output_size > 0)
1853 oview = of->get_output_view(this->local_symbol_offset_, output_size);
1855 off_t dyn_output_size = this->output_local_dynsym_count_ * sym_size;
1856 unsigned char* dyn_oview = NULL;
1857 if (dyn_output_size > 0)
1858 dyn_oview = of->get_output_view(this->local_dynsym_offset_,
1861 const Output_sections out_sections(this->output_sections());
1863 gold_assert(this->local_values_.size() == loccount);
1865 unsigned char* ov = oview;
1866 unsigned char* dyn_ov = dyn_oview;
1868 for (unsigned int i = 1; i < loccount; ++i, psyms += sym_size)
1870 elfcpp::Sym<size, big_endian> isym(psyms);
1872 Symbol_value<size>& lv(this->local_values_[i]);
1875 unsigned int st_shndx = this->adjust_sym_shndx(i, isym.get_st_shndx(),
1879 gold_assert(st_shndx < out_sections.size());
1880 if (out_sections[st_shndx] == NULL)
1882 st_shndx = out_sections[st_shndx]->out_shndx();
1883 if (st_shndx >= elfcpp::SHN_LORESERVE)
1885 if (lv.needs_output_symtab_entry() && !strip_all)
1886 symtab_xindex->add(lv.output_symtab_index(), st_shndx);
1887 if (lv.needs_output_dynsym_entry())
1888 dynsym_xindex->add(lv.output_dynsym_index(), st_shndx);
1889 st_shndx = elfcpp::SHN_XINDEX;
1893 // Write the symbol to the output symbol table.
1894 if (!strip_all && lv.needs_output_symtab_entry())
1896 elfcpp::Sym_write<size, big_endian> osym(ov);
1898 gold_assert(isym.get_st_name() < strtab_size);
1899 const char* name = pnames + isym.get_st_name();
1900 osym.put_st_name(sympool->get_offset(name));
1901 osym.put_st_value(this->local_values_[i].value(this, 0));
1902 osym.put_st_size(isym.get_st_size());
1903 osym.put_st_info(isym.get_st_info());
1904 osym.put_st_other(isym.get_st_other());
1905 osym.put_st_shndx(st_shndx);
1910 // Write the symbol to the output dynamic symbol table.
1911 if (lv.needs_output_dynsym_entry())
1913 gold_assert(dyn_ov < dyn_oview + dyn_output_size);
1914 elfcpp::Sym_write<size, big_endian> osym(dyn_ov);
1916 gold_assert(isym.get_st_name() < strtab_size);
1917 const char* name = pnames + isym.get_st_name();
1918 osym.put_st_name(dynpool->get_offset(name));
1919 osym.put_st_value(this->local_values_[i].value(this, 0));
1920 osym.put_st_size(isym.get_st_size());
1921 osym.put_st_info(isym.get_st_info());
1922 osym.put_st_other(isym.get_st_other());
1923 osym.put_st_shndx(st_shndx);
1930 if (output_size > 0)
1932 gold_assert(ov - oview == output_size);
1933 of->write_output_view(this->local_symbol_offset_, output_size, oview);
1936 if (dyn_output_size > 0)
1938 gold_assert(dyn_ov - dyn_oview == dyn_output_size);
1939 of->write_output_view(this->local_dynsym_offset_, dyn_output_size,
1944 // Set *INFO to symbolic information about the offset OFFSET in the
1945 // section SHNDX. Return true if we found something, false if we
1948 template<int size, bool big_endian>
1950 Sized_relobj<size, big_endian>::get_symbol_location_info(
1953 Symbol_location_info* info)
1955 if (this->symtab_shndx_ == 0)
1958 section_size_type symbols_size;
1959 const unsigned char* symbols = this->section_contents(this->symtab_shndx_,
1963 unsigned int symbol_names_shndx =
1964 this->adjust_shndx(this->section_link(this->symtab_shndx_));
1965 section_size_type names_size;
1966 const unsigned char* symbol_names_u =
1967 this->section_contents(symbol_names_shndx, &names_size, false);
1968 const char* symbol_names = reinterpret_cast<const char*>(symbol_names_u);
1970 const int sym_size = This::sym_size;
1971 const size_t count = symbols_size / sym_size;
1973 const unsigned char* p = symbols;
1974 for (size_t i = 0; i < count; ++i, p += sym_size)
1976 elfcpp::Sym<size, big_endian> sym(p);
1978 if (sym.get_st_type() == elfcpp::STT_FILE)
1980 if (sym.get_st_name() >= names_size)
1981 info->source_file = "(invalid)";
1983 info->source_file = symbol_names + sym.get_st_name();
1988 unsigned int st_shndx = this->adjust_sym_shndx(i, sym.get_st_shndx(),
1991 && st_shndx == shndx
1992 && static_cast<off_t>(sym.get_st_value()) <= offset
1993 && (static_cast<off_t>(sym.get_st_value() + sym.get_st_size())
1996 if (sym.get_st_name() > names_size)
1997 info->enclosing_symbol_name = "(invalid)";
2000 info->enclosing_symbol_name = symbol_names + sym.get_st_name();
2001 if (parameters->options().do_demangle())
2003 char* demangled_name = cplus_demangle(
2004 info->enclosing_symbol_name.c_str(),
2005 DMGL_ANSI | DMGL_PARAMS);
2006 if (demangled_name != NULL)
2008 info->enclosing_symbol_name.assign(demangled_name);
2009 free(demangled_name);
2020 // Look for a kept section corresponding to the given discarded section,
2021 // and return its output address. This is used only for relocations in
2022 // debugging sections. If we can't find the kept section, return 0.
2024 template<int size, bool big_endian>
2025 typename Sized_relobj<size, big_endian>::Address
2026 Sized_relobj<size, big_endian>::map_to_kept_section(
2030 Relobj* kept_object;
2031 unsigned int kept_shndx;
2032 if (this->get_kept_comdat_section(shndx, &kept_object, &kept_shndx))
2034 Sized_relobj<size, big_endian>* kept_relobj =
2035 static_cast<Sized_relobj<size, big_endian>*>(kept_object);
2036 Output_section* os = kept_relobj->output_section(kept_shndx);
2037 Address offset = kept_relobj->get_output_section_offset(kept_shndx);
2038 if (os != NULL && offset != invalid_address)
2041 return os->address() + offset;
2048 // Get symbol counts.
2050 template<int size, bool big_endian>
2052 Sized_relobj<size, big_endian>::do_get_global_symbol_counts(
2053 const Symbol_table*,
2057 *defined = this->defined_count_;
2059 for (Symbols::const_iterator p = this->symbols_.begin();
2060 p != this->symbols_.end();
2063 && (*p)->source() == Symbol::FROM_OBJECT
2064 && (*p)->object() == this
2065 && (*p)->is_defined())
2070 // Input_objects methods.
2072 // Add a regular relocatable object to the list. Return false if this
2073 // object should be ignored.
2076 Input_objects::add_object(Object* obj)
2078 // Set the global target from the first object file we recognize.
2079 Target* target = obj->target();
2080 if (!parameters->target_valid())
2081 set_parameters_target(target);
2082 else if (target != ¶meters->target())
2084 obj->error(_("incompatible target"));
2088 // Print the filename if the -t/--trace option is selected.
2089 if (parameters->options().trace())
2090 gold_info("%s", obj->name().c_str());
2092 if (!obj->is_dynamic())
2093 this->relobj_list_.push_back(static_cast<Relobj*>(obj));
2096 // See if this is a duplicate SONAME.
2097 Dynobj* dynobj = static_cast<Dynobj*>(obj);
2098 const char* soname = dynobj->soname();
2100 std::pair<Unordered_set<std::string>::iterator, bool> ins =
2101 this->sonames_.insert(soname);
2104 // We have already seen a dynamic object with this soname.
2108 this->dynobj_list_.push_back(dynobj);
2111 // Add this object to the cross-referencer if requested.
2112 if (parameters->options().user_set_print_symbol_counts())
2114 if (this->cref_ == NULL)
2115 this->cref_ = new Cref();
2116 this->cref_->add_object(obj);
2122 // For each dynamic object, record whether we've seen all of its
2123 // explicit dependencies.
2126 Input_objects::check_dynamic_dependencies() const
2128 for (Dynobj_list::const_iterator p = this->dynobj_list_.begin();
2129 p != this->dynobj_list_.end();
2132 const Dynobj::Needed& needed((*p)->needed());
2133 bool found_all = true;
2134 for (Dynobj::Needed::const_iterator pneeded = needed.begin();
2135 pneeded != needed.end();
2138 if (this->sonames_.find(*pneeded) == this->sonames_.end())
2144 (*p)->set_has_unknown_needed_entries(!found_all);
2148 // Start processing an archive.
2151 Input_objects::archive_start(Archive* archive)
2153 if (parameters->options().user_set_print_symbol_counts())
2155 if (this->cref_ == NULL)
2156 this->cref_ = new Cref();
2157 this->cref_->add_archive_start(archive);
2161 // Stop processing an archive.
2164 Input_objects::archive_stop(Archive* archive)
2166 if (parameters->options().user_set_print_symbol_counts())
2167 this->cref_->add_archive_stop(archive);
2170 // Print symbol counts
2173 Input_objects::print_symbol_counts(const Symbol_table* symtab) const
2175 if (parameters->options().user_set_print_symbol_counts()
2176 && this->cref_ != NULL)
2177 this->cref_->print_symbol_counts(symtab);
2180 // Relocate_info methods.
2182 // Return a string describing the location of a relocation. This is
2183 // only used in error messages.
2185 template<int size, bool big_endian>
2187 Relocate_info<size, big_endian>::location(size_t, off_t offset) const
2189 // See if we can get line-number information from debugging sections.
2190 std::string filename;
2191 std::string file_and_lineno; // Better than filename-only, if available.
2193 Sized_dwarf_line_info<size, big_endian> line_info(this->object);
2194 // This will be "" if we failed to parse the debug info for any reason.
2195 file_and_lineno = line_info.addr2line(this->data_shndx, offset);
2197 std::string ret(this->object->name());
2199 Symbol_location_info info;
2200 if (this->object->get_symbol_location_info(this->data_shndx, offset, &info))
2202 ret += " in function ";
2203 ret += info.enclosing_symbol_name;
2205 filename = info.source_file;
2208 if (!file_and_lineno.empty())
2209 ret += file_and_lineno;
2212 if (!filename.empty())
2215 ret += this->object->section_name(this->data_shndx);
2217 // Offsets into sections have to be positive.
2218 snprintf(buf, sizeof(buf), "+0x%lx", static_cast<long>(offset));
2225 } // End namespace gold.
2230 using namespace gold;
2232 // Read an ELF file with the header and return the appropriate
2233 // instance of Object.
2235 template<int size, bool big_endian>
2237 make_elf_sized_object(const std::string& name, Input_file* input_file,
2238 off_t offset, const elfcpp::Ehdr<size, big_endian>& ehdr)
2240 int et = ehdr.get_e_type();
2241 if (et == elfcpp::ET_REL)
2243 Sized_relobj<size, big_endian>* obj =
2244 new Sized_relobj<size, big_endian>(name, input_file, offset, ehdr);
2248 else if (et == elfcpp::ET_DYN)
2250 Sized_dynobj<size, big_endian>* obj =
2251 new Sized_dynobj<size, big_endian>(name, input_file, offset, ehdr);
2257 gold_error(_("%s: unsupported ELF file type %d"),
2263 } // End anonymous namespace.
2268 // Return whether INPUT_FILE is an ELF object.
2271 is_elf_object(Input_file* input_file, off_t offset,
2272 const unsigned char** start, int *read_size)
2274 off_t filesize = input_file->file().filesize();
2275 int want = elfcpp::Elf_sizes<64>::ehdr_size;
2276 if (filesize - offset < want)
2277 want = filesize - offset;
2279 const unsigned char* p = input_file->file().get_view(offset, 0, want,
2287 static unsigned char elfmagic[4] =
2289 elfcpp::ELFMAG0, elfcpp::ELFMAG1,
2290 elfcpp::ELFMAG2, elfcpp::ELFMAG3
2292 return memcmp(p, elfmagic, 4) == 0;
2295 // Read an ELF file and return the appropriate instance of Object.
2298 make_elf_object(const std::string& name, Input_file* input_file, off_t offset,
2299 const unsigned char* p, section_offset_type bytes,
2300 bool* punconfigured)
2302 if (punconfigured != NULL)
2303 *punconfigured = false;
2305 if (bytes < elfcpp::EI_NIDENT)
2307 gold_error(_("%s: ELF file too short"), name.c_str());
2311 int v = p[elfcpp::EI_VERSION];
2312 if (v != elfcpp::EV_CURRENT)
2314 if (v == elfcpp::EV_NONE)
2315 gold_error(_("%s: invalid ELF version 0"), name.c_str());
2317 gold_error(_("%s: unsupported ELF version %d"), name.c_str(), v);
2321 int c = p[elfcpp::EI_CLASS];
2322 if (c == elfcpp::ELFCLASSNONE)
2324 gold_error(_("%s: invalid ELF class 0"), name.c_str());
2327 else if (c != elfcpp::ELFCLASS32
2328 && c != elfcpp::ELFCLASS64)
2330 gold_error(_("%s: unsupported ELF class %d"), name.c_str(), c);
2334 int d = p[elfcpp::EI_DATA];
2335 if (d == elfcpp::ELFDATANONE)
2337 gold_error(_("%s: invalid ELF data encoding"), name.c_str());
2340 else if (d != elfcpp::ELFDATA2LSB
2341 && d != elfcpp::ELFDATA2MSB)
2343 gold_error(_("%s: unsupported ELF data encoding %d"), name.c_str(), d);
2347 bool big_endian = d == elfcpp::ELFDATA2MSB;
2349 if (c == elfcpp::ELFCLASS32)
2351 if (bytes < elfcpp::Elf_sizes<32>::ehdr_size)
2353 gold_error(_("%s: ELF file too short"), name.c_str());
2358 #ifdef HAVE_TARGET_32_BIG
2359 elfcpp::Ehdr<32, true> ehdr(p);
2360 return make_elf_sized_object<32, true>(name, input_file,
2363 if (punconfigured != NULL)
2364 *punconfigured = true;
2366 gold_error(_("%s: not configured to support "
2367 "32-bit big-endian object"),
2374 #ifdef HAVE_TARGET_32_LITTLE
2375 elfcpp::Ehdr<32, false> ehdr(p);
2376 return make_elf_sized_object<32, false>(name, input_file,
2379 if (punconfigured != NULL)
2380 *punconfigured = true;
2382 gold_error(_("%s: not configured to support "
2383 "32-bit little-endian object"),
2391 if (bytes < elfcpp::Elf_sizes<64>::ehdr_size)
2393 gold_error(_("%s: ELF file too short"), name.c_str());
2398 #ifdef HAVE_TARGET_64_BIG
2399 elfcpp::Ehdr<64, true> ehdr(p);
2400 return make_elf_sized_object<64, true>(name, input_file,
2403 if (punconfigured != NULL)
2404 *punconfigured = true;
2406 gold_error(_("%s: not configured to support "
2407 "64-bit big-endian object"),
2414 #ifdef HAVE_TARGET_64_LITTLE
2415 elfcpp::Ehdr<64, false> ehdr(p);
2416 return make_elf_sized_object<64, false>(name, input_file,
2419 if (punconfigured != NULL)
2420 *punconfigured = true;
2422 gold_error(_("%s: not configured to support "
2423 "64-bit little-endian object"),
2431 // Instantiate the templates we need.
2433 #ifdef HAVE_TARGET_32_LITTLE
2436 Object::read_section_data<32, false>(elfcpp::Elf_file<32, false, Object>*,
2437 Read_symbols_data*);
2440 #ifdef HAVE_TARGET_32_BIG
2443 Object::read_section_data<32, true>(elfcpp::Elf_file<32, true, Object>*,
2444 Read_symbols_data*);
2447 #ifdef HAVE_TARGET_64_LITTLE
2450 Object::read_section_data<64, false>(elfcpp::Elf_file<64, false, Object>*,
2451 Read_symbols_data*);
2454 #ifdef HAVE_TARGET_64_BIG
2457 Object::read_section_data<64, true>(elfcpp::Elf_file<64, true, Object>*,
2458 Read_symbols_data*);
2461 #ifdef HAVE_TARGET_32_LITTLE
2463 class Sized_relobj<32, false>;
2466 #ifdef HAVE_TARGET_32_BIG
2468 class Sized_relobj<32, true>;
2471 #ifdef HAVE_TARGET_64_LITTLE
2473 class Sized_relobj<64, false>;
2476 #ifdef HAVE_TARGET_64_BIG
2478 class Sized_relobj<64, true>;
2481 #ifdef HAVE_TARGET_32_LITTLE
2483 struct Relocate_info<32, false>;
2486 #ifdef HAVE_TARGET_32_BIG
2488 struct Relocate_info<32, true>;
2491 #ifdef HAVE_TARGET_64_LITTLE
2493 struct Relocate_info<64, false>;
2496 #ifdef HAVE_TARGET_64_BIG
2498 struct Relocate_info<64, true>;
2501 } // End namespace gold.