[binutils.git] / bfd / elf.c

/* ELF executable support for BFD.
   Copyright 1993 Free Software Foundation, Inc.

This file is part of BFD, the Binary File Descriptor library.

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */

/*

SECTION
	ELF backends

	BFD support for ELF formats is being worked on.
	Currently, the best supported back ends are for sparc and i386
	(running svr4 or Solaris 2).

	Documentation of the internals of the support code still needs
	to be written.  The code is changing quickly enough that we
	haven't bothered yet.
 */

#include "bfd.h"
#include "sysdep.h"
#include "bfdlink.h"
#include "libbfd.h"
#define ARCH_SIZE 0
#include "libelf.h"

/* Standard ELF hash function.  Do not change this function; you will
   cause invalid hash tables to be generated.  (Well, you would if this
   were being used yet.)  */
unsigned long
bfd_elf_hash (name)
     CONST unsigned char *name;
{
  unsigned long h = 0;
  unsigned long g;
  int ch;

  while ((ch = *name++) != '\0')
    {
      h = (h << 4) + ch;
      if ((g = (h & 0xf0000000)) != 0)
	{
	  h ^= g >> 24;
	  h &= ~g;
	}
    }
  return h;
}

/* Read a specified number of bytes at a specified offset in an ELF
   file, into a newly allocated buffer, and return a pointer to the
   buffer. */

static char *
elf_read (abfd, offset, size)
     bfd * abfd;
     long offset;
     int size;
{
  char *buf;

  if ((buf = bfd_alloc (abfd, size)) == NULL)
    {
      bfd_set_error (bfd_error_no_memory);
      return NULL;
    }
  if (bfd_seek (abfd, offset, SEEK_SET) == -1)
    return NULL;
  if (bfd_read ((PTR) buf, size, 1, abfd) != size)
    {
      if (bfd_get_error () != bfd_error_system_call)
	bfd_set_error (bfd_error_file_truncated);
      return NULL;
    }
  return buf;
}

boolean
elf_mkobject (abfd)
     bfd * abfd;
{
  /* this just does initialization */
  /* coff_mkobject zalloc's space for tdata.coff_obj_data ... */
  elf_tdata (abfd) = (struct elf_obj_tdata *)
    bfd_zalloc (abfd, sizeof (struct elf_obj_tdata));
  if (elf_tdata (abfd) == 0)
    {
      bfd_set_error (bfd_error_no_memory);
      return false;
    }
  /* since everything is done at close time, do we need any
     initialization? */

  return true;
}

char *
elf_get_str_section (abfd, shindex)
     bfd * abfd;
     unsigned int shindex;
{
  Elf_Internal_Shdr **i_shdrp;
  char *shstrtab = NULL;
  unsigned int offset;
  unsigned int shstrtabsize;

  i_shdrp = elf_elfsections (abfd);
  if (i_shdrp == 0 || i_shdrp[shindex] == 0)
    return 0;

  shstrtab = i_shdrp[shindex]->rawdata;
  if (shstrtab == NULL)
    {
      /* No cached one, attempt to read, and cache what we read. */
      offset = i_shdrp[shindex]->sh_offset;
      shstrtabsize = i_shdrp[shindex]->sh_size;
      shstrtab = elf_read (abfd, offset, shstrtabsize);
      i_shdrp[shindex]->rawdata = (void *) shstrtab;
    }
  return shstrtab;
}

char *
elf_string_from_elf_section (abfd, shindex, strindex)
     bfd * abfd;
     unsigned int shindex;
     unsigned int strindex;
{
  Elf_Internal_Shdr *hdr;

  if (strindex == 0)
    return "";

  hdr = elf_elfsections (abfd)[shindex];

  if (!hdr->rawdata
      && elf_get_str_section (abfd, shindex) == NULL)
    return NULL;

  return ((char *) hdr->rawdata) + strindex;
}

/* Make a BFD section from an ELF section.  We store a pointer to the
   BFD section in the rawdata field of the header.  */

boolean
_bfd_elf_make_section_from_shdr (abfd, hdr, name)
     bfd *abfd;
     Elf_Internal_Shdr *hdr;
     const char *name;
{
  asection *newsect;
  flagword flags;

  if (hdr->rawdata != NULL)
    {
      BFD_ASSERT (strcmp (name, ((asection *) hdr->rawdata)->name) == 0);
      return true;
    }

  newsect = bfd_make_section_anyway (abfd, name);
  if (newsect == NULL)
    return false;

  newsect->filepos = hdr->sh_offset;

  if (! bfd_set_section_vma (abfd, newsect, hdr->sh_addr)
      || ! bfd_set_section_size (abfd, newsect, hdr->sh_size)
      || ! bfd_set_section_alignment (abfd, newsect,
				      bfd_log2 (hdr->sh_addralign)))
    return false;

  flags = SEC_NO_FLAGS;
  if (hdr->sh_type != SHT_NOBITS)
    flags |= SEC_HAS_CONTENTS;
  if ((hdr->sh_flags & SHF_ALLOC) != 0)
    {
      flags |= SEC_ALLOC;
      if (hdr->sh_type != SHT_NOBITS)
	flags |= SEC_LOAD;
    }
  if ((hdr->sh_flags & SHF_WRITE) == 0)
    flags |= SEC_READONLY;
  if ((hdr->sh_flags & SHF_EXECINSTR) != 0)
    flags |= SEC_CODE;
  else if ((flags & SEC_ALLOC) != 0)
    flags |= SEC_DATA;

  /* The debugging sections appear to be recognized only by name, not
     any sort of flag.  */
  if (strncmp (name, ".debug", sizeof ".debug" - 1) == 0
      || strncmp (name, ".line", sizeof ".line" - 1) == 0
      || strncmp (name, ".stab", sizeof ".stab" - 1) == 0)
    flags |= SEC_DEBUGGING;

  if (! bfd_set_section_flags (abfd, newsect, flags))
    return false;

  hdr->rawdata = (PTR) newsect;
  elf_section_data (newsect)->this_hdr = *hdr;

  return true;
}

/*
INTERNAL_FUNCTION
	bfd_elf_find_section

SYNOPSIS
	struct elf_internal_shdr *bfd_elf_find_section (bfd *abfd, char *name);

DESCRIPTION
	Helper functions for GDB to locate the string tables.
	Since BFD hides string tables from callers, GDB needs to use an
	internal hook to find them.  Sun's .stabstr, in particular,
	isn't even pointed to by the .stab section, so ordinary
	mechanisms wouldn't work to find it, even if we had some.
*/

struct elf_internal_shdr *
bfd_elf_find_section (abfd, name)
     bfd * abfd;
     char *name;
{
  Elf_Internal_Shdr **i_shdrp;
  char *shstrtab;
  unsigned int max;
  unsigned int i;

  i_shdrp = elf_elfsections (abfd);
  if (i_shdrp != NULL)
    {
      shstrtab = elf_get_str_section (abfd, elf_elfheader (abfd)->e_shstrndx);
      if (shstrtab != NULL)
	{
	  max = elf_elfheader (abfd)->e_shnum;
	  for (i = 1; i < max; i++)
	    if (!strcmp (&shstrtab[i_shdrp[i]->sh_name], name))
	      return i_shdrp[i];
	}
    }
  return 0;
}

const char *const bfd_elf_section_type_names[] = {
  "SHT_NULL", "SHT_PROGBITS", "SHT_SYMTAB", "SHT_STRTAB",
  "SHT_RELA", "SHT_HASH", "SHT_DYNAMIC", "SHT_NOTE",
  "SHT_NOBITS", "SHT_REL", "SHT_SHLIB", "SHT_DYNSYM",
};

/* ELF relocs are against symbols.  If we are producing relocateable
   output, and the reloc is against an external symbol, and nothing
   has given us any additional addend, the resulting reloc will also
   be against the same symbol.  In such a case, we don't want to
   change anything about the way the reloc is handled, since it will
   all be done at final link time.  Rather than put special case code
   into bfd_perform_relocation, all the reloc types use this howto
   function.  It just short circuits the reloc if producing
   relocateable output against an external symbol.  */

/*ARGSUSED*/
bfd_reloc_status_type
bfd_elf_generic_reloc (abfd,
		       reloc_entry,
		       symbol,
		       data,
		       input_section,
		       output_bfd,
		       error_message)
     bfd *abfd;
     arelent *reloc_entry;
     asymbol *symbol;
     PTR data;
     asection *input_section;
     bfd *output_bfd;
     char **error_message;
{
  if (output_bfd != (bfd *) NULL
      && (symbol->flags & BSF_SECTION_SYM) == 0
      && (! reloc_entry->howto->partial_inplace
	  || reloc_entry->addend == 0))
    {
      reloc_entry->address += input_section->output_offset;
      return bfd_reloc_ok;
    }

  return bfd_reloc_continue;
}
\f
/* Create an entry in an ELF linker hash table.  */

struct bfd_hash_entry *
_bfd_elf_link_hash_newfunc (entry, table, string)
     struct bfd_hash_entry *entry;
     struct bfd_hash_table *table;
     const char *string;
{
  struct elf_link_hash_entry *ret = (struct elf_link_hash_entry *) entry;

  /* Allocate the structure if it has not already been allocated by a
     subclass.  */
  if (ret == (struct elf_link_hash_entry *) NULL)
    ret = ((struct elf_link_hash_entry *)
	   bfd_hash_allocate (table, sizeof (struct elf_link_hash_entry)));
  if (ret == (struct elf_link_hash_entry *) NULL)
    {
      bfd_set_error (bfd_error_no_memory);
      return (struct bfd_hash_entry *) ret;
    }

  /* Call the allocation method of the superclass.  */
  ret = ((struct elf_link_hash_entry *)
	 _bfd_link_hash_newfunc ((struct bfd_hash_entry *) ret,
				 table, string));
  if (ret != (struct elf_link_hash_entry *) NULL)
    {
      /* Set local fields.  */
      ret->indx = -1;
      ret->size = 0;
      ret->align = 0;
      ret->dynindx = -1;
      ret->dynstr_index = 0;
      ret->weakdef = NULL;
      ret->type = STT_NOTYPE;
      ret->elf_link_hash_flags = 0;
    }

  return (struct bfd_hash_entry *) ret;
}

/* Initialize an ELF linker hash table.  */

boolean
_bfd_elf_link_hash_table_init (table, abfd, newfunc)
     struct elf_link_hash_table *table;
     bfd *abfd;
     struct bfd_hash_entry *(*newfunc) PARAMS ((struct bfd_hash_entry *,
						struct bfd_hash_table *,
						const char *));
{
  table->dynobj = NULL;
  table->dynsymcount = 0;
  table->dynstr = NULL;
  table->bucketcount = 0;
  return _bfd_link_hash_table_init (&table->root, abfd, newfunc);
}

/* Create an ELF linker hash table.  */

struct bfd_link_hash_table *
_bfd_elf_link_hash_table_create (abfd)
     bfd *abfd;
{
  struct elf_link_hash_table *ret;

  ret = ((struct elf_link_hash_table *)
	 bfd_alloc (abfd, sizeof (struct elf_link_hash_table)));
  if (ret == (struct elf_link_hash_table *) NULL)
    {
      bfd_set_error (bfd_error_no_memory);
      return NULL;
    }

  if (! _bfd_elf_link_hash_table_init (ret, abfd, _bfd_elf_link_hash_newfunc))
    {
      bfd_release (abfd, ret);
      return NULL;
    }

  return &ret->root;
}
Commit	Line	Data
32090b8e KR	1	/* ELF executable support for BFD.
	2	Copyright 1993 Free Software Foundation, Inc.
	3
	4	This file is part of BFD, the Binary File Descriptor library.
	5
	6	This program is free software; you can redistribute it and/or modify
	7	it under the terms of the GNU General Public License as published by
	8	the Free Software Foundation; either version 2 of the License, or
	9	(at your option) any later version.
	10
	11	This program is distributed in the hope that it will be useful,
	12	but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	GNU General Public License for more details.
	15
	16	You should have received a copy of the GNU General Public License
	17	along with this program; if not, write to the Free Software
	18	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
	19
d1b44e83 ILT	20	/*
	21
	22	SECTION
	23	ELF backends
	24
	25	BFD support for ELF formats is being worked on.
	26	Currently, the best supported back ends are for sparc and i386
	27	(running svr4 or Solaris 2).
	28
	29	Documentation of the internals of the support code still needs
	30	to be written. The code is changing quickly enough that we
	31	haven't bothered yet.
	32	*/
	33
32090b8e KR	34	#include "bfd.h"
32090b8e KR	35	#include "sysdep.h"
013dec1a	36	#include "bfdlink.h"
32090b8e KR	37	#include "libbfd.h"
	38	#define ARCH_SIZE 0
	39	#include "libelf.h"
	40
32090b8e KR	41	/* Standard ELF hash function. Do not change this function; you will
	42	cause invalid hash tables to be generated. (Well, you would if this
	43	were being used yet.) */
	44	unsigned long
013dec1a ILT	45	bfd_elf_hash (name)
013dec1a ILT	46	CONST unsigned char *name;
32090b8e KR	47	{
	48	unsigned long h = 0;
	49	unsigned long g;
	50	int ch;
	51
	52	while ((ch = *name++) != '\0')
	53	{
	54	h = (h << 4) + ch;
	55	if ((g = (h & 0xf0000000)) != 0)
	56	{
	57	h ^= g >> 24;
	58	h &= ~g;
	59	}
	60	}
	61	return h;
	62	}
	63
	64	/* Read a specified number of bytes at a specified offset in an ELF
	65	file, into a newly allocated buffer, and return a pointer to the
	66	buffer. */
	67
	68	static char *
013dec1a ILT	69	elf_read (abfd, offset, size)
	70	bfd * abfd;
	71	long offset;
	72	int size;
32090b8e KR	73	{
	74	char *buf;
	75
	76	if ((buf = bfd_alloc (abfd, size)) == NULL)
	77	{
013dec1a	78	bfd_set_error (bfd_error_no_memory);
32090b8e KR	79	return NULL;
	80	}
	81	if (bfd_seek (abfd, offset, SEEK_SET) == -1)
013dec1a	82	return NULL;
32090b8e KR	83	if (bfd_read ((PTR) buf, size, 1, abfd) != size)
32090b8e KR	84	{
013dec1a ILT	85	if (bfd_get_error () != bfd_error_system_call)
013dec1a ILT	86	bfd_set_error (bfd_error_file_truncated);
32090b8e KR	87	return NULL;
	88	}
	89	return buf;
	90	}
	91
	92	boolean
013dec1a ILT	93	elf_mkobject (abfd)
013dec1a ILT	94	bfd * abfd;
32090b8e KR	95	{
	96	/* this just does initialization */
	97	/* coff_mkobject zalloc's space for tdata.coff_obj_data ... */
	98	elf_tdata (abfd) = (struct elf_obj_tdata *)
	99	bfd_zalloc (abfd, sizeof (struct elf_obj_tdata));
	100	if (elf_tdata (abfd) == 0)
	101	{
013dec1a	102	bfd_set_error (bfd_error_no_memory);
32090b8e KR	103	return false;
	104	}
	105	/* since everything is done at close time, do we need any
	106	initialization? */
	107
	108	return true;
	109	}
	110
	111	char *
013dec1a ILT	112	elf_get_str_section (abfd, shindex)
	113	bfd * abfd;
	114	unsigned int shindex;
32090b8e KR	115	{
	116	Elf_Internal_Shdr **i_shdrp;
	117	char *shstrtab = NULL;
	118	unsigned int offset;
	119	unsigned int shstrtabsize;
	120
	121	i_shdrp = elf_elfsections (abfd);
	122	if (i_shdrp == 0 \|\| i_shdrp[shindex] == 0)
	123	return 0;
	124
	125	shstrtab = i_shdrp[shindex]->rawdata;
	126	if (shstrtab == NULL)
	127	{
	128	/* No cached one, attempt to read, and cache what we read. */
	129	offset = i_shdrp[shindex]->sh_offset;
	130	shstrtabsize = i_shdrp[shindex]->sh_size;
	131	shstrtab = elf_read (abfd, offset, shstrtabsize);
	132	i_shdrp[shindex]->rawdata = (void *) shstrtab;
	133	}
	134	return shstrtab;
	135	}
	136
	137	char *
013dec1a ILT	138	elf_string_from_elf_section (abfd, shindex, strindex)
	139	bfd * abfd;
	140	unsigned int shindex;
	141	unsigned int strindex;
32090b8e KR	142	{
	143	Elf_Internal_Shdr *hdr;
	144
	145	if (strindex == 0)
	146	return "";
	147
	148	hdr = elf_elfsections (abfd)[shindex];
	149
	150	if (!hdr->rawdata
	151	&& elf_get_str_section (abfd, shindex) == NULL)
	152	return NULL;
	153
	154	return ((char *) hdr->rawdata) + strindex;
	155	}
	156
497c5434 ILT	157	/* Make a BFD section from an ELF section. We store a pointer to the
	158	BFD section in the rawdata field of the header. */
	159
	160	boolean
	161	_bfd_elf_make_section_from_shdr (abfd, hdr, name)
	162	bfd *abfd;
	163	Elf_Internal_Shdr *hdr;
	164	const char *name;
	165	{
	166	asection *newsect;
	167	flagword flags;
	168
	169	if (hdr->rawdata != NULL)
	170	{
	171	BFD_ASSERT (strcmp (name, ((asection *) hdr->rawdata)->name) == 0);
	172	return true;
	173	}
	174
	175	newsect = bfd_make_section_anyway (abfd, name);
	176	if (newsect == NULL)
	177	return false;
	178
	179	newsect->filepos = hdr->sh_offset;
	180
	181	if (! bfd_set_section_vma (abfd, newsect, hdr->sh_addr)
	182	\|\| ! bfd_set_section_size (abfd, newsect, hdr->sh_size)
	183	\|\| ! bfd_set_section_alignment (abfd, newsect,
	184	bfd_log2 (hdr->sh_addralign)))
	185	return false;
	186
	187	flags = SEC_NO_FLAGS;
	188	if (hdr->sh_type != SHT_NOBITS)
	189	flags \|= SEC_HAS_CONTENTS;
	190	if ((hdr->sh_flags & SHF_ALLOC) != 0)
	191	{
	192	flags \|= SEC_ALLOC;
	193	if (hdr->sh_type != SHT_NOBITS)
	194	flags \|= SEC_LOAD;
	195	}
	196	if ((hdr->sh_flags & SHF_WRITE) == 0)
	197	flags \|= SEC_READONLY;
	198	if ((hdr->sh_flags & SHF_EXECINSTR) != 0)
	199	flags \|= SEC_CODE;
	200	else if ((flags & SEC_ALLOC) != 0)
	201	flags \|= SEC_DATA;
	202
	203	/* The debugging sections appear to be recognized only by name, not
	204	any sort of flag. */
	205	if (strncmp (name, ".debug", sizeof ".debug" - 1) == 0
	206	\|\| strncmp (name, ".line", sizeof ".line" - 1) == 0
	207	\|\| strncmp (name, ".stab", sizeof ".stab" - 1) == 0)
	208	flags \|= SEC_DEBUGGING;
	209
	210	if (! bfd_set_section_flags (abfd, newsect, flags))
	211	return false;
	212
	213	hdr->rawdata = (PTR) newsect;
	214	elf_section_data (newsect)->this_hdr = *hdr;
	215
	216	return true;
	217	}
	218
32090b8e KR	219	/*
	220	INTERNAL_FUNCTION
	221	bfd_elf_find_section
	222
	223	SYNOPSIS
	224	struct elf_internal_shdr bfd_elf_find_section (bfd abfd, char *name);
	225
	226	DESCRIPTION
	227	Helper functions for GDB to locate the string tables.
	228	Since BFD hides string tables from callers, GDB needs to use an
	229	internal hook to find them. Sun's .stabstr, in particular,
	230	isn't even pointed to by the .stab section, so ordinary
	231	mechanisms wouldn't work to find it, even if we had some.
	232	*/
	233
	234	struct elf_internal_shdr *
013dec1a ILT	235	bfd_elf_find_section (abfd, name)
	236	bfd * abfd;
	237	char *name;
32090b8e KR	238	{
	239	Elf_Internal_Shdr **i_shdrp;
	240	char *shstrtab;
	241	unsigned int max;
	242	unsigned int i;
	243
	244	i_shdrp = elf_elfsections (abfd);
	245	if (i_shdrp != NULL)
	246	{
	247	shstrtab = elf_get_str_section (abfd, elf_elfheader (abfd)->e_shstrndx);
	248	if (shstrtab != NULL)
	249	{
	250	max = elf_elfheader (abfd)->e_shnum;
	251	for (i = 1; i < max; i++)
	252	if (!strcmp (&shstrtab[i_shdrp[i]->sh_name], name))
	253	return i_shdrp[i];
	254	}
	255	}
	256	return 0;
	257	}
	258
32090b8e KR	259	const char *const bfd_elf_section_type_names[] = {
	260	"SHT_NULL", "SHT_PROGBITS", "SHT_SYMTAB", "SHT_STRTAB",
	261	"SHT_RELA", "SHT_HASH", "SHT_DYNAMIC", "SHT_NOTE",
	262	"SHT_NOBITS", "SHT_REL", "SHT_SHLIB", "SHT_DYNSYM",
	263	};
	264
	265	/* ELF relocs are against symbols. If we are producing relocateable
	266	output, and the reloc is against an external symbol, and nothing
	267	has given us any additional addend, the resulting reloc will also
	268	be against the same symbol. In such a case, we don't want to
	269	change anything about the way the reloc is handled, since it will
	270	all be done at final link time. Rather than put special case code
	271	into bfd_perform_relocation, all the reloc types use this howto
	272	function. It just short circuits the reloc if producing
	273	relocateable output against an external symbol. */
	274
013dec1a	275	/ARGSUSED/
32090b8e KR	276	bfd_reloc_status_type
	277	bfd_elf_generic_reloc (abfd,
	278	reloc_entry,
	279	symbol,
	280	data,
	281	input_section,
4c3721d5 ILT	282	output_bfd,
4c3721d5 ILT	283	error_message)
32090b8e KR	284	bfd *abfd;
	285	arelent *reloc_entry;
	286	asymbol *symbol;
	287	PTR data;
	288	asection *input_section;
	289	bfd *output_bfd;
4c3721d5	290	char **error_message;
32090b8e KR	291	{
	292	if (output_bfd != (bfd *) NULL
	293	&& (symbol->flags & BSF_SECTION_SYM) == 0
d1b44e83 ILT	294	&& (! reloc_entry->howto->partial_inplace
d1b44e83 ILT	295	\|\| reloc_entry->addend == 0))
32090b8e KR	296	{
	297	reloc_entry->address += input_section->output_offset;
	298	return bfd_reloc_ok;
	299	}
	300
	301	return bfd_reloc_continue;
	302	}
013dec1a	303	\f
013dec1a ILT	304	/* Create an entry in an ELF linker hash table. */
013dec1a ILT	305
5315c428 ILT	306	struct bfd_hash_entry *
5315c428 ILT	307	_bfd_elf_link_hash_newfunc (entry, table, string)
013dec1a ILT	308	struct bfd_hash_entry *entry;
	309	struct bfd_hash_table *table;
	310	const char *string;
	311	{
	312	struct elf_link_hash_entry ret = (struct elf_link_hash_entry ) entry;
	313
	314	/* Allocate the structure if it has not already been allocated by a
	315	subclass. */
	316	if (ret == (struct elf_link_hash_entry *) NULL)
	317	ret = ((struct elf_link_hash_entry *)
	318	bfd_hash_allocate (table, sizeof (struct elf_link_hash_entry)));
	319	if (ret == (struct elf_link_hash_entry *) NULL)
	320	{
	321	bfd_set_error (bfd_error_no_memory);
	322	return (struct bfd_hash_entry *) ret;
	323	}
	324
	325	/* Call the allocation method of the superclass. */
	326	ret = ((struct elf_link_hash_entry *)
	327	_bfd_link_hash_newfunc ((struct bfd_hash_entry *) ret,
	328	table, string));
	329	if (ret != (struct elf_link_hash_entry *) NULL)
	330	{
	331	/* Set local fields. */
	332	ret->indx = -1;
	333	ret->size = 0;
	334	ret->align = 0;
	335	ret->dynindx = -1;
	336	ret->dynstr_index = 0;
	337	ret->weakdef = NULL;
	338	ret->type = STT_NOTYPE;
	339	ret->elf_link_hash_flags = 0;
	340	}
	341
	342	return (struct bfd_hash_entry *) ret;
	343	}
	344
5315c428 ILT	345	/* Initialize an ELF linker hash table. */
	346
	347	boolean
	348	_bfd_elf_link_hash_table_init (table, abfd, newfunc)
	349	struct elf_link_hash_table *table;
	350	bfd *abfd;
	351	struct bfd_hash_entry (newfunc) PARAMS ((struct bfd_hash_entry *,
	352	struct bfd_hash_table *,
	353	const char *));
	354	{
	355	table->dynobj = NULL;
	356	table->dynsymcount = 0;
	357	table->dynstr = NULL;
	358	table->bucketcount = 0;
	359	return _bfd_link_hash_table_init (&table->root, abfd, newfunc);
	360	}
	361
013dec1a ILT	362	/* Create an ELF linker hash table. */
	363
	364	struct bfd_link_hash_table *
	365	_bfd_elf_link_hash_table_create (abfd)
	366	bfd *abfd;
	367	{
	368	struct elf_link_hash_table *ret;
	369
	370	ret = ((struct elf_link_hash_table *)
	371	bfd_alloc (abfd, sizeof (struct elf_link_hash_table)));
	372	if (ret == (struct elf_link_hash_table *) NULL)
	373	{
	374	bfd_set_error (bfd_error_no_memory);
	375	return NULL;
	376	}
5315c428 ILT	377
5315c428 ILT	378	if (! _bfd_elf_link_hash_table_init (ret, abfd, _bfd_elf_link_hash_newfunc))
013dec1a ILT	379	{
	380	bfd_release (abfd, ret);
	381	return NULL;
	382	}
	383
013dec1a ILT	384	return &ret->root;
013dec1a ILT	385	}