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"
46 // Struct Read_symbols_data.
48 // Destroy any remaining File_view objects.
50 Read_symbols_data::~Read_symbols_data()
52 if (this->section_headers != NULL)
53 delete this->section_headers;
54 if (this->section_names != NULL)
55 delete this->section_names;
56 if (this->symbols != NULL)
58 if (this->symbol_names != NULL)
59 delete this->symbol_names;
60 if (this->versym != NULL)
62 if (this->verdef != NULL)
64 if (this->verneed != NULL)
70 // Initialize the symtab_xindex_ array. Find the SHT_SYMTAB_SHNDX
71 // section and read it in. SYMTAB_SHNDX is the index of the symbol
72 // table we care about.
74 template<int size, bool big_endian>
76 Xindex::initialize_symtab_xindex(Object* object, unsigned int symtab_shndx)
78 if (!this->symtab_xindex_.empty())
81 gold_assert(symtab_shndx != 0);
83 // Look through the sections in reverse order, on the theory that it
84 // is more likely to be near the end than the beginning.
85 unsigned int i = object->shnum();
89 if (object->section_type(i) == elfcpp::SHT_SYMTAB_SHNDX
90 && this->adjust_shndx(object->section_link(i)) == symtab_shndx)
92 this->read_symtab_xindex<size, big_endian>(object, i, NULL);
97 object->error(_("missing SHT_SYMTAB_SHNDX section"));
100 // Read in the symtab_xindex_ array, given the section index of the
101 // SHT_SYMTAB_SHNDX section. If PSHDRS is not NULL, it points at the
104 template<int size, bool big_endian>
106 Xindex::read_symtab_xindex(Object* object, unsigned int xindex_shndx,
107 const unsigned char* pshdrs)
109 section_size_type bytecount;
110 const unsigned char* contents;
112 contents = object->section_contents(xindex_shndx, &bytecount, false);
115 const unsigned char* p = (pshdrs
117 * elfcpp::Elf_sizes<size>::shdr_size));
118 typename elfcpp::Shdr<size, big_endian> shdr(p);
119 bytecount = convert_to_section_size_type(shdr.get_sh_size());
120 contents = object->get_view(shdr.get_sh_offset(), bytecount, true, false);
123 gold_assert(this->symtab_xindex_.empty());
124 this->symtab_xindex_.reserve(bytecount / 4);
125 for (section_size_type i = 0; i < bytecount; i += 4)
127 unsigned int shndx = elfcpp::Swap<32, big_endian>::readval(contents + i);
128 // We preadjust the section indexes we save.
129 this->symtab_xindex_.push_back(this->adjust_shndx(shndx));
133 // Symbol symndx has a section of SHN_XINDEX; return the real section
137 Xindex::sym_xindex_to_shndx(Object* object, unsigned int symndx)
139 if (symndx >= this->symtab_xindex_.size())
141 object->error(_("symbol %u out of range for SHT_SYMTAB_SHNDX section"),
143 return elfcpp::SHN_UNDEF;
145 unsigned int shndx = this->symtab_xindex_[symndx];
146 if (shndx < elfcpp::SHN_LORESERVE || shndx >= object->shnum())
148 object->error(_("extended index for symbol %u out of range: %u"),
150 return elfcpp::SHN_UNDEF;
157 // Report an error for this object file. This is used by the
158 // elfcpp::Elf_file interface, and also called by the Object code
162 Object::error(const char* format, ...) const
165 va_start(args, format);
167 if (vasprintf(&buf, format, args) < 0)
170 gold_error(_("%s: %s"), this->name().c_str(), buf);
174 // Return a view of the contents of a section.
177 Object::section_contents(unsigned int shndx, section_size_type* plen,
180 Location loc(this->do_section_contents(shndx));
181 *plen = convert_to_section_size_type(loc.data_size);
184 static const unsigned char empty[1] = { '\0' };
187 return this->get_view(loc.file_offset, *plen, true, cache);
190 // Read the section data into SD. This is code common to Sized_relobj
191 // and Sized_dynobj, so we put it into Object.
193 template<int size, bool big_endian>
195 Object::read_section_data(elfcpp::Elf_file<size, big_endian, Object>* elf_file,
196 Read_symbols_data* sd)
198 const int shdr_size = elfcpp::Elf_sizes<size>::shdr_size;
200 // Read the section headers.
201 const off_t shoff = elf_file->shoff();
202 const unsigned int shnum = this->shnum();
203 sd->section_headers = this->get_lasting_view(shoff, shnum * shdr_size,
206 // Read the section names.
207 const unsigned char* pshdrs = sd->section_headers->data();
208 const unsigned char* pshdrnames = pshdrs + elf_file->shstrndx() * shdr_size;
209 typename elfcpp::Shdr<size, big_endian> shdrnames(pshdrnames);
211 if (shdrnames.get_sh_type() != elfcpp::SHT_STRTAB)
212 this->error(_("section name section has wrong type: %u"),
213 static_cast<unsigned int>(shdrnames.get_sh_type()));
215 sd->section_names_size =
216 convert_to_section_size_type(shdrnames.get_sh_size());
217 sd->section_names = this->get_lasting_view(shdrnames.get_sh_offset(),
218 sd->section_names_size, false,
222 // If NAME is the name of a special .gnu.warning section, arrange for
223 // the warning to be issued. SHNDX is the section index. Return
224 // whether it is a warning section.
227 Object::handle_gnu_warning_section(const char* name, unsigned int shndx,
228 Symbol_table* symtab)
230 const char warn_prefix[] = ".gnu.warning.";
231 const int warn_prefix_len = sizeof warn_prefix - 1;
232 if (strncmp(name, warn_prefix, warn_prefix_len) == 0)
234 // Read the section contents to get the warning text. It would
235 // be nicer if we only did this if we have to actually issue a
236 // warning. Unfortunately, warnings are issued as we relocate
237 // sections. That means that we can not lock the object then,
238 // as we might try to issue the same warning multiple times
240 section_size_type len;
241 const unsigned char* contents = this->section_contents(shndx, &len,
245 const char* warning = name + warn_prefix_len;
246 contents = reinterpret_cast<const unsigned char*>(warning);
247 len = strlen(warning);
249 std::string warning(reinterpret_cast<const char*>(contents), len);
250 symtab->add_warning(name + warn_prefix_len, this, warning);
256 // If NAME is the name of the special section which indicates that
257 // this object was compiled with -fstack-split, mark it accordingly.
260 Object::handle_split_stack_section(const char* name)
262 if (strcmp(name, ".note.GNU-split-stack") == 0)
264 this->uses_split_stack_ = true;
267 if (strcmp(name, ".note.GNU-no-split-stack") == 0)
269 this->has_no_split_stack_ = true;
277 // To copy the symbols data read from the file to a local data structure.
278 // This function is called from do_layout only while doing garbage
282 Relobj::copy_symbols_data(Symbols_data* gc_sd, Read_symbols_data* sd,
283 unsigned int section_header_size)
285 gc_sd->section_headers_data =
286 new unsigned char[(section_header_size)];
287 memcpy(gc_sd->section_headers_data, sd->section_headers->data(),
288 section_header_size);
289 gc_sd->section_names_data =
290 new unsigned char[sd->section_names_size];
291 memcpy(gc_sd->section_names_data, sd->section_names->data(),
292 sd->section_names_size);
293 gc_sd->section_names_size = sd->section_names_size;
294 if (sd->symbols != NULL)
296 gc_sd->symbols_data =
297 new unsigned char[sd->symbols_size];
298 memcpy(gc_sd->symbols_data, sd->symbols->data(),
303 gc_sd->symbols_data = NULL;
305 gc_sd->symbols_size = sd->symbols_size;
306 gc_sd->external_symbols_offset = sd->external_symbols_offset;
307 if (sd->symbol_names != NULL)
309 gc_sd->symbol_names_data =
310 new unsigned char[sd->symbol_names_size];
311 memcpy(gc_sd->symbol_names_data, sd->symbol_names->data(),
312 sd->symbol_names_size);
316 gc_sd->symbol_names_data = NULL;
318 gc_sd->symbol_names_size = sd->symbol_names_size;
321 // This function determines if a particular section name must be included
322 // in the link. This is used during garbage collection to determine the
323 // roots of the worklist.
326 Relobj::is_section_name_included(const char* name)
328 if (is_prefix_of(".ctors", name)
329 || is_prefix_of(".dtors", name)
330 || is_prefix_of(".note", name)
331 || is_prefix_of(".init", name)
332 || is_prefix_of(".fini", name)
333 || is_prefix_of(".gcc_except_table", name)
334 || is_prefix_of(".jcr", name)
335 || is_prefix_of(".preinit_array", name)
336 || (is_prefix_of(".text", name)
337 && strstr(name, "personality"))
338 || (is_prefix_of(".data", name)
339 && strstr(name, "personality"))
340 || (is_prefix_of(".gnu.linkonce.d", name)
341 && strstr(name, "personality")))
348 // Class Sized_relobj.
350 template<int size, bool big_endian>
351 Sized_relobj<size, big_endian>::Sized_relobj(
352 const std::string& name,
353 Input_file* input_file,
355 const elfcpp::Ehdr<size, big_endian>& ehdr)
356 : Relobj(name, input_file, offset),
357 elf_file_(this, ehdr),
359 local_symbol_count_(0),
360 output_local_symbol_count_(0),
361 output_local_dynsym_count_(0),
364 local_symbol_offset_(0),
365 local_dynsym_offset_(0),
367 local_got_offsets_(),
368 kept_comdat_sections_(),
369 has_eh_frame_(false),
370 discarded_eh_frame_shndx_(-1U)
374 template<int size, bool big_endian>
375 Sized_relobj<size, big_endian>::~Sized_relobj()
379 // Set up an object file based on the file header. This sets up the
380 // section information.
382 template<int size, bool big_endian>
384 Sized_relobj<size, big_endian>::do_setup()
386 const unsigned int shnum = this->elf_file_.shnum();
387 this->set_shnum(shnum);
390 // Find the SHT_SYMTAB section, given the section headers. The ELF
391 // standard says that maybe in the future there can be more than one
392 // SHT_SYMTAB section. Until somebody figures out how that could
393 // work, we assume there is only one.
395 template<int size, bool big_endian>
397 Sized_relobj<size, big_endian>::find_symtab(const unsigned char* pshdrs)
399 const unsigned int shnum = this->shnum();
400 this->symtab_shndx_ = 0;
403 // Look through the sections in reverse order, since gas tends
404 // to put the symbol table at the end.
405 const unsigned char* p = pshdrs + shnum * This::shdr_size;
406 unsigned int i = shnum;
407 unsigned int xindex_shndx = 0;
408 unsigned int xindex_link = 0;
412 p -= This::shdr_size;
413 typename This::Shdr shdr(p);
414 if (shdr.get_sh_type() == elfcpp::SHT_SYMTAB)
416 this->symtab_shndx_ = i;
417 if (xindex_shndx > 0 && xindex_link == i)
420 new Xindex(this->elf_file_.large_shndx_offset());
421 xindex->read_symtab_xindex<size, big_endian>(this,
424 this->set_xindex(xindex);
429 // Try to pick up the SHT_SYMTAB_SHNDX section, if there is
430 // one. This will work if it follows the SHT_SYMTAB
432 if (shdr.get_sh_type() == elfcpp::SHT_SYMTAB_SHNDX)
435 xindex_link = this->adjust_shndx(shdr.get_sh_link());
441 // Return the Xindex structure to use for object with lots of
444 template<int size, bool big_endian>
446 Sized_relobj<size, big_endian>::do_initialize_xindex()
448 gold_assert(this->symtab_shndx_ != -1U);
449 Xindex* xindex = new Xindex(this->elf_file_.large_shndx_offset());
450 xindex->initialize_symtab_xindex<size, big_endian>(this, this->symtab_shndx_);
454 // Return whether SHDR has the right type and flags to be a GNU
455 // .eh_frame section.
457 template<int size, bool big_endian>
459 Sized_relobj<size, big_endian>::check_eh_frame_flags(
460 const elfcpp::Shdr<size, big_endian>* shdr) const
462 return (shdr->get_sh_type() == elfcpp::SHT_PROGBITS
463 && (shdr->get_sh_flags() & elfcpp::SHF_ALLOC) != 0);
466 // Return whether there is a GNU .eh_frame section, given the section
467 // headers and the section names.
469 template<int size, bool big_endian>
471 Sized_relobj<size, big_endian>::find_eh_frame(
472 const unsigned char* pshdrs,
474 section_size_type names_size) const
476 const unsigned int shnum = this->shnum();
477 const unsigned char* p = pshdrs + This::shdr_size;
478 for (unsigned int i = 1; i < shnum; ++i, p += This::shdr_size)
480 typename This::Shdr shdr(p);
481 if (this->check_eh_frame_flags(&shdr))
483 if (shdr.get_sh_name() >= names_size)
485 this->error(_("bad section name offset for section %u: %lu"),
486 i, static_cast<unsigned long>(shdr.get_sh_name()));
490 const char* name = names + shdr.get_sh_name();
491 if (strcmp(name, ".eh_frame") == 0)
498 // Read the sections and symbols from an object file.
500 template<int size, bool big_endian>
502 Sized_relobj<size, big_endian>::do_read_symbols(Read_symbols_data* sd)
504 this->read_section_data(&this->elf_file_, sd);
506 const unsigned char* const pshdrs = sd->section_headers->data();
508 this->find_symtab(pshdrs);
510 const unsigned char* namesu = sd->section_names->data();
511 const char* names = reinterpret_cast<const char*>(namesu);
512 if (memmem(names, sd->section_names_size, ".eh_frame", 10) != NULL)
514 if (this->find_eh_frame(pshdrs, names, sd->section_names_size))
515 this->has_eh_frame_ = true;
519 sd->symbols_size = 0;
520 sd->external_symbols_offset = 0;
521 sd->symbol_names = NULL;
522 sd->symbol_names_size = 0;
524 if (this->symtab_shndx_ == 0)
526 // No symbol table. Weird but legal.
530 // Get the symbol table section header.
531 typename This::Shdr symtabshdr(pshdrs
532 + this->symtab_shndx_ * This::shdr_size);
533 gold_assert(symtabshdr.get_sh_type() == elfcpp::SHT_SYMTAB);
535 // If this object has a .eh_frame section, we need all the symbols.
536 // Otherwise we only need the external symbols. While it would be
537 // simpler to just always read all the symbols, I've seen object
538 // files with well over 2000 local symbols, which for a 64-bit
539 // object file format is over 5 pages that we don't need to read
542 const int sym_size = This::sym_size;
543 const unsigned int loccount = symtabshdr.get_sh_info();
544 this->local_symbol_count_ = loccount;
545 this->local_values_.resize(loccount);
546 section_offset_type locsize = loccount * sym_size;
547 off_t dataoff = symtabshdr.get_sh_offset();
548 section_size_type datasize =
549 convert_to_section_size_type(symtabshdr.get_sh_size());
550 off_t extoff = dataoff + locsize;
551 section_size_type extsize = datasize - locsize;
553 off_t readoff = this->has_eh_frame_ ? dataoff : extoff;
554 section_size_type readsize = this->has_eh_frame_ ? datasize : extsize;
558 // No external symbols. Also weird but also legal.
562 File_view* fvsymtab = this->get_lasting_view(readoff, readsize, true, false);
564 // Read the section header for the symbol names.
565 unsigned int strtab_shndx = this->adjust_shndx(symtabshdr.get_sh_link());
566 if (strtab_shndx >= this->shnum())
568 this->error(_("invalid symbol table name index: %u"), strtab_shndx);
571 typename This::Shdr strtabshdr(pshdrs + strtab_shndx * This::shdr_size);
572 if (strtabshdr.get_sh_type() != elfcpp::SHT_STRTAB)
574 this->error(_("symbol table name section has wrong type: %u"),
575 static_cast<unsigned int>(strtabshdr.get_sh_type()));
579 // Read the symbol names.
580 File_view* fvstrtab = this->get_lasting_view(strtabshdr.get_sh_offset(),
581 strtabshdr.get_sh_size(),
584 sd->symbols = fvsymtab;
585 sd->symbols_size = readsize;
586 sd->external_symbols_offset = this->has_eh_frame_ ? locsize : 0;
587 sd->symbol_names = fvstrtab;
588 sd->symbol_names_size =
589 convert_to_section_size_type(strtabshdr.get_sh_size());
592 // Return the section index of symbol SYM. Set *VALUE to its value in
593 // the object file. Set *IS_ORDINARY if this is an ordinary section
594 // index. not a special cod between SHN_LORESERVE and SHN_HIRESERVE.
595 // Note that for a symbol which is not defined in this object file,
596 // this will set *VALUE to 0 and return SHN_UNDEF; it will not return
597 // the final value of the symbol in the link.
599 template<int size, bool big_endian>
601 Sized_relobj<size, big_endian>::symbol_section_and_value(unsigned int sym,
605 section_size_type symbols_size;
606 const unsigned char* symbols = this->section_contents(this->symtab_shndx_,
610 const size_t count = symbols_size / This::sym_size;
611 gold_assert(sym < count);
613 elfcpp::Sym<size, big_endian> elfsym(symbols + sym * This::sym_size);
614 *value = elfsym.get_st_value();
616 return this->adjust_sym_shndx(sym, elfsym.get_st_shndx(), is_ordinary);
619 // Return whether to include a section group in the link. LAYOUT is
620 // used to keep track of which section groups we have already seen.
621 // INDEX is the index of the section group and SHDR is the section
622 // header. If we do not want to include this group, we set bits in
623 // OMIT for each section which should be discarded.
625 template<int size, bool big_endian>
627 Sized_relobj<size, big_endian>::include_section_group(
628 Symbol_table* symtab,
632 const unsigned char* shdrs,
633 const char* section_names,
634 section_size_type section_names_size,
635 std::vector<bool>* omit)
637 // Read the section contents.
638 typename This::Shdr shdr(shdrs + index * This::shdr_size);
639 const unsigned char* pcon = this->get_view(shdr.get_sh_offset(),
640 shdr.get_sh_size(), true, false);
641 const elfcpp::Elf_Word* pword =
642 reinterpret_cast<const elfcpp::Elf_Word*>(pcon);
644 // The first word contains flags. We only care about COMDAT section
645 // groups. Other section groups are always included in the link
646 // just like ordinary sections.
647 elfcpp::Elf_Word flags = elfcpp::Swap<32, big_endian>::readval(pword);
649 // Look up the group signature, which is the name of a symbol. This
650 // is a lot of effort to go to to read a string. Why didn't they
651 // just have the group signature point into the string table, rather
652 // than indirect through a symbol?
654 // Get the appropriate symbol table header (this will normally be
655 // the single SHT_SYMTAB section, but in principle it need not be).
656 const unsigned int link = this->adjust_shndx(shdr.get_sh_link());
657 typename This::Shdr symshdr(this, this->elf_file_.section_header(link));
659 // Read the symbol table entry.
660 unsigned int symndx = shdr.get_sh_info();
661 if (symndx >= symshdr.get_sh_size() / This::sym_size)
663 this->error(_("section group %u info %u out of range"),
667 off_t symoff = symshdr.get_sh_offset() + symndx * This::sym_size;
668 const unsigned char* psym = this->get_view(symoff, This::sym_size, true,
670 elfcpp::Sym<size, big_endian> sym(psym);
672 // Read the symbol table names.
673 section_size_type symnamelen;
674 const unsigned char* psymnamesu;
675 psymnamesu = this->section_contents(this->adjust_shndx(symshdr.get_sh_link()),
677 const char* psymnames = reinterpret_cast<const char*>(psymnamesu);
679 // Get the section group signature.
680 if (sym.get_st_name() >= symnamelen)
682 this->error(_("symbol %u name offset %u out of range"),
683 symndx, sym.get_st_name());
687 std::string signature(psymnames + sym.get_st_name());
689 // It seems that some versions of gas will create a section group
690 // associated with a section symbol, and then fail to give a name to
691 // the section symbol. In such a case, use the name of the section.
692 if (signature[0] == '\0' && sym.get_st_type() == elfcpp::STT_SECTION)
695 unsigned int sym_shndx = this->adjust_sym_shndx(symndx,
698 if (!is_ordinary || sym_shndx >= this->shnum())
700 this->error(_("symbol %u invalid section index %u"),
704 typename This::Shdr member_shdr(shdrs + sym_shndx * This::shdr_size);
705 if (member_shdr.get_sh_name() < section_names_size)
706 signature = section_names + member_shdr.get_sh_name();
709 // Record this section group in the layout, and see whether we've already
710 // seen one with the same signature.
713 Kept_section* kept_section = NULL;
715 if ((flags & elfcpp::GRP_COMDAT) == 0)
717 include_group = true;
722 include_group = layout->find_or_add_kept_section(signature,
724 true, &kept_section);
728 size_t count = shdr.get_sh_size() / sizeof(elfcpp::Elf_Word);
730 std::vector<unsigned int> shndxes;
731 bool relocate_group = include_group && parameters->options().relocatable();
733 shndxes.reserve(count - 1);
735 for (size_t i = 1; i < count; ++i)
737 elfcpp::Elf_Word shndx =
738 this->adjust_shndx(elfcpp::Swap<32, big_endian>::readval(pword + i));
741 shndxes.push_back(shndx);
743 if (shndx >= this->shnum())
745 this->error(_("section %u in section group %u out of range"),
750 // Check for an earlier section number, since we're going to get
751 // it wrong--we may have already decided to include the section.
753 this->error(_("invalid section group %u refers to earlier section %u"),
756 // Get the name of the member section.
757 typename This::Shdr member_shdr(shdrs + shndx * This::shdr_size);
758 if (member_shdr.get_sh_name() >= section_names_size)
760 // This is an error, but it will be diagnosed eventually
761 // in do_layout, so we don't need to do anything here but
765 std::string mname(section_names + member_shdr.get_sh_name());
770 kept_section->add_comdat_section(mname, shndx,
771 member_shdr.get_sh_size());
775 (*omit)[shndx] = true;
779 Relobj* kept_object = kept_section->object();
780 if (kept_section->is_comdat())
782 // Find the corresponding kept section, and store
783 // that info in the discarded section table.
784 unsigned int kept_shndx;
786 if (kept_section->find_comdat_section(mname, &kept_shndx,
789 // We don't keep a mapping for this section if
790 // it has a different size. The mapping is only
791 // used for relocation processing, and we don't
792 // want to treat the sections as similar if the
793 // sizes are different. Checking the section
794 // size is the approach used by the GNU linker.
795 if (kept_size == member_shdr.get_sh_size())
796 this->set_kept_comdat_section(shndx, kept_object,
802 // The existing section is a linkonce section. Add
803 // a mapping if there is exactly one section in the
804 // group (which is true when COUNT == 2) and if it
807 && (kept_section->linkonce_size()
808 == member_shdr.get_sh_size()))
809 this->set_kept_comdat_section(shndx, kept_object,
810 kept_section->shndx());
817 layout->layout_group(symtab, this, index, name, signature.c_str(),
818 shdr, flags, &shndxes);
820 return include_group;
823 // Whether to include a linkonce section in the link. NAME is the
824 // name of the section and SHDR is the section header.
826 // Linkonce sections are a GNU extension implemented in the original
827 // GNU linker before section groups were defined. The semantics are
828 // that we only include one linkonce section with a given name. The
829 // name of a linkonce section is normally .gnu.linkonce.T.SYMNAME,
830 // where T is the type of section and SYMNAME is the name of a symbol.
831 // In an attempt to make linkonce sections interact well with section
832 // groups, we try to identify SYMNAME and use it like a section group
833 // signature. We want to block section groups with that signature,
834 // but not other linkonce sections with that signature. We also use
835 // the full name of the linkonce section as a normal section group
838 template<int size, bool big_endian>
840 Sized_relobj<size, big_endian>::include_linkonce_section(
844 const elfcpp::Shdr<size, big_endian>& shdr)
846 typename elfcpp::Elf_types<size>::Elf_WXword sh_size = shdr.get_sh_size();
847 // In general the symbol name we want will be the string following
848 // the last '.'. However, we have to handle the case of
849 // .gnu.linkonce.t.__i686.get_pc_thunk.bx, which was generated by
850 // some versions of gcc. So we use a heuristic: if the name starts
851 // with ".gnu.linkonce.t.", we use everything after that. Otherwise
852 // we look for the last '.'. We can't always simply skip
853 // ".gnu.linkonce.X", because we have to deal with cases like
854 // ".gnu.linkonce.d.rel.ro.local".
855 const char* const linkonce_t = ".gnu.linkonce.t.";
857 if (strncmp(name, linkonce_t, strlen(linkonce_t)) == 0)
858 symname = name + strlen(linkonce_t);
860 symname = strrchr(name, '.') + 1;
861 std::string sig1(symname);
862 std::string sig2(name);
865 bool include1 = layout->find_or_add_kept_section(sig1, this, index, false,
867 bool include2 = layout->find_or_add_kept_section(sig2, this, index, false,
872 // We are not including this section because we already saw the
873 // name of the section as a signature. This normally implies
874 // that the kept section is another linkonce section. If it is
875 // the same size, record it as the section which corresponds to
877 if (kept2->object() != NULL
878 && !kept2->is_comdat()
879 && kept2->linkonce_size() == sh_size)
880 this->set_kept_comdat_section(index, kept2->object(), kept2->shndx());
884 // The section is being discarded on the basis of its symbol
885 // name. This means that the corresponding kept section was
886 // part of a comdat group, and it will be difficult to identify
887 // the specific section within that group that corresponds to
888 // this linkonce section. We'll handle the simple case where
889 // the group has only one member section. Otherwise, it's not
891 unsigned int kept_shndx;
893 if (kept1->object() != NULL
894 && kept1->is_comdat()
895 && kept1->find_single_comdat_section(&kept_shndx, &kept_size)
896 && kept_size == sh_size)
897 this->set_kept_comdat_section(index, kept1->object(), kept_shndx);
901 kept1->set_linkonce_size(sh_size);
902 kept2->set_linkonce_size(sh_size);
905 return include1 && include2;
908 // Layout an input section.
910 template<int size, bool big_endian>
912 Sized_relobj<size, big_endian>::layout_section(Layout* layout,
915 typename This::Shdr& shdr,
916 unsigned int reloc_shndx,
917 unsigned int reloc_type)
920 Output_section* os = layout->layout(this, shndx, name, shdr,
921 reloc_shndx, reloc_type, &offset);
923 this->output_sections()[shndx] = os;
925 this->section_offsets_[shndx] = invalid_address;
927 this->section_offsets_[shndx] = convert_types<Address, off_t>(offset);
929 // If this section requires special handling, and if there are
930 // relocs that apply to it, then we must do the special handling
931 // before we apply the relocs.
932 if (offset == -1 && reloc_shndx != 0)
933 this->set_relocs_must_follow_section_writes();
936 // Lay out the input sections. We walk through the sections and check
937 // whether they should be included in the link. If they should, we
938 // pass them to the Layout object, which will return an output section
940 // During garbage collection (--gc-sections) and identical code folding
941 // (--icf), this function is called twice. When it is called the first
942 // time, it is for setting up some sections as roots to a work-list for
943 // --gc-sections and to do comdat processing. Actual layout happens the
944 // second time around after all the relevant sections have been determined.
945 // The first time, is_worklist_ready or is_icf_ready is false. It is then
946 // set to true after the garbage collection worklist or identical code
947 // folding is processed and the relevant sections to be kept are
948 // determined. Then, this function is called again to layout the sections.
950 template<int size, bool big_endian>
952 Sized_relobj<size, big_endian>::do_layout(Symbol_table* symtab,
954 Read_symbols_data* sd)
956 const unsigned int shnum = this->shnum();
957 bool is_gc_pass_one = ((parameters->options().gc_sections()
958 && !symtab->gc()->is_worklist_ready())
959 || (parameters->options().icf_enabled()
960 && !symtab->icf()->is_icf_ready()));
962 bool is_gc_pass_two = ((parameters->options().gc_sections()
963 && symtab->gc()->is_worklist_ready())
964 || (parameters->options().icf_enabled()
965 && symtab->icf()->is_icf_ready()));
967 bool is_gc_or_icf = (parameters->options().gc_sections()
968 || parameters->options().icf_enabled());
970 // Both is_gc_pass_one and is_gc_pass_two should not be true.
971 gold_assert(!(is_gc_pass_one && is_gc_pass_two));
975 Symbols_data* gc_sd = NULL;
978 // During garbage collection save the symbols data to use it when
979 // re-entering this function.
980 gc_sd = new Symbols_data;
981 this->copy_symbols_data(gc_sd, sd, This::shdr_size * shnum);
982 this->set_symbols_data(gc_sd);
984 else if (is_gc_pass_two)
986 gc_sd = this->get_symbols_data();
989 const unsigned char* section_headers_data = NULL;
990 section_size_type section_names_size;
991 const unsigned char* symbols_data = NULL;
992 section_size_type symbols_size;
993 section_offset_type external_symbols_offset;
994 const unsigned char* symbol_names_data = NULL;
995 section_size_type symbol_names_size;
999 section_headers_data = gc_sd->section_headers_data;
1000 section_names_size = gc_sd->section_names_size;
1001 symbols_data = gc_sd->symbols_data;
1002 symbols_size = gc_sd->symbols_size;
1003 external_symbols_offset = gc_sd->external_symbols_offset;
1004 symbol_names_data = gc_sd->symbol_names_data;
1005 symbol_names_size = gc_sd->symbol_names_size;
1009 section_headers_data = sd->section_headers->data();
1010 section_names_size = sd->section_names_size;
1011 if (sd->symbols != NULL)
1012 symbols_data = sd->symbols->data();
1013 symbols_size = sd->symbols_size;
1014 external_symbols_offset = sd->external_symbols_offset;
1015 if (sd->symbol_names != NULL)
1016 symbol_names_data = sd->symbol_names->data();
1017 symbol_names_size = sd->symbol_names_size;
1020 // Get the section headers.
1021 const unsigned char* shdrs = section_headers_data;
1022 const unsigned char* pshdrs;
1024 // Get the section names.
1025 const unsigned char* pnamesu = (is_gc_or_icf)
1026 ? gc_sd->section_names_data
1027 : sd->section_names->data();
1029 const char* pnames = reinterpret_cast<const char*>(pnamesu);
1031 // If any input files have been claimed by plugins, we need to defer
1032 // actual layout until the replacement files have arrived.
1033 const bool should_defer_layout =
1034 (parameters->options().has_plugins()
1035 && parameters->options().plugins()->should_defer_layout());
1036 unsigned int num_sections_to_defer = 0;
1038 // For each section, record the index of the reloc section if any.
1039 // Use 0 to mean that there is no reloc section, -1U to mean that
1040 // there is more than one.
1041 std::vector<unsigned int> reloc_shndx(shnum, 0);
1042 std::vector<unsigned int> reloc_type(shnum, elfcpp::SHT_NULL);
1043 // Skip the first, dummy, section.
1044 pshdrs = shdrs + This::shdr_size;
1045 for (unsigned int i = 1; i < shnum; ++i, pshdrs += This::shdr_size)
1047 typename This::Shdr shdr(pshdrs);
1049 // Count the number of sections whose layout will be deferred.
1050 if (should_defer_layout && (shdr.get_sh_flags() & elfcpp::SHF_ALLOC))
1051 ++num_sections_to_defer;
1053 unsigned int sh_type = shdr.get_sh_type();
1054 if (sh_type == elfcpp::SHT_REL || sh_type == elfcpp::SHT_RELA)
1056 unsigned int target_shndx = this->adjust_shndx(shdr.get_sh_info());
1057 if (target_shndx == 0 || target_shndx >= shnum)
1059 this->error(_("relocation section %u has bad info %u"),
1064 if (reloc_shndx[target_shndx] != 0)
1065 reloc_shndx[target_shndx] = -1U;
1068 reloc_shndx[target_shndx] = i;
1069 reloc_type[target_shndx] = sh_type;
1074 Output_sections& out_sections(this->output_sections());
1075 std::vector<Address>& out_section_offsets(this->section_offsets_);
1077 if (!is_gc_pass_two)
1079 out_sections.resize(shnum);
1080 out_section_offsets.resize(shnum);
1083 // If we are only linking for symbols, then there is nothing else to
1085 if (this->input_file()->just_symbols())
1087 if (!is_gc_pass_two)
1089 delete sd->section_headers;
1090 sd->section_headers = NULL;
1091 delete sd->section_names;
1092 sd->section_names = NULL;
1097 if (num_sections_to_defer > 0)
1099 parameters->options().plugins()->add_deferred_layout_object(this);
1100 this->deferred_layout_.reserve(num_sections_to_defer);
1103 // Whether we've seen a .note.GNU-stack section.
1104 bool seen_gnu_stack = false;
1105 // The flags of a .note.GNU-stack section.
1106 uint64_t gnu_stack_flags = 0;
1108 // Keep track of which sections to omit.
1109 std::vector<bool> omit(shnum, false);
1111 // Keep track of reloc sections when emitting relocations.
1112 const bool relocatable = parameters->options().relocatable();
1113 const bool emit_relocs = (relocatable
1114 || parameters->options().emit_relocs());
1115 std::vector<unsigned int> reloc_sections;
1117 // Keep track of .eh_frame sections.
1118 std::vector<unsigned int> eh_frame_sections;
1120 // Skip the first, dummy, section.
1121 pshdrs = shdrs + This::shdr_size;
1122 for (unsigned int i = 1; i < shnum; ++i, pshdrs += This::shdr_size)
1124 typename This::Shdr shdr(pshdrs);
1126 if (shdr.get_sh_name() >= section_names_size)
1128 this->error(_("bad section name offset for section %u: %lu"),
1129 i, static_cast<unsigned long>(shdr.get_sh_name()));
1133 const char* name = pnames + shdr.get_sh_name();
1135 if (!is_gc_pass_two)
1137 if (this->handle_gnu_warning_section(name, i, symtab))
1143 // The .note.GNU-stack section is special. It gives the
1144 // protection flags that this object file requires for the stack
1146 if (strcmp(name, ".note.GNU-stack") == 0)
1148 seen_gnu_stack = true;
1149 gnu_stack_flags |= shdr.get_sh_flags();
1153 // The .note.GNU-split-stack section is also special. It
1154 // indicates that the object was compiled with
1156 if (this->handle_split_stack_section(name))
1158 if (!parameters->options().relocatable()
1159 && !parameters->options().shared())
1163 // Skip attributes section.
1164 if (parameters->target().is_attributes_section(name))
1169 bool discard = omit[i];
1172 if (shdr.get_sh_type() == elfcpp::SHT_GROUP)
1174 if (!this->include_section_group(symtab, layout, i, name,
1180 else if ((shdr.get_sh_flags() & elfcpp::SHF_GROUP) == 0
1181 && Layout::is_linkonce(name))
1183 if (!this->include_linkonce_section(layout, i, name, shdr))
1190 // Do not include this section in the link.
1191 out_sections[i] = NULL;
1192 out_section_offsets[i] = invalid_address;
1197 if (is_gc_pass_one && parameters->options().gc_sections())
1199 if (is_section_name_included(name)
1200 || shdr.get_sh_type() == elfcpp::SHT_INIT_ARRAY
1201 || shdr.get_sh_type() == elfcpp::SHT_FINI_ARRAY)
1203 symtab->gc()->worklist().push(Section_id(this, i));
1205 // If the section name XXX can be represented as a C identifier
1206 // it cannot be discarded if there are references to
1207 // __start_XXX and __stop_XXX symbols. These need to be
1208 // specially handled.
1209 if (is_cident(name))
1211 symtab->gc()->add_cident_section(name, Section_id(this, i));
1215 // When doing a relocatable link we are going to copy input
1216 // reloc sections into the output. We only want to copy the
1217 // ones associated with sections which are not being discarded.
1218 // However, we don't know that yet for all sections. So save
1219 // reloc sections and process them later. Garbage collection is
1220 // not triggered when relocatable code is desired.
1222 && (shdr.get_sh_type() == elfcpp::SHT_REL
1223 || shdr.get_sh_type() == elfcpp::SHT_RELA))
1225 reloc_sections.push_back(i);
1229 if (relocatable && shdr.get_sh_type() == elfcpp::SHT_GROUP)
1232 // The .eh_frame section is special. It holds exception frame
1233 // information that we need to read in order to generate the
1234 // exception frame header. We process these after all the other
1235 // sections so that the exception frame reader can reliably
1236 // determine which sections are being discarded, and discard the
1237 // corresponding information.
1239 && strcmp(name, ".eh_frame") == 0
1240 && this->check_eh_frame_flags(&shdr))
1244 out_sections[i] = reinterpret_cast<Output_section*>(1);
1245 out_section_offsets[i] = invalid_address;
1248 eh_frame_sections.push_back(i);
1252 if (is_gc_pass_two && parameters->options().gc_sections())
1254 // This is executed during the second pass of garbage
1255 // collection. do_layout has been called before and some
1256 // sections have been already discarded. Simply ignore
1257 // such sections this time around.
1258 if (out_sections[i] == NULL)
1260 gold_assert(out_section_offsets[i] == invalid_address);
1263 if (((shdr.get_sh_flags() & elfcpp::SHF_ALLOC) != 0)
1264 && symtab->gc()->is_section_garbage(this, i))
1266 if (parameters->options().print_gc_sections())
1267 gold_info(_("%s: removing unused section from '%s'"
1269 program_name, this->section_name(i).c_str(),
1270 this->name().c_str());
1271 out_sections[i] = NULL;
1272 out_section_offsets[i] = invalid_address;
1277 if (is_gc_pass_two && parameters->options().icf_enabled())
1279 if (out_sections[i] == NULL)
1281 gold_assert(out_section_offsets[i] == invalid_address);
1284 if (((shdr.get_sh_flags() & elfcpp::SHF_ALLOC) != 0)
1285 && symtab->icf()->is_section_folded(this, i))
1287 if (parameters->options().print_icf_sections())
1290 symtab->icf()->get_folded_section(this, i);
1291 Relobj* folded_obj =
1292 reinterpret_cast<Relobj*>(folded.first);
1293 gold_info(_("%s: ICF folding section '%s' in file '%s'"
1294 "into '%s' in file '%s'"),
1295 program_name, this->section_name(i).c_str(),
1296 this->name().c_str(),
1297 folded_obj->section_name(folded.second).c_str(),
1298 folded_obj->name().c_str());
1300 out_sections[i] = NULL;
1301 out_section_offsets[i] = invalid_address;
1306 // Defer layout here if input files are claimed by plugins. When gc
1307 // is turned on this function is called twice. For the second call
1308 // should_defer_layout should be false.
1309 if (should_defer_layout && (shdr.get_sh_flags() & elfcpp::SHF_ALLOC))
1311 gold_assert(!is_gc_pass_two);
1312 this->deferred_layout_.push_back(Deferred_layout(i, name,
1316 // Put dummy values here; real values will be supplied by
1317 // do_layout_deferred_sections.
1318 out_sections[i] = reinterpret_cast<Output_section*>(2);
1319 out_section_offsets[i] = invalid_address;
1323 // During gc_pass_two if a section that was previously deferred is
1324 // found, do not layout the section as layout_deferred_sections will
1325 // do it later from gold.cc.
1327 && (out_sections[i] == reinterpret_cast<Output_section*>(2)))
1332 // This is during garbage collection. The out_sections are
1333 // assigned in the second call to this function.
1334 out_sections[i] = reinterpret_cast<Output_section*>(1);
1335 out_section_offsets[i] = invalid_address;
1339 // When garbage collection is switched on the actual layout
1340 // only happens in the second call.
1341 this->layout_section(layout, i, name, shdr, reloc_shndx[i],
1346 if (!is_gc_pass_two)
1347 layout->layout_gnu_stack(seen_gnu_stack, gnu_stack_flags);
1349 // When doing a relocatable link handle the reloc sections at the
1350 // end. Garbage collection and Identical Code Folding is not
1351 // turned on for relocatable code.
1353 this->size_relocatable_relocs();
1355 gold_assert(!(is_gc_or_icf) || reloc_sections.empty());
1357 for (std::vector<unsigned int>::const_iterator p = reloc_sections.begin();
1358 p != reloc_sections.end();
1361 unsigned int i = *p;
1362 const unsigned char* pshdr;
1363 pshdr = section_headers_data + i * This::shdr_size;
1364 typename This::Shdr shdr(pshdr);
1366 unsigned int data_shndx = this->adjust_shndx(shdr.get_sh_info());
1367 if (data_shndx >= shnum)
1369 // We already warned about this above.
1373 Output_section* data_section = out_sections[data_shndx];
1374 if (data_section == NULL)
1376 out_sections[i] = NULL;
1377 out_section_offsets[i] = invalid_address;
1381 Relocatable_relocs* rr = new Relocatable_relocs();
1382 this->set_relocatable_relocs(i, rr);
1384 Output_section* os = layout->layout_reloc(this, i, shdr, data_section,
1386 out_sections[i] = os;
1387 out_section_offsets[i] = invalid_address;
1390 // Handle the .eh_frame sections at the end.
1391 gold_assert(!is_gc_pass_one || eh_frame_sections.empty());
1392 for (std::vector<unsigned int>::const_iterator p = eh_frame_sections.begin();
1393 p != eh_frame_sections.end();
1396 gold_assert(this->has_eh_frame_);
1397 gold_assert(external_symbols_offset != 0);
1399 unsigned int i = *p;
1400 const unsigned char *pshdr;
1401 pshdr = section_headers_data + i * This::shdr_size;
1402 typename This::Shdr shdr(pshdr);
1405 Output_section* os = layout->layout_eh_frame(this,
1414 out_sections[i] = os;
1415 if (os == NULL || offset == -1)
1417 // An object can contain at most one section holding exception
1418 // frame information.
1419 gold_assert(this->discarded_eh_frame_shndx_ == -1U);
1420 this->discarded_eh_frame_shndx_ = i;
1421 out_section_offsets[i] = invalid_address;
1424 out_section_offsets[i] = convert_types<Address, off_t>(offset);
1426 // If this section requires special handling, and if there are
1427 // relocs that apply to it, then we must do the special handling
1428 // before we apply the relocs.
1429 if (os != NULL && offset == -1 && reloc_shndx[i] != 0)
1430 this->set_relocs_must_follow_section_writes();
1435 delete[] gc_sd->section_headers_data;
1436 delete[] gc_sd->section_names_data;
1437 delete[] gc_sd->symbols_data;
1438 delete[] gc_sd->symbol_names_data;
1439 this->set_symbols_data(NULL);
1443 delete sd->section_headers;
1444 sd->section_headers = NULL;
1445 delete sd->section_names;
1446 sd->section_names = NULL;
1450 // Layout sections whose layout was deferred while waiting for
1451 // input files from a plugin.
1453 template<int size, bool big_endian>
1455 Sized_relobj<size, big_endian>::do_layout_deferred_sections(Layout* layout)
1457 typename std::vector<Deferred_layout>::iterator deferred;
1459 for (deferred = this->deferred_layout_.begin();
1460 deferred != this->deferred_layout_.end();
1463 typename This::Shdr shdr(deferred->shdr_data_);
1464 // If the section is not included, it is because the garbage collector
1465 // decided it is not needed. Avoid reverting that decision.
1466 if (!this->is_section_included(deferred->shndx_))
1469 this->layout_section(layout, deferred->shndx_, deferred->name_.c_str(),
1470 shdr, deferred->reloc_shndx_, deferred->reloc_type_);
1473 this->deferred_layout_.clear();
1476 // Add the symbols to the symbol table.
1478 template<int size, bool big_endian>
1480 Sized_relobj<size, big_endian>::do_add_symbols(Symbol_table* symtab,
1481 Read_symbols_data* sd,
1484 if (sd->symbols == NULL)
1486 gold_assert(sd->symbol_names == NULL);
1490 const int sym_size = This::sym_size;
1491 size_t symcount = ((sd->symbols_size - sd->external_symbols_offset)
1493 if (symcount * sym_size != sd->symbols_size - sd->external_symbols_offset)
1495 this->error(_("size of symbols is not multiple of symbol size"));
1499 this->symbols_.resize(symcount);
1501 const char* sym_names =
1502 reinterpret_cast<const char*>(sd->symbol_names->data());
1503 symtab->add_from_relobj(this,
1504 sd->symbols->data() + sd->external_symbols_offset,
1505 symcount, this->local_symbol_count_,
1506 sym_names, sd->symbol_names_size,
1508 &this->defined_count_);
1512 delete sd->symbol_names;
1513 sd->symbol_names = NULL;
1516 // Find out if this object, that is a member of a lib group, should be included
1517 // in the link. We check every symbol defined by this object. If the symbol
1518 // table has a strong undefined reference to that symbol, we have to include
1521 template<int size, bool big_endian>
1522 Archive::Should_include
1523 Sized_relobj<size, big_endian>::do_should_include_member(Symbol_table* symtab,
1524 Read_symbols_data* sd,
1527 char* tmpbuf = NULL;
1528 size_t tmpbuflen = 0;
1529 const char* sym_names =
1530 reinterpret_cast<const char*>(sd->symbol_names->data());
1531 const unsigned char* syms =
1532 sd->symbols->data() + sd->external_symbols_offset;
1533 const int sym_size = elfcpp::Elf_sizes<size>::sym_size;
1534 size_t symcount = ((sd->symbols_size - sd->external_symbols_offset)
1537 const unsigned char* p = syms;
1539 for (size_t i = 0; i < symcount; ++i, p += sym_size)
1541 elfcpp::Sym<size, big_endian> sym(p);
1542 unsigned int st_shndx = sym.get_st_shndx();
1543 if (st_shndx == elfcpp::SHN_UNDEF)
1546 unsigned int st_name = sym.get_st_name();
1547 const char* name = sym_names + st_name;
1549 Archive::Should_include t = Archive::should_include_member(symtab, name,
1553 if (t == Archive::SHOULD_INCLUDE_YES)
1562 return Archive::SHOULD_INCLUDE_UNKNOWN;
1565 // First pass over the local symbols. Here we add their names to
1566 // *POOL and *DYNPOOL, and we store the symbol value in
1567 // THIS->LOCAL_VALUES_. This function is always called from a
1568 // singleton thread. This is followed by a call to
1569 // finalize_local_symbols.
1571 template<int size, bool big_endian>
1573 Sized_relobj<size, big_endian>::do_count_local_symbols(Stringpool* pool,
1574 Stringpool* dynpool)
1576 gold_assert(this->symtab_shndx_ != -1U);
1577 if (this->symtab_shndx_ == 0)
1579 // This object has no symbols. Weird but legal.
1583 // Read the symbol table section header.
1584 const unsigned int symtab_shndx = this->symtab_shndx_;
1585 typename This::Shdr symtabshdr(this,
1586 this->elf_file_.section_header(symtab_shndx));
1587 gold_assert(symtabshdr.get_sh_type() == elfcpp::SHT_SYMTAB);
1589 // Read the local symbols.
1590 const int sym_size = This::sym_size;
1591 const unsigned int loccount = this->local_symbol_count_;
1592 gold_assert(loccount == symtabshdr.get_sh_info());
1593 off_t locsize = loccount * sym_size;
1594 const unsigned char* psyms = this->get_view(symtabshdr.get_sh_offset(),
1595 locsize, true, true);
1597 // Read the symbol names.
1598 const unsigned int strtab_shndx =
1599 this->adjust_shndx(symtabshdr.get_sh_link());
1600 section_size_type strtab_size;
1601 const unsigned char* pnamesu = this->section_contents(strtab_shndx,
1604 const char* pnames = reinterpret_cast<const char*>(pnamesu);
1606 // Loop over the local symbols.
1608 const Output_sections& out_sections(this->output_sections());
1609 unsigned int shnum = this->shnum();
1610 unsigned int count = 0;
1611 unsigned int dyncount = 0;
1612 // Skip the first, dummy, symbol.
1614 bool discard_all = parameters->options().discard_all();
1615 bool discard_locals = parameters->options().discard_locals();
1616 for (unsigned int i = 1; i < loccount; ++i, psyms += sym_size)
1618 elfcpp::Sym<size, big_endian> sym(psyms);
1620 Symbol_value<size>& lv(this->local_values_[i]);
1623 unsigned int shndx = this->adjust_sym_shndx(i, sym.get_st_shndx(),
1625 lv.set_input_shndx(shndx, is_ordinary);
1627 if (sym.get_st_type() == elfcpp::STT_SECTION)
1628 lv.set_is_section_symbol();
1629 else if (sym.get_st_type() == elfcpp::STT_TLS)
1630 lv.set_is_tls_symbol();
1632 // Save the input symbol value for use in do_finalize_local_symbols().
1633 lv.set_input_value(sym.get_st_value());
1635 // Decide whether this symbol should go into the output file.
1637 if ((shndx < shnum && out_sections[shndx] == NULL)
1638 || shndx == this->discarded_eh_frame_shndx_)
1640 lv.set_no_output_symtab_entry();
1641 gold_assert(!lv.needs_output_dynsym_entry());
1645 if (sym.get_st_type() == elfcpp::STT_SECTION)
1647 lv.set_no_output_symtab_entry();
1648 gold_assert(!lv.needs_output_dynsym_entry());
1652 if (sym.get_st_name() >= strtab_size)
1654 this->error(_("local symbol %u section name out of range: %u >= %u"),
1655 i, sym.get_st_name(),
1656 static_cast<unsigned int>(strtab_size));
1657 lv.set_no_output_symtab_entry();
1661 const char* name = pnames + sym.get_st_name();
1663 // If needed, add the symbol to the dynamic symbol table string pool.
1664 if (lv.needs_output_dynsym_entry())
1666 dynpool->add(name, true, NULL);
1670 if (discard_all && lv.may_be_discarded_from_output_symtab())
1672 lv.set_no_output_symtab_entry();
1676 // If --discard-locals option is used, discard all temporary local
1677 // symbols. These symbols start with system-specific local label
1678 // prefixes, typically .L for ELF system. We want to be compatible
1679 // with GNU ld so here we essentially use the same check in
1680 // bfd_is_local_label(). The code is different because we already
1683 // - the symbol is local and thus cannot have global or weak binding.
1684 // - the symbol is not a section symbol.
1685 // - the symbol has a name.
1687 // We do not discard a symbol if it needs a dynamic symbol entry.
1689 && sym.get_st_type() != elfcpp::STT_FILE
1690 && !lv.needs_output_dynsym_entry()
1691 && lv.may_be_discarded_from_output_symtab()
1692 && parameters->target().is_local_label_name(name))
1694 lv.set_no_output_symtab_entry();
1698 // Discard the local symbol if -retain_symbols_file is specified
1699 // and the local symbol is not in that file.
1700 if (!parameters->options().should_retain_symbol(name))
1702 lv.set_no_output_symtab_entry();
1706 // Add the symbol to the symbol table string pool.
1707 pool->add(name, true, NULL);
1711 this->output_local_symbol_count_ = count;
1712 this->output_local_dynsym_count_ = dyncount;
1715 // Finalize the local symbols. Here we set the final value in
1716 // THIS->LOCAL_VALUES_ and set their output symbol table indexes.
1717 // This function is always called from a singleton thread. The actual
1718 // output of the local symbols will occur in a separate task.
1720 template<int size, bool big_endian>
1722 Sized_relobj<size, big_endian>::do_finalize_local_symbols(unsigned int index,
1724 Symbol_table* symtab)
1726 gold_assert(off == static_cast<off_t>(align_address(off, size >> 3)));
1728 const unsigned int loccount = this->local_symbol_count_;
1729 this->local_symbol_offset_ = off;
1731 const bool relocatable = parameters->options().relocatable();
1732 const Output_sections& out_sections(this->output_sections());
1733 const std::vector<Address>& out_offsets(this->section_offsets_);
1734 unsigned int shnum = this->shnum();
1736 for (unsigned int i = 1; i < loccount; ++i)
1738 Symbol_value<size>& lv(this->local_values_[i]);
1741 unsigned int shndx = lv.input_shndx(&is_ordinary);
1743 // Set the output symbol value.
1747 if (shndx == elfcpp::SHN_ABS || Symbol::is_common_shndx(shndx))
1748 lv.set_output_value(lv.input_value());
1751 this->error(_("unknown section index %u for local symbol %u"),
1753 lv.set_output_value(0);
1760 this->error(_("local symbol %u section index %u out of range"),
1765 Output_section* os = out_sections[shndx];
1766 Address secoffset = out_offsets[shndx];
1767 if (symtab->is_section_folded(this, shndx))
1769 gold_assert (os == NULL && secoffset == invalid_address);
1770 // Get the os of the section it is folded onto.
1771 Section_id folded = symtab->icf()->get_folded_section(this,
1773 gold_assert(folded.first != NULL);
1774 Sized_relobj<size, big_endian>* folded_obj = reinterpret_cast
1775 <Sized_relobj<size, big_endian>*>(folded.first);
1776 os = folded_obj->output_section(folded.second);
1777 gold_assert(os != NULL);
1778 secoffset = folded_obj->get_output_section_offset(folded.second);
1780 // This could be a relaxed input section.
1781 if (secoffset == invalid_address)
1783 const Output_relaxed_input_section* relaxed_section =
1784 os->find_relaxed_input_section(folded_obj, folded.second);
1785 gold_assert(relaxed_section != NULL);
1786 secoffset = relaxed_section->address() - os->address();
1792 // This local symbol belongs to a section we are discarding.
1793 // In some cases when applying relocations later, we will
1794 // attempt to match it to the corresponding kept section,
1795 // so we leave the input value unchanged here.
1798 else if (secoffset == invalid_address)
1802 // This is a SHF_MERGE section or one which otherwise
1803 // requires special handling.
1804 if (shndx == this->discarded_eh_frame_shndx_)
1806 // This local symbol belongs to a discarded .eh_frame
1807 // section. Just treat it like the case in which
1808 // os == NULL above.
1809 gold_assert(this->has_eh_frame_);
1812 else if (!lv.is_section_symbol())
1814 // This is not a section symbol. We can determine
1815 // the final value now.
1816 lv.set_output_value(os->output_address(this, shndx,
1819 else if (!os->find_starting_output_address(this, shndx, &start))
1821 // This is a section symbol, but apparently not one in a
1822 // merged section. First check to see if this is a relaxed
1823 // input section. If so, use its address. Otherwise just
1824 // use the start of the output section. This happens with
1825 // relocatable links when the input object has section
1826 // symbols for arbitrary non-merge sections.
1827 const Output_section_data* posd =
1828 os->find_relaxed_input_section(this, shndx);
1831 Address relocatable_link_adjustment =
1832 relocatable ? os->address() : 0;
1833 lv.set_output_value(posd->address()
1834 - relocatable_link_adjustment);
1837 lv.set_output_value(os->address());
1841 // We have to consider the addend to determine the
1842 // value to use in a relocation. START is the start
1843 // of this input section. If we are doing a relocatable
1844 // link, use offset from start output section instead of
1846 Address adjusted_start =
1847 relocatable ? start - os->address() : start;
1848 Merged_symbol_value<size>* msv =
1849 new Merged_symbol_value<size>(lv.input_value(),
1851 lv.set_merged_symbol_value(msv);
1854 else if (lv.is_tls_symbol())
1855 lv.set_output_value(os->tls_offset()
1857 + lv.input_value());
1859 lv.set_output_value((relocatable ? 0 : os->address())
1861 + lv.input_value());
1864 if (!lv.is_output_symtab_index_set())
1866 lv.set_output_symtab_index(index);
1873 // Set the output dynamic symbol table indexes for the local variables.
1875 template<int size, bool big_endian>
1877 Sized_relobj<size, big_endian>::do_set_local_dynsym_indexes(unsigned int index)
1879 const unsigned int loccount = this->local_symbol_count_;
1880 for (unsigned int i = 1; i < loccount; ++i)
1882 Symbol_value<size>& lv(this->local_values_[i]);
1883 if (lv.needs_output_dynsym_entry())
1885 lv.set_output_dynsym_index(index);
1892 // Set the offset where local dynamic symbol information will be stored.
1893 // Returns the count of local symbols contributed to the symbol table by
1896 template<int size, bool big_endian>
1898 Sized_relobj<size, big_endian>::do_set_local_dynsym_offset(off_t off)
1900 gold_assert(off == static_cast<off_t>(align_address(off, size >> 3)));
1901 this->local_dynsym_offset_ = off;
1902 return this->output_local_dynsym_count_;
1905 // If Symbols_data is not NULL get the section flags from here otherwise
1906 // get it from the file.
1908 template<int size, bool big_endian>
1910 Sized_relobj<size, big_endian>::do_section_flags(unsigned int shndx)
1912 Symbols_data* sd = this->get_symbols_data();
1915 const unsigned char* pshdrs = sd->section_headers_data
1916 + This::shdr_size * shndx;
1917 typename This::Shdr shdr(pshdrs);
1918 return shdr.get_sh_flags();
1920 // If sd is NULL, read the section header from the file.
1921 return this->elf_file_.section_flags(shndx);
1924 // Get the section's ent size from Symbols_data. Called by get_section_contents
1927 template<int size, bool big_endian>
1929 Sized_relobj<size, big_endian>::do_section_entsize(unsigned int shndx)
1931 Symbols_data* sd = this->get_symbols_data();
1932 gold_assert (sd != NULL);
1934 const unsigned char* pshdrs = sd->section_headers_data
1935 + This::shdr_size * shndx;
1936 typename This::Shdr shdr(pshdrs);
1937 return shdr.get_sh_entsize();
1941 // Write out the local symbols.
1943 template<int size, bool big_endian>
1945 Sized_relobj<size, big_endian>::write_local_symbols(
1947 const Stringpool* sympool,
1948 const Stringpool* dynpool,
1949 Output_symtab_xindex* symtab_xindex,
1950 Output_symtab_xindex* dynsym_xindex)
1952 const bool strip_all = parameters->options().strip_all();
1955 if (this->output_local_dynsym_count_ == 0)
1957 this->output_local_symbol_count_ = 0;
1960 gold_assert(this->symtab_shndx_ != -1U);
1961 if (this->symtab_shndx_ == 0)
1963 // This object has no symbols. Weird but legal.
1967 // Read the symbol table section header.
1968 const unsigned int symtab_shndx = this->symtab_shndx_;
1969 typename This::Shdr symtabshdr(this,
1970 this->elf_file_.section_header(symtab_shndx));
1971 gold_assert(symtabshdr.get_sh_type() == elfcpp::SHT_SYMTAB);
1972 const unsigned int loccount = this->local_symbol_count_;
1973 gold_assert(loccount == symtabshdr.get_sh_info());
1975 // Read the local symbols.
1976 const int sym_size = This::sym_size;
1977 off_t locsize = loccount * sym_size;
1978 const unsigned char* psyms = this->get_view(symtabshdr.get_sh_offset(),
1979 locsize, true, false);
1981 // Read the symbol names.
1982 const unsigned int strtab_shndx =
1983 this->adjust_shndx(symtabshdr.get_sh_link());
1984 section_size_type strtab_size;
1985 const unsigned char* pnamesu = this->section_contents(strtab_shndx,
1988 const char* pnames = reinterpret_cast<const char*>(pnamesu);
1990 // Get views into the output file for the portions of the symbol table
1991 // and the dynamic symbol table that we will be writing.
1992 off_t output_size = this->output_local_symbol_count_ * sym_size;
1993 unsigned char* oview = NULL;
1994 if (output_size > 0)
1995 oview = of->get_output_view(this->local_symbol_offset_, output_size);
1997 off_t dyn_output_size = this->output_local_dynsym_count_ * sym_size;
1998 unsigned char* dyn_oview = NULL;
1999 if (dyn_output_size > 0)
2000 dyn_oview = of->get_output_view(this->local_dynsym_offset_,
2003 const Output_sections out_sections(this->output_sections());
2005 gold_assert(this->local_values_.size() == loccount);
2007 unsigned char* ov = oview;
2008 unsigned char* dyn_ov = dyn_oview;
2010 for (unsigned int i = 1; i < loccount; ++i, psyms += sym_size)
2012 elfcpp::Sym<size, big_endian> isym(psyms);
2014 Symbol_value<size>& lv(this->local_values_[i]);
2017 unsigned int st_shndx = this->adjust_sym_shndx(i, isym.get_st_shndx(),
2021 gold_assert(st_shndx < out_sections.size());
2022 if (out_sections[st_shndx] == NULL)
2024 st_shndx = out_sections[st_shndx]->out_shndx();
2025 if (st_shndx >= elfcpp::SHN_LORESERVE)
2027 if (lv.has_output_symtab_entry())
2028 symtab_xindex->add(lv.output_symtab_index(), st_shndx);
2029 if (lv.has_output_dynsym_entry())
2030 dynsym_xindex->add(lv.output_dynsym_index(), st_shndx);
2031 st_shndx = elfcpp::SHN_XINDEX;
2035 // Write the symbol to the output symbol table.
2036 if (lv.has_output_symtab_entry())
2038 elfcpp::Sym_write<size, big_endian> osym(ov);
2040 gold_assert(isym.get_st_name() < strtab_size);
2041 const char* name = pnames + isym.get_st_name();
2042 osym.put_st_name(sympool->get_offset(name));
2043 osym.put_st_value(this->local_values_[i].value(this, 0));
2044 osym.put_st_size(isym.get_st_size());
2045 osym.put_st_info(isym.get_st_info());
2046 osym.put_st_other(isym.get_st_other());
2047 osym.put_st_shndx(st_shndx);
2052 // Write the symbol to the output dynamic symbol table.
2053 if (lv.has_output_dynsym_entry())
2055 gold_assert(dyn_ov < dyn_oview + dyn_output_size);
2056 elfcpp::Sym_write<size, big_endian> osym(dyn_ov);
2058 gold_assert(isym.get_st_name() < strtab_size);
2059 const char* name = pnames + isym.get_st_name();
2060 osym.put_st_name(dynpool->get_offset(name));
2061 osym.put_st_value(this->local_values_[i].value(this, 0));
2062 osym.put_st_size(isym.get_st_size());
2063 osym.put_st_info(isym.get_st_info());
2064 osym.put_st_other(isym.get_st_other());
2065 osym.put_st_shndx(st_shndx);
2072 if (output_size > 0)
2074 gold_assert(ov - oview == output_size);
2075 of->write_output_view(this->local_symbol_offset_, output_size, oview);
2078 if (dyn_output_size > 0)
2080 gold_assert(dyn_ov - dyn_oview == dyn_output_size);
2081 of->write_output_view(this->local_dynsym_offset_, dyn_output_size,
2086 // Set *INFO to symbolic information about the offset OFFSET in the
2087 // section SHNDX. Return true if we found something, false if we
2090 template<int size, bool big_endian>
2092 Sized_relobj<size, big_endian>::get_symbol_location_info(
2095 Symbol_location_info* info)
2097 if (this->symtab_shndx_ == 0)
2100 section_size_type symbols_size;
2101 const unsigned char* symbols = this->section_contents(this->symtab_shndx_,
2105 unsigned int symbol_names_shndx =
2106 this->adjust_shndx(this->section_link(this->symtab_shndx_));
2107 section_size_type names_size;
2108 const unsigned char* symbol_names_u =
2109 this->section_contents(symbol_names_shndx, &names_size, false);
2110 const char* symbol_names = reinterpret_cast<const char*>(symbol_names_u);
2112 const int sym_size = This::sym_size;
2113 const size_t count = symbols_size / sym_size;
2115 const unsigned char* p = symbols;
2116 for (size_t i = 0; i < count; ++i, p += sym_size)
2118 elfcpp::Sym<size, big_endian> sym(p);
2120 if (sym.get_st_type() == elfcpp::STT_FILE)
2122 if (sym.get_st_name() >= names_size)
2123 info->source_file = "(invalid)";
2125 info->source_file = symbol_names + sym.get_st_name();
2130 unsigned int st_shndx = this->adjust_sym_shndx(i, sym.get_st_shndx(),
2133 && st_shndx == shndx
2134 && static_cast<off_t>(sym.get_st_value()) <= offset
2135 && (static_cast<off_t>(sym.get_st_value() + sym.get_st_size())
2138 if (sym.get_st_name() > names_size)
2139 info->enclosing_symbol_name = "(invalid)";
2142 info->enclosing_symbol_name = symbol_names + sym.get_st_name();
2143 if (parameters->options().do_demangle())
2145 char* demangled_name = cplus_demangle(
2146 info->enclosing_symbol_name.c_str(),
2147 DMGL_ANSI | DMGL_PARAMS);
2148 if (demangled_name != NULL)
2150 info->enclosing_symbol_name.assign(demangled_name);
2151 free(demangled_name);
2162 // Look for a kept section corresponding to the given discarded section,
2163 // and return its output address. This is used only for relocations in
2164 // debugging sections. If we can't find the kept section, return 0.
2166 template<int size, bool big_endian>
2167 typename Sized_relobj<size, big_endian>::Address
2168 Sized_relobj<size, big_endian>::map_to_kept_section(
2172 Relobj* kept_object;
2173 unsigned int kept_shndx;
2174 if (this->get_kept_comdat_section(shndx, &kept_object, &kept_shndx))
2176 Sized_relobj<size, big_endian>* kept_relobj =
2177 static_cast<Sized_relobj<size, big_endian>*>(kept_object);
2178 Output_section* os = kept_relobj->output_section(kept_shndx);
2179 Address offset = kept_relobj->get_output_section_offset(kept_shndx);
2180 if (os != NULL && offset != invalid_address)
2183 return os->address() + offset;
2190 // Get symbol counts.
2192 template<int size, bool big_endian>
2194 Sized_relobj<size, big_endian>::do_get_global_symbol_counts(
2195 const Symbol_table*,
2199 *defined = this->defined_count_;
2201 for (Symbols::const_iterator p = this->symbols_.begin();
2202 p != this->symbols_.end();
2205 && (*p)->source() == Symbol::FROM_OBJECT
2206 && (*p)->object() == this
2207 && (*p)->is_defined())
2212 // Input_objects methods.
2214 // Add a regular relocatable object to the list. Return false if this
2215 // object should be ignored.
2218 Input_objects::add_object(Object* obj)
2220 // Print the filename if the -t/--trace option is selected.
2221 if (parameters->options().trace())
2222 gold_info("%s", obj->name().c_str());
2224 if (!obj->is_dynamic())
2225 this->relobj_list_.push_back(static_cast<Relobj*>(obj));
2228 // See if this is a duplicate SONAME.
2229 Dynobj* dynobj = static_cast<Dynobj*>(obj);
2230 const char* soname = dynobj->soname();
2232 std::pair<Unordered_set<std::string>::iterator, bool> ins =
2233 this->sonames_.insert(soname);
2236 // We have already seen a dynamic object with this soname.
2240 this->dynobj_list_.push_back(dynobj);
2243 // Add this object to the cross-referencer if requested.
2244 if (parameters->options().user_set_print_symbol_counts()
2245 || parameters->options().cref())
2247 if (this->cref_ == NULL)
2248 this->cref_ = new Cref();
2249 this->cref_->add_object(obj);
2255 // For each dynamic object, record whether we've seen all of its
2256 // explicit dependencies.
2259 Input_objects::check_dynamic_dependencies() const
2261 bool issued_copy_dt_needed_error = false;
2262 for (Dynobj_list::const_iterator p = this->dynobj_list_.begin();
2263 p != this->dynobj_list_.end();
2266 const Dynobj::Needed& needed((*p)->needed());
2267 bool found_all = true;
2268 Dynobj::Needed::const_iterator pneeded;
2269 for (pneeded = needed.begin(); pneeded != needed.end(); ++pneeded)
2271 if (this->sonames_.find(*pneeded) == this->sonames_.end())
2277 (*p)->set_has_unknown_needed_entries(!found_all);
2279 // --copy-dt-needed-entries aka --add-needed is a GNU ld option
2280 // that gold does not support. However, they cause no trouble
2281 // unless there is a DT_NEEDED entry that we don't know about;
2282 // warn only in that case.
2284 && !issued_copy_dt_needed_error
2285 && (parameters->options().copy_dt_needed_entries()
2286 || parameters->options().add_needed()))
2288 const char* optname;
2289 if (parameters->options().copy_dt_needed_entries())
2290 optname = "--copy-dt-needed-entries";
2292 optname = "--add-needed";
2293 gold_error(_("%s is not supported but is required for %s in %s"),
2294 optname, (*pneeded).c_str(), (*p)->name().c_str());
2295 issued_copy_dt_needed_error = true;
2300 // Start processing an archive.
2303 Input_objects::archive_start(Archive* archive)
2305 if (parameters->options().user_set_print_symbol_counts()
2306 || parameters->options().cref())
2308 if (this->cref_ == NULL)
2309 this->cref_ = new Cref();
2310 this->cref_->add_archive_start(archive);
2314 // Stop processing an archive.
2317 Input_objects::archive_stop(Archive* archive)
2319 if (parameters->options().user_set_print_symbol_counts()
2320 || parameters->options().cref())
2321 this->cref_->add_archive_stop(archive);
2324 // Print symbol counts
2327 Input_objects::print_symbol_counts(const Symbol_table* symtab) const
2329 if (parameters->options().user_set_print_symbol_counts()
2330 && this->cref_ != NULL)
2331 this->cref_->print_symbol_counts(symtab);
2334 // Print a cross reference table.
2337 Input_objects::print_cref(const Symbol_table* symtab, FILE* f) const
2339 if (parameters->options().cref() && this->cref_ != NULL)
2340 this->cref_->print_cref(symtab, f);
2343 // Relocate_info methods.
2345 // Return a string describing the location of a relocation. This is
2346 // only used in error messages.
2348 template<int size, bool big_endian>
2350 Relocate_info<size, big_endian>::location(size_t, off_t offset) const
2352 // See if we can get line-number information from debugging sections.
2353 std::string filename;
2354 std::string file_and_lineno; // Better than filename-only, if available.
2356 Sized_dwarf_line_info<size, big_endian> line_info(this->object);
2357 // This will be "" if we failed to parse the debug info for any reason.
2358 file_and_lineno = line_info.addr2line(this->data_shndx, offset);
2360 std::string ret(this->object->name());
2362 Symbol_location_info info;
2363 if (this->object->get_symbol_location_info(this->data_shndx, offset, &info))
2365 ret += " in function ";
2366 ret += info.enclosing_symbol_name;
2368 filename = info.source_file;
2371 if (!file_and_lineno.empty())
2372 ret += file_and_lineno;
2375 if (!filename.empty())
2378 ret += this->object->section_name(this->data_shndx);
2380 // Offsets into sections have to be positive.
2381 snprintf(buf, sizeof(buf), "+0x%lx", static_cast<long>(offset));
2388 } // End namespace gold.
2393 using namespace gold;
2395 // Read an ELF file with the header and return the appropriate
2396 // instance of Object.
2398 template<int size, bool big_endian>
2400 make_elf_sized_object(const std::string& name, Input_file* input_file,
2401 off_t offset, const elfcpp::Ehdr<size, big_endian>& ehdr,
2402 bool* punconfigured)
2404 Target* target = select_target(ehdr.get_e_machine(), size, big_endian,
2405 ehdr.get_e_ident()[elfcpp::EI_OSABI],
2406 ehdr.get_e_ident()[elfcpp::EI_ABIVERSION]);
2408 gold_fatal(_("%s: unsupported ELF machine number %d"),
2409 name.c_str(), ehdr.get_e_machine());
2411 if (!parameters->target_valid())
2412 set_parameters_target(target);
2413 else if (target != ¶meters->target())
2415 if (punconfigured != NULL)
2416 *punconfigured = true;
2418 gold_error(_("%s: incompatible target"), name.c_str());
2422 return target->make_elf_object<size, big_endian>(name, input_file, offset,
2426 } // End anonymous namespace.
2431 // Return whether INPUT_FILE is an ELF object.
2434 is_elf_object(Input_file* input_file, off_t offset,
2435 const unsigned char** start, int *read_size)
2437 off_t filesize = input_file->file().filesize();
2438 int want = elfcpp::Elf_recognizer::max_header_size;
2439 if (filesize - offset < want)
2440 want = filesize - offset;
2442 const unsigned char* p = input_file->file().get_view(offset, 0, want,
2447 return elfcpp::Elf_recognizer::is_elf_file(p, want);
2450 // Read an ELF file and return the appropriate instance of Object.
2453 make_elf_object(const std::string& name, Input_file* input_file, off_t offset,
2454 const unsigned char* p, section_offset_type bytes,
2455 bool* punconfigured)
2457 if (punconfigured != NULL)
2458 *punconfigured = false;
2461 bool big_endian = false;
2463 if (!elfcpp::Elf_recognizer::is_valid_header(p, bytes, &size,
2464 &big_endian, &error))
2466 gold_error(_("%s: %s"), name.c_str(), error.c_str());
2474 #ifdef HAVE_TARGET_32_BIG
2475 elfcpp::Ehdr<32, true> ehdr(p);
2476 return make_elf_sized_object<32, true>(name, input_file,
2477 offset, ehdr, punconfigured);
2479 if (punconfigured != NULL)
2480 *punconfigured = true;
2482 gold_error(_("%s: not configured to support "
2483 "32-bit big-endian object"),
2490 #ifdef HAVE_TARGET_32_LITTLE
2491 elfcpp::Ehdr<32, false> ehdr(p);
2492 return make_elf_sized_object<32, false>(name, input_file,
2493 offset, ehdr, punconfigured);
2495 if (punconfigured != NULL)
2496 *punconfigured = true;
2498 gold_error(_("%s: not configured to support "
2499 "32-bit little-endian object"),
2505 else if (size == 64)
2509 #ifdef HAVE_TARGET_64_BIG
2510 elfcpp::Ehdr<64, true> ehdr(p);
2511 return make_elf_sized_object<64, true>(name, input_file,
2512 offset, ehdr, punconfigured);
2514 if (punconfigured != NULL)
2515 *punconfigured = true;
2517 gold_error(_("%s: not configured to support "
2518 "64-bit big-endian object"),
2525 #ifdef HAVE_TARGET_64_LITTLE
2526 elfcpp::Ehdr<64, false> ehdr(p);
2527 return make_elf_sized_object<64, false>(name, input_file,
2528 offset, ehdr, punconfigured);
2530 if (punconfigured != NULL)
2531 *punconfigured = true;
2533 gold_error(_("%s: not configured to support "
2534 "64-bit little-endian object"),
2544 // Instantiate the templates we need.
2546 #ifdef HAVE_TARGET_32_LITTLE
2549 Object::read_section_data<32, false>(elfcpp::Elf_file<32, false, Object>*,
2550 Read_symbols_data*);
2553 #ifdef HAVE_TARGET_32_BIG
2556 Object::read_section_data<32, true>(elfcpp::Elf_file<32, true, Object>*,
2557 Read_symbols_data*);
2560 #ifdef HAVE_TARGET_64_LITTLE
2563 Object::read_section_data<64, false>(elfcpp::Elf_file<64, false, Object>*,
2564 Read_symbols_data*);
2567 #ifdef HAVE_TARGET_64_BIG
2570 Object::read_section_data<64, true>(elfcpp::Elf_file<64, true, Object>*,
2571 Read_symbols_data*);
2574 #ifdef HAVE_TARGET_32_LITTLE
2576 class Sized_relobj<32, false>;
2579 #ifdef HAVE_TARGET_32_BIG
2581 class Sized_relobj<32, true>;
2584 #ifdef HAVE_TARGET_64_LITTLE
2586 class Sized_relobj<64, false>;
2589 #ifdef HAVE_TARGET_64_BIG
2591 class Sized_relobj<64, true>;
2594 #ifdef HAVE_TARGET_32_LITTLE
2596 struct Relocate_info<32, false>;
2599 #ifdef HAVE_TARGET_32_BIG
2601 struct Relocate_info<32, true>;
2604 #ifdef HAVE_TARGET_64_LITTLE
2606 struct Relocate_info<64, false>;
2609 #ifdef HAVE_TARGET_64_BIG
2611 struct Relocate_info<64, true>;
2614 #ifdef HAVE_TARGET_32_LITTLE
2617 Xindex::initialize_symtab_xindex<32, false>(Object*, unsigned int);
2621 Xindex::read_symtab_xindex<32, false>(Object*, unsigned int,
2622 const unsigned char*);
2625 #ifdef HAVE_TARGET_32_BIG
2628 Xindex::initialize_symtab_xindex<32, true>(Object*, unsigned int);
2632 Xindex::read_symtab_xindex<32, true>(Object*, unsigned int,
2633 const unsigned char*);
2636 #ifdef HAVE_TARGET_64_LITTLE
2639 Xindex::initialize_symtab_xindex<64, false>(Object*, unsigned int);
2643 Xindex::read_symtab_xindex<64, false>(Object*, unsigned int,
2644 const unsigned char*);
2647 #ifdef HAVE_TARGET_64_BIG
2650 Xindex::initialize_symtab_xindex<64, true>(Object*, unsigned int);
2654 Xindex::read_symtab_xindex<64, true>(Object*, unsigned int,
2655 const unsigned char*);
2658 } // End namespace gold.