Attachment #94929 for bug #144851

View | Details | Raw Unified | Return to bug 144851
Collapse All | Expand All

Lines 1022-1027 struct elf_backend_data Link Here

(-)gdb-6.5.orig/bfd/elf-bfd.h (+7 lines)
1022	bfd_boolean , bfd_boolean ,	1022	bfd_boolean , bfd_boolean ,
1023	bfd , asection *);	1023	bfd , asection *);
1024		1024
		1025	/* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
		1026	bfd_boolean (elf_hash_symbol) (struct elf_link_hash_entry );
		1027
1025	/* Used to handle bad SHF_LINK_ORDER input. */	1028	/* Used to handle bad SHF_LINK_ORDER input. */
1026	bfd_error_handler_type link_order_error_handler;	1029	bfd_error_handler_type link_order_error_handler;
1027		1030
Lines 1462-1467 extern bfd_vma _bfd_elf_section_offset Link Here
1462		1465
1463	extern unsigned long bfd_elf_hash	1466	extern unsigned long bfd_elf_hash
1464	(const char *);	1467	(const char *);
		1468	extern unsigned long bfd_elf_gnu_hash
		1469	(const char *);
1465		1470
1466	extern bfd_reloc_status_type bfd_elf_generic_reloc	1471	extern bfd_reloc_status_type bfd_elf_generic_reloc
1467	(bfd , arelent , asymbol , void , asection , bfd , char **);	1472	(bfd , arelent , asymbol , void , asection , bfd , char **);
Lines 1632-1637 extern bfd_boolean _bfd_elf_merge_symbol Link Here
1632	struct elf_link_hash_entry *, bfd_boolean ,	1637	struct elf_link_hash_entry *, bfd_boolean ,
1633	bfd_boolean , bfd_boolean , bfd_boolean *);	1638	bfd_boolean , bfd_boolean , bfd_boolean *);
1634		1639
		1640	extern bfd_boolean _bfd_elf_hash_symbol (struct elf_link_hash_entry *);
		1641
1635	extern bfd_boolean _bfd_elf_add_default_symbol	1642	extern bfd_boolean _bfd_elf_add_default_symbol
1636	(bfd , struct bfd_link_info , struct elf_link_hash_entry *,	1643	(bfd , struct bfd_link_info , struct elf_link_hash_entry *,
1637	const char , Elf_Internal_Sym , asection *, bfd_vma ,	1644	const char , Elf_Internal_Sym , asection *, bfd_vma ,

Lines 3614-3619 elf64_x86_64_additional_program_headers Link Here

(-)gdb-6.5.orig/bfd/elf64-x86-64.c (+15 lines)
3614	return count;	3614	return count;
3615	}	3615	}
3616		3616
		3617	/* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
		3618
		3619	static bfd_boolean
		3620	elf64_x86_64_hash_symbol (struct elf_link_hash_entry *h)
		3621	{
		3622	if (h->plt.offset != (bfd_vma) -1
		3623	&& !h->def_regular
		3624	&& !h->pointer_equality_needed)
		3625	return FALSE;
		3626
		3627	return _bfd_elf_hash_symbol (h);
		3628	}
		3629
3617	static const struct bfd_elf_special_section	3630	static const struct bfd_elf_special_section
3618	elf64_x86_64_special_sections[]=	3631	elf64_x86_64_special_sections[]=
3619	{	3632	{
Lines 3685-3689 static const struct bfd_elf_special_sect Link Here
3685	elf64_x86_64_special_sections	3698	elf64_x86_64_special_sections
3686	#define elf_backend_additional_program_headers \	3699	#define elf_backend_additional_program_headers \
3687	elf64_x86_64_additional_program_headers	3700	elf64_x86_64_additional_program_headers
		3701	#define elf_backend_hash_symbol \
		3702	elf64_x86_64_hash_symbol
3688		3703
3689	#include "elf64-target.h"	3704	#include "elf64-target.h"




  return h & 0xffffffff;
}

/* DT_GNU_HASH hash function.  Do not change this function; you will
   cause invalid hash tables to be generated.  */

unsigned long
bfd_elf_gnu_hash (const char *namearg)
{
  const unsigned char *name = (const unsigned char *) namearg;
  unsigned long h = 5381;
  unsigned char ch;

  while ((ch = *name++) != '\0')
    h = (h << 5) + h + ch;
  return h & 0xffffffff;
}

bfd_boolean
bfd_elf_mkobject (bfd *abfd)
{

	    case DT_AUXILIARY: name = "AUXILIARY"; stringp = TRUE; break;
	    case DT_USED: name = "USED"; break;
	    case DT_FILTER: name = "FILTER"; stringp = TRUE; break;
	    case DT_GNU_HASH: name = "GNU_HASH"; break;
	    }

	  fprintf (f, "  %-11s ", name);

    case SHT_FINI_ARRAY:	/* .fini_array section.  */
    case SHT_PREINIT_ARRAY:	/* .preinit_array section.  */
    case SHT_GNU_LIBLIST:	/* .gnu.liblist section.  */
    case SHT_GNU_HASH:		/* .gnu.hash section.  */
      return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);

    case SHT_DYNAMIC:	/* Dynamic linking information.  */

  { ".gnu.version_r", 14,  0, SHT_GNU_verneed, 0 },
  { ".gnu.liblist",   12,  0, SHT_GNU_LIBLIST, SHF_ALLOC },
  { ".gnu.conflict",  13,  0, SHT_RELA,     SHF_ALLOC },
  { ".gnu.hash",       9,  0, SHT_GNU_HASH, SHF_ALLOC },
  { NULL,              0,  0, 0,            0 }
};


    case SHT_GROUP:
      this_hdr->sh_entsize = 4;
      break;

    case SHT_GNU_HASH:
      this_hdr->sh_entsize = bed->s->arch_size == 64 ? 0 : 4;
      break;
    }

  if ((asect->flags & SEC_ALLOC) != 0)

	  break;

	case SHT_HASH:
	case SHT_GNU_HASH:
	case SHT_GNU_versym:
	  /* sh_link is the section header index of the symbol table
	     this hash table or version table is for.  */




  return plt->vma + (i + 1) * PLT_ENTRY_SIZE;
}

/* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */

static bfd_boolean
elf_i386_hash_symbol (struct elf_link_hash_entry *h)
{
  if (h->plt.offset != (bfd_vma) -1
      && !h->def_regular
      && !h->pointer_equality_needed)
    return FALSE;

  return _bfd_elf_hash_symbol (h);
}

#define TARGET_LITTLE_SYM		bfd_elf32_i386_vec
#define TARGET_LITTLE_NAME		"elf32-i386"

#define elf_backend_size_dynamic_sections     elf_i386_size_dynamic_sections
#define elf_backend_always_size_sections      elf_i386_always_size_sections
#define elf_backend_plt_sym_val		      elf_i386_plt_sym_val
#define elf_backend_hash_symbol		      elf_i386_hash_symbol

#include "elf32-target.h"





  if (!_bfd_elf_define_linkage_sym (abfd, info, s, "_DYNAMIC"))
    return FALSE;

  if (info->emit_hash)
    {
      s = bfd_make_section_with_flags (abfd, ".hash", flags | SEC_READONLY);
      if (s == NULL
	  || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
	return FALSE;
      elf_section_data (s)->this_hdr.sh_entsize = bed->s->sizeof_hash_entry;
    }

  if (info->emit_gnu_hash)
    {
      s = bfd_make_section_with_flags (abfd, ".gnu.hash",
				       flags | SEC_READONLY);
      if (s == NULL
	  || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
	return FALSE;
      /* For 64-bit ELF, .gnu.hash is a non-uniform entity size section:
	 4 32-bit words followed by variable count of 64-bit words, then
	 variable count of 32-bit words.  */
      if (bed->s->arch_size == 64)
	elf_section_data (s)->this_hdr.sh_entsize = 0;
      else
	elf_section_data (s)->this_hdr.sh_entsize = 4;
    }

  /* Let the backend create the rest of the sections.  This lets the
     backend set the right flags.  The backend will normally create

  return TRUE;
}

struct collect_gnu_hash_codes
{
  bfd *output_bfd;
  const struct elf_backend_data *bed;
  unsigned long int nsyms;
  unsigned long int maskbits;
  unsigned long int *hashcodes;
  unsigned long int *hashval;
  unsigned long int *indx;
  unsigned long int *counts;
  bfd_vma *bitmask;
  bfd_byte *contents;
  long int min_dynindx;
  unsigned long int bucketcount;
  unsigned long int symindx;
  long int local_indx;
  long int shift1, shift2;
  unsigned long int mask;
};

/* This function will be called though elf_link_hash_traverse to store
   all hash value of the exported symbols in an array.  */

static bfd_boolean
elf_collect_gnu_hash_codes (struct elf_link_hash_entry *h, void *data)
{
  struct collect_gnu_hash_codes *s = data;
  const char *name;
  char *p;
  unsigned long ha;
  char *alc = NULL;

  if (h->root.type == bfd_link_hash_warning)
    h = (struct elf_link_hash_entry *) h->root.u.i.link;

  /* Ignore indirect symbols.  These are added by the versioning code.  */
  if (h->dynindx == -1)
    return TRUE;

  /* Ignore also local symbols and undefined symbols.  */
  if (! (*s->bed->elf_hash_symbol) (h))
    return TRUE;

  name = h->root.root.string;
  p = strchr (name, ELF_VER_CHR);
  if (p != NULL)
    {
      alc = bfd_malloc (p - name + 1);
      memcpy (alc, name, p - name);
      alc[p - name] = '\0';
      name = alc;
    }

  /* Compute the hash value.  */
  ha = bfd_elf_gnu_hash (name);

  /* Store the found hash value in the array for compute_bucket_count,
     and also for .dynsym reordering purposes.  */
  s->hashcodes[s->nsyms] = ha;
  s->hashval[h->dynindx] = ha;
  ++s->nsyms;
  if (s->min_dynindx < 0 || s->min_dynindx > h->dynindx)
    s->min_dynindx = h->dynindx;

  if (alc != NULL)
    free (alc);

  return TRUE;
}

/* This function will be called though elf_link_hash_traverse to do
   final dynaminc symbol renumbering.  */

static bfd_boolean
elf_renumber_gnu_hash_syms (struct elf_link_hash_entry *h, void *data)
{
  struct collect_gnu_hash_codes *s = data;
  unsigned long int bucket;
  unsigned long int val;

  if (h->root.type == bfd_link_hash_warning)
    h = (struct elf_link_hash_entry *) h->root.u.i.link;

  /* Ignore indirect symbols.  */
  if (h->dynindx == -1)
    return TRUE;

  /* Ignore also local symbols and undefined symbols.  */
  if (! (*s->bed->elf_hash_symbol) (h))
    {
      if (h->dynindx >= s->min_dynindx)
	h->dynindx = s->local_indx++;
      return TRUE;
    }

  bucket = s->hashval[h->dynindx] % s->bucketcount;
  val = (s->hashval[h->dynindx] >> s->shift1)
	& ((s->maskbits >> s->shift1) - 1);
  s->bitmask[val] |= ((bfd_vma) 1) << (s->hashval[h->dynindx] & s->mask);
  s->bitmask[val]
    |= ((bfd_vma) 1) << ((s->hashval[h->dynindx] >> s->shift2) & s->mask);
  val = s->hashval[h->dynindx] & ~(unsigned long int) 1;
  if (s->counts[bucket] == 1)
    /* Last element terminates the chain.  */
    val |= 1;
  bfd_put_32 (s->output_bfd, val,
	      s->contents + (s->indx[bucket] - s->symindx) * 4);
  --s->counts[bucket];
  h->dynindx = s->indx[bucket]++;
  return TRUE;
}

/* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */

bfd_boolean
_bfd_elf_hash_symbol (struct elf_link_hash_entry *h)
{
  return !(h->forced_local
	   || h->root.type == bfd_link_hash_undefined
	   || h->root.type == bfd_link_hash_undefweak
	   || ((h->root.type == bfd_link_hash_defined
		|| h->root.type == bfd_link_hash_defweak)
	       && h->root.u.def.section->output_section == NULL));
}

/* Array used to determine the number of hash table buckets to use
   based on the number of symbols there are.  If there are fewer than
   3 symbols we use 1 bucket, fewer than 17 symbols we use 3 buckets,

   Therefore the result is always a good payoff between few collisions
   (= short chain lengths) and table size.  */
static size_t
compute_bucket_count (struct bfd_link_info *info, unsigned long int *hashcodes,
		      unsigned long int nsyms, int gnu_hash)
{
  size_t dynsymcount = elf_hash_table (info)->dynsymcount;
  size_t best_size = 0;
  unsigned long int *hashcodes;
  unsigned long int *hashcodesp;
  unsigned long int i;
  bfd_size_type amt;

  /* Compute the hash values for all exported symbols.  At the same
     time store the values in an array so that we could use them for
     optimizations.  */
  amt = dynsymcount;
  amt *= sizeof (unsigned long int);
  hashcodes = bfd_malloc (amt);
  if (hashcodes == NULL)
    return 0;
  hashcodesp = hashcodes;

  /* Put all hash values in HASHCODES.  */
  elf_link_hash_traverse (elf_hash_table (info),
			  elf_collect_hash_codes, &hashcodesp);

  /* We have a problem here.  The following code to optimize the table
     size requires an integer type with more the 32 bits.  If
     BFD_HOST_U_64_BIT is set we know about such a type.  */
#ifdef BFD_HOST_U_64_BIT
  if (info->optimize)
    {
      unsigned long int nsyms = hashcodesp - hashcodes;
      size_t minsize;
      size_t maxsize;
      BFD_HOST_U_64_BIT best_chlen = ~((BFD_HOST_U_64_BIT) 0);
      unsigned long int *counts ;
      bfd *dynobj = elf_hash_table (info)->dynobj;
      const struct elf_backend_data *bed = get_elf_backend_data (dynobj);
      unsigned long int *counts;

      /* Possible optimization parameters: if we have NSYMS symbols we say
	 that the hashing table must at least have NSYMS/4 and at most

      if (minsize == 0)
	minsize = 1;
      best_size = maxsize = nsyms * 2;
      if (gnu_hash)
	{
	  if (minsize < 2)
	    minsize = 2;
	  if ((best_size & 31) == 0)
	    ++best_size;
	}

      /* Create array where we count the collisions in.  We must use bfd_malloc
	 since the size could be large.  */

      amt *= sizeof (unsigned long int);
      counts = bfd_malloc (amt);
      if (counts == NULL)
	return 0;
	  free (hashcodes);
	  return 0;
	}

      /* Compute the "optimal" size for the hash table.  The criteria is a
	 minimal chain length.  The minor criteria is (of course) the size

	  unsigned long int j;
	  unsigned long int fact;

	  if (gnu_hash && (i & 31) == 0)
	    continue;

	  memset (counts, '\0', i * sizeof (unsigned long int));

	  /* Determine how often each hash bucket is used.  */

#  define BFD_TARGET_PAGESIZE	(4096)
# endif

	  /* We in any case need 2 + DYNSYMCOUNT entries for the size values
	     and the chains.  */
	  max = (2 + dynsymcount) * bed->s->sizeof_hash_entry;

# if 1
	  /* Variant 1: optimize for short chains.  We add the squares

	    max += counts[j] * counts[j];

	  /* This adds penalties for the overall size of the table.  */
	  fact = i / (BFD_TARGET_PAGESIZE / bed->s->sizeof_hash_entry) + 1;
	  max *= fact * fact;
# else
	  /* Variant 2: Optimize a lot more for small table.  Here we


	  /* The overall size of the table is considered, but not as
	     strong as in variant 1, where it is squared.  */
	  fact = i / (BFD_TARGET_PAGESIZE / bed->s->sizeof_hash_entry) + 1;
	  max *= fact;
# endif


      for (i = 0; elf_buckets[i] != 0; i++)
	{
	  best_size = elf_buckets[i];
	  if (nsyms < elf_buckets[i + 1])
	    break;
	}
      if (gnu_hash && best_size < 2)
	best_size = 2;
    }

  /* Free the arrays we needed.  */
  free (hashcodes);

  return best_size;
}


	  bfd_size_type strsize;

	  strsize = _bfd_elf_strtab_size (elf_hash_table (info)->dynstr);
	  if ((info->emit_hash
	       && !_bfd_elf_add_dynamic_entry (info, DT_HASH, 0))
	      || (info->emit_gnu_hash
		  && !_bfd_elf_add_dynamic_entry (info, DT_GNU_HASH, 0))
	      || !_bfd_elf_add_dynamic_entry (info, DT_STRTAB, 0)
	      || !_bfd_elf_add_dynamic_entry (info, DT_SYMTAB, 0)
	      || !_bfd_elf_add_dynamic_entry (info, DT_STRSZ, strsize)

      asection *s;
      bfd_size_type dynsymcount;
      unsigned long section_sym_count;
      size_t bucketcount = 0;
      size_t hash_entry_size;
      unsigned int dtagcount;

      dynobj = elf_hash_table (info)->dynobj;

	  memset (s->contents, 0, section_sym_count * bed->s->sizeof_sym);
	}

      elf_hash_table (info)->bucketcount = 0;

      /* Compute the size of the hashing table.  As a side effect this
	 computes the hash values for all the names we export.  */
      if (info->emit_hash)
	{
	  unsigned long int *hashcodes;
	  unsigned long int *hashcodesp;
	  bfd_size_type amt;
	  unsigned long int nsyms;
	  size_t bucketcount;
	  size_t hash_entry_size;

	  /* Compute the hash values for all exported symbols.  At the same
	     time store the values in an array so that we could use them for
	     optimizations.  */
	  amt = dynsymcount * sizeof (unsigned long int);
	  hashcodes = bfd_malloc (amt);
	  if (hashcodes == NULL)
	    return FALSE;
	  hashcodesp = hashcodes;

	  /* Put all hash values in HASHCODES.  */
	  elf_link_hash_traverse (elf_hash_table (info),
				  elf_collect_hash_codes, &hashcodesp);
      s->size = ((2 + bucketcount + dynsymcount) * hash_entry_size);
      s->contents = bfd_zalloc (output_bfd, s->size);
      if (s->contents == NULL)
	return FALSE;

	  nsyms = hashcodesp - hashcodes;
	  bucketcount
	    = compute_bucket_count (info, hashcodes, nsyms, 0);
	  free (hashcodes);

	  if (bucketcount == 0)
	    return FALSE;

	  elf_hash_table (info)->bucketcount = bucketcount;

	  s = bfd_get_section_by_name (dynobj, ".hash");
	  BFD_ASSERT (s != NULL);
	  hash_entry_size = elf_section_data (s)->this_hdr.sh_entsize;
	  s->size = ((2 + bucketcount + dynsymcount) * hash_entry_size);
	  s->contents = bfd_zalloc (output_bfd, s->size);
	  if (s->contents == NULL)
	    return FALSE;

	  bfd_put (8 * hash_entry_size, output_bfd, bucketcount, s->contents);
	  bfd_put (8 * hash_entry_size, output_bfd, dynsymcount,
		   s->contents + hash_entry_size);
	}

      if (info->emit_gnu_hash)
	{
	  size_t i, cnt;
	  unsigned char *contents;
	  struct collect_gnu_hash_codes cinfo;
	  bfd_size_type amt;
	  size_t bucketcount;

	  memset (&cinfo, 0, sizeof (cinfo));

	  /* Compute the hash values for all exported symbols.  At the same
	     time store the values in an array so that we could use them for
	     optimizations.  */
	  amt = dynsymcount * 2 * sizeof (unsigned long int);
	  cinfo.hashcodes = bfd_malloc (amt);
	  if (cinfo.hashcodes == NULL)
	    return FALSE;

	  cinfo.hashval = cinfo.hashcodes + dynsymcount;
	  cinfo.min_dynindx = -1;
	  cinfo.output_bfd = output_bfd;
	  cinfo.bed = bed;

	  /* Put all hash values in HASHCODES.  */
	  elf_link_hash_traverse (elf_hash_table (info),
				  elf_collect_gnu_hash_codes, &cinfo);

	  bucketcount
	    = compute_bucket_count (info, cinfo.hashcodes, cinfo.nsyms, 1);

	  if (bucketcount == 0)
	    {
	      free (cinfo.hashcodes);
	      return FALSE;
	    }

	  s = bfd_get_section_by_name (dynobj, ".gnu.hash");
	  BFD_ASSERT (s != NULL);

	  if (cinfo.nsyms == 0)
	    {
	      /* Empty .gnu.hash section is special.  */
	      BFD_ASSERT (cinfo.min_dynindx == -1);
	      free (cinfo.hashcodes);
	      s->size = 5 * 4 + bed->s->arch_size / 8;
	      contents = bfd_zalloc (output_bfd, s->size);
	      if (contents == NULL)
		return FALSE;
	      s->contents = contents;
	      /* 1 empty bucket.  */
	      bfd_put_32 (output_bfd, 1, contents);
	      /* SYMIDX above the special symbol 0.  */
	      bfd_put_32 (output_bfd, 1, contents + 4);
	      /* Just one word for bitmask.  */
	      bfd_put_32 (output_bfd, 1, contents + 8);
	      /* Only hash fn bloom filter.  */
	      bfd_put_32 (output_bfd, 0, contents + 12);
	      /* No hashes are valid - empty bitmask.  */
	      bfd_put (bed->s->arch_size, output_bfd, 0, contents + 16);
	      /* No hashes in the only bucket.  */
	      bfd_put_32 (output_bfd, 0,
			  contents + 16 + bed->s->arch_size / 8);
	    }
	  else
	    {
	      BFD_ASSERT (cinfo.min_dynindx != -1);
	      unsigned long int maskwords, maskbitslog2;

	      maskbitslog2 = bfd_log2 (cinfo.nsyms) + 1;
	      if (maskbitslog2 < 3)
		maskbitslog2 = 5;
	      else if ((1 << (maskbitslog2 - 2)) & cinfo.nsyms)
		maskbitslog2 = maskbitslog2 + 3;
	      else
		maskbitslog2 = maskbitslog2 + 2;
	      if (bed->s->arch_size == 64)
		{
		  if (maskbitslog2 == 5)
		    maskbitslog2 = 6;
		  cinfo.shift1 = 6;
		}
	      else
		cinfo.shift1 = 5;
	      cinfo.mask = (1 << cinfo.shift1) - 1;
	      cinfo.shift2 = maskbitslog2 + cinfo.shift1;
	      cinfo.maskbits = 1 << maskbitslog2;
	      maskwords = 1 << (maskbitslog2 - cinfo.shift1);
	      amt = bucketcount * sizeof (unsigned long int) * 2;
	      amt += maskwords * sizeof (bfd_vma);
	      cinfo.bitmask = bfd_malloc (amt);
	      if (cinfo.bitmask == NULL)
		{
		  free (cinfo.hashcodes);
		  return FALSE;
		}

	      cinfo.counts = (void *) (cinfo.bitmask + maskwords);
	      cinfo.indx = cinfo.counts + bucketcount;
	      cinfo.symindx = dynsymcount - cinfo.nsyms;
	      memset (cinfo.bitmask, 0, maskwords * sizeof (bfd_vma));

	      /* Determine how often each hash bucket is used.  */
	      memset (cinfo.counts, 0, bucketcount * sizeof (cinfo.counts[0]));
	      for (i = 0; i < cinfo.nsyms; ++i)
		++cinfo.counts[cinfo.hashcodes[i] % bucketcount];

	      for (i = 0, cnt = cinfo.symindx; i < bucketcount; ++i)
		if (cinfo.counts[i] != 0)
		  {
		    cinfo.indx[i] = cnt;
		    cnt += cinfo.counts[i];
		  }
	      BFD_ASSERT (cnt == dynsymcount);
	      cinfo.bucketcount = bucketcount;
	      cinfo.local_indx = cinfo.min_dynindx;

	      s->size = (4 + bucketcount + cinfo.nsyms) * 4;
	      s->size += cinfo.maskbits / 8;
	      contents = bfd_zalloc (output_bfd, s->size);
	      if (contents == NULL)
		{
		  free (cinfo.bitmask);
		  free (cinfo.hashcodes);
		  return FALSE;
		}

	      s->contents = contents;
	      bfd_put_32 (output_bfd, bucketcount, contents);
	      bfd_put_32 (output_bfd, cinfo.symindx, contents + 4);
	      bfd_put_32 (output_bfd, maskwords, contents + 8);
	      bfd_put_32 (output_bfd, cinfo.shift2, contents + 12);
	      contents += 16 + cinfo.maskbits / 8;

	      for (i = 0; i < bucketcount; ++i)
		{
		  if (cinfo.counts[i] == 0)
		    bfd_put_32 (output_bfd, 0, contents);
		  else
		    bfd_put_32 (output_bfd, cinfo.indx[i], contents);
		  contents += 4;
		}

	      cinfo.contents = contents;

	      /* Renumber dynamic symbols, populate .gnu.hash section.  */
	      elf_link_hash_traverse (elf_hash_table (info),
				      elf_renumber_gnu_hash_syms, &cinfo);

	      contents = s->contents + 16;
	      for (i = 0; i < maskwords; ++i)
		{
		  bfd_put (bed->s->arch_size, output_bfd, cinfo.bitmask[i],
			   contents);
		  contents += bed->s->arch_size / 8;
		}

	      free (cinfo.bitmask);
	      free (cinfo.hashcodes);
	    }
	}

      s = bfd_get_section_by_name (dynobj, ".dynstr");
      BFD_ASSERT (s != NULL);

    {
      size_t bucketcount;
      size_t bucket;
      size_t hash_entry_size;
      bfd_byte *bucketpos;
      bfd_vma chain;
      bfd_byte *esym;

      sym.st_name = h->dynstr_index;


      bucketcount = elf_hash_table (finfo->info)->bucketcount;
      bucket = h->u.elf_hash_value % bucketcount;

      if (finfo->hash_sec != NULL)
	{
	  size_t hash_entry_size;
	  bfd_byte *bucketpos;
	  bfd_vma chain;

	  hash_entry_size
	    = elf_section_data (finfo->hash_sec)->this_hdr.sh_entsize;
	  bucketpos = ((bfd_byte *) finfo->hash_sec->contents
		       + (bucket + 2) * hash_entry_size);
	  chain = bfd_get (8 * hash_entry_size, finfo->output_bfd, bucketpos);
	  bfd_put (8 * hash_entry_size, finfo->output_bfd, h->dynindx, bucketpos);
	  bfd_put (8 * hash_entry_size, finfo->output_bfd, chain,
		   ((bfd_byte *) finfo->hash_sec->contents
		    + (bucketcount + 2 + h->dynindx) * hash_entry_size));
	}

      if (finfo->symver_sec != NULL && finfo->symver_sec->contents != NULL)
	{

    {
      finfo.dynsym_sec = bfd_get_section_by_name (dynobj, ".dynsym");
      finfo.hash_sec = bfd_get_section_by_name (dynobj, ".hash");
      BFD_ASSERT (finfo.dynsym_sec != NULL);
      finfo.symver_sec = bfd_get_section_by_name (dynobj, ".gnu.version");
      /* Note that it is OK if symver_sec is NULL.  */
    }

	    case DT_HASH:
	      name = ".hash";
	      goto get_vma;
	    case DT_GNU_HASH:
	      name = ".gnu.hash";
	      goto get_vma;
	    case DT_STRTAB:
	      name = ".dynstr";
	      goto get_vma;

Lines 553-558 Link Here

(-)gdb-6.5.orig/bfd/elfxx-target.h (+5 lines)
553	#define elf_backend_merge_symbol NULL	553	#define elf_backend_merge_symbol NULL
554	#endif	554	#endif
555		555
		556	#ifndef elf_backend_hash_symbol
		557	#define elf_backend_hash_symbol _bfd_elf_hash_symbol
		558	#endif
		559
556	extern const struct elf_size_info _bfd_elfNN_size_info;	560	extern const struct elf_size_info _bfd_elfNN_size_info;
557		561
558	#ifndef INCLUDED_TARGET_FILE	562	#ifndef INCLUDED_TARGET_FILE
Lines 630-635 static const struct elf_backend_data elf Link Here
630	elf_backend_common_section_index,	634	elf_backend_common_section_index,
631	elf_backend_common_section,	635	elf_backend_common_section,
632	elf_backend_merge_symbol,	636	elf_backend_merge_symbol,
		637	elf_backend_hash_symbol,
633	elf_backend_link_order_error_handler,	638	elf_backend_link_order_error_handler,
634	elf_backend_relplt_name,	639	elf_backend_relplt_name,
635	ELF_MACHINE_ALT1,	640	ELF_MACHINE_ALT1,

Lines 338-343 Link Here

(-)gdb-6.5.orig/include/elf/common.h (+2 lines)
338	#define SHT_LOOS 0x60000000 /* First of OS specific semantics */	338	#define SHT_LOOS 0x60000000 /* First of OS specific semantics */
339	#define SHT_HIOS 0x6fffffff /* Last of OS specific semantics */	339	#define SHT_HIOS 0x6fffffff /* Last of OS specific semantics */
340		340
		341	#define SHT_GNU_HASH 0x6ffffff6 /* GNU style symbol hash table */
341	#define SHT_GNU_LIBLIST 0x6ffffff7 /* List of prelink dependencies */	342	#define SHT_GNU_LIBLIST 0x6ffffff7 /* List of prelink dependencies */
342		343
343	/* The next three section types are defined by Solaris, and are named	344	/* The next three section types are defined by Solaris, and are named
Lines 577-582 Link Here
577	#define DT_VALRNGHI 0x6ffffdff	578	#define DT_VALRNGHI 0x6ffffdff
578		579
579	#define DT_ADDRRNGLO 0x6ffffe00	580	#define DT_ADDRRNGLO 0x6ffffe00
		581	#define DT_GNU_HASH 0x6ffffef5
580	#define DT_TLSDESC_PLT 0x6ffffef6	582	#define DT_TLSDESC_PLT 0x6ffffef6
581	#define DT_TLSDESC_GOT 0x6ffffef7	583	#define DT_TLSDESC_GOT 0x6ffffef7
582	#define DT_GNU_CONFLICT 0x6ffffef8	584	#define DT_GNU_CONFLICT 0x6ffffef8

Lines 324-329 struct bfd_link_info Link Here

(-)gdb-6.5.orig/include/bfdlink.h (+6 lines)
324	/* TRUE if unreferenced sections should be removed. */	324	/* TRUE if unreferenced sections should be removed. */
325	unsigned int gc_sections: 1;	325	unsigned int gc_sections: 1;
326		326
		327	/* TRUE if .hash section should be created. */
		328	unsigned int emit_hash: 1;
		329
		330	/* TRUE if .gnu.hash section should be created. */
		331	unsigned int emit_gnu_hash: 1;
		332
327	/* What to do with unresolved symbols in an object file.	333	/* What to do with unresolved symbols in an object file.
328	When producing executables the default is GENERATE_ERROR.	334	When producing executables the default is GENERATE_ERROR.
329	When producing shared libraries the default is IGNORE. The	335	When producing shared libraries the default is IGNORE. The

Return to bug 144851

Lines 206-211 bfd_elf_hash (const char *namearg) Link Here

(-)gdb-6.5.orig/bfd/elf.c (+23 lines)
206	return h & 0xffffffff;	206	return h & 0xffffffff;
207	}	207	}
208		208
		209	/* DT_GNU_HASH hash function. Do not change this function; you will
		210	cause invalid hash tables to be generated. */
		211
		212	unsigned long
		213	bfd_elf_gnu_hash (const char *namearg)
		214	{
		215	const unsigned char name = (const unsigned char ) namearg;
		216	unsigned long h = 5381;
		217	unsigned char ch;
		218
		219	while ((ch = *name++) != '\0')
		220	h = (h << 5) + h + ch;
		221	return h & 0xffffffff;
		222	}
		223
209	bfd_boolean	224	bfd_boolean
210	bfd_elf_mkobject (bfd *abfd)	225	bfd_elf_mkobject (bfd *abfd)
211	{	226	{
Lines 1239-1244 _bfd_elf_print_private_bfd_data (bfd *ab Link Here
1239	case DT_AUXILIARY: name = "AUXILIARY"; stringp = TRUE; break;	1254	case DT_AUXILIARY: name = "AUXILIARY"; stringp = TRUE; break;
1240	case DT_USED: name = "USED"; break;	1255	case DT_USED: name = "USED"; break;
1241	case DT_FILTER: name = "FILTER"; stringp = TRUE; break;	1256	case DT_FILTER: name = "FILTER"; stringp = TRUE; break;
		1257	case DT_GNU_HASH: name = "GNU_HASH"; break;
1242	}	1258	}
1243		1259
1244	fprintf (f, " %-11s ", name);	1260	fprintf (f, " %-11s ", name);
Lines 1822-1827 bfd_section_from_shdr (bfd *abfd, unsign Link Here
1822	case SHT_FINI_ARRAY: /* .fini_array section. */	1838	case SHT_FINI_ARRAY: /* .fini_array section. */
1823	case SHT_PREINIT_ARRAY: /* .preinit_array section. */	1839	case SHT_PREINIT_ARRAY: /* .preinit_array section. */
1824	case SHT_GNU_LIBLIST: /* .gnu.liblist section. */	1840	case SHT_GNU_LIBLIST: /* .gnu.liblist section. */
		1841	case SHT_GNU_HASH: /* .gnu.hash section. */
1825	return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);	1842	return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
1826		1843
1827	case SHT_DYNAMIC: /* Dynamic linking information. */	1844	case SHT_DYNAMIC: /* Dynamic linking information. */
Lines 2294-2299 static const struct bfd_elf_special_sect Link Here
2294	{ ".gnu.version_r", 14, 0, SHT_GNU_verneed, 0 },	2311	{ ".gnu.version_r", 14, 0, SHT_GNU_verneed, 0 },
2295	{ ".gnu.liblist", 12, 0, SHT_GNU_LIBLIST, SHF_ALLOC },	2312	{ ".gnu.liblist", 12, 0, SHT_GNU_LIBLIST, SHF_ALLOC },
2296	{ ".gnu.conflict", 13, 0, SHT_RELA, SHF_ALLOC },	2313	{ ".gnu.conflict", 13, 0, SHT_RELA, SHF_ALLOC },
		2314	{ ".gnu.hash", 9, 0, SHT_GNU_HASH, SHF_ALLOC },
2297	{ NULL, 0, 0, 0, 0 }	2315	{ NULL, 0, 0, 0, 0 }
2298	};	2316	};
2299		2317
Lines 2810-2815 elf_fake_sections (bfd abfd, asection Link Here
2810	case SHT_GROUP:	2828	case SHT_GROUP:
2811	this_hdr->sh_entsize = 4;	2829	this_hdr->sh_entsize = 4;
2812	break;	2830	break;
		2831
		2832	case SHT_GNU_HASH:
		2833	this_hdr->sh_entsize = bed->s->arch_size == 64 ? 0 : 4;
		2834	break;
2813	}	2835	}
2814		2836
2815	if ((asect->flags & SEC_ALLOC) != 0)	2837	if ((asect->flags & SEC_ALLOC) != 0)
Lines 3255-3260 assign_section_numbers (bfd *abfd, struc Link Here
3255	break;	3277	break;
3256		3278
3257	case SHT_HASH:	3279	case SHT_HASH:
		3280	case SHT_GNU_HASH:
3258	case SHT_GNU_versym:	3281	case SHT_GNU_versym:
3259	/* sh_link is the section header index of the symbol table	3282	/* sh_link is the section header index of the symbol table
3260	this hash table or version table is for. */	3283	this hash table or version table is for. */

Lines 3872-3877 elf_i386_plt_sym_val (bfd_vma i, const a Link Here

(-)gdb-6.5.orig/bfd/elf32-i386.c (+13 lines)
3872	return plt->vma + (i + 1) * PLT_ENTRY_SIZE;	3872	return plt->vma + (i + 1) * PLT_ENTRY_SIZE;
3873	}	3873	}
3874		3874
		3875	/* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
		3876
		3877	static bfd_boolean
		3878	elf_i386_hash_symbol (struct elf_link_hash_entry *h)
		3879	{
		3880	if (h->plt.offset != (bfd_vma) -1
		3881	&& !h->def_regular
		3882	&& !h->pointer_equality_needed)
		3883	return FALSE;
		3884
		3885	return _bfd_elf_hash_symbol (h);
		3886	}
3875		3887
3876	#define TARGET_LITTLE_SYM bfd_elf32_i386_vec	3888	#define TARGET_LITTLE_SYM bfd_elf32_i386_vec
3877	#define TARGET_LITTLE_NAME "elf32-i386"	3889	#define TARGET_LITTLE_NAME "elf32-i386"
Lines 3912-3917 elf_i386_plt_sym_val (bfd_vma i, const a Link Here
3912	#define elf_backend_size_dynamic_sections elf_i386_size_dynamic_sections	3924	#define elf_backend_size_dynamic_sections elf_i386_size_dynamic_sections
3913	#define elf_backend_always_size_sections elf_i386_always_size_sections	3925	#define elf_backend_always_size_sections elf_i386_always_size_sections
3914	#define elf_backend_plt_sym_val elf_i386_plt_sym_val	3926	#define elf_backend_plt_sym_val elf_i386_plt_sym_val
		3927	#define elf_backend_hash_symbol elf_i386_hash_symbol
3915		3928
3916	#include "elf32-target.h"	3929	#include "elf32-target.h"
3917		3930