[deliverable/binutils-gdb.git] / gold / object.cc

// object.cc -- support for an object file for linking in gold

#include "gold.h"

#include <cerrno>
#include <cstring>
#include <cassert>

#include "object.h"
#include "target-select.h"
#include "layout.h"

namespace gold
{

// Class Object.

const unsigned char*
Object::get_view(off_t start, off_t size)
{
  return this->input_file_->file().get_view(start + this->offset_, size);
}

void
Object::read(off_t start, off_t size, void* p)
{
  this->input_file_->file().read(start + this->offset_, size, p);
}

File_view*
Object::get_lasting_view(off_t start, off_t size)
{
  return this->input_file_->file().get_lasting_view(start + this->offset_,
						    size);
}

// Class Sized_object.

template<int size, bool big_endian>
Sized_object<size, big_endian>::Sized_object(
    const std::string& name,
    Input_file* input_file,
    off_t offset,
    const elfcpp::Ehdr<size, big_endian>& ehdr)
  : Object(name, input_file, false, offset),
    flags_(ehdr.get_e_flags()),
    shoff_(ehdr.get_e_shoff()),
    shstrndx_(0),
    symtab_shnum_(0),
    symbols_(NULL)
{
  if (ehdr.get_e_ehsize() != This::ehdr_size)
    {
      fprintf(stderr, _("%s: %s: bad e_ehsize field (%d != %d)\n"),
	      program_name, this->name().c_str(), ehdr.get_e_ehsize(),
	      This::ehdr_size);
      gold_exit(false);
    }
  if (ehdr.get_e_shentsize() != This::shdr_size)
    {
      fprintf(stderr, _("%s: %s: bad e_shentsize field (%d != %d)\n"),
	      program_name, this->name().c_str(), ehdr.get_e_shentsize(),
	      This::shdr_size);
      gold_exit(false);
    }
}

template<int size, bool big_endian>
Sized_object<size, big_endian>::~Sized_object()
{
}

// Set up an object file bsaed on the file header.  This sets up the
// target and reads the section information.

template<int size, bool big_endian>
void
Sized_object<size, big_endian>::setup(
    const elfcpp::Ehdr<size, big_endian>& ehdr)
{
  int machine = ehdr.get_e_machine();
  Target* target = select_target(machine, size, big_endian,
				 ehdr.get_e_ident()[elfcpp::EI_OSABI],
				 ehdr.get_e_ident()[elfcpp::EI_ABIVERSION]);
  if (target == NULL)
    {
      fprintf(stderr, _("%s: %s: unsupported ELF machine number %d\n"),
	      program_name, this->name().c_str(), machine);
      gold_exit(false);
    }
  this->set_target(target);
  unsigned int shnum = ehdr.get_e_shnum();
  unsigned int shstrndx = ehdr.get_e_shstrndx();
  if ((shnum == 0 || shstrndx == elfcpp::SHN_XINDEX)
      && this->shoff_ != 0)
    {
      const unsigned char* p = this->get_view (this->shoff_, This::shdr_size);
      elfcpp::Shdr<size, big_endian> shdr(p);
      if (shnum == 0)
	shnum = shdr.get_sh_size();
      if (shstrndx == elfcpp::SHN_XINDEX)
	shstrndx = shdr.get_sh_link();
    }
  this->set_shnum(shnum);
  this->shstrndx_ = shstrndx;

  if (shnum == 0)
    return;

  // Find the SHT_SYMTAB section.
  const unsigned char* p = this->get_view (this->shoff_,
					   shnum * This::shdr_size);
  // Skip the first section, which is always empty.
  p += This::shdr_size;
  for (unsigned int i = 1; i < shnum; ++i)
    {
      elfcpp::Shdr<size, big_endian> shdr(p);
      if (shdr.get_sh_type() == elfcpp::SHT_SYMTAB)
	{
	  this->symtab_shnum_ = i;
	  break;
	}
      p += This::shdr_size;
    }
}

// Read the symbols and relocations from an object file.

template<int size, bool big_endian>
Read_symbols_data
Sized_object<size, big_endian>::do_read_symbols()
{
  if (this->symtab_shnum_ == 0)
    {
      // No symbol table.  Weird but legal.
      Read_symbols_data ret;
      ret.symbols = NULL;
      ret.symbols_size = 0;
      ret.symbol_names = NULL;
      ret.symbol_names_size = 0;
      return ret;
    }

  const int shdr_size = This::shdr_size;

  // Read the symbol table section header.
  off_t symtabshdroff = this->shoff_ + (this->symtab_shnum_ * shdr_size);
  const unsigned char* psymtabshdr = this->get_view(symtabshdroff, shdr_size);
  elfcpp::Shdr<size, big_endian> symtabshdr(psymtabshdr);
  assert(symtabshdr.get_sh_type() == elfcpp::SHT_SYMTAB);

  // We only need the external symbols.
  const int sym_size = This::sym_size;
  off_t locsize = symtabshdr.get_sh_info() * sym_size;
  off_t extoff = symtabshdr.get_sh_offset() + locsize;
  off_t extsize = symtabshdr.get_sh_size() - locsize;

  // Read the symbol table.
  File_view* fvsymtab = this->get_lasting_view(extoff, extsize);

  // Read the section header for the symbol names.
  unsigned int strtab_shnum = symtabshdr.get_sh_link();
  if (strtab_shnum == 0 || strtab_shnum >= this->shnum())
    {
      fprintf(stderr, _("%s: %s: invalid symbol table name index: %u\n"),
	      program_name, this->name().c_str(), strtab_shnum);
      gold_exit(false);
    }
  off_t strtabshdroff = this->shoff_ + (strtab_shnum * shdr_size);
  const unsigned char *pstrtabshdr = this->get_view(strtabshdroff, shdr_size);
  elfcpp::Shdr<size, big_endian> strtabshdr(pstrtabshdr);
  if (strtabshdr.get_sh_type() != elfcpp::SHT_STRTAB)
    {
      fprintf(stderr,
	      _("%s: %s: symbol table name section has wrong type: %u\n"),
	      program_name, this->name().c_str(),
	      static_cast<unsigned int>(strtabshdr.get_sh_type()));
      gold_exit(false);
    }

  // Read the symbol names.
  File_view* fvstrtab = this->get_lasting_view(strtabshdr.get_sh_offset(),
					       strtabshdr.get_sh_size());

  Read_symbols_data ret;
  ret.symbols = fvsymtab;
  ret.symbols_size = extsize;
  ret.symbol_names = fvstrtab;
  ret.symbol_names_size = strtabshdr.get_sh_size();

  return ret;
}

// Add the symbols to the symbol table.

template<int size, bool big_endian>
void
Sized_object<size, big_endian>::do_add_symbols(Symbol_table* symtab,
					       Read_symbols_data sd)
{
  if (sd.symbols == NULL)
    {
      assert(sd.symbol_names == NULL);
      return;
    }

  const int sym_size = This::sym_size;
  size_t symcount = sd.symbols_size / sym_size;
  if (symcount * sym_size != sd.symbols_size)
    {
      fprintf(stderr,
	      _("%s: %s: size of symbols is not multiple of symbol size\n"),
	      program_name, this->name().c_str());
      gold_exit(false);
    }

  this->symbols_ = new Symbol*[symcount];

  const elfcpp::Sym<size, big_endian>* syms =
    reinterpret_cast<const elfcpp::Sym<size, big_endian>*>(sd.symbols->data());
  const char* sym_names =
    reinterpret_cast<const char*>(sd.symbol_names->data());
  symtab->add_from_object(this, syms, symcount, sym_names, 
			  sd.symbol_names_size,  this->symbols_);

  delete sd.symbols;
  delete sd.symbol_names;
}

// Return whether to include a section group in the link.  LAYOUT is
// used to keep track of which section groups we have already seen.
// INDEX is the index of the section group and SHDR is the section
// header.  If we do not want to include this group, we set bits in
// OMIT for each section which should be discarded.

template<int size, bool big_endian>
bool
Sized_object<size, big_endian>::include_section_group(
    Layout* layout,
    unsigned int index,
    const elfcpp::Shdr<size, big_endian>& shdr,
    std::vector<bool>* omit)
{
  // Read the section contents.
  const unsigned char* pcon = this->get_view(shdr.get_sh_offset(),
					     shdr.get_sh_size());
  const elfcpp::Elf_Word* pword =
    reinterpret_cast<const elfcpp::Elf_Word*>(pcon);

  // The first word contains flags.  We only care about COMDAT section
  // groups.  Other section groups are always included in the link
  // just like ordinary sections.
  elfcpp::Elf_Word flags = elfcpp::read_elf_word<big_endian>(pword);
  if ((flags & elfcpp::GRP_COMDAT) == 0)
    return true;

  // Look up the group signature, which is the name of a symbol.  This
  // is a lot of effort to go to to read a string.  Why didn't they
  // just use the name of the SHT_GROUP section as the group
  // signature?

  // Get the appropriate symbol table header (this will normally be
  // the single SHT_SYMTAB section, but in principle it need not be).
  if (shdr.get_sh_link() >= this->shnum())
    {
      fprintf(stderr, _("%s: %s: section group %u link %u out of range\n"),
	      program_name, this->name().c_str(), index, shdr.get_sh_link());
      gold_exit(false);
    }
  off_t off = this->shoff_ + shdr.get_sh_link() * This::shdr_size;
  const unsigned char* psymshdr = this->get_view(off, This::shdr_size);
  elfcpp::Shdr<size, big_endian> symshdr(psymshdr);

  // Read the symbol table entry.
  if (shdr.get_sh_info() >= symshdr.get_sh_size() / This::sym_size)
    {
      fprintf(stderr, _("%s: %s: section group %u info %u out of range\n"),
	      program_name, this->name().c_str(), index, shdr.get_sh_info());
      gold_exit(false);
    }
  off_t symoff = symshdr.get_sh_offset() + shdr.get_sh_info() * This::sym_size;
  const unsigned char* psym = this->get_view(symoff, This::sym_size);
  elfcpp::Sym<size, big_endian> sym(psym);

  // Read the section header for the symbol table names.
  if (symshdr.get_sh_link() >= this->shnum())
    {
      fprintf(stderr, _("%s; %s: symtab section %u link %u out of range\n"),
	      program_name, this->name().c_str(), shdr.get_sh_link(),
	      symshdr.get_sh_link());
      gold_exit(false);
    }
  off_t symnameoff = this->shoff_ + symshdr.get_sh_link() * This::shdr_size;
  const unsigned char* psymnamehdr = this->get_view(symnameoff,
						    This::shdr_size);
  elfcpp::Shdr<size, big_endian> symnamehdr(psymnamehdr);

  // Read the symbol table names.
  const unsigned char *psymnamesu = this->get_view(symnamehdr.get_sh_offset(),
						   symnamehdr.get_sh_size());
  const char* psymnames = reinterpret_cast<const char*>(psymnamesu);

  // Get the section group signature.
  if (sym.get_st_name() >= symnamehdr.get_sh_size())
    {
      fprintf(stderr, _("%s: %s: symbol %u name offset %u out of range\n"),
	      program_name, this->name().c_str(), shdr.get_sh_info(),
	      sym.get_st_name());
      gold_exit(false);
    }

  const char* signature = psymnames + sym.get_st_name();

  // Record this section group, and see whether we've already seen one
  // with the same signature.
  if (layout->add_comdat(signature, true))
    return true;

  // This is a duplicate.  We want to discard the sections in this
  // group.
  size_t count = shdr.get_sh_size() / sizeof(elfcpp::Elf_Word);
  for (size_t i = 1; i < count; ++i)
    {
      elfcpp::Elf_Word secnum = elfcpp::read_elf_word<big_endian>(pword + i);
      if (secnum >= this->shnum())
	{
	  fprintf(stderr,
		  _("%s: %s: section %u in section group %u out of range"),
		  program_name, this->name().c_str(), secnum,
		  index);
	  gold_exit(false);
	}
      (*omit)[secnum] = true;
    }

  return false;
}

// Whether to include a linkonce section in the link.  NAME is the
// name of the section and SHDR is the section header.

// Linkonce sections are a GNU extension implemented in the original
// GNU linker before section groups were defined.  The semantics are
// that we only include one linkonce section with a given name.  The
// name of a linkonce section is normally .gnu.linkonce.T.SYMNAME,
// where T is the type of section and SYMNAME is the name of a symbol.
// In an attempt to make linkonce sections interact well with section
// groups, we try to identify SYMNAME and use it like a section group
// signature.  We want to block section groups with that signature,
// but not other linkonce sections with that signature.  We also use
// the full name of the linkonce section as a normal section group
// signature.

template<int size, bool big_endian>
bool
Sized_object<size, big_endian>::include_linkonce_section(
    Layout* layout,
    const char* name,
    const elfcpp::Shdr<size, big_endian>&)
{
  const char* symname = strrchr(name, '.') + 1;
  bool omit1 = layout->add_comdat(symname, false);
  bool omit2 = layout->add_comdat(name, true);
  return omit1 || omit2;
}

// Lay out the input sections.  We walk through the sections and check
// whether they should be included in the link.  If they should, we
// pass them to the Layout object, which will return an output section
// and an offset.

template<int size, bool big_endian>
void
Sized_object<size, big_endian>::do_layout(Layout* layout)
{
  // This is always called from the main thread.  Lock the file to
  // keep the error checks happy.
  Task_locker_obj<File_read> frl(this->input_file()->file());

  // Get the section headers.
  unsigned int shnum = this->shnum();
  const unsigned char* pshdrs = this->get_view(this->shoff_,
					       shnum * This::shdr_size);

  // Get the section names.
  const unsigned char* pshdrnames = pshdrs + this->shstrndx_ * This::shdr_size;
  elfcpp::Shdr<size, big_endian> shdrnames(pshdrnames);
  typename elfcpp::Elf_types<size>::Elf_WXword names_size =
    shdrnames.get_sh_size();
  const unsigned char* pnamesu = this->get_view(shdrnames.get_sh_offset(),
						shdrnames.get_sh_size());
  const char* pnames = reinterpret_cast<const char*>(pnamesu);

  std::vector<Map_to_output>& map_sections(this->map_to_output());
  map_sections.reserve(shnum);

  // Keep track of which sections to omit.
  std::vector<bool> omit(shnum, false);

  for (unsigned int i = 0; i < shnum; ++i)
    {
      elfcpp::Shdr<size, big_endian> shdr(pshdrs);

      if (shdr.get_sh_name() >= names_size)
	{
	  fprintf(stderr,
		  _("%s: %s: bad section name offset for section %u: %lu\n"),
		  program_name, this->name().c_str(), i,
		  static_cast<unsigned long>(shdr.get_sh_name()));
	  gold_exit(false);
	}

      const char* name = pnames + shdr.get_sh_name();

      bool discard = omit[i];
      if (!discard)
	{
	  if (shdr.get_sh_type() == elfcpp::SHT_GROUP)
	    {
	      if (!this->include_section_group(layout, i, shdr, &omit))
		discard = true;
	    }
	  else if (Layout::is_linkonce(name))
	    {
	      if (!this->include_linkonce_section(layout, name, shdr))
		discard = true;
	    }
	}

      if (discard)
	{
	  // Do not include this section in the link.
	  map_sections[i].output_section = NULL;
	  continue;
	}

      off_t offset;
      Output_section* os = layout->layout(this, name, shdr, &offset);

      map_sections[i].output_section = os;
      map_sections[i].offset = offset;

      pshdrs += This::shdr_size;
    }
}

} // End namespace gold.

namespace
{

using namespace gold;

// Read an ELF file with the header and return the appropriate
// instance of Object.

template<int size, bool big_endian>
Object*
make_elf_sized_object(const std::string& name, Input_file* input_file,
		      off_t offset, const elfcpp::Ehdr<size, big_endian>& ehdr)
{
  int et = ehdr.get_e_type();
  if (et != elfcpp::ET_REL && et != elfcpp::ET_DYN)
    {
      fprintf(stderr, "%s: %s: unsupported ELF type %d\n",
	      program_name, name.c_str(), static_cast<int>(et));
      gold_exit(false);
    }

  if (et == elfcpp::ET_REL)
    {
      Sized_object<size, big_endian>* obj =
	new Sized_object<size, big_endian>(name, input_file, offset, ehdr);
      obj->setup(ehdr);
      return obj;
    }
  else
    {
      // elfcpp::ET_DYN
      fprintf(stderr, _("%s: %s: dynamic objects are not yet supported\n"),
	      program_name, name.c_str());
      gold_exit(false);
//       Sized_dynobj<size, big_endian>* obj =
// 	new Sized_dynobj<size, big_endian>(this->input_.name(), input_file,
// 					   offset, ehdr);
//       obj->setup(ehdr);
//       return obj;
    }
}

} // End anonymous namespace.

namespace gold
{

// Read an ELF file and return the appropriate instance of Object.

Object*
make_elf_object(const std::string& name, Input_file* input_file, off_t offset,
		const unsigned char* p, off_t bytes)
{
  if (bytes < elfcpp::EI_NIDENT)
    {
      fprintf(stderr, _("%s: %s: ELF file too short\n"),
	      program_name, name.c_str());
      gold_exit(false);
    }

  int v = p[elfcpp::EI_VERSION];
  if (v != elfcpp::EV_CURRENT)
    {
      if (v == elfcpp::EV_NONE)
	fprintf(stderr, _("%s: %s: invalid ELF version 0\n"),
		program_name, name.c_str());
      else
	fprintf(stderr, _("%s: %s: unsupported ELF version %d\n"),
		program_name, name.c_str(), v);
      gold_exit(false);
    }

  int c = p[elfcpp::EI_CLASS];
  if (c == elfcpp::ELFCLASSNONE)
    {
      fprintf(stderr, _("%s: %s: invalid ELF class 0\n"),
	      program_name, name.c_str());
      gold_exit(false);
    }
  else if (c != elfcpp::ELFCLASS32
	   && c != elfcpp::ELFCLASS64)
    {
      fprintf(stderr, _("%s: %s: unsupported ELF class %d\n"),
	      program_name, name.c_str(), c);
      gold_exit(false);
    }

  int d = p[elfcpp::EI_DATA];
  if (d == elfcpp::ELFDATANONE)
    {
      fprintf(stderr, _("%s: %s: invalid ELF data encoding\n"),
	      program_name, name.c_str());
      gold_exit(false);
    }
  else if (d != elfcpp::ELFDATA2LSB
	   && d != elfcpp::ELFDATA2MSB)
    {
      fprintf(stderr, _("%s: %s: unsupported ELF data encoding %d\n"),
	      program_name, name.c_str(), d);
      gold_exit(false);
    }

  bool big_endian = d == elfcpp::ELFDATA2MSB;

  if (c == elfcpp::ELFCLASS32)
    {
      if (bytes < elfcpp::Elf_sizes<32>::ehdr_size)
	{
	  fprintf(stderr, _("%s: %s: ELF file too short\n"),
		  program_name, name.c_str());
	  gold_exit(false);
	}
      if (big_endian)
	{
	  elfcpp::Ehdr<32, true> ehdr(p);
	  return make_elf_sized_object<32, true>(name, input_file,
						 offset, ehdr);
	}
      else
	{
	  elfcpp::Ehdr<32, false> ehdr(p);
	  return make_elf_sized_object<32, false>(name, input_file,
						  offset, ehdr);
	}
    }
  else
    {
      if (bytes < elfcpp::Elf_sizes<32>::ehdr_size)
	{
	  fprintf(stderr, _("%s: %s: ELF file too short\n"),
		  program_name, name.c_str());
	  gold_exit(false);
	}
      if (big_endian)
	{
	  elfcpp::Ehdr<64, true> ehdr(p);
	  return make_elf_sized_object<64, true>(name, input_file,
						 offset, ehdr);
	}
      else
	{
	  elfcpp::Ehdr<64, false> ehdr(p);
	  return make_elf_sized_object<64, false>(name, input_file,
						  offset, ehdr);
	}
    }
}

// Instantiate the templates we need.  We could use the configure
// script to restrict this to only the ones for implemented targets.

template
class Sized_object<32, false>;

template
class Sized_object<32, true>;

template
class Sized_object<64, false>;

template
class Sized_object<64, true>;

} // End namespace gold.
Commit	Line	Data
bae7f79e ILT	1	// object.cc -- support for an object file for linking in gold
	2
	3	#include "gold.h"
	4
	5	#include <cerrno>
	6	#include <cstring>
	7	#include <cassert>
	8
	9	#include "object.h"
14bfc3f5	10	#include "target-select.h"
a2fb1b05	11	#include "layout.h"
bae7f79e ILT	12
	13	namespace gold
	14	{
	15
	16	// Class Object.
	17
	18	const unsigned char*
	19	Object::get_view(off_t start, off_t size)
	20	{
	21	return this->input_file_->file().get_view(start + this->offset_, size);
	22	}
	23
	24	void
	25	Object::read(off_t start, off_t size, void* p)
	26	{
	27	this->input_file_->file().read(start + this->offset_, size, p);
	28	}
	29
	30	File_view*
	31	Object::get_lasting_view(off_t start, off_t size)
	32	{
	33	return this->input_file_->file().get_lasting_view(start + this->offset_,
	34	size);
	35	}
	36
	37	// Class Sized_object.
	38
	39	template<int size, bool big_endian>
	40	Sized_object<size, big_endian>::Sized_object(
	41	const std::string& name,
	42	Input_file* input_file,
	43	off_t offset,
	44	const elfcpp::Ehdr<size, big_endian>& ehdr)
14bfc3f5	45	: Object(name, input_file, false, offset),
bae7f79e	46	flags_(ehdr.get_e_flags()),
bae7f79e	47	shoff_(ehdr.get_e_shoff()),
bae7f79e	48	shstrndx_(0),
14bfc3f5 ILT	49	symtab_shnum_(0),
14bfc3f5 ILT	50	symbols_(NULL)
bae7f79e	51	{
a2fb1b05	52	if (ehdr.get_e_ehsize() != This::ehdr_size)
bae7f79e ILT	53	{
	54	fprintf(stderr, _("%s: %s: bad e_ehsize field (%d != %d)\n"),
	55	program_name, this->name().c_str(), ehdr.get_e_ehsize(),
a2fb1b05	56	This::ehdr_size);
bae7f79e ILT	57	gold_exit(false);
bae7f79e ILT	58	}
a2fb1b05	59	if (ehdr.get_e_shentsize() != This::shdr_size)
bae7f79e ILT	60	{
	61	fprintf(stderr, _("%s: %s: bad e_shentsize field (%d != %d)\n"),
	62	program_name, this->name().c_str(), ehdr.get_e_shentsize(),
a2fb1b05	63	This::shdr_size);
bae7f79e ILT	64	gold_exit(false);
	65	}
	66	}
	67
	68	template<int size, bool big_endian>
	69	Sized_object<size, big_endian>::~Sized_object()
	70	{
	71	}
	72
	73	// Set up an object file bsaed on the file header. This sets up the
	74	// target and reads the section information.
	75
	76	template<int size, bool big_endian>
	77	void
	78	Sized_object<size, big_endian>::setup(
	79	const elfcpp::Ehdr<size, big_endian>& ehdr)
	80	{
a2fb1b05 ILT	81	int machine = ehdr.get_e_machine();
	82	Target* target = select_target(machine, size, big_endian,
	83	ehdr.get_e_ident()[elfcpp::EI_OSABI],
	84	ehdr.get_e_ident()[elfcpp::EI_ABIVERSION]);
14bfc3f5 ILT	85	if (target == NULL)
	86	{
	87	fprintf(stderr, _("%s: %s: unsupported ELF machine number %d\n"),
a2fb1b05	88	program_name, this->name().c_str(), machine);
14bfc3f5 ILT	89	gold_exit(false);
	90	}
	91	this->set_target(target);
bae7f79e ILT	92	unsigned int shnum = ehdr.get_e_shnum();
	93	unsigned int shstrndx = ehdr.get_e_shstrndx();
	94	if ((shnum == 0 \|\| shstrndx == elfcpp::SHN_XINDEX)
	95	&& this->shoff_ != 0)
	96	{
a2fb1b05	97	const unsigned char* p = this->get_view (this->shoff_, This::shdr_size);
bae7f79e ILT	98	elfcpp::Shdr<size, big_endian> shdr(p);
	99	if (shnum == 0)
	100	shnum = shdr.get_sh_size();
	101	if (shstrndx == elfcpp::SHN_XINDEX)
	102	shstrndx = shdr.get_sh_link();
	103	}
a2fb1b05	104	this->set_shnum(shnum);
bae7f79e ILT	105	this->shstrndx_ = shstrndx;
	106
	107	if (shnum == 0)
	108	return;
	109
	110	// Find the SHT_SYMTAB section.
a2fb1b05 ILT	111	const unsigned char* p = this->get_view (this->shoff_,
a2fb1b05 ILT	112	shnum * This::shdr_size);
bae7f79e	113	// Skip the first section, which is always empty.
a2fb1b05	114	p += This::shdr_size;
bae7f79e ILT	115	for (unsigned int i = 1; i < shnum; ++i)
	116	{
	117	elfcpp::Shdr<size, big_endian> shdr(p);
	118	if (shdr.get_sh_type() == elfcpp::SHT_SYMTAB)
	119	{
	120	this->symtab_shnum_ = i;
	121	break;
	122	}
a2fb1b05	123	p += This::shdr_size;
bae7f79e ILT	124	}
	125	}
	126
	127	// Read the symbols and relocations from an object file.
	128
	129	template<int size, bool big_endian>
	130	Read_symbols_data
	131	Sized_object<size, big_endian>::do_read_symbols()
	132	{
	133	if (this->symtab_shnum_ == 0)
	134	{
	135	// No symbol table. Weird but legal.
	136	Read_symbols_data ret;
	137	ret.symbols = NULL;
	138	ret.symbols_size = 0;
	139	ret.symbol_names = NULL;
	140	ret.symbol_names_size = 0;
	141	return ret;
	142	}
	143
a2fb1b05	144	const int shdr_size = This::shdr_size;
bae7f79e ILT	145
	146	// Read the symbol table section header.
	147	off_t symtabshdroff = this->shoff_ + (this->symtab_shnum_ * shdr_size);
	148	const unsigned char* psymtabshdr = this->get_view(symtabshdroff, shdr_size);
	149	elfcpp::Shdr<size, big_endian> symtabshdr(psymtabshdr);
	150	assert(symtabshdr.get_sh_type() == elfcpp::SHT_SYMTAB);
	151
14bfc3f5	152	// We only need the external symbols.
a2fb1b05	153	const int sym_size = This::sym_size;
14bfc3f5 ILT	154	off_t locsize = symtabshdr.get_sh_info() * sym_size;
	155	off_t extoff = symtabshdr.get_sh_offset() + locsize;
	156	off_t extsize = symtabshdr.get_sh_size() - locsize;
	157
bae7f79e	158	// Read the symbol table.
14bfc3f5	159	File_view* fvsymtab = this->get_lasting_view(extoff, extsize);
bae7f79e ILT	160
	161	// Read the section header for the symbol names.
	162	unsigned int strtab_shnum = symtabshdr.get_sh_link();
a2fb1b05	163	if (strtab_shnum == 0 \|\| strtab_shnum >= this->shnum())
bae7f79e ILT	164	{
	165	fprintf(stderr, _("%s: %s: invalid symbol table name index: %u\n"),
	166	program_name, this->name().c_str(), strtab_shnum);
	167	gold_exit(false);
	168	}
	169	off_t strtabshdroff = this->shoff_ + (strtab_shnum * shdr_size);
	170	const unsigned char *pstrtabshdr = this->get_view(strtabshdroff, shdr_size);
	171	elfcpp::Shdr<size, big_endian> strtabshdr(pstrtabshdr);
	172	if (strtabshdr.get_sh_type() != elfcpp::SHT_STRTAB)
	173	{
	174	fprintf(stderr,
	175	_("%s: %s: symbol table name section has wrong type: %u\n"),
	176	program_name, this->name().c_str(),
	177	static_cast<unsigned int>(strtabshdr.get_sh_type()));
	178	gold_exit(false);
	179	}
	180
	181	// Read the symbol names.
	182	File_view* fvstrtab = this->get_lasting_view(strtabshdr.get_sh_offset(),
	183	strtabshdr.get_sh_size());
	184
	185	Read_symbols_data ret;
	186	ret.symbols = fvsymtab;
14bfc3f5	187	ret.symbols_size = extsize;
bae7f79e ILT	188	ret.symbol_names = fvstrtab;
	189	ret.symbol_names_size = strtabshdr.get_sh_size();
	190
	191	return ret;
	192	}
	193
	194	// Add the symbols to the symbol table.
	195
	196	template<int size, bool big_endian>
	197	void
14bfc3f5 ILT	198	Sized_object<size, big_endian>::do_add_symbols(Symbol_table* symtab,
14bfc3f5 ILT	199	Read_symbols_data sd)
bae7f79e ILT	200	{
	201	if (sd.symbols == NULL)
	202	{
	203	assert(sd.symbol_names == NULL);
	204	return;
	205	}
	206
a2fb1b05	207	const int sym_size = This::sym_size;
14bfc3f5 ILT	208	size_t symcount = sd.symbols_size / sym_size;
14bfc3f5 ILT	209	if (symcount * sym_size != sd.symbols_size)
bae7f79e	210	{
14bfc3f5 ILT	211	fprintf(stderr,
	212	_("%s: %s: size of symbols is not multiple of symbol size\n"),
	213	program_name, this->name().c_str());
	214	gold_exit(false);
bae7f79e	215	}
14bfc3f5 ILT	216
	217	this->symbols_ = new Symbol*[symcount];
	218
	219	const elfcpp::Sym<size, big_endian>* syms =
	220	reinterpret_cast<const elfcpp::Sym<size, big_endian>*>(sd.symbols->data());
	221	const char* sym_names =
	222	reinterpret_cast<const char*>(sd.symbol_names->data());
	223	symtab->add_from_object(this, syms, symcount, sym_names,
	224	sd.symbol_names_size, this->symbols_);
a2fb1b05 ILT	225
	226	delete sd.symbols;
	227	delete sd.symbol_names;
	228	}
	229
	230	// Return whether to include a section group in the link. LAYOUT is
	231	// used to keep track of which section groups we have already seen.
	232	// INDEX is the index of the section group and SHDR is the section
	233	// header. If we do not want to include this group, we set bits in
	234	// OMIT for each section which should be discarded.
	235
	236	template<int size, bool big_endian>
	237	bool
	238	Sized_object<size, big_endian>::include_section_group(
	239	Layout* layout,
	240	unsigned int index,
	241	const elfcpp::Shdr<size, big_endian>& shdr,
	242	std::vector<bool>* omit)
	243	{
	244	// Read the section contents.
	245	const unsigned char* pcon = this->get_view(shdr.get_sh_offset(),
	246	shdr.get_sh_size());
	247	const elfcpp::Elf_Word* pword =
	248	reinterpret_cast<const elfcpp::Elf_Word*>(pcon);
	249
	250	// The first word contains flags. We only care about COMDAT section
	251	// groups. Other section groups are always included in the link
	252	// just like ordinary sections.
	253	elfcpp::Elf_Word flags = elfcpp::read_elf_word<big_endian>(pword);
	254	if ((flags & elfcpp::GRP_COMDAT) == 0)
	255	return true;
	256
	257	// Look up the group signature, which is the name of a symbol. This
	258	// is a lot of effort to go to to read a string. Why didn't they
	259	// just use the name of the SHT_GROUP section as the group
	260	// signature?
	261
	262	// Get the appropriate symbol table header (this will normally be
	263	// the single SHT_SYMTAB section, but in principle it need not be).
	264	if (shdr.get_sh_link() >= this->shnum())
	265	{
	266	fprintf(stderr, _("%s: %s: section group %u link %u out of range\n"),
	267	program_name, this->name().c_str(), index, shdr.get_sh_link());
	268	gold_exit(false);
	269	}
	270	off_t off = this->shoff_ + shdr.get_sh_link() * This::shdr_size;
	271	const unsigned char* psymshdr = this->get_view(off, This::shdr_size);
	272	elfcpp::Shdr<size, big_endian> symshdr(psymshdr);
	273
	274	// Read the symbol table entry.
	275	if (shdr.get_sh_info() >= symshdr.get_sh_size() / This::sym_size)
	276	{
	277	fprintf(stderr, _("%s: %s: section group %u info %u out of range\n"),
	278	program_name, this->name().c_str(), index, shdr.get_sh_info());
	279	gold_exit(false);
	280	}
	281	off_t symoff = symshdr.get_sh_offset() + shdr.get_sh_info() * This::sym_size;
	282	const unsigned char* psym = this->get_view(symoff, This::sym_size);
	283	elfcpp::Sym<size, big_endian> sym(psym);
	284
	285	// Read the section header for the symbol table names.
	286	if (symshdr.get_sh_link() >= this->shnum())
	287	{
	288	fprintf(stderr, _("%s; %s: symtab section %u link %u out of range\n"),
289	program_name, this->name().c_str(), shdr.get_sh_link(),
290	symshdr.get_sh_link());
291	gold_exit(false);
292	}
293	off_t symnameoff = this->shoff_ + symshdr.get_sh_link() * This::shdr_size;
294	const unsigned char* psymnamehdr = this->get_view(symnameoff,
295	This::shdr_size);
296	elfcpp::Shdr<size, big_endian> symnamehdr(psymnamehdr);
297
298	// Read the symbol table names.
299	const unsigned char *psymnamesu = this->get_view(symnamehdr.get_sh_offset(),
300	symnamehdr.get_sh_size());
301	const char* psymnames = reinterpret_cast<const char*>(psymnamesu);
302
303	// Get the section group signature.
304	if (sym.get_st_name() >= symnamehdr.get_sh_size())
305	{
306	fprintf(stderr, _("%s: %s: symbol %u name offset %u out of range\n"),
307	program_name, this->name().c_str(), shdr.get_sh_info(),
308	sym.get_st_name());
309	gold_exit(false);
310	}
311
312	const char* signature = psymnames + sym.get_st_name();
313
314	// Record this section group, and see whether we've already seen one
315	// with the same signature.
316	if (layout->add_comdat(signature, true))
317	return true;
318
319	// This is a duplicate. We want to discard the sections in this
320	// group.
321	size_t count = shdr.get_sh_size() / sizeof(elfcpp::Elf_Word);
322	for (size_t i = 1; i < count; ++i)
323	{
324	elfcpp::Elf_Word secnum = elfcpp::read_elf_word<big_endian>(pword + i);
325	if (secnum >= this->shnum())
326	{
327	fprintf(stderr,
328	_("%s: %s: section %u in section group %u out of range"),
329	program_name, this->name().c_str(), secnum,
330	index);
331	gold_exit(false);
332	}
333	(*omit)[secnum] = true;
334	}
335
336	return false;
337	}
338
339	// Whether to include a linkonce section in the link. NAME is the
340	// name of the section and SHDR is the section header.
341
342	// Linkonce sections are a GNU extension implemented in the original
343	// GNU linker before section groups were defined. The semantics are
344	// that we only include one linkonce section with a given name. The
345	// name of a linkonce section is normally .gnu.linkonce.T.SYMNAME,
346	// where T is the type of section and SYMNAME is the name of a symbol.
347	// In an attempt to make linkonce sections interact well with section
348	// groups, we try to identify SYMNAME and use it like a section group
349	// signature. We want to block section groups with that signature,
350	// but not other linkonce sections with that signature. We also use
351	// the full name of the linkonce section as a normal section group
352	// signature.
353
354	template<int size, bool big_endian>
355	bool
356	Sized_object<size, big_endian>::include_linkonce_section(
357	Layout* layout,
358	const char* name,
359	const elfcpp::Shdr<size, big_endian>&)
360	{
361	const char* symname = strrchr(name, '.') + 1;
362	bool omit1 = layout->add_comdat(symname, false);
363	bool omit2 = layout->add_comdat(name, true);
364	return omit1 \|\| omit2;
365	}
366
367	// Lay out the input sections. We walk through the sections and check
368	// whether they should be included in the link. If they should, we
369	// pass them to the Layout object, which will return an output section
370	// and an offset.
371
372	template<int size, bool big_endian>
373	void
374	Sized_object<size, big_endian>::do_layout(Layout* layout)
375	{
376	// This is always called from the main thread. Lock the file to
377	// keep the error checks happy.
378	Task_locker_obj<File_read> frl(this->input_file()->file());
379
380	// Get the section headers.
381	unsigned int shnum = this->shnum();
382	const unsigned char* pshdrs = this->get_view(this->shoff_,
383	shnum * This::shdr_size);
384
385	// Get the section names.
386	const unsigned char* pshdrnames = pshdrs + this->shstrndx_ * This::shdr_size;
387	elfcpp::Shdr<size, big_endian> shdrnames(pshdrnames);
388	typename elfcpp::Elf_types<size>::Elf_WXword names_size =
389	shdrnames.get_sh_size();
390	const unsigned char* pnamesu = this->get_view(shdrnames.get_sh_offset(),
391	shdrnames.get_sh_size());
392	const char* pnames = reinterpret_cast<const char*>(pnamesu);
393
394	std::vector<Map_to_output>& map_sections(this->map_to_output());
395	map_sections.reserve(shnum);
396
397	// Keep track of which sections to omit.
398	std::vector<bool> omit(shnum, false);
399
400	for (unsigned int i = 0; i < shnum; ++i)
401	{
402	elfcpp::Shdr<size, big_endian> shdr(pshdrs);
403
404	if (shdr.get_sh_name() >= names_size)
405	{
406	fprintf(stderr,
407	_("%s: %s: bad section name offset for section %u: %lu\n"),
408	program_name, this->name().c_str(), i,
409	static_cast<unsigned long>(shdr.get_sh_name()));
410	gold_exit(false);
411	}
412
413	const char* name = pnames + shdr.get_sh_name();
414
415	bool discard = omit[i];
416	if (!discard)
417	{
418	if (shdr.get_sh_type() == elfcpp::SHT_GROUP)
419	{
420	if (!this->include_section_group(layout, i, shdr, &omit))
421	discard = true;
422	}
423	else if (Layout::is_linkonce(name))
424	{
425	if (!this->include_linkonce_section(layout, name, shdr))
426	discard = true;
427	}
428	}
429
430	if (discard)
431	{
432	// Do not include this section in the link.
433	map_sections[i].output_section = NULL;
434	continue;
435	}
436
437	off_t offset;
438	Output_section* os = layout->layout(this, name, shdr, &offset);
439
440	map_sections[i].output_section = os;
441	map_sections[i].offset = offset;
442
443	pshdrs += This::shdr_size;
444	}
bae7f79e ILT	445	}
	446
	447	} // End namespace gold.
	448
	449	namespace
	450	{
	451
	452	using namespace gold;
	453
	454	// Read an ELF file with the header and return the appropriate
	455	// instance of Object.
	456
	457	template<int size, bool big_endian>
	458	Object*
	459	make_elf_sized_object(const std::string& name, Input_file* input_file,
	460	off_t offset, const elfcpp::Ehdr<size, big_endian>& ehdr)
	461	{
	462	int et = ehdr.get_e_type();
	463	if (et != elfcpp::ET_REL && et != elfcpp::ET_DYN)
	464	{
	465	fprintf(stderr, "%s: %s: unsupported ELF type %d\n",
	466	program_name, name.c_str(), static_cast<int>(et));
	467	gold_exit(false);
	468	}
	469
	470	if (et == elfcpp::ET_REL)
	471	{
	472	Sized_object<size, big_endian>* obj =
	473	new Sized_object<size, big_endian>(name, input_file, offset, ehdr);
	474	obj->setup(ehdr);
	475	return obj;
	476	}
	477	else
	478	{
	479	// elfcpp::ET_DYN
	480	fprintf(stderr, _("%s: %s: dynamic objects are not yet supported\n"),
	481	program_name, name.c_str());
	482	gold_exit(false);
	483	// Sized_dynobj<size, big_endian>* obj =
	484	// new Sized_dynobj<size, big_endian>(this->input_.name(), input_file,
	485	// offset, ehdr);
	486	// obj->setup(ehdr);
	487	// return obj;
	488	}
	489	}
	490
	491	} // End anonymous namespace.
	492
	493	namespace gold
	494	{
	495
	496	// Read an ELF file and return the appropriate instance of Object.
	497
	498	Object*
	499	make_elf_object(const std::string& name, Input_file* input_file, off_t offset,
	500	const unsigned char* p, off_t bytes)
	501	{
	502	if (bytes < elfcpp::EI_NIDENT)
	503	{
	504	fprintf(stderr, _("%s: %s: ELF file too short\n"),
	505	program_name, name.c_str());
	506	gold_exit(false);
	507	}
	508
509	int v = p[elfcpp::EI_VERSION];
510	if (v != elfcpp::EV_CURRENT)
511	{
512	if (v == elfcpp::EV_NONE)
513	fprintf(stderr, _("%s: %s: invalid ELF version 0\n"),
514	program_name, name.c_str());
515	else
516	fprintf(stderr, _("%s: %s: unsupported ELF version %d\n"),
517	program_name, name.c_str(), v);
518	gold_exit(false);
519	}
520
521	int c = p[elfcpp::EI_CLASS];
522	if (c == elfcpp::ELFCLASSNONE)
523	{
524	fprintf(stderr, _("%s: %s: invalid ELF class 0\n"),
525	program_name, name.c_str());
526	gold_exit(false);
527	}
528	else if (c != elfcpp::ELFCLASS32
529	&& c != elfcpp::ELFCLASS64)
530	{
531	fprintf(stderr, _("%s: %s: unsupported ELF class %d\n"),
532	program_name, name.c_str(), c);
533	gold_exit(false);
534	}
535
536	int d = p[elfcpp::EI_DATA];
537	if (d == elfcpp::ELFDATANONE)
538	{
539	fprintf(stderr, _("%s: %s: invalid ELF data encoding\n"),
540	program_name, name.c_str());
541	gold_exit(false);
542	}
543	else if (d != elfcpp::ELFDATA2LSB
544	&& d != elfcpp::ELFDATA2MSB)
545	{
546	fprintf(stderr, _("%s: %s: unsupported ELF data encoding %d\n"),
547	program_name, name.c_str(), d);
548	gold_exit(false);
549	}
550
551	bool big_endian = d == elfcpp::ELFDATA2MSB;
552
553	if (c == elfcpp::ELFCLASS32)
554	{
555	if (bytes < elfcpp::Elf_sizes<32>::ehdr_size)
556	{
557	fprintf(stderr, _("%s: %s: ELF file too short\n"),
558	program_name, name.c_str());
559	gold_exit(false);
560	}
561	if (big_endian)
562	{
563	elfcpp::Ehdr<32, true> ehdr(p);
564	return make_elf_sized_object<32, true>(name, input_file,
565	offset, ehdr);
566	}
567	else
568	{
569	elfcpp::Ehdr<32, false> ehdr(p);
570	return make_elf_sized_object<32, false>(name, input_file,
571	offset, ehdr);
572	}
573	}
574	else
575	{
576	if (bytes < elfcpp::Elf_sizes<32>::ehdr_size)
577	{
578	fprintf(stderr, _("%s: %s: ELF file too short\n"),
579	program_name, name.c_str());
580	gold_exit(false);
581	}
582	if (big_endian)
583	{
584	elfcpp::Ehdr<64, true> ehdr(p);
585	return make_elf_sized_object<64, true>(name, input_file,
586	offset, ehdr);
587	}
588	else
589	{
590	elfcpp::Ehdr<64, false> ehdr(p);
591	return make_elf_sized_object<64, false>(name, input_file,
592	offset, ehdr);
593	}
594	}
595	}
596
597	// Instantiate the templates we need. We could use the configure
598	// script to restrict this to only the ones for implemented targets.
599
600	template
601	class Sized_object<32, false>;
602
603	template
604	class Sized_object<32, true>;
605
606	template
607	class Sized_object<64, false>;
608
609	template
610	class Sized_object<64, true>;
611
612	} // End namespace gold.