dwarf2.c stash->sec_info_ptr and stash->sec

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

diff --git a/bfd/merge.c b/bfd/merge.c
index 6b367b5734a1bc85563bc0ef37ab27f7b9a50209..11be669c2c38057c546698cf18731c41b3c1efa3 100644 (file)
--- a/bfd/merge.c
+++ b/bfd/merge.c
@@ -1,12 +1,12 @@
 /* SEC_MERGE support.
 /* SEC_MERGE support.

-   Copyright 2001, 2002, 2003 Free Software Foundation, Inc.
+   Copyright (C) 2001-2019 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"


@@ -105,7 +109,8 @@ sec_merge_hash_newfunc (struct bfd_hash_entry *entry,
   /* Allocate the structure if it has not already been allocated by a
      subclass.  */
   if (entry == NULL)
   /* Allocate the structure if it has not already been allocated by a
      subclass.  */
   if (entry == NULL)

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

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


@@ -132,12 +137,12 @@ static struct sec_merge_hash_entry *
 sec_merge_hash_lookup (struct sec_merge_hash *table, const char *string,
                       unsigned int alignment, bfd_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;


@@ -188,8 +193,8 @@ sec_merge_hash_lookup (struct sec_merge_hash *table, const char *string,
       len = table->entsize;
     }
 
       len = table->entsize;
     }
 

-  index = hash % table->table.size;
-  for (hashp = (struct sec_merge_hash_entry *) table->table.table[index];
+  _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)
     {
        hashp != NULL;
        hashp = (struct sec_merge_hash_entry *) hashp->root.next)
     {


@@ -217,16 +222,11 @@ sec_merge_hash_lookup (struct sec_merge_hash *table, const char *string,
     return NULL;
 
   hashp = ((struct sec_merge_hash_entry *)
     return NULL;
 
   hashp = ((struct sec_merge_hash_entry *)

-          sec_merge_hash_newfunc (NULL, &table->table, string));
+          bfd_hash_insert (&table->table, string, hash));

   if (hashp == NULL)
     return NULL;
   if (hashp == NULL)
     return NULL;

-  hashp->root.string = string;
-  hashp->root.hash = hash;

   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;
 }
 
   return hashp;
 }
 


@@ -237,11 +237,12 @@ sec_merge_init (unsigned int entsize, bfd_boolean strings)
 {
   struct sec_merge_hash *table;
 
 {
   struct sec_merge_hash *table;
 

-  table = bfd_malloc (sizeof (struct sec_merge_hash));
+  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;


@@ -263,7 +264,7 @@ static struct sec_merge_hash_entry *
 sec_merge_add (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);
   if (entry == NULL)
 
   entry = sec_merge_hash_lookup (tab, str, alignment, TRUE);
   if (entry == NULL)


@@ -284,44 +285,74 @@ sec_merge_add (struct sec_merge_hash *tab, const char *str,
 }
 
 static bfd_boolean
 }
 
 static bfd_boolean

-sec_merge_emit (bfd *abfd, struct sec_merge_hash_entry *entry)
+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;
   int alignment_power = sec->output_section->alignment_power;
   bfd_size_type off = 0;
   int alignment_power = sec->output_section->alignment_power;

+  bfd_size_type pad_len;
+
+  /* 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;

 
 

-  if (alignment_power)
-    pad = bfd_zmalloc ((bfd_size_type) 1 << alignment_power);
+  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 (pad, 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 (str, 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;

 }
 
 /* Register a SEC_MERGE section as a candidate for merging.
 }
 
 /* Register a SEC_MERGE section as a candidate for merging.


@@ -335,28 +366,38 @@ _bfd_add_merge_section (bfd *abfd, void **psinfo, asection *sec,
   struct sec_merge_sec_info *secinfo;
   unsigned int align;
   bfd_size_type amt;
   struct sec_merge_sec_info *secinfo;
   unsigned int align;
   bfd_size_type amt;

+  bfd_byte *contents;

 
   if ((abfd->flags & DYNAMIC) != 0
       || (sec->flags & SEC_MERGE) == 0)
     abort ();
 
 
   if ((abfd->flags & DYNAMIC) != 0
       || (sec->flags & SEC_MERGE) == 0)
     abort ();
 

-  if (sec->_raw_size == 0
+  if (sec->size == 0

       || (sec->flags & SEC_EXCLUDE) != 0
       || sec->entsize == 0)
     return TRUE;
 
       || (sec->flags & SEC_EXCLUDE) != 0
       || sec->entsize == 0)
     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.  */
       return TRUE;
     }
 
   if ((sec->flags & SEC_RELOC) != 0)
     {
       /* We aren't prepared to handle relocations in merged sections.  */
       return TRUE;
     }
 

-  align = sec->alignment_power;
-  if ((sec->entsize < (unsigned) 1 << align
+#ifndef CHAR_BIT
+#define CHAR_BIT 8
+#endif
+  if (sec->alignment_power >= sizeof (align) * CHAR_BIT)
+    return TRUE;
+
+  align = 1u << sec->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) 1 << align
-         && (sec->entsize & (((unsigned) 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


@@ -378,7 +419,8 @@ _bfd_add_merge_section (bfd *abfd, void **psinfo, asection *sec,
   if (sinfo == NULL)
     {
       /* Initialize the information we need to keep track of.  */
   if (sinfo == NULL)
     {
       /* Initialize the information we need to keep track of.  */

-      sinfo = bfd_alloc (abfd, sizeof (struct sec_merge_info));
+      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;
       if (sinfo == NULL)
        goto error_return;
       sinfo->next = (struct sec_merge_info *) *psinfo;


@@ -391,7 +433,12 @@ _bfd_add_merge_section (bfd *abfd, void **psinfo, asection *sec,
 
   /* 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;


@@ -410,8 +457,11 @@ _bfd_add_merge_section (bfd *abfd, void **psinfo, asection *sec,
   secinfo->htab = sinfo->htab;
   secinfo->first_str = NULL;
 
   secinfo->htab = sinfo->htab;
   secinfo->first_str = NULL;
 

-  if (! bfd_get_section_contents (sec->owner, sec, secinfo->contents,
-                                 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;
 
   return TRUE;
     goto error_return;
 
   return TRUE;


@@ -434,7 +484,7 @@ record_section (struct sec_merge_info *sinfo,
   unsigned int align, i;
 
   align = sec->alignment_power;
   unsigned int align, i;
 
   align = sec->alignment_power;

-  end = secinfo->contents + sec->_raw_size;
+  end = secinfo->contents + sec->size;

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


@@ -445,7 +495,8 @@ record_section (struct sec_merge_info *sinfo,
          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;


@@ -476,7 +527,7 @@ record_section (struct sec_merge_info *sinfo,
                  if (!nul && !((p - secinfo->contents) & mask))
                    {
                      nul = TRUE;
                  if (!nul && !((p - secinfo->contents) & mask))
                    {
                      nul = TRUE;

-                     entry = sec_merge_add (sinfo->htab, p,
+                     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;


@@ -490,7 +541,7 @@ record_section (struct sec_merge_info *sinfo,
     {
       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;
        }


@@ -504,6 +555,9 @@ error_return:
   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)
 {
 static int
 strrevcmp (const void *a, const void *b)
 {


@@ -511,8 +565,8 @@ strrevcmp (const void *a, const void *b)
   struct sec_merge_hash_entry *B = *(struct sec_merge_hash_entry **) b;
   unsigned int lenA = A->len;
   unsigned int lenB = B->len;
   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 = A->root.string + lenA - 1;
-  const unsigned char *t = B->root.string + lenB - 1;
+  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)
   int l = lenA < lenB ? lenA : lenB;
 
   while (l)


@@ -536,8 +590,8 @@ strrevcmp_align (const void *a, const void *b)
   struct sec_merge_hash_entry *B = *(struct sec_merge_hash_entry **) b;
   unsigned int lenA = A->len;
   unsigned int lenB = B->len;
   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 = A->root.string + lenA - 1;
-  const unsigned char *t = B->root.string + lenB - 1;
+  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));
 
   int l = lenA < lenB ? lenA : lenB;
   int tail_align = (lenA & (A->alignment - 1)) - (lenB & (A->alignment - 1));
 


@@ -570,7 +624,7 @@ is_suffix (const struct sec_merge_hash_entry *A,
 
 /* 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
+static struct sec_merge_sec_info *

 merge_strings (struct sec_merge_info *sinfo)
 {
   struct sec_merge_hash_entry **array, **a, *e;
 merge_strings (struct sec_merge_info *sinfo)
 {
   struct sec_merge_hash_entry **array, **a, *e;


@@ -580,9 +634,9 @@ merge_strings (struct sec_merge_info *sinfo)
 
   /* Now sort the strings */
   amt = sinfo->htab->size * sizeof (struct sec_merge_hash_entry *);
 
   /* Now sort the strings */
   amt = sinfo->htab->size * sizeof (struct sec_merge_hash_entry *);

-  array = bfd_malloc (amt);
+  array = (struct sec_merge_hash_entry **) bfd_malloc (amt);

   if (array == NULL)
   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)


@@ -627,9 +681,7 @@ merge_strings (struct sec_merge_info *sinfo)
        }
     }
 
        }
     }
 

-alloc_failure:
-  if (array)
-    free (array);
+  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;


@@ -638,7 +690,7 @@ 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)


@@ -653,7 +705,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.  */


@@ -670,20 +722,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.  */
 
 bfd_boolean
 }
 
 /* This function is called once after all SEC_MERGE sections are registered
    with _bfd_merge_section.  */
 
 bfd_boolean

-_bfd_merge_sections (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_link_info *info,
-                    void *xsinfo, void (*remove_hook) (bfd *, asection *))
+_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;

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


@@ -694,6 +750,7 @@ _bfd_merge_sections (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_link_info *info,
       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)
          {


@@ -701,17 +758,27 @@ _bfd_merge_sections (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_link_info *info,
            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)
+             {
+               align = (bfd_size_type) 1 << secinfo->sec->alignment_power;
+               if ((secinfo->sec->size & (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;


@@ -725,24 +792,28 @@ _bfd_merge_sections (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_link_info *info,
              if (e->secinfo->first_str == NULL)
                {
                  if (secinfo)
              if (e->secinfo->first_str == NULL)
                {
                  if (secinfo)

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

                  e->secinfo->first_str = e;
                  size = 0;
                }
                  e->secinfo->first_str = e;
                  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 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)
-           _bfd_strip_section_from_output (info, secinfo->sec);
+      /* 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;


@@ -755,17 +826,38 @@ _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)
+    return FALSE;
+

   if (secinfo->first_str == NULL)
     return TRUE;
 
   if (secinfo->first_str == NULL)
     return TRUE;
 

-  pos = sec->output_section->filepos + sec->output_offset;
-  if (bfd_seek (output_bfd, pos, SEEK_SET) != 0)
-    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))
+  if (! sec_merge_emit (output_bfd, secinfo->first_str, contents,
+                       sec->output_offset))

     return FALSE;
 
   return TRUE;
     return FALSE;
 
   return TRUE;


@@ -786,15 +878,17 @@ _bfd_merged_section_offset (bfd *output_bfd ATTRIBUTE_UNUSED, asection **psec,
 
   secinfo = (struct sec_merge_sec_info *) psecinfo;
 
 
   secinfo = (struct sec_merge_sec_info *) psecinfo;
 

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

     {
     {

-      if (offset > sec->_raw_size)
-       {
-         (*_bfd_error_handler)
-           (_("%s: access beyond end of merged section (%ld)"),
-            bfd_get_filename (sec->owner), (long) offset);
-       }
-      return (secinfo->first_str ? 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 (secinfo->htab->strings)


@@ -828,7 +922,7 @@ _bfd_merged_section_offset (bfd *output_bfd ATTRIBUTE_UNUSED, asection **psec,
     {
       p = secinfo->contents + (offset / 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)


@@ -847,3 +941,17 @@ _bfd_merged_section_offset (bfd *output_bfd ATTRIBUTE_UNUSED, asection **psec,
   *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);
+    }
+}