[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"

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, offset),
    osabi_(ehdr.get_e_ident()[elfcpp::EI_OSABI]),
    abiversion_(ehdr.get_e_ident()[elfcpp::EI_ABIVERSION]),
    machine_(ehdr.get_e_machine()),
    flags_(ehdr.get_e_flags()),
    target_(NULL),
    shoff_(ehdr.get_e_shoff()),
    shnum_(0),
    shstrndx_(0),
    symtab_shnum_(0)
{
  if (ehdr.get_e_ehsize() != elfcpp::Elf_sizes<size>::ehdr_size)
    {
      fprintf(stderr, _("%s: %s: bad e_ehsize field (%d != %d)\n"),
	      program_name, this->name().c_str(), ehdr.get_e_ehsize(),
	      elfcpp::Elf_sizes<size>::ehdr_size);
      gold_exit(false);
    }
  if (ehdr.get_e_shentsize() != elfcpp::Elf_sizes<size>::shdr_size)
    {
      fprintf(stderr, _("%s: %s: bad e_shentsize field (%d != %d)\n"),
	      program_name, this->name().c_str(), ehdr.get_e_shentsize(),
	      elfcpp::Elf_sizes<size>::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)
{
  //  this->target_ = select_target(this->machine_, size, big_endian,
  //				this->osabi_, this->abiversion_);
  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_, elfcpp::Elf_sizes<size>::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->shnum_ = shnum;
  this->shstrndx_ = shstrndx;

  if (shnum == 0)
    return;

  // Find the SHT_SYMTAB section.
  const unsigned char* p = this->get_view
    (this->shoff_, shnum * elfcpp::Elf_sizes<size>::shdr_size);
  // Skip the first section, which is always empty.
  p += elfcpp::Elf_sizes<size>::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 += elfcpp::Elf_sizes<size>::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;
    }

  int shdr_size = elfcpp::Elf_sizes<size>::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);

  // Read the symbol table.
  File_view* fvsymtab = this->get_lasting_view(symtabshdr.get_sh_offset(),
					       symtabshdr.get_sh_size());

  // 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 = symtabshdr.get_sh_size();
  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(Read_symbols_data sd)
{
  if (sd.symbols == NULL)
    {
      assert(sd.symbol_names == NULL);
      return;
    }

  int sym_size = elfcpp::Elf_sizes<size>::sym_size;
  const unsigned char* symstart = sd.symbols->data();
  const unsigned char* symend = symstart + sd.symbols_size;
  for (const unsigned char* p = symstart; p < symend; p += sym_size)
    {
      elfcpp::Sym<size, big_endian> sym(p);

      unsigned int nameoff = sym.get_st_name();
      if (nameoff >= sd.symbol_names_size)
	{
	  fprintf(stderr,
		  _("%s: %s: invalid symbol name offset %u for symbol %d\n"),
		  program_name, this->name().c_str(), nameoff,
		  (p - symstart) / sym_size);
	  gold_exit(false);
	}
      const unsigned char* name = sd.symbol_names->data() + nameoff;
      printf("%s\n", name);
    }
}

} // 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"
	10
	11	namespace gold
	12	{
	13
	14	// Class Object.
	15
	16	const unsigned char*
	17	Object::get_view(off_t start, off_t size)
	18	{
	19	return this->input_file_->file().get_view(start + this->offset_, size);
	20	}
	21
	22	void
	23	Object::read(off_t start, off_t size, void* p)
	24	{
	25	this->input_file_->file().read(start + this->offset_, size, p);
	26	}
	27
	28	File_view*
	29	Object::get_lasting_view(off_t start, off_t size)
	30	{
	31	return this->input_file_->file().get_lasting_view(start + this->offset_,
	32	size);
	33	}
	34
	35	// Class Sized_object.
	36
	37	template<int size, bool big_endian>
	38	Sized_object<size, big_endian>::Sized_object(
	39	const std::string& name,
	40	Input_file* input_file,
	41	off_t offset,
	42	const elfcpp::Ehdr<size, big_endian>& ehdr)
	43	: Object(name, input_file, offset),
	44	osabi_(ehdr.get_e_ident()[elfcpp::EI_OSABI]),
	45	abiversion_(ehdr.get_e_ident()[elfcpp::EI_ABIVERSION]),
	46	machine_(ehdr.get_e_machine()),
	47	flags_(ehdr.get_e_flags()),
	48	target_(NULL),
	49	shoff_(ehdr.get_e_shoff()),
	50	shnum_(0),
	51	shstrndx_(0),
	52	symtab_shnum_(0)
	53	{
	54	if (ehdr.get_e_ehsize() != elfcpp::Elf_sizes<size>::ehdr_size)
	55	{
	56	fprintf(stderr, _("%s: %s: bad e_ehsize field (%d != %d)\n"),
	57	program_name, this->name().c_str(), ehdr.get_e_ehsize(),
	58	elfcpp::Elf_sizes<size>::ehdr_size);
	59	gold_exit(false);
	60	}
	61	if (ehdr.get_e_shentsize() != elfcpp::Elf_sizes<size>::shdr_size)
	62	{
	63	fprintf(stderr, _("%s: %s: bad e_shentsize field (%d != %d)\n"),
	64	program_name, this->name().c_str(), ehdr.get_e_shentsize(),
65	elfcpp::Elf_sizes<size>::shdr_size);
66	gold_exit(false);
67	}
68	}
69
70	template<int size, bool big_endian>
71	Sized_object<size, big_endian>::~Sized_object()
72	{
73	}
74
75	// Set up an object file bsaed on the file header. This sets up the
76	// target and reads the section information.
77
78	template<int size, bool big_endian>
79	void
80	Sized_object<size, big_endian>::setup(
81	const elfcpp::Ehdr<size, big_endian>& ehdr)
82	{
83	// this->target_ = select_target(this->machine_, size, big_endian,
84	// this->osabi_, this->abiversion_);
85	unsigned int shnum = ehdr.get_e_shnum();
86	unsigned int shstrndx = ehdr.get_e_shstrndx();
87	if ((shnum == 0 \|\| shstrndx == elfcpp::SHN_XINDEX)
88	&& this->shoff_ != 0)
89	{
90	const unsigned char* p = this->get_view
91	(this->shoff_, elfcpp::Elf_sizes<size>::shdr_size);
92	elfcpp::Shdr<size, big_endian> shdr(p);
93	if (shnum == 0)
94	shnum = shdr.get_sh_size();
95	if (shstrndx == elfcpp::SHN_XINDEX)
96	shstrndx = shdr.get_sh_link();
97	}
98	this->shnum_ = shnum;
99	this->shstrndx_ = shstrndx;
100
101	if (shnum == 0)
102	return;
103
104	// Find the SHT_SYMTAB section.
105	const unsigned char* p = this->get_view
106	(this->shoff_, shnum * elfcpp::Elf_sizes<size>::shdr_size);
107	// Skip the first section, which is always empty.
108	p += elfcpp::Elf_sizes<size>::shdr_size;
109	for (unsigned int i = 1; i < shnum; ++i)
110	{
111	elfcpp::Shdr<size, big_endian> shdr(p);
112	if (shdr.get_sh_type() == elfcpp::SHT_SYMTAB)
113	{
114	this->symtab_shnum_ = i;
115	break;
116	}
117	p += elfcpp::Elf_sizes<size>::shdr_size;
118	}
119	}
120
121	// Read the symbols and relocations from an object file.
122
123	template<int size, bool big_endian>
124	Read_symbols_data
125	Sized_object<size, big_endian>::do_read_symbols()
126	{
127	if (this->symtab_shnum_ == 0)
128	{
129	// No symbol table. Weird but legal.
130	Read_symbols_data ret;
131	ret.symbols = NULL;
132	ret.symbols_size = 0;
133	ret.symbol_names = NULL;
134	ret.symbol_names_size = 0;
135	return ret;
136	}
137
138	int shdr_size = elfcpp::Elf_sizes<size>::shdr_size;
139
140	// Read the symbol table section header.
141	off_t symtabshdroff = this->shoff_ + (this->symtab_shnum_ * shdr_size);
142	const unsigned char* psymtabshdr = this->get_view(symtabshdroff, shdr_size);
143	elfcpp::Shdr<size, big_endian> symtabshdr(psymtabshdr);
144	assert(symtabshdr.get_sh_type() == elfcpp::SHT_SYMTAB);
145
146	// Read the symbol table.
147	File_view* fvsymtab = this->get_lasting_view(symtabshdr.get_sh_offset(),
148	symtabshdr.get_sh_size());
149
150	// Read the section header for the symbol names.
151	unsigned int strtab_shnum = symtabshdr.get_sh_link();
152	if (strtab_shnum == 0 \|\| strtab_shnum >= this->shnum_)
153	{
154	fprintf(stderr, _("%s: %s: invalid symbol table name index: %u\n"),
155	program_name, this->name().c_str(), strtab_shnum);
156	gold_exit(false);
157	}
158	off_t strtabshdroff = this->shoff_ + (strtab_shnum * shdr_size);
159	const unsigned char *pstrtabshdr = this->get_view(strtabshdroff, shdr_size);
160	elfcpp::Shdr<size, big_endian> strtabshdr(pstrtabshdr);
161	if (strtabshdr.get_sh_type() != elfcpp::SHT_STRTAB)
162	{
163	fprintf(stderr,
164	_("%s: %s: symbol table name section has wrong type: %u\n"),
165	program_name, this->name().c_str(),
166	static_cast<unsigned int>(strtabshdr.get_sh_type()));
167	gold_exit(false);
168	}
169
170	// Read the symbol names.
171	File_view* fvstrtab = this->get_lasting_view(strtabshdr.get_sh_offset(),
172	strtabshdr.get_sh_size());
173
174	Read_symbols_data ret;
175	ret.symbols = fvsymtab;
176	ret.symbols_size = symtabshdr.get_sh_size();
177	ret.symbol_names = fvstrtab;
178	ret.symbol_names_size = strtabshdr.get_sh_size();
179
180	return ret;
181	}
182
183	// Add the symbols to the symbol table.
184
185	template<int size, bool big_endian>
186	void
187	Sized_object<size, big_endian>::do_add_symbols(Read_symbols_data sd)
188	{
189	if (sd.symbols == NULL)
190	{
191	assert(sd.symbol_names == NULL);
192	return;
193	}
194
195	int sym_size = elfcpp::Elf_sizes<size>::sym_size;
196	const unsigned char* symstart = sd.symbols->data();
197	const unsigned char* symend = symstart + sd.symbols_size;
198	for (const unsigned char* p = symstart; p < symend; p += sym_size)
199	{
200	elfcpp::Sym<size, big_endian> sym(p);
201
202	unsigned int nameoff = sym.get_st_name();
203	if (nameoff >= sd.symbol_names_size)
204	{
205	fprintf(stderr,
206	_("%s: %s: invalid symbol name offset %u for symbol %d\n"),
207	program_name, this->name().c_str(), nameoff,
208	(p - symstart) / sym_size);
209	gold_exit(false);
210	}
211	const unsigned char* name = sd.symbol_names->data() + nameoff;
212	printf("%s\n", name);
213	}
214	}
215
216	} // End namespace gold.
217
218	namespace
219	{
220
221	using namespace gold;
222
223	// Read an ELF file with the header and return the appropriate
224	// instance of Object.
225
226	template<int size, bool big_endian>
227	Object*
228	make_elf_sized_object(const std::string& name, Input_file* input_file,
229	off_t offset, const elfcpp::Ehdr<size, big_endian>& ehdr)
230	{
231	int et = ehdr.get_e_type();
232	if (et != elfcpp::ET_REL && et != elfcpp::ET_DYN)
233	{
234	fprintf(stderr, "%s: %s: unsupported ELF type %d\n",
235	program_name, name.c_str(), static_cast<int>(et));
236	gold_exit(false);
237	}
238
239	if (et == elfcpp::ET_REL)
240	{
241	Sized_object<size, big_endian>* obj =
242	new Sized_object<size, big_endian>(name, input_file, offset, ehdr);
243	obj->setup(ehdr);
244	return obj;
245	}
246	else
247	{
248	// elfcpp::ET_DYN
249	fprintf(stderr, _("%s: %s: dynamic objects are not yet supported\n"),
250	program_name, name.c_str());
251	gold_exit(false);
252	// Sized_dynobj<size, big_endian>* obj =
253	// new Sized_dynobj<size, big_endian>(this->input_.name(), input_file,
254	// offset, ehdr);
255	// obj->setup(ehdr);
256	// return obj;
257	}
258	}
259
260	} // End anonymous namespace.
261
262	namespace gold
263	{
264
265	// Read an ELF file and return the appropriate instance of Object.
266
267	Object*
268	make_elf_object(const std::string& name, Input_file* input_file, off_t offset,
269	const unsigned char* p, off_t bytes)
270	{
271	if (bytes < elfcpp::EI_NIDENT)
272	{
273	fprintf(stderr, _("%s: %s: ELF file too short\n"),
274	program_name, name.c_str());
275	gold_exit(false);
276	}
277
278	int v = p[elfcpp::EI_VERSION];
279	if (v != elfcpp::EV_CURRENT)
280	{
281	if (v == elfcpp::EV_NONE)
282	fprintf(stderr, _("%s: %s: invalid ELF version 0\n"),
283	program_name, name.c_str());
284	else
285	fprintf(stderr, _("%s: %s: unsupported ELF version %d\n"),
286	program_name, name.c_str(), v);
287	gold_exit(false);
288	}
289
290	int c = p[elfcpp::EI_CLASS];
291	if (c == elfcpp::ELFCLASSNONE)
292	{
293	fprintf(stderr, _("%s: %s: invalid ELF class 0\n"),
294	program_name, name.c_str());
295	gold_exit(false);
296	}
297	else if (c != elfcpp::ELFCLASS32
298	&& c != elfcpp::ELFCLASS64)
299	{
300	fprintf(stderr, _("%s: %s: unsupported ELF class %d\n"),
301	program_name, name.c_str(), c);
302	gold_exit(false);
303	}
304
305	int d = p[elfcpp::EI_DATA];
306	if (d == elfcpp::ELFDATANONE)
307	{
308	fprintf(stderr, _("%s: %s: invalid ELF data encoding\n"),
309	program_name, name.c_str());
310	gold_exit(false);
311	}
312	else if (d != elfcpp::ELFDATA2LSB
313	&& d != elfcpp::ELFDATA2MSB)
314	{
315	fprintf(stderr, _("%s: %s: unsupported ELF data encoding %d\n"),
316	program_name, name.c_str(), d);
317	gold_exit(false);
318	}
319
320	bool big_endian = d == elfcpp::ELFDATA2MSB;
321
322	if (c == elfcpp::ELFCLASS32)
323	{
324	if (bytes < elfcpp::Elf_sizes<32>::ehdr_size)
325	{
326	fprintf(stderr, _("%s: %s: ELF file too short\n"),
327	program_name, name.c_str());
328	gold_exit(false);
329	}
330	if (big_endian)
331	{
332	elfcpp::Ehdr<32, true> ehdr(p);
333	return make_elf_sized_object<32, true>(name, input_file,
334	offset, ehdr);
335	}
336	else
337	{
338	elfcpp::Ehdr<32, false> ehdr(p);
339	return make_elf_sized_object<32, false>(name, input_file,
340	offset, ehdr);
341	}
342	}
343	else
344	{
345	if (bytes < elfcpp::Elf_sizes<32>::ehdr_size)
346	{
347	fprintf(stderr, _("%s: %s: ELF file too short\n"),
348	program_name, name.c_str());
349	gold_exit(false);
350	}
351	if (big_endian)
352	{
353	elfcpp::Ehdr<64, true> ehdr(p);
354	return make_elf_sized_object<64, true>(name, input_file,
355	offset, ehdr);
356	}
357	else
358	{
359	elfcpp::Ehdr<64, false> ehdr(p);
360	return make_elf_sized_object<64, false>(name, input_file,
361	offset, ehdr);
362	}
363	}
364	}
365
366	// Instantiate the templates we need. We could use the configure
367	// script to restrict this to only the ones for implemented targets.
368
369	template
370	class Sized_object<32, false>;
371
372	template
373	class Sized_object<32, true>;
374
375	template
376	class Sized_object<64, false>;
377
378	template
379	class Sized_object<64, true>;
380
381	} // End namespace gold.