Attachment #89027: A dynsort patch that applies against binutils-2.17.50.0.2 for bug #114008

# need two copies of the executable, one to download and one for the

# need two copies of the executable, one to download and one for the

# debugger).

# debugger).

BFD32_LIBS = \

BFD32_LIBS = \

	cache.lo coffgen.lo corefile.lo \

	cache.lo coffgen.lo corefile.lo \

	format.lo init.lo libbfd.lo opncls.lo reloc.lo \

	format.lo init.lo libbfd.lo opncls.lo reloc.lo \

	section.lo syms.lo targets.lo hash.lo linker.lo \

	section.lo syms.lo targets.lo hash.lo linker.lo \

BFD64_LIBS = archive64.lo

BFD64_LIBS = archive64.lo

BFD32_LIBS_CFILES = \

BFD32_LIBS_CFILES = \

	cache.c coffgen.c corefile.c \

	cache.c coffgen.c corefile.c \

	format.c init.c libbfd.c opncls.c reloc.c \

	format.c init.c libbfd.c opncls.c reloc.c \

	section.c syms.c targets.c hash.c linker.c \

	section.c syms.c targets.c hash.c linker.c \

	cache.lo coffgen.lo corefile.lo format.lo init.lo libbfd.lo \

	cache.lo coffgen.lo corefile.lo format.lo init.lo libbfd.lo \

	opncls.lo reloc.lo section.lo syms.lo targets.lo hash.lo \

	opncls.lo reloc.lo section.lo syms.lo targets.lo hash.lo \

	linker.lo srec.lo binary.lo tekhex.lo ihex.lo stabs.lo \

	linker.lo srec.lo binary.lo tekhex.lo ihex.lo stabs.lo \

am__objects_2 = archive64.lo

am__objects_2 = archive64.lo

am_libbfd_la_OBJECTS = $(am__objects_1) $(am__objects_2)

am_libbfd_la_OBJECTS = $(am__objects_1) $(am__objects_2)

libbfd_la_OBJECTS = $(am_libbfd_la_OBJECTS)

libbfd_la_OBJECTS = $(am_libbfd_la_OBJECTS)

# need two copies of the executable, one to download and one for the

# need two copies of the executable, one to download and one for the

# debugger).

# debugger).

BFD32_LIBS = \

BFD32_LIBS = \

	cache.lo coffgen.lo corefile.lo \

	cache.lo coffgen.lo corefile.lo \

	format.lo init.lo libbfd.lo opncls.lo reloc.lo \

	format.lo init.lo libbfd.lo opncls.lo reloc.lo \

	section.lo syms.lo targets.lo hash.lo linker.lo \

	section.lo syms.lo targets.lo hash.lo linker.lo \

BFD64_LIBS = archive64.lo

BFD64_LIBS = archive64.lo

BFD32_LIBS_CFILES = \

BFD32_LIBS_CFILES = \

	cache.c coffgen.c corefile.c \

	cache.c coffgen.c corefile.c \

	format.c init.c libbfd.c opncls.c reloc.c \

	format.c init.c libbfd.c opncls.c reloc.c \

	section.c syms.c targets.c hash.c linker.c \

	section.c syms.c targets.c hash.c linker.c \

typedef unsigned int flagword;	/* 32 bits of flags */

typedef unsigned int flagword;	/* 32 bits of flags */

typedef unsigned char bfd_byte;

typedef unsigned char bfd_byte;

/* File formats.  */

/* File formats.  */

{

{

  struct bfd_link_hash_table root;

  struct bfd_link_hash_table root;

  /* Whether we have created the special dynamic sections required

  /* Whether we have created the special dynamic sections required

     when linking against or generating a shared object.  */

     when linking against or generating a shared object.  */

  bfd_boolean dynamic_sections_created;

  bfd_boolean dynamic_sections_created;

/* Traverse an ELF linker hash table.  */

/* Traverse an ELF linker hash table.  */

#define elf_link_hash_traverse(table, func, info)			\

#define elf_link_hash_traverse(table, func, info)			\

    (info)))

    (info)))

/* Get the ELF linker hash table from a link_info structure.  */

/* Get the ELF linker hash table from a link_info structure.  */

#define elf_hash_table(p) ((struct elf_link_hash_table *) ((p)->hash))

#define elf_hash_table(p) ((struct elf_link_hash_table *) ((p)->hash))

extern unsigned long bfd_elf_hash

extern unsigned long bfd_elf_hash

  (const char *);

  (const char *);

extern bfd_reloc_status_type bfd_elf_generic_reloc

extern bfd_reloc_status_type bfd_elf_generic_reloc

  (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);

  (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);

  (struct bfd_hash_entry *, struct bfd_hash_table *, const char *);

  (struct bfd_hash_entry *, struct bfd_hash_table *, const char *);

extern struct bfd_link_hash_table *_bfd_elf_link_hash_table_create

extern struct bfd_link_hash_table *_bfd_elf_link_hash_table_create

  (bfd *);

  (bfd *);

extern void _bfd_elf_link_hash_copy_indirect

extern void _bfd_elf_link_hash_copy_indirect

  (struct bfd_link_info *, struct elf_link_hash_entry *,

  (struct bfd_link_info *, struct elf_link_hash_entry *,

   struct elf_link_hash_entry *);

   struct elf_link_hash_entry *);

extern bfd_boolean _bfd_elf_strtab_emit

extern bfd_boolean _bfd_elf_strtab_emit

  (bfd *, struct elf_strtab_hash *);

  (bfd *, struct elf_strtab_hash *);

extern void _bfd_elf_strtab_finalize

extern void _bfd_elf_strtab_finalize

extern bfd_boolean _bfd_elf_discard_section_eh_frame

extern bfd_boolean _bfd_elf_discard_section_eh_frame

  (bfd *, struct bfd_link_info *, asection *,

  (bfd *, struct bfd_link_info *, asection *,

  _bfd_generic_link_hash_table_free

  _bfd_generic_link_hash_table_free

    ((struct bfd_link_hash_table *) ret->static_hash_table);

    ((struct bfd_link_hash_table *) ret->static_hash_table);

}

}

static unsigned long

static unsigned long

    /* Entry this is a suffix of (if len < 0).  */

    /* Entry this is a suffix of (if len < 0).  */

    struct elf_strtab_hash_entry *suffix;

    struct elf_strtab_hash_entry *suffix;

  } u;

  } u;

};

};

/* The strtab hash table.  */

/* The strtab hash table.  */

  bfd_size_type sec_size;

  bfd_size_type sec_size;

  /* Array of pointers to strtab entries.  */

  /* Array of pointers to strtab entries.  */

  struct elf_strtab_hash_entry **array;

  struct elf_strtab_hash_entry **array;

};

};

/* Routine to create an entry in a section merge hashtab.  */

/* Routine to create an entry in a section merge hashtab.  */

    }

    }

  table->array[0] = NULL;

  table->array[0] = NULL;

  return table;

  return table;

}

}

{

{

  bfd_hash_table_free (&tab->table);

  bfd_hash_table_free (&tab->table);

  free (tab->array);

  free (tab->array);

  free (tab);

  free (tab);

}

}

_bfd_elf_strtab_emit (register bfd *abfd, struct elf_strtab_hash *tab)

_bfd_elf_strtab_emit (register bfd *abfd, struct elf_strtab_hash *tab)

{

{

  bfd_size_type off = 1, i;

  bfd_size_type off = 1, i;

  if (bfd_bwrite ("", 1, abfd) != 1)

  if (bfd_bwrite ("", 1, abfd) != 1)

    return FALSE;

    return FALSE;

      register const char *str;

      register const char *str;

      register unsigned int len;

      register unsigned int len;

      if ((int) len < 0)

      if ((int) len < 0)

	continue;

	continue;

      if (bfd_bwrite (str, len, abfd) != len)

      if (bfd_bwrite (str, len, abfd) != len)

	return FALSE;

	return FALSE;

  return lenA - lenB;

  return lenA - lenB;

}

}

static inline int

static inline int

is_suffix (const struct elf_strtab_hash_entry *A,

is_suffix (const struct elf_strtab_hash_entry *A,

	   const struct elf_strtab_hash_entry *B)

	   const struct elf_strtab_hash_entry *B)

/* This function assigns final string table offsets for used strings,

/* This function assigns final string table offsets for used strings,

   merging strings matching suffixes of longer strings if possible.  */

   merging strings matching suffixes of longer strings if possible.  */

void

void

{

{

  struct elf_strtab_hash_entry **array, **a, *e;

  struct elf_strtab_hash_entry **array, **a, *e;

  bfd_size_type size, amt;

  bfd_size_type size, amt;

	}

	}

    }

    }

  /* Assign positions to the strings we want to keep.  */

  /* Assign positions to the strings we want to keep.  */

  size = 1;

  size = 1;

  for (i = 1; i < tab->size; ++i)

  for (i = 1; i < tab->size; ++i)

    {

    {

      if (e->refcount && e->len > 0)

      if (e->refcount && e->len > 0)

	{

	{

	  e->u.index = size;

	  e->u.index = size;

  /* Adjust the rest.  */

  /* Adjust the rest.  */

  for (i = 1; i < tab->size; ++i)

  for (i = 1; i < tab->size; ++i)

    {

    {

      if (e->refcount && e->len < 0)

      if (e->refcount && e->len < 0)

	e->u.index = e->u.suffix->u.index + (e->u.suffix->len + e->len);

	e->u.index = e->u.suffix->u.index + (e->u.suffix->len + e->len);

    }

    }

  table->tls_size = 0;

  table->tls_size = 0;

  table->loaded = NULL;

  table->loaded = NULL;

  table->is_relocatable_executable = FALSE;

  table->is_relocatable_executable = FALSE;

  ret = _bfd_link_hash_table_init (&table->root, abfd, newfunc, entsize);

  ret = _bfd_link_hash_table_init (&table->root, abfd, newfunc, entsize);

  table->root.type = bfd_link_elf_hash_table;

  table->root.type = bfd_link_elf_hash_table;

  return &ret->root;

  return &ret->root;

}

}

/* This is a hook for the ELF emulation code in the generic linker to

/* This is a hook for the ELF emulation code in the generic linker to

   tell the backend linker what file name to use for the DT_NEEDED

   tell the backend linker what file name to use for the DT_NEEDED

   entry for a dynamic object.  */

   entry for a dynamic object.  */

      _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->strtab_hdr.sh_name);

      _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->strtab_hdr.sh_name);

    }

    }

  t->shstrtab_hdr.sh_size = _bfd_elf_strtab_size (elf_shstrtab (abfd));

  t->shstrtab_hdr.sh_size = _bfd_elf_strtab_size (elf_shstrtab (abfd));

  elf_numsections (abfd) = section_number;

  elf_numsections (abfd) = section_number;

    = (struct elf32_hppa_link_hash_table *) btab;

    = (struct elf32_hppa_link_hash_table *) btab;

  bfd_hash_table_free (&htab->bstab);

  bfd_hash_table_free (&htab->bstab);

}

}

/* Build a name for an entry in the stub hash table.  */

/* Build a name for an entry in the stub hash table.  */

  bfd_hash_table_free (ret->stub_hash_table);

  bfd_hash_table_free (ret->stub_hash_table);

  free (ret->stub_hash_table);

  free (ret->stub_hash_table);

}

}

/* Assorted hash table functions.  */

/* Assorted hash table functions.  */

  bfd_hash_table_free (&ret->stub_hash_table);

  bfd_hash_table_free (&ret->stub_hash_table);

  bfd_hash_table_free (&ret->branch_hash_table);

  bfd_hash_table_free (&ret->branch_hash_table);

}

}

/* Satisfy the ELF linker by filling in some fields in our fake bfd.  */

/* Satisfy the ELF linker by filling in some fields in our fake bfd.  */

  const struct elf_backend_data *bed;

  const struct elf_backend_data *bed;

  bfd_byte *extdyn;

  bfd_byte *extdyn;

  size = _bfd_elf_strtab_size (dynstr);

  size = _bfd_elf_strtab_size (dynstr);

  bed = get_elf_backend_data (dynobj);

  bed = get_elf_backend_data (dynobj);

      return FALSE;

      return FALSE;

    }

    }

}

}

{

{

  char *p;

  char *p;

  unsigned long ha;

  unsigned long ha;

  char *alc = NULL;

  char *alc = NULL;

  p = strchr (name, ELF_VER_CHR);

  p = strchr (name, ELF_VER_CHR);

  if (p != NULL)

  if (p != NULL)

    {

    {

  /* Compute the hash value.  */

  /* Compute the hash value.  */

  ha = bfd_elf_hash (name);

  ha = bfd_elf_hash (name);

  /* Store the found hash value in the array given as the argument.  */

  /* Store the found hash value in the array given as the argument.  */

  *(*valuep)++ = ha;

  *(*valuep)++ = ha;

     later.  */

     later.  */

  h->u.elf_hash_value = ha;

  h->u.elf_hash_value = ha;

  return TRUE;

  return TRUE;

}

}

  return best_size;

  return best_size;

}

}

/* Set up the sizes and contents of the ELF dynamic sections.  This is

/* Set up the sizes and contents of the ELF dynamic sections.  This is

   called by the ELF linker emulation before_allocation routine.  We

   called by the ELF linker emulation before_allocation routine.  We

   must set the sizes of the sections before the linker sets the

   must set the sizes of the sections before the linker sets the

	 section symbol for each output section, which come first.

	 section symbol for each output section, which come first.

	 Next come all of the back-end allocated local dynamic syms,

	 Next come all of the back-end allocated local dynamic syms,

	 followed by the rest of the global symbols.  */

	 followed by the rest of the global symbols.  */

      dynsymcount = _bfd_elf_link_renumber_dynsyms (output_bfd, info,

      dynsymcount = _bfd_elf_link_renumber_dynsyms (output_bfd, info,

						    &section_sym_count);

						    &section_sym_count);

      for (dtagcount = 0; dtagcount <= info->spare_dynamic_tags; ++dtagcount)

      for (dtagcount = 0; dtagcount <= info->spare_dynamic_tags; ++dtagcount)

	if (!_bfd_elf_add_dynamic_entry (info, DT_NULL, 0))

	if (!_bfd_elf_add_dynamic_entry (info, DT_NULL, 0))

	  return FALSE;

	  return FALSE;

    }

    }

  return TRUE;

  return TRUE;

    bfd_vma sym_mask;

    bfd_vma sym_mask;

  } u;

  } u;

  enum elf_reloc_type_class type;

  enum elf_reloc_type_class type;

  /* We use this as an array of size int_rels_per_ext_rel.  */

  /* We use this as an array of size int_rels_per_ext_rel.  */

  Elf_Internal_Rela rela[1];

  Elf_Internal_Rela rela[1];

};

};

  const struct elf_link_sort_rela *b = B;

  const struct elf_link_sort_rela *b = B;

  int copya, copyb;

  int copya, copyb;

  if (a->u.offset < b->u.offset)

  if (a->u.offset < b->u.offset)

    return -1;

    return -1;

  if (a->u.offset > b->u.offset)

  if (a->u.offset > b->u.offset)

}

}

static size_t

static size_t

{

{

  asection *reldyn;

  asection *reldyn;

  bfd_size_type count, size;

  bfd_size_type count, size;

  size_t i, ret, sort_elt, ext_size;

  size_t i, ret, sort_elt, ext_size;

  void (*swap_out) (bfd *, const Elf_Internal_Rela *, bfd_byte *);

  void (*swap_out) (bfd *, const Elf_Internal_Rela *, bfd_byte *);

  struct bfd_link_order *lo;

  struct bfd_link_order *lo;

  bfd_vma r_sym_mask;

  bfd_vma r_sym_mask;

  reldyn = bfd_get_section_by_name (abfd, ".rela.dyn");

  reldyn = bfd_get_section_by_name (abfd, ".rela.dyn");

  if (reldyn == NULL || reldyn->size == 0)

  if (reldyn == NULL || reldyn->size == 0)

    }

    }

  if (bed->s->arch_size == 32)

  if (bed->s->arch_size == 32)

  else

  else

  for (lo = reldyn->map_head.link_order; lo != NULL; lo = lo->next)

  for (lo = reldyn->map_head.link_order; lo != NULL; lo = lo->next)

    if (lo->type == bfd_indirect_link_order)

    if (lo->type == bfd_indirect_link_order)

      {

      {

	bfd_byte *erel, *erelend;

	bfd_byte *erel, *erelend;

	asection *o = lo->u.indirect.section;

	asection *o = lo->u.indirect.section;

	if (o->contents == NULL && o->size != 0)

	if (o->contents == NULL && o->size != 0)

	  {

	  {

	p = sort + o->output_offset / ext_size * sort_elt;

	p = sort + o->output_offset / ext_size * sort_elt;

	while (erel < erelend)

	while (erel < erelend)

	  {

	  {

	    struct elf_link_sort_rela *s = (struct elf_link_sort_rela *) p;

	    struct elf_link_sort_rela *s = (struct elf_link_sort_rela *) p;

	    (*swap_in) (abfd, erel, s->rela);

	    (*swap_in) (abfd, erel, s->rela);

	    s->type = (*bed->elf_backend_reloc_type_class) (s->rela);

	    s->type = (*bed->elf_backend_reloc_type_class) (s->rela);

	    s->u.sym_mask = r_sym_mask;

	    s->u.sym_mask = r_sym_mask;

	    p += sort_elt;

	    p += sort_elt;

	    erel += ext_size;

	    erel += ext_size;

	  }

	  }

    }

    }

  if (dynamic && info->combreloc && dynobj != NULL)

  if (dynamic && info->combreloc && dynobj != NULL)

  /* If we are linking against a dynamic object, or generating a

  /* If we are linking against a dynamic object, or generating a

     shared library, finish up the dynamic linking information.  */

     shared library, finish up the dynamic linking information.  */

#endif

#endif

#ifndef bfd_elfNN_bfd_link_hash_table_free

#ifndef bfd_elfNN_bfd_link_hash_table_free

#endif

#endif

#ifdef elf_backend_relocate_section

#ifdef elf_backend_relocate_section

  /* TRUE if unreferenced sections should be removed.  */

  /* TRUE if unreferenced sections should be removed.  */

  unsigned int gc_sections: 1;

  unsigned int gc_sections: 1;

  /* What to do with unresolved symbols in an object file.

  /* What to do with unresolved symbols in an object file.

     When producing executables the default is GENERATE_ERROR.

     When producing executables the default is GENERATE_ERROR.

     When producing shared libraries the default is IGNORE.  The

     When producing shared libraries the default is IGNORE.  The

	link_info.relro = TRUE;

	link_info.relro = TRUE;

      else if (strcmp (optarg, "norelro") == 0)

      else if (strcmp (optarg, "norelro") == 0)

	link_info.relro = FALSE;

	link_info.relro = FALSE;

      /* What about the other Solaris -z options? FIXME.  */

      /* What about the other Solaris -z options? FIXME.  */

      break;

      break;

EOF

EOF

  fprintf (file, _("  --eh-frame-hdr\tCreate .eh_frame_hdr section\n"));

  fprintf (file, _("  --eh-frame-hdr\tCreate .eh_frame_hdr section\n"));

  fprintf (file, _("  -z combreloc\t\tMerge dynamic relocs into one section and sort\n"));

  fprintf (file, _("  -z combreloc\t\tMerge dynamic relocs into one section and sort\n"));

  fprintf (file, _("  -z defs\t\tReport unresolved symbols in object files.\n"));

  fprintf (file, _("  -z defs\t\tReport unresolved symbols in object files.\n"));

  fprintf (file, _("  -z execstack\t\tMark executable as requiring executable stack\n"));

  fprintf (file, _("  -z execstack\t\tMark executable as requiring executable stack\n"));

  fprintf (file, _("  -z initfirst\t\tMark DSO to be initialized first at runtime\n"));

  fprintf (file, _("  -z initfirst\t\tMark DSO to be initialized first at runtime\n"));

  fprintf (file, _("  -z interpose\t\tMark object to interpose all DSOs but executable\n"));

  fprintf (file, _("  -z interpose\t\tMark object to interpose all DSOs but executable\n"));

  fprintf (file, _("  -z nodelete\t\tMark DSO non-deletable at runtime\n"));

  fprintf (file, _("  -z nodelete\t\tMark DSO non-deletable at runtime\n"));

  fprintf (file, _("  -z nodlopen\t\tMark DSO not available to dlopen\n"));

  fprintf (file, _("  -z nodlopen\t\tMark DSO not available to dlopen\n"));

  fprintf (file, _("  -z nodump\t\tMark DSO not available to dldump\n"));

  fprintf (file, _("  -z nodump\t\tMark DSO not available to dldump\n"));

  fprintf (file, _("  -z noexecstack\tMark executable as not requiring executable stack\n"));

  fprintf (file, _("  -z noexecstack\tMark executable as not requiring executable stack\n"));

  fprintf (file, _("  -z norelro\t\tDon't create RELRO program header\n"));

  fprintf (file, _("  -z norelro\t\tDon't create RELRO program header\n"));

  fprintf (file, _("  -z now\t\tMark object non-lazy runtime binding\n"));

  fprintf (file, _("  -z now\t\tMark object non-lazy runtime binding\n"));

Disallows undefined symbols in object files.  Undefined symbols in

Disallows undefined symbols in object files.  Undefined symbols in

shared libraries are still allowed.

shared libraries are still allowed.

@item execstack

@item execstack

Marks the object as requiring executable stack.

Marks the object as requiring executable stack.

@item nodump

@item nodump

Marks the object can not be dumped by @code{dldump}.

Marks the object can not be dumped by @code{dldump}.

@item noexecstack

@item noexecstack

Marks the object as not requiring executable stack.

Marks the object as not requiring executable stack.

  link_info.relax_pass = 1;

  link_info.relax_pass = 1;

  link_info.warn_shared_textrel = FALSE;

  link_info.warn_shared_textrel = FALSE;

  link_info.gc_sections = FALSE;

  link_info.gc_sections = FALSE;

  ldfile_add_arch ("");

  ldfile_add_arch ("");