Automatic date update in version.in

[deliverable/binutils-gdb.git] / bfd / merge.c

diff --git a/bfd/merge.c b/bfd/merge.c
index ce61207251f36b6a961f8e68ba91c94f540c5758..0c6f7a10d3d8c67946e26be3880d1f2e1c75e531 100644 (file)
--- a/bfd/merge.c
+++ b/bfd/merge.c
@@ -1,12 +1,12 @@
 /* SEC_MERGE support.
 /* SEC_MERGE support.

-   Copyright 2001, 2002 Free Software Foundation, Inc.
+   Copyright (C) 2001-2020 Free Software Foundation, Inc.

    Written by Jakub Jelinek <jakub@redhat.com>.
 
    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
    Written by Jakub Jelinek <jakub@redhat.com>.
 
    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
+   the Free Software Foundation; either version 3 of the License, or

    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,


@@ -16,13 +16,17 @@
 
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
 
    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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
+   MA 02110-1301, USA.  */
+

 
 /* This file contains support for merging duplicate entities within sections,
    as used in ELF SHF_MERGE.  */
 
 
 /* This file contains support for merging duplicate entities within sections,
    as used in ELF SHF_MERGE.  */
 

-#include "bfd.h"

 #include "sysdep.h"
 #include "sysdep.h"

+#include <limits.h>
+#include "bfd.h"
+#include "elf-bfd.h"

 #include "libbfd.h"
 #include "hashtab.h"
 #include "libiberty.h"
 #include "libbfd.h"
 #include "hashtab.h"
 #include "libiberty.h"


@@ -34,7 +38,7 @@ struct sec_merge_sec_info;
 struct sec_merge_hash_entry
 {
   struct bfd_hash_entry root;
 struct sec_merge_hash_entry
 {
   struct bfd_hash_entry root;

-  /* Length of this entry.  */
+  /* Length of this entry.  This includes the zero terminator.  */

   unsigned int len;
   /* Start of this string needs to be aligned to
      alignment octets (not 1 << align).  */
   unsigned int len;
   /* Start of this string needs to be aligned to
      alignment octets (not 1 << align).  */


@@ -43,8 +47,6 @@ struct sec_merge_hash_entry
   {
     /* Index within the merged section.  */
     bfd_size_type index;
   {
     /* Index within the merged section.  */
     bfd_size_type index;

-    /* Entity size (if present in suffix hash tables).  */
-    unsigned int entsize;

     /* Entry this is a suffix of (if alignment is 0).  */
     struct sec_merge_hash_entry *suffix;
   } u;
     /* Entry this is a suffix of (if alignment is 0).  */
     struct sec_merge_hash_entry *suffix;
   } u;


@@ -68,7 +70,7 @@ struct sec_merge_hash
   /* Entity size.  */
   unsigned int entsize;
   /* Are entries fixed size or zero terminated strings?  */
   /* Entity size.  */
   unsigned int entsize;
   /* Are entries fixed size or zero terminated strings?  */

-  boolean strings;
+  bfd_boolean strings;

 };
 
 struct sec_merge_info
 };
 
 struct sec_merge_info


@@ -88,82 +90,59 @@ struct sec_merge_sec_info
   /* The corresponding section.  */
   asection *sec;
   /* Pointer to merge_info pointing to us.  */
   /* The corresponding section.  */
   asection *sec;
   /* Pointer to merge_info pointing to us.  */

-  PTR *psecinfo;
+  void **psecinfo;

   /* A hash table used to hold section content.  */
   struct sec_merge_hash *htab;
   /* First string in this section.  */
   /* A hash table used to hold section content.  */
   struct sec_merge_hash *htab;
   /* First string in this section.  */

-  struct sec_merge_hash_entry *first;
+  struct sec_merge_hash_entry *first_str;

   /* Original section content.  */
   unsigned char contents[1];
 };
 
   /* Original section content.  */
   unsigned char contents[1];
 };
 

-static struct bfd_hash_entry *sec_merge_hash_newfunc
-  PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
-static struct sec_merge_hash_entry *sec_merge_hash_lookup
-  PARAMS ((struct sec_merge_hash *, const char *, unsigned int, boolean));
-static struct sec_merge_hash *sec_merge_init
-  PARAMS ((unsigned int, boolean));
-static struct sec_merge_hash_entry *sec_merge_add
-  PARAMS ((struct sec_merge_hash *, const char *, unsigned int,
-          struct sec_merge_sec_info *));
-static boolean sec_merge_emit
-  PARAMS ((bfd *, struct sec_merge_hash_entry *));
-static int cmplengthentry PARAMS ((const PTR, const PTR));
-static int last4_eq PARAMS ((const PTR, const PTR));
-static int last_eq PARAMS ((const PTR, const PTR));
-static boolean record_section
-  PARAMS ((struct sec_merge_info *, struct sec_merge_sec_info *));
-static void merge_strings PARAMS ((struct sec_merge_info *));

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

-sec_merge_hash_newfunc (entry, table, string)
-     struct bfd_hash_entry *entry;
-     struct bfd_hash_table *table;
-     const char *string;
+sec_merge_hash_newfunc (struct bfd_hash_entry *entry,
+                       struct bfd_hash_table *table, const char *string)

 {
 {

-  struct sec_merge_hash_entry *ret = (struct sec_merge_hash_entry *) entry;
-

   /* Allocate the structure if it has not already been allocated by a
      subclass.  */
   /* Allocate the structure if it has not already been allocated by a
      subclass.  */

-  if (ret == (struct sec_merge_hash_entry *) NULL)
-    ret = ((struct sec_merge_hash_entry *)
-          bfd_hash_allocate (table, sizeof (struct sec_merge_hash_entry)));
-  if (ret == (struct sec_merge_hash_entry *) NULL)
+  if (entry == NULL)
+    entry = (struct bfd_hash_entry *)
+       bfd_hash_allocate (table, sizeof (struct sec_merge_hash_entry));
+  if (entry == NULL)

     return NULL;
 
   /* Call the allocation method of the superclass.  */
     return NULL;
 
   /* Call the allocation method of the superclass.  */

-  ret = ((struct sec_merge_hash_entry *)
-        bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
+  entry = bfd_hash_newfunc (entry, table, string);

 
 

-  if (ret)
+  if (entry != NULL)

     {
       /* Initialize the local fields.  */
     {
       /* Initialize the local fields.  */

+      struct sec_merge_hash_entry *ret = (struct sec_merge_hash_entry *) entry;
+

       ret->u.suffix = NULL;
       ret->alignment = 0;
       ret->secinfo = NULL;
       ret->next = NULL;
     }
 
       ret->u.suffix = NULL;
       ret->alignment = 0;
       ret->secinfo = NULL;
       ret->next = NULL;
     }
 

-  return (struct bfd_hash_entry *) ret;
+  return entry;

 }
 
 /* Look up an entry in a section merge hash table.  */
 
 static struct sec_merge_hash_entry *
 }
 
 /* Look up an entry in a section merge hash table.  */
 
 static struct sec_merge_hash_entry *

-sec_merge_hash_lookup (table, string, alignment, create)
-     struct sec_merge_hash *table;
-     const char *string;
-     unsigned int alignment;
-     boolean create;
+sec_merge_hash_lookup (struct sec_merge_hash *table, const char *string,
+                      unsigned int alignment, bfd_boolean create)

 {
 {

-  register const unsigned char *s;
-  register unsigned long hash;
-  register unsigned int c;
+  const unsigned char *s;
+  unsigned long hash;
+  unsigned int c;

   struct sec_merge_hash_entry *hashp;
   unsigned int len, i;
   struct sec_merge_hash_entry *hashp;
   unsigned int len, i;

-  unsigned int index;
+  unsigned int _index;

 
   hash = 0;
   len = 0;
 
   hash = 0;
   len = 0;


@@ -214,9 +193,9 @@ sec_merge_hash_lookup (table, string, alignment, create)
       len = table->entsize;
     }
 
       len = table->entsize;
     }
 

-  index = hash % table->table.size;
-  for (hashp = (struct sec_merge_hash_entry *) table->table.table[index];
-       hashp != (struct sec_merge_hash_entry *) NULL;
+  _index = hash % table->table.size;
+  for (hashp = (struct sec_merge_hash_entry *) table->table.table[_index];
+       hashp != NULL;

        hashp = (struct sec_merge_hash_entry *) hashp->root.next)
     {
       if (hashp->root.hash == hash
        hashp = (struct sec_merge_hash_entry *) hashp->root.next)
     {
       if (hashp->root.hash == hash


@@ -227,9 +206,12 @@ sec_merge_hash_lookup (table, string, alignment, create)
             alignment, we need to insert another copy.  */
          if (hashp->alignment < alignment)
            {
             alignment, we need to insert another copy.  */
          if (hashp->alignment < alignment)
            {

-             /*  Mark the less aligned copy as deleted.  */
-             hashp->len = 0;
-             hashp->alignment = 0;
+             if (create)
+               {
+                 /*  Mark the less aligned copy as deleted.  */
+                 hashp->len = 0;
+                 hashp->alignment = 0;
+               }

              break;
            }
          return hashp;
              break;
            }
          return hashp;


@@ -237,38 +219,30 @@ sec_merge_hash_lookup (table, string, alignment, create)
     }
 
   if (! create)
     }
 
   if (! create)

-    return (struct sec_merge_hash_entry *) NULL;
-
-  hashp = (struct sec_merge_hash_entry *)
-         sec_merge_hash_newfunc ((struct bfd_hash_entry *) NULL,
-                                 (struct bfd_hash_table *) table, string);
-  if (hashp == (struct sec_merge_hash_entry *) NULL)
-    return (struct sec_merge_hash_entry *) NULL;
-  hashp->root.string = string;
-  hashp->root.hash = hash;
+    return NULL;
+
+  hashp = ((struct sec_merge_hash_entry *)
+          bfd_hash_insert (&table->table, string, hash));
+  if (hashp == NULL)
+    return NULL;

   hashp->len = len;
   hashp->alignment = alignment;
   hashp->len = len;
   hashp->alignment = alignment;

-  hashp->root.next = table->table.table[index];
-  table->table.table[index] = (struct bfd_hash_entry *) hashp;
-

   return hashp;
 }
 
 /* Create a new hash table.  */
 
 static struct sec_merge_hash *
   return hashp;
 }
 
 /* Create a new hash table.  */
 
 static struct sec_merge_hash *

-sec_merge_init (entsize, strings)
-     unsigned int entsize;
-     boolean strings;
+sec_merge_init (unsigned int entsize, bfd_boolean strings)

 {
   struct sec_merge_hash *table;
 {
   struct sec_merge_hash *table;

-  bfd_size_type amt = sizeof (struct sec_merge_hash);

 
 

-  table = (struct sec_merge_hash *) bfd_malloc (amt);
+  table = (struct sec_merge_hash *) bfd_malloc (sizeof (struct sec_merge_hash));

   if (table == NULL)
     return NULL;
 
   if (table == NULL)
     return NULL;
 

-  if (! bfd_hash_table_init (&table->table, sec_merge_hash_newfunc))
+  if (! bfd_hash_table_init_n (&table->table, sec_merge_hash_newfunc,
+                              sizeof (struct sec_merge_hash_entry), 16699))

     {
       free (table);
       return NULL;
     {
       free (table);
       return NULL;


@@ -287,15 +261,12 @@ sec_merge_init (entsize, strings)
    already present.  */
 
 static struct sec_merge_hash_entry *
    already present.  */
 
 static struct sec_merge_hash_entry *

-sec_merge_add (tab, str, alignment, secinfo)
-     struct sec_merge_hash *tab;
-     const char *str;
-     unsigned int alignment;
-     struct sec_merge_sec_info *secinfo;
+sec_merge_add (struct sec_merge_hash *tab, const char *str,
+              unsigned int alignment, struct sec_merge_sec_info *secinfo)

 {
 {

-  register struct sec_merge_hash_entry *entry;
+  struct sec_merge_hash_entry *entry;

 
 

-  entry = sec_merge_hash_lookup (tab, str, alignment, true);
+  entry = sec_merge_hash_lookup (tab, str, alignment, TRUE);

   if (entry == NULL)
     return NULL;
 
   if (entry == NULL)
     return NULL;
 


@@ -313,82 +284,124 @@ sec_merge_add (tab, str, alignment, secinfo)
   return entry;
 }
 
   return entry;
 }
 

-static boolean
-sec_merge_emit (abfd, entry)
-     register bfd *abfd;
-     struct sec_merge_hash_entry *entry;
+static bfd_boolean
+sec_merge_emit (bfd *abfd, struct sec_merge_hash_entry *entry,
+               unsigned char *contents, file_ptr offset)

 {
   struct sec_merge_sec_info *secinfo = entry->secinfo;
   asection *sec = secinfo->sec;
 {
   struct sec_merge_sec_info *secinfo = entry->secinfo;
   asection *sec = secinfo->sec;

-  char *pad = "";
+  char *pad = NULL;

   bfd_size_type off = 0;
   bfd_size_type off = 0;

-  int alignment_power = bfd_get_section_alignment (abfd, sec->output_section);
+  unsigned int opb = bfd_octets_per_byte (abfd, sec);
+  int alignment_power = sec->output_section->alignment_power * opb;
+  bfd_size_type pad_len;  /* Octets.  */

 
 

-  if (alignment_power)
-    pad = bfd_zmalloc ((bfd_size_type) 1 << alignment_power);
+  /* FIXME: If alignment_power is 0 then really we should scan the
+     entry list for the largest required alignment and use that.  */
+  pad_len = alignment_power ? ((bfd_size_type) 1 << alignment_power) : 16;
+
+  pad = (char *) bfd_zmalloc (pad_len);
+  if (pad == NULL)
+    return FALSE;

 
   for (; entry != NULL && entry->secinfo == secinfo; entry = entry->next)
     {
 
   for (; entry != NULL && entry->secinfo == secinfo; entry = entry->next)
     {

-      register const char *str;
-      register size_t len;
+      const char *str;
+      bfd_size_type len;

 
 

-      len = off & (entry->alignment - 1);
-      if (len)
+      len = -off & (entry->alignment - 1);
+      if (len != 0)

        {
        {

-         len = entry->alignment - len;
-         if (bfd_bwrite ((PTR) pad, (bfd_size_type) len, abfd) != len)
-           break;
+         BFD_ASSERT (len <= pad_len);
+         if (contents)
+           {
+             memcpy (contents + offset, pad, len);
+             offset += len;
+           }
+         else if (bfd_bwrite (pad, len, abfd) != len)
+           goto err;

          off += len;
        }
 
       str = entry->root.string;
       len = entry->len;
 
          off += len;
        }
 
       str = entry->root.string;
       len = entry->len;
 

-      if (bfd_bwrite ((PTR) str, (bfd_size_type) len, abfd) != len)
-       break;
+      if (contents)
+       {
+         memcpy (contents + offset, str, len);
+         offset += len;
+       }
+      else if (bfd_bwrite (str, len, abfd) != len)
+       goto err;

 
       off += len;
     }
 
 
       off += len;
     }
 

-  if (alignment_power)
-    free (pad);
+  /* Trailing alignment needed?  */
+  off = sec->size - off;
+  if (off != 0)
+    {
+      BFD_ASSERT (off <= pad_len);
+      if (contents)
+       memcpy (contents + offset, pad, off);
+      else if (bfd_bwrite (pad, off, abfd) != off)
+       goto err;
+    }

 
 

-  return entry == NULL || entry->secinfo != secinfo;
+  free (pad);
+  return TRUE;
+
+ err:
+  free (pad);
+  return FALSE;

 }
 
 }
 

-/* This function is called for each input file from the add_symbols
-   pass of the linker.  */
+/* Register a SEC_MERGE section as a candidate for merging.
+   This function is called for all non-dynamic SEC_MERGE input sections.  */

 
 

-boolean
-_bfd_merge_section (abfd, psinfo, sec, psecinfo)
-     bfd *abfd;
-     PTR *psinfo;
-     asection *sec;
-     PTR *psecinfo;
+bfd_boolean
+_bfd_add_merge_section (bfd *abfd, void **psinfo, asection *sec,
+                       void **psecinfo)

 {
   struct sec_merge_info *sinfo;
   struct sec_merge_sec_info *secinfo;
 {
   struct sec_merge_info *sinfo;
   struct sec_merge_sec_info *secinfo;

-  unsigned int align;
+  unsigned int alignment_power;  /* Octets.  */
+  unsigned int align;            /* Octets.  */

   bfd_size_type amt;
   bfd_size_type amt;

+  bfd_byte *contents;
+  unsigned int opb = bfd_octets_per_byte (abfd, sec);
+
+  if ((abfd->flags & DYNAMIC) != 0
+      || (sec->flags & SEC_MERGE) == 0)
+    abort ();

 
 

-  if (sec->_raw_size == 0
-      || (sec->flags & SEC_EXCLUDE)
-      || (sec->flags & SEC_MERGE) == 0
+  if (sec->size == 0
+      || (sec->flags & SEC_EXCLUDE) != 0

       || sec->entsize == 0)
       || sec->entsize == 0)

-    return true;
+    return TRUE;
+
+  if (sec->size % sec->entsize != 0)
+    return TRUE;

 
   if ((sec->flags & SEC_RELOC) != 0)
     {
       /* We aren't prepared to handle relocations in merged sections.  */
 
   if ((sec->flags & SEC_RELOC) != 0)
     {
       /* We aren't prepared to handle relocations in merged sections.  */

-      return true;
+      return TRUE;

     }
 
     }
 

-  align = bfd_get_section_alignment (sec->owner, sec);
-  if ((sec->entsize < (unsigned int)(1 << align)
+#ifndef CHAR_BIT
+#define CHAR_BIT 8
+#endif
+  alignment_power = sec->alignment_power * opb;
+  if (alignment_power >= sizeof (align) * CHAR_BIT)
+    return TRUE;
+
+  align = 1u << alignment_power;
+  if ((sec->entsize < align

        && ((sec->entsize & (sec->entsize - 1))
           || !(sec->flags & SEC_STRINGS)))
        && ((sec->entsize & (sec->entsize - 1))
           || !(sec->flags & SEC_STRINGS)))

-      || (sec->entsize > (unsigned int)(1 << align)
-         && (sec->entsize & ((1 << align) - 1))))
+      || (sec->entsize > align
+         && (sec->entsize & (align - 1))))

     {
       /* Sanity check.  If string character size is smaller than
         alignment, then we require character size to be a power
     {
       /* Sanity check.  If string character size is smaller than
         alignment, then we require character size to be a power


@@ -396,26 +409,27 @@ _bfd_merge_section (abfd, psinfo, sec, psecinfo)
         of alignment.  For non-string constants, alignment must
         be smaller than or equal to entity size and entity size
         must be integer multiple of alignment.  */
         of alignment.  For non-string constants, alignment must
         be smaller than or equal to entity size and entity size
         must be integer multiple of alignment.  */

-      return true;
+      return TRUE;

     }
 
   for (sinfo = (struct sec_merge_info *) *psinfo; sinfo; sinfo = sinfo->next)
     if ((secinfo = sinfo->chain)
        && ! ((secinfo->sec->flags ^ sec->flags) & (SEC_MERGE | SEC_STRINGS))
        && secinfo->sec->entsize == sec->entsize
     }
 
   for (sinfo = (struct sec_merge_info *) *psinfo; sinfo; sinfo = sinfo->next)
     if ((secinfo = sinfo->chain)
        && ! ((secinfo->sec->flags ^ sec->flags) & (SEC_MERGE | SEC_STRINGS))
        && secinfo->sec->entsize == sec->entsize

-       && ! strcmp (secinfo->sec->name, sec->name))
+       && secinfo->sec->alignment_power == sec->alignment_power
+       && secinfo->sec->output_section == sec->output_section)

       break;
 
   if (sinfo == NULL)
     {
       /* Initialize the information we need to keep track of.  */
       break;
 
   if (sinfo == NULL)
     {
       /* Initialize the information we need to keep track of.  */

-      amt = sizeof (struct sec_merge_info);
-      sinfo = (struct sec_merge_info *) bfd_alloc (abfd, amt);
+      sinfo = (struct sec_merge_info *)
+         bfd_alloc (abfd, sizeof (struct sec_merge_info));

       if (sinfo == NULL)
        goto error_return;
       sinfo->next = (struct sec_merge_info *) *psinfo;
       sinfo->chain = NULL;
       if (sinfo == NULL)
        goto error_return;
       sinfo->next = (struct sec_merge_info *) *psinfo;
       sinfo->chain = NULL;

-      *psinfo = (PTR) sinfo;
+      *psinfo = sinfo;

       sinfo->htab = sec_merge_init (sec->entsize, (sec->flags & SEC_STRINGS));
       if (sinfo->htab == NULL)
        goto error_return;
       sinfo->htab = sec_merge_init (sec->entsize, (sec->flags & SEC_STRINGS));
       if (sinfo->htab == NULL)
        goto error_return;


@@ -423,12 +437,17 @@ _bfd_merge_section (abfd, psinfo, sec, psecinfo)
 
   /* Read the section from abfd.  */
 
 
   /* Read the section from abfd.  */
 

-  amt = sizeof (struct sec_merge_sec_info) + sec->_raw_size - 1;
+  amt = sizeof (struct sec_merge_sec_info) - 1 + sec->size;
+  if (sec->flags & SEC_STRINGS)
+    /* Some versions of gcc may emit a string without a zero terminator.
+       See http://gcc.gnu.org/ml/gcc-patches/2006-06/msg01004.html
+       Allocate space for an extra zero.  */
+    amt += sec->entsize;

   *psecinfo = bfd_alloc (abfd, amt);
   if (*psecinfo == NULL)
     goto error_return;
 
   *psecinfo = bfd_alloc (abfd, amt);
   if (*psecinfo == NULL)
     goto error_return;
 

-  secinfo = (struct sec_merge_sec_info *)*psecinfo;
+  secinfo = (struct sec_merge_sec_info *) *psecinfo;

   if (sinfo->chain)
     {
       secinfo->next = sinfo->chain->next;
   if (sinfo->chain)
     {
       secinfo->next = sinfo->chain->next;


@@ -440,114 +459,37 @@ _bfd_merge_section (abfd, psinfo, sec, psecinfo)
   secinfo->sec = sec;
   secinfo->psecinfo = psecinfo;
   secinfo->htab = sinfo->htab;
   secinfo->sec = sec;
   secinfo->psecinfo = psecinfo;
   secinfo->htab = sinfo->htab;

-  secinfo->first = NULL;
+  secinfo->first_str = NULL;

 
 

-  if (! bfd_get_section_contents (sec->owner, sec, secinfo->contents,
-                                 (bfd_vma) 0, sec->_raw_size))
+  sec->rawsize = sec->size;
+  if (sec->flags & SEC_STRINGS)
+    memset (secinfo->contents + sec->size, 0, sec->entsize);
+  contents = secinfo->contents;
+  if (! bfd_get_full_section_contents (sec->owner, sec, &contents))

     goto error_return;
 
     goto error_return;
 

-  return true;
+  return TRUE;

 
  error_return:
   *psecinfo = NULL;
 
  error_return:
   *psecinfo = NULL;

-  return false;
-}
-
-/* Compare two sec_merge_hash_entry structures.  This is called via qsort.  */
-
-static int
-cmplengthentry (a, b)
-     const PTR a;
-     const PTR b;
-{
-  struct sec_merge_hash_entry * A = *(struct sec_merge_hash_entry **) a;
-  struct sec_merge_hash_entry * B = *(struct sec_merge_hash_entry **) b;
-
-  if (A->len < B->len)
-    return 1;
-  else if (A->len > B->len)
-    return -1;
-
-  return memcmp (A->root.string, B->root.string, A->len);
-}
-
-static int
-last4_eq (a, b)
-     const PTR a;
-     const PTR b;
-{
-  struct sec_merge_hash_entry * A = (struct sec_merge_hash_entry *) a;
-  struct sec_merge_hash_entry * B = (struct sec_merge_hash_entry *) b;
-
-  if (memcmp (A->root.string + A->len - 5 * A->u.entsize,
-             B->root.string + B->len - 5 * A->u.entsize,
-             4 * A->u.entsize) != 0)
-    /* This was a hashtable collision.  */
-    return 0;
-
-  if (A->len <= B->len)
-    /* B cannot be a suffix of A unless A is equal to B, which is guaranteed
-       not to be equal by the hash table.  */
-    return 0;
-
-  if (A->alignment < B->alignment
-      || ((A->len - B->len) & (B->alignment - 1)))
-    /* The suffix is not sufficiently aligned.  */
-    return 0;
-
-  return memcmp (A->root.string + (A->len - B->len),
-                B->root.string, B->len - 5 * A->u.entsize) == 0;
-}
-
-static int
-last_eq (a, b)
-     const PTR a;
-     const PTR b;
-{
-  struct sec_merge_hash_entry * A = (struct sec_merge_hash_entry *) a;
-  struct sec_merge_hash_entry * B = (struct sec_merge_hash_entry *) b;
-
-  if (B->len >= 5 * A->u.entsize)
-    /* Longer strings are just pushed into the hash table,
-       they'll be used when looking up for very short strings.  */
-    return 0;
-
-  if (memcmp (A->root.string + A->len - 2 * A->u.entsize,
-             B->root.string + B->len - 2 * A->u.entsize,
-             A->u.entsize) != 0)
-    /* This was a hashtable collision.  */
-    return 0;
-
-  if (A->len <= B->len)
-    /* B cannot be a suffix of A unless A is equal to B, which is guaranteed
-       not to be equal by the hash table.  */
-    return 0;
-
-  if (A->alignment < B->alignment
-      || ((A->len - B->len) & (B->alignment - 1)))
-    /* The suffix is not sufficiently aligned.  */
-    return 0;
-
-  return memcmp (A->root.string + (A->len - B->len),
-                B->root.string, B->len - 2 * A->u.entsize) == 0;
+  return FALSE;

 }
 
 /* Record one section into the hash table.  */
 }
 
 /* Record one section into the hash table.  */

-static boolean
-record_section (sinfo, secinfo)
-     struct sec_merge_info *sinfo;
-     struct sec_merge_sec_info *secinfo;
+static bfd_boolean
+record_section (struct sec_merge_info *sinfo,
+               struct sec_merge_sec_info *secinfo)

 {
   asection *sec = secinfo->sec;
   struct sec_merge_hash_entry *entry;
 {
   asection *sec = secinfo->sec;
   struct sec_merge_hash_entry *entry;

-  boolean nul;
+  bfd_boolean nul;

   unsigned char *p, *end;
   bfd_vma mask, eltalign;
   unsigned int align, i;
 
   unsigned char *p, *end;
   bfd_vma mask, eltalign;
   unsigned int align, i;
 

-  align = bfd_get_section_alignment (sec->owner, sec);
-  end = secinfo->contents + sec->_raw_size;
-  nul = false;
+  align = sec->alignment_power;
+  end = secinfo->contents + sec->size;
+  nul = FALSE;

   mask = ((bfd_vma) 1 << align) - 1;
   if (sec->flags & SEC_STRINGS)
     {
   mask = ((bfd_vma) 1 << align) - 1;
   if (sec->flags & SEC_STRINGS)
     {


@@ -557,7 +499,8 @@ record_section (sinfo, secinfo)
          eltalign = ((eltalign ^ (eltalign - 1)) + 1) >> 1;
          if (!eltalign || eltalign > mask)
            eltalign = mask + 1;
          eltalign = ((eltalign ^ (eltalign - 1)) + 1) >> 1;
          if (!eltalign || eltalign > mask)
            eltalign = mask + 1;

-         entry = sec_merge_add (sinfo->htab, p, (unsigned) eltalign, secinfo);
+         entry = sec_merge_add (sinfo->htab, (char *) p, (unsigned) eltalign,
+                                secinfo);

          if (! entry)
            goto error_return;
          p += entry->len;
          if (! entry)
            goto error_return;
          p += entry->len;


@@ -567,14 +510,14 @@ record_section (sinfo, secinfo)
                {
                  if (!nul && !((p - secinfo->contents) & mask))
                    {
                {
                  if (!nul && !((p - secinfo->contents) & mask))
                    {

-                     nul = true;
+                     nul = TRUE;

                      entry = sec_merge_add (sinfo->htab, "",
                                             (unsigned) mask + 1, secinfo);
                      if (! entry)
                        goto error_return;
                    }
                  p++;
                      entry = sec_merge_add (sinfo->htab, "",
                                             (unsigned) mask + 1, secinfo);
                      if (! entry)
                        goto error_return;
                    }
                  p++;

-               }
+               }

            }
          else
            {
            }
          else
            {


@@ -587,8 +530,8 @@ record_section (sinfo, secinfo)
                    break;
                  if (!nul && !((p - secinfo->contents) & mask))
                    {
                    break;
                  if (!nul && !((p - secinfo->contents) & mask))
                    {

-                     nul = true;
-                     entry = sec_merge_add (sinfo->htab, p,
+                     nul = TRUE;
+                     entry = sec_merge_add (sinfo->htab, (char *) p,

                                             (unsigned) mask + 1, secinfo);
                      if (! entry)
                        goto error_return;
                                             (unsigned) mask + 1, secinfo);
                      if (! entry)
                        goto error_return;


@@ -602,124 +545,147 @@ record_section (sinfo, secinfo)
     {
       for (p = secinfo->contents; p < end; p += sec->entsize)
        {
     {
       for (p = secinfo->contents; p < end; p += sec->entsize)
        {

-         entry = sec_merge_add (sinfo->htab, p, 1, secinfo);
+         entry = sec_merge_add (sinfo->htab, (char *) p, 1, secinfo);

          if (! entry)
            goto error_return;
        }
     }
 
          if (! entry)
            goto error_return;
        }
     }
 

-  return true;
+  return TRUE;

 
 

-error_return:
+ error_return:

   for (secinfo = sinfo->chain; secinfo; secinfo = secinfo->next)
     *secinfo->psecinfo = NULL;
   for (secinfo = sinfo->chain; secinfo; secinfo = secinfo->next)
     *secinfo->psecinfo = NULL;

-  return false;
+  return FALSE;
+}
+
+/* qsort comparison function.  Won't ever return zero as all entries
+   differ, so there is no issue with qsort stability here.  */
+
+static int
+strrevcmp (const void *a, const void *b)
+{
+  struct sec_merge_hash_entry *A = *(struct sec_merge_hash_entry **) a;
+  struct sec_merge_hash_entry *B = *(struct sec_merge_hash_entry **) b;
+  unsigned int lenA = A->len;
+  unsigned int lenB = B->len;
+  const unsigned char *s = (const unsigned char *) A->root.string + lenA - 1;
+  const unsigned char *t = (const unsigned char *) B->root.string + lenB - 1;
+  int l = lenA < lenB ? lenA : lenB;
+
+  while (l)
+    {
+      if (*s != *t)
+       return (int) *s - (int) *t;
+      s--;
+      t--;
+      l--;
+    }
+  return lenA - lenB;
+}
+
+/* Like strrevcmp, but for the case where all strings have the same
+   alignment > entsize.  */
+
+static int
+strrevcmp_align (const void *a, const void *b)
+{
+  struct sec_merge_hash_entry *A = *(struct sec_merge_hash_entry **) a;
+  struct sec_merge_hash_entry *B = *(struct sec_merge_hash_entry **) b;
+  unsigned int lenA = A->len;
+  unsigned int lenB = B->len;
+  const unsigned char *s = (const unsigned char *) A->root.string + lenA - 1;
+  const unsigned char *t = (const unsigned char *) B->root.string + lenB - 1;
+  int l = lenA < lenB ? lenA : lenB;
+  int tail_align = (lenA & (A->alignment - 1)) - (lenB & (A->alignment - 1));
+
+  if (tail_align != 0)
+    return tail_align;
+
+  while (l)
+    {
+      if (*s != *t)
+       return (int) *s - (int) *t;
+      s--;
+      t--;
+      l--;
+    }
+  return lenA - lenB;
+}
+
+static inline int
+is_suffix (const struct sec_merge_hash_entry *A,
+          const struct sec_merge_hash_entry *B)
+{
+  if (A->len <= B->len)
+    /* B cannot be a suffix of A unless A is equal to B, which is guaranteed
+       not to be equal by the hash table.  */
+    return 0;
+
+  return memcmp (A->root.string + (A->len - B->len),
+                B->root.string, B->len) == 0;

 }
 
 /* This is a helper function for _bfd_merge_sections.  It attempts to
    merge strings matching suffixes of longer strings.  */
 }
 
 /* This is a helper function for _bfd_merge_sections.  It attempts to
    merge strings matching suffixes of longer strings.  */

-static void
-merge_strings (sinfo)
-     struct sec_merge_info *sinfo;
+static struct sec_merge_sec_info *
+merge_strings (struct sec_merge_info *sinfo)

 {
 {

-  struct sec_merge_hash_entry **array, **a, **end, *e;
+  struct sec_merge_hash_entry **array, **a, *e;

   struct sec_merge_sec_info *secinfo;
   struct sec_merge_sec_info *secinfo;

-  htab_t lasttab = NULL, last4tab = NULL;

   bfd_size_type size, amt;
   bfd_size_type size, amt;

+  unsigned int alignment = 0;

 
 

-  /* Now sort the strings by length, longest first.  */
-  array = NULL;
+  /* Now sort the strings */

   amt = sinfo->htab->size * sizeof (struct sec_merge_hash_entry *);
   array = (struct sec_merge_hash_entry **) bfd_malloc (amt);
   if (array == NULL)
   amt = sinfo->htab->size * sizeof (struct sec_merge_hash_entry *);
   array = (struct sec_merge_hash_entry **) bfd_malloc (amt);
   if (array == NULL)

-    goto alloc_failure;
+    return NULL;

 
   for (e = sinfo->htab->first, a = array; e; e = e->next)
     if (e->alignment)
 
   for (e = sinfo->htab->first, a = array; e; e = e->next)
     if (e->alignment)

-      *a++ = e;
+      {
+       *a++ = e;
+       /* Adjust the length to not include the zero terminator.  */
+       e->len -= sinfo->htab->entsize;
+       if (alignment != e->alignment)
+         {
+           if (alignment == 0)
+             alignment = e->alignment;
+           else
+             alignment = (unsigned) -1;
+         }
+      }

 
   sinfo->htab->size = a - array;
 
   sinfo->htab->size = a - array;

-
-  qsort (array, (size_t) sinfo->htab->size,
-        sizeof (struct sec_merge_hash_entry *), cmplengthentry);
-
-  last4tab = htab_create_alloc ((size_t) sinfo->htab->size * 4, 
-                               NULL, last4_eq, NULL, calloc, free);
-  lasttab = htab_create_alloc ((size_t) sinfo->htab->size * 4, 
-                              NULL, last_eq, NULL, calloc, free);
-  if (lasttab == NULL || last4tab == NULL)
-    goto alloc_failure;
-
-  /* Now insert the strings into hash tables (strings with last 4 characters
-     and strings with last character equal), look for longer strings which
-     we're suffix of.  */
-  for (a = array, end = array + sinfo->htab->size; a < end; a++)
+  if (sinfo->htab->size != 0)

     {
     {

-      register hashval_t hash;
-      unsigned int c;
-      unsigned int i;
-      const unsigned char *s;
-      PTR *p;
-
-      e = *a;
-      e->u.entsize = sinfo->htab->entsize;
-      if (e->len <= e->u.entsize)
-       break;
-      if (e->len > 4 * e->u.entsize)
+      qsort (array, (size_t) sinfo->htab->size,
+            sizeof (struct sec_merge_hash_entry *),
+            (alignment != (unsigned) -1 && alignment > sinfo->htab->entsize
+             ? strrevcmp_align : strrevcmp));
+
+      /* Loop over the sorted array and merge suffixes */
+      e = *--a;
+      e->len += sinfo->htab->entsize;
+      while (--a >= array)

        {
        {

-         s = e->root.string + e->len - e->u.entsize;
-         hash = 0;
-         for (i = 0; i < 4 * e->u.entsize; i++)
-           {
-             c = *--s;
-             hash += c + (c << 17);
-             hash ^= hash >> 2;
-           }
-         p = htab_find_slot_with_hash (last4tab, e, hash, INSERT);
-         if (p == NULL)
-           goto alloc_failure;
-         if (*p)
-           {
-             struct sec_merge_hash_entry *ent;
+         struct sec_merge_hash_entry *cmp = *a;

 
 

-             ent = (struct sec_merge_hash_entry *) *p;
-             e->u.suffix = ent;
-             e->alignment = 0;
-             continue;
+         cmp->len += sinfo->htab->entsize;
+         if (e->alignment >= cmp->alignment
+             && !((e->len - cmp->len) & (cmp->alignment - 1))
+             && is_suffix (e, cmp))
+           {
+             cmp->u.suffix = e;
+             cmp->alignment = 0;

            }
          else
            }
          else

-           *p = (PTR) e;
+           e = cmp;

        }
        }

-      s = e->root.string + e->len - e->u.entsize;
-      hash = 0;
-      for (i = 0; i < e->u.entsize; i++)
-       {
-         c = *--s;
-         hash += c + (c << 17);
-         hash ^= hash >> 2;
-       }
-      p = htab_find_slot_with_hash (lasttab, e, hash, INSERT);
-      if (p == NULL)
-       goto alloc_failure;
-      if (*p)
-       {
-         struct sec_merge_hash_entry *ent;
-
-         ent = (struct sec_merge_hash_entry *) *p;
-         e->u.suffix = ent;
-         e->alignment = 0;
-       }
-      else
-       *p = (PTR) e;

     }
 
     }
 

-alloc_failure:
-  if (array)
-    free (array);
-  if (lasttab)
-    htab_delete (lasttab);
-  if (last4tab)
-    htab_delete (last4tab);
+  free (array);

 
   /* Now assign positions to the strings we want to keep.  */
   size = 0;
 
   /* Now assign positions to the strings we want to keep.  */
   size = 0;


@@ -728,14 +694,14 @@ alloc_failure:
     {
       if (e->secinfo != secinfo)
        {
     {
       if (e->secinfo != secinfo)
        {

-         secinfo->sec->_cooked_size = size;
+         secinfo->sec->size = size;

          secinfo = e->secinfo;
        }
       if (e->alignment)
        {
          secinfo = e->secinfo;
        }
       if (e->alignment)
        {

-         if (e->secinfo->first == NULL)
+         if (e->secinfo->first_str == NULL)

            {
            {

-             e->secinfo->first = e;
+             e->secinfo->first_str = e;

              size = 0;
            }
          size = (size + e->alignment - 1) & ~((bfd_vma) e->alignment - 1);
              size = 0;
            }
          size = (size + e->alignment - 1) & ~((bfd_vma) e->alignment - 1);


@@ -743,7 +709,7 @@ alloc_failure:
          size += e->len;
        }
     }
          size += e->len;
        }
     }

-  secinfo->sec->_cooked_size = size;
+  secinfo->sec->size = size;

 
   /* And now adjust the rest, removing them from the chain (but not hashtable)
      at the same time.  */
 
   /* And now adjust the rest, removing them from the chain (but not hashtable)
      at the same time.  */


@@ -760,22 +726,24 @@ alloc_failure:
            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);
          }
       }

+  return secinfo;

 }
 
 /* This function is called once after all SEC_MERGE sections are registered
    with _bfd_merge_section.  */
 
 }
 
 /* This function is called once after all SEC_MERGE sections are registered
    with _bfd_merge_section.  */
 

-boolean
-_bfd_merge_sections (abfd, xsinfo, remove_hook)
-     bfd *abfd ATTRIBUTE_UNUSED;
-     PTR xsinfo;
-     void (*remove_hook) PARAMS((bfd *, asection *));
+bfd_boolean
+_bfd_merge_sections (bfd *abfd,
+                    struct bfd_link_info *info ATTRIBUTE_UNUSED,
+                    void *xsinfo,
+                    void (*remove_hook) (bfd *, asection *))

 {
   struct sec_merge_info *sinfo;
 
   for (sinfo = (struct sec_merge_info *) xsinfo; sinfo; sinfo = sinfo->next)
     {
 {
   struct sec_merge_info *sinfo;
 
   for (sinfo = (struct sec_merge_info *) xsinfo; sinfo; sinfo = sinfo->next)
     {

-      struct sec_merge_sec_info * secinfo;
+      struct sec_merge_sec_info *secinfo;
+      bfd_size_type align;  /* Bytes.  */

 
       if (! sinfo->chain)
        continue;
 
       if (! sinfo->chain)
        continue;


@@ -786,6 +754,7 @@ _bfd_merge_sections (abfd, xsinfo, remove_hook)
       secinfo->next = NULL;
 
       /* Record the sections into the hash table.  */
       secinfo->next = NULL;
 
       /* Record the sections into the hash table.  */

+      align = 1;

       for (secinfo = sinfo->chain; secinfo; secinfo = secinfo->next)
        if (secinfo->sec->flags & SEC_EXCLUDE)
          {
       for (secinfo = sinfo->chain; secinfo; secinfo = secinfo->next)
        if (secinfo->sec->flags & SEC_EXCLUDE)
          {


@@ -793,77 +762,111 @@ _bfd_merge_sections (abfd, xsinfo, remove_hook)
            if (remove_hook)
              (*remove_hook) (abfd, secinfo->sec);
          }
            if (remove_hook)
              (*remove_hook) (abfd, secinfo->sec);
          }

-       else if (! record_section (sinfo, secinfo))
-         break;
-
-      if (secinfo)
-       continue;
+       else
+         {
+           if (!record_section (sinfo, secinfo))
+             return FALSE;
+           if (align)
+             {
+               unsigned int opb = bfd_octets_per_byte (abfd, secinfo->sec);
+
+               align = (bfd_size_type) 1 << secinfo->sec->alignment_power;
+               if (((secinfo->sec->size / opb) & (align - 1)) != 0)
+                 align = 0;
+             }
+         }

 
       if (sinfo->htab->first == NULL)
        continue;
 
       if (sinfo->htab->strings)
 
       if (sinfo->htab->first == NULL)
        continue;
 
       if (sinfo->htab->strings)

-       merge_strings (sinfo);
+       {
+         secinfo = merge_strings (sinfo);
+         if (!secinfo)
+           return FALSE;
+       }

       else
        {
          struct sec_merge_hash_entry *e;
       else
        {
          struct sec_merge_hash_entry *e;

-         bfd_size_type size = 0;
+         bfd_size_type size = 0;  /* Octets.  */

 
          /* Things are much simpler for non-strings.
             Just assign them slots in the section.  */
          secinfo = NULL;
          for (e = sinfo->htab->first; e; e = e->next)
            {
 
          /* Things are much simpler for non-strings.
             Just assign them slots in the section.  */
          secinfo = NULL;
          for (e = sinfo->htab->first; e; e = e->next)
            {

-             if (e->secinfo->first == NULL)
+             if (e->secinfo->first_str == NULL)

                {
                  if (secinfo)
                {
                  if (secinfo)

-                   secinfo->sec->_cooked_size = size;
-                 e->secinfo->first = e;
+                   secinfo->sec->size = size;
+                 e->secinfo->first_str = e;

                  size = 0;
                }
                  size = 0;
                }

-             size = (size + e->alignment - 1)
-                    & ~((bfd_vma) e->alignment - 1);
+             size = (size + e->alignment - 1) & ~((bfd_vma) e->alignment - 1);

              e->u.index = size;
              size += e->len;
              secinfo = e->secinfo;
            }
              e->u.index = size;
              size += e->len;
              secinfo = e->secinfo;
            }

-         secinfo->sec->_cooked_size = size;
+         secinfo->sec->size = size;

        }
 
        }
 

-       /* Finally shrink all input sections which have not made it into
-          the hash table at all.  */
-       for (secinfo = sinfo->chain; secinfo; secinfo = secinfo->next)
-         if (secinfo->first == NULL)
-           secinfo->sec->_cooked_size = 0;
+      /* If the input sections were padded according to their alignments,
+        then pad the output too.  */
+      if (align)
+       secinfo->sec->size = (secinfo->sec->size + align - 1) & -align;
+
+      /* Finally remove all input sections which have not made it into
+        the hash table at all.  */
+      for (secinfo = sinfo->chain; secinfo; secinfo = secinfo->next)
+       if (secinfo->first_str == NULL)
+         secinfo->sec->flags |= SEC_EXCLUDE | SEC_KEEP;

     }
 
     }
 

-  return true;
+  return TRUE;

 }
 
 /* Write out the merged section.  */
 
 }
 
 /* Write out the merged section.  */
 

-boolean
-_bfd_write_merged_section (output_bfd, sec, psecinfo)
-     bfd *output_bfd;
-     asection *sec;
-     PTR psecinfo;
+bfd_boolean
+_bfd_write_merged_section (bfd *output_bfd, asection *sec, void *psecinfo)

 {
   struct sec_merge_sec_info *secinfo;
   file_ptr pos;
 {
   struct sec_merge_sec_info *secinfo;
   file_ptr pos;

+  unsigned char *contents;
+  Elf_Internal_Shdr *hdr;

 
   secinfo = (struct sec_merge_sec_info *) psecinfo;
 
 
   secinfo = (struct sec_merge_sec_info *) psecinfo;
 

-  if (!secinfo->first)
-    return true;
+  if (!secinfo)
+    return FALSE;

 
 

-  pos = sec->output_section->filepos + sec->output_offset;
-  if (bfd_seek (output_bfd, pos, SEEK_SET) != 0)
-    return false;
+  if (secinfo->first_str == NULL)
+    return TRUE;

 
 

-  if (! sec_merge_emit (output_bfd, secinfo->first))
-    return false;
+  /* FIXME: octets_per_byte.  */
+  hdr = &elf_section_data (sec->output_section)->this_hdr;
+  if (hdr->sh_offset == (file_ptr) -1)
+    {
+      /* We must compress this section.  Write output to the
+        buffer.  */
+      contents = hdr->contents;
+      if ((sec->output_section->flags & SEC_ELF_COMPRESS) == 0
+         || contents == NULL)
+       abort ();
+    }
+  else
+    {
+      contents = NULL;
+      pos = sec->output_section->filepos + sec->output_offset;
+      if (bfd_seek (output_bfd, pos, SEEK_SET) != 0)
+       return FALSE;
+    }
+
+  if (! sec_merge_emit (output_bfd, secinfo->first_str, contents,
+                       sec->output_offset))
+    return FALSE;

 
 

-  return true;
+  return TRUE;

 }
 
 /* Adjust an address in the SEC_MERGE section.  Given OFFSET within
 }
 
 /* Adjust an address in the SEC_MERGE section.  Given OFFSET within


@@ -871,11 +874,8 @@ _bfd_write_merged_section (output_bfd, sec, psecinfo)
    section and writes the new section back into *PSEC.  */
 
 bfd_vma
    section and writes the new section back into *PSEC.  */
 
 bfd_vma

-_bfd_merged_section_offset (output_bfd, psec, psecinfo, offset, addend)
-     bfd *output_bfd ATTRIBUTE_UNUSED;
-     asection **psec;
-     PTR psecinfo;
-     bfd_vma offset, addend;
+_bfd_merged_section_offset (bfd *output_bfd ATTRIBUTE_UNUSED, asection **psec,
+                           void *psecinfo, bfd_vma offset)

 {
   struct sec_merge_sec_info *secinfo;
   struct sec_merge_hash_entry *entry;
 {
   struct sec_merge_sec_info *secinfo;
   struct sec_merge_hash_entry *entry;


@@ -884,30 +884,31 @@ _bfd_merged_section_offset (output_bfd, psec, psecinfo, offset, addend)
 
   secinfo = (struct sec_merge_sec_info *) psecinfo;
 
 
   secinfo = (struct sec_merge_sec_info *) psecinfo;
 

-  if (offset + addend >= sec->_raw_size)
+  if (!secinfo)
+    return offset;
+
+  if (offset >= sec->rawsize)

     {
     {

-      if (offset + addend > sec->_raw_size)
-       {
-         (*_bfd_error_handler)
-           (_("%s: access beyond end of merged section (%ld + %ld)"),
-            bfd_get_filename (sec->owner), (long) offset, (long) addend);
-       }
-      return (secinfo->first ? sec->_cooked_size : 0);
+      if (offset > sec->rawsize)
+       _bfd_error_handler
+         /* xgettext:c-format */
+         (_("%pB: access beyond end of merged section (%" PRId64 ")"),
+          sec->owner, (int64_t) offset);
+      return secinfo->first_str ? sec->size : 0;

     }
 
   if (secinfo->htab->strings)
     {
       if (sec->entsize == 1)
        {
     }
 
   if (secinfo->htab->strings)
     {
       if (sec->entsize == 1)
        {

-         p = secinfo->contents + offset + addend - 1;
+         p = secinfo->contents + offset - 1;

          while (p >= secinfo->contents && *p)
            --p;
          ++p;
        }
       else
        {
          while (p >= secinfo->contents && *p)
            --p;
          ++p;
        }
       else
        {

-         p = secinfo->contents
-             + ((offset + addend) / sec->entsize) * sec->entsize;
+         p = secinfo->contents + (offset / sec->entsize) * sec->entsize;

          p -= sec->entsize;
          while (p >= secinfo->contents)
            {
          p -= sec->entsize;
          while (p >= secinfo->contents)
            {


@@ -925,10 +926,9 @@ _bfd_merged_section_offset (output_bfd, psec, psecinfo, offset, addend)
     }
   else
     {
     }
   else
     {

-      p = secinfo->contents
-         + ((offset + addend) / sec->entsize) * sec->entsize;
+      p = secinfo->contents + (offset / sec->entsize) * sec->entsize;

     }
     }

-  entry = sec_merge_hash_lookup (secinfo->htab, p, 0, false);
+  entry = sec_merge_hash_lookup (secinfo->htab, (char *) p, 0, FALSE);

   if (!entry)
     {
       if (! secinfo->htab->strings)
   if (!entry)
     {
       if (! secinfo->htab->strings)


@@ -940,11 +940,24 @@ _bfd_merged_section_offset (output_bfd, psec, psecinfo, offset, addend)
       if (! secinfo->htab->first)
        abort ();
       entry = secinfo->htab->first;
       if (! secinfo->htab->first)
        abort ();
       entry = secinfo->htab->first;

-      p = secinfo->contents
-         + ((offset + addend) / sec->entsize + 1) * sec->entsize
-         - entry->len;
+      p = (secinfo->contents + (offset / sec->entsize + 1) * sec->entsize
+          - entry->len);

     }
 
   *psec = entry->secinfo->sec;
   return entry->u.index + (secinfo->contents + offset - p);
 }
     }
 
   *psec = entry->secinfo->sec;
   return entry->u.index + (secinfo->contents + offset - p);
 }

+
+/* Tidy up when done.  */
+
+void
+_bfd_merge_sections_free (void *xsinfo)
+{
+  struct sec_merge_info *sinfo;
+
+  for (sinfo = (struct sec_merge_info *) xsinfo; sinfo; sinfo = sinfo->next)
+    {
+      bfd_hash_table_free (&sinfo->htab->table);
+      free (sinfo->htab);
+    }
+}