Changeset 1973 for binutils/trunk/bfd/elf.c

Timestamp:

Feb 6, 2017, 1:00:00 PM (8 years ago)

Author:

Silvan Scherrer

Message:

binutils: update trunk to version 2.27

Location:

binutils/trunk

Files:

• . (modified) (1 prop)
• bfd/elf.c (modified) (129 diffs)

binutils/trunk/bfd/elf.c ¶

@@ -1 +1 @@
 /* ELF executable support for BFD.
 
-   Copyright (C) 1993-2014 Free Software Foundation, Inc.
+   Copyright (C) 1993-2016 Free Software Foundation, Inc.
 
    This file is part of BFD, the Binary File Descriptor library.
@@ -43 +43 @@
 #include "libiberty.h"
 #include "safe-ctype.h"
-#include "elf-linux-psinfo.h"
+#include "elf-linux-core.h"
 
 #ifdef CORE_HEADER
@@ -52 +52 @@
 static bfd_boolean assign_file_positions_except_relocs (bfd *, struct bfd_link_info *);
 static bfd_boolean prep_headers (bfd *);
-static bfd_boolean swap_out_syms (bfd *, struct bfd_strtab_hash **, int) ;
+static bfd_boolean swap_out_syms (bfd *, struct elf_strtab_hash **, int) ;
 static bfd_boolean elf_read_notes (bfd *, file_ptr, bfd_size_type) ;
 static bfd_boolean elf_parse_notes (bfd *abfd, char *buf, size_t size,
@@ -298 +298 @@
          in case the string table is not terminated.  */
       if (shstrtabsize + 1 <= 1
-          || (shstrtab = (bfd_byte *) bfd_alloc (abfd, shstrtabsize + 1)) == NULL
-          || bfd_seek (abfd, offset, SEEK_SET) != 0)
+          || bfd_seek (abfd, offset, SEEK_SET) != 0
+          || (shstrtab = (bfd_byte *) bfd_alloc (abfd, shstrtabsize + 1)) == NULL)
         shstrtab = NULL;
       else if (bfd_bread (shstrtab, shstrtabsize, abfd) != shstrtabsize)
@@ -305 +305 @@
           if (bfd_get_error () != bfd_error_system_call)
             bfd_set_error (bfd_error_file_truncated);
+          bfd_release (abfd, shstrtab);
           shstrtab = NULL;
           /* Once we've failed to read it, make sure we don't keep
@@ -333 +334 @@
   hdr = elf_elfsections (abfd)[shindex];
 
-  if (hdr->contents == NULL
-      && bfd_elf_get_str_section (abfd, shindex) == NULL)
-    return NULL;
+  if (hdr->contents == NULL)
+    {
+      if (hdr->sh_type != SHT_STRTAB && hdr->sh_type < SHT_LOOS)
+        {
+          /* PR 17512: file: f057ec89.  */
+          _bfd_error_handler (_("%B: attempt to load strings from a non-string section (number %d)"),
+                              abfd, shindex);
+          return NULL;
+        }
+
+      if (bfd_elf_get_str_section (abfd, shindex) == NULL)
+        return NULL;
+    }
 
   if (strindex >= hdr->sh_size)
@@ -390 +401 @@
   /* Normal syms might have section extension entries.  */
   shndx_hdr = NULL;
-  if (symtab_hdr == &elf_tdata (ibfd)->symtab_hdr)
-    shndx_hdr = &elf_tdata (ibfd)->symtab_shndx_hdr;
+  if (elf_symtab_shndx_list (ibfd) != NULL)
+    {
+      elf_section_list * entry;
+      Elf_Internal_Shdr **sections = elf_elfsections (ibfd);
+
+      /* Find an index section that is linked to this symtab section.  */
+      for (entry = elf_symtab_shndx_list (ibfd); entry != NULL; entry = entry->next)
+        {
+          /* PR 20063.  */
+          if (entry->hdr.sh_link >= elf_numsections (ibfd))
+            continue;
+
+          if (sections[entry->hdr.sh_link] == symtab_hdr)
+            {
+              shndx_hdr = & entry->hdr;
+              break;
+            };
+        }
+
+      if (shndx_hdr == NULL)
+        {
+          if (symtab_hdr == & elf_symtab_hdr (ibfd))
+            /* Not really accurate, but this was how the old code used to work.  */
+            shndx_hdr = & elf_symtab_shndx_list (ibfd)->hdr;
+          /* Otherwise we do nothing.  The assumption is that
+             the index table will not be needed.  */
+        }
+    }
 
   /* Read the symbols.  */
@@ -399 +436 @@
   bed = get_elf_backend_data (ibfd);
   extsym_size = bed->s->sizeof_sym;
-  amt = symcount * extsym_size;
+  amt = (bfd_size_type) symcount * extsym_size;
   pos = symtab_hdr->sh_offset + symoffset * extsym_size;
   if (extsym_buf == NULL)
@@ -418 +455 @@
   else
     {
-      amt = symcount * sizeof (Elf_External_Sym_Shndx);
+      amt = (bfd_size_type) symcount * sizeof (Elf_External_Sym_Shndx);
       pos = shndx_hdr->sh_offset + symoffset * sizeof (Elf_External_Sym_Shndx);
       if (extshndx_buf == NULL)
@@ -637 +674 @@
                   src = shdr->contents + shdr->sh_size;
                   dest = (Elf_Internal_Group *) (shdr->contents + amt);
+
                   while (1)
                     {
@@ -806 +844 @@
     {
       Elf_Internal_Shdr *shdr = elf_tdata (abfd)->group_sect_ptr[i];
-      Elf_Internal_Group *idx = (Elf_Internal_Group *) shdr->contents;
-      unsigned int n_elt = shdr->sh_size / 4;
+      Elf_Internal_Group *idx;
+      unsigned int n_elt;
+
+      /* PR binutils/18758: Beware of corrupt binaries with invalid group data.  */
+      if (shdr == NULL || shdr->bfd_section == NULL || shdr->contents == NULL)
+        {
+          (*_bfd_error_handler)
+            (_("%B: section group entry number %u is corrupt"),
+             abfd, i);
+          result = FALSE;
+          continue;
+        }
+
+      idx = (Elf_Internal_Group *) shdr->contents;
+      n_elt = shdr->sh_size / 4;
 
       while (--n_elt != 0)
@@ -844 +895 @@
 }
 
+static char *
+convert_debug_to_zdebug (bfd *abfd, const char *name)
+{
+  unsigned int len = strlen (name);
+  char *new_name = bfd_alloc (abfd, len + 2);
+  if (new_name == NULL)
+    return NULL;
+  new_name[0] = '.';
+  new_name[1] = 'z';
+  memcpy (new_name + 2, name + 1, len);
+  return new_name;
+}
+
+static char *
+convert_zdebug_to_debug (bfd *abfd, const char *name)
+{
+  unsigned int len = strlen (name);
+  char *new_name = bfd_alloc (abfd, len);
+  if (new_name == NULL)
+    return NULL;
+  new_name[0] = '.';
+  memcpy (new_name + 1, name + 2, len - 1);
+  return new_name;
+}
+
 /* Make a BFD section from an ELF section.  We store a pointer to the
    BFD section in the bfd_section field of the header.  */
@@ -901 +977 @@
       flags |= SEC_MERGE;
       newsect->entsize = hdr->sh_entsize;
-      if ((hdr->sh_flags & SHF_STRINGS) != 0)
-        flags |= SEC_STRINGS;
-    }
+    }
+  if ((hdr->sh_flags & SHF_STRINGS) != 0)
+    flags |= SEC_STRINGS;
   if (hdr->sh_flags & SHF_GROUP)
     if (!setup_group (abfd, hdr, newsect))
@@ -1030 +1106 @@
     {
       enum { nothing, compress, decompress } action = nothing;
-      char *new_name;
-
-      if (bfd_is_section_compressed (abfd, newsect))
+      int compression_header_size;
+      bfd_size_type uncompressed_size;
+      bfd_boolean compressed
+        = bfd_is_section_compressed_with_header (abfd, newsect,
+                                                 &compression_header_size,
+                                                 &uncompressed_size);
+
+      if (compressed)
         {
           /* Compressed section.  Check if we should decompress.  */
@@ -1038 +1119 @@
             action = decompress;
         }
-      else
-        {
-          /* Normal section.  Check if we should compress.  */
-          if ((abfd->flags & BFD_COMPRESS) && newsect->size != 0)
+
+      /* Compress the uncompressed section or convert from/to .zdebug*
+         section.  Check if we should compress.  */
+      if (action == nothing)
+        {
+          if (newsect->size != 0
+              && (abfd->flags & BFD_COMPRESS)
+              && compression_header_size >= 0
+              && uncompressed_size > 0
+              && (!compressed
+                  || ((compression_header_size > 0)
+                      != ((abfd->flags & BFD_COMPRESS_GABI) != 0))))
             action = compress;
-        }
-
-      new_name = NULL;
-      switch (action)
-        {
-        case nothing:
-          break;
-        case compress:
+          else
+            return TRUE;
+        }
+
+      if (action == compress)
+        {
           if (!bfd_init_section_compress_status (abfd, newsect))
             {
@@ -1058 +1145 @@
               return FALSE;
             }
-          if (name[1] != 'z')
-            {
-              unsigned int len = strlen (name);
-
-              new_name = bfd_alloc (abfd, len + 2);
-              if (new_name == NULL)
-                return FALSE;
-              new_name[0] = '.';
-              new_name[1] = 'z';
-              memcpy (new_name + 2, name + 1, len);
-            }
-          break;
-        case decompress:
+        }
+      else
+        {
           if (!bfd_init_section_decompress_status (abfd, newsect))
             {
@@ -1078 +1155 @@
               return FALSE;
             }
-          if (name[1] == 'z')
+        }
+
+      if (abfd->is_linker_input)
+        {
+          if (name[1] == 'z'
+              && (action == decompress
+                  || (action == compress
+                      && (abfd->flags & BFD_COMPRESS_GABI) != 0)))
             {
-              unsigned int len = strlen (name);
-
-              new_name = bfd_alloc (abfd, len);
+              /* Convert section name from .zdebug_* to .debug_* so
+                 that linker will consider this section as a debug
+                 section.  */
+              char *new_name = convert_zdebug_to_debug (abfd, name);
               if (new_name == NULL)
                 return FALSE;
-              new_name[0] = '.';
-              memcpy (new_name + 1, name + 2, len - 1);
+              bfd_rename_section (abfd, newsect, new_name);
             }
-          break;
-        }
-      if (new_name != NULL)
-        bfd_rename_section (abfd, newsect, new_name);
+        }
+      else
+        /* For objdump, don't rename the section.  For objcopy, delay
+           section rename to elf_fake_sections.  */
+        newsect->flags |= SEC_ELF_RENAME;
     }
 
@@ -1097 +1182 @@
 }
 
-const char *const bfd_elf_section_type_names[] = {
+const char *const bfd_elf_section_type_names[] =
+{
   "SHT_NULL", "SHT_PROGBITS", "SHT_SYMTAB", "SHT_STRTAB",
   "SHT_RELA", "SHT_HASH", "SHT_DYNAMIC", "SHT_NOTE",
@@ -1135 +1221 @@
 
 
+/* Returns TRUE if section A matches section B.
+   Names, addresses and links may be different, but everything else
+   should be the same.  */
+
+static bfd_boolean
+section_match (const Elf_Internal_Shdr * a,
+               const Elf_Internal_Shdr * b)
+{
+  return
+    a->sh_type         == b->sh_type
+    && (a->sh_flags & ~ SHF_INFO_LINK)
+    == (b->sh_flags & ~ SHF_INFO_LINK)
+    && a->sh_addralign == b->sh_addralign
+    && a->sh_size      == b->sh_size
+    && a->sh_entsize   == b->sh_entsize
+    /* FIXME: Check sh_addr ?  */
+    ;
+}
+
+/* Find a section in OBFD that has the same characteristics
+   as IHEADER.  Return the index of this section or SHN_UNDEF if
+   none can be found.  Check's section HINT first, as this is likely
+   to be the correct section.  */
+
+static unsigned int
+find_link (const bfd * obfd, const Elf_Internal_Shdr * iheader, const unsigned int hint)
+{
+  Elf_Internal_Shdr ** oheaders = elf_elfsections (obfd);
+  unsigned int i;
+
+  if (section_match (oheaders[hint], iheader))
+    return hint;
+
+  for (i = 1; i < elf_numsections (obfd); i++)
+    {
+      Elf_Internal_Shdr * oheader = oheaders[i];
+
+      if (section_match (oheader, iheader))
+        /* FIXME: Do we care if there is a potential for
+           multiple matches ?  */
+        return i;
+    }
+
+  return SHN_UNDEF;
+}
+
+/* PR 19938: Attempt to set the ELF section header fields of an OS or
+   Processor specific section, based upon a matching input section.
+   Returns TRUE upon success, FALSE otherwise.  */
+   
+static bfd_boolean
+copy_special_section_fields (const bfd *ibfd,
+                             bfd *obfd,
+                             const Elf_Internal_Shdr *iheader,
+                             Elf_Internal_Shdr *oheader,
+                             const unsigned int secnum)
+{
+  const struct elf_backend_data *bed = get_elf_backend_data (obfd);
+  const Elf_Internal_Shdr **iheaders = (const Elf_Internal_Shdr **) elf_elfsections (ibfd);
+  bfd_boolean changed = FALSE;
+  unsigned int sh_link;
+
+  if (oheader->sh_type == SHT_NOBITS)
+    {
+      /* This is a feature for objcopy --only-keep-debug:
+         When a section's type is changed to NOBITS, we preserve
+         the sh_link and sh_info fields so that they can be
+         matched up with the original.
+
+         Note: Strictly speaking these assignments are wrong.
+         The sh_link and sh_info fields should point to the
+         relevent sections in the output BFD, which may not be in
+         the same location as they were in the input BFD.  But
+         the whole point of this action is to preserve the
+         original values of the sh_link and sh_info fields, so
+         that they can be matched up with the section headers in
+         the original file.  So strictly speaking we may be
+         creating an invalid ELF file, but it is only for a file
+         that just contains debug info and only for sections
+         without any contents.  */
+      if (oheader->sh_link == 0)
+        oheader->sh_link = iheader->sh_link;
+      if (oheader->sh_info == 0)
+        oheader->sh_info = iheader->sh_info;
+      return TRUE;
+    }
+
+  /* Allow the target a chance to decide how these fields should be set.  */
+  if (bed->elf_backend_copy_special_section_fields != NULL
+      && bed->elf_backend_copy_special_section_fields
+      (ibfd, obfd, iheader, oheader))
+    return TRUE;
+
+  /* We have an iheader which might match oheader, and which has non-zero
+     sh_info and/or sh_link fields.  Attempt to follow those links and find
+     the section in the output bfd which corresponds to the linked section
+     in the input bfd.  */
+  if (iheader->sh_link != SHN_UNDEF)
+    {
+      sh_link = find_link (obfd, iheaders[iheader->sh_link], iheader->sh_link);
+      if (sh_link != SHN_UNDEF)
+        {
+          oheader->sh_link = sh_link;
+          changed = TRUE;
+        }
+      else
+        /* FIXME: Should we install iheader->sh_link
+           if we could not find a match ?  */
+        (* _bfd_error_handler)
+          (_("%B: Failed to find link section for section %d"), obfd, secnum);
+    }
+
+  if (iheader->sh_info)
+    {
+      /* The sh_info field can hold arbitrary information, but if the
+         SHF_LINK_INFO flag is set then it should be interpreted as a
+         section index.  */
+      if (iheader->sh_flags & SHF_INFO_LINK)
+        {
+          sh_link = find_link (obfd, iheaders[iheader->sh_info],
+                               iheader->sh_info);
+          if (sh_link != SHN_UNDEF)
+            oheader->sh_flags |= SHF_INFO_LINK;
+        }
+      else
+        /* No idea what it means - just copy it.  */
+        sh_link = iheader->sh_info;
+
+      if (sh_link != SHN_UNDEF)
+        {
+          oheader->sh_info = sh_link;
+          changed = TRUE;
+        }
+      else
+        (* _bfd_error_handler)
+          (_("%B: Failed to find info section for section %d"), obfd, secnum);
+    }
+
+  return changed;
+}
+  
 /* Copy the program header and other data from one object module to
    another.  */
@@ -1141 +1368 @@
 _bfd_elf_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
 {
+  const Elf_Internal_Shdr **iheaders = (const Elf_Internal_Shdr **) elf_elfsections (ibfd);
+  Elf_Internal_Shdr **oheaders = elf_elfsections (obfd);
+  const struct elf_backend_data *bed;
+  unsigned int i;
+
   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
-      || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
+    || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
     return TRUE;
 
@@ -1157 +1389 @@
     elf_elfheader (ibfd)->e_ident[EI_OSABI];
 
+  /* If set, copy the EI_ABIVERSION field.  */
+  if (elf_elfheader (ibfd)->e_ident[EI_ABIVERSION])
+    elf_elfheader (obfd)->e_ident[EI_ABIVERSION]
+      = elf_elfheader (ibfd)->e_ident[EI_ABIVERSION];
+  
   /* Copy object attributes.  */
   _bfd_elf_copy_obj_attributes (ibfd, obfd);
+
+  if (iheaders == NULL || oheaders == NULL)
+    return TRUE;
+
+  bed = get_elf_backend_data (obfd);
+
+  /* Possibly copy other fields in the section header.  */
+  for (i = 1; i < elf_numsections (obfd); i++)
+    {
+      unsigned int j;
+      Elf_Internal_Shdr * oheader = oheaders[i];
+
+      /* Ignore ordinary sections.  SHT_NOBITS sections are considered however
+         because of a special case need for generating separate debug info
+         files.  See below for more details.  */
+      if (oheader == NULL
+          || (oheader->sh_type != SHT_NOBITS
+              && oheader->sh_type < SHT_LOOS))
+        continue;
+
+      /* Ignore empty sections, and sections whose
+         fields have already been initialised.  */
+      if (oheader->sh_size == 0
+          || (oheader->sh_info != 0 && oheader->sh_link != 0))
+        continue;
+
+      /* Scan for the matching section in the input bfd.
+         First we try for a direct mapping between the input and output sections.  */
+      for (j = 1; j < elf_numsections (ibfd); j++)
+        {
+          const Elf_Internal_Shdr * iheader = iheaders[j];
+
+          if (iheader == NULL)
+            continue;
+
+          if (oheader->bfd_section != NULL
+              && iheader->bfd_section != NULL
+              && iheader->bfd_section->output_section != NULL
+              && iheader->bfd_section->output_section == oheader->bfd_section)
+            {
+              /* We have found a connection from the input section to the
+                 output section.  Attempt to copy the header fields.  If
+                 this fails then do not try any further sections - there
+                 should only be a one-to-one mapping between input and output. */
+              if (! copy_special_section_fields (ibfd, obfd, iheader, oheader, i))
+                j = elf_numsections (ibfd);
+              break;
+            }
+        }
+
+      if (j < elf_numsections (ibfd))
+        continue;
+
+      /* That failed.  So try to deduce the corresponding input section.
+         Unfortunately we cannot compare names as the output string table
+         is empty, so instead we check size, address and type.  */
+      for (j = 1; j < elf_numsections (ibfd); j++)
+        {
+          const Elf_Internal_Shdr * iheader = iheaders[j];
+
+          if (iheader == NULL)
+            continue;
+
+          /* Try matching fields in the input section's header.
+             Since --only-keep-debug turns all non-debug sections into
+             SHT_NOBITS sections, the output SHT_NOBITS type matches any
+             input type.  */
+          if ((oheader->sh_type == SHT_NOBITS
+               || iheader->sh_type == oheader->sh_type)
+              && (iheader->sh_flags & ~ SHF_INFO_LINK)
+              == (oheader->sh_flags & ~ SHF_INFO_LINK)
+              && iheader->sh_addralign == oheader->sh_addralign
+              && iheader->sh_entsize == oheader->sh_entsize
+              && iheader->sh_size == oheader->sh_size
+              && iheader->sh_addr == oheader->sh_addr
+              && (iheader->sh_info != oheader->sh_info
+                  || iheader->sh_link != oheader->sh_link))
+            {
+              if (copy_special_section_fields (ibfd, obfd, iheader, oheader, i))
+                break;
+            }
+        }
+
+      if (j == elf_numsections (ibfd) && oheader->sh_type >= SHT_LOOS)
+        {
+          /* Final attempt.  Call the backend copy function
+             with a NULL input section.  */
+          if (bed->elf_backend_copy_special_section_fields != NULL)
+            bed->elf_backend_copy_special_section_fields (ibfd, obfd, NULL, oheader);
+        }
+    }
+
   return TRUE;
 }
@@ -1255 +1584 @@
 
       extdyn = dynbuf;
+      /* PR 17512: file: 6f427532.  */
+      if (s->size < extdynsize)
+        goto error_return;
       extdynend = extdyn + s->size;
-      for (; extdyn < extdynend; extdyn += extdynsize)
+      /* PR 17512: file: id:000006,sig:06,src:000000,op:flip4,pos:5664.
+         Fix range check.  */
+      for (; extdyn <= (extdynend - extdynsize); extdyn += extdynsize)
         {
           Elf_Internal_Dyn dyn;
@@ -1424 +1758 @@
 }
 
+/* Get version string.  */
+
+const char *
+_bfd_elf_get_symbol_version_string (bfd *abfd, asymbol *symbol,
+                                    bfd_boolean *hidden)
+{
+  const char *version_string = NULL;
+  if (elf_dynversym (abfd) != 0
+      && (elf_dynverdef (abfd) != 0 || elf_dynverref (abfd) != 0))
+    {
+      unsigned int vernum = ((elf_symbol_type *) symbol)->version;
+
+      *hidden = (vernum & VERSYM_HIDDEN) != 0;
+      vernum &= VERSYM_VERSION;
+
+      if (vernum == 0)
+        version_string = "";
+      else if (vernum == 1)
+        version_string = "Base";
+      else if (vernum <= elf_tdata (abfd)->cverdefs)
+        version_string =
+          elf_tdata (abfd)->verdef[vernum - 1].vd_nodename;
+      else
+        {
+          Elf_Internal_Verneed *t;
+
+          version_string = "";
+          for (t = elf_tdata (abfd)->verref;
+               t != NULL;
+               t = t->vn_nextref)
+            {
+              Elf_Internal_Vernaux *a;
+
+              for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
+                {
+                  if (a->vna_other == vernum)
+                    {
+                      version_string = a->vna_nodename;
+                      break;
+                    }
+                }
+            }
+        }
+    }
+  return version_string;
+}
+
 /* Display ELF-specific fields of a symbol.  */
 
@@ -1450 +1831 @@
         unsigned char st_other;
         bfd_vma val;
+        const char *version_string;
+        bfd_boolean hidden;
 
         section_name = symbol->section ? symbol->section->name : "(*none*)";
@@ -1475 +1858 @@
 
         /* If we have version information, print it.  */
-        if (elf_dynversym (abfd) != 0
-            && (elf_dynverdef (abfd) != 0
-                || elf_dynverref (abfd) != 0))
+        version_string = _bfd_elf_get_symbol_version_string (abfd,
+                                                             symbol,
+                                                             &hidden);
+        if (version_string)
           {
-            unsigned int vernum;
-            const char *version_string;
-
-            vernum = ((elf_symbol_type *) symbol)->version & VERSYM_VERSION;
-
-            if (vernum == 0)
-              version_string = "";
-            else if (vernum == 1)
-              version_string = "Base";
-            else if (vernum <= elf_tdata (abfd)->cverdefs)
-              version_string =
-                elf_tdata (abfd)->verdef[vernum - 1].vd_nodename;
-            else
-              {
-                Elf_Internal_Verneed *t;
-
-                version_string = "";
-                for (t = elf_tdata (abfd)->verref;
-                     t != NULL;
-                     t = t->vn_nextref)
-                  {
-                    Elf_Internal_Vernaux *a;
-
-                    for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
-                      {
-                        if (a->vna_other == vernum)
-                          {
-                            version_string = a->vna_nodename;
-                            break;
-                          }
-                      }
-                  }
-              }
-
-            if ((((elf_symbol_type *) symbol)->version & VERSYM_HIDDEN) == 0)
+            if (!hidden)
               fprintf (file, "  %-11s", version_string);
             else
@@ -1546 +1896 @@
 }
 
-/* Allocate an ELF string table--force the first byte to be zero.  */
-
-struct bfd_strtab_hash *
-_bfd_elf_stringtab_init (void)
-{
-  struct bfd_strtab_hash *ret;
-
-  ret = _bfd_stringtab_init ();
-  if (ret != NULL)
-    {
-      bfd_size_type loc;
-
-      loc = _bfd_stringtab_add (ret, "", TRUE, FALSE);
-      BFD_ASSERT (loc == 0 || loc == (bfd_size_type) -1);
-      if (loc == (bfd_size_type) -1)
-        {
-          _bfd_stringtab_free (ret);
-          ret = NULL;
-        }
-    }
-  return ret;
-}
-
 
 /* ELF .o/exec file reading */
@@ -1592 +1919 @@
     {
       /* PR17512: A corrupt ELF binary might contain a recursive group of
-         sections, each the string indicies pointing to the next in the
+         sections, with each the string indicies pointing to the next in the
          loop.  Detect this here, by refusing to load a section that we are
          already in the process of loading.  We only trigger this test if
@@ -1715 +2042 @@
         }
 
-      BFD_ASSERT (elf_onesymtab (abfd) == 0);
+      /* PR 18854: A binary might contain more than one symbol table.
+         Unusual, but possible.  Warn, but continue.  */
+      if (elf_onesymtab (abfd) != 0)
+        {
+          (*_bfd_error_handler)
+            (_("%B: warning: multiple symbol tables detected - ignoring the table in section %u"),
+             abfd, shindex);
+          goto success;
+        }
       elf_onesymtab (abfd) = shindex;
-      elf_tdata (abfd)->symtab_hdr = *hdr;
-      elf_elfsections (abfd)[shindex] = hdr = &elf_tdata (abfd)->symtab_hdr;
+      elf_symtab_hdr (abfd) = *hdr;
+      elf_elfsections (abfd)[shindex] = hdr = & elf_symtab_hdr (abfd);
       abfd->flags |= HAS_SYMS;
 
@@ -1736 +2071 @@
          can't read symbols without that section loaded as well.  It
          is most likely specified by the next section header.  */
-      if (elf_elfsections (abfd)[elf_symtab_shndx (abfd)]->sh_link != shindex)
-        {
-          unsigned int i, num_sec;
-
-          num_sec = elf_numsections (abfd);
-          for (i = shindex + 1; i < num_sec; i++)
+      {
+        elf_section_list * entry;
+        unsigned int i, num_sec;
+
+        for (entry = elf_symtab_shndx_list (abfd); entry != NULL; entry = entry->next)
+          if (entry->hdr.sh_link == shindex)
+            goto success;
+
+        num_sec = elf_numsections (abfd);
+        for (i = shindex + 1; i < num_sec; i++)
+          {
+            Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i];
+
+            if (hdr2->sh_type == SHT_SYMTAB_SHNDX
+                && hdr2->sh_link == shindex)
+              break;
+          }
+
+        if (i == num_sec)
+          for (i = 1; i < shindex; i++)
             {
               Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i];
+
               if (hdr2->sh_type == SHT_SYMTAB_SHNDX
                   && hdr2->sh_link == shindex)
                 break;
             }
-          if (i == num_sec)
-            for (i = 1; i < shindex; i++)
-              {
-                Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i];
-                if (hdr2->sh_type == SHT_SYMTAB_SHNDX
-                    && hdr2->sh_link == shindex)
-                  break;
-              }
-          if (i != shindex)
-            ret = bfd_section_from_shdr (abfd, i);
-        }
-      goto success;
+
+        if (i != shindex)
+          ret = bfd_section_from_shdr (abfd, i);
+        /* else FIXME: we have failed to find the symbol table - should we issue an error ? */
+        goto success;
+      }
 
     case SHT_DYNSYM:            /* A dynamic symbol table.  */
@@ -1780 +2124 @@
         }
 
-      BFD_ASSERT (elf_dynsymtab (abfd) == 0);
+      /* PR 18854: A binary might contain more than one dynamic symbol table.
+         Unusual, but possible.  Warn, but continue.  */
+      if (elf_dynsymtab (abfd) != 0)
+        {
+          (*_bfd_error_handler)
+            (_("%B: warning: multiple dynamic symbol tables detected - ignoring the table in section %u"),
+             abfd, shindex);
+          goto success;
+        }
       elf_dynsymtab (abfd) = shindex;
       elf_tdata (abfd)->dynsymtab_hdr = *hdr;
@@ -1792 +2144 @@
 
     case SHT_SYMTAB_SHNDX:      /* Symbol section indices when >64k sections.  */
-      if (elf_symtab_shndx (abfd) == shindex)
+      {
+        elf_section_list * entry;
+
+        for (entry = elf_symtab_shndx_list (abfd); entry != NULL; entry = entry->next)
+          if (entry->ndx == shindex)
+            goto success;
+        
+        entry = bfd_alloc (abfd, sizeof * entry);
+        if (entry == NULL)
+          goto fail;
+        entry->ndx = shindex;
+        entry->hdr = * hdr;
+        entry->next = elf_symtab_shndx_list (abfd);
+        elf_symtab_shndx_list (abfd) = entry;
+        elf_elfsections (abfd)[shindex] = & entry->hdr;
         goto success;
-
-      BFD_ASSERT (elf_symtab_shndx (abfd) == 0);
-      elf_symtab_shndx (abfd) = shindex;
-      elf_tdata (abfd)->symtab_shndx_hdr = *hdr;
-      elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->symtab_shndx_hdr;
-      goto success;
+      }
 
     case SHT_STRTAB:            /* A string table.  */
@@ -1869 +2230 @@
         unsigned int num_sec = elf_numsections (abfd);
         struct bfd_elf_section_data *esdt;
-        bfd_size_type amt;
 
         if (hdr->sh_entsize
@@ -1959 +2319 @@
           p_hdr = &esdt->rel.hdr;
 
-        BFD_ASSERT (*p_hdr == NULL);
-        amt = sizeof (*hdr2);
-        hdr2 = (Elf_Internal_Shdr *) bfd_alloc (abfd, amt);
+        /* PR 17512: file: 0b4f81b7.  */
+        if (*p_hdr != NULL)
+          goto fail;
+        hdr2 = (Elf_Internal_Shdr *) bfd_alloc (abfd, sizeof (*hdr2));
         if (hdr2 == NULL)
           goto fail;
@@ -2016 +2377 @@
         {
           Elf_Internal_Group *idx = (Elf_Internal_Group *) hdr->contents;
-          unsigned int n_elt = hdr->sh_size / GRP_ENTRY_SIZE;
+          unsigned int n_elt = hdr->sh_size / sizeof (* idx);
           asection *s;
 
+          if (n_elt == 0)
+            goto fail;
           if (idx->flags & GRP_COMDAT)
             hdr->bfd_section->flags
@@ -2025 +2388 @@
           /* We try to keep the same section order as it comes in.  */
           idx += n_elt;
+
           while (--n_elt != 0)
             {
@@ -2623 +2987 @@
 }
 
+static bfd_boolean
+_bfd_elf_set_reloc_sh_name (bfd *abfd,
+                            Elf_Internal_Shdr *rel_hdr,
+                            const char *sec_name,
+                            bfd_boolean use_rela_p)
+{
+  char *name = (char *) bfd_alloc (abfd,
+                                   sizeof ".rela" + strlen (sec_name));
+  if (name == NULL)
+    return FALSE;
+
+  sprintf (name, "%s%s", use_rela_p ? ".rela" : ".rel", sec_name);
+  rel_hdr->sh_name =
+    (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd), name,
+                                        FALSE);
+  if (rel_hdr->sh_name == (unsigned int) -1)
+    return FALSE;
+
+  return TRUE;
+}
+
 /* Allocate and initialize a section-header for a new reloc section,
    containing relocations against ASECT.  It is stored in RELDATA.  If
@@ -2631 +3016 @@
 _bfd_elf_init_reloc_shdr (bfd *abfd,
                           struct bfd_elf_section_reloc_data *reldata,
-                          asection *asect,
-                          bfd_boolean use_rela_p)
+                          const char *sec_name,
+                          bfd_boolean use_rela_p,
+                          bfd_boolean delay_st_name_p)
 {
   Elf_Internal_Shdr *rel_hdr;
-  char *name;
   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
-  bfd_size_type amt;
-
-  amt = sizeof (Elf_Internal_Shdr);
+
   BFD_ASSERT (reldata->hdr == NULL);
-  rel_hdr = bfd_zalloc (abfd, amt);
+  rel_hdr = bfd_zalloc (abfd, sizeof (*rel_hdr));
   reldata->hdr = rel_hdr;
 
-  amt = sizeof ".rela" + strlen (asect->name);
-  name = (char *) bfd_alloc (abfd, amt);
-  if (name == NULL)
-    return FALSE;
-  sprintf (name, "%s%s", use_rela_p ? ".rela" : ".rel", asect->name);
-  rel_hdr->sh_name =
-    (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd), name,
-                                        FALSE);
-  if (rel_hdr->sh_name == (unsigned int) -1)
+  if (delay_st_name_p)
+    rel_hdr->sh_name = (unsigned int) -1;
+  else if (!_bfd_elf_set_reloc_sh_name (abfd, rel_hdr, sec_name,
+                                        use_rela_p))
     return FALSE;
   rel_hdr->sh_type = use_rela_p ? SHT_RELA : SHT_REL;
@@ -2694 +3072 @@
   Elf_Internal_Shdr *this_hdr;
   unsigned int sh_type;
+  const char *name = asect->name;
+  bfd_boolean delay_st_name_p = FALSE;
 
   if (arg->failed)
@@ -2704 +3084 @@
   this_hdr = &esd->this_hdr;
 
-  this_hdr->sh_name = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd),
-                                                          asect->name, FALSE);
-  if (this_hdr->sh_name == (unsigned int) -1)
-    {
-      arg->failed = TRUE;
-      return;
+  if (arg->link_info)
+    {
+      /* ld: compress DWARF debug sections with names: .debug_*.  */
+      if ((arg->link_info->compress_debug & COMPRESS_DEBUG)
+          && (asect->flags & SEC_DEBUGGING)
+          && name[1] == 'd'
+          && name[6] == '_')
+        {
+          /* Set SEC_ELF_COMPRESS to indicate this section should be
+             compressed.  */
+          asect->flags |= SEC_ELF_COMPRESS;
+
+          /* If this section will be compressed, delay adding setion
+             name to section name section after it is compressed in
+             _bfd_elf_assign_file_positions_for_non_load.  */
+          delay_st_name_p = TRUE;
+        }
+    }
+  else if ((asect->flags & SEC_ELF_RENAME))
+    {
+      /* objcopy: rename output DWARF debug section.  */
+      if ((abfd->flags & (BFD_DECOMPRESS | BFD_COMPRESS_GABI)))
+        {
+          /* When we decompress or compress with SHF_COMPRESSED,
+             convert section name from .zdebug_* to .debug_* if
+             needed.  */
+          if (name[1] == 'z')
+            {
+              char *new_name = convert_zdebug_to_debug (abfd, name);
+              if (new_name == NULL)
+                {
+                  arg->failed = TRUE;
+                  return;
+                }
+              name = new_name;
+            }
+        }
+      else if (asect->compress_status == COMPRESS_SECTION_DONE)
+        {
+          /* PR binutils/18087: Compression does not always make a
+             section smaller.  So only rename the section when
+             compression has actually taken place.  If input section
+             name is .zdebug_*, we should never compress it again.  */
+          char *new_name = convert_debug_to_zdebug (abfd, name);
+          if (new_name == NULL)
+            {
+              arg->failed = TRUE;
+              return;
+            }
+          BFD_ASSERT (name[1] != 'z');
+          name = new_name;
+        }
+    }
+
+  if (delay_st_name_p)
+    this_hdr->sh_name = (unsigned int) -1;
+  else
+    {
+      this_hdr->sh_name
+        = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd),
+                                              name, FALSE);
+      if (this_hdr->sh_name == (unsigned int) -1)
+        {
+          arg->failed = TRUE;
+          return;
+        }
     }
 
@@ -2723 +3163 @@
   this_hdr->sh_size = asect->size;
   this_hdr->sh_link = 0;
+  /* PR 17512: file: 0eb809fe, 8b0535ee.  */
+  if (asect->alignment_power >= (sizeof (bfd_vma) * 8) - 1)
+    {
+      (*_bfd_error_handler)
+        (_("%B: error: Alignment power %d of section `%A' is too big"),
+         abfd, asect, asect->alignment_power);
+      arg->failed = TRUE;
+      return;
+    }
   this_hdr->sh_addralign = (bfd_vma) 1 << asect->alignment_power;
   /* The sh_entsize and sh_info fields may have been set already by
@@ -2758 +3207 @@
 
     case SHT_STRTAB:
+    case SHT_NOTE:
+    case SHT_NOBITS:
+    case SHT_PROGBITS:
+      break;
+
     case SHT_INIT_ARRAY:
     case SHT_FINI_ARRAY:
     case SHT_PREINIT_ARRAY:
-    case SHT_NOTE:
-    case SHT_NOBITS:
-    case SHT_PROGBITS:
+      this_hdr->sh_entsize = bed->s->arch_size / 8;
       break;
 
@@ -2835 +3287 @@
       this_hdr->sh_flags |= SHF_MERGE;
       this_hdr->sh_entsize = asect->entsize;
-      if ((asect->flags & SEC_STRINGS) != 0)
-        this_hdr->sh_flags |= SHF_STRINGS;
-    }
+    }
+  if ((asect->flags & SEC_STRINGS) != 0)
+    this_hdr->sh_flags |= SHF_STRINGS;
   if ((asect->flags & SEC_GROUP) == 0 && elf_group_name (asect) != NULL)
     this_hdr->sh_flags |= SHF_GROUP;
@@ -2871 +3323 @@
           /* Do the normal setup if we wouldn't create any sections here.  */
           && esd->rel.count + esd->rela.count > 0
-          && (arg->link_info->relocatable || arg->link_info->emitrelocations))
+          && (bfd_link_relocatable (arg->link_info)
+              || arg->link_info->emitrelocations))
         {
           if (esd->rel.count && esd->rel.hdr == NULL
-              && !_bfd_elf_init_reloc_shdr (abfd, &esd->rel, asect, FALSE))
+              && !_bfd_elf_init_reloc_shdr (abfd, &esd->rel, name, FALSE,
+                                            delay_st_name_p))
             {
               arg->failed = TRUE;
@@ -2880 +3334 @@
             }
           if (esd->rela.count && esd->rela.hdr == NULL
-              && !_bfd_elf_init_reloc_shdr (abfd, &esd->rela, asect, TRUE))
+              && !_bfd_elf_init_reloc_shdr (abfd, &esd->rela, name, TRUE,
+                                            delay_st_name_p))
             {
               arg->failed = TRUE;
@@ -2889 +3344 @@
                                           (asect->use_rela_p
                                            ? &esd->rela : &esd->rel),
-                                          asect,
-                                          asect->use_rela_p))
+                                          name,
+                                          asect->use_rela_p,
+                                          delay_st_name_p))
           arg->failed = TRUE;
     }
@@ -3024 +3480 @@
 }
 
+/* Return the section which RELOC_SEC applies to.  */
+
+asection *
+_bfd_elf_get_reloc_section (asection *reloc_sec)
+{
+  const char *name;
+  unsigned int type;
+  bfd *abfd;
+
+  if (reloc_sec == NULL)
+    return NULL;
+
+  type = elf_section_data (reloc_sec)->this_hdr.sh_type;
+  if (type != SHT_REL && type != SHT_RELA)
+    return NULL;
+
+  /* We look up the section the relocs apply to by name.  */
+  name = reloc_sec->name;
+  if (type == SHT_REL)
+    name += 4;
+  else
+    name += 5;
+
+  /* If a target needs .got.plt section, relocations in rela.plt/rel.plt
+     section apply to .got.plt section.  */
+  abfd = reloc_sec->owner;
+  if (get_elf_backend_data (abfd)->want_got_plt
+      && strcmp (name, ".plt") == 0)
+    {
+      /* .got.plt is a linker created input section.  It may be mapped
+         to some other output section.  Try two likely sections.  */
+      name = ".got.plt";
+      reloc_sec = bfd_get_section_by_name (abfd, name);
+      if (reloc_sec != NULL)
+        return reloc_sec;
+      name = ".got";
+    }
+
+  reloc_sec = bfd_get_section_by_name (abfd, name);
+  return reloc_sec;
+}
+
 /* Assign all ELF section numbers.  The dummy first section is handled here
    too.  The link/info pointers for the standard section types are filled
@@ -3033 +3531 @@
   struct elf_obj_tdata *t = elf_tdata (abfd);
   asection *sec;
-  unsigned int section_number, secn;
+  unsigned int section_number;
   Elf_Internal_Shdr **i_shdrp;
   struct bfd_elf_section_data *d;
@@ -3043 +3541 @@
 
   /* SHT_GROUP sections are in relocatable files only.  */
-  if (link_info == NULL || link_info->relocatable)
-    {
+  if (link_info == NULL || bfd_link_relocatable (link_info))
+    {
+      size_t reloc_count = 0;
+
       /* Put SHT_GROUP sections first.  */
       for (sec = abfd->sections; sec != NULL; sec = sec->next)
@@ -3061 +3561 @@
                 d->this_idx = section_number++;
             }
-        }
+
+          /* Count relocations.  */
+          reloc_count += sec->reloc_count;
+        }
+
+      /* Clear HAS_RELOC if there are no relocations.  */
+      if (reloc_count == 0)
+        abfd->flags &= ~HAS_RELOC;
     }
 
@@ -3070 +3577 @@
       if (d->this_hdr.sh_type != SHT_GROUP)
         d->this_idx = section_number++;
-      _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->this_hdr.sh_name);
+      if (d->this_hdr.sh_name != (unsigned int) -1)
+        _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->this_hdr.sh_name);
       if (d->rel.hdr)
         {
           d->rel.idx = section_number++;
-          _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->rel.hdr->sh_name);
+          if (d->rel.hdr->sh_name != (unsigned int) -1)
+            _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->rel.hdr->sh_name);
         }
       else
@@ -3082 +3591 @@
         {
           d->rela.idx = section_number++;
-          _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->rela.hdr->sh_name);
+          if (d->rela.hdr->sh_name != (unsigned int) -1)
+            _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->rela.hdr->sh_name);
         }
       else
@@ -3102 +3612 @@
       if (section_number > ((SHN_LORESERVE - 2) & 0xFFFF))
         {
-          elf_symtab_shndx (abfd) = section_number++;
-          t->symtab_shndx_hdr.sh_name
+          elf_section_list * entry;
+
+          BFD_ASSERT (elf_symtab_shndx_list (abfd) == NULL);
+
+          entry = bfd_zalloc (abfd, sizeof * entry);
+          entry->ndx = section_number++;
+          elf_symtab_shndx_list (abfd) = entry;
+          entry->hdr.sh_name
             = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd),
                                                   ".symtab_shndx", FALSE);
-          if (t->symtab_shndx_hdr.sh_name == (unsigned int) -1)
+          if (entry->hdr.sh_name == (unsigned int) -1)
             return FALSE;
         }
@@ -3119 +3635 @@
       return FALSE;
     }
-
-  _bfd_elf_strtab_finalize (elf_shstrtab (abfd));
-  t->shstrtab_hdr.sh_size = _bfd_elf_strtab_size (elf_shstrtab (abfd));
 
   elf_numsections (abfd) = section_number;
@@ -3149 +3662 @@
       if (elf_numsections (abfd) > (SHN_LORESERVE & 0xFFFF))
         {
-          i_shdrp[elf_symtab_shndx (abfd)] = &t->symtab_shndx_hdr;
-          t->symtab_shndx_hdr.sh_link = elf_onesymtab (abfd);
+          elf_section_list * entry = elf_symtab_shndx_list (abfd);
+          BFD_ASSERT (entry != NULL);
+          i_shdrp[entry->ndx] = & entry->hdr;
+          entry->hdr.sh_link = elf_onesymtab (abfd);
         }
       i_shdrp[elf_strtab_sec (abfd)] = &t->strtab_hdr;
@@ -3159 +3674 @@
     {
       asection *s;
-      const char *name;
 
       d = elf_section_data (sec);
@@ -3263 +3777 @@
             d->this_hdr.sh_link = elf_section_data (s)->this_idx;
 
-          /* We look up the section the relocs apply to by name.  */
-          name = sec->name;
-          if (d->this_hdr.sh_type == SHT_REL)
-            name += 4;
-          else
-            name += 5;
-          s = bfd_get_section_by_name (abfd, name);
+          s = get_elf_backend_data (abfd)->get_reloc_section (sec);
           if (s != NULL)
             {
@@ -3345 +3853 @@
     }
 
-  for (secn = 1; secn < section_number; ++secn)
-    if (i_shdrp[secn] == NULL)
-      i_shdrp[secn] = i_shdrp[0];
-    else
-      i_shdrp[secn]->sh_name = _bfd_elf_strtab_offset (elf_shstrtab (abfd),
-                                                       i_shdrp[secn]->sh_name);
+  /* Delay setting sh_name to _bfd_elf_write_object_contents so that
+     _bfd_elf_assign_file_positions_for_non_load can convert DWARF
+     debug section name from .debug_* to .zdebug_* if needed.  */
+
   return TRUE;
 }
@@ -3401 +3907 @@
   unsigned int num_locals2 = 0;
   unsigned int num_globals2 = 0;
-  int max_index = 0;
+  unsigned int max_index = 0;
   unsigned int idx;
   asection *asect;
@@ -3550 +4056 @@
   struct fake_section_arg fsargs;
   bfd_boolean failed;
-  struct bfd_strtab_hash *strtab = NULL;
+  struct elf_strtab_hash *strtab = NULL;
   Elf_Internal_Shdr *shstrtab_hdr;
   bfd_boolean need_symtab;
@@ -3601 +4107 @@
   /* sh_name was set in prep_headers.  */
   shstrtab_hdr->sh_type = SHT_STRTAB;
-  shstrtab_hdr->sh_flags = 0;
+  shstrtab_hdr->sh_flags = bed->elf_strtab_flags;
   shstrtab_hdr->sh_addr = 0;
-  shstrtab_hdr->sh_size = _bfd_elf_strtab_size (elf_shstrtab (abfd));
+  /* sh_size is set in _bfd_elf_assign_file_positions_for_non_load.  */
   shstrtab_hdr->sh_entsize = 0;
   shstrtab_hdr->sh_link = 0;
   shstrtab_hdr->sh_info = 0;
-  /* sh_offset is set in assign_file_positions_except_relocs.  */
+  /* sh_offset is set in _bfd_elf_assign_file_positions_for_non_load.  */
   shstrtab_hdr->sh_addralign = 1;
 
@@ -3620 +4126 @@
       off = elf_next_file_pos (abfd);
 
-      hdr = &elf_tdata (abfd)->symtab_hdr;
+      hdr = & elf_symtab_hdr (abfd);
       off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
 
-      hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
-      if (hdr->sh_size != 0)
-        off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
+      if (elf_symtab_shndx_list (abfd) != NULL)
+        {
+          hdr = & elf_symtab_shndx_list (abfd)->hdr;
+          if (hdr->sh_size != 0)
+            off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
+          /* FIXME: What about other symtab_shndx sections in the list ?  */
+        }
 
       hdr = &elf_tdata (abfd)->strtab_hdr;
@@ -3635 +4145 @@
          out.  */
       if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
-          || ! _bfd_stringtab_emit (abfd, strtab))
+          || ! _bfd_elf_strtab_emit (abfd, strtab))
         return FALSE;
-      _bfd_stringtab_free (strtab);
+      _bfd_elf_strtab_free (strtab);
     }
 
@@ -3976 +4486 @@
       phdr_index = 0;
       maxpagesize = bed->maxpagesize;
+      /* PR 17512: file: c8455299.
+         Avoid divide-by-zero errors later on.
+         FIXME: Should we abort if the maxpagesize is zero ?  */
+      if (maxpagesize == 0)
+        maxpagesize = 1;
       writable = FALSE;
       dynsec = bfd_get_section_by_name (abfd, ".dynamic");
@@ -4046 +4561 @@
             }
           else if ((last_hdr->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0
-                   && (hdr->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) != 0)
+                   && (hdr->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) != 0
+                   && ((abfd->flags & D_PAGED) == 0
+                       || (((last_hdr->lma + last_size - 1) & -maxpagesize)
+                           != (hdr->lma & -maxpagesize))))
             {
-              /* We don't want to put a loadable section after a
-                 nonloadable section in the same segment.
-                 Consider .tbss sections as loadable for this purpose.  */
+              /* We don't want to put a loaded section after a
+                 nonloaded (ie. bss style) section in the same segment
+                 as that will force the non-loaded section to be loaded.
+                 Consider .tbss sections as loaded for this purpose.
+                 However, like the writable/non-writable case below,
+                 if they are on the same page then they must be put
+                 in the same segment.  */
               new_segment = TRUE;
             }
@@ -4321 +4843 @@
               m->next = NULL;
               m->p_type = PT_GNU_RELRO;
-              m->p_flags = PF_R;
-              m->p_flags_valid = 1;
-
               *pm = m;
               pm = &m->next;
@@ -4963 +5482 @@
   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
   Elf_Internal_Shdr **i_shdrpp;
-  Elf_Internal_Shdr **hdrpp;
+  Elf_Internal_Shdr **hdrpp, **end_hdrpp;
   Elf_Internal_Phdr *phdrs;
   Elf_Internal_Phdr *p;
@@ -4971 +5490 @@
   bfd_vma phdrs_vaddr, phdrs_paddr;
   file_ptr off;
-  unsigned int num_sec;
-  unsigned int i;
   unsigned int count;
 
   i_shdrpp = elf_elfsections (abfd);
-  num_sec = elf_numsections (abfd);
+  end_hdrpp = i_shdrpp + elf_numsections (abfd);
   off = elf_next_file_pos (abfd);
-  for (i = 1, hdrpp = i_shdrpp + 1; i < num_sec; i++, hdrpp++)
+  for (hdrpp = i_shdrpp + 1; hdrpp < end_hdrpp; hdrpp++)
     {
       Elf_Internal_Shdr *hdr;
@@ -5009 +5526 @@
       else if (((hdr->sh_type == SHT_REL || hdr->sh_type == SHT_RELA)
                 && hdr->bfd_section == NULL)
+               || (hdr->bfd_section != NULL
+                   && (hdr->bfd_section->flags & SEC_ELF_COMPRESS))
+                   /* Compress DWARF debug sections.  */
                || hdr == i_shdrpp[elf_onesymtab (abfd)]
-               || hdr == i_shdrpp[elf_symtab_shndx (abfd)]
-               || hdr == i_shdrpp[elf_strtab_sec (abfd)])
+               || (elf_symtab_shndx_list (abfd) != NULL
+                   && hdr == i_shdrpp[elf_symtab_shndx_list (abfd)->ndx])
+               || hdr == i_shdrpp[elf_strtab_sec (abfd)]
+               || hdr == i_shdrpp[elf_shstrtab_sec (abfd)])
         hdr->sh_offset = -1;
       else
@@ -5152 +5674 @@
                 p->p_align = 1;
               if (!m->p_flags_valid)
-                p->p_flags = (lp->p_flags & ~PF_W);
+                p->p_flags = PF_R;
             }
           else
@@ -5167 +5689 @@
       else if (m->count != 0)
         {
+          unsigned int i;
           if (p->p_type != PT_LOAD
               && (p->p_type != PT_NOTE
                   || bfd_get_format (abfd) != bfd_core))
             {
-              BFD_ASSERT (!m->includes_filehdr && !m->includes_phdrs);
+              if (m->includes_filehdr || m->includes_phdrs)
+                {
+                  /* PR 17512: file: 2195325e.  */
+                  (*_bfd_error_handler)
+                    (_("%B: warning: non-load segment includes file header and/or program header"),
+                     abfd);
+                  return FALSE;
+                }
 
               p->p_filesz = 0;
@@ -5207 +5737 @@
 }
 
+static elf_section_list *
+find_section_in_list (unsigned int i, elf_section_list * list)
+{
+  for (;list != NULL; list = list->next)
+    if (list->ndx == i)
+      break;
+  return list;
+}
+
 /* Work out the file positions of all the sections.  This is called by
    _bfd_elf_compute_section_file_positions.  All the section sizes and
@@ -5251 +5790 @@
           if (((hdr->sh_type == SHT_REL || hdr->sh_type == SHT_RELA)
                && hdr->bfd_section == NULL)
+              || (hdr->bfd_section != NULL
+                  && (hdr->bfd_section->flags & SEC_ELF_COMPRESS))
+                  /* Compress DWARF debug sections.  */
               || i == elf_onesymtab (abfd)
-              || i == elf_symtab_shndx (abfd)
-              || i == elf_strtab_sec (abfd))
+              || (elf_symtab_shndx_list (abfd) != NULL
+                  && hdr == i_shdrpp[elf_symtab_shndx_list (abfd)->ndx])
+              || i == elf_strtab_sec (abfd)
+              || i == elf_shstrtab_sec (abfd))
             {
               hdr->sh_offset = -1;
@@ -5283 +5827 @@
 
       /* Set e_type in ELF header to ET_EXEC for -pie -Ttext-segment=.  */
-      if (link_info != NULL
-          && link_info->executable
-          && link_info->shared)
+      if (link_info != NULL && bfd_link_pie (link_info))
         {
           unsigned int num_segments = elf_elfheader (abfd)->e_phnum;
@@ -5404 +5946 @@
    of the loadable file image, and the file position of section headers.  */
 
-static void
-_bfd_elf_assign_file_positions_for_relocs (bfd *abfd)
+static bfd_boolean
+_bfd_elf_assign_file_positions_for_non_load (bfd *abfd)
 {
   file_ptr off;
-  unsigned int i, num_sec;
-  Elf_Internal_Shdr **shdrpp;
+  Elf_Internal_Shdr **shdrpp, **end_shdrpp;
+  Elf_Internal_Shdr *shdrp;
   Elf_Internal_Ehdr *i_ehdrp;
   const struct elf_backend_data *bed;
@@ -5415 +5957 @@
   off = elf_next_file_pos (abfd);
 
-  num_sec = elf_numsections (abfd);
-  for (i = 1, shdrpp = elf_elfsections (abfd) + 1; i < num_sec; i++, shdrpp++)
-    {
-      Elf_Internal_Shdr *shdrp;
-
+  shdrpp = elf_elfsections (abfd);
+  end_shdrpp = shdrpp + elf_numsections (abfd);
+  for (shdrpp++; shdrpp < end_shdrpp; shdrpp++)
+    {
       shdrp = *shdrpp;
-      if ((shdrp->sh_type == SHT_REL || shdrp->sh_type == SHT_RELA)
-          && shdrp->sh_offset == -1)
-        off = _bfd_elf_assign_file_position_for_section (shdrp, off, TRUE);
-    }
-
-/* Place the section headers.  */
+      if (shdrp->sh_offset == -1)
+        {
+          asection *sec = shdrp->bfd_section;
+          bfd_boolean is_rel = (shdrp->sh_type == SHT_REL
+                                || shdrp->sh_type == SHT_RELA);
+          if (is_rel
+              || (sec != NULL && (sec->flags & SEC_ELF_COMPRESS)))
+            {
+              if (!is_rel)
+                {
+                  const char *name = sec->name;
+                  struct bfd_elf_section_data *d;
+
+                  /* Compress DWARF debug sections.  */
+                  if (!bfd_compress_section (abfd, sec,
+                                             shdrp->contents))
+                    return FALSE;
+
+                  if (sec->compress_status == COMPRESS_SECTION_DONE
+                      && (abfd->flags & BFD_COMPRESS_GABI) == 0)
+                    {
+                      /* If section is compressed with zlib-gnu, convert
+                         section name from .debug_* to .zdebug_*.  */
+                      char *new_name
+                        = convert_debug_to_zdebug (abfd, name);
+                      if (new_name == NULL)
+                        return FALSE;
+                      name = new_name;
+                    }
+                  /* Add setion name to section name section.  */
+                  if (shdrp->sh_name != (unsigned int) -1)
+                    abort ();
+                  shdrp->sh_name
+                    = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd),
+                                                          name, FALSE);
+                  d = elf_section_data (sec);
+
+                  /* Add reloc setion name to section name section.  */
+                  if (d->rel.hdr
+                      && !_bfd_elf_set_reloc_sh_name (abfd,
+                                                      d->rel.hdr,
+                                                      name, FALSE))
+                    return FALSE;
+                  if (d->rela.hdr
+                      && !_bfd_elf_set_reloc_sh_name (abfd,
+                                                      d->rela.hdr,
+                                                      name, TRUE))
+                    return FALSE;
+
+                  /* Update section size and contents.  */
+                  shdrp->sh_size = sec->size;
+                  shdrp->contents = sec->contents;
+                  shdrp->bfd_section->contents = NULL;
+                }
+              off = _bfd_elf_assign_file_position_for_section (shdrp,
+                                                               off,
+                                                               TRUE);
+            }
+        }
+    }
+
+  /* Place section name section after DWARF debug sections have been
+     compressed.  */
+  _bfd_elf_strtab_finalize (elf_shstrtab (abfd));
+  shdrp = &elf_tdata (abfd)->shstrtab_hdr;
+  shdrp->sh_size = _bfd_elf_strtab_size (elf_shstrtab (abfd));
+  off = _bfd_elf_assign_file_position_for_section (shdrp, off, TRUE);
+
+  /* Place the section headers.  */
   i_ehdrp = elf_elfheader (abfd);
   bed = get_elf_backend_data (abfd);
@@ -5433 +6037 @@
   off += i_ehdrp->e_shnum * i_ehdrp->e_shentsize;
   elf_next_file_pos (abfd) = off;
+
+  return TRUE;
 }
 
@@ -5455 +6061 @@
     return FALSE;
 
-  _bfd_elf_assign_file_positions_for_relocs (abfd);
+  if (!_bfd_elf_assign_file_positions_for_non_load (abfd))
+    return FALSE;
 
   /* After writing the headers, we need to write the sections too...  */
@@ -5461 +6068 @@
   for (count = 1; count < num_sec; count++)
     {
+      i_shdrp[count]->sh_name
+        = _bfd_elf_strtab_offset (elf_shstrtab (abfd),
+                                  i_shdrp[count]->sh_name);
       if (bed->elf_backend_section_processing)
         (*bed->elf_backend_section_processing) (abfd, i_shdrp[count]);
@@ -5912 +6522 @@
              a warning is produced.  */
           if (segment->p_type == PT_LOAD)
-            (*_bfd_error_handler) (_("%B: warning: Empty loadable segment"
-                                     " detected, is this intentional ?\n"),
+            (*_bfd_error_handler) (_("\
+%B: warning: Empty loadable segment detected, is this intentional ?"),
                                    ibfd);
 
@@ -5967 +6577 @@
       first_suggested_lma = TRUE;
 
-      for (section = ibfd->sections;
+      for (section = first_section, j = 0;
            section != NULL;
            section = section->next)
-        if (section == first_section)
-          break;
-
-      for (j = 0; section != NULL; section = section->next)
         {
           if (INCLUDE_SECTION_IN_SEGMENT (section, segment, bed))
@@ -6526 +7132 @@
         if (segment->p_type == PT_LOAD
             && maxpagesize < segment->p_align)
-          maxpagesize = segment->p_align;
+          {
+            /* PR 17512: file: f17299af.  */
+            if (segment->p_align > (bfd_vma) 1 << ((sizeof (bfd_vma) * 8) - 2))
+              (*_bfd_error_handler) (_("\
+%B: warning: segment alignment of 0x%llx is too large"),
+                                     ibfd, (long long) segment->p_align);
+            else
+              maxpagesize = segment->p_align;
+          }
 
       if (maxpagesize != get_elf_backend_data (obfd)->maxpagesize)
@@ -6546 +7160 @@
 {
   Elf_Internal_Shdr *ihdr, *ohdr;
-  bfd_boolean final_link = link_info != NULL && !link_info->relocatable;
+  bfd_boolean final_link = (link_info != NULL
+                            && !bfd_link_relocatable (link_info));
 
   if (ibfd->xvec->flavour != bfd_target_elf_flavour
@@ -6583 +7198 @@
           elf_section_data (osec)->group = elf_section_data (isec)->group;
         }
+
+      /* If not decompress, preserve SHF_COMPRESSED.  */
+      if ((ibfd->flags & BFD_DECOMPRESS) == 0)
+        elf_section_flags (osec) |= (elf_section_flags (isec)
+                                     & SHF_COMPRESSED);
     }
 
@@ -6761 +7381 @@
       else if (shndx == elf_shstrtab_sec (ibfd))
         shndx = MAP_SHSTRTAB;
-      else if (shndx == elf_symtab_shndx (ibfd))
+      else if (find_section_in_list (shndx, elf_symtab_shndx_list (ibfd)))
         shndx = MAP_SYM_SHNDX;
       osym->internal_elf_sym.st_shndx = shndx;
@@ -6773 +7393 @@
 static bfd_boolean
 swap_out_syms (bfd *abfd,
-               struct bfd_strtab_hash **sttp,
+               struct elf_strtab_hash **sttp,
                int relocatable_p)
 {
@@ -6779 +7399 @@
   int symcount;
   asymbol **syms;
-  struct bfd_strtab_hash *stt;
+  struct elf_strtab_hash *stt;
   Elf_Internal_Shdr *symtab_hdr;
   Elf_Internal_Shdr *symtab_shndx_hdr;
   Elf_Internal_Shdr *symstrtab_hdr;
+  struct elf_sym_strtab *symstrtab;
   bfd_byte *outbound_syms;
   bfd_byte *outbound_shndx;
+  unsigned long outbound_syms_index;
+  unsigned long outbound_shndx_index;
   int idx;
   unsigned int num_locals;
@@ -6794 +7417 @@
 
   /* Dump out the symtabs.  */
-  stt = _bfd_elf_stringtab_init ();
+  stt = _bfd_elf_strtab_init ();
   if (stt == NULL)
     return FALSE;
@@ -6810 +7433 @@
   symstrtab_hdr->sh_type = SHT_STRTAB;
 
+  /* Allocate buffer to swap out the .strtab section.  */
+  symstrtab = (struct elf_sym_strtab *) bfd_malloc ((symcount + 1)
+                                                    * sizeof (*symstrtab));
+  if (symstrtab == NULL)
+    {
+      _bfd_elf_strtab_free (stt);
+      return FALSE;
+    }
+
   outbound_syms = (bfd_byte *) bfd_alloc2 (abfd, 1 + symcount,
                                            bed->s->sizeof_sym);
   if (outbound_syms == NULL)
     {
-      _bfd_stringtab_free (stt);
+error_return:
+      _bfd_elf_strtab_free (stt);
+      free (symstrtab);
       return FALSE;
     }
   symtab_hdr->contents = outbound_syms;
+  outbound_syms_index = 0;
 
   outbound_shndx = NULL;
-  symtab_shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
-  if (symtab_shndx_hdr->sh_name != 0)
-    {
-      amt = (bfd_size_type) (1 + symcount) * sizeof (Elf_External_Sym_Shndx);
-      outbound_shndx =  (bfd_byte *)
-          bfd_zalloc2 (abfd, 1 + symcount, sizeof (Elf_External_Sym_Shndx));
-      if (outbound_shndx == NULL)
-        {
-          _bfd_stringtab_free (stt);
-          return FALSE;
-        }
-
-      symtab_shndx_hdr->contents = outbound_shndx;
-      symtab_shndx_hdr->sh_type = SHT_SYMTAB_SHNDX;
-      symtab_shndx_hdr->sh_size = amt;
-      symtab_shndx_hdr->sh_addralign = sizeof (Elf_External_Sym_Shndx);
-      symtab_shndx_hdr->sh_entsize = sizeof (Elf_External_Sym_Shndx);
+  outbound_shndx_index = 0;
+
+  if (elf_symtab_shndx_list (abfd))
+    {
+      symtab_shndx_hdr = & elf_symtab_shndx_list (abfd)->hdr;
+      if (symtab_shndx_hdr->sh_name != 0)
+        {
+          amt = (bfd_size_type) (1 + symcount) * sizeof (Elf_External_Sym_Shndx);
+          outbound_shndx =  (bfd_byte *)
+            bfd_zalloc2 (abfd, 1 + symcount, sizeof (Elf_External_Sym_Shndx));
+          if (outbound_shndx == NULL)
+            goto error_return;
+
+          symtab_shndx_hdr->contents = outbound_shndx;
+          symtab_shndx_hdr->sh_type = SHT_SYMTAB_SHNDX;
+          symtab_shndx_hdr->sh_size = amt;
+          symtab_shndx_hdr->sh_addralign = sizeof (Elf_External_Sym_Shndx);
+          symtab_shndx_hdr->sh_entsize = sizeof (Elf_External_Sym_Shndx);
+        }
+      /* FIXME: What about any other headers in the list ?  */
     }
 
@@ -6850 +7488 @@
     sym.st_shndx = SHN_UNDEF;
     sym.st_target_internal = 0;
-    bed->s->swap_symbol_out (abfd, &sym, outbound_syms, outbound_shndx);
-    outbound_syms += bed->s->sizeof_sym;
+    symstrtab[0].sym = sym;
+    symstrtab[0].dest_index = outbound_syms_index;
+    symstrtab[0].destshndx_index = outbound_shndx_index;
+    outbound_syms_index++;
     if (outbound_shndx != NULL)
-      outbound_shndx += sizeof (Elf_External_Sym_Shndx);
+      outbound_shndx_index++;
   }
 
@@ -6861 +7501 @@
 
   syms = bfd_get_outsymbols (abfd);
-  for (idx = 0; idx < symcount; idx++)
+  for (idx = 0; idx < symcount;)
     {
       Elf_Internal_Sym sym;
@@ -6873 +7513 @@
         {
           /* Local section symbols have no name.  */
-          sym.st_name = 0;
+          sym.st_name = (unsigned long) -1;
         }
       else
         {
-          sym.st_name = (unsigned long) _bfd_stringtab_add (stt,
-                                                            syms[idx]->name,
-                                                            TRUE, FALSE);
+          /* Call _bfd_elf_strtab_offset after _bfd_elf_strtab_finalize
+             to get the final offset for st_name.  */
+          sym.st_name
+            = (unsigned long) _bfd_elf_strtab_add (stt, syms[idx]->name,
+                                                   FALSE);
           if (sym.st_name == (unsigned long) -1)
-            {
-              _bfd_stringtab_free (stt);
-              return FALSE;
-            }
+            goto error_return;
         }
 
@@ -6944 +7583 @@
                   break;
                 case MAP_SYM_SHNDX:
-                  shndx = elf_symtab_shndx (abfd);
+                  if (elf_symtab_shndx_list (abfd))
+                    shndx = elf_symtab_shndx_list (abfd)->ndx;
                   break;
                 default:
@@ -6974 +7614 @@
                                           sec->name);
                       bfd_set_error (bfd_error_invalid_operation);
-                      _bfd_stringtab_free (stt);
-                      return FALSE;
+                      goto error_return;
                     }
 
@@ -7019 +7658 @@
       else if (bfd_is_com_section (syms[idx]->section))
         {
-#ifdef USE_STT_COMMON
-          if (type == STT_OBJECT)
-            sym.st_info = ELF_ST_INFO (STB_GLOBAL, STT_COMMON);
-          else
-#endif
-            sym.st_info = ELF_ST_INFO (STB_GLOBAL, type);
+          if (type != STT_TLS)
+            {
+              if ((abfd->flags & BFD_CONVERT_ELF_COMMON))
+                type = ((abfd->flags & BFD_USE_ELF_STT_COMMON)
+                        ? STT_COMMON : STT_OBJECT);
+              else
+                type = ((flags & BSF_ELF_COMMON) != 0
+                        ? STT_COMMON : STT_OBJECT);
+            }
+          sym.st_info = ELF_ST_INFO (STB_GLOBAL, type);
         }
       else if (bfd_is_und_section (syms[idx]->section))
@@ -7061 +7704 @@
         }
 
-      bed->s->swap_symbol_out (abfd, &sym, outbound_syms, outbound_shndx);
-      outbound_syms += bed->s->sizeof_sym;
+      idx++;
+      symstrtab[idx].sym = sym;
+      symstrtab[idx].dest_index = outbound_syms_index;
+      symstrtab[idx].destshndx_index = outbound_shndx_index;
+
+      outbound_syms_index++;
       if (outbound_shndx != NULL)
-        outbound_shndx += sizeof (Elf_External_Sym_Shndx);
-    }
+        outbound_shndx_index++;
+    }
+
+  /* Finalize the .strtab section.  */
+  _bfd_elf_strtab_finalize (stt);
+
+  /* Swap out the .strtab section.  */
+  for (idx = 0; idx <= symcount; idx++)
+    {
+      struct elf_sym_strtab *elfsym = &symstrtab[idx];
+      if (elfsym->sym.st_name == (unsigned long) -1)
+        elfsym->sym.st_name = 0;
+      else
+        elfsym->sym.st_name = _bfd_elf_strtab_offset (stt,
+                                                      elfsym->sym.st_name);
+      bed->s->swap_symbol_out (abfd, &elfsym->sym,
+                               (outbound_syms
+                                + (elfsym->dest_index
+                                   * bed->s->sizeof_sym)),
+                               (outbound_shndx
+                                + (elfsym->destshndx_index
+                                   * sizeof (Elf_External_Sym_Shndx))));
+    }
+  free (symstrtab);
 
   *sttp = stt;
-  symstrtab_hdr->sh_size = _bfd_stringtab_size (stt);
+  symstrtab_hdr->sh_size = _bfd_elf_strtab_size (stt);
   symstrtab_hdr->sh_type = SHT_STRTAB;
-
-  symstrtab_hdr->sh_flags = 0;
+  symstrtab_hdr->sh_flags = bed->elf_strtab_flags;
   symstrtab_hdr->sh_addr = 0;
   symstrtab_hdr->sh_entsize = 0;
@@ -7273 +7941 @@
       hdr = &elf_tdata (abfd)->dynverref_hdr;
 
-      if (hdr->sh_info)
-        elf_tdata (abfd)->verref = (Elf_Internal_Verneed *)
-          bfd_zalloc2 (abfd, hdr->sh_info, sizeof (Elf_Internal_Verneed));
-      else
-        elf_tdata (abfd)->verref = NULL;
-        
-      if (elf_tdata (abfd)->verref == NULL)
-        goto error_return;
-
-      elf_tdata (abfd)->cverrefs = hdr->sh_info;
-
-      contents = (bfd_byte *) bfd_malloc (hdr->sh_size);
-      if (contents == NULL)
-        {
+      if (hdr->sh_info == 0 || hdr->sh_size < sizeof (Elf_External_Verneed))
+        {
+error_return_bad_verref:
+          (*_bfd_error_handler)
+            (_("%B: .gnu.version_r invalid entry"), abfd);
+          bfd_set_error (bfd_error_bad_value);
 error_return_verref:
           elf_tdata (abfd)->verref = NULL;
@@ -7292 +7952 @@
           goto error_return;
         }
+
+      contents = (bfd_byte *) bfd_malloc (hdr->sh_size);
+      if (contents == NULL)
+        goto error_return_verref;
+
       if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
           || bfd_bread (contents, hdr->sh_size, abfd) != hdr->sh_size)
         goto error_return_verref;
 
-      if (hdr->sh_info && hdr->sh_size < sizeof (Elf_External_Verneed))
+      elf_tdata (abfd)->verref = (Elf_Internal_Verneed *)
+        bfd_zalloc2 (abfd, hdr->sh_info, sizeof (Elf_Internal_Verneed));
+
+      if (elf_tdata (abfd)->verref == NULL)
         goto error_return_verref;
 
@@ -7318 +7986 @@
                                              iverneed->vn_file);
           if (iverneed->vn_filename == NULL)
-            goto error_return_verref;
+            goto error_return_bad_verref;
 
           if (iverneed->vn_cnt == 0)
@@ -7333 +8001 @@
           if (iverneed->vn_aux
               > (size_t) (contents_end - (bfd_byte *) everneed))
-            goto error_return_verref;
+            goto error_return_bad_verref;
 
           evernaux = ((Elf_External_Vernaux *)
@@ -7346 +8014 @@
                                                  ivernaux->vna_name);
               if (ivernaux->vna_nodename == NULL)
-                goto error_return_verref;
-
+                goto error_return_bad_verref;
+
+              if (ivernaux->vna_other > freeidx)
+                freeidx = ivernaux->vna_other;
+
+              ivernaux->vna_nextptr = NULL;
+              if (ivernaux->vna_next == 0)
+                {
+                  iverneed->vn_cnt = j + 1;
+                  break;
+                }
               if (j + 1 < iverneed->vn_cnt)
                 ivernaux->vna_nextptr = ivernaux + 1;
-              else
-                ivernaux->vna_nextptr = NULL;
 
               if (ivernaux->vna_next
                   > (size_t) (contents_end - (bfd_byte *) evernaux))
-                goto error_return_verref;
+                goto error_return_bad_verref;
 
               evernaux = ((Elf_External_Vernaux *)
                           ((bfd_byte *) evernaux + ivernaux->vna_next));
-
-              if (ivernaux->vna_other > freeidx)
-                freeidx = ivernaux->vna_other;
             }
 
+          iverneed->vn_nextref = NULL;
+          if (iverneed->vn_next == 0)
+            break;
           if (i + 1 < hdr->sh_info)
             iverneed->vn_nextref = iverneed + 1;
-          else
-            iverneed->vn_nextref = NULL;
 
           if (iverneed->vn_next
               > (size_t) (contents_end - (bfd_byte *) everneed))
-            goto error_return_verref;
+            goto error_return_bad_verref;
 
           everneed = ((Elf_External_Verneed *)
                       ((bfd_byte *) everneed + iverneed->vn_next));
         }
+      elf_tdata (abfd)->cverrefs = i;
 
       free (contents);
@@ -7394 +8068 @@
       hdr = &elf_tdata (abfd)->dynverdef_hdr;
 
+      if (hdr->sh_info == 0 || hdr->sh_size < sizeof (Elf_External_Verdef))
+        {
+        error_return_bad_verdef:
+          (*_bfd_error_handler)
+            (_("%B: .gnu.version_d invalid entry"), abfd);
+          bfd_set_error (bfd_error_bad_value);
+        error_return_verdef:
+          elf_tdata (abfd)->verdef = NULL;
+          elf_tdata (abfd)->cverdefs = 0;
+          goto error_return;
+        }
+
       contents = (bfd_byte *) bfd_malloc (hdr->sh_size);
       if (contents == NULL)
-        goto error_return;
+        goto error_return_verdef;
       if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
           || bfd_bread (contents, hdr->sh_size, abfd) != hdr->sh_size)
-        goto error_return;
-
-      if (hdr->sh_info && hdr->sh_size < sizeof (Elf_External_Verdef))
-        goto error_return;
+        goto error_return_verdef;
 
       BFD_ASSERT (sizeof (Elf_External_Verdef)
@@ -7420 +8103 @@
           _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
 
+          if ((iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION)) == 0)
+            goto error_return_bad_verdef;
           if ((iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION)) > maxidx)
             maxidx = iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION);
 
+          if (iverdefmem.vd_next == 0)
+            break;
+
           if (iverdefmem.vd_next
               > (size_t) (contents_end_def - (bfd_byte *) everdef))
-            goto error_return;
+            goto error_return_bad_verdef;
 
           everdef = ((Elf_External_Verdef *)
@@ -7438 +8126 @@
             freeidx = ++maxidx;
         }
-      if (maxidx)
-        elf_tdata (abfd)->verdef = (Elf_Internal_Verdef *)
-          bfd_zalloc2 (abfd, maxidx, sizeof (Elf_Internal_Verdef));
-      else
-        elf_tdata (abfd)->verdef = NULL;
-
+
+      elf_tdata (abfd)->verdef = (Elf_Internal_Verdef *)
+        bfd_zalloc2 (abfd, maxidx, sizeof (Elf_Internal_Verdef));
       if (elf_tdata (abfd)->verdef == NULL)
-        goto error_return;
+        goto error_return_verdef;
 
       elf_tdata (abfd)->cverdefs = maxidx;
@@ -7460 +8145 @@
 
           if ((iverdefmem.vd_ndx & VERSYM_VERSION) == 0)
-            {
-error_return_verdef:
-              elf_tdata (abfd)->verdef = NULL;
-              elf_tdata (abfd)->cverdefs = 0;
-              goto error_return;
-            }
+            goto error_return_bad_verdef;
 
           iverdef = &iverdefarr[(iverdefmem.vd_ndx & VERSYM_VERSION) - 1];
-          memcpy (iverdef, &iverdefmem, sizeof (Elf_Internal_Verdef));
+          memcpy (iverdef, &iverdefmem, offsetof (Elf_Internal_Verdef, vd_bfd));
 
           iverdef->vd_bfd = abfd;
@@ -7485 +8165 @@
           if (iverdef->vd_aux
               > (size_t) (contents_end_aux - (bfd_byte *) everdef))
-            goto error_return_verdef;
+            goto error_return_bad_verdef;
 
           everdaux = ((Elf_External_Verdaux *)
@@ -7498 +8178 @@
                                                  iverdaux->vda_name);
               if (iverdaux->vda_nodename == NULL)
-                goto error_return_verdef;
-
+                goto error_return_bad_verdef;
+
+              iverdaux->vda_nextptr = NULL;
+              if (iverdaux->vda_next == 0)
+                {
+                  iverdef->vd_cnt = j + 1;
+                  break;
+                }
               if (j + 1 < iverdef->vd_cnt)
                 iverdaux->vda_nextptr = iverdaux + 1;
-              else
-                iverdaux->vda_nextptr = NULL;
 
               if (iverdaux->vda_next
                   > (size_t) (contents_end_aux - (bfd_byte *) everdaux))
-                goto error_return_verdef;
+                goto error_return_bad_verdef;
 
               everdaux = ((Elf_External_Verdaux *)
@@ -7513 +8197 @@
             }
 
+          iverdef->vd_nodename = NULL;
           if (iverdef->vd_cnt)
             iverdef->vd_nodename = iverdef->vd_auxptr->vda_nodename;
 
+          iverdef->vd_nextdef = NULL;
+          if (iverdef->vd_next == 0)
+            break;
           if ((size_t) (iverdef - iverdefarr) + 1 < maxidx)
             iverdef->vd_nextdef = iverdef + 1;
-          else
-            iverdef->vd_nextdef = NULL;
 
           everdef = ((Elf_External_Verdef *)
@@ -7562 +8248 @@
         goto error_return_verdef;
       iverdef->vd_nextdef = NULL;
-      iverdef->vd_auxptr = (struct elf_internal_verdaux *)
-          bfd_alloc (abfd, sizeof (Elf_Internal_Verdaux));
+      iverdef->vd_auxptr = ((struct elf_internal_verdaux *)
+                            bfd_zalloc (abfd, sizeof (Elf_Internal_Verdaux)));
       if (iverdef->vd_auxptr == NULL)
         goto error_return_verdef;
@@ -7569 +8255 @@
       iverdaux = iverdef->vd_auxptr;
       iverdaux->vda_nodename = iverdef->vd_nodename;
-      iverdaux->vda_nextptr = NULL;
     }
 
@@ -7627 +8312 @@
     return TRUE;
 
+  /* Treat assembler generated fake symbols, dollar local labels and
+     forward-backward labels (aka local labels) as locals.
+     These labels have the form:
+
+       L0^A.*                                  (fake symbols)
+
+       [.]?L[0123456789]+{^A|^B}[0123456789]*  (local labels)
+
+     Versions which start with .L will have already been matched above,
+     so we only need to match the rest.  */
+  if (name[0] == 'L' && ISDIGIT (name[1]))
+    {
+      bfd_boolean ret = FALSE;
+      const char * p;
+      char c;
+
+      for (p = name + 2; (c = *p); p++)
+        {
+          if (c == 1 || c == 2)
+            {
+              if (c == 1 && p == name + 2)
+                /* A fake symbol.  */
+                return TRUE;
+
+              /* FIXME: We are being paranoid here and treating symbols like
+                 L0^Bfoo as if there were non-local, on the grounds that the
+                 assembler will never generate them.  But can any symbol
+                 containing an ASCII value in the range 1-31 ever be anything
+                 other than some kind of local ?  */
+              ret = TRUE;
+            }
+
+          if (! ISDIGIT (c))
+            {
+              ret = FALSE;
+              break;
+            }
+        }
+      return ret;
+    }
+
   return FALSE;
 }
@@ -7651 +8377 @@
 
   return bfd_default_set_arch_mach (abfd, arch, machine);
-}
-
-/* Find the function to a particular section and offset,
-   for error reporting.  */
-
-static bfd_boolean
-elf_find_function (bfd *abfd,
-                   asymbol **symbols,
-                   asection *section,
-                   bfd_vma offset,
-                   const char **filename_ptr,
-                   const char **functionname_ptr)
-{
-  struct elf_find_function_cache
-  {
-    asection *last_section;
-    asymbol *func;
-    const char *filename;
-    bfd_size_type func_size;
-  } *cache;
-
-  if (symbols == NULL)
-    return FALSE;
-
-  cache = elf_tdata (abfd)->elf_find_function_cache;
-  if (cache == NULL)
-    {
-      cache = bfd_zalloc (abfd, sizeof (*cache));
-      elf_tdata (abfd)->elf_find_function_cache = cache;
-      if (cache == NULL)
-        return FALSE;
-    }
-  if (cache->last_section != section
-      || cache->func == NULL
-      || offset < cache->func->value
-      || offset >= cache->func->value + cache->func_size)
-    {
-      asymbol *file;
-      bfd_vma low_func;
-      asymbol **p;
-      /* ??? Given multiple file symbols, it is impossible to reliably
-         choose the right file name for global symbols.  File symbols are
-         local symbols, and thus all file symbols must sort before any
-         global symbols.  The ELF spec may be interpreted to say that a
-         file symbol must sort before other local symbols, but currently
-         ld -r doesn't do this.  So, for ld -r output, it is possible to
-         make a better choice of file name for local symbols by ignoring
-         file symbols appearing after a given local symbol.  */
-      enum { nothing_seen, symbol_seen, file_after_symbol_seen } state;
-      const struct elf_backend_data *bed = get_elf_backend_data (abfd);
-
-      file = NULL;
-      low_func = 0;
-      state = nothing_seen;
-      cache->filename = NULL;
-      cache->func = NULL;
-      cache->func_size = 0;
-      cache->last_section = section;
-
-      for (p = symbols; *p != NULL; p++)
-        {
-          asymbol *sym = *p;
-          bfd_vma code_off;
-          bfd_size_type size;
-
-          if ((sym->flags & BSF_FILE) != 0)
-            {
-              file = sym;
-              if (state == symbol_seen)
-                state = file_after_symbol_seen;
-              continue;
-            }
-
-          size = bed->maybe_function_sym (sym, section, &code_off);
-          if (size != 0
-              && code_off <= offset
-              && (code_off > low_func
-                  || (code_off == low_func
-                      && size > cache->func_size)))
-            {
-              cache->func = sym;
-              cache->func_size = size;
-              cache->filename = NULL;
-              low_func = code_off;
-              if (file != NULL
-                  && ((sym->flags & BSF_LOCAL) != 0
-                      || state != file_after_symbol_seen))
-                cache->filename = bfd_asymbol_name (file);
-            }
-          if (state == nothing_seen)
-            state = symbol_seen;
-        }
-    }
-
-  if (cache->func == NULL)
-    return FALSE;
-
-  if (filename_ptr)
-    *filename_ptr = cache->filename;
-  if (functionname_ptr)
-    *functionname_ptr = bfd_asymbol_name (cache->func);
-
-  return TRUE;
 }
 
@@ -7775 +8398 @@
                                      line_ptr, discriminator_ptr,
                                      dwarf_debug_sections, 0,
-                                     &elf_tdata (abfd)->dwarf2_find_line_info))
+                                     &elf_tdata (abfd)->dwarf2_find_line_info)
+      || _bfd_dwarf1_find_nearest_line (abfd, symbols, section, offset,
+                                        filename_ptr, functionname_ptr,
+                                        line_ptr))
     {
       if (!*functionname_ptr)
-        elf_find_function (abfd, symbols, section, offset,
-                           *filename_ptr ? NULL : filename_ptr,
-                           functionname_ptr);
-
-      return TRUE;
-    }
-
-  if (_bfd_dwarf1_find_nearest_line (abfd, symbols, section, offset,
-                                     filename_ptr, functionname_ptr, line_ptr))
-    {
-      if (!*functionname_ptr)
-        elf_find_function (abfd, symbols, section, offset,
-                           *filename_ptr ? NULL : filename_ptr,
-                           functionname_ptr);
-
+        _bfd_elf_find_function (abfd, symbols, section, offset,
+                                *filename_ptr ? NULL : filename_ptr,
+                                functionname_ptr);
       return TRUE;
     }
@@ -7807 +8421 @@
     return FALSE;
 
-  if (! elf_find_function (abfd, symbols, section, offset,
-                           filename_ptr, functionname_ptr))
+  if (! _bfd_elf_find_function (abfd, symbols, section, offset,
+                                filename_ptr, functionname_ptr))
     return FALSE;
 
@@ -7852 +8466 @@
   int ret = bed->s->sizeof_ehdr;
 
-  if (!info->relocatable)
+  if (!bfd_link_relocatable (info))
     {
       bfd_size_type phdr_size = elf_program_header_size (abfd);
@@ -7889 +8503 @@
     return FALSE;
 
+  if (!count)
+    return TRUE;
+
   hdr = &elf_section_data (section)->this_hdr;
+  if (hdr->sh_offset == (file_ptr) -1)
+    {
+      /* We must compress this section.  Write output to the buffer.  */
+      unsigned char *contents = hdr->contents;
+      if ((offset + count) > hdr->sh_size
+          || (section->flags & SEC_ELF_COMPRESS) == 0
+          || contents == NULL)
+        abort ();
+      memcpy (contents + offset, location, count);
+      return TRUE;
+    }
   pos = hdr->sh_offset + offset;
   if (bfd_seek (abfd, pos, SEEK_SET) != 0
@@ -8310 +8938 @@
 
 static bfd_boolean
+elfcore_grok_s390_vxrs_low (bfd *abfd, Elf_Internal_Note *note)
+{
+  return elfcore_make_note_pseudosection (abfd, ".reg-s390-vxrs-low", note);
+}
+
+static bfd_boolean
+elfcore_grok_s390_vxrs_high (bfd *abfd, Elf_Internal_Note *note)
+{
+  return elfcore_make_note_pseudosection (abfd, ".reg-s390-vxrs-high", note);
+}
+
+static bfd_boolean
 elfcore_grok_arm_vfp (bfd *abfd, Elf_Internal_Note *note)
 {
@@ -8772 +9412 @@
       else
         return TRUE;
+
+    case NT_S390_VXRS_LOW:
+      if (note->namesz == 6
+          && strcmp (note->namedata, "LINUX") == 0)
+        return elfcore_grok_s390_vxrs_low (abfd, note);
+      else
+        return TRUE;
+
+    case NT_S390_VXRS_HIGH:
+      if (note->namesz == 6
+          && strcmp (note->namedata, "LINUX") == 0)
+        return elfcore_grok_s390_vxrs_high (abfd, note);
+      else
+        return TRUE;
 
     case NT_ARM_VFP:
@@ -8833 +9487 @@
       return elfcore_make_note_pseudosection (abfd, ".note.linuxcore.siginfo",
                                               note);
+
     }
 }
@@ -8839 +9494 @@
 elfobj_grok_gnu_build_id (bfd *abfd, Elf_Internal_Note *note)
 {
-  struct elf_obj_tdata *t;
+  struct bfd_build_id* build_id;
 
   if (note->descsz == 0)
     return FALSE;
 
-  t = elf_tdata (abfd);
-  t->build_id = bfd_alloc (abfd, sizeof (*t->build_id) - 1 + note->descsz);
-  if (t->build_id == NULL)
+  build_id = bfd_alloc (abfd, sizeof (struct bfd_build_id) - 1 + note->descsz);
+  if (build_id == NULL)
     return FALSE;
 
-  t->build_id->size = note->descsz;
-  memcpy (t->build_id->data, note->descdata, note->descsz);
+  build_id->size = note->descsz;
+  memcpy (build_id->data, note->descdata, note->descsz);
+  abfd->build_id = build_id;
 
   return TRUE;
@@ -8891 +9546 @@
     case NT_STAPSDT:
       return elfobj_grok_stapsdt_note_1 (abfd, note);
+
+    default:
+      return TRUE;
+    }
+}
+
+static bfd_boolean
+elfcore_grok_freebsd_psinfo (bfd *abfd, Elf_Internal_Note *note)
+{
+  size_t offset;
+
+  /* Check for version 1 in pr_version. */
+  if (bfd_h_get_32 (abfd, (bfd_byte *) note->descdata) != 1)
+    return FALSE;
+  offset = 4;
+
+  /* Skip over pr_psinfosz. */
+  switch (abfd->arch_info->bits_per_word)
+    {
+    case 32:
+      offset += 4;
+      break;
+
+    case 64:
+      offset += 4;      /* Padding before pr_psinfosz. */
+      offset += 8;
+      break;
+
+    default:
+      return FALSE;
+    }
+
+  /* pr_fname is PRFNAMESZ (16) + 1 bytes in size.  */
+  elf_tdata (abfd)->core->program
+    = _bfd_elfcore_strndup (abfd, note->descdata + offset, 17);
+  offset += 17;
+
+  /* pr_psargs is PRARGSZ (80) + 1 bytes in size.  */
+  elf_tdata (abfd)->core->command
+    = _bfd_elfcore_strndup (abfd, note->descdata + offset, 81);
+
+  return TRUE;
+}
+
+static bfd_boolean
+elfcore_grok_freebsd_prstatus (bfd *abfd, Elf_Internal_Note *note)
+{
+  size_t offset;
+  size_t size;
+
+  /* Check for version 1 in pr_version. */
+  if (bfd_h_get_32 (abfd, (bfd_byte *) note->descdata) != 1)
+    return FALSE;
+  offset = 4;
+
+  /* Skip over pr_statussz.  */
+  switch (abfd->arch_info->bits_per_word)
+    {
+    case 32:
+      offset += 4;
+      break;
+
+    case 64:
+      offset += 4;      /* Padding before pr_statussz. */
+      offset += 8;
+      break;
+
+    default:
+      return FALSE;
+    }
+
+  /* Extract size of pr_reg from pr_gregsetsz.  */
+  if (abfd->arch_info->bits_per_word == 32)
+    size = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + offset);
+  else
+    size = bfd_h_get_64 (abfd, (bfd_byte *) note->descdata + offset);
+
+  /* Skip over pr_gregsetsz and pr_fpregsetsz. */
+  offset += (abfd->arch_info->bits_per_word / 8) * 2;
+
+  /* Skip over pr_osreldate. */
+  offset += 4;
+
+  /* Read signal from pr_cursig. */
+  if (elf_tdata (abfd)->core->signal == 0)
+    elf_tdata (abfd)->core->signal
+      = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + offset);
+  offset += 4;
+
+  /* Read TID from pr_pid. */
+  elf_tdata (abfd)->core->lwpid
+      = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + offset);
+  offset += 4;
+
+  /* Padding before pr_reg. */
+  if (abfd->arch_info->bits_per_word == 64)
+    offset += 4;
+
+  /* Make a ".reg/999" section and a ".reg" section.  */
+  return _bfd_elfcore_make_pseudosection (abfd, ".reg",
+                                          size, note->descpos + offset);
+}
+
+static bfd_boolean
+elfcore_grok_freebsd_note (bfd *abfd, Elf_Internal_Note *note)
+{
+  switch (note->type)
+    {
+    case NT_PRSTATUS:
+      return elfcore_grok_freebsd_prstatus (abfd, note);
+
+    case NT_FPREGSET:
+      return elfcore_grok_prfpreg (abfd, note);
+
+    case NT_PRPSINFO:
+      return elfcore_grok_freebsd_psinfo (abfd, note);
+
+    case NT_FREEBSD_THRMISC:
+      if (note->namesz == 8)
+        return elfcore_make_note_pseudosection (abfd, ".thrmisc", note);
+      else
+        return TRUE;
+
+    case NT_FREEBSD_PROCSTAT_AUXV:
+      {
+        asection *sect = bfd_make_section_anyway_with_flags (abfd, ".auxv",
+                                                             SEC_HAS_CONTENTS);
+
+        if (sect == NULL)
+          return FALSE;
+        sect->size = note->descsz - 4;
+        sect->filepos = note->descpos + 4;
+        sect->alignment_power = 1 + bfd_get_arch_size (abfd) / 32;
+
+        return TRUE;
+      }
+
+    case NT_X86_XSTATE:
+      if (note->namesz == 8)
+        return elfcore_grok_xstatereg (abfd, note);
+      else
+        return TRUE;
 
     default:
@@ -9330 +10127 @@
   struct elf_external_linux_prpsinfo32 data;
 
-  memset (&data, 0, sizeof (data));
-  LINUX_PRPSINFO32_SWAP_FIELDS (abfd, prpsinfo, data);
-
+  swap_linux_prpsinfo32_out (abfd, prpsinfo, &data);
   return elfcore_write_note (abfd, buf, bufsiz, "CORE", NT_PRPSINFO,
                              &data, sizeof (data));
@@ -9344 +10139 @@
   struct elf_external_linux_prpsinfo64 data;
 
-  memset (&data, 0, sizeof (data));
-  LINUX_PRPSINFO64_SWAP_FIELDS (abfd, prpsinfo, data);
-
+  swap_linux_prpsinfo64_out (abfd, prpsinfo, &data);
   return elfcore_write_note (abfd, buf, bufsiz,
                              "CORE", NT_PRPSINFO, &data, sizeof (data));
@@ -9498 +10291 @@
                          const void *xfpregs, int size)
 {
-  char *note_name = "LINUX";
+  char *note_name;
+  if (get_elf_backend_data (abfd)->elf_osabi == ELFOSABI_FREEBSD)
+    note_name = "FreeBSD";
+  else
+    note_name = "LINUX";
   return elfcore_write_note (abfd, buf, bufsiz,
                              note_name, NT_X86_XSTATE, xfpregs, size);
@@ -9636 +10433 @@
   return elfcore_write_note (abfd, buf, bufsiz,
                              note_name, NT_S390_TDB, s390_tdb, size);
+}
+
+char *
+elfcore_write_s390_vxrs_low (bfd *abfd,
+                             char *buf,
+                             int *bufsiz,
+                             const void *s390_vxrs_low,
+                             int size)
+{
+  char *note_name = "LINUX";
+  return elfcore_write_note (abfd, buf, bufsiz,
+                             note_name, NT_S390_VXRS_LOW, s390_vxrs_low, size);
+}
+
+char *
+elfcore_write_s390_vxrs_high (bfd *abfd,
+                             char *buf,
+                             int *bufsiz,
+                             const void *s390_vxrs_high,
+                             int size)
+{
+  char *note_name = "LINUX";
+  return elfcore_write_note (abfd, buf, bufsiz,
+                             note_name, NT_S390_VXRS_HIGH,
+                             s390_vxrs_high, size);
 }
 
@@ -9722 +10544 @@
   if (strcmp (section, ".reg-s390-tdb") == 0)
     return elfcore_write_s390_tdb (abfd, buf, bufsiz, data, size);
+  if (strcmp (section, ".reg-s390-vxrs-low") == 0)
+    return elfcore_write_s390_vxrs_low (abfd, buf, bufsiz, data, size);
+  if (strcmp (section, ".reg-s390-vxrs-high") == 0)
+    return elfcore_write_s390_vxrs_high (abfd, buf, bufsiz, data, size);
   if (strcmp (section, ".reg-arm-vfp") == 0)
     return elfcore_write_arm_vfp (abfd, buf, bufsiz, data, size);
@@ -9769 +10595 @@
 
         case bfd_core:
-          if (CONST_STRNEQ (in.namedata, "NetBSD-CORE"))
+          {
+#define GROKER_ELEMENT(S,F) {S, sizeof (S) - 1, F}
+            struct
             {
-              if (! elfcore_grok_netbsd_note (abfd, &in))
-                return FALSE;
+              const char * string;
+              size_t len;
+              bfd_boolean (* func)(bfd *, Elf_Internal_Note *);
             }
-          else if (CONST_STRNEQ (in.namedata, "OpenBSD"))
+            grokers[] =
             {
-              if (! elfcore_grok_openbsd_note (abfd, &in))
-                return FALSE;
-            }
-          else if (CONST_STRNEQ (in.namedata, "QNX"))
-            {
-              if (! elfcore_grok_nto_note (abfd, &in))
-                return FALSE;
-            }
-          else if (CONST_STRNEQ (in.namedata, "SPU/"))
-            {
-              if (! elfcore_grok_spu_note (abfd, &in))
-                return FALSE;
-            }
-          else
-            {
-              if (! elfcore_grok_note (abfd, &in))
-                return FALSE;
-            }
-          break;
+              GROKER_ELEMENT ("", elfcore_grok_note),
+              GROKER_ELEMENT ("FreeBSD", elfcore_grok_freebsd_note),
+              GROKER_ELEMENT ("NetBSD-CORE", elfcore_grok_netbsd_note),
+              GROKER_ELEMENT ( "OpenBSD", elfcore_grok_openbsd_note),
+              GROKER_ELEMENT ("QNX", elfcore_grok_nto_note),
+              GROKER_ELEMENT ("SPU/", elfcore_grok_spu_note)
+            };
+#undef GROKER_ELEMENT
+            int i;
+
+            for (i = ARRAY_SIZE (grokers); i--;)
+              {
+                if (in.namesz >= grokers[i].len
+                    && strncmp (in.namedata, grokers[i].string,
+                                grokers[i].len) == 0)
+                  {
+                    if (! grokers[i].func (abfd, & in))
+                      return FALSE;
+                    break;
+                  }
+              }
+            break;
+          }
 
         case bfd_object:
@@ -9828 +10661 @@
     return FALSE;
 
-  buf = (char *) bfd_malloc (size);
+  buf = (char *) bfd_malloc (size + 1);
   if (buf == NULL)
     return FALSE;
+
+  /* PR 17512: file: ec08f814
+     0-termintate the buffer so that string searches will not overflow.  */
+  buf[size] = 0;
 
   if (bfd_bread (buf, size, abfd) != size
@@ -9952 +10789 @@
 }
 
+/* Adjust an address within a section.  Given OFFSET within SEC, return
+   the new offset within the section, based upon changes made to the
+   section.  Returns -1 if the offset is now invalid.
+   The offset (in abnd out) is in target sized bytes, however big a
+   byte may be.  */
+
 bfd_vma
 _bfd_elf_section_offset (bfd *abfd,
@@ -9965 +10808 @@
     case SEC_INFO_TYPE_EH_FRAME:
       return _bfd_elf_eh_frame_section_offset (abfd, info, sec, offset);
+
     default:
       if ((sec->flags & SEC_ELF_REVERSE_COPY) != 0)
         {
+          /* Reverse the offset.  */
           const struct elf_backend_data *bed = get_elf_backend_data (abfd);
           bfd_size_type address_size = bed->s->arch_size / 8;
-          offset = sec->size - offset - address_size;
+
+          /* address_size and sec->size are in octets.  Convert
+             to bytes before subtracting the original offset.  */
+          offset = (sec->size - address_size) / bfd_octets_per_byte (abfd) - offset;
         }
       return offset;