* configure.ac (AC_CHECK_FUNCS): Sort into alphabetical order.
[binutils.git] / gold / object.cc
blobeeacdaa6e7f6a826035886fe1cd3a18638941f0f
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.
23 #include "gold.h"
25 #include <cerrno>
26 #include <cstring>
27 #include <cstdarg>
28 #include "demangle.h"
29 #include "libiberty.h"
31 #include "gc.h"
32 #include "target-select.h"
33 #include "dwarf_reader.h"
34 #include "layout.h"
35 #include "output.h"
36 #include "symtab.h"
37 #include "cref.h"
38 #include "reloc.h"
39 #include "object.h"
40 #include "dynobj.h"
41 #include "plugin.h"
43 namespace gold
46 // Class Xindex.
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>
53 void
54 Xindex::initialize_symtab_xindex(Object* object, unsigned int symtab_shndx)
56 if (!this->symtab_xindex_.empty())
57 return;
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();
64 while (i > 0)
66 --i;
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);
71 return;
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
80 // section headers.
82 template<int size, bool big_endian>
83 void
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;
89 if (pshdrs == NULL)
90 contents = object->section_contents(xindex_shndx, &bytecount, false);
91 else
93 const unsigned char* p = (pshdrs
94 + (xindex_shndx
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
112 // index.
114 unsigned int
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"),
120 symndx);
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"),
127 symndx, shndx);
128 return elfcpp::SHN_UNDEF;
130 return shndx;
133 // Class Object.
135 // Report an error for this object file. This is used by the
136 // elfcpp::Elf_file interface, and also called by the Object code
137 // itself.
139 void
140 Object::error(const char* format, ...) const
142 va_list args;
143 va_start(args, format);
144 char* buf = NULL;
145 if (vasprintf(&buf, format, args) < 0)
146 gold_nomem();
147 va_end(args);
148 gold_error(_("%s: %s"), this->name().c_str(), buf);
149 free(buf);
152 // Return a view of the contents of a section.
154 const unsigned char*
155 Object::section_contents(unsigned int shndx, section_size_type* plen,
156 bool cache)
158 Location loc(this->do_section_contents(shndx));
159 *plen = convert_to_section_size_type(loc.data_size);
160 if (*plen == 0)
162 static const unsigned char empty[1] = { '\0' };
163 return empty;
165 return this->get_view(loc.file_offset, *plen, true, cache);
168 // Read the section data into SD. This is code common to Sized_relobj
169 // and Sized_dynobj, so we put it into Object.
171 template<int size, bool big_endian>
172 void
173 Object::read_section_data(elfcpp::Elf_file<size, big_endian, Object>* elf_file,
174 Read_symbols_data* sd)
176 const int shdr_size = elfcpp::Elf_sizes<size>::shdr_size;
178 // Read the section headers.
179 const off_t shoff = elf_file->shoff();
180 const unsigned int shnum = this->shnum();
181 sd->section_headers = this->get_lasting_view(shoff, shnum * shdr_size,
182 true, true);
184 // Read the section names.
185 const unsigned char* pshdrs = sd->section_headers->data();
186 const unsigned char* pshdrnames = pshdrs + elf_file->shstrndx() * shdr_size;
187 typename elfcpp::Shdr<size, big_endian> shdrnames(pshdrnames);
189 if (shdrnames.get_sh_type() != elfcpp::SHT_STRTAB)
190 this->error(_("section name section has wrong type: %u"),
191 static_cast<unsigned int>(shdrnames.get_sh_type()));
193 sd->section_names_size =
194 convert_to_section_size_type(shdrnames.get_sh_size());
195 sd->section_names = this->get_lasting_view(shdrnames.get_sh_offset(),
196 sd->section_names_size, false,
197 false);
200 // If NAME is the name of a special .gnu.warning section, arrange for
201 // the warning to be issued. SHNDX is the section index. Return
202 // whether it is a warning section.
204 bool
205 Object::handle_gnu_warning_section(const char* name, unsigned int shndx,
206 Symbol_table* symtab)
208 const char warn_prefix[] = ".gnu.warning.";
209 const int warn_prefix_len = sizeof warn_prefix - 1;
210 if (strncmp(name, warn_prefix, warn_prefix_len) == 0)
212 // Read the section contents to get the warning text. It would
213 // be nicer if we only did this if we have to actually issue a
214 // warning. Unfortunately, warnings are issued as we relocate
215 // sections. That means that we can not lock the object then,
216 // as we might try to issue the same warning multiple times
217 // simultaneously.
218 section_size_type len;
219 const unsigned char* contents = this->section_contents(shndx, &len,
220 false);
221 if (len == 0)
223 const char* warning = name + warn_prefix_len;
224 contents = reinterpret_cast<const unsigned char*>(warning);
225 len = strlen(warning);
227 std::string warning(reinterpret_cast<const char*>(contents), len);
228 symtab->add_warning(name + warn_prefix_len, this, warning);
229 return true;
231 return false;
234 // If NAME is the name of the special section which indicates that
235 // this object was compiled with -fstack-split, mark it accordingly.
237 bool
238 Object::handle_split_stack_section(const char* name)
240 if (strcmp(name, ".note.GNU-split-stack") == 0)
242 this->uses_split_stack_ = true;
243 return true;
245 if (strcmp(name, ".note.GNU-no-split-stack") == 0)
247 this->has_no_split_stack_ = true;
248 return true;
250 return false;
253 // Class Relobj
255 // To copy the symbols data read from the file to a local data structure.
256 // This function is called from do_layout only while doing garbage
257 // collection.
259 void
260 Relobj::copy_symbols_data(Symbols_data* gc_sd, Read_symbols_data* sd,
261 unsigned int section_header_size)
263 gc_sd->section_headers_data =
264 new unsigned char[(section_header_size)];
265 memcpy(gc_sd->section_headers_data, sd->section_headers->data(),
266 section_header_size);
267 gc_sd->section_names_data =
268 new unsigned char[sd->section_names_size];
269 memcpy(gc_sd->section_names_data, sd->section_names->data(),
270 sd->section_names_size);
271 gc_sd->section_names_size = sd->section_names_size;
272 if (sd->symbols != NULL)
274 gc_sd->symbols_data =
275 new unsigned char[sd->symbols_size];
276 memcpy(gc_sd->symbols_data, sd->symbols->data(),
277 sd->symbols_size);
279 else
281 gc_sd->symbols_data = NULL;
283 gc_sd->symbols_size = sd->symbols_size;
284 gc_sd->external_symbols_offset = sd->external_symbols_offset;
285 if (sd->symbol_names != NULL)
287 gc_sd->symbol_names_data =
288 new unsigned char[sd->symbol_names_size];
289 memcpy(gc_sd->symbol_names_data, sd->symbol_names->data(),
290 sd->symbol_names_size);
292 else
294 gc_sd->symbol_names_data = NULL;
296 gc_sd->symbol_names_size = sd->symbol_names_size;
299 // This function determines if a particular section name must be included
300 // in the link. This is used during garbage collection to determine the
301 // roots of the worklist.
303 bool
304 Relobj::is_section_name_included(const char* name)
306 if (is_prefix_of(".ctors", name)
307 || is_prefix_of(".dtors", name)
308 || is_prefix_of(".note", name)
309 || is_prefix_of(".init", name)
310 || is_prefix_of(".fini", name)
311 || is_prefix_of(".gcc_except_table", name)
312 || is_prefix_of(".jcr", name)
313 || is_prefix_of(".preinit_array", name)
314 || (is_prefix_of(".text", name)
315 && strstr(name, "personality"))
316 || (is_prefix_of(".data", name)
317 && strstr(name, "personality"))
318 || (is_prefix_of(".gnu.linkonce.d", name) &&
319 strstr(name, "personality")))
321 return true;
323 return false;
326 // Class Sized_relobj.
328 template<int size, bool big_endian>
329 Sized_relobj<size, big_endian>::Sized_relobj(
330 const std::string& name,
331 Input_file* input_file,
332 off_t offset,
333 const elfcpp::Ehdr<size, big_endian>& ehdr)
334 : Relobj(name, input_file, offset),
335 elf_file_(this, ehdr),
336 symtab_shndx_(-1U),
337 local_symbol_count_(0),
338 output_local_symbol_count_(0),
339 output_local_dynsym_count_(0),
340 symbols_(),
341 defined_count_(0),
342 local_symbol_offset_(0),
343 local_dynsym_offset_(0),
344 local_values_(),
345 local_got_offsets_(),
346 kept_comdat_sections_(),
347 has_eh_frame_(false),
348 discarded_eh_frame_shndx_(-1U)
352 template<int size, bool big_endian>
353 Sized_relobj<size, big_endian>::~Sized_relobj()
357 // Set up an object file based on the file header. This sets up the
358 // section information.
360 template<int size, bool big_endian>
361 void
362 Sized_relobj<size, big_endian>::do_setup()
364 const unsigned int shnum = this->elf_file_.shnum();
365 this->set_shnum(shnum);
368 // Find the SHT_SYMTAB section, given the section headers. The ELF
369 // standard says that maybe in the future there can be more than one
370 // SHT_SYMTAB section. Until somebody figures out how that could
371 // work, we assume there is only one.
373 template<int size, bool big_endian>
374 void
375 Sized_relobj<size, big_endian>::find_symtab(const unsigned char* pshdrs)
377 const unsigned int shnum = this->shnum();
378 this->symtab_shndx_ = 0;
379 if (shnum > 0)
381 // Look through the sections in reverse order, since gas tends
382 // to put the symbol table at the end.
383 const unsigned char* p = pshdrs + shnum * This::shdr_size;
384 unsigned int i = shnum;
385 unsigned int xindex_shndx = 0;
386 unsigned int xindex_link = 0;
387 while (i > 0)
389 --i;
390 p -= This::shdr_size;
391 typename This::Shdr shdr(p);
392 if (shdr.get_sh_type() == elfcpp::SHT_SYMTAB)
394 this->symtab_shndx_ = i;
395 if (xindex_shndx > 0 && xindex_link == i)
397 Xindex* xindex =
398 new Xindex(this->elf_file_.large_shndx_offset());
399 xindex->read_symtab_xindex<size, big_endian>(this,
400 xindex_shndx,
401 pshdrs);
402 this->set_xindex(xindex);
404 break;
407 // Try to pick up the SHT_SYMTAB_SHNDX section, if there is
408 // one. This will work if it follows the SHT_SYMTAB
409 // section.
410 if (shdr.get_sh_type() == elfcpp::SHT_SYMTAB_SHNDX)
412 xindex_shndx = i;
413 xindex_link = this->adjust_shndx(shdr.get_sh_link());
419 // Return the Xindex structure to use for object with lots of
420 // sections.
422 template<int size, bool big_endian>
423 Xindex*
424 Sized_relobj<size, big_endian>::do_initialize_xindex()
426 gold_assert(this->symtab_shndx_ != -1U);
427 Xindex* xindex = new Xindex(this->elf_file_.large_shndx_offset());
428 xindex->initialize_symtab_xindex<size, big_endian>(this, this->symtab_shndx_);
429 return xindex;
432 // Return whether SHDR has the right type and flags to be a GNU
433 // .eh_frame section.
435 template<int size, bool big_endian>
436 bool
437 Sized_relobj<size, big_endian>::check_eh_frame_flags(
438 const elfcpp::Shdr<size, big_endian>* shdr) const
440 return (shdr->get_sh_type() == elfcpp::SHT_PROGBITS
441 && (shdr->get_sh_flags() & elfcpp::SHF_ALLOC) != 0);
444 // Return whether there is a GNU .eh_frame section, given the section
445 // headers and the section names.
447 template<int size, bool big_endian>
448 bool
449 Sized_relobj<size, big_endian>::find_eh_frame(
450 const unsigned char* pshdrs,
451 const char* names,
452 section_size_type names_size) const
454 const unsigned int shnum = this->shnum();
455 const unsigned char* p = pshdrs + This::shdr_size;
456 for (unsigned int i = 1; i < shnum; ++i, p += This::shdr_size)
458 typename This::Shdr shdr(p);
459 if (this->check_eh_frame_flags(&shdr))
461 if (shdr.get_sh_name() >= names_size)
463 this->error(_("bad section name offset for section %u: %lu"),
464 i, static_cast<unsigned long>(shdr.get_sh_name()));
465 continue;
468 const char* name = names + shdr.get_sh_name();
469 if (strcmp(name, ".eh_frame") == 0)
470 return true;
473 return false;
476 // Read the sections and symbols from an object file.
478 template<int size, bool big_endian>
479 void
480 Sized_relobj<size, big_endian>::do_read_symbols(Read_symbols_data* sd)
482 this->read_section_data(&this->elf_file_, sd);
484 const unsigned char* const pshdrs = sd->section_headers->data();
486 this->find_symtab(pshdrs);
488 const unsigned char* namesu = sd->section_names->data();
489 const char* names = reinterpret_cast<const char*>(namesu);
490 if (memmem(names, sd->section_names_size, ".eh_frame", 10) != NULL)
492 if (this->find_eh_frame(pshdrs, names, sd->section_names_size))
493 this->has_eh_frame_ = true;
496 sd->symbols = NULL;
497 sd->symbols_size = 0;
498 sd->external_symbols_offset = 0;
499 sd->symbol_names = NULL;
500 sd->symbol_names_size = 0;
502 if (this->symtab_shndx_ == 0)
504 // No symbol table. Weird but legal.
505 return;
508 // Get the symbol table section header.
509 typename This::Shdr symtabshdr(pshdrs
510 + this->symtab_shndx_ * This::shdr_size);
511 gold_assert(symtabshdr.get_sh_type() == elfcpp::SHT_SYMTAB);
513 // If this object has a .eh_frame section, we need all the symbols.
514 // Otherwise we only need the external symbols. While it would be
515 // simpler to just always read all the symbols, I've seen object
516 // files with well over 2000 local symbols, which for a 64-bit
517 // object file format is over 5 pages that we don't need to read
518 // now.
520 const int sym_size = This::sym_size;
521 const unsigned int loccount = symtabshdr.get_sh_info();
522 this->local_symbol_count_ = loccount;
523 this->local_values_.resize(loccount);
524 section_offset_type locsize = loccount * sym_size;
525 off_t dataoff = symtabshdr.get_sh_offset();
526 section_size_type datasize =
527 convert_to_section_size_type(symtabshdr.get_sh_size());
528 off_t extoff = dataoff + locsize;
529 section_size_type extsize = datasize - locsize;
531 off_t readoff = this->has_eh_frame_ ? dataoff : extoff;
532 section_size_type readsize = this->has_eh_frame_ ? datasize : extsize;
534 if (readsize == 0)
536 // No external symbols. Also weird but also legal.
537 return;
540 File_view* fvsymtab = this->get_lasting_view(readoff, readsize, true, false);
542 // Read the section header for the symbol names.
543 unsigned int strtab_shndx = this->adjust_shndx(symtabshdr.get_sh_link());
544 if (strtab_shndx >= this->shnum())
546 this->error(_("invalid symbol table name index: %u"), strtab_shndx);
547 return;
549 typename This::Shdr strtabshdr(pshdrs + strtab_shndx * This::shdr_size);
550 if (strtabshdr.get_sh_type() != elfcpp::SHT_STRTAB)
552 this->error(_("symbol table name section has wrong type: %u"),
553 static_cast<unsigned int>(strtabshdr.get_sh_type()));
554 return;
557 // Read the symbol names.
558 File_view* fvstrtab = this->get_lasting_view(strtabshdr.get_sh_offset(),
559 strtabshdr.get_sh_size(),
560 false, true);
562 sd->symbols = fvsymtab;
563 sd->symbols_size = readsize;
564 sd->external_symbols_offset = this->has_eh_frame_ ? locsize : 0;
565 sd->symbol_names = fvstrtab;
566 sd->symbol_names_size =
567 convert_to_section_size_type(strtabshdr.get_sh_size());
570 // Return the section index of symbol SYM. Set *VALUE to its value in
571 // the object file. Set *IS_ORDINARY if this is an ordinary section
572 // index. not a special cod between SHN_LORESERVE and SHN_HIRESERVE.
573 // Note that for a symbol which is not defined in this object file,
574 // this will set *VALUE to 0 and return SHN_UNDEF; it will not return
575 // the final value of the symbol in the link.
577 template<int size, bool big_endian>
578 unsigned int
579 Sized_relobj<size, big_endian>::symbol_section_and_value(unsigned int sym,
580 Address* value,
581 bool* is_ordinary)
583 section_size_type symbols_size;
584 const unsigned char* symbols = this->section_contents(this->symtab_shndx_,
585 &symbols_size,
586 false);
588 const size_t count = symbols_size / This::sym_size;
589 gold_assert(sym < count);
591 elfcpp::Sym<size, big_endian> elfsym(symbols + sym * This::sym_size);
592 *value = elfsym.get_st_value();
594 return this->adjust_sym_shndx(sym, elfsym.get_st_shndx(), is_ordinary);
597 // Return whether to include a section group in the link. LAYOUT is
598 // used to keep track of which section groups we have already seen.
599 // INDEX is the index of the section group and SHDR is the section
600 // header. If we do not want to include this group, we set bits in
601 // OMIT for each section which should be discarded.
603 template<int size, bool big_endian>
604 bool
605 Sized_relobj<size, big_endian>::include_section_group(
606 Symbol_table* symtab,
607 Layout* layout,
608 unsigned int index,
609 const char* name,
610 const unsigned char* shdrs,
611 const char* section_names,
612 section_size_type section_names_size,
613 std::vector<bool>* omit)
615 // Read the section contents.
616 typename This::Shdr shdr(shdrs + index * This::shdr_size);
617 const unsigned char* pcon = this->get_view(shdr.get_sh_offset(),
618 shdr.get_sh_size(), true, false);
619 const elfcpp::Elf_Word* pword =
620 reinterpret_cast<const elfcpp::Elf_Word*>(pcon);
622 // The first word contains flags. We only care about COMDAT section
623 // groups. Other section groups are always included in the link
624 // just like ordinary sections.
625 elfcpp::Elf_Word flags = elfcpp::Swap<32, big_endian>::readval(pword);
627 // Look up the group signature, which is the name of a symbol. This
628 // is a lot of effort to go to to read a string. Why didn't they
629 // just have the group signature point into the string table, rather
630 // than indirect through a symbol?
632 // Get the appropriate symbol table header (this will normally be
633 // the single SHT_SYMTAB section, but in principle it need not be).
634 const unsigned int link = this->adjust_shndx(shdr.get_sh_link());
635 typename This::Shdr symshdr(this, this->elf_file_.section_header(link));
637 // Read the symbol table entry.
638 unsigned int symndx = shdr.get_sh_info();
639 if (symndx >= symshdr.get_sh_size() / This::sym_size)
641 this->error(_("section group %u info %u out of range"),
642 index, symndx);
643 return false;
645 off_t symoff = symshdr.get_sh_offset() + symndx * This::sym_size;
646 const unsigned char* psym = this->get_view(symoff, This::sym_size, true,
647 false);
648 elfcpp::Sym<size, big_endian> sym(psym);
650 // Read the symbol table names.
651 section_size_type symnamelen;
652 const unsigned char* psymnamesu;
653 psymnamesu = this->section_contents(this->adjust_shndx(symshdr.get_sh_link()),
654 &symnamelen, true);
655 const char* psymnames = reinterpret_cast<const char*>(psymnamesu);
657 // Get the section group signature.
658 if (sym.get_st_name() >= symnamelen)
660 this->error(_("symbol %u name offset %u out of range"),
661 symndx, sym.get_st_name());
662 return false;
665 std::string signature(psymnames + sym.get_st_name());
667 // It seems that some versions of gas will create a section group
668 // associated with a section symbol, and then fail to give a name to
669 // the section symbol. In such a case, use the name of the section.
670 if (signature[0] == '\0' && sym.get_st_type() == elfcpp::STT_SECTION)
672 bool is_ordinary;
673 unsigned int sym_shndx = this->adjust_sym_shndx(symndx,
674 sym.get_st_shndx(),
675 &is_ordinary);
676 if (!is_ordinary || sym_shndx >= this->shnum())
678 this->error(_("symbol %u invalid section index %u"),
679 symndx, sym_shndx);
680 return false;
682 typename This::Shdr member_shdr(shdrs + sym_shndx * This::shdr_size);
683 if (member_shdr.get_sh_name() < section_names_size)
684 signature = section_names + member_shdr.get_sh_name();
687 // Record this section group in the layout, and see whether we've already
688 // seen one with the same signature.
689 bool include_group;
690 bool is_comdat;
691 Kept_section* kept_section = NULL;
693 if ((flags & elfcpp::GRP_COMDAT) == 0)
695 include_group = true;
696 is_comdat = false;
698 else
700 include_group = layout->find_or_add_kept_section(signature,
701 this, index, true,
702 true, &kept_section);
703 is_comdat = true;
706 size_t count = shdr.get_sh_size() / sizeof(elfcpp::Elf_Word);
708 std::vector<unsigned int> shndxes;
709 bool relocate_group = include_group && parameters->options().relocatable();
710 if (relocate_group)
711 shndxes.reserve(count - 1);
713 for (size_t i = 1; i < count; ++i)
715 elfcpp::Elf_Word shndx =
716 this->adjust_shndx(elfcpp::Swap<32, big_endian>::readval(pword + i));
718 if (relocate_group)
719 shndxes.push_back(shndx);
721 if (shndx >= this->shnum())
723 this->error(_("section %u in section group %u out of range"),
724 shndx, index);
725 continue;
728 // Check for an earlier section number, since we're going to get
729 // it wrong--we may have already decided to include the section.
730 if (shndx < index)
731 this->error(_("invalid section group %u refers to earlier section %u"),
732 index, shndx);
734 // Get the name of the member section.
735 typename This::Shdr member_shdr(shdrs + shndx * This::shdr_size);
736 if (member_shdr.get_sh_name() >= section_names_size)
738 // This is an error, but it will be diagnosed eventually
739 // in do_layout, so we don't need to do anything here but
740 // ignore it.
741 continue;
743 std::string mname(section_names + member_shdr.get_sh_name());
745 if (include_group)
747 if (is_comdat)
748 kept_section->add_comdat_section(mname, shndx,
749 member_shdr.get_sh_size());
751 else
753 (*omit)[shndx] = true;
755 if (is_comdat)
757 Relobj* kept_object = kept_section->object();
758 if (kept_section->is_comdat())
760 // Find the corresponding kept section, and store
761 // that info in the discarded section table.
762 unsigned int kept_shndx;
763 uint64_t kept_size;
764 if (kept_section->find_comdat_section(mname, &kept_shndx,
765 &kept_size))
767 // We don't keep a mapping for this section if
768 // it has a different size. The mapping is only
769 // used for relocation processing, and we don't
770 // want to treat the sections as similar if the
771 // sizes are different. Checking the section
772 // size is the approach used by the GNU linker.
773 if (kept_size == member_shdr.get_sh_size())
774 this->set_kept_comdat_section(shndx, kept_object,
775 kept_shndx);
778 else
780 // The existing section is a linkonce section. Add
781 // a mapping if there is exactly one section in the
782 // group (which is true when COUNT == 2) and if it
783 // is the same size.
784 if (count == 2
785 && (kept_section->linkonce_size()
786 == member_shdr.get_sh_size()))
787 this->set_kept_comdat_section(shndx, kept_object,
788 kept_section->shndx());
794 if (relocate_group)
795 layout->layout_group(symtab, this, index, name, signature.c_str(),
796 shdr, flags, &shndxes);
798 return include_group;
801 // Whether to include a linkonce section in the link. NAME is the
802 // name of the section and SHDR is the section header.
804 // Linkonce sections are a GNU extension implemented in the original
805 // GNU linker before section groups were defined. The semantics are
806 // that we only include one linkonce section with a given name. The
807 // name of a linkonce section is normally .gnu.linkonce.T.SYMNAME,
808 // where T is the type of section and SYMNAME is the name of a symbol.
809 // In an attempt to make linkonce sections interact well with section
810 // groups, we try to identify SYMNAME and use it like a section group
811 // signature. We want to block section groups with that signature,
812 // but not other linkonce sections with that signature. We also use
813 // the full name of the linkonce section as a normal section group
814 // signature.
816 template<int size, bool big_endian>
817 bool
818 Sized_relobj<size, big_endian>::include_linkonce_section(
819 Layout* layout,
820 unsigned int index,
821 const char* name,
822 const elfcpp::Shdr<size, big_endian>& shdr)
824 typename elfcpp::Elf_types<size>::Elf_WXword sh_size = shdr.get_sh_size();
825 // In general the symbol name we want will be the string following
826 // the last '.'. However, we have to handle the case of
827 // .gnu.linkonce.t.__i686.get_pc_thunk.bx, which was generated by
828 // some versions of gcc. So we use a heuristic: if the name starts
829 // with ".gnu.linkonce.t.", we use everything after that. Otherwise
830 // we look for the last '.'. We can't always simply skip
831 // ".gnu.linkonce.X", because we have to deal with cases like
832 // ".gnu.linkonce.d.rel.ro.local".
833 const char* const linkonce_t = ".gnu.linkonce.t.";
834 const char* symname;
835 if (strncmp(name, linkonce_t, strlen(linkonce_t)) == 0)
836 symname = name + strlen(linkonce_t);
837 else
838 symname = strrchr(name, '.') + 1;
839 std::string sig1(symname);
840 std::string sig2(name);
841 Kept_section* kept1;
842 Kept_section* kept2;
843 bool include1 = layout->find_or_add_kept_section(sig1, this, index, false,
844 false, &kept1);
845 bool include2 = layout->find_or_add_kept_section(sig2, this, index, false,
846 true, &kept2);
848 if (!include2)
850 // We are not including this section because we already saw the
851 // name of the section as a signature. This normally implies
852 // that the kept section is another linkonce section. If it is
853 // the same size, record it as the section which corresponds to
854 // this one.
855 if (kept2->object() != NULL
856 && !kept2->is_comdat()
857 && kept2->linkonce_size() == sh_size)
858 this->set_kept_comdat_section(index, kept2->object(), kept2->shndx());
860 else if (!include1)
862 // The section is being discarded on the basis of its symbol
863 // name. This means that the corresponding kept section was
864 // part of a comdat group, and it will be difficult to identify
865 // the specific section within that group that corresponds to
866 // this linkonce section. We'll handle the simple case where
867 // the group has only one member section. Otherwise, it's not
868 // worth the effort.
869 unsigned int kept_shndx;
870 uint64_t kept_size;
871 if (kept1->object() != NULL
872 && kept1->is_comdat()
873 && kept1->find_single_comdat_section(&kept_shndx, &kept_size)
874 && kept_size == sh_size)
875 this->set_kept_comdat_section(index, kept1->object(), kept_shndx);
877 else
879 kept1->set_linkonce_size(sh_size);
880 kept2->set_linkonce_size(sh_size);
883 return include1 && include2;
886 // Layout an input section.
888 template<int size, bool big_endian>
889 inline void
890 Sized_relobj<size, big_endian>::layout_section(Layout* layout,
891 unsigned int shndx,
892 const char* name,
893 typename This::Shdr& shdr,
894 unsigned int reloc_shndx,
895 unsigned int reloc_type)
897 off_t offset;
898 Output_section* os = layout->layout(this, shndx, name, shdr,
899 reloc_shndx, reloc_type, &offset);
901 this->output_sections()[shndx] = os;
902 if (offset == -1)
903 this->section_offsets_[shndx] = invalid_address;
904 else
905 this->section_offsets_[shndx] = convert_types<Address, off_t>(offset);
907 // If this section requires special handling, and if there are
908 // relocs that apply to it, then we must do the special handling
909 // before we apply the relocs.
910 if (offset == -1 && reloc_shndx != 0)
911 this->set_relocs_must_follow_section_writes();
914 // Lay out the input sections. We walk through the sections and check
915 // whether they should be included in the link. If they should, we
916 // pass them to the Layout object, which will return an output section
917 // and an offset.
918 // During garbage collection (--gc-sections) and identical code folding
919 // (--icf), this function is called twice. When it is called the first
920 // time, it is for setting up some sections as roots to a work-list for
921 // --gc-sections and to do comdat processing. Actual layout happens the
922 // second time around after all the relevant sections have been determined.
923 // The first time, is_worklist_ready or is_icf_ready is false. It is then
924 // set to true after the garbage collection worklist or identical code
925 // folding is processed and the relevant sections to be kept are
926 // determined. Then, this function is called again to layout the sections.
928 template<int size, bool big_endian>
929 void
930 Sized_relobj<size, big_endian>::do_layout(Symbol_table* symtab,
931 Layout* layout,
932 Read_symbols_data* sd)
934 const unsigned int shnum = this->shnum();
935 bool is_gc_pass_one = ((parameters->options().gc_sections()
936 && !symtab->gc()->is_worklist_ready())
937 || (parameters->options().icf_enabled()
938 && !symtab->icf()->is_icf_ready()));
940 bool is_gc_pass_two = ((parameters->options().gc_sections()
941 && symtab->gc()->is_worklist_ready())
942 || (parameters->options().icf_enabled()
943 && symtab->icf()->is_icf_ready()));
945 bool is_gc_or_icf = (parameters->options().gc_sections()
946 || parameters->options().icf_enabled());
948 // Both is_gc_pass_one and is_gc_pass_two should not be true.
949 gold_assert(!(is_gc_pass_one && is_gc_pass_two));
951 if (shnum == 0)
952 return;
953 Symbols_data* gc_sd = NULL;
954 if (is_gc_pass_one)
956 // During garbage collection save the symbols data to use it when
957 // re-entering this function.
958 gc_sd = new Symbols_data;
959 this->copy_symbols_data(gc_sd, sd, This::shdr_size * shnum);
960 this->set_symbols_data(gc_sd);
962 else if (is_gc_pass_two)
964 gc_sd = this->get_symbols_data();
967 const unsigned char* section_headers_data = NULL;
968 section_size_type section_names_size;
969 const unsigned char* symbols_data = NULL;
970 section_size_type symbols_size;
971 section_offset_type external_symbols_offset;
972 const unsigned char* symbol_names_data = NULL;
973 section_size_type symbol_names_size;
975 if (is_gc_or_icf)
977 section_headers_data = gc_sd->section_headers_data;
978 section_names_size = gc_sd->section_names_size;
979 symbols_data = gc_sd->symbols_data;
980 symbols_size = gc_sd->symbols_size;
981 external_symbols_offset = gc_sd->external_symbols_offset;
982 symbol_names_data = gc_sd->symbol_names_data;
983 symbol_names_size = gc_sd->symbol_names_size;
985 else
987 section_headers_data = sd->section_headers->data();
988 section_names_size = sd->section_names_size;
989 if (sd->symbols != NULL)
990 symbols_data = sd->symbols->data();
991 symbols_size = sd->symbols_size;
992 external_symbols_offset = sd->external_symbols_offset;
993 if (sd->symbol_names != NULL)
994 symbol_names_data = sd->symbol_names->data();
995 symbol_names_size = sd->symbol_names_size;
998 // Get the section headers.
999 const unsigned char* shdrs = section_headers_data;
1000 const unsigned char* pshdrs;
1002 // Get the section names.
1003 const unsigned char* pnamesu = (is_gc_or_icf)
1004 ? gc_sd->section_names_data
1005 : sd->section_names->data();
1007 const char* pnames = reinterpret_cast<const char*>(pnamesu);
1009 // If any input files have been claimed by plugins, we need to defer
1010 // actual layout until the replacement files have arrived.
1011 const bool should_defer_layout =
1012 (parameters->options().has_plugins()
1013 && parameters->options().plugins()->should_defer_layout());
1014 unsigned int num_sections_to_defer = 0;
1016 // For each section, record the index of the reloc section if any.
1017 // Use 0 to mean that there is no reloc section, -1U to mean that
1018 // there is more than one.
1019 std::vector<unsigned int> reloc_shndx(shnum, 0);
1020 std::vector<unsigned int> reloc_type(shnum, elfcpp::SHT_NULL);
1021 // Skip the first, dummy, section.
1022 pshdrs = shdrs + This::shdr_size;
1023 for (unsigned int i = 1; i < shnum; ++i, pshdrs += This::shdr_size)
1025 typename This::Shdr shdr(pshdrs);
1027 // Count the number of sections whose layout will be deferred.
1028 if (should_defer_layout && (shdr.get_sh_flags() & elfcpp::SHF_ALLOC))
1029 ++num_sections_to_defer;
1031 unsigned int sh_type = shdr.get_sh_type();
1032 if (sh_type == elfcpp::SHT_REL || sh_type == elfcpp::SHT_RELA)
1034 unsigned int target_shndx = this->adjust_shndx(shdr.get_sh_info());
1035 if (target_shndx == 0 || target_shndx >= shnum)
1037 this->error(_("relocation section %u has bad info %u"),
1038 i, target_shndx);
1039 continue;
1042 if (reloc_shndx[target_shndx] != 0)
1043 reloc_shndx[target_shndx] = -1U;
1044 else
1046 reloc_shndx[target_shndx] = i;
1047 reloc_type[target_shndx] = sh_type;
1052 Output_sections& out_sections(this->output_sections());
1053 std::vector<Address>& out_section_offsets(this->section_offsets_);
1055 if (!is_gc_pass_two)
1057 out_sections.resize(shnum);
1058 out_section_offsets.resize(shnum);
1061 // If we are only linking for symbols, then there is nothing else to
1062 // do here.
1063 if (this->input_file()->just_symbols())
1065 if (!is_gc_pass_two)
1067 delete sd->section_headers;
1068 sd->section_headers = NULL;
1069 delete sd->section_names;
1070 sd->section_names = NULL;
1072 return;
1075 if (num_sections_to_defer > 0)
1077 parameters->options().plugins()->add_deferred_layout_object(this);
1078 this->deferred_layout_.reserve(num_sections_to_defer);
1081 // Whether we've seen a .note.GNU-stack section.
1082 bool seen_gnu_stack = false;
1083 // The flags of a .note.GNU-stack section.
1084 uint64_t gnu_stack_flags = 0;
1086 // Keep track of which sections to omit.
1087 std::vector<bool> omit(shnum, false);
1089 // Keep track of reloc sections when emitting relocations.
1090 const bool relocatable = parameters->options().relocatable();
1091 const bool emit_relocs = (relocatable
1092 || parameters->options().emit_relocs());
1093 std::vector<unsigned int> reloc_sections;
1095 // Keep track of .eh_frame sections.
1096 std::vector<unsigned int> eh_frame_sections;
1098 // Skip the first, dummy, section.
1099 pshdrs = shdrs + This::shdr_size;
1100 for (unsigned int i = 1; i < shnum; ++i, pshdrs += This::shdr_size)
1102 typename This::Shdr shdr(pshdrs);
1104 if (shdr.get_sh_name() >= section_names_size)
1106 this->error(_("bad section name offset for section %u: %lu"),
1107 i, static_cast<unsigned long>(shdr.get_sh_name()));
1108 return;
1111 const char* name = pnames + shdr.get_sh_name();
1113 if (!is_gc_pass_two)
1115 if (this->handle_gnu_warning_section(name, i, symtab))
1117 if (!relocatable)
1118 omit[i] = true;
1121 // The .note.GNU-stack section is special. It gives the
1122 // protection flags that this object file requires for the stack
1123 // in memory.
1124 if (strcmp(name, ".note.GNU-stack") == 0)
1126 seen_gnu_stack = true;
1127 gnu_stack_flags |= shdr.get_sh_flags();
1128 omit[i] = true;
1131 // The .note.GNU-split-stack section is also special. It
1132 // indicates that the object was compiled with
1133 // -fsplit-stack.
1134 if (this->handle_split_stack_section(name))
1136 if (!parameters->options().relocatable()
1137 && !parameters->options().shared())
1138 omit[i] = true;
1141 bool discard = omit[i];
1142 if (!discard)
1144 if (shdr.get_sh_type() == elfcpp::SHT_GROUP)
1146 if (!this->include_section_group(symtab, layout, i, name,
1147 shdrs, pnames,
1148 section_names_size,
1149 &omit))
1150 discard = true;
1152 else if ((shdr.get_sh_flags() & elfcpp::SHF_GROUP) == 0
1153 && Layout::is_linkonce(name))
1155 if (!this->include_linkonce_section(layout, i, name, shdr))
1156 discard = true;
1160 if (discard)
1162 // Do not include this section in the link.
1163 out_sections[i] = NULL;
1164 out_section_offsets[i] = invalid_address;
1165 continue;
1169 if (is_gc_pass_one && parameters->options().gc_sections())
1171 if (is_section_name_included(name)
1172 || shdr.get_sh_type() == elfcpp::SHT_INIT_ARRAY
1173 || shdr.get_sh_type() == elfcpp::SHT_FINI_ARRAY)
1175 symtab->gc()->worklist().push(Section_id(this, i));
1179 // When doing a relocatable link we are going to copy input
1180 // reloc sections into the output. We only want to copy the
1181 // ones associated with sections which are not being discarded.
1182 // However, we don't know that yet for all sections. So save
1183 // reloc sections and process them later. Garbage collection is
1184 // not triggered when relocatable code is desired.
1185 if (emit_relocs
1186 && (shdr.get_sh_type() == elfcpp::SHT_REL
1187 || shdr.get_sh_type() == elfcpp::SHT_RELA))
1189 reloc_sections.push_back(i);
1190 continue;
1193 if (relocatable && shdr.get_sh_type() == elfcpp::SHT_GROUP)
1194 continue;
1196 // The .eh_frame section is special. It holds exception frame
1197 // information that we need to read in order to generate the
1198 // exception frame header. We process these after all the other
1199 // sections so that the exception frame reader can reliably
1200 // determine which sections are being discarded, and discard the
1201 // corresponding information.
1202 if (!relocatable
1203 && strcmp(name, ".eh_frame") == 0
1204 && this->check_eh_frame_flags(&shdr))
1206 if (is_gc_pass_one)
1208 out_sections[i] = reinterpret_cast<Output_section*>(1);
1209 out_section_offsets[i] = invalid_address;
1211 else
1212 eh_frame_sections.push_back(i);
1213 continue;
1216 if (is_gc_pass_two && parameters->options().gc_sections())
1218 // This is executed during the second pass of garbage
1219 // collection. do_layout has been called before and some
1220 // sections have been already discarded. Simply ignore
1221 // such sections this time around.
1222 if (out_sections[i] == NULL)
1224 gold_assert(out_section_offsets[i] == invalid_address);
1225 continue;
1227 if (((shdr.get_sh_flags() & elfcpp::SHF_ALLOC) != 0)
1228 && symtab->gc()->is_section_garbage(this, i))
1230 if (parameters->options().print_gc_sections())
1231 gold_info(_("%s: removing unused section from '%s'"
1232 " in file '%s'"),
1233 program_name, this->section_name(i).c_str(),
1234 this->name().c_str());
1235 out_sections[i] = NULL;
1236 out_section_offsets[i] = invalid_address;
1237 continue;
1241 if (is_gc_pass_two && parameters->options().icf_enabled())
1243 if (out_sections[i] == NULL)
1245 gold_assert(out_section_offsets[i] == invalid_address);
1246 continue;
1248 if (((shdr.get_sh_flags() & elfcpp::SHF_ALLOC) != 0)
1249 && symtab->icf()->is_section_folded(this, i))
1251 if (parameters->options().print_icf_sections())
1253 Section_id folded =
1254 symtab->icf()->get_folded_section(this, i);
1255 Relobj* folded_obj =
1256 reinterpret_cast<Relobj*>(folded.first);
1257 gold_info(_("%s: ICF folding section '%s' in file '%s'"
1258 "into '%s' in file '%s'"),
1259 program_name, this->section_name(i).c_str(),
1260 this->name().c_str(),
1261 folded_obj->section_name(folded.second).c_str(),
1262 folded_obj->name().c_str());
1264 out_sections[i] = NULL;
1265 out_section_offsets[i] = invalid_address;
1266 continue;
1270 // Defer layout here if input files are claimed by plugins. When gc
1271 // is turned on this function is called twice. For the second call
1272 // should_defer_layout should be false.
1273 if (should_defer_layout && (shdr.get_sh_flags() & elfcpp::SHF_ALLOC))
1275 gold_assert(!is_gc_pass_two);
1276 this->deferred_layout_.push_back(Deferred_layout(i, name,
1277 pshdrs,
1278 reloc_shndx[i],
1279 reloc_type[i]));
1280 // Put dummy values here; real values will be supplied by
1281 // do_layout_deferred_sections.
1282 out_sections[i] = reinterpret_cast<Output_section*>(2);
1283 out_section_offsets[i] = invalid_address;
1284 continue;
1287 // During gc_pass_two if a section that was previously deferred is
1288 // found, do not layout the section as layout_deferred_sections will
1289 // do it later from gold.cc.
1290 if (is_gc_pass_two
1291 && (out_sections[i] == reinterpret_cast<Output_section*>(2)))
1292 continue;
1294 if (is_gc_pass_one)
1296 // This is during garbage collection. The out_sections are
1297 // assigned in the second call to this function.
1298 out_sections[i] = reinterpret_cast<Output_section*>(1);
1299 out_section_offsets[i] = invalid_address;
1301 else
1303 // When garbage collection is switched on the actual layout
1304 // only happens in the second call.
1305 this->layout_section(layout, i, name, shdr, reloc_shndx[i],
1306 reloc_type[i]);
1310 if (!is_gc_pass_one)
1311 layout->layout_gnu_stack(seen_gnu_stack, gnu_stack_flags);
1313 // When doing a relocatable link handle the reloc sections at the
1314 // end. Garbage collection and Identical Code Folding is not
1315 // turned on for relocatable code.
1316 if (emit_relocs)
1317 this->size_relocatable_relocs();
1319 gold_assert(!(is_gc_or_icf) || reloc_sections.empty());
1321 for (std::vector<unsigned int>::const_iterator p = reloc_sections.begin();
1322 p != reloc_sections.end();
1323 ++p)
1325 unsigned int i = *p;
1326 const unsigned char* pshdr;
1327 pshdr = section_headers_data + i * This::shdr_size;
1328 typename This::Shdr shdr(pshdr);
1330 unsigned int data_shndx = this->adjust_shndx(shdr.get_sh_info());
1331 if (data_shndx >= shnum)
1333 // We already warned about this above.
1334 continue;
1337 Output_section* data_section = out_sections[data_shndx];
1338 if (data_section == NULL)
1340 out_sections[i] = NULL;
1341 out_section_offsets[i] = invalid_address;
1342 continue;
1345 Relocatable_relocs* rr = new Relocatable_relocs();
1346 this->set_relocatable_relocs(i, rr);
1348 Output_section* os = layout->layout_reloc(this, i, shdr, data_section,
1349 rr);
1350 out_sections[i] = os;
1351 out_section_offsets[i] = invalid_address;
1354 // Handle the .eh_frame sections at the end.
1355 gold_assert(!is_gc_pass_one || eh_frame_sections.empty());
1356 for (std::vector<unsigned int>::const_iterator p = eh_frame_sections.begin();
1357 p != eh_frame_sections.end();
1358 ++p)
1360 gold_assert(this->has_eh_frame_);
1361 gold_assert(external_symbols_offset != 0);
1363 unsigned int i = *p;
1364 const unsigned char *pshdr;
1365 pshdr = section_headers_data + i * This::shdr_size;
1366 typename This::Shdr shdr(pshdr);
1368 off_t offset;
1369 Output_section* os = layout->layout_eh_frame(this,
1370 symbols_data,
1371 symbols_size,
1372 symbol_names_data,
1373 symbol_names_size,
1374 i, shdr,
1375 reloc_shndx[i],
1376 reloc_type[i],
1377 &offset);
1378 out_sections[i] = os;
1379 if (offset == -1)
1381 // An object can contain at most one section holding exception
1382 // frame information.
1383 gold_assert(this->discarded_eh_frame_shndx_ == -1U);
1384 this->discarded_eh_frame_shndx_ = i;
1385 out_section_offsets[i] = invalid_address;
1387 else
1388 out_section_offsets[i] = convert_types<Address, off_t>(offset);
1390 // If this section requires special handling, and if there are
1391 // relocs that apply to it, then we must do the special handling
1392 // before we apply the relocs.
1393 if (offset == -1 && reloc_shndx[i] != 0)
1394 this->set_relocs_must_follow_section_writes();
1397 if (is_gc_pass_two)
1399 delete[] gc_sd->section_headers_data;
1400 delete[] gc_sd->section_names_data;
1401 delete[] gc_sd->symbols_data;
1402 delete[] gc_sd->symbol_names_data;
1403 this->set_symbols_data(NULL);
1405 else
1407 delete sd->section_headers;
1408 sd->section_headers = NULL;
1409 delete sd->section_names;
1410 sd->section_names = NULL;
1414 // Layout sections whose layout was deferred while waiting for
1415 // input files from a plugin.
1417 template<int size, bool big_endian>
1418 void
1419 Sized_relobj<size, big_endian>::do_layout_deferred_sections(Layout* layout)
1421 typename std::vector<Deferred_layout>::iterator deferred;
1423 for (deferred = this->deferred_layout_.begin();
1424 deferred != this->deferred_layout_.end();
1425 ++deferred)
1427 typename This::Shdr shdr(deferred->shdr_data_);
1428 this->layout_section(layout, deferred->shndx_, deferred->name_.c_str(),
1429 shdr, deferred->reloc_shndx_, deferred->reloc_type_);
1432 this->deferred_layout_.clear();
1435 // Add the symbols to the symbol table.
1437 template<int size, bool big_endian>
1438 void
1439 Sized_relobj<size, big_endian>::do_add_symbols(Symbol_table* symtab,
1440 Read_symbols_data* sd,
1441 Layout*)
1443 if (sd->symbols == NULL)
1445 gold_assert(sd->symbol_names == NULL);
1446 return;
1449 const int sym_size = This::sym_size;
1450 size_t symcount = ((sd->symbols_size - sd->external_symbols_offset)
1451 / sym_size);
1452 if (symcount * sym_size != sd->symbols_size - sd->external_symbols_offset)
1454 this->error(_("size of symbols is not multiple of symbol size"));
1455 return;
1458 this->symbols_.resize(symcount);
1460 const char* sym_names =
1461 reinterpret_cast<const char*>(sd->symbol_names->data());
1462 symtab->add_from_relobj(this,
1463 sd->symbols->data() + sd->external_symbols_offset,
1464 symcount, this->local_symbol_count_,
1465 sym_names, sd->symbol_names_size,
1466 &this->symbols_,
1467 &this->defined_count_);
1469 delete sd->symbols;
1470 sd->symbols = NULL;
1471 delete sd->symbol_names;
1472 sd->symbol_names = NULL;
1475 // First pass over the local symbols. Here we add their names to
1476 // *POOL and *DYNPOOL, and we store the symbol value in
1477 // THIS->LOCAL_VALUES_. This function is always called from a
1478 // singleton thread. This is followed by a call to
1479 // finalize_local_symbols.
1481 template<int size, bool big_endian>
1482 void
1483 Sized_relobj<size, big_endian>::do_count_local_symbols(Stringpool* pool,
1484 Stringpool* dynpool)
1486 gold_assert(this->symtab_shndx_ != -1U);
1487 if (this->symtab_shndx_ == 0)
1489 // This object has no symbols. Weird but legal.
1490 return;
1493 // Read the symbol table section header.
1494 const unsigned int symtab_shndx = this->symtab_shndx_;
1495 typename This::Shdr symtabshdr(this,
1496 this->elf_file_.section_header(symtab_shndx));
1497 gold_assert(symtabshdr.get_sh_type() == elfcpp::SHT_SYMTAB);
1499 // Read the local symbols.
1500 const int sym_size = This::sym_size;
1501 const unsigned int loccount = this->local_symbol_count_;
1502 gold_assert(loccount == symtabshdr.get_sh_info());
1503 off_t locsize = loccount * sym_size;
1504 const unsigned char* psyms = this->get_view(symtabshdr.get_sh_offset(),
1505 locsize, true, true);
1507 // Read the symbol names.
1508 const unsigned int strtab_shndx =
1509 this->adjust_shndx(symtabshdr.get_sh_link());
1510 section_size_type strtab_size;
1511 const unsigned char* pnamesu = this->section_contents(strtab_shndx,
1512 &strtab_size,
1513 true);
1514 const char* pnames = reinterpret_cast<const char*>(pnamesu);
1516 // Loop over the local symbols.
1518 const Output_sections& out_sections(this->output_sections());
1519 unsigned int shnum = this->shnum();
1520 unsigned int count = 0;
1521 unsigned int dyncount = 0;
1522 // Skip the first, dummy, symbol.
1523 psyms += sym_size;
1524 bool discard_locals = parameters->options().discard_locals();
1525 for (unsigned int i = 1; i < loccount; ++i, psyms += sym_size)
1527 elfcpp::Sym<size, big_endian> sym(psyms);
1529 Symbol_value<size>& lv(this->local_values_[i]);
1531 bool is_ordinary;
1532 unsigned int shndx = this->adjust_sym_shndx(i, sym.get_st_shndx(),
1533 &is_ordinary);
1534 lv.set_input_shndx(shndx, is_ordinary);
1536 if (sym.get_st_type() == elfcpp::STT_SECTION)
1537 lv.set_is_section_symbol();
1538 else if (sym.get_st_type() == elfcpp::STT_TLS)
1539 lv.set_is_tls_symbol();
1541 // Save the input symbol value for use in do_finalize_local_symbols().
1542 lv.set_input_value(sym.get_st_value());
1544 // Decide whether this symbol should go into the output file.
1546 if ((shndx < shnum && out_sections[shndx] == NULL)
1547 || (shndx == this->discarded_eh_frame_shndx_))
1549 lv.set_no_output_symtab_entry();
1550 gold_assert(!lv.needs_output_dynsym_entry());
1551 continue;
1554 if (sym.get_st_type() == elfcpp::STT_SECTION)
1556 lv.set_no_output_symtab_entry();
1557 gold_assert(!lv.needs_output_dynsym_entry());
1558 continue;
1561 if (sym.get_st_name() >= strtab_size)
1563 this->error(_("local symbol %u section name out of range: %u >= %u"),
1564 i, sym.get_st_name(),
1565 static_cast<unsigned int>(strtab_size));
1566 lv.set_no_output_symtab_entry();
1567 continue;
1570 // If --discard-locals option is used, discard all temporary local
1571 // symbols. These symbols start with system-specific local label
1572 // prefixes, typically .L for ELF system. We want to be compatible
1573 // with GNU ld so here we essentially use the same check in
1574 // bfd_is_local_label(). The code is different because we already
1575 // know that:
1577 // - the symbol is local and thus cannot have global or weak binding.
1578 // - the symbol is not a section symbol.
1579 // - the symbol has a name.
1581 // We do not discard a symbol if it needs a dynamic symbol entry.
1582 const char* name = pnames + sym.get_st_name();
1583 if (discard_locals
1584 && sym.get_st_type() != elfcpp::STT_FILE
1585 && !lv.needs_output_dynsym_entry()
1586 && parameters->target().is_local_label_name(name))
1588 lv.set_no_output_symtab_entry();
1589 continue;
1592 // Discard the local symbol if -retain_symbols_file is specified
1593 // and the local symbol is not in that file.
1594 if (!parameters->options().should_retain_symbol(name))
1596 lv.set_no_output_symtab_entry();
1597 continue;
1600 // Add the symbol to the symbol table string pool.
1601 pool->add(name, true, NULL);
1602 ++count;
1604 // If needed, add the symbol to the dynamic symbol table string pool.
1605 if (lv.needs_output_dynsym_entry())
1607 dynpool->add(name, true, NULL);
1608 ++dyncount;
1612 this->output_local_symbol_count_ = count;
1613 this->output_local_dynsym_count_ = dyncount;
1616 // Finalize the local symbols. Here we set the final value in
1617 // THIS->LOCAL_VALUES_ and set their output symbol table indexes.
1618 // This function is always called from a singleton thread. The actual
1619 // output of the local symbols will occur in a separate task.
1621 template<int size, bool big_endian>
1622 unsigned int
1623 Sized_relobj<size, big_endian>::do_finalize_local_symbols(unsigned int index,
1624 off_t off,
1625 Symbol_table* symtab)
1627 gold_assert(off == static_cast<off_t>(align_address(off, size >> 3)));
1629 const unsigned int loccount = this->local_symbol_count_;
1630 this->local_symbol_offset_ = off;
1632 const bool relocatable = parameters->options().relocatable();
1633 const Output_sections& out_sections(this->output_sections());
1634 const std::vector<Address>& out_offsets(this->section_offsets_);
1635 unsigned int shnum = this->shnum();
1637 for (unsigned int i = 1; i < loccount; ++i)
1639 Symbol_value<size>& lv(this->local_values_[i]);
1641 bool is_ordinary;
1642 unsigned int shndx = lv.input_shndx(&is_ordinary);
1644 // Set the output symbol value.
1646 if (!is_ordinary)
1648 if (shndx == elfcpp::SHN_ABS || Symbol::is_common_shndx(shndx))
1649 lv.set_output_value(lv.input_value());
1650 else
1652 this->error(_("unknown section index %u for local symbol %u"),
1653 shndx, i);
1654 lv.set_output_value(0);
1657 else
1659 if (shndx >= shnum)
1661 this->error(_("local symbol %u section index %u out of range"),
1662 i, shndx);
1663 shndx = 0;
1666 Output_section* os = out_sections[shndx];
1667 Address secoffset = out_offsets[shndx];
1668 if (symtab->is_section_folded(this, shndx))
1670 gold_assert (os == NULL && secoffset == invalid_address);
1671 // Get the os of the section it is folded onto.
1672 Section_id folded = symtab->icf()->get_folded_section(this,
1673 shndx);
1674 gold_assert(folded.first != NULL);
1675 Sized_relobj<size, big_endian>* folded_obj = reinterpret_cast
1676 <Sized_relobj<size, big_endian>*>(folded.first);
1677 os = folded_obj->output_section(folded.second);
1678 gold_assert(os != NULL);
1679 secoffset = folded_obj->get_output_section_offset(folded.second);
1680 gold_assert(secoffset != invalid_address);
1683 if (os == NULL)
1685 // This local symbol belongs to a section we are discarding.
1686 // In some cases when applying relocations later, we will
1687 // attempt to match it to the corresponding kept section,
1688 // so we leave the input value unchanged here.
1689 continue;
1691 else if (secoffset == invalid_address)
1693 uint64_t start;
1695 // This is a SHF_MERGE section or one which otherwise
1696 // requires special handling.
1697 if (shndx == this->discarded_eh_frame_shndx_)
1699 // This local symbol belongs to a discarded .eh_frame
1700 // section. Just treat it like the case in which
1701 // os == NULL above.
1702 gold_assert(this->has_eh_frame_);
1703 continue;
1705 else if (!lv.is_section_symbol())
1707 // This is not a section symbol. We can determine
1708 // the final value now.
1709 lv.set_output_value(os->output_address(this, shndx,
1710 lv.input_value()));
1712 else if (!os->find_starting_output_address(this, shndx, &start))
1714 // This is a section symbol, but apparently not one in a
1715 // merged section. First check to see if this is a relaxed
1716 // input section. If so, use its address. Otherwise just
1717 // use the start of the output section. This happens with
1718 // relocatable links when the input object has section
1719 // symbols for arbitrary non-merge sections.
1720 const Output_section_data* posd =
1721 os->find_relaxed_input_section(this, shndx);
1722 if (posd != NULL)
1723 lv.set_output_value(posd->address());
1724 else
1725 lv.set_output_value(os->address());
1727 else
1729 // We have to consider the addend to determine the
1730 // value to use in a relocation. START is the start
1731 // of this input section.
1732 Merged_symbol_value<size>* msv =
1733 new Merged_symbol_value<size>(lv.input_value(), start);
1734 lv.set_merged_symbol_value(msv);
1737 else if (lv.is_tls_symbol())
1738 lv.set_output_value(os->tls_offset()
1739 + secoffset
1740 + lv.input_value());
1741 else
1742 lv.set_output_value((relocatable ? 0 : os->address())
1743 + secoffset
1744 + lv.input_value());
1747 if (lv.needs_output_symtab_entry())
1749 lv.set_output_symtab_index(index);
1750 ++index;
1753 return index;
1756 // Set the output dynamic symbol table indexes for the local variables.
1758 template<int size, bool big_endian>
1759 unsigned int
1760 Sized_relobj<size, big_endian>::do_set_local_dynsym_indexes(unsigned int index)
1762 const unsigned int loccount = this->local_symbol_count_;
1763 for (unsigned int i = 1; i < loccount; ++i)
1765 Symbol_value<size>& lv(this->local_values_[i]);
1766 if (lv.needs_output_dynsym_entry())
1768 lv.set_output_dynsym_index(index);
1769 ++index;
1772 return index;
1775 // Set the offset where local dynamic symbol information will be stored.
1776 // Returns the count of local symbols contributed to the symbol table by
1777 // this object.
1779 template<int size, bool big_endian>
1780 unsigned int
1781 Sized_relobj<size, big_endian>::do_set_local_dynsym_offset(off_t off)
1783 gold_assert(off == static_cast<off_t>(align_address(off, size >> 3)));
1784 this->local_dynsym_offset_ = off;
1785 return this->output_local_dynsym_count_;
1788 // If Symbols_data is not NULL get the section flags from here otherwise
1789 // get it from the file.
1791 template<int size, bool big_endian>
1792 uint64_t
1793 Sized_relobj<size, big_endian>::do_section_flags(unsigned int shndx)
1795 Symbols_data* sd = this->get_symbols_data();
1796 if (sd != NULL)
1798 const unsigned char* pshdrs = sd->section_headers_data
1799 + This::shdr_size * shndx;
1800 typename This::Shdr shdr(pshdrs);
1801 return shdr.get_sh_flags();
1803 // If sd is NULL, read the section header from the file.
1804 return this->elf_file_.section_flags(shndx);
1807 // Get the section's ent size from Symbols_data. Called by get_section_contents
1808 // in icf.cc
1810 template<int size, bool big_endian>
1811 uint64_t
1812 Sized_relobj<size, big_endian>::do_section_entsize(unsigned int shndx)
1814 Symbols_data* sd = this->get_symbols_data();
1815 gold_assert (sd != NULL);
1817 const unsigned char* pshdrs = sd->section_headers_data
1818 + This::shdr_size * shndx;
1819 typename This::Shdr shdr(pshdrs);
1820 return shdr.get_sh_entsize();
1824 // Write out the local symbols.
1826 template<int size, bool big_endian>
1827 void
1828 Sized_relobj<size, big_endian>::write_local_symbols(
1829 Output_file* of,
1830 const Stringpool* sympool,
1831 const Stringpool* dynpool,
1832 Output_symtab_xindex* symtab_xindex,
1833 Output_symtab_xindex* dynsym_xindex)
1835 const bool strip_all = parameters->options().strip_all();
1836 if (strip_all)
1838 if (this->output_local_dynsym_count_ == 0)
1839 return;
1840 this->output_local_symbol_count_ = 0;
1843 gold_assert(this->symtab_shndx_ != -1U);
1844 if (this->symtab_shndx_ == 0)
1846 // This object has no symbols. Weird but legal.
1847 return;
1850 // Read the symbol table section header.
1851 const unsigned int symtab_shndx = this->symtab_shndx_;
1852 typename This::Shdr symtabshdr(this,
1853 this->elf_file_.section_header(symtab_shndx));
1854 gold_assert(symtabshdr.get_sh_type() == elfcpp::SHT_SYMTAB);
1855 const unsigned int loccount = this->local_symbol_count_;
1856 gold_assert(loccount == symtabshdr.get_sh_info());
1858 // Read the local symbols.
1859 const int sym_size = This::sym_size;
1860 off_t locsize = loccount * sym_size;
1861 const unsigned char* psyms = this->get_view(symtabshdr.get_sh_offset(),
1862 locsize, true, false);
1864 // Read the symbol names.
1865 const unsigned int strtab_shndx =
1866 this->adjust_shndx(symtabshdr.get_sh_link());
1867 section_size_type strtab_size;
1868 const unsigned char* pnamesu = this->section_contents(strtab_shndx,
1869 &strtab_size,
1870 false);
1871 const char* pnames = reinterpret_cast<const char*>(pnamesu);
1873 // Get views into the output file for the portions of the symbol table
1874 // and the dynamic symbol table that we will be writing.
1875 off_t output_size = this->output_local_symbol_count_ * sym_size;
1876 unsigned char* oview = NULL;
1877 if (output_size > 0)
1878 oview = of->get_output_view(this->local_symbol_offset_, output_size);
1880 off_t dyn_output_size = this->output_local_dynsym_count_ * sym_size;
1881 unsigned char* dyn_oview = NULL;
1882 if (dyn_output_size > 0)
1883 dyn_oview = of->get_output_view(this->local_dynsym_offset_,
1884 dyn_output_size);
1886 const Output_sections out_sections(this->output_sections());
1888 gold_assert(this->local_values_.size() == loccount);
1890 unsigned char* ov = oview;
1891 unsigned char* dyn_ov = dyn_oview;
1892 psyms += sym_size;
1893 for (unsigned int i = 1; i < loccount; ++i, psyms += sym_size)
1895 elfcpp::Sym<size, big_endian> isym(psyms);
1897 Symbol_value<size>& lv(this->local_values_[i]);
1899 bool is_ordinary;
1900 unsigned int st_shndx = this->adjust_sym_shndx(i, isym.get_st_shndx(),
1901 &is_ordinary);
1902 if (is_ordinary)
1904 gold_assert(st_shndx < out_sections.size());
1905 if (out_sections[st_shndx] == NULL)
1906 continue;
1907 st_shndx = out_sections[st_shndx]->out_shndx();
1908 if (st_shndx >= elfcpp::SHN_LORESERVE)
1910 if (lv.needs_output_symtab_entry() && !strip_all)
1911 symtab_xindex->add(lv.output_symtab_index(), st_shndx);
1912 if (lv.needs_output_dynsym_entry())
1913 dynsym_xindex->add(lv.output_dynsym_index(), st_shndx);
1914 st_shndx = elfcpp::SHN_XINDEX;
1918 // Write the symbol to the output symbol table.
1919 if (!strip_all && lv.needs_output_symtab_entry())
1921 elfcpp::Sym_write<size, big_endian> osym(ov);
1923 gold_assert(isym.get_st_name() < strtab_size);
1924 const char* name = pnames + isym.get_st_name();
1925 osym.put_st_name(sympool->get_offset(name));
1926 osym.put_st_value(this->local_values_[i].value(this, 0));
1927 osym.put_st_size(isym.get_st_size());
1928 osym.put_st_info(isym.get_st_info());
1929 osym.put_st_other(isym.get_st_other());
1930 osym.put_st_shndx(st_shndx);
1932 ov += sym_size;
1935 // Write the symbol to the output dynamic symbol table.
1936 if (lv.needs_output_dynsym_entry())
1938 gold_assert(dyn_ov < dyn_oview + dyn_output_size);
1939 elfcpp::Sym_write<size, big_endian> osym(dyn_ov);
1941 gold_assert(isym.get_st_name() < strtab_size);
1942 const char* name = pnames + isym.get_st_name();
1943 osym.put_st_name(dynpool->get_offset(name));
1944 osym.put_st_value(this->local_values_[i].value(this, 0));
1945 osym.put_st_size(isym.get_st_size());
1946 osym.put_st_info(isym.get_st_info());
1947 osym.put_st_other(isym.get_st_other());
1948 osym.put_st_shndx(st_shndx);
1950 dyn_ov += sym_size;
1955 if (output_size > 0)
1957 gold_assert(ov - oview == output_size);
1958 of->write_output_view(this->local_symbol_offset_, output_size, oview);
1961 if (dyn_output_size > 0)
1963 gold_assert(dyn_ov - dyn_oview == dyn_output_size);
1964 of->write_output_view(this->local_dynsym_offset_, dyn_output_size,
1965 dyn_oview);
1969 // Set *INFO to symbolic information about the offset OFFSET in the
1970 // section SHNDX. Return true if we found something, false if we
1971 // found nothing.
1973 template<int size, bool big_endian>
1974 bool
1975 Sized_relobj<size, big_endian>::get_symbol_location_info(
1976 unsigned int shndx,
1977 off_t offset,
1978 Symbol_location_info* info)
1980 if (this->symtab_shndx_ == 0)
1981 return false;
1983 section_size_type symbols_size;
1984 const unsigned char* symbols = this->section_contents(this->symtab_shndx_,
1985 &symbols_size,
1986 false);
1988 unsigned int symbol_names_shndx =
1989 this->adjust_shndx(this->section_link(this->symtab_shndx_));
1990 section_size_type names_size;
1991 const unsigned char* symbol_names_u =
1992 this->section_contents(symbol_names_shndx, &names_size, false);
1993 const char* symbol_names = reinterpret_cast<const char*>(symbol_names_u);
1995 const int sym_size = This::sym_size;
1996 const size_t count = symbols_size / sym_size;
1998 const unsigned char* p = symbols;
1999 for (size_t i = 0; i < count; ++i, p += sym_size)
2001 elfcpp::Sym<size, big_endian> sym(p);
2003 if (sym.get_st_type() == elfcpp::STT_FILE)
2005 if (sym.get_st_name() >= names_size)
2006 info->source_file = "(invalid)";
2007 else
2008 info->source_file = symbol_names + sym.get_st_name();
2009 continue;
2012 bool is_ordinary;
2013 unsigned int st_shndx = this->adjust_sym_shndx(i, sym.get_st_shndx(),
2014 &is_ordinary);
2015 if (is_ordinary
2016 && st_shndx == shndx
2017 && static_cast<off_t>(sym.get_st_value()) <= offset
2018 && (static_cast<off_t>(sym.get_st_value() + sym.get_st_size())
2019 > offset))
2021 if (sym.get_st_name() > names_size)
2022 info->enclosing_symbol_name = "(invalid)";
2023 else
2025 info->enclosing_symbol_name = symbol_names + sym.get_st_name();
2026 if (parameters->options().do_demangle())
2028 char* demangled_name = cplus_demangle(
2029 info->enclosing_symbol_name.c_str(),
2030 DMGL_ANSI | DMGL_PARAMS);
2031 if (demangled_name != NULL)
2033 info->enclosing_symbol_name.assign(demangled_name);
2034 free(demangled_name);
2038 return true;
2042 return false;
2045 // Look for a kept section corresponding to the given discarded section,
2046 // and return its output address. This is used only for relocations in
2047 // debugging sections. If we can't find the kept section, return 0.
2049 template<int size, bool big_endian>
2050 typename Sized_relobj<size, big_endian>::Address
2051 Sized_relobj<size, big_endian>::map_to_kept_section(
2052 unsigned int shndx,
2053 bool* found) const
2055 Relobj* kept_object;
2056 unsigned int kept_shndx;
2057 if (this->get_kept_comdat_section(shndx, &kept_object, &kept_shndx))
2059 Sized_relobj<size, big_endian>* kept_relobj =
2060 static_cast<Sized_relobj<size, big_endian>*>(kept_object);
2061 Output_section* os = kept_relobj->output_section(kept_shndx);
2062 Address offset = kept_relobj->get_output_section_offset(kept_shndx);
2063 if (os != NULL && offset != invalid_address)
2065 *found = true;
2066 return os->address() + offset;
2069 *found = false;
2070 return 0;
2073 // Get symbol counts.
2075 template<int size, bool big_endian>
2076 void
2077 Sized_relobj<size, big_endian>::do_get_global_symbol_counts(
2078 const Symbol_table*,
2079 size_t* defined,
2080 size_t* used) const
2082 *defined = this->defined_count_;
2083 size_t count = 0;
2084 for (Symbols::const_iterator p = this->symbols_.begin();
2085 p != this->symbols_.end();
2086 ++p)
2087 if (*p != NULL
2088 && (*p)->source() == Symbol::FROM_OBJECT
2089 && (*p)->object() == this
2090 && (*p)->is_defined())
2091 ++count;
2092 *used = count;
2095 // Input_objects methods.
2097 // Add a regular relocatable object to the list. Return false if this
2098 // object should be ignored.
2100 bool
2101 Input_objects::add_object(Object* obj)
2103 // Print the filename if the -t/--trace option is selected.
2104 if (parameters->options().trace())
2105 gold_info("%s", obj->name().c_str());
2107 if (!obj->is_dynamic())
2108 this->relobj_list_.push_back(static_cast<Relobj*>(obj));
2109 else
2111 // See if this is a duplicate SONAME.
2112 Dynobj* dynobj = static_cast<Dynobj*>(obj);
2113 const char* soname = dynobj->soname();
2115 std::pair<Unordered_set<std::string>::iterator, bool> ins =
2116 this->sonames_.insert(soname);
2117 if (!ins.second)
2119 // We have already seen a dynamic object with this soname.
2120 return false;
2123 this->dynobj_list_.push_back(dynobj);
2126 // Add this object to the cross-referencer if requested.
2127 if (parameters->options().user_set_print_symbol_counts())
2129 if (this->cref_ == NULL)
2130 this->cref_ = new Cref();
2131 this->cref_->add_object(obj);
2134 return true;
2137 // For each dynamic object, record whether we've seen all of its
2138 // explicit dependencies.
2140 void
2141 Input_objects::check_dynamic_dependencies() const
2143 for (Dynobj_list::const_iterator p = this->dynobj_list_.begin();
2144 p != this->dynobj_list_.end();
2145 ++p)
2147 const Dynobj::Needed& needed((*p)->needed());
2148 bool found_all = true;
2149 for (Dynobj::Needed::const_iterator pneeded = needed.begin();
2150 pneeded != needed.end();
2151 ++pneeded)
2153 if (this->sonames_.find(*pneeded) == this->sonames_.end())
2155 found_all = false;
2156 break;
2159 (*p)->set_has_unknown_needed_entries(!found_all);
2163 // Start processing an archive.
2165 void
2166 Input_objects::archive_start(Archive* archive)
2168 if (parameters->options().user_set_print_symbol_counts())
2170 if (this->cref_ == NULL)
2171 this->cref_ = new Cref();
2172 this->cref_->add_archive_start(archive);
2176 // Stop processing an archive.
2178 void
2179 Input_objects::archive_stop(Archive* archive)
2181 if (parameters->options().user_set_print_symbol_counts())
2182 this->cref_->add_archive_stop(archive);
2185 // Print symbol counts
2187 void
2188 Input_objects::print_symbol_counts(const Symbol_table* symtab) const
2190 if (parameters->options().user_set_print_symbol_counts()
2191 && this->cref_ != NULL)
2192 this->cref_->print_symbol_counts(symtab);
2195 // Relocate_info methods.
2197 // Return a string describing the location of a relocation. This is
2198 // only used in error messages.
2200 template<int size, bool big_endian>
2201 std::string
2202 Relocate_info<size, big_endian>::location(size_t, off_t offset) const
2204 // See if we can get line-number information from debugging sections.
2205 std::string filename;
2206 std::string file_and_lineno; // Better than filename-only, if available.
2208 Sized_dwarf_line_info<size, big_endian> line_info(this->object);
2209 // This will be "" if we failed to parse the debug info for any reason.
2210 file_and_lineno = line_info.addr2line(this->data_shndx, offset);
2212 std::string ret(this->object->name());
2213 ret += ':';
2214 Symbol_location_info info;
2215 if (this->object->get_symbol_location_info(this->data_shndx, offset, &info))
2217 ret += " in function ";
2218 ret += info.enclosing_symbol_name;
2219 ret += ":";
2220 filename = info.source_file;
2223 if (!file_and_lineno.empty())
2224 ret += file_and_lineno;
2225 else
2227 if (!filename.empty())
2228 ret += filename;
2229 ret += "(";
2230 ret += this->object->section_name(this->data_shndx);
2231 char buf[100];
2232 // Offsets into sections have to be positive.
2233 snprintf(buf, sizeof(buf), "+0x%lx", static_cast<long>(offset));
2234 ret += buf;
2235 ret += ")";
2237 return ret;
2240 } // End namespace gold.
2242 namespace
2245 using namespace gold;
2247 // Read an ELF file with the header and return the appropriate
2248 // instance of Object.
2250 template<int size, bool big_endian>
2251 Object*
2252 make_elf_sized_object(const std::string& name, Input_file* input_file,
2253 off_t offset, const elfcpp::Ehdr<size, big_endian>& ehdr,
2254 bool* punconfigured)
2256 Target* target = select_target(ehdr.get_e_machine(), size, big_endian,
2257 ehdr.get_e_ident()[elfcpp::EI_OSABI],
2258 ehdr.get_e_ident()[elfcpp::EI_ABIVERSION]);
2259 if (target == NULL)
2260 gold_fatal(_("%s: unsupported ELF machine number %d"),
2261 name.c_str(), ehdr.get_e_machine());
2263 if (!parameters->target_valid())
2264 set_parameters_target(target);
2265 else if (target != &parameters->target())
2267 if (punconfigured != NULL)
2268 *punconfigured = true;
2269 else
2270 gold_error(_("%s: incompatible target"), name.c_str());
2271 return NULL;
2274 return target->make_elf_object<size, big_endian>(name, input_file, offset,
2275 ehdr);
2278 } // End anonymous namespace.
2280 namespace gold
2283 // Return whether INPUT_FILE is an ELF object.
2285 bool
2286 is_elf_object(Input_file* input_file, off_t offset,
2287 const unsigned char** start, int *read_size)
2289 off_t filesize = input_file->file().filesize();
2290 int want = elfcpp::Elf_recognizer::max_header_size;
2291 if (filesize - offset < want)
2292 want = filesize - offset;
2294 const unsigned char* p = input_file->file().get_view(offset, 0, want,
2295 true, false);
2296 *start = p;
2297 *read_size = want;
2299 return elfcpp::Elf_recognizer::is_elf_file(p, want);
2302 // Read an ELF file and return the appropriate instance of Object.
2304 Object*
2305 make_elf_object(const std::string& name, Input_file* input_file, off_t offset,
2306 const unsigned char* p, section_offset_type bytes,
2307 bool* punconfigured)
2309 if (punconfigured != NULL)
2310 *punconfigured = false;
2312 std::string error;
2313 bool big_endian = false;
2314 int size = 0;
2315 if (!elfcpp::Elf_recognizer::is_valid_header(p, bytes, &size,
2316 &big_endian, &error))
2318 gold_error(_("%s: %s"), name.c_str(), error.c_str());
2319 return NULL;
2322 if (size == 32)
2324 if (big_endian)
2326 #ifdef HAVE_TARGET_32_BIG
2327 elfcpp::Ehdr<32, true> ehdr(p);
2328 return make_elf_sized_object<32, true>(name, input_file,
2329 offset, ehdr, punconfigured);
2330 #else
2331 if (punconfigured != NULL)
2332 *punconfigured = true;
2333 else
2334 gold_error(_("%s: not configured to support "
2335 "32-bit big-endian object"),
2336 name.c_str());
2337 return NULL;
2338 #endif
2340 else
2342 #ifdef HAVE_TARGET_32_LITTLE
2343 elfcpp::Ehdr<32, false> ehdr(p);
2344 return make_elf_sized_object<32, false>(name, input_file,
2345 offset, ehdr, punconfigured);
2346 #else
2347 if (punconfigured != NULL)
2348 *punconfigured = true;
2349 else
2350 gold_error(_("%s: not configured to support "
2351 "32-bit little-endian object"),
2352 name.c_str());
2353 return NULL;
2354 #endif
2357 else if (size == 64)
2359 if (big_endian)
2361 #ifdef HAVE_TARGET_64_BIG
2362 elfcpp::Ehdr<64, true> ehdr(p);
2363 return make_elf_sized_object<64, true>(name, input_file,
2364 offset, ehdr, punconfigured);
2365 #else
2366 if (punconfigured != NULL)
2367 *punconfigured = true;
2368 else
2369 gold_error(_("%s: not configured to support "
2370 "64-bit big-endian object"),
2371 name.c_str());
2372 return NULL;
2373 #endif
2375 else
2377 #ifdef HAVE_TARGET_64_LITTLE
2378 elfcpp::Ehdr<64, false> ehdr(p);
2379 return make_elf_sized_object<64, false>(name, input_file,
2380 offset, ehdr, punconfigured);
2381 #else
2382 if (punconfigured != NULL)
2383 *punconfigured = true;
2384 else
2385 gold_error(_("%s: not configured to support "
2386 "64-bit little-endian object"),
2387 name.c_str());
2388 return NULL;
2389 #endif
2392 else
2393 gold_unreachable();
2396 // Instantiate the templates we need.
2398 #ifdef HAVE_TARGET_32_LITTLE
2399 template
2400 void
2401 Object::read_section_data<32, false>(elfcpp::Elf_file<32, false, Object>*,
2402 Read_symbols_data*);
2403 #endif
2405 #ifdef HAVE_TARGET_32_BIG
2406 template
2407 void
2408 Object::read_section_data<32, true>(elfcpp::Elf_file<32, true, Object>*,
2409 Read_symbols_data*);
2410 #endif
2412 #ifdef HAVE_TARGET_64_LITTLE
2413 template
2414 void
2415 Object::read_section_data<64, false>(elfcpp::Elf_file<64, false, Object>*,
2416 Read_symbols_data*);
2417 #endif
2419 #ifdef HAVE_TARGET_64_BIG
2420 template
2421 void
2422 Object::read_section_data<64, true>(elfcpp::Elf_file<64, true, Object>*,
2423 Read_symbols_data*);
2424 #endif
2426 #ifdef HAVE_TARGET_32_LITTLE
2427 template
2428 class Sized_relobj<32, false>;
2429 #endif
2431 #ifdef HAVE_TARGET_32_BIG
2432 template
2433 class Sized_relobj<32, true>;
2434 #endif
2436 #ifdef HAVE_TARGET_64_LITTLE
2437 template
2438 class Sized_relobj<64, false>;
2439 #endif
2441 #ifdef HAVE_TARGET_64_BIG
2442 template
2443 class Sized_relobj<64, true>;
2444 #endif
2446 #ifdef HAVE_TARGET_32_LITTLE
2447 template
2448 struct Relocate_info<32, false>;
2449 #endif
2451 #ifdef HAVE_TARGET_32_BIG
2452 template
2453 struct Relocate_info<32, true>;
2454 #endif
2456 #ifdef HAVE_TARGET_64_LITTLE
2457 template
2458 struct Relocate_info<64, false>;
2459 #endif
2461 #ifdef HAVE_TARGET_64_BIG
2462 template
2463 struct Relocate_info<64, true>;
2464 #endif
2466 } // End namespace gold.