Vendor branch: Upgrade binutils 2.25 => 2.25.1
authorJohn Marino <draco@marino.st>
Wed, 4 Nov 2015 09:11:25 +0000 (10:11 +0100)
committerJohn Marino <draco@marino.st>
Wed, 4 Nov 2015 09:34:44 +0000 (10:34 +0100)
58 files changed:
contrib/binutils-2.25/bfd/archive.c
contrib/binutils-2.25/bfd/archive64.c
contrib/binutils-2.25/bfd/bfd-in2.h
contrib/binutils-2.25/bfd/coffgen.c
contrib/binutils-2.25/bfd/compress.c
contrib/binutils-2.25/bfd/doc/bfdver.texi
contrib/binutils-2.25/bfd/dwarf2.c
contrib/binutils-2.25/bfd/elf-attrs.c
contrib/binutils-2.25/bfd/elf-bfd.h
contrib/binutils-2.25/bfd/elf.c
contrib/binutils-2.25/bfd/elf32-i386.c
contrib/binutils-2.25/bfd/elf32-or1k.c
contrib/binutils-2.25/bfd/elf64-x86-64.c
contrib/binutils-2.25/bfd/elfcode.h
contrib/binutils-2.25/bfd/elflink.c
contrib/binutils-2.25/bfd/elfxx-target.h
contrib/binutils-2.25/bfd/format.c
contrib/binutils-2.25/bfd/libbfd.c
contrib/binutils-2.25/bfd/libbfd.h
contrib/binutils-2.25/bfd/linker.c
contrib/binutils-2.25/bfd/opncls.c
contrib/binutils-2.25/bfd/reloc.c
contrib/binutils-2.25/bfd/syms.c
contrib/binutils-2.25/bfd/tekhex.c
contrib/binutils-2.25/bfd/version.h
contrib/binutils-2.25/binutils/addr2line.c
contrib/binutils-2.25/binutils/ar.c
contrib/binutils-2.25/binutils/budbg.h
contrib/binutils-2.25/binutils/cxxfilt.c
contrib/binutils-2.25/binutils/dwarf.c
contrib/binutils-2.25/binutils/dwarf.h
contrib/binutils-2.25/binutils/elfcomm.c
contrib/binutils-2.25/binutils/elfcomm.h
contrib/binutils-2.25/binutils/nm.c
contrib/binutils-2.25/binutils/objcopy.c
contrib/binutils-2.25/binutils/objdump.c
contrib/binutils-2.25/binutils/prdbg.c
contrib/binutils-2.25/binutils/readelf.c
contrib/binutils-2.25/binutils/size.c
contrib/binutils-2.25/binutils/strings.c
contrib/binutils-2.25/gas/config/tc-i386.c
contrib/binutils-2.25/gas/doc/as.1
contrib/binutils-2.25/gas/doc/c-aarch64.texi
contrib/binutils-2.25/gas/doc/c-arm.texi
contrib/binutils-2.25/gas/doc/c-ppc.texi
contrib/binutils-2.25/gas/read.c
contrib/binutils-2.25/gold/powerpc.cc
contrib/binutils-2.25/gold/reloc.cc
contrib/binutils-2.25/gold/x86_64.cc
contrib/binutils-2.25/include/bfdlink.h
contrib/binutils-2.25/include/dwarf2.h
contrib/binutils-2.25/include/elf/internal.h
contrib/binutils-2.25/ld/emultempl/elf32.em
contrib/binutils-2.25/ld/ldexp.c
contrib/binutils-2.25/ld/ldexp.h
contrib/binutils-2.25/ld/ldlang.c
contrib/binutils-2.25/ld/ldlang.h
contrib/binutils-2.25/ld/ldmain.c

index df37996..34a9830 100644 (file)
@@ -311,8 +311,7 @@ _bfd_look_for_bfd_in_cache (bfd *arch_bfd, file_ptr filepos)
       struct ar_cache *entry = (struct ar_cache *) htab_find (hash_table, &m);
       if (!entry)
        return NULL;
-      else
-       return entry->arbfd;
+      return entry->arbfd;
     }
   else
     return NULL;
@@ -902,6 +901,10 @@ do_slurp_bsd_armap (bfd *abfd)
     return FALSE;
   parsed_size = mapdata->parsed_size;
   free (mapdata);
+  /* PR 17512: file: 883ff754.  */
+  /* PR 17512: file: 0458885f.  */
+  if (parsed_size < 4)
+    return FALSE;
 
   raw_armap = (bfd_byte *) bfd_zalloc (abfd, parsed_size);
   if (raw_armap == NULL)
@@ -1038,12 +1041,19 @@ do_slurp_coff_armap (bfd *abfd)
     }
 
   /* OK, build the carsyms.  */
-  for (i = 0; i < nsymz; i++)
+  for (i = 0; i < nsymz && stringsize > 0; i++)
     {
+      bfd_size_type len;
+
       rawptr = raw_armap + i;
       carsyms->file_offset = swap ((bfd_byte *) rawptr);
       carsyms->name = stringbase;
-      stringbase += strlen (stringbase) + 1;
+      /* PR 17512: file: 4a1d50c1.  */
+      len = strnlen (stringbase, stringsize);
+      if (len < stringsize)
+       len ++;
+      stringbase += len;
+      stringsize -= len;
       carsyms++;
     }
   *stringbase = 0;
@@ -1131,6 +1141,7 @@ bfd_slurp_armap (bfd *abfd)
        return FALSE;
       if (bfd_seek (abfd, -(file_ptr) (sizeof (hdr) + 20), SEEK_CUR) != 0)
        return FALSE;
+      extname[20] = 0;
       if (CONST_STRNEQ (extname, "__.SYMDEF SORTED")
          || CONST_STRNEQ (extname, "__.SYMDEF"))
        return do_slurp_bsd_armap (abfd);
@@ -1964,6 +1975,9 @@ bfd_generic_stat_arch_elt (bfd *abfd, struct stat *buf)
     }
 
   hdr = arch_hdr (abfd);
+  /* PR 17512: file: 3d9e9fe9.  */
+  if (hdr == NULL)
+    return -1;
 
 #define foo(arelt, stelt, size)                                \
   buf->stelt = strtol (hdr->arelt, &aloser, size);     \
index 6b87ec5..9d29b90 100644 (file)
@@ -46,6 +46,7 @@ bfd_elf64_archive_slurp_armap (bfd *abfd)
   struct areltdata *mapdata;
   bfd_byte int_buf[8];
   char *stringbase;
+  char *stringend;
   bfd_byte *raw_armap = NULL;
   carsym *carsyms;
   bfd_size_type amt;
@@ -92,11 +93,18 @@ bfd_elf64_archive_slurp_armap (bfd *abfd)
   ptrsize = 8 * nsymz;
 
   amt = carsym_size + stringsize + 1;
+  if (carsym_size < nsymz || ptrsize < nsymz || amt < nsymz)
+    {
+      bfd_set_error (bfd_error_malformed_archive);
+      return FALSE;
+    }
   ardata->symdefs = (struct carsym *) bfd_zalloc (abfd, amt);
   if (ardata->symdefs == NULL)
     return FALSE;
   carsyms = ardata->symdefs;
   stringbase = ((char *) ardata->symdefs) + carsym_size;
+  stringbase[stringsize] = 0;
+  stringend = stringbase + stringsize;
 
   raw_armap = (bfd_byte *) bfd_alloc (abfd, ptrsize);
   if (raw_armap == NULL)
@@ -114,7 +122,8 @@ bfd_elf64_archive_slurp_armap (bfd *abfd)
     {
       carsyms->file_offset = bfd_getb64 (raw_armap + i * 8);
       carsyms->name = stringbase;
-      stringbase += strlen (stringbase) + 1;
+      if (stringbase < stringend)
+       stringbase += strlen (stringbase) + 1;
       ++carsyms;
     }
   *stringbase = '\0';
index c7a2bb5..bca5181 100644 (file)
@@ -299,10 +299,13 @@ typedef struct bfd_section *sec_ptr;
 
 #define bfd_is_com_section(ptr) (((ptr)->flags & SEC_IS_COMMON) != 0)
 
+#define bfd_get_section_limit_octets(bfd, sec)                 \
+  ((bfd)->direction != write_direction && (sec)->rawsize != 0  \
+   ? (sec)->rawsize : (sec)->size)
+
 /* Find the address one past the end of SEC.  */
 #define bfd_get_section_limit(bfd, sec) \
-  (((bfd)->direction != write_direction && (sec)->rawsize != 0 \
-    ? (sec)->rawsize : (sec)->size) / bfd_octets_per_byte (bfd))
+  (bfd_get_section_limit_octets(bfd, sec) / bfd_octets_per_byte (bfd))
 
 /* Return TRUE if input section SEC has been discarded.  */
 #define discarded_section(sec)                         \
index a22f67a..d071d8a 100644 (file)
@@ -146,8 +146,9 @@ make_a_section_from_file (bfd *abfd,
   /* Compress/decompress DWARF debug sections with names: .debug_* and
      .zdebug_*, after the section flags is set.  */
   if ((flags & SEC_DEBUGGING)
+      && strlen (name) > 7
       && ((name[1] == 'd' && name[6] == '_')
-         || (name[1] == 'z' && name[7] == '_')))
+         || (strlen (name) > 8 && name[1] == 'z' && name[7] == '_')))
     {
       enum { nothing, compress, decompress } action = nothing;
       char *new_name = NULL;
@@ -365,6 +366,10 @@ coff_object_p (bfd *abfd)
          bfd_release (abfd, opthdr);
          return NULL;
        }
+      /* PR 17512: file: 11056-1136-0.004.  */
+      if (internal_f.f_opthdr < aoutsz)
+       memset (((char *) opthdr) + internal_f.f_opthdr, 0, aoutsz - internal_f.f_opthdr);
+
       bfd_coff_swap_aouthdr_in (abfd, opthdr, (void *) &internal_a);
       bfd_release (abfd, opthdr);
     }
@@ -463,7 +468,10 @@ _bfd_coff_internal_syment_name (bfd *abfd,
          if (strings == NULL)
            return NULL;
        }
-      if (sym->_n._n_n._n_offset >= obj_coff_strings_len (abfd))
+      /* PR 17910: Only check for string overflow if the length has been set.
+        Some DLLs, eg those produced by Visual Studio, may not set the length field.  */
+      if (obj_coff_strings_len (abfd) > 0
+         && sym->_n._n_n._n_offset >= obj_coff_strings_len (abfd))
        return NULL;
       return strings + sym->_n._n_n._n_offset;
     }
@@ -760,8 +768,9 @@ coff_renumber_symbols (bfd *bfd_ptr, int *first_undef)
 
   for (symbol_index = 0; symbol_index < symbol_count; symbol_index++)
     {
-      coff_symbol_type *coff_symbol_ptr = coff_symbol_from (bfd_ptr, symbol_ptr_ptr[symbol_index]);
+      coff_symbol_type *coff_symbol_ptr;
 
+      coff_symbol_ptr = coff_symbol_from (bfd_ptr, symbol_ptr_ptr[symbol_index]);
       symbol_ptr_ptr[symbol_index]->udata.i = symbol_index;
       if (coff_symbol_ptr && coff_symbol_ptr->native)
        {
@@ -805,9 +814,9 @@ coff_mangle_symbols (bfd *bfd_ptr)
 
   for (symbol_index = 0; symbol_index < symbol_count; symbol_index++)
     {
-      coff_symbol_type *coff_symbol_ptr =
-      coff_symbol_from (bfd_ptr, symbol_ptr_ptr[symbol_index]);
+      coff_symbol_type *coff_symbol_ptr;
 
+      coff_symbol_ptr = coff_symbol_from (bfd_ptr, symbol_ptr_ptr[symbol_index]);
       if (coff_symbol_ptr && coff_symbol_ptr->native)
        {
          int i;
@@ -1711,15 +1720,15 @@ _bfd_coff_read_string_table (bfd *abfd)
     }
 
   strings = (char *) bfd_malloc (strsize + 1);
+  if (strings == NULL)
+    return NULL;
+
   /* PR 17521 file: 079-54929-0.004.
      A corrupt file could contain an index that points into the first
      STRING_SIZE_SIZE bytes of the string table, so make sure that
      they are zero.  */
   memset (strings, 0, STRING_SIZE_SIZE);
 
-  if (strings == NULL)
-    return NULL;
-
   if (bfd_bread (strings + STRING_SIZE_SIZE, strsize - STRING_SIZE_SIZE, abfd)
       != strsize - STRING_SIZE_SIZE)
     {
@@ -1808,6 +1817,16 @@ coff_get_normalized_symtab (bfd *abfd)
       symbol_ptr = internal_ptr;
       internal_ptr->is_sym = TRUE;
 
+      /* PR 17512: file: 1353-1166-0.004.  */
+      if (symbol_ptr->u.syment.n_sclass == C_FILE
+         && symbol_ptr->u.syment.n_numaux > 0
+         && raw_src + symesz + symbol_ptr->u.syment.n_numaux
+         * symesz > raw_end)
+       {
+         bfd_release (abfd, internal);
+         return NULL;
+       }
+
       for (i = 0;
           i < symbol_ptr->u.syment.n_numaux;
           i++)
@@ -1815,7 +1834,10 @@ coff_get_normalized_symtab (bfd *abfd)
          internal_ptr++;
          /* PR 17512: Prevent buffer overrun.  */
          if (internal_ptr >= internal_end)
-           return NULL;
+           {
+             bfd_release (abfd, internal);
+             return NULL;
+           }
 
          raw_src += symesz;
          bfd_coff_swap_aux_in (abfd, (void *) raw_src,
@@ -1823,6 +1845,7 @@ coff_get_normalized_symtab (bfd *abfd)
                                symbol_ptr->u.syment.n_sclass,
                                (int) i, symbol_ptr->u.syment.n_numaux,
                                &(internal_ptr->u.auxent));
+
          internal_ptr->is_sym = FALSE;
          coff_pointerize_aux (abfd, internal, symbol_ptr, i,
                               internal_ptr);
index 20eef95..6a87258 100644 (file)
@@ -239,6 +239,8 @@ bfd_get_full_section_contents (bfd *abfd, sec_ptr sec, bfd_byte **ptr)
 #endif
 
     case COMPRESS_SECTION_DONE:
+      if (sec->contents == NULL)
+       return FALSE;
       if (p == NULL)
        {
          p = (bfd_byte *) bfd_malloc (sz);
@@ -246,7 +248,9 @@ bfd_get_full_section_contents (bfd *abfd, sec_ptr sec, bfd_byte **ptr)
            return FALSE;
          *ptr = p;
        }
-      memcpy (p, sec->contents, sz);
+      /* PR 17512; file: 5bc29788.  */
+      if (p != sec->contents)
+       memcpy (p, sec->contents, sz);
       return TRUE;
 
     default:
index e854b40..2bc0516 100644 (file)
@@ -1,4 +1,4 @@
-@set VERSION 2.25
+@set VERSION 2.25.1
 @set VERSION_PACKAGE (GNU Binutils) 
-@set UPDATED December 2014
+@set UPDATED July 2015
 @set BUGURL @uref{http://www.sourceware.org/bugzilla/}
index 93236a6..2ba36fd 100644 (file)
@@ -222,6 +222,9 @@ struct comp_unit
   /* The abbrev hash table.  */
   struct abbrev_info **abbrevs;
 
+  /* DW_AT_language.  */
+  int lang;
+
   /* Note that an error was found by comp_unit_find_nearest_line.  */
   int error;
 
@@ -553,83 +556,124 @@ read_section (bfd *           abfd,
   return TRUE;
 }
 
-/* VERBATIM
-   The following function up to the END VERBATIM mark are
-   copied directly from dwarf2read.c.  */
-
 /* Read dwarf information from a buffer.  */
 
 static unsigned int
-read_1_byte (bfd *abfd ATTRIBUTE_UNUSED, bfd_byte *buf)
+read_1_byte (bfd *abfd ATTRIBUTE_UNUSED, bfd_byte *buf, bfd_byte *end)
 {
+  if (buf + 1 > end)
+    return 0;
   return bfd_get_8 (abfd, buf);
 }
 
 static int
-read_1_signed_byte (bfd *abfd ATTRIBUTE_UNUSED, bfd_byte *buf)
+read_1_signed_byte (bfd *abfd ATTRIBUTE_UNUSED, bfd_byte *buf, bfd_byte *end)
 {
+  if (buf + 1 > end)
+    return 0;
   return bfd_get_signed_8 (abfd, buf);
 }
 
 static unsigned int
-read_2_bytes (bfd *abfd, bfd_byte *buf)
+read_2_bytes (bfd *abfd, bfd_byte *buf, bfd_byte *end)
 {
+  if (buf + 2 > end)
+    return 0;
   return bfd_get_16 (abfd, buf);
 }
 
 static unsigned int
-read_4_bytes (bfd *abfd, bfd_byte *buf)
+read_4_bytes (bfd *abfd, bfd_byte *buf, bfd_byte *end)
 {
+  if (buf + 4 > end)
+    return 0;
   return bfd_get_32 (abfd, buf);
 }
 
 static bfd_uint64_t
-read_8_bytes (bfd *abfd, bfd_byte *buf)
+read_8_bytes (bfd *abfd, bfd_byte *buf, bfd_byte *end)
 {
+  if (buf + 8 > end)
+    return 0;
   return bfd_get_64 (abfd, buf);
 }
 
 static bfd_byte *
 read_n_bytes (bfd *abfd ATTRIBUTE_UNUSED,
              bfd_byte *buf,
+             bfd_byte *end,
              unsigned int size ATTRIBUTE_UNUSED)
 {
+  if (buf + size > end)
+    return NULL;
   return buf;
 }
 
+/* Scans a NUL terminated string starting at BUF, returning a pointer to it.
+   Returns the number of characters in the string, *including* the NUL byte,
+   in BYTES_READ_PTR.  This value is set even if the function fails.  Bytes
+   at or beyond BUF_END will not be read.  Returns NULL if there was a
+   problem, or if the string is empty.  */
+
 static char *
-read_string (bfd *abfd ATTRIBUTE_UNUSED,
-            bfd_byte *buf,
-            unsigned int *bytes_read_ptr)
+read_string (bfd *          abfd ATTRIBUTE_UNUSED,
+            bfd_byte *     buf,
+            bfd_byte *     buf_end,
+            unsigned int * bytes_read_ptr)
 {
-  /* Return a pointer to the embedded string.  */
-  char *str = (char *) buf;
+  bfd_byte *str = buf;
+
+  if (buf >= buf_end)
+    {
+      * bytes_read_ptr = 0;
+      return NULL;
+    }
 
   if (*str == '\0')
     {
-      *bytes_read_ptr = 1;
+      * bytes_read_ptr = 1;
       return NULL;
     }
 
-  *bytes_read_ptr = strlen (str) + 1;
-  return str;
+  while (buf < buf_end)
+    if (* buf ++ == 0)
+      {
+       * bytes_read_ptr = buf - str;
+       return (char *) str;
+      }
+
+  * bytes_read_ptr = buf - str;
+  return NULL;
 }
 
-/* END VERBATIM */
+/* Reads an offset from BUF and then locates the string at this offset
+   inside the debug string section.  Returns a pointer to the string.
+   Returns the number of bytes read from BUF, *not* the length of the string,
+   in BYTES_READ_PTR.  This value is set even if the function fails.  Bytes
+   at or beyond BUF_END will not be read from BUF.  Returns NULL if there was
+   a problem, or if the string is empty.  Does not check for NUL termination
+   of the string.  */
 
 static char *
 read_indirect_string (struct comp_unit * unit,
                      bfd_byte *         buf,
+                     bfd_byte *         buf_end,
                      unsigned int *     bytes_read_ptr)
 {
   bfd_uint64_t offset;
   struct dwarf2_debug *stash = unit->stash;
   char *str;
 
+  if (buf + unit->offset_size > buf_end)
+    {
+      * bytes_read_ptr = 0;
+      return NULL;
+    }
+
   if (unit->offset_size == 4)
-    offset = read_4_bytes (unit->abfd, buf);
+    offset = read_4_bytes (unit->abfd, buf, buf_end);
   else
-    offset = read_8_bytes (unit->abfd, buf);
+    offset = read_8_bytes (unit->abfd, buf, buf_end);
 
   *bytes_read_ptr = unit->offset_size;
 
@@ -638,6 +682,8 @@ read_indirect_string (struct comp_unit * unit,
                      &stash->dwarf_str_buffer, &stash->dwarf_str_size))
     return NULL;
 
+  if (offset >= stash->dwarf_str_size)
+    return NULL;
   str = (char *) stash->dwarf_str_buffer + offset;
   if (*str == '\0')
     return NULL;
@@ -651,16 +697,23 @@ read_indirect_string (struct comp_unit * unit,
 static char *
 read_alt_indirect_string (struct comp_unit * unit,
                          bfd_byte *         buf,
+                         bfd_byte *         buf_end,
                          unsigned int *     bytes_read_ptr)
 {
   bfd_uint64_t offset;
   struct dwarf2_debug *stash = unit->stash;
   char *str;
 
+  if (buf + unit->offset_size > buf_end)
+    {
+      * bytes_read_ptr = 0;
+      return NULL;
+    }
+
   if (unit->offset_size == 4)
-    offset = read_4_bytes (unit->abfd, buf);
+    offset = read_4_bytes (unit->abfd, buf, buf_end);
   else
-    offset = read_8_bytes (unit->abfd, buf);
+    offset = read_8_bytes (unit->abfd, buf, buf_end);
 
   *bytes_read_ptr = unit->offset_size;
 
@@ -684,7 +737,7 @@ read_alt_indirect_string (struct comp_unit * unit,
        }
       stash->alt_bfd_ptr = debug_bfd;
     }
-  
+
   if (! read_section (unit->stash->alt_bfd_ptr,
                      stash->debug_sections + debug_str_alt,
                      NULL, /* FIXME: Do we need to load alternate symbols ?  */
@@ -693,6 +746,8 @@ read_alt_indirect_string (struct comp_unit * unit,
                      &stash->alt_dwarf_str_size))
     return NULL;
 
+  if (offset >= stash->alt_dwarf_str_size)
+    return NULL;
   str = (char *) stash->alt_dwarf_str_buffer + offset;
   if (*str == '\0')
     return NULL;
@@ -730,7 +785,7 @@ read_alt_indirect_ref (struct comp_unit * unit,
        }
       stash->alt_bfd_ptr = debug_bfd;
     }
-  
+
   if (! read_section (unit->stash->alt_bfd_ptr,
                      stash->debug_sections + debug_info_alt,
                      NULL, /* FIXME: Do we need to load alternate symbols ?  */
@@ -739,17 +794,22 @@ read_alt_indirect_ref (struct comp_unit * unit,
                      &stash->alt_dwarf_info_size))
     return NULL;
 
+  if (offset >= stash->alt_dwarf_info_size)
+    return NULL;
   return stash->alt_dwarf_info_buffer + offset;
 }
 
 static bfd_uint64_t
-read_address (struct comp_unit *unit, bfd_byte *buf)
+read_address (struct comp_unit *unit, bfd_byte *buf, bfd_byte * buf_end)
 {
   int signed_vma = 0;
 
   if (bfd_get_flavour (unit->abfd) == bfd_target_elf_flavour)
     signed_vma = get_elf_backend_data (unit->abfd)->sign_extend_vma;
 
+  if (buf + unit->addr_size > buf_end)
+    return 0;
+
   if (signed_vma)
     {
       switch (unit->addr_size)
@@ -812,6 +872,7 @@ read_abbrevs (bfd *abfd, bfd_uint64_t offset, struct dwarf2_debug *stash)
 {
   struct abbrev_info **abbrevs;
   bfd_byte *abbrev_ptr;
+  bfd_byte *abbrev_end;
   struct abbrev_info *cur_abbrev;
   unsigned int abbrev_number, bytes_read, abbrev_name;
   unsigned int abbrev_form, hash_number;
@@ -822,13 +883,17 @@ read_abbrevs (bfd *abfd, bfd_uint64_t offset, struct dwarf2_debug *stash)
                      &stash->dwarf_abbrev_buffer, &stash->dwarf_abbrev_size))
     return NULL;
 
+  if (offset >= stash->dwarf_abbrev_size)
+    return NULL;
+
   amt = sizeof (struct abbrev_info*) * ABBREV_HASH_SIZE;
   abbrevs = (struct abbrev_info **) bfd_zalloc (abfd, amt);
   if (abbrevs == NULL)
     return NULL;
 
   abbrev_ptr = stash->dwarf_abbrev_buffer + offset;
-  abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
+  abbrev_end = stash->dwarf_abbrev_buffer + stash->dwarf_abbrev_size;
+  abbrev_number = safe_read_leb128 (abfd, abbrev_ptr, &bytes_read, FALSE, abbrev_end);
   abbrev_ptr += bytes_read;
 
   /* Loop until we reach an abbrev number of 0.  */
@@ -842,15 +907,15 @@ read_abbrevs (bfd *abfd, bfd_uint64_t offset, struct dwarf2_debug *stash)
       /* Read in abbrev header.  */
       cur_abbrev->number = abbrev_number;
       cur_abbrev->tag = (enum dwarf_tag)
-       read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
+       safe_read_leb128 (abfd, abbrev_ptr, &bytes_read, FALSE, abbrev_end);
       abbrev_ptr += bytes_read;
-      cur_abbrev->has_children = read_1_byte (abfd, abbrev_ptr);
+      cur_abbrev->has_children = read_1_byte (abfd, abbrev_ptr, abbrev_end);
       abbrev_ptr += 1;
 
       /* Now read in declarations.  */
-      abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
+      abbrev_name = safe_read_leb128 (abfd, abbrev_ptr, &bytes_read, FALSE, abbrev_end);
       abbrev_ptr += bytes_read;
-      abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
+      abbrev_form = safe_read_leb128 (abfd, abbrev_ptr, &bytes_read, FALSE, abbrev_end);
       abbrev_ptr += bytes_read;
 
       while (abbrev_name)
@@ -885,9 +950,9 @@ read_abbrevs (bfd *abfd, bfd_uint64_t offset, struct dwarf2_debug *stash)
            = (enum dwarf_attribute) abbrev_name;
          cur_abbrev->attrs[cur_abbrev->num_attrs++].form
            = (enum dwarf_form) abbrev_form;
-         abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
+         abbrev_name = safe_read_leb128 (abfd, abbrev_ptr, &bytes_read, FALSE, abbrev_end);
          abbrev_ptr += bytes_read;
-         abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
+         abbrev_form = safe_read_leb128 (abfd, abbrev_ptr, &bytes_read, FALSE, abbrev_end);
          abbrev_ptr += bytes_read;
        }
 
@@ -905,9 +970,9 @@ read_abbrevs (bfd *abfd, bfd_uint64_t offset, struct dwarf2_debug *stash)
       if ((unsigned int) (abbrev_ptr - stash->dwarf_abbrev_buffer)
          >= stash->dwarf_abbrev_size)
        break;
-      abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
+      abbrev_number = safe_read_leb128 (abfd, abbrev_ptr, &bytes_read, FALSE, abbrev_end);
       abbrev_ptr += bytes_read;
-      if (lookup_abbrev (abbrev_number,abbrevs) != NULL)
+      if (lookup_abbrev (abbrev_number, abbrevs) != NULL)
        break;
     }
 
@@ -922,19 +987,29 @@ is_str_attr (enum dwarf_form form)
   return form == DW_FORM_string || form == DW_FORM_strp || form == DW_FORM_GNU_strp_alt;
 }
 
-/* Read an attribute value described by an attribute form.  */
+/* Read and fill in the value of attribute ATTR as described by FORM.
+   Read data starting from INFO_PTR, but never at or beyond INFO_PTR_END.
+   Returns an updated INFO_PTR taking into account the amount of data read.  */
 
 static bfd_byte *
-read_attribute_value (struct attribute *attr,
-                     unsigned form,
-                     struct comp_unit *unit,
-                     bfd_byte *info_ptr)
+read_attribute_value (struct attribute *  attr,
+                     unsigned            form,
+                     struct comp_unit *  unit,
+                     bfd_byte *          info_ptr,
+                     bfd_byte *          info_ptr_end)
 {
   bfd *abfd = unit->abfd;
   unsigned int bytes_read;
   struct dwarf_block *blk;
   bfd_size_type amt;
 
+  if (info_ptr >= info_ptr_end)
+    {
+      (*_bfd_error_handler) (_("Dwarf Error: Info pointer extends beyond end of attributes"));
+      bfd_set_error (bfd_error_bad_value);
+      return info_ptr;
+    }
+
   attr->form = (enum dwarf_form) form;
 
   switch (form)
@@ -945,23 +1020,23 @@ read_attribute_value (struct attribute *attr,
       if (unit->version == 3 || unit->version == 4)
        {
          if (unit->offset_size == 4)
-           attr->u.val = read_4_bytes (unit->abfd, info_ptr);
+           attr->u.val = read_4_bytes (unit->abfd, info_ptr, info_ptr_end);
          else
-           attr->u.val = read_8_bytes (unit->abfd, info_ptr);
+           attr->u.val = read_8_bytes (unit->abfd, info_ptr, info_ptr_end);
          info_ptr += unit->offset_size;
          break;
        }
       /* FALLTHROUGH */
     case DW_FORM_addr:
-      attr->u.val = read_address (unit, info_ptr);
+      attr->u.val = read_address (unit, info_ptr, info_ptr_end);
       info_ptr += unit->addr_size;
       break;
     case DW_FORM_GNU_ref_alt:
     case DW_FORM_sec_offset:
       if (unit->offset_size == 4)
-       attr->u.val = read_4_bytes (unit->abfd, info_ptr);
+       attr->u.val = read_4_bytes (unit->abfd, info_ptr, info_ptr_end);
       else
-       attr->u.val = read_8_bytes (unit->abfd, info_ptr);
+       attr->u.val = read_8_bytes (unit->abfd, info_ptr, info_ptr_end);
       info_ptr += unit->offset_size;
       break;
     case DW_FORM_block2:
@@ -969,9 +1044,9 @@ read_attribute_value (struct attribute *attr,
       blk = (struct dwarf_block *) bfd_alloc (abfd, amt);
       if (blk == NULL)
        return NULL;
-      blk->size = read_2_bytes (abfd, info_ptr);
+      blk->size = read_2_bytes (abfd, info_ptr, info_ptr_end);
       info_ptr += 2;
-      blk->data = read_n_bytes (abfd, info_ptr, blk->size);
+      blk->data = read_n_bytes (abfd, info_ptr, info_ptr_end, blk->size);
       info_ptr += blk->size;
       attr->u.blk = blk;
       break;
@@ -980,34 +1055,34 @@ read_attribute_value (struct attribute *attr,
       blk = (struct dwarf_block *) bfd_alloc (abfd, amt);
       if (blk == NULL)
        return NULL;
-      blk->size = read_4_bytes (abfd, info_ptr);
+      blk->size = read_4_bytes (abfd, info_ptr, info_ptr_end);
       info_ptr += 4;
-      blk->data = read_n_bytes (abfd, info_ptr, blk->size);
+      blk->data = read_n_bytes (abfd, info_ptr, info_ptr_end, blk->size);
       info_ptr += blk->size;
       attr->u.blk = blk;
       break;
     case DW_FORM_data2:
-      attr->u.val = read_2_bytes (abfd, info_ptr);
+      attr->u.val = read_2_bytes (abfd, info_ptr, info_ptr_end);
       info_ptr += 2;
       break;
     case DW_FORM_data4:
-      attr->u.val = read_4_bytes (abfd, info_ptr);
+      attr->u.val = read_4_bytes (abfd, info_ptr, info_ptr_end);
       info_ptr += 4;
       break;
     case DW_FORM_data8:
-      attr->u.val = read_8_bytes (abfd, info_ptr);
+      attr->u.val = read_8_bytes (abfd, info_ptr, info_ptr_end);
       info_ptr += 8;
       break;
     case DW_FORM_string:
-      attr->u.str = read_string (abfd, info_ptr, &bytes_read);
+      attr->u.str = read_string (abfd, info_ptr, info_ptr_end, &bytes_read);
       info_ptr += bytes_read;
       break;
     case DW_FORM_strp:
-      attr->u.str = read_indirect_string (unit, info_ptr, &bytes_read);
+      attr->u.str = read_indirect_string (unit, info_ptr, info_ptr_end, &bytes_read);
       info_ptr += bytes_read;
       break;
     case DW_FORM_GNU_strp_alt:
-      attr->u.str = read_alt_indirect_string (unit, info_ptr, &bytes_read);
+      attr->u.str = read_alt_indirect_string (unit, info_ptr, info_ptr_end, &bytes_read);
       info_ptr += bytes_read;
       break;
     case DW_FORM_exprloc:
@@ -1016,9 +1091,9 @@ read_attribute_value (struct attribute *attr,
       blk = (struct dwarf_block *) bfd_alloc (abfd, amt);
       if (blk == NULL)
        return NULL;
-      blk->size = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
+      blk->size = safe_read_leb128 (abfd, info_ptr, &bytes_read, FALSE, info_ptr_end);
       info_ptr += bytes_read;
-      blk->data = read_n_bytes (abfd, info_ptr, blk->size);
+      blk->data = read_n_bytes (abfd, info_ptr, info_ptr_end, blk->size);
       info_ptr += blk->size;
       attr->u.blk = blk;
       break;
@@ -1027,59 +1102,59 @@ read_attribute_value (struct attribute *attr,
       blk = (struct dwarf_block *) bfd_alloc (abfd, amt);
       if (blk == NULL)
        return NULL;
-      blk->size = read_1_byte (abfd, info_ptr);
+      blk->size = read_1_byte (abfd, info_ptr, info_ptr_end);
       info_ptr += 1;
-      blk->data = read_n_bytes (abfd, info_ptr, blk->size);
+      blk->data = read_n_bytes (abfd, info_ptr, info_ptr_end, blk->size);
       info_ptr += blk->size;
       attr->u.blk = blk;
       break;
     case DW_FORM_data1:
-      attr->u.val = read_1_byte (abfd, info_ptr);
+      attr->u.val = read_1_byte (abfd, info_ptr, info_ptr_end);
       info_ptr += 1;
       break;
     case DW_FORM_flag:
-      attr->u.val = read_1_byte (abfd, info_ptr);
+      attr->u.val = read_1_byte (abfd, info_ptr, info_ptr_end);
       info_ptr += 1;
       break;
     case DW_FORM_flag_present:
       attr->u.val = 1;
       break;
     case DW_FORM_sdata:
-      attr->u.sval = read_signed_leb128 (abfd, info_ptr, &bytes_read);
+      attr->u.sval = safe_read_leb128 (abfd, info_ptr, &bytes_read, TRUE, info_ptr_end);
       info_ptr += bytes_read;
       break;
     case DW_FORM_udata:
-      attr->u.val = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
+      attr->u.val = safe_read_leb128 (abfd, info_ptr, &bytes_read, FALSE, info_ptr_end);
       info_ptr += bytes_read;
       break;
     case DW_FORM_ref1:
-      attr->u.val = read_1_byte (abfd, info_ptr);
+      attr->u.val = read_1_byte (abfd, info_ptr, info_ptr_end);
       info_ptr += 1;
       break;
     case DW_FORM_ref2:
-      attr->u.val = read_2_bytes (abfd, info_ptr);
+      attr->u.val = read_2_bytes (abfd, info_ptr, info_ptr_end);
       info_ptr += 2;
       break;
     case DW_FORM_ref4:
-      attr->u.val = read_4_bytes (abfd, info_ptr);
+      attr->u.val = read_4_bytes (abfd, info_ptr, info_ptr_end);
       info_ptr += 4;
       break;
     case DW_FORM_ref8:
-      attr->u.val = read_8_bytes (abfd, info_ptr);
+      attr->u.val = read_8_bytes (abfd, info_ptr, info_ptr_end);
       info_ptr += 8;
       break;
     case DW_FORM_ref_sig8:
-      attr->u.val = read_8_bytes (abfd, info_ptr);
+      attr->u.val = read_8_bytes (abfd, info_ptr, info_ptr_end);
       info_ptr += 8;
       break;
     case DW_FORM_ref_udata:
-      attr->u.val = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
+      attr->u.val = safe_read_leb128 (abfd, info_ptr, &bytes_read, FALSE, info_ptr_end);
       info_ptr += bytes_read;
       break;
     case DW_FORM_indirect:
-      form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
+      form = safe_read_leb128 (abfd, info_ptr, &bytes_read, FALSE, info_ptr_end);
       info_ptr += bytes_read;
-      info_ptr = read_attribute_value (attr, form, unit, info_ptr);
+      info_ptr = read_attribute_value (attr, form, unit, info_ptr, info_ptr_end);
       break;
     default:
       (*_bfd_error_handler) (_("Dwarf Error: Invalid or unhandled FORM value: %#x."),
@@ -1093,16 +1168,44 @@ read_attribute_value (struct attribute *attr,
 /* Read an attribute described by an abbreviated attribute.  */
 
 static bfd_byte *
-read_attribute (struct attribute *attr,
-               struct attr_abbrev *abbrev,
-               struct comp_unit *unit,
-               bfd_byte *info_ptr)
+read_attribute (struct attribute *    attr,
+               struct attr_abbrev *  abbrev,
+               struct comp_unit *    unit,
+               bfd_byte *            info_ptr,
+               bfd_byte *            info_ptr_end)
 {
   attr->name = abbrev->name;
-  info_ptr = read_attribute_value (attr, abbrev->form, unit, info_ptr);
+  info_ptr = read_attribute_value (attr, abbrev->form, unit, info_ptr, info_ptr_end);
   return info_ptr;
 }
 
+/* Return whether DW_AT_name will return the same as DW_AT_linkage_name
+   for a function.  */
+
+static bfd_boolean
+non_mangled (int lang)
+{
+  switch (lang)
+    {
+    default:
+      return FALSE;
+
+    case DW_LANG_C89:
+    case DW_LANG_C:
+    case DW_LANG_Ada83:
+    case DW_LANG_Cobol74:
+    case DW_LANG_Cobol85:
+    case DW_LANG_Fortran77:
+    case DW_LANG_Pascal83:
+    case DW_LANG_C99:
+    case DW_LANG_Ada95:
+    case DW_LANG_PLI:
+    case DW_LANG_UPC:
+    case DW_LANG_C11:
+      return TRUE;
+    }
+}
+
 /* Source line information table routines.  */
 
 #define FILE_ALLOC_CHUNK 5
@@ -1161,14 +1264,15 @@ struct funcinfo
   struct funcinfo *caller_func;
   /* Source location file name where caller_func inlines this func.  */
   char *caller_file;
-  /* Source location line number where caller_func inlines this func.  */
-  int caller_line;
   /* Source location file name.  */
   char *file;
+  /* Source location line number where caller_func inlines this func.  */
+  int caller_line;
   /* Source location line number.  */
   int line;
   int tag;
-  char *name;
+  bfd_boolean is_linkage;
+  const char *name;
   struct arange arange;
   /* Where the symbol is defined.  */
   asection *sec;
@@ -1356,7 +1460,11 @@ concat_filename (struct line_info_table *table, unsigned int file)
       char *name;
       size_t len;
 
-      if (table->files[file - 1].dir)
+      if (table->files[file - 1].dir
+         /* PR 17512: file: 0317e960.  */
+         && table->files[file - 1].dir <= table->num_dirs
+         /* PR 17512: file: 7f3d2e4b.  */
+         && table->dirs != NULL)
        subdir_name = table->dirs[table->files[file - 1].dir - 1];
 
       if (!subdir_name || !IS_ABSOLUTE_PATH (subdir_name))
@@ -1577,27 +1685,47 @@ decode_line_info (struct comp_unit *unit, struct dwarf2_debug *stash)
 
   table->lcl_head = NULL;
 
+  if (stash->dwarf_line_size < 16)
+    {
+      (*_bfd_error_handler)
+       (_("Dwarf Error: Line info section is too small (%ld)"),
+        (long) stash->dwarf_line_size);
+      bfd_set_error (bfd_error_bad_value);
+      return NULL;
+    }
   line_ptr = stash->dwarf_line_buffer + unit->line_offset;
+  line_end = stash->dwarf_line_buffer + stash->dwarf_line_size;
 
   /* Read in the prologue.  */
-  lh.total_length = read_4_bytes (abfd, line_ptr);
+  lh.total_length = read_4_bytes (abfd, line_ptr, line_end);
   line_ptr += 4;
   offset_size = 4;
   if (lh.total_length == 0xffffffff)
     {
-      lh.total_length = read_8_bytes (abfd, line_ptr);
+      lh.total_length = read_8_bytes (abfd, line_ptr, line_end);
       line_ptr += 8;
       offset_size = 8;
     }
   else if (lh.total_length == 0 && unit->addr_size == 8)
     {
       /* Handle (non-standard) 64-bit DWARF2 formats.  */
-      lh.total_length = read_4_bytes (abfd, line_ptr);
+      lh.total_length = read_4_bytes (abfd, line_ptr, line_end);
       line_ptr += 4;
       offset_size = 8;
     }
+
+  if (lh.total_length > stash->dwarf_line_size)
+    {
+      (*_bfd_error_handler)
+       (_("Dwarf Error: Line info data is bigger (0x%lx) than the section (0x%lx)"),
+        (long) lh.total_length, (long) stash->dwarf_line_size);
+      bfd_set_error (bfd_error_bad_value);
+      return NULL;
+    }
+
   line_end = line_ptr + lh.total_length;
-  lh.version = read_2_bytes (abfd, line_ptr);
+
+  lh.version = read_2_bytes (abfd, line_ptr, line_end);
   if (lh.version < 2 || lh.version > 4)
     {
       (*_bfd_error_handler)
@@ -1606,20 +1734,32 @@ decode_line_info (struct comp_unit *unit, struct dwarf2_debug *stash)
       return NULL;
     }
   line_ptr += 2;
+
+  if (line_ptr + offset_size + (lh.version >=4 ? 6 : 5) >= line_end)
+    {
+      (*_bfd_error_handler)
+       (_("Dwarf Error: Ran out of room reading prologue"));
+      bfd_set_error (bfd_error_bad_value);
+      return NULL;
+    }
+
   if (offset_size == 4)
-    lh.prologue_length = read_4_bytes (abfd, line_ptr);
+    lh.prologue_length = read_4_bytes (abfd, line_ptr, line_end);
   else
-    lh.prologue_length = read_8_bytes (abfd, line_ptr);
+    lh.prologue_length = read_8_bytes (abfd, line_ptr, line_end);
   line_ptr += offset_size;
-  lh.minimum_instruction_length = read_1_byte (abfd, line_ptr);
+
+  lh.minimum_instruction_length = read_1_byte (abfd, line_ptr, line_end);
   line_ptr += 1;
+
   if (lh.version >= 4)
     {
-      lh.maximum_ops_per_insn = read_1_byte (abfd, line_ptr);
+      lh.maximum_ops_per_insn = read_1_byte (abfd, line_ptr, line_end);
       line_ptr += 1;
     }
   else
     lh.maximum_ops_per_insn = 1;
+
   if (lh.maximum_ops_per_insn == 0)
     {
       (*_bfd_error_handler)
@@ -1627,14 +1767,26 @@ decode_line_info (struct comp_unit *unit, struct dwarf2_debug *stash)
       bfd_set_error (bfd_error_bad_value);
       return NULL;
     }
-  lh.default_is_stmt = read_1_byte (abfd, line_ptr);
+
+  lh.default_is_stmt = read_1_byte (abfd, line_ptr, line_end);
   line_ptr += 1;
-  lh.line_base = read_1_signed_byte (abfd, line_ptr);
+
+  lh.line_base = read_1_signed_byte (abfd, line_ptr, line_end);
   line_ptr += 1;
-  lh.line_range = read_1_byte (abfd, line_ptr);
+
+  lh.line_range = read_1_byte (abfd, line_ptr, line_end);
   line_ptr += 1;
-  lh.opcode_base = read_1_byte (abfd, line_ptr);
+
+  lh.opcode_base = read_1_byte (abfd, line_ptr, line_end);
   line_ptr += 1;
+
+  if (line_ptr + (lh.opcode_base - 1) >= line_end)
+    {
+      (*_bfd_error_handler) (_("Dwarf Error: Ran out of room reading opcodes"));
+      bfd_set_error (bfd_error_bad_value);
+      return NULL;
+    }
+
   amt = lh.opcode_base * sizeof (unsigned char);
   lh.standard_opcode_lengths = (unsigned char *) bfd_alloc (abfd, amt);
 
@@ -1642,12 +1794,12 @@ decode_line_info (struct comp_unit *unit, struct dwarf2_debug *stash)
 
   for (i = 1; i < lh.opcode_base; ++i)
     {
-      lh.standard_opcode_lengths[i] = read_1_byte (abfd, line_ptr);
+      lh.standard_opcode_lengths[i] = read_1_byte (abfd, line_ptr, line_end);
       line_ptr += 1;
     }
 
   /* Read directory table.  */
-  while ((cur_dir = read_string (abfd, line_ptr, &bytes_read)) != NULL)
+  while ((cur_dir = read_string (abfd, line_ptr, line_end, &bytes_read)) != NULL)
     {
       line_ptr += bytes_read;
 
@@ -1670,7 +1822,7 @@ decode_line_info (struct comp_unit *unit, struct dwarf2_debug *stash)
   line_ptr += bytes_read;
 
   /* Read file name table.  */
-  while ((cur_file = read_string (abfd, line_ptr, &bytes_read)) != NULL)
+  while ((cur_file = read_string (abfd, line_ptr, line_end, &bytes_read)) != NULL)
     {
       line_ptr += bytes_read;
 
@@ -1689,13 +1841,11 @@ decode_line_info (struct comp_unit *unit, struct dwarf2_debug *stash)
 
       table->files[table->num_files].name = cur_file;
       table->files[table->num_files].dir =
-       read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
+       safe_read_leb128 (abfd, line_ptr, &bytes_read, FALSE, line_end);
       line_ptr += bytes_read;
-      table->files[table->num_files].time =
-       read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
+      table->files[table->num_files].time = safe_read_leb128 (abfd, line_ptr, &bytes_read, FALSE, line_end);
       line_ptr += bytes_read;
-      table->files[table->num_files].size =
-       read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
+      table->files[table->num_files].size = safe_read_leb128 (abfd, line_ptr, &bytes_read, FALSE, line_end);
       line_ptr += bytes_read;
       table->num_files++;
     }
@@ -1725,13 +1875,15 @@ decode_line_info (struct comp_unit *unit, struct dwarf2_debug *stash)
       /* Decode the table.  */
       while (! end_sequence)
        {
-         op_code = read_1_byte (abfd, line_ptr);
+         op_code = read_1_byte (abfd, line_ptr, line_end);
          line_ptr += 1;
 
          if (op_code >= lh.opcode_base)
            {
              /* Special operand.  */
              adj_opcode = op_code - lh.opcode_base;
+             if (lh.line_range == 0)
+               goto line_fail;
              if (lh.maximum_ops_per_insn == 1)
                address += (adj_opcode / lh.line_range
                            * lh.minimum_instruction_length);
@@ -1757,9 +1909,9 @@ decode_line_info (struct comp_unit *unit, struct dwarf2_debug *stash)
          else switch (op_code)
            {
            case DW_LNS_extended_op:
-             exop_len = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
+             exop_len = safe_read_leb128 (abfd, line_ptr, &bytes_read, FALSE, line_end);
              line_ptr += bytes_read;
-             extended_op = read_1_byte (abfd, line_ptr);
+             extended_op = read_1_byte (abfd, line_ptr, line_end);
              line_ptr += 1;
 
              switch (extended_op)
@@ -1778,12 +1930,12 @@ decode_line_info (struct comp_unit *unit, struct dwarf2_debug *stash)
                    goto line_fail;
                  break;
                case DW_LNE_set_address:
-                 address = read_address (unit, line_ptr);
+                 address = read_address (unit, line_ptr, line_end);
                  op_index = 0;
                  line_ptr += unit->addr_size;
                  break;
                case DW_LNE_define_file:
-                 cur_file = read_string (abfd, line_ptr, &bytes_read);
+                 cur_file = read_string (abfd, line_ptr, line_end, &bytes_read);
                  line_ptr += bytes_read;
                  if ((table->num_files % FILE_ALLOC_CHUNK) == 0)
                    {
@@ -1798,19 +1950,19 @@ decode_line_info (struct comp_unit *unit, struct dwarf2_debug *stash)
                    }
                  table->files[table->num_files].name = cur_file;
                  table->files[table->num_files].dir =
-                   read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
+                   safe_read_leb128 (abfd, line_ptr, &bytes_read, FALSE, line_end);
                  line_ptr += bytes_read;
                  table->files[table->num_files].time =
-                   read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
+                   safe_read_leb128 (abfd, line_ptr, &bytes_read, FALSE, line_end);
                  line_ptr += bytes_read;
                  table->files[table->num_files].size =
-                   read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
+                   safe_read_leb128 (abfd, line_ptr, &bytes_read, FALSE, line_end);
                  line_ptr += bytes_read;
                  table->num_files++;
                  break;
                case DW_LNE_set_discriminator:
                  discriminator =
-                   read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
+                   safe_read_leb128 (abfd, line_ptr, &bytes_read, FALSE, line_end);
                  line_ptr += bytes_read;
                  break;
                case DW_LNE_HP_source_file_correlation:
@@ -1839,12 +1991,12 @@ decode_line_info (struct comp_unit *unit, struct dwarf2_debug *stash)
            case DW_LNS_advance_pc:
              if (lh.maximum_ops_per_insn == 1)
                address += (lh.minimum_instruction_length
-                           * read_unsigned_leb128 (abfd, line_ptr,
-                                                   &bytes_read));
+                           * safe_read_leb128 (abfd, line_ptr, &bytes_read,
+                                               FALSE, line_end));
              else
                {
-                 bfd_vma adjust = read_unsigned_leb128 (abfd, line_ptr,
-                                                        &bytes_read);
+                 bfd_vma adjust = safe_read_leb128 (abfd, line_ptr, &bytes_read,
+                                                    FALSE, line_end);
                  address = ((op_index + adjust) / lh.maximum_ops_per_insn
                             * lh.minimum_instruction_length);
                  op_index = (op_index + adjust) % lh.maximum_ops_per_insn;
@@ -1852,7 +2004,7 @@ decode_line_info (struct comp_unit *unit, struct dwarf2_debug *stash)
              line_ptr += bytes_read;
              break;
            case DW_LNS_advance_line:
-             line += read_signed_leb128 (abfd, line_ptr, &bytes_read);
+             line += safe_read_leb128 (abfd, line_ptr, &bytes_read, TRUE, line_end);
              line_ptr += bytes_read;
              break;
            case DW_LNS_set_file:
@@ -1861,7 +2013,7 @@ decode_line_info (struct comp_unit *unit, struct dwarf2_debug *stash)
 
                /* The file and directory tables are 0
                   based, the references are 1 based.  */
-               file = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
+               file = safe_read_leb128 (abfd, line_ptr, &bytes_read, FALSE, line_end);
                line_ptr += bytes_read;
                if (filename)
                  free (filename);
@@ -1869,7 +2021,7 @@ decode_line_info (struct comp_unit *unit, struct dwarf2_debug *stash)
                break;
              }
            case DW_LNS_set_column:
-             column = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
+             column = safe_read_leb128 (abfd, line_ptr, &bytes_read, FALSE, line_end);
              line_ptr += bytes_read;
              break;
            case DW_LNS_negate_stmt:
@@ -1891,7 +2043,7 @@ decode_line_info (struct comp_unit *unit, struct dwarf2_debug *stash)
                }
              break;
            case DW_LNS_fixed_advance_pc:
-             address += read_2_bytes (abfd, line_ptr);
+             address += read_2_bytes (abfd, line_ptr, line_end);
              op_index = 0;
              line_ptr += 2;
              break;
@@ -1899,7 +2051,7 @@ decode_line_info (struct comp_unit *unit, struct dwarf2_debug *stash)
              /* Unknown standard opcode, ignore it.  */
              for (i = 0; i < lh.standard_opcode_lengths[op_code]; i++)
                {
-                 (void) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
+                 (void) safe_read_leb128 (abfd, line_ptr, &bytes_read, FALSE, line_end);
                  line_ptr += bytes_read;
                }
              break;
@@ -1992,7 +2144,7 @@ read_debug_ranges (struct comp_unit *unit)
 
 /* Function table functions.  */
 
-/* If ADDR is within UNIT's function tables, set FUNCTIONNAME_PTR, and return
+/* If ADDR is within UNIT's function tables, set FUNCTION_PTR, and return
    TRUE.  Note that we need to find the function that has the smallest range
    that contains ADDR, to handle inlined functions without depending upon
    them being ordered in TABLE by increasing range.  */
@@ -2000,8 +2152,7 @@ read_debug_ranges (struct comp_unit *unit)
 static bfd_boolean
 lookup_address_in_function_table (struct comp_unit *unit,
                                  bfd_vma addr,
-                                 struct funcinfo **function_ptr,
-                                 const char **functionname_ptr)
+                                 struct funcinfo **function_ptr)
 {
   struct funcinfo* each_func;
   struct funcinfo* best_fit = NULL;
@@ -2030,14 +2181,10 @@ lookup_address_in_function_table (struct comp_unit *unit,
 
   if (best_fit)
     {
-      *functionname_ptr = best_fit->name;
       *function_ptr = best_fit;
       return TRUE;
     }
-  else
-    {
-      return FALSE;
-    }
+  return FALSE;
 }
 
 /* If SYM at ADDR is within function table of UNIT, set FILENAME_PTR
@@ -2128,10 +2275,12 @@ lookup_symbol_in_variable_table (struct comp_unit *unit,
 
 static char *
 find_abstract_instance_name (struct comp_unit *unit,
-                            struct attribute *attr_ptr)
+                            struct attribute *attr_ptr,
+                            bfd_boolean *is_linkage)
 {
   bfd *abfd = unit->abfd;
   bfd_byte *info_ptr;
+  bfd_byte *info_ptr_end;
   unsigned int abbrev_number, bytes_read, i;
   struct abbrev_info *abbrev;
   bfd_uint64_t die_ref = attr_ptr->u.val;
@@ -2148,6 +2297,7 @@ find_abstract_instance_name (struct comp_unit *unit,
        abort ();
 
       info_ptr = unit->sec_info_ptr + die_ref;
+      info_ptr_end = unit->end_ptr;
 
       /* Now find the CU containing this pointer.  */
       if (info_ptr >= unit->info_ptr_unit && info_ptr < unit->end_ptr)
@@ -2179,15 +2329,20 @@ find_abstract_instance_name (struct comp_unit *unit,
          (*_bfd_error_handler)
            (_("Dwarf Error: Unable to read alt ref %u."), die_ref);
          bfd_set_error (bfd_error_bad_value);
-         return name;
+         return NULL;
        }
+      info_ptr_end = unit->stash->alt_dwarf_info_buffer + unit->stash->alt_dwarf_info_size;
+
       /* FIXME: Do we need to locate the correct CU, in a similar
         fashion to the code in the DW_FORM_ref_addr case above ?  */
     }
   else
-    info_ptr = unit->info_ptr_unit + die_ref;
+    {
+      info_ptr = unit->info_ptr_unit + die_ref;
+      info_ptr_end = unit->end_ptr;
+    }
 
-  abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
+  abbrev_number = safe_read_leb128 (abfd, info_ptr, &bytes_read, FALSE, info_ptr_end);
   info_ptr += bytes_read;
 
   if (abbrev_number)
@@ -2204,7 +2359,7 @@ find_abstract_instance_name (struct comp_unit *unit,
          for (i = 0; i < abbrev->num_attrs; ++i)
            {
              info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit,
-                                        info_ptr);
+                                        info_ptr, info_ptr_end);
              if (info_ptr == NULL)
                break;
              switch (attr.name)
@@ -2213,17 +2368,24 @@ find_abstract_instance_name (struct comp_unit *unit,
                  /* Prefer DW_AT_MIPS_linkage_name or DW_AT_linkage_name
                     over DW_AT_name.  */
                  if (name == NULL && is_str_attr (attr.form))
-                   name = attr.u.str;
+                   {
+                     name = attr.u.str;
+                     if (non_mangled (unit->lang))
+                       *is_linkage = TRUE;
+                   }
                  break;
                case DW_AT_specification:
-                 name = find_abstract_instance_name (unit, &attr);
+                 name = find_abstract_instance_name (unit, &attr, is_linkage);
                  break;
                case DW_AT_linkage_name:
                case DW_AT_MIPS_linkage_name:
                  /* PR 16949:  Corrupt debug info can place
                     non-string forms into these attributes.  */
                  if (is_str_attr (attr.form))
-                   name = attr.u.str;
+                   {
+                     name = attr.u.str;
+                     *is_linkage = TRUE;
+                   }
                  break;
                default:
                  break;
@@ -2239,6 +2401,7 @@ read_rangelist (struct comp_unit *unit, struct arange *arange,
                bfd_uint64_t offset)
 {
   bfd_byte *ranges_ptr;
+  bfd_byte *ranges_end;
   bfd_vma base_address = unit->base_address;
 
   if (! unit->stash->dwarf_ranges_buffer)
@@ -2246,16 +2409,24 @@ read_rangelist (struct comp_unit *unit, struct arange *arange,
       if (! read_debug_ranges (unit))
        return FALSE;
     }
+
   ranges_ptr = unit->stash->dwarf_ranges_buffer + offset;
+  if (ranges_ptr < unit->stash->dwarf_ranges_buffer)
+    return FALSE;
+  ranges_end = unit->stash->dwarf_ranges_buffer + unit->stash->dwarf_ranges_size;
 
   for (;;)
     {
       bfd_vma low_pc;
       bfd_vma high_pc;
 
-      low_pc = read_address (unit, ranges_ptr);
+      /* PR 17512: file: 62cada7d.  */
+      if (ranges_ptr + 2 * unit->addr_size > ranges_end)
+       return FALSE;
+
+      low_pc = read_address (unit, ranges_ptr, ranges_end);
       ranges_ptr += unit->addr_size;
-      high_pc = read_address (unit, ranges_ptr);
+      high_pc = read_address (unit, ranges_ptr, ranges_end);
       ranges_ptr += unit->addr_size;
 
       if (low_pc == 0 && high_pc == 0)
@@ -2282,6 +2453,7 @@ scan_unit_for_symbols (struct comp_unit *unit)
 {
   bfd *abfd = unit->abfd;
   bfd_byte *info_ptr = unit->first_child_die_ptr;
+  bfd_byte *info_ptr_end = unit->stash->info_ptr_end;
   int nesting_level = 1;
   struct funcinfo **nested_funcs;
   int nested_funcs_size;
@@ -2306,7 +2478,11 @@ scan_unit_for_symbols (struct comp_unit *unit)
       bfd_vma high_pc = 0;
       bfd_boolean high_pc_relative = FALSE;
 
-      abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
+      /* PR 17512: file: 9f405d9d.  */
+      if (info_ptr >= info_ptr_end)
+       goto fail;
+
+      abbrev_number = safe_read_leb128 (abfd, info_ptr, &bytes_read, FALSE, info_ptr_end);
       info_ptr += bytes_read;
 
       if (! abbrev_number)
@@ -2370,7 +2546,7 @@ scan_unit_for_symbols (struct comp_unit *unit)
 
       for (i = 0; i < abbrev->num_attrs; ++i)
        {
-         info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr);
+         info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr, info_ptr_end);
          if (info_ptr == NULL)
            goto fail;
 
@@ -2389,14 +2565,19 @@ scan_unit_for_symbols (struct comp_unit *unit)
 
                case DW_AT_abstract_origin:
                case DW_AT_specification:
-                 func->name = find_abstract_instance_name (unit, &attr);
+                 func->name = find_abstract_instance_name (unit, &attr,
+                                                           &func->is_linkage);
                  break;
 
                case DW_AT_name:
                  /* Prefer DW_AT_MIPS_linkage_name or DW_AT_linkage_name
                     over DW_AT_name.  */
                  if (func->name == NULL && is_str_attr (attr.form))
-                   func->name = attr.u.str;
+                   {
+                     func->name = attr.u.str;
+                     if (non_mangled (unit->lang))
+                       func->is_linkage = TRUE;
+                   }
                  break;
 
                case DW_AT_linkage_name:
@@ -2404,7 +2585,10 @@ scan_unit_for_symbols (struct comp_unit *unit)
                  /* PR 16949:  Corrupt debug info can place
                     non-string forms into these attributes.  */
                  if (is_str_attr (attr.form))
-                   func->name = attr.u.str;
+                   {
+                     func->name = attr.u.str;
+                     func->is_linkage = TRUE;
+                   }
                  break;
 
                case DW_AT_low_pc:
@@ -2560,15 +2744,15 @@ parse_comp_unit (struct dwarf2_debug *stash,
   bfd *abfd = stash->bfd_ptr;
   bfd_boolean high_pc_relative = FALSE;
 
-  version = read_2_bytes (abfd, info_ptr);
+  version = read_2_bytes (abfd, info_ptr, end_ptr);
   info_ptr += 2;
   BFD_ASSERT (offset_size == 4 || offset_size == 8);
   if (offset_size == 4)
-    abbrev_offset = read_4_bytes (abfd, info_ptr);
+    abbrev_offset = read_4_bytes (abfd, info_ptr, end_ptr);
   else
-    abbrev_offset = read_8_bytes (abfd, info_ptr);
+    abbrev_offset = read_8_bytes (abfd, info_ptr, end_ptr);
   info_ptr += offset_size;
-  addr_size = read_1_byte (abfd, info_ptr);
+  addr_size = read_1_byte (abfd, info_ptr, end_ptr);
   info_ptr += 1;
 
   if (version != 2 && version != 3 && version != 4)
@@ -2605,7 +2789,7 @@ parse_comp_unit (struct dwarf2_debug *stash,
   if (! abbrevs)
     return 0;
 
-  abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
+  abbrev_number = safe_read_leb128 (abfd, info_ptr, &bytes_read, FALSE, end_ptr);
   info_ptr += bytes_read;
   if (! abbrev_number)
     {
@@ -2640,7 +2824,7 @@ parse_comp_unit (struct dwarf2_debug *stash,
 
   for (i = 0; i < abbrev->num_attrs; ++i)
     {
-      info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr);
+      info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr, end_ptr);
       if (info_ptr == NULL)
        return NULL;
 
@@ -2679,6 +2863,15 @@ parse_comp_unit (struct dwarf2_debug *stash,
        case DW_AT_comp_dir:
          {
            char *comp_dir = attr.u.str;
+
+           /* PR 17512: file: 1fe726be.  */
+           if (! is_str_attr (attr.form))
+             {
+               (*_bfd_error_handler)
+                 (_("Dwarf Error: DW_AT_comp_dir attribute encountered with a non-string form."));
+               comp_dir = NULL;
+             }
+
            if (comp_dir)
              {
                /* Irix 6.2 native cc prepends <machine>.: to the compilation
@@ -2692,6 +2885,10 @@ parse_comp_unit (struct dwarf2_debug *stash,
            break;
          }
 
+       case DW_AT_language:
+         unit->lang = attr.u.val;
+         break;
+
        default:
          break;
        }
@@ -2736,7 +2933,7 @@ comp_unit_contains_address (struct comp_unit *unit, bfd_vma addr)
 
 /* If UNIT contains ADDR, set the output parameters to the values for
    the line containing ADDR.  The output parameters, FILENAME_PTR,
-   FUNCTIONNAME_PTR, and LINENUMBER_PTR, are pointers to the objects
+   FUNCTION_PTR, and LINENUMBER_PTR, are pointers to the objects
    to be filled in.
 
    Returns the range of addresses covered by the entry that was used
@@ -2746,13 +2943,12 @@ static bfd_vma
 comp_unit_find_nearest_line (struct comp_unit *unit,
                             bfd_vma addr,
                             const char **filename_ptr,
-                            const char **functionname_ptr,
+                            struct funcinfo **function_ptr,
                             unsigned int *linenumber_ptr,
                             unsigned int *discriminator_ptr,
                             struct dwarf2_debug *stash)
 {
   bfd_boolean func_p;
-  struct funcinfo *function;
 
   if (unit->error)
     return FALSE;
@@ -2781,11 +2977,10 @@ comp_unit_find_nearest_line (struct comp_unit *unit,
        }
     }
 
-  function = NULL;
-  func_p = lookup_address_in_function_table (unit, addr,
-                                            &function, functionname_ptr);
-  if (func_p && (function->tag == DW_TAG_inlined_subroutine))
-    stash->inliner_chain = function;
+  *function_ptr = NULL;
+  func_p = lookup_address_in_function_table (unit, addr, function_ptr);
+  if (func_p && (*function_ptr)->tag == DW_TAG_inlined_subroutine)
+    stash->inliner_chain = *function_ptr;
 
   return lookup_address_in_line_info_table (unit->line_table, addr,
                                            filename_ptr,
@@ -3593,6 +3788,57 @@ _bfd_dwarf2_slurp_debug_info (bfd *abfd, bfd *debug_bfd,
   return TRUE;
 }
 
+/* Scan the debug information in PINFO looking for a DW_TAG_subprogram
+   abbrev with a DW_AT_low_pc attached to it.  Then lookup that same
+   symbol in SYMBOLS and return the difference between the low_pc and
+   the symbol's address.  Returns 0 if no suitable symbol could be found.  */
+
+bfd_signed_vma
+_bfd_dwarf2_find_symbol_bias (asymbol ** symbols, void ** pinfo)
+{
+  struct dwarf2_debug *stash;
+  struct comp_unit * unit;
+
+  stash = (struct dwarf2_debug *) *pinfo;
+
+  if (stash == NULL)
+    return 0;
+
+  for (unit = stash->all_comp_units; unit; unit = unit->next_unit)
+    {
+      struct funcinfo * func;
+
+      if (unit->function_table == NULL)
+       {
+         if (unit->line_table == NULL)
+           unit->line_table = decode_line_info (unit, stash);
+         if (unit->line_table != NULL)
+           scan_unit_for_symbols (unit);
+       }
+
+      for (func = unit->function_table; func != NULL; func = func->prev_func)
+       if (func->name && func->arange.low)
+         {
+           asymbol ** psym;
+
+           /* FIXME: Do we need to scan the aranges looking for the lowest pc value ?  */
+
+           for (psym = symbols; * psym != NULL; psym++)
+             {
+               asymbol * sym = * psym;
+
+               if (sym->flags & BSF_FUNCTION
+                   && sym->section != NULL
+                   && strcmp (sym->name, func->name) == 0)
+                 return ((bfd_signed_vma) func->arange.low) -
+                   ((bfd_signed_vma) (sym->value + sym->section->vma));
+             }
+         }
+    }
+
+  return 0;
+}
+
 /* Find the source code location of SYMBOL.  If SYMBOL is NULL
    then find the nearest source code location corresponding to
    the address SECTION + OFFSET.
@@ -3631,6 +3877,7 @@ _bfd_dwarf2_find_nearest_line (bfd *abfd,
   /* What address are we looking for?  */
   bfd_vma addr;
   struct comp_unit* each;
+  struct funcinfo *function = NULL;
   bfd_boolean found = FALSE;
   bfd_boolean do_line;
 
@@ -3713,7 +3960,7 @@ _bfd_dwarf2_find_nearest_line (bfd *abfd,
     {
       bfd_vma min_range = (bfd_vma) -1;
       const char * local_filename = NULL;
-      const char * local_functionname = NULL;
+      struct funcinfo *local_function = NULL;
       unsigned int local_linenumber = 0;
       unsigned int local_discriminator = 0;
 
@@ -3725,7 +3972,7 @@ _bfd_dwarf2_find_nearest_line (bfd *abfd,
                    || comp_unit_contains_address (each, addr))
                   && (range = comp_unit_find_nearest_line (each, addr,
                                                            & local_filename,
-                                                           & local_functionname,
+                                                           & local_function,
                                                            & local_linenumber,
                                                            & local_discriminator,
                                                            stash)) != 0);
@@ -3746,8 +3993,8 @@ _bfd_dwarf2_find_nearest_line (bfd *abfd,
                {
                  if (filename_ptr && local_filename)
                    * filename_ptr = local_filename;
-                 if (functionname_ptr && local_functionname)
-                   * functionname_ptr = local_functionname;
+                 if (local_function)
+                   function = local_function;
                  if (discriminator_ptr && local_discriminator)
                    * discriminator_ptr = local_discriminator;
                  if (local_linenumber)
@@ -3778,13 +4025,13 @@ _bfd_dwarf2_find_nearest_line (bfd *abfd,
       unsigned int offset_size = addr_size;
       bfd_byte *info_ptr_unit = stash->info_ptr;
 
-      length = read_4_bytes (stash->bfd_ptr, stash->info_ptr);
+      length = read_4_bytes (stash->bfd_ptr, stash->info_ptr, stash->info_ptr_end);
       /* A 0xffffff length is the DWARF3 way of indicating
         we use 64-bit offsets, instead of 32-bit offsets.  */
       if (length == 0xffffffff)
        {
          offset_size = 8;
-         length = read_8_bytes (stash->bfd_ptr, stash->info_ptr + 4);
+         length = read_8_bytes (stash->bfd_ptr, stash->info_ptr + 4, stash->info_ptr_end);
          stash->info_ptr += 12;
        }
       /* A zero length is the IRIX way of indicating 64-bit offsets,
@@ -3793,7 +4040,7 @@ _bfd_dwarf2_find_nearest_line (bfd *abfd,
       else if (length == 0)
        {
          offset_size = 8;
-         length = read_4_bytes (stash->bfd_ptr, stash->info_ptr + 4);
+         length = read_4_bytes (stash->bfd_ptr, stash->info_ptr + 4, stash->info_ptr_end);
          stash->info_ptr += 8;
        }
       /* In the absence of the hints above, we assume 32-bit DWARF2
@@ -3815,13 +4062,25 @@ _bfd_dwarf2_find_nearest_line (bfd *abfd,
 
       if (length > 0)
        {
+         bfd_byte * new_ptr;
+
          each = parse_comp_unit (stash, length, info_ptr_unit,
                                  offset_size);
          if (!each)
            /* The dwarf information is damaged, don't trust it any
               more.  */
            break;
-         stash->info_ptr += length;
+
+         new_ptr = stash->info_ptr + length;
+         /* PR 17512: file: 1500698c.  */
+         if (new_ptr < stash->info_ptr)
+           {
+             /* A corrupt length value - do not trust the info any more.  */
+             found = FALSE;
+             break;
+           }
+         else
+           stash->info_ptr = new_ptr;
 
          if (stash->all_comp_units)
            stash->all_comp_units->prev_unit = each;
@@ -3849,7 +4108,7 @@ _bfd_dwarf2_find_nearest_line (bfd *abfd,
                      || comp_unit_contains_address (each, addr))
                     && comp_unit_find_nearest_line (each, addr,
                                                     filename_ptr,
-                                                    functionname_ptr,
+                                                    &function,
                                                     linenumber_ptr,
                                                     discriminator_ptr,
                                                     stash) != 0);
@@ -3868,6 +4127,19 @@ _bfd_dwarf2_find_nearest_line (bfd *abfd,
     }
 
  done:
+  if (function)
+    {
+      if (!function->is_linkage
+         && _bfd_elf_find_function (abfd, symbols, section, offset,
+                                    *filename_ptr ? NULL : filename_ptr,
+                                    functionname_ptr))
+       {
+         function->name = *functionname_ptr;
+         function->is_linkage = TRUE;
+       }
+      else
+       *functionname_ptr = function->name;
+    }
   if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0)
     unset_sections (stash);
 
@@ -3985,3 +4257,109 @@ _bfd_dwarf2_cleanup_debug_info (bfd *abfd, void **pinfo)
   if (stash->alt_bfd_ptr)
     bfd_close (stash->alt_bfd_ptr);
 }
+
+/* Find the function to a particular section and offset,
+   for error reporting.  */
+
+bfd_boolean
+_bfd_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;
+
+  if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
+    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;
+}
index cd0cbca..d20bbdd 100644 (file)
@@ -430,9 +430,13 @@ _bfd_elf_parse_attributes (bfd *abfd, Elf_Internal_Shdr * hdr)
 {
   bfd_byte *contents;
   bfd_byte *p;
+  bfd_byte *p_end;
   bfd_vma len;
   const char *std_sec;
 
+  /* PR 17512: file: 2844a11d.  */
+  if (hdr->sh_size == 0)
+    return;
   contents = (bfd_byte *) bfd_malloc (hdr->sh_size);
   if (!contents)
     return;
@@ -443,11 +447,12 @@ _bfd_elf_parse_attributes (bfd *abfd, Elf_Internal_Shdr * hdr)
       return;
     }
   p = contents;
+  p_end = p + hdr->sh_size;
   std_sec = get_elf_backend_data (abfd)->obj_attrs_vendor;
   if (*(p++) == 'A')
     {
       len = hdr->sh_size - 1;
-      while (len > 0)
+      while (len > 0 && p < p_end - 4)
        {
          unsigned namelen;
          bfd_vma section_len;
@@ -455,6 +460,8 @@ _bfd_elf_parse_attributes (bfd *abfd, Elf_Internal_Shdr * hdr)
 
          section_len = bfd_get_32 (abfd, p);
          p += 4;
+         if (section_len == 0)
+           break;
          if (section_len > len)
            section_len = len;
          len -= section_len;
@@ -475,7 +482,7 @@ _bfd_elf_parse_attributes (bfd *abfd, Elf_Internal_Shdr * hdr)
            }
 
          p += namelen;
-         while (section_len > 0)
+         while (section_len > 0 && p < p_end)
            {
              int tag;
              unsigned int n;
@@ -483,15 +490,23 @@ _bfd_elf_parse_attributes (bfd *abfd, Elf_Internal_Shdr * hdr)
              bfd_vma subsection_len;
              bfd_byte *end;
 
-             tag = read_unsigned_leb128 (abfd, p, &n);
+             tag = safe_read_leb128 (abfd, p, &n, FALSE, p_end);
              p += n;
-             subsection_len = bfd_get_32 (abfd, p);
+             if (p < p_end - 4)
+               subsection_len = bfd_get_32 (abfd, p);
+             else
+               subsection_len = 0;
              p += 4;
+             if (subsection_len == 0)
+               break;
              if (subsection_len > section_len)
                subsection_len = section_len;
              section_len -= subsection_len;
              subsection_len -= n + 4;
              end = p + subsection_len;
+             /* PR 17512: file: 0e8c0c90.  */
+             if (end > p_end)
+               end = p_end;
              switch (tag)
                {
                case Tag_File:
@@ -499,25 +514,25 @@ _bfd_elf_parse_attributes (bfd *abfd, Elf_Internal_Shdr * hdr)
                    {
                      int type;
 
-                     tag = read_unsigned_leb128 (abfd, p, &n);
+                     tag = safe_read_leb128 (abfd, p, &n, FALSE, end);
                      p += n;
                      type = _bfd_elf_obj_attrs_arg_type (abfd, vendor, tag);
                      switch (type & (ATTR_TYPE_FLAG_INT_VAL | ATTR_TYPE_FLAG_STR_VAL))
                        {
                        case ATTR_TYPE_FLAG_INT_VAL | ATTR_TYPE_FLAG_STR_VAL:
-                         val = read_unsigned_leb128 (abfd, p, &n);
+                         val = safe_read_leb128 (abfd, p, &n, FALSE, end);
                          p += n;
                          bfd_elf_add_obj_attr_int_string (abfd, vendor, tag,
-                                                          val, (char *)p);
+                                                          val, (char *) p);
                          p += strlen ((char *)p) + 1;
                          break;
                        case ATTR_TYPE_FLAG_STR_VAL:
                          bfd_elf_add_obj_attr_string (abfd, vendor, tag,
-                                                      (char *)p);
+                                                      (char *) p);
                          p += strlen ((char *)p) + 1;
                          break;
                        case ATTR_TYPE_FLAG_INT_VAL:
-                         val = read_unsigned_leb128 (abfd, p, &n);
+                         val = safe_read_leb128 (abfd, p, &n, FALSE, end);
                          p += n;
                          bfd_elf_add_obj_attr_int (abfd, vendor, tag, val);
                          break;
index 72e7a66..6a87d71 100644 (file)
@@ -196,6 +196,9 @@ struct elf_link_hash_entry
   unsigned int pointer_equality_needed : 1;
   /* Symbol is a unique global symbol.  */
   unsigned int unique_global : 1;
+  /* Symbol is defined by a shared library with non-default visibility
+     in a read/write section.  */
+  unsigned int protected_def : 1;
 
   /* String table index in .dynstr if this is a dynamic symbol.  */
   unsigned long dynstr_index;
@@ -239,7 +242,8 @@ struct elf_link_hash_entry
   _bfd_elf_symbol_refs_local_p (H, INFO, 1)
 
 /* Common symbols that are turned into definitions don't have the
-   DEF_REGULAR flag set, so they might appear to be undefined.  */
+   DEF_REGULAR flag set, so they might appear to be undefined.
+   Symbols defined in linker scripts also don't have DEF_REGULAR set.  */
 #define ELF_COMMON_DEF_P(H) \
   (!(H)->def_regular                                                   \
    && !(H)->def_dynamic                                                        \
@@ -1109,6 +1113,11 @@ struct elf_backend_data
   unsigned int (*elf_backend_count_relocs)
     (struct bfd_link_info *, asection *);
 
+  /* Say whether to sort relocs output by ld -r and ld --emit-relocs,
+     by r_offset.  If NULL, default to true.  */
+  bfd_boolean (*sort_relocs_p)
+    (asection *);
+
   /* This function, if defined, is called when an NT_PRSTATUS note is found
      in a core file.  */
   bfd_boolean (*elf_backend_grok_prstatus)
@@ -1904,6 +1913,8 @@ extern bfd_boolean _bfd_elf_find_line
   (bfd *, asymbol **, asymbol *, const char **, unsigned int *);
 extern bfd_boolean _bfd_elf_find_inliner_info
   (bfd *, const char **, const char **, unsigned int *);
+extern bfd_boolean _bfd_elf_find_function
+  (bfd *, asymbol **, asection *, bfd_vma, const char **, const char **);
 #define _bfd_elf_read_minisymbols _bfd_generic_read_minisymbols
 #define _bfd_elf_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
 extern int _bfd_elf_sizeof_headers
@@ -2017,7 +2028,7 @@ extern bfd_boolean _bfd_elf_link_output_relocs
    struct elf_link_hash_entry **);
 
 extern bfd_boolean _bfd_elf_adjust_dynamic_copy
-  (struct elf_link_hash_entry *, asection *);
+  (struct bfd_link_info *, struct elf_link_hash_entry *, asection *);
 
 extern bfd_boolean _bfd_elf_dynamic_symbol_p
   (struct elf_link_hash_entry *, struct bfd_link_info *, bfd_boolean);
index 8b207ad..9de3ddb 100644 (file)
@@ -297,13 +297,14 @@ bfd_elf_get_str_section (bfd *abfd, unsigned int shindex)
       /* Allocate and clear an extra byte at the end, to prevent crashes
         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)
        {
          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
             trying.  Otherwise, we'll keep allocating space for
@@ -332,9 +333,19 @@ bfd_elf_string_from_elf_section (bfd *abfd,
 
   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)
     {
@@ -1253,8 +1264,13 @@ _bfd_elf_print_private_bfd_data (bfd *abfd, void *farg)
       swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
 
       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;
          const char *name = "";
@@ -1589,7 +1605,7 @@ bfd_section_from_shdr (bfd *abfd, unsigned int shindex)
   if (++ nesting > 3)
     {
       /* PR17512: A corrupt ELF binary might contain a recursive group of
-        sections, each the string indicies pointing to the next in the
+        sections, each with 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
         we have nested at least three sections deep as normal ELF binaries
@@ -1956,7 +1972,9 @@ bfd_section_from_shdr (bfd *abfd, unsigned int shindex)
        else
          p_hdr = &esdt->rel.hdr;
 
-       BFD_ASSERT (*p_hdr == NULL);
+       /* PR 17512: file: 0b4f81b7.  */
+       if (*p_hdr != NULL)
+         goto fail;
        amt = sizeof (*hdr2);
        hdr2 = (Elf_Internal_Shdr *) bfd_alloc (abfd, amt);
        if (hdr2 == NULL)
@@ -2013,9 +2031,11 @@ bfd_section_from_shdr (bfd *abfd, unsigned int shindex)
       if (hdr->contents != NULL)
        {
          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
              |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
@@ -2720,6 +2740,15 @@ elf_fake_sections (bfd *abfd, asection *asect, void *fsarg)
   this_hdr->sh_offset = 0;
   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
      copy_private_section_data.  */
@@ -3973,6 +4002,11 @@ _bfd_elf_map_sections_to_segments (bfd *abfd, struct bfd_link_info *info)
       last_size = 0;
       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");
       if (dynsec != NULL
@@ -5168,7 +5202,14 @@ assign_file_positions_for_non_load_sections (bfd *abfd,
              && (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;
              p->p_offset = m->sections[0]->filepos;
@@ -6523,7 +6564,15 @@ rewrite:
           i++, segment++)
        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)
        bfd_emul_set_maxpagesize (bfd_get_target (obfd), maxpagesize);
@@ -7648,109 +7697,6 @@ _bfd_elf_set_arch_mach (bfd *abfd,
   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;
-}
-
 /* Find the nearest line to a particular section and offset,
    for error reporting.  */
 
@@ -7770,24 +7716,15 @@ _bfd_elf_find_nearest_line (bfd *abfd,
                                     filename_ptr, functionname_ptr,
                                     line_ptr, discriminator_ptr,
                                     dwarf_debug_sections, 0,
-                                    &elf_tdata (abfd)->dwarf2_find_line_info))
-    {
-      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))
+                                    &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);
-
+       _bfd_elf_find_function (abfd, symbols, section, offset,
+                               *filename_ptr ? NULL : filename_ptr,
+                               functionname_ptr);
       return TRUE;
     }
 
@@ -7802,8 +7739,8 @@ _bfd_elf_find_nearest_line (bfd *abfd,
   if (symbols == NULL)
     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;
 
   *line_ptr = 0;
@@ -9822,10 +9759,14 @@ elf_read_notes (bfd *abfd, file_ptr offset, bfd_size_type size)
   if (bfd_seek (abfd, offset, SEEK_SET) != 0)
     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
       || !elf_parse_notes (abfd, buf, size, offset))
     {
index f9b9428..69c0b54 100644 (file)
@@ -37,7 +37,7 @@
 
 static reloc_howto_type elf_howto_table[]=
 {
-  HOWTO(R_386_NONE, 0, 0, 0, FALSE, 0, complain_overflow_bitfield,
+  HOWTO(R_386_NONE, 0, 3, 0, FALSE, 0, complain_overflow_dont,
        bfd_elf_generic_reloc, "R_386_NONE",
        TRUE, 0x00000000, 0x00000000, FALSE),
   HOWTO(R_386_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
@@ -379,7 +379,9 @@ elf_i386_rtype_to_howto (bfd *abfd, unsigned r_type)
                             abfd, (int) r_type);
       indx = R_386_NONE;
     }
-  BFD_ASSERT (elf_howto_table [indx].type == r_type);
+  /* PR 17512: file: 0f67f69d.  */
+  if (elf_howto_table [indx].type != r_type)
+    return NULL;
   return &elf_howto_table[indx];
 }
 
@@ -2164,7 +2166,7 @@ elf_i386_adjust_dynamic_symbol (struct bfd_link_info *info,
 
   s = htab->sdynbss;
 
-  return _bfd_elf_adjust_dynamic_copy (h, s);
+  return _bfd_elf_adjust_dynamic_copy (info, h, s);
 }
 
 /* Allocate space in .plt, .got and associated reloc sections for
@@ -5015,7 +5017,7 @@ bad_return:
   if (plt_sym_val == NULL)
     goto bad_return;
 
-  for (i = 0; i < count; i++, p++)
+  for (i = 0; i < count; i++)
     plt_sym_val[i] = -1;
 
   plt_offset = bed->plt->plt_entry_size;
@@ -5024,6 +5026,10 @@ bad_return:
     {
       long reloc_index;
 
+      /* Skip unknown relocation.  PR 17512: file: bc9d6cf5.  */
+      if (p->howto == NULL)
+       continue;
+
       if (p->howto->type != R_386_JUMP_SLOT
          && p->howto->type != R_386_IRELATIVE)
        continue;
index 5cf29e1..91d62d3 100644 (file)
@@ -60,8 +60,8 @@ static reloc_howto_type or1k_elf_howto_table[] =
   /* This reloc does nothing.  */
   HOWTO (R_OR1K_NONE,           /* type */
          0,                     /* rightshift */
-         2,                     /* size (0 = byte, 1 = short, 2 = long) */
-         32,                    /* bitsize */
+         3,                     /* size (0 = byte, 1 = short, 2 = long) */
+         0,                     /* bitsize */
          FALSE,                 /* pc_relative */
          0,                     /* bitpos */
          complain_overflow_dont, /* complain_on_overflow */
@@ -704,7 +704,7 @@ or1k_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED,
 {
   unsigned int i;
 
-  for (i = ARRAY_SIZE (or1k_reloc_map); --i;)
+  for (i = ARRAY_SIZE (or1k_reloc_map); i--;)
     if (or1k_reloc_map[i].bfd_reloc_val == code)
       return & or1k_elf_howto_table[or1k_reloc_map[i].or1k_reloc_val];
 
@@ -738,7 +738,11 @@ or1k_info_to_howto_rela (bfd * abfd ATTRIBUTE_UNUSED,
   unsigned int r_type;
 
   r_type = ELF32_R_TYPE (dst->r_info);
-  BFD_ASSERT (r_type < (unsigned int) R_OR1K_max);
+  if (r_type >= (unsigned int) R_OR1K_max)
+    {
+      _bfd_error_handler (_("%B: invalid OR1K reloc number: %d"), abfd, r_type);
+      r_type = 0;
+    }
   cache_ptr->howto = & or1k_elf_howto_table[r_type];
 }
 
@@ -2187,7 +2191,7 @@ or1k_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
       h->needs_copy = 1;
     }
 
-  return _bfd_elf_adjust_dynamic_copy (h, s);
+  return _bfd_elf_adjust_dynamic_copy (info, h, s);
 }
 
 /* Allocate space in .plt, .got and associated reloc sections for
index fefb08c..18983e8 100644 (file)
@@ -54,7 +54,7 @@
    special_function, name, partial_inplace, src_mask, dst_mask, pcrel_offset.  */
 static reloc_howto_type x86_64_elf_howto_table[] =
 {
-  HOWTO(R_X86_64_NONE, 0, 0, 0, FALSE, 0, complain_overflow_dont,
+  HOWTO(R_X86_64_NONE, 0, 3, 0, FALSE, 0, complain_overflow_dont,
        bfd_elf_generic_reloc, "R_X86_64_NONE", FALSE, 0x00000000, 0x00000000,
        FALSE),
   HOWTO(R_X86_64_64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
@@ -302,7 +302,7 @@ elf_x86_64_reloc_type_lookup (bfd *abfd,
        return elf_x86_64_rtype_to_howto (abfd,
                                          x86_64_reloc_map[i].elf_reloc_val);
     }
-  return 0;
+  return NULL;
 }
 
 static reloc_howto_type *
@@ -2431,7 +2431,7 @@ elf_x86_64_adjust_dynamic_symbol (struct bfd_link_info *info,
 
   s = htab->sdynbss;
 
-  return _bfd_elf_adjust_dynamic_copy (h, s);
+  return _bfd_elf_adjust_dynamic_copy (info, h, s);
 }
 
 /* Allocate space in .plt, .got and associated reloc sections for
@@ -2677,13 +2677,23 @@ elf_x86_64_allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf)
                       && ! bfd_elf_link_record_dynamic_symbol (info, h))
                return FALSE;
            }
-         /* For PIE, discard space for relocs against symbols which
-            turn out to need copy relocs.  */
+         /* For PIE, discard space for pc-relative relocs against
+            symbols which turn out to need copy relocs.  */
          else if (info->executable
                   && (h->needs_copy || eh->needs_copy)
                   && h->def_dynamic
                   && !h->def_regular)
-           eh->dyn_relocs = NULL;
+           {
+             struct elf_dyn_relocs **pp;
+
+             for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
+               {
+                 if (p->pc_count != 0)
+                   *pp = p->next;
+                 else
+                   pp = &p->next;
+               }
+           }
        }
     }
   else if (ELIMINATE_COPY_RELOCS)
@@ -5400,7 +5410,7 @@ bad_return:
   if (plt_sym_val == NULL)
     goto bad_return;
 
-  for (i = 0; i < count; i++, p++)
+  for (i = 0; i < count; i++)
     plt_sym_val[i] = -1;
 
   plt_offset = bed->plt_entry_size;
@@ -5409,6 +5419,10 @@ bad_return:
     {
       long reloc_index;
 
+      /* Skip unknown relocation.  */
+      if (p->howto == NULL)
+       continue;
+
       if (p->howto->type != R_X86_64_JUMP_SLOT
          && p->howto->type != R_X86_64_IRELATIVE)
        continue;
index ec53c3b..d34e18e 100644 (file)
@@ -1501,7 +1501,9 @@ elf_slurp_reloc_table (bfd *abfd,
       rel_hdr2 = d->rela.hdr;
       reloc_count2 = rel_hdr2 ? NUM_SHDR_ENTRIES (rel_hdr2) : 0;
 
-      BFD_ASSERT (asect->reloc_count == reloc_count + reloc_count2);
+      /* PR 17512: file: 0b4f81b7.  */
+      if (asect->reloc_count != reloc_count + reloc_count2)
+       return FALSE;
       BFD_ASSERT ((rel_hdr && asect->rel_filepos == rel_hdr->sh_offset)
                  || (rel_hdr2 && asect->rel_filepos == rel_hdr2->sh_offset));
 
index 94ab762..2c6b04b 100644 (file)
@@ -20,6 +20,7 @@
 
 #include "sysdep.h"
 #include "bfd.h"
+#include "bfd_stdint.h"
 #include "bfdlink.h"
 #include "libbfd.h"
 #define ARCH_SIZE 0
@@ -84,6 +85,7 @@ _bfd_elf_define_linkage_sym (bfd *abfd,
   h = (struct elf_link_hash_entry *) bh;
   h->def_regular = 1;
   h->non_elf = 0;
+  h->root.linker_def = 1;
   h->type = STT_OBJECT;
   if (ELF_ST_VISIBILITY (h->other) != STV_INTERNAL)
     h->other = (h->other & ~ELF_ST_VISIBILITY (-1)) | STV_HIDDEN;
@@ -760,6 +762,7 @@ _bfd_elf_link_omit_section_dynsym (bfd *output_bfd ATTRIBUTE_UNUSED,
                                   asection *p)
 {
   struct elf_link_hash_table *htab;
+  asection *ip;
 
   switch (elf_section_data (p)->this_hdr.sh_type)
     {
@@ -775,18 +778,9 @@ _bfd_elf_link_omit_section_dynsym (bfd *output_bfd ATTRIBUTE_UNUSED,
       if (htab->text_index_section != NULL)
        return p != htab->text_index_section && p != htab->data_index_section;
 
-      if (strcmp (p->name, ".got") == 0
-         || strcmp (p->name, ".got.plt") == 0
-         || strcmp (p->name, ".plt") == 0)
-       {
-         asection *ip;
-
-         if (htab->dynobj != NULL
+      return (htab->dynobj != NULL
              && (ip = bfd_get_linker_section (htab->dynobj, p->name)) != NULL
-             && ip->output_section == p)
-           return TRUE;
-       }
-      return FALSE;
+             && ip->output_section == p);
 
       /* There shouldn't be section relative relocations
         against any other section.  */
@@ -851,7 +845,7 @@ _bfd_elf_link_renumber_dynsyms (bfd *output_bfd,
 
 static void
 elf_merge_st_other (bfd *abfd, struct elf_link_hash_entry *h,
-                   const Elf_Internal_Sym *isym,
+                   const Elf_Internal_Sym *isym, asection *sec,
                    bfd_boolean definition, bfd_boolean dynamic)
 {
   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
@@ -872,6 +866,10 @@ elf_merge_st_other (bfd *abfd, struct elf_link_hash_entry *h,
       if (symvis - 1 < hvis - 1)
        h->other = symvis | (h->other & ~ELF_ST_VISIBILITY (-1));
     }
+  else if (definition
+          && ELF_ST_VISIBILITY (isym->st_other) != STV_DEFAULT
+          && (sec->flags & SEC_READONLY) == 0)
+    h->protected_def = 1;
 }
 
 /* This function is called when we want to merge a new symbol with an
@@ -1422,7 +1420,7 @@ _bfd_elf_merge_symbol (bfd *abfd,
       /* Merge st_other.  If the symbol already has a dynamic index,
         but visibility says it should not be visible, turn it into a
         local symbol.  */
-      elf_merge_st_other (abfd, h, sym, newdef, newdyn);
+      elf_merge_st_other (abfd, h, sym, sec, newdef, newdyn);
       if (h->dynindx != -1)
        switch (ELF_ST_VISIBILITY (h->other))
          {
@@ -2636,7 +2634,8 @@ _bfd_elf_adjust_dynamic_symbol (struct elf_link_hash_entry *h, void *data)
    DYNBSS.  */
 
 bfd_boolean
-_bfd_elf_adjust_dynamic_copy (struct elf_link_hash_entry *h,
+_bfd_elf_adjust_dynamic_copy (struct bfd_link_info *info,
+                             struct elf_link_hash_entry *h,
                              asection *dynbss)
 {
   unsigned int power_of_two;
@@ -2675,6 +2674,11 @@ _bfd_elf_adjust_dynamic_copy (struct elf_link_hash_entry *h,
   /* Increment the size of DYNBSS to make room for the symbol.  */
   dynbss->size += h->size;
 
+  if (h->protected_def)
+    info->callbacks->einfo
+      (_("%P: copy reloc against protected `%T' is dangerous\n"),
+       h->root.root.string);
+
   return TRUE;
 }
 
@@ -4351,7 +4355,7 @@ error_free_dyn:
            }
 
          /* Merge st_other field.  */
-         elf_merge_st_other (abfd, h, isym, definition, dynamic);
+         elf_merge_st_other (abfd, h, isym, sec, definition, dynamic);
 
          /* We don't want to make debug symbol dynamic.  */
          if (definition && (sec->flags & SEC_DEBUGGING) && !info->relocatable)
@@ -7957,6 +7961,138 @@ bfd_elf_perform_complex_relocation (bfd *input_bfd,
   return r;
 }
 
+/* qsort comparison functions sorting external relocs by r_offset.  */
+
+static int
+cmp_ext32l_r_offset (const void *p, const void *q)
+{
+  union aligned32
+  {
+    uint32_t v;
+    unsigned char c[4];
+  };
+  const union aligned32 *a
+    = (const union aligned32 *) ((const Elf32_External_Rel *) p)->r_offset;
+  const union aligned32 *b
+    = (const union aligned32 *) ((const Elf32_External_Rel *) q)->r_offset;
+
+  uint32_t aval = (  (uint32_t) a->c[0]
+                  | (uint32_t) a->c[1] << 8
+                  | (uint32_t) a->c[2] << 16
+                  | (uint32_t) a->c[3] << 24);
+  uint32_t bval = (  (uint32_t) b->c[0]
+                  | (uint32_t) b->c[1] << 8
+                  | (uint32_t) b->c[2] << 16
+                  | (uint32_t) b->c[3] << 24);
+  if (aval < bval)
+    return -1;
+  else if (aval > bval)
+    return 1;
+  return 0;
+}
+
+static int
+cmp_ext32b_r_offset (const void *p, const void *q)
+{
+  union aligned32
+  {
+    uint32_t v;
+    unsigned char c[4];
+  };
+  const union aligned32 *a
+    = (const union aligned32 *) ((const Elf32_External_Rel *) p)->r_offset;
+  const union aligned32 *b
+    = (const union aligned32 *) ((const Elf32_External_Rel *) q)->r_offset;
+
+  uint32_t aval = (  (uint32_t) a->c[0] << 24
+                  | (uint32_t) a->c[1] << 16
+                  | (uint32_t) a->c[2] << 8
+                  | (uint32_t) a->c[3]);
+  uint32_t bval = (  (uint32_t) b->c[0] << 24
+                  | (uint32_t) b->c[1] << 16
+                  | (uint32_t) b->c[2] << 8
+                  | (uint32_t) b->c[3]);
+  if (aval < bval)
+    return -1;
+  else if (aval > bval)
+    return 1;
+  return 0;
+}
+
+#ifdef BFD_HOST_64_BIT
+static int
+cmp_ext64l_r_offset (const void *p, const void *q)
+{
+  union aligned64
+  {
+    uint64_t v;
+    unsigned char c[8];
+  };
+  const union aligned64 *a
+    = (const union aligned64 *) ((const Elf64_External_Rel *) p)->r_offset;
+  const union aligned64 *b
+    = (const union aligned64 *) ((const Elf64_External_Rel *) q)->r_offset;
+
+  uint64_t aval = (  (uint64_t) a->c[0]
+                  | (uint64_t) a->c[1] << 8
+                  | (uint64_t) a->c[2] << 16
+                  | (uint64_t) a->c[3] << 24
+                  | (uint64_t) a->c[4] << 32
+                  | (uint64_t) a->c[5] << 40
+                  | (uint64_t) a->c[6] << 48
+                  | (uint64_t) a->c[7] << 56);
+  uint64_t bval = (  (uint64_t) b->c[0]
+                  | (uint64_t) b->c[1] << 8
+                  | (uint64_t) b->c[2] << 16
+                  | (uint64_t) b->c[3] << 24
+                  | (uint64_t) b->c[4] << 32
+                  | (uint64_t) b->c[5] << 40
+                  | (uint64_t) b->c[6] << 48
+                  | (uint64_t) b->c[7] << 56);
+  if (aval < bval)
+    return -1;
+  else if (aval > bval)
+    return 1;
+  return 0;
+}
+
+static int
+cmp_ext64b_r_offset (const void *p, const void *q)
+{
+  union aligned64
+  {
+    uint64_t v;
+    unsigned char c[8];
+  };
+  const union aligned64 *a
+    = (const union aligned64 *) ((const Elf64_External_Rel *) p)->r_offset;
+  const union aligned64 *b
+    = (const union aligned64 *) ((const Elf64_External_Rel *) q)->r_offset;
+
+  uint64_t aval = (  (uint64_t) a->c[0] << 56
+                  | (uint64_t) a->c[1] << 48
+                  | (uint64_t) a->c[2] << 40
+                  | (uint64_t) a->c[3] << 32
+                  | (uint64_t) a->c[4] << 24
+                  | (uint64_t) a->c[5] << 16
+                  | (uint64_t) a->c[6] << 8
+                  | (uint64_t) a->c[7]);
+  uint64_t bval = (  (uint64_t) b->c[0] << 56
+                  | (uint64_t) b->c[1] << 48
+                  | (uint64_t) b->c[2] << 40
+                  | (uint64_t) b->c[3] << 32
+                  | (uint64_t) b->c[4] << 24
+                  | (uint64_t) b->c[5] << 16
+                  | (uint64_t) b->c[6] << 8
+                  | (uint64_t) b->c[7]);
+  if (aval < bval)
+    return -1;
+  else if (aval > bval)
+    return 1;
+  return 0;
+}
+#endif
+
 /* When performing a relocatable link, the input relocations are
    preserved.  But, if they reference global symbols, the indices
    referenced must be updated.  Update all the relocations found in
@@ -7964,7 +8100,8 @@ bfd_elf_perform_complex_relocation (bfd *input_bfd,
 
 static void
 elf_link_adjust_relocs (bfd *abfd,
-                       struct bfd_elf_section_reloc_data *reldata)
+                       struct bfd_elf_section_reloc_data *reldata,
+                       bfd_boolean sort)
 {
   unsigned int i;
   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
@@ -8020,6 +8157,35 @@ elf_link_adjust_relocs (bfd *abfd,
                           | (irela[j].r_info & r_type_mask));
       (*swap_out) (abfd, irela, erela);
     }
+
+  if (sort)
+    {
+      int (*compare) (const void *, const void *);
+
+      if (bed->s->arch_size == 32)
+       {
+         if (abfd->xvec->header_byteorder == BFD_ENDIAN_LITTLE)
+           compare = cmp_ext32l_r_offset;
+         else if (abfd->xvec->header_byteorder == BFD_ENDIAN_BIG)
+           compare = cmp_ext32b_r_offset;
+         else
+           abort ();
+       }
+      else
+       {
+#ifdef BFD_HOST_64_BIT
+         if (abfd->xvec->header_byteorder == BFD_ENDIAN_LITTLE)
+           compare = cmp_ext64l_r_offset;
+         else if (abfd->xvec->header_byteorder == BFD_ENDIAN_BIG)
+           compare = cmp_ext64b_r_offset;
+         else
+#endif
+           abort ();
+       }
+      qsort (reldata->hdr->contents, count, reldata->hdr->sh_entsize, compare);
+      free (reldata->hashes);
+      reldata->hashes = NULL;
+    }
 }
 
 struct elf_link_sort_rela
@@ -8392,6 +8558,8 @@ elf_link_output_sym (struct elf_final_link_info *flinfo,
      struct elf_link_hash_entry *);
   const struct elf_backend_data *bed;
 
+  BFD_ASSERT (elf_onesymtab (flinfo->output_bfd));
+
   bed = get_elf_backend_data (flinfo->output_bfd);
   output_symbol_hook = bed->elf_backend_link_output_symbol_hook;
   if (output_symbol_hook != NULL)
@@ -8872,12 +9040,6 @@ elf_link_output_extsym (struct bfd_hash_entry *bh, void *data)
                    asection *tls_sec = elf_hash_table (flinfo->info)->tls_sec;
                    if (tls_sec != NULL)
                      sym.st_value -= tls_sec->vma;
-                   else
-                     {
-                       /* The TLS section may have been garbage collected.  */
-                       BFD_ASSERT (flinfo->info->gc_sections
-                                   && !input_sec->gc_mark);
-                     }
                  }
              }
          }
@@ -10159,7 +10321,7 @@ elf_reloc_link_order (bfd *output_bfd,
 
       size = (bfd_size_type) bfd_get_reloc_size (howto);
       buf = (bfd_byte *) bfd_zmalloc (size);
-      if (buf == NULL)
+      if (buf == NULL && size != 0)
        return FALSE;
       rstat = _bfd_relocate_contents (howto, output_bfd, addend, buf);
       switch (rstat)
@@ -10433,12 +10595,10 @@ bfd_elf_final_link (bfd *abfd, struct bfd_link_info *info)
   bfd_size_type max_internal_reloc_count;
   bfd_size_type max_sym_count;
   bfd_size_type max_sym_shndx_count;
-  file_ptr off;
   Elf_Internal_Sym elfsym;
   unsigned int i;
   Elf_Internal_Shdr *symtab_hdr;
   Elf_Internal_Shdr *symtab_shndx_hdr;
-  Elf_Internal_Shdr *symstrtab_hdr;
   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
   struct elf_outext_info eoinfo;
   bfd_boolean merged;
@@ -10669,7 +10829,7 @@ bfd_elf_final_link (bfd *abfd, struct bfd_link_info *info)
   /* Figure out the file positions for everything but the symbol table
      and the relocs.  We set symcount to force assign_section_numbers
      to create a symbol table.  */
-  bfd_get_symcount (abfd) = info->strip == strip_all ? 0 : 1;
+  bfd_get_symcount (abfd) = info->strip != strip_all || emit_relocs;
   BFD_ASSERT (! abfd->output_has_begun);
   if (! _bfd_elf_compute_section_file_positions (abfd, info))
     goto error_return;
@@ -10710,13 +10870,6 @@ bfd_elf_final_link (bfd *abfd, struct bfd_link_info *info)
   /* sh_offset is set just below.  */
   symtab_hdr->sh_addralign = (bfd_vma) 1 << bed->s->log_file_align;
 
-  off = elf_next_file_pos (abfd);
-  off = _bfd_elf_assign_file_position_for_section (symtab_hdr, off, TRUE);
-
-  /* Note that at this point elf_next_file_pos (abfd) is
-     incorrect.  We do not yet know the size of the .symtab section.
-     We correct next_file_pos below, after we do know the size.  */
-
   /* Allocate a buffer to hold swapped out symbols.  This is to avoid
      continuously seeking to the right position in the file.  */
   if (! info->keep_memory || max_sym_count < 20)
@@ -10739,11 +10892,18 @@ bfd_elf_final_link (bfd *abfd, struct bfd_link_info *info)
        goto error_return;
     }
 
-  /* Start writing out the symbol table.  The first symbol is always a
-     dummy symbol.  */
-  if (info->strip != strip_all
-      || emit_relocs)
+  if (info->strip != strip_all || emit_relocs)
     {
+      file_ptr off = elf_next_file_pos (abfd);
+
+      _bfd_elf_assign_file_position_for_section (symtab_hdr, off, TRUE);
+
+      /* Note that at this point elf_next_file_pos (abfd) is
+        incorrect.  We do not yet know the size of the .symtab section.
+        We correct next_file_pos below, after we do know the size.  */
+
+      /* Start writing out the symbol table.  The first symbol is always a
+        dummy symbol.  */
       elfsym.st_value = 0;
       elfsym.st_size = 0;
       elfsym.st_info = 0;
@@ -10753,16 +10913,13 @@ bfd_elf_final_link (bfd *abfd, struct bfd_link_info *info)
       if (elf_link_output_sym (&flinfo, NULL, &elfsym, bfd_und_section_ptr,
                               NULL) != 1)
        goto error_return;
-    }
 
-  /* Output a symbol for each section.  We output these even if we are
-     discarding local symbols, since they are used for relocs.  These
-     symbols have no names.  We store the index of each one in the
-     index field of the section, so that we can find it again when
-     outputting relocs.  */
-  if (info->strip != strip_all
-      || emit_relocs)
-    {
+      /* Output a symbol for each section.  We output these even if we are
+        discarding local symbols, since they are used for relocs.  These
+        symbols have no names.  We store the index of each one in the
+        index field of the section, so that we can find it again when
+        outputting relocs.  */
+
       elfsym.st_size = 0;
       elfsym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
       elfsym.st_other = 0;
@@ -10993,7 +11150,8 @@ bfd_elf_final_link (bfd *abfd, struct bfd_link_info *info)
 
   /* If backend needs to output some local symbols not present in the hash
      table, do it now.  */
-  if (bed->elf_backend_output_arch_local_syms)
+  if (bed->elf_backend_output_arch_local_syms
+      && (info->strip != strip_all || emit_relocs))
     {
       typedef int (*out_sym_func)
        (void *, const char *, Elf_Internal_Sym *, asection *,
@@ -11103,7 +11261,8 @@ bfd_elf_final_link (bfd *abfd, struct bfd_link_info *info)
 
   /* If backend needs to output some symbols not present in the hash
      table, do it now.  */
-  if (bed->elf_backend_output_arch_syms)
+  if (bed->elf_backend_output_arch_syms
+      && (info->strip != strip_all || emit_relocs))
     {
       typedef int (*out_sym_func)
        (void *, const char *, Elf_Internal_Sym *, asection *,
@@ -11119,45 +11278,46 @@ bfd_elf_final_link (bfd *abfd, struct bfd_link_info *info)
     return FALSE;
 
   /* Now we know the size of the symtab section.  */
-  off += symtab_hdr->sh_size;
-
-  symtab_shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
-  if (symtab_shndx_hdr->sh_name != 0)
+  if (bfd_get_symcount (abfd) > 0)
     {
-      symtab_shndx_hdr->sh_type = SHT_SYMTAB_SHNDX;
-      symtab_shndx_hdr->sh_entsize = sizeof (Elf_External_Sym_Shndx);
-      symtab_shndx_hdr->sh_addralign = sizeof (Elf_External_Sym_Shndx);
-      amt = bfd_get_symcount (abfd) * sizeof (Elf_External_Sym_Shndx);
-      symtab_shndx_hdr->sh_size = amt;
+      /* Finish up and write out the symbol string table (.strtab)
+        section.  */
+      Elf_Internal_Shdr *symstrtab_hdr;
+      file_ptr off = symtab_hdr->sh_offset + symtab_hdr->sh_size;
 
-      off = _bfd_elf_assign_file_position_for_section (symtab_shndx_hdr,
-                                                      off, TRUE);
+      symtab_shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
+      if (symtab_shndx_hdr->sh_name != 0)
+       {
+         symtab_shndx_hdr->sh_type = SHT_SYMTAB_SHNDX;
+         symtab_shndx_hdr->sh_entsize = sizeof (Elf_External_Sym_Shndx);
+         symtab_shndx_hdr->sh_addralign = sizeof (Elf_External_Sym_Shndx);
+         amt = bfd_get_symcount (abfd) * sizeof (Elf_External_Sym_Shndx);
+         symtab_shndx_hdr->sh_size = amt;
 
-      if (bfd_seek (abfd, symtab_shndx_hdr->sh_offset, SEEK_SET) != 0
-         || (bfd_bwrite (flinfo.symshndxbuf, amt, abfd) != amt))
-       return FALSE;
-    }
+         off = _bfd_elf_assign_file_position_for_section (symtab_shndx_hdr,
+                                                          off, TRUE);
 
+         if (bfd_seek (abfd, symtab_shndx_hdr->sh_offset, SEEK_SET) != 0
+             || (bfd_bwrite (flinfo.symshndxbuf, amt, abfd) != amt))
+           return FALSE;
+       }
 
-  /* Finish up and write out the symbol string table (.strtab)
-     section.  */
-  symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
-  /* sh_name was set in prep_headers.  */
-  symstrtab_hdr->sh_type = SHT_STRTAB;
-  symstrtab_hdr->sh_flags = 0;
-  symstrtab_hdr->sh_addr = 0;
-  symstrtab_hdr->sh_size = _bfd_stringtab_size (flinfo.symstrtab);
-  symstrtab_hdr->sh_entsize = 0;
-  symstrtab_hdr->sh_link = 0;
-  symstrtab_hdr->sh_info = 0;
-  /* sh_offset is set just below.  */
-  symstrtab_hdr->sh_addralign = 1;
+      symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
+      /* sh_name was set in prep_headers.  */
+      symstrtab_hdr->sh_type = SHT_STRTAB;
+      symstrtab_hdr->sh_flags = 0;
+      symstrtab_hdr->sh_addr = 0;
+      symstrtab_hdr->sh_size = _bfd_stringtab_size (flinfo.symstrtab);
+      symstrtab_hdr->sh_entsize = 0;
+      symstrtab_hdr->sh_link = 0;
+      symstrtab_hdr->sh_info = 0;
+      /* sh_offset is set just below.  */
+      symstrtab_hdr->sh_addralign = 1;
 
-  off = _bfd_elf_assign_file_position_for_section (symstrtab_hdr, off, TRUE);
-  elf_next_file_pos (abfd) = off;
+      off = _bfd_elf_assign_file_position_for_section (symstrtab_hdr,
+                                                      off, TRUE);
+      elf_next_file_pos (abfd) = off;
 
-  if (bfd_get_symcount (abfd) > 0)
-    {
       if (bfd_seek (abfd, symstrtab_hdr->sh_offset, SEEK_SET) != 0
          || ! _bfd_stringtab_emit (abfd, flinfo.symstrtab))
        return FALSE;
@@ -11167,13 +11327,15 @@ bfd_elf_final_link (bfd *abfd, struct bfd_link_info *info)
   for (o = abfd->sections; o != NULL; o = o->next)
     {
       struct bfd_elf_section_data *esdo = elf_section_data (o);
+      bfd_boolean sort;
       if ((o->flags & SEC_RELOC) == 0)
        continue;
 
+      sort = bed->sort_relocs_p == NULL || (*bed->sort_relocs_p) (o);
       if (esdo->rel.hdr != NULL)
-       elf_link_adjust_relocs (abfd, &esdo->rel);
+       elf_link_adjust_relocs (abfd, &esdo->rel, sort);
       if (esdo->rela.hdr != NULL)
-       elf_link_adjust_relocs (abfd, &esdo->rela);
+       elf_link_adjust_relocs (abfd, &esdo->rela, sort);
 
       /* Set the reloc_count field to 0 to prevent write_relocs from
         trying to swap the relocs out itself.  */
@@ -11420,6 +11582,8 @@ bfd_elf_final_link (bfd *abfd, struct bfd_link_info *info)
            {
              /* The contents of the .dynstr section are actually in a
                 stringtab.  */
+             file_ptr off;
+
              off = elf_section_data (o->output_section)->this_hdr.sh_offset;
              if (bfd_seek (abfd, off, SEEK_SET) != 0
                  || ! _bfd_elf_strtab_emit (abfd,
@@ -11896,7 +12060,7 @@ elf_gc_sweep_symbol (struct elf_link_hash_entry *h, void *data)
   if (!h->mark
       && (((h->root.type == bfd_link_hash_defined
            || h->root.type == bfd_link_hash_defweak)
-          && !(h->def_regular
+          && !((h->def_regular || ELF_COMMON_DEF_P (h))
                && h->root.u.def.section->gc_mark))
          || h->root.type == bfd_link_hash_undefined
          || h->root.type == bfd_link_hash_undefweak))
@@ -12119,7 +12283,7 @@ bfd_elf_gc_mark_dynamic_ref_symbol (struct elf_link_hash_entry *h, void *inf)
   if ((h->root.type == bfd_link_hash_defined
        || h->root.type == bfd_link_hash_defweak)
       && (h->ref_dynamic
-         || (h->def_regular
+         || ((h->def_regular || ELF_COMMON_DEF_P (h))
              && ELF_ST_VISIBILITY (h->other) != STV_INTERNAL
              && ELF_ST_VISIBILITY (h->other) != STV_HIDDEN
              && (!info->executable
@@ -13038,7 +13202,7 @@ _bfd_elf_copy_link_hash_symbol_type (bfd *abfd,
   ehdest->target_internal = ehsrc->target_internal;
 
   isym.st_other = ehsrc->other;
-  elf_merge_st_other (abfd, ehdest, &isym, TRUE, FALSE);
+  elf_merge_st_other (abfd, ehdest, &isym, NULL, TRUE, FALSE);
 }
 
 /* Append a RELA relocation REL to section S in BFD.  */
index 692fb46..64d2461 100644 (file)
 #ifndef elf_backend_count_relocs
 #define elf_backend_count_relocs               NULL
 #endif
+#ifndef elf_backend_sort_relocs_p
+#define elf_backend_sort_relocs_p              NULL
+#endif
 #ifndef elf_backend_grok_prstatus
 #define elf_backend_grok_prstatus              NULL
 #endif
@@ -733,6 +736,7 @@ static struct elf_backend_data elfNN_bed =
   elf_backend_ignore_undef_symbol,
   elf_backend_emit_relocs,
   elf_backend_count_relocs,
+  elf_backend_sort_relocs_p,
   elf_backend_grok_prstatus,
   elf_backend_grok_psinfo,
   elf_backend_write_core_note,
index c4bc944..f0d1e66 100644 (file)
@@ -402,7 +402,7 @@ bfd_check_format_matches (bfd *abfd, bfd_format format, char ***matching)
   /* We still have more than one equally good match, and at least some
      of the targets support match priority.  Choose the first of the
      best matches.  */
-  if (match_count > 1 && best_count != match_count)
+  if (matching_vector && match_count > 1 && best_count != match_count)
     {
       int i;
 
index 6352c9c..c079247 100644 (file)
@@ -171,15 +171,18 @@ void *
 bfd_malloc (bfd_size_type size)
 {
   void *ptr;
+  size_t sz = (size_t) size;
 
-  if (size != (size_t) size)
+  if (size != sz
+      /* This is to pacify memory checkers like valgrind.  */
+      || ((signed long) sz) < 0)
     {
       bfd_set_error (bfd_error_no_memory);
       return NULL;
     }
 
-  ptr = malloc ((size_t) size);
-  if (ptr == NULL && (size_t) size != 0)
+  ptr = malloc (sz);
+  if (ptr == NULL && sz != 0)
     bfd_set_error (bfd_error_no_memory);
 
   return ptr;
@@ -190,8 +193,6 @@ bfd_malloc (bfd_size_type size)
 void *
 bfd_malloc2 (bfd_size_type nmemb, bfd_size_type size)
 {
-  void *ptr;
-
   if ((nmemb | size) >= HALF_BFD_SIZE_TYPE
       && size != 0
       && nmemb > ~(bfd_size_type) 0 / size)
@@ -200,19 +201,7 @@ bfd_malloc2 (bfd_size_type nmemb, bfd_size_type size)
       return NULL;
     }
 
-  size *= nmemb;
-
-  if (size != (size_t) size)
-    {
-      bfd_set_error (bfd_error_no_memory);
-      return NULL;
-    }
-
-  ptr = malloc ((size_t) size);
-  if (ptr == NULL && (size_t) size != 0)
-    bfd_set_error (bfd_error_no_memory);
-
-  return ptr;
+  return bfd_malloc (size * nmemb);
 }
 
 /* Reallocate memory using realloc.  */
@@ -221,19 +210,22 @@ void *
 bfd_realloc (void *ptr, bfd_size_type size)
 {
   void *ret;
+  size_t sz = (size_t) size;
+
+  if (ptr == NULL)
+    return bfd_malloc (size);
 
-  if (size != (size_t) size)
+  if (size != sz
+      /* This is to pacify memory checkers like valgrind.  */
+      || ((signed long) sz) < 0)
     {
       bfd_set_error (bfd_error_no_memory);
       return NULL;
     }
 
-  if (ptr == NULL)
-    ret = malloc ((size_t) size);
-  else
-    ret = realloc (ptr, (size_t) size);
+  ret = realloc (ptr, sz);
 
-  if (ret == NULL && (size_t) size != 0)
+  if (ret == NULL && sz != 0)
     bfd_set_error (bfd_error_no_memory);
 
   return ret;
@@ -244,8 +236,6 @@ bfd_realloc (void *ptr, bfd_size_type size)
 void *
 bfd_realloc2 (void *ptr, bfd_size_type nmemb, bfd_size_type size)
 {
-  void *ret;
-
   if ((nmemb | size) >= HALF_BFD_SIZE_TYPE
       && size != 0
       && nmemb > ~(bfd_size_type) 0 / size)
@@ -254,23 +244,7 @@ bfd_realloc2 (void *ptr, bfd_size_type nmemb, bfd_size_type size)
       return NULL;
     }
 
-  size *= nmemb;
-
-  if (size != (size_t) size)
-    {
-      bfd_set_error (bfd_error_no_memory);
-      return NULL;
-    }
-
-  if (ptr == NULL)
-    ret = malloc ((size_t) size);
-  else
-    ret = realloc (ptr, (size_t) size);
-
-  if (ret == NULL && (size_t) size != 0)
-    bfd_set_error (bfd_error_no_memory);
-
-  return ret;
+  return bfd_realloc (ptr, size * nmemb);
 }
 
 /* Reallocate memory using realloc.
@@ -279,24 +253,10 @@ bfd_realloc2 (void *ptr, bfd_size_type nmemb, bfd_size_type size)
 void *
 bfd_realloc_or_free (void *ptr, bfd_size_type size)
 {
-  size_t amount = (size_t) size;
-  void *ret;
+  void *ret = bfd_realloc (ptr, size);
 
-  if (size != amount)
-    ret = NULL;
-  else if (ptr == NULL)
-    ret = malloc (amount);
-  else
-    ret = realloc (ptr, amount);
-
-  if (ret == NULL)
-    {
-      if (amount > 0)
-       bfd_set_error (bfd_error_no_memory);
-
-      if (ptr != NULL)
-       free (ptr);
-    }
+  if (ret == NULL && ptr != NULL)
+    free (ptr);
 
   return ret;
 }
@@ -306,23 +266,10 @@ bfd_realloc_or_free (void *ptr, bfd_size_type size)
 void *
 bfd_zmalloc (bfd_size_type size)
 {
-  void *ptr;
+  void *ptr = bfd_malloc (size);
 
-  if (size != (size_t) size)
-    {
-      bfd_set_error (bfd_error_no_memory);
-      return NULL;
-    }
-
-  ptr = malloc ((size_t) size);
-
-  if ((size_t) size != 0)
-    {
-      if (ptr == NULL)
-       bfd_set_error (bfd_error_no_memory);
-      else
-       memset (ptr, 0, (size_t) size);
-    }
+  if (ptr != NULL && size > 0)
+    memset (ptr, 0, (size_t) size);
 
   return ptr;
 }
@@ -333,32 +280,14 @@ bfd_zmalloc (bfd_size_type size)
 void *
 bfd_zmalloc2 (bfd_size_type nmemb, bfd_size_type size)
 {
-  void *ptr;
+  void *ptr = bfd_malloc2 (nmemb, size);
 
-  if ((nmemb | size) >= HALF_BFD_SIZE_TYPE
-      && size != 0
-      && nmemb > ~(bfd_size_type) 0 / size)
+  if (ptr != NULL)
     {
-      bfd_set_error (bfd_error_no_memory);
-      return NULL;
-    }
-
-  size *= nmemb;
-
-  if (size != (size_t) size)
-    {
-      bfd_set_error (bfd_error_no_memory);
-      return NULL;
-    }
+      size_t sz = nmemb * size;
 
-  ptr = malloc ((size_t) size);
-
-  if ((size_t) size != 0)
-    {
-      if (ptr == NULL)
-       bfd_set_error (bfd_error_no_memory);
-      else
-       memset (ptr, 0, (size_t) size);
+      if (sz > 0)
+       memset (ptr, 0, sz);
     }
 
   return ptr;
@@ -1074,6 +1003,45 @@ read_unsigned_leb128 (bfd *abfd ATTRIBUTE_UNUSED,
   return result;
 }
 
+/* Read in a LEB128 encoded value from ABFD starting at DATA.
+   If SIGN is true, return a signed LEB128 value.
+   If LENGTH_RETURN is not NULL, return in it the number of bytes read.
+   No bytes will be read at address END or beyond.  */
+
+bfd_vma
+safe_read_leb128 (bfd *abfd ATTRIBUTE_UNUSED,
+                 bfd_byte *data,
+                 unsigned int *length_return,
+                 bfd_boolean sign,
+                 const bfd_byte * const end)
+{
+  bfd_vma result = 0;
+  unsigned int num_read = 0;
+  unsigned int shift = 0;
+  unsigned char byte = 0;
+
+  while (data < end)
+    {
+      byte = bfd_get_8 (abfd, data);
+      data++;
+      num_read++;
+
+      result |= ((bfd_vma) (byte & 0x7f)) << shift;
+
+      shift += 7;
+      if ((byte & 0x80) == 0)
+       break;
+    }
+
+  if (length_return != NULL)
+    *length_return = num_read;
+
+  if (sign && (shift < 8 * sizeof (result)) && (byte & 0x40))
+    result |= (bfd_vma) -1 << shift;
+
+  return result;
+}
+
 /* Helper function for reading sleb128 encoded data.  */
 
 bfd_signed_vma
index 6c48f82..1c54d0f 100644 (file)
@@ -842,6 +842,8 @@ extern void bfd_section_already_linked_table_traverse
 
 extern bfd_vma read_unsigned_leb128 (bfd *, bfd_byte *, unsigned int *);
 extern bfd_signed_vma read_signed_leb128 (bfd *, bfd_byte *, unsigned int *);
+extern bfd_vma safe_read_leb128 (bfd *, bfd_byte *, unsigned int *,
+                                bfd_boolean, const bfd_byte * const);
 /* Extracted from init.c.  */
 /* Extracted from libbfd.c.  */
 bfd_boolean bfd_write_bigendian_4byte_int (bfd *, unsigned int);
index abdf5b0..f7f32a3 100644 (file)
@@ -1560,6 +1560,7 @@ _bfd_generic_link_add_one_symbol (struct bfd_link_info *info,
              h->type = bfd_link_hash_defined;
            h->u.def.section = section;
            h->u.def.value = value;
+           h->linker_def = 0;
 
            /* If we have been asked to, we act like collect2 and
               identify all functions that might be global
@@ -1659,6 +1660,7 @@ _bfd_generic_link_add_one_symbol (struct bfd_link_info *info,
            }
          else
            h->u.c.p->section = section;
+         h->linker_def = 0;
          break;
 
        case REF:
@@ -2432,7 +2434,7 @@ _bfd_generic_reloc_link_order (bfd *abfd,
 
       size = bfd_get_reloc_size (r->howto);
       buf = (bfd_byte *) bfd_zmalloc (size);
-      if (buf == NULL)
+      if (buf == NULL && size != 0)
        return FALSE;
       rstat = _bfd_relocate_contents (r->howto, abfd,
                                      (bfd_vma) link_order->u.reloc.p->addend,
index 75af627..404b944 100644 (file)
@@ -940,15 +940,19 @@ bfd_alloc (bfd *abfd, bfd_size_type size)
   unsigned long ul_size = (unsigned long) size;
 
   if (size != ul_size
-      /* A small negative size can result in objalloc_alloc allocating just
-        1 byte of memory, but the caller will be expecting more.  So catch
-        this case here.  */
-      || (size != 0 && (((ul_size + OBJALLOC_ALIGN - 1) &~ (OBJALLOC_ALIGN - 1)) == 0)))
+      /* Note - although objalloc_alloc takes an unsigned long as its
+        argument, internally the size is treated as a signed long.  This can
+        lead to problems where, for example, a request to allocate -1 bytes
+        can result in just 1 byte being allocated, rather than
+        ((unsigned long) -1) bytes.  Also memory checkers will often
+        complain about attempts to allocate a negative amount of memory.
+        So to stop these problems we fail if the size is negative.  */
+      || ((signed long) ul_size) < 0)
     {
       bfd_set_error (bfd_error_no_memory);
       return NULL;
     }
-                                                       
+
   ret = objalloc_alloc ((struct objalloc *) abfd->memory, ul_size);
   if (ret == NULL)
     bfd_set_error (bfd_error_no_memory);
index dc47173..ba73ef7 100644 (file)
@@ -437,6 +437,7 @@ bfd_get_reloc_size (reloc_howto_type *howto)
     case 3: return 0;
     case 4: return 8;
     case 8: return 16;
+    case -1: return 2;
     case -2: return 4;
     default: abort ();
     }
@@ -578,7 +579,7 @@ bfd_perform_relocation (bfd *abfd,
 {
   bfd_vma relocation;
   bfd_reloc_status_type flag = bfd_reloc_ok;
-  bfd_size_type octets = reloc_entry->address * bfd_octets_per_byte (abfd);
+  bfd_size_type octets;
   bfd_vma output_base = 0;
   reloc_howto_type *howto = reloc_entry->howto;
   asection *reloc_target_output_section;
@@ -592,6 +593,10 @@ bfd_perform_relocation (bfd *abfd,
       return bfd_reloc_ok;
     }
 
+  /* PR 17512: file: 0f67f69d.  */
+  if (howto == NULL)
+    return bfd_reloc_undefined;
+
   /* If we are not producing relocatable output, return an error if
      the symbol is not defined.  An undefined weak symbol is
      considered to have a value of zero (SVR4 ABI, p. 4-27).  */
@@ -613,8 +618,12 @@ bfd_perform_relocation (bfd *abfd,
        return cont;
     }
 
-  /* Is the address of the relocation really within the section?  */
-  if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
+  /* Is the address of the relocation really within the section?
+     Include the size of the reloc in the test for out of range addresses.
+     PR 17512: file: c146ab8b, 46dff27f, 38e53ebf.  */
+  octets = reloc_entry->address * bfd_octets_per_byte (abfd);
+  if (octets + bfd_get_reloc_size (howto)
+      > bfd_get_section_limit_octets (abfd, input_section))
     return bfd_reloc_outofrange;
 
   /* Work out which section the relocation is targeted at and the
@@ -964,7 +973,7 @@ bfd_install_relocation (bfd *abfd,
 {
   bfd_vma relocation;
   bfd_reloc_status_type flag = bfd_reloc_ok;
-  bfd_size_type octets = reloc_entry->address * bfd_octets_per_byte (abfd);
+  bfd_size_type octets;
   bfd_vma output_base = 0;
   reloc_howto_type *howto = reloc_entry->howto;
   asection *reloc_target_output_section;
@@ -997,7 +1006,9 @@ bfd_install_relocation (bfd *abfd,
     }
 
   /* Is the address of the relocation really within the section?  */
-  if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
+  octets = reloc_entry->address * bfd_octets_per_byte (abfd);
+  if (octets + bfd_get_reloc_size (howto)
+      > bfd_get_section_limit_octets (abfd, input_section))
     return bfd_reloc_outofrange;
 
   /* Work out which section the relocation is targeted at and the
@@ -1332,9 +1343,11 @@ _bfd_final_link_relocate (reloc_howto_type *howto,
                          bfd_vma addend)
 {
   bfd_vma relocation;
+  bfd_size_type octets = address * bfd_octets_per_byte (input_bfd);
 
   /* Sanity check the address.  */
-  if (address > bfd_get_section_limit (input_bfd, input_section))
+  if (octets + bfd_get_reloc_size (howto)
+      > bfd_get_section_limit_octets (input_bfd, input_section))
     return bfd_reloc_outofrange;
 
   /* This function assumes that we are dealing with a basic relocation
@@ -1389,8 +1402,9 @@ _bfd_relocate_contents (reloc_howto_type *howto,
   switch (size)
     {
     default:
-    case 0:
       abort ();
+    case 0:
+      return bfd_reloc_ok;
     case 1:
       x = bfd_get_8 (input_bfd, location);
       break;
@@ -1557,8 +1571,9 @@ _bfd_clear_contents (reloc_howto_type *howto,
   switch (size)
     {
     default:
-    case 0:
       abort ();
+    case 0:
+      return;
     case 1:
       x = bfd_get_8 (input_bfd, location);
       break;
@@ -7655,11 +7670,23 @@ bfd_generic_get_relocated_section_contents (bfd *abfd,
                     abfd, input_section, * parent);
                  goto error_return;
 
+               case bfd_reloc_notsupported:
+                 /* PR ld/17512
+                    This error can result when processing a corrupt binary.
+                    Do not abort.  Issue an error message instead.  */
+                 link_info->callbacks->einfo
+                   (_("%X%P: %B(%A): relocation \"%R\" is not supported\n"),
+                    abfd, input_section, * parent);
+                 goto error_return;
+
                default:
-                 abort ();
+                 /* PR 17512; file: 90c2a92e.
+                    Report unexpected results, without aborting.  */
+                 link_info->callbacks->einfo
+                   (_("%X%P: %B(%A): relocation \"%R\" returns an unrecognized value %x\n"),
+                    abfd, input_section, * parent, r);
                  break;
                }
-
            }
        }
     }
index a1d1d77..02e191d 100644 (file)
@@ -1191,6 +1191,8 @@ _bfd_stab_section_find_nearest_line (bfd *abfd,
                {
                  nul_fun = stab;
                  nul_str = str;
+                 if (file_name >= (char *) info->strs + strsize || file_name < (char *) str)
+                   file_name = NULL;
                  if (stab + STABSIZE + TYPEOFF < info->stabs + stabsize
                      && *(stab + STABSIZE + TYPEOFF) == (bfd_byte) N_SO)
                    {
@@ -1200,6 +1202,8 @@ _bfd_stab_section_find_nearest_line (bfd *abfd,
                      directory_name = file_name;
                      file_name = ((char *) str
                                   + bfd_get_32 (abfd, stab + STRDXOFF));
+                     if (file_name >= (char *) info->strs + strsize || file_name < (char *) str)
+                       file_name = NULL;
                    }
                }
              break;
@@ -1207,6 +1211,10 @@ _bfd_stab_section_find_nearest_line (bfd *abfd,
            case N_SOL:
              /* The name of an include file.  */
              file_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF);
+             /* PR 17512: file: 0c680a1f.  */
+             /* PR 17512: file: 5da8aec4.  */
+             if (file_name >= (char *) info->strs + strsize || file_name < (char *) str)
+               file_name = NULL;
              break;
 
            case N_FUN:
@@ -1214,6 +1222,8 @@ _bfd_stab_section_find_nearest_line (bfd *abfd,
              function_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF);
              if (function_name == (char *) str)
                continue;
+             if (function_name >= (char *) info->strs + strsize)
+               function_name = NULL;
 
              nul_fun = NULL;
              info->indextable[i].val = bfd_get_32 (abfd, stab + VALOFF);
@@ -1321,6 +1331,8 @@ _bfd_stab_section_find_nearest_line (bfd *abfd,
          if (val <= offset)
            {
              file_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF);
+             if (file_name >= (char *) info->strs + strsize || file_name < (char *) str)
+               file_name = NULL;
              *pline = 0;
            }
          break;
index 0328689..5620e85 100644 (file)
@@ -267,7 +267,7 @@ typedef struct tekhex_data_struct
 #define enda(x) (x->vma + x->size)
 
 static bfd_boolean
-getvalue (char **srcp, bfd_vma *valuep)
+getvalue (char **srcp, bfd_vma *valuep, char * endp)
 {
   char *src = *srcp;
   bfd_vma value = 0;
@@ -279,7 +279,7 @@ getvalue (char **srcp, bfd_vma *valuep)
   len = hex_value (*src++);
   if (len == 0)
     len = 16;
-  while (len--)
+  while (len-- && src < endp)
     {
       if (!ISHEX (*src))
        return FALSE;
@@ -288,11 +288,11 @@ getvalue (char **srcp, bfd_vma *valuep)
 
   *srcp = src;
   *valuep = value;
-  return TRUE;
+  return len == -1U;
 }
 
 static bfd_boolean
-getsym (char *dstp, char **srcp, unsigned int *lenp)
+getsym (char *dstp, char **srcp, unsigned int *lenp, char * endp)
 {
   char *src = *srcp;
   unsigned int i;
@@ -304,12 +304,12 @@ getsym (char *dstp, char **srcp, unsigned int *lenp)
   len = hex_value (*src++);
   if (len == 0)
     len = 16;
-  for (i = 0; i < len; i++)
+  for (i = 0; i < len && src < endp; i++)
     dstp[i] = src[i];
   dstp[i] = 0;
   *srcp = src + i;
   *lenp = len;
-  return TRUE;
+  return i == len;
 }
 
 static struct data_struct *
@@ -354,7 +354,7 @@ insert_byte (bfd *abfd, int value, bfd_vma addr)
   how big the data is.  */
 
 static bfd_boolean
-first_phase (bfd *abfd, int type, char *src)
+first_phase (bfd *abfd, int type, char *src, char * src_end)
 {
   asection *section, *alt_section;
   unsigned int len;
@@ -368,21 +368,21 @@ first_phase (bfd *abfd, int type, char *src)
       {
        bfd_vma addr;
 
-       if (!getvalue (&src, &addr))
+       if (!getvalue (&src, &addr, src_end))
          return FALSE;
 
-       while (*src)
+       while (*src && src < src_end - 1)
          {
            insert_byte (abfd, HEX (src), addr);
            src += 2;
            addr++;
          }
+       return TRUE;
       }
 
-      return TRUE;
     case '3':
       /* Symbol record, read the segment.  */
-      if (!getsym (sym, &src, &len))
+      if (!getsym (sym, &src, &len, src_end))
        return FALSE;
       section = bfd_get_section_by_name (abfd, sym);
       if (section == NULL)
@@ -397,17 +397,23 @@ first_phase (bfd *abfd, int type, char *src)
            return FALSE;
        }
       alt_section = NULL;
-      while (*src)
+      while (src < src_end && *src)
        {
          switch (*src)
            {
            case '1':           /* Section range.  */
              src++;
-             if (!getvalue (&src, &section->vma))
+             if (!getvalue (&src, &section->vma, src_end))
                return FALSE;
-             if (!getvalue (&src, &val))
+             if (!getvalue (&src, &val, src_end))
                return FALSE;
+             if (val < section->vma)
+               val = section->vma;
              section->size = val - section->vma;
+             /* PR 17512: file: objdump-s-endless-loop.tekhex.
+                Check for overlarge section sizes.  */
+             if (section->size & 0x80000000)
+               return FALSE;
              section->flags = SEC_HAS_CONTENTS | SEC_LOAD | SEC_ALLOC;
              break;
            case '0':
@@ -432,7 +438,7 @@ first_phase (bfd *abfd, int type, char *src)
                abfd->flags |= HAS_SYMS;
                new_symbol->prev = abfd->tdata.tekhex_data->symbols;
                abfd->tdata.tekhex_data->symbols = new_symbol;
-               if (!getsym (sym, &src, &len))
+               if (!getsym (sym, &src, &len, src_end))
                  return FALSE;
                new_symbol->symbol.name = (const char *)
                     bfd_alloc (abfd, (bfd_size_type) len + 1);
@@ -480,7 +486,7 @@ first_phase (bfd *abfd, int type, char *src)
                        new_symbol->symbol.section = alt_section;
                      }
                  }
-               if (!getvalue (&src, &val))
+               if (!getvalue (&src, &val, src_end))
                  return FALSE;
                new_symbol->symbol.value = val - section->vma;
                break;
@@ -498,7 +504,7 @@ first_phase (bfd *abfd, int type, char *src)
    record.  */
 
 static bfd_boolean
-pass_over (bfd *abfd, bfd_boolean (*func) (bfd *, int, char *))
+pass_over (bfd *abfd, bfd_boolean (*func) (bfd *, int, char *, char *))
 {
   unsigned int chars_on_line;
   bfd_boolean is_eof = FALSE;
@@ -539,8 +545,7 @@ pass_over (bfd *abfd, bfd_boolean (*func) (bfd *, int, char *))
 
       /* Put a null at the end.  */
       src[chars_on_line] = 0;
-
-      if (!func (abfd, type, src))
+      if (!func (abfd, type, src, src + chars_on_line))
        return FALSE;
     }
 
@@ -957,6 +962,7 @@ tekhex_print_symbol (bfd *abfd,
 #define tekhex_find_nearest_line                    _bfd_nosymbols_find_nearest_line
 #define tekhex_find_line                            _bfd_nosymbols_find_line
 #define tekhex_find_inliner_info                    _bfd_nosymbols_find_inliner_info
+#define tekhex_get_symbol_version_string           _bfd_nosymbols_get_symbol_version_string
 #define tekhex_bfd_make_debug_symbol                _bfd_nosymbols_bfd_make_debug_symbol
 #define tekhex_read_minisymbols                     _bfd_generic_read_minisymbols
 #define tekhex_minisymbol_to_symbol                 _bfd_generic_minisymbol_to_symbol
index c806928..b0c2f71 100644 (file)
@@ -1,4 +1,4 @@
-#define BFD_VERSION_DATE 20141223
+#define BFD_VERSION_DATE 20150721
 #define BFD_VERSION @bfd_version@
 #define BFD_VERSION_STRING  @bfd_version_package@ @bfd_version_string@
 #define REPORT_BUGS_TO @report_bugs_to@
index f88e745..7cabb8b 100644 (file)
@@ -140,6 +140,14 @@ slurp_symtab (bfd *abfd)
       syms = xmalloc (storage);
       symcount = bfd_canonicalize_dynamic_symtab (abfd, syms);
     }
+
+  /* PR 17512: file: 2a1d3b5b.
+     Do not pretend that we have some symbols when we don't.  */
+  if (symcount <= 0)
+    {
+      free (syms);
+      syms = NULL;
+    }
 }
 \f
 /* These global variables are used to pass information between
@@ -423,6 +431,7 @@ main (int argc, char **argv)
 
   program_name = *argv;
   xmalloc_set_program_name (program_name);
+  bfd_set_error_program_name (program_name);
 
   expandargv (&argc, &argv);
 
index 117826d..7c3c869 100644 (file)
@@ -691,6 +691,7 @@ main (int argc, char **argv)
 
   program_name = argv[0];
   xmalloc_set_program_name (program_name);
+  bfd_set_error_program_name (program_name);
 #if BFD_SUPPORTS_PLUGINS
   bfd_plugin_set_program_name (program_name);
 #endif
index 9753ddf..d018bfc 100644 (file)
@@ -29,7 +29,8 @@ extern void *read_debugging_info (bfd *, asymbol **, long, bfd_boolean);
 /* Routine used to print generic debugging information.  */
 
 extern bfd_boolean print_debugging_info
-  (FILE *, void *, bfd *, asymbol **, void *, bfd_boolean);
+  (FILE *, void *, bfd *, asymbol **,
+   char * (*) (struct bfd *, const char *, int), bfd_boolean);
 
 /* Routines used to read and write stabs information.  */
 
index 157ebe0..391eb29 100644 (file)
@@ -176,6 +176,7 @@ main (int argc, char **argv)
 
   program_name = argv[0];
   xmalloc_set_program_name (program_name);
+  bfd_set_error_program_name (program_name);
 
   expandargv (&argc, &argv);
 
index 84e628a..a04adec 100644 (file)
@@ -38,12 +38,13 @@ static unsigned int last_pointer_size = 0;
 static int warned_about_missing_comp_units = FALSE;
 
 static unsigned int num_debug_info_entries = 0;
+static unsigned int alloc_num_debug_info_entries = 0;
 static debug_info *debug_information = NULL;
 /* Special value for num_debug_info_entries to indicate
    that the .debug_info section could not be loaded/parsed.  */
 #define DEBUG_INFO_UNAVAILABLE  (unsigned int) -1
 
-int eh_addr_size;
+unsigned int eh_addr_size;
 
 int do_debug_info;
 int do_debug_abbrevs;
@@ -104,7 +105,7 @@ static void load_cu_tu_indexes (void *file);
 #define FLAG_DEBUG_LINES_RAW    1
 #define FLAG_DEBUG_LINES_DECODED 2
 
-static int
+static unsigned int
 size_of_encoded_value (int encoding)
 {
   switch (encoding & 0x7)
@@ -124,7 +125,7 @@ get_encoded_value (unsigned char **pdata,
                   unsigned char * end)
 {
   unsigned char * data = * pdata;
-  int size = size_of_encoded_value (encoding);
+  unsigned int size = size_of_encoded_value (encoding);
   dwarf_vma val;
 
   if (data + size >= end)
@@ -134,6 +135,22 @@ get_encoded_value (unsigned char **pdata,
       return 0;
     }
 
+  /* PR 17512: file: 002-829853-0.004.  */
+  if (size > 8)
+    {
+      warn (_("Encoded size of %d is too large to read\n"), size);
+      * pdata = end;
+      return 0;
+    }
+
+  /* PR 17512: file: 1085-5603-0.004.  */
+  if (size == 0)
+    {
+      warn (_("Encoded size of 0 is too small to read\n"));
+      * pdata = end;
+      return 0;
+    }
+
   if (encoding & DW_EH_PE_signed)
     val = byte_get_signed (data, size);
   else
@@ -146,17 +163,17 @@ get_encoded_value (unsigned char **pdata,
   return val;
 }
 
-#if __STDC_VERSION__ >= 199901L || (defined(__GNUC__) && __GNUC__ >= 2)
-#ifndef __MINGW32__
-#define  DWARF_VMA_FMT       "ll"
-#define  DWARF_VMA_FMT_LONG  "%16.16llx"
+#if defined HAVE_LONG_LONG && SIZEOF_LONG_LONG > SIZEOF_LONG
+# ifndef __MINGW32__
+#  define DWARF_VMA_FMT                "ll"
+#  define DWARF_VMA_FMT_LONG   "%16.16llx"
+# else
+#  define DWARF_VMA_FMT                "I64"
+#  define DWARF_VMA_FMT_LONG   "%016I64x"
+# endif
 #else
-#define  DWARF_VMA_FMT       "I64"
-#define  DWARF_VMA_FMT_LONG  "%016I64x"
-#endif
-#else
-#define  DWARF_VMA_FMT       "l"
-#define  DWARF_VMA_FMT_LONG  "%16.16lx"
+# define DWARF_VMA_FMT         "l"
+# define DWARF_VMA_FMT_LONG    "%16.16lx"
 #endif
 
 /* Convert a dwarf vma value into a string.  Returns a pointer to a static
@@ -264,6 +281,11 @@ read_leb128 (unsigned char *data,
       shift += 7;
       if ((byte & 0x80) == 0)
        break;
+
+      /* PR 17512: file: 0ca183b8.
+        FIXME: Should we signal this error somehow ?  */
+      if (shift >= sizeof (result) * 8)
+       break;
     }
 
   if (length_return != NULL)
@@ -304,10 +326,10 @@ read_uleb128 (unsigned char * data,
          else                                  \
            amount = 0;                         \
        }                                       \
-      if (amount)                              \
-       VAL = byte_get ((PTR), amount);         \
-      else                                     \
+      if (amount == 0 || amount > 8)           \
        VAL = 0;                                \
+      else                                     \
+       VAL = byte_get ((PTR), amount);         \
     }                                          \
   while (0)
 
@@ -408,7 +430,7 @@ process_extended_line_op (unsigned char * data,
   len = read_uleb128 (data, & bytes_read, end);
   data += bytes_read;
 
-  if (len == 0 || data == end)
+  if (len == 0 || data == end || len > (uintptr_t) (end - data))
     {
       warn (_("Badly formed extended line op encountered!\n"));
       return bytes_read;
@@ -427,7 +449,15 @@ process_extended_line_op (unsigned char * data,
       break;
 
     case DW_LNE_set_address:
-      SAFE_BYTE_GET (adr, data, len - bytes_read - 1, end);
+      /* PR 17512: file: 002-100480-0.004.  */
+      if (len - bytes_read - 1 > 8)
+       {
+         warn (_("Length (%d) of DW_LNE_set_address op is too long\n"),
+               len - bytes_read - 1);
+         adr = 0;
+       }
+      else
+       SAFE_BYTE_GET (adr, data, len - bytes_read - 1, end);
       printf (_("set Address to 0x%s\n"), dwarf_vmatoa ("x", adr));
       state_machine_regs.address = adr;
       state_machine_regs.op_index = 0;
@@ -449,7 +479,7 @@ process_extended_line_op (unsigned char * data,
       printf ("%s\n\n", name);
 
       if (((unsigned int) (data - orig_data) != len) || data == end)
-        warn (_("DW_LNE_define_file: Bad opcode length\n"));
+       warn (_("DW_LNE_define_file: Bad opcode length\n"));
       break;
 
     case DW_LNE_set_discriminator:
@@ -490,68 +520,68 @@ process_extended_line_op (unsigned char * data,
       break;
     case DW_LNE_HP_source_file_correlation:
       {
-        unsigned char *edata = data + len - bytes_read - 1;
-
-        printf ("DW_LNE_HP_source_file_correlation\n");
-
-        while (data < edata)
-          {
-            unsigned int opc;
-
-            opc = read_uleb128 (data, & bytes_read, edata);
-            data += bytes_read;
-
-            switch (opc)
-              {
-              case DW_LNE_HP_SFC_formfeed:
-                printf ("    DW_LNE_HP_SFC_formfeed\n");
-                break;
-              case DW_LNE_HP_SFC_set_listing_line:
-                printf ("    DW_LNE_HP_SFC_set_listing_line (%s)\n",
-                        dwarf_vmatoa ("u",
-                                      read_uleb128 (data, & bytes_read, edata)));
-                data += bytes_read;
-                break;
-              case DW_LNE_HP_SFC_associate:
-                printf ("    DW_LNE_HP_SFC_associate ");
-                printf ("(%s",
-                        dwarf_vmatoa ("u",
-                                      read_uleb128 (data, & bytes_read, edata)));
-                data += bytes_read;
-                printf (",%s",
-                        dwarf_vmatoa ("u",
-                                      read_uleb128 (data, & bytes_read, edata)));
-                data += bytes_read;
-                printf (",%s)\n",
-                        dwarf_vmatoa ("u",
-                                      read_uleb128 (data, & bytes_read, edata)));
-                data += bytes_read;
-                break;
-              default:
-                printf (_("    UNKNOWN DW_LNE_HP_SFC opcode (%u)\n"), opc);
-                data = edata;
-                break;
-              }
-          }
+       unsigned char *edata = data + len - bytes_read - 1;
+
+       printf ("DW_LNE_HP_source_file_correlation\n");
+
+       while (data < edata)
+         {
+           unsigned int opc;
+
+           opc = read_uleb128 (data, & bytes_read, edata);
+           data += bytes_read;
+
+           switch (opc)
+             {
+             case DW_LNE_HP_SFC_formfeed:
+               printf ("    DW_LNE_HP_SFC_formfeed\n");
+               break;
+             case DW_LNE_HP_SFC_set_listing_line:
+               printf ("    DW_LNE_HP_SFC_set_listing_line (%s)\n",
+                       dwarf_vmatoa ("u",
+                                     read_uleb128 (data, & bytes_read, edata)));
+               data += bytes_read;
+               break;
+             case DW_LNE_HP_SFC_associate:
+               printf ("    DW_LNE_HP_SFC_associate ");
+               printf ("(%s",
+                       dwarf_vmatoa ("u",
+                                     read_uleb128 (data, & bytes_read, edata)));
+               data += bytes_read;
+               printf (",%s",
+                       dwarf_vmatoa ("u",
+                                     read_uleb128 (data, & bytes_read, edata)));
+               data += bytes_read;
+               printf (",%s)\n",
+                       dwarf_vmatoa ("u",
+                                     read_uleb128 (data, & bytes_read, edata)));
+               data += bytes_read;
+               break;
+             default:
+               printf (_("    UNKNOWN DW_LNE_HP_SFC opcode (%u)\n"), opc);
+               data = edata;
+               break;
+             }
+         }
       }
       break;
 
     default:
       {
-        unsigned int rlen = len - bytes_read - 1;
-
-        if (op_code >= DW_LNE_lo_user
-            /* The test against DW_LNW_hi_user is redundant due to
-               the limited range of the unsigned char data type used
-               for op_code.  */
-            /*&& op_code <= DW_LNE_hi_user*/)
-          printf (_("user defined: "));
-        else
-          printf (_("UNKNOWN: "));
-        printf (_("length %d ["), rlen);
-        for (; rlen; rlen--)
-          printf (" %02x", *data++);
-        printf ("]\n");
+       unsigned int rlen = len - bytes_read - 1;
+
+       if (op_code >= DW_LNE_lo_user
+           /* The test against DW_LNW_hi_user is redundant due to
+              the limited range of the unsigned char data type used
+              for op_code.  */
+           /*&& op_code <= DW_LNE_hi_user*/)
+         printf (_("user defined: "));
+       else
+         printf (_("UNKNOWN: "));
+       printf (_("length %d ["), rlen);
+       for (; rlen; rlen--)
+         printf (" %02x", *data++);
+       printf ("]\n");
       }
       break;
     }
@@ -628,7 +658,7 @@ fetch_indexed_value (dwarf_vma offset, dwarf_vma bytes)
   if (offset + bytes > section->size)
     {
       warn (_("Offset into section %s too big: %s\n"),
-            section->name, dwarf_vmatoa ("x", offset));
+           section->name, dwarf_vmatoa ("x", offset));
       return "<offset too big>";
     }
 
@@ -841,6 +871,8 @@ display_block (unsigned char *data,
   dwarf_vma maxlen;
 
   printf (_(" %s byte block: "), dwarf_vmatoa ("u", length));
+  if (data > end)
+    return (unsigned char *) end;
 
   maxlen = (dwarf_vma) (end - data);
   length = length > maxlen ? maxlen : length;
@@ -1231,8 +1263,7 @@ decode_location_expression (unsigned char * data,
          printf ("DW_OP_implicit_value");
          uvalue = read_uleb128 (data, &bytes_read, end);
          data += bytes_read;
-         display_block (data, uvalue, end);
-         data += uvalue;
+         data = display_block (data, uvalue, end);
          break;
 
          /* GNU extensions.  */
@@ -1245,10 +1276,11 @@ decode_location_expression (unsigned char * data,
          break;
        case DW_OP_GNU_encoded_addr:
          {
-           int encoding;
+           int encoding = 0;
            dwarf_vma addr;
 
-           encoding = *data++;
+           if (data < end)
+             encoding = *data++;
            addr = get_encoded_value (&data, encoding, section, end);
 
            printf ("DW_OP_GNU_encoded_addr: fmt:%02x addr:", encoding);
@@ -1281,6 +1313,9 @@ decode_location_expression (unsigned char * data,
        case DW_OP_GNU_entry_value:
          uvalue = read_uleb128 (data, &bytes_read, end);
          data += bytes_read;
+         /* PR 17531: file: 0cc9cd00.  */
+         if (uvalue > (dwarf_vma) (end - data))
+           uvalue = end - data;
          printf ("DW_OP_GNU_entry_value: (");
          if (decode_location_expression (data, pointer_size, offset_size,
                                          dwarf_version, uvalue,
@@ -1288,6 +1323,8 @@ decode_location_expression (unsigned char * data,
            need_frame_base = 1;
          putchar (')');
          data += uvalue;
+         if (data > end)
+           data = end;
          break;
        case DW_OP_GNU_const_type:
          uvalue = read_uleb128 (data, &bytes_read, end);
@@ -1295,8 +1332,7 @@ decode_location_expression (unsigned char * data,
          printf ("DW_OP_GNU_const_type: <0x%s> ",
                  dwarf_vmatoa ("x", cu_offset + uvalue));
          SAFE_BYTE_GET_AND_INC (uvalue, data, 1, end);
-         display_block (data, uvalue, end);
-         data += uvalue;
+         data = display_block (data, uvalue, end);
          break;
        case DW_OP_GNU_regval_type:
          uvalue = read_uleb128 (data, &bytes_read, end);
@@ -1331,16 +1367,16 @@ decode_location_expression (unsigned char * data,
          printf ("DW_OP_GNU_parameter_ref: <0x%s>",
                  dwarf_vmatoa ("x", cu_offset + uvalue));
          break;
-        case DW_OP_GNU_addr_index:
-          uvalue = read_uleb128 (data, &bytes_read, end);
-          data += bytes_read;
-          printf ("DW_OP_GNU_addr_index <0x%s>", dwarf_vmatoa ("x", uvalue));
-          break;
-        case DW_OP_GNU_const_index:
-          uvalue = read_uleb128 (data, &bytes_read, end);
-          data += bytes_read;
-          printf ("DW_OP_GNU_const_index <0x%s>", dwarf_vmatoa ("x", uvalue));
-          break;
+       case DW_OP_GNU_addr_index:
+         uvalue = read_uleb128 (data, &bytes_read, end);
+         data += bytes_read;
+         printf ("DW_OP_GNU_addr_index <0x%s>", dwarf_vmatoa ("x", uvalue));
+         break;
+       case DW_OP_GNU_const_index:
+         uvalue = read_uleb128 (data, &bytes_read, end);
+         data += bytes_read;
+         printf ("DW_OP_GNU_const_index <0x%s>", dwarf_vmatoa ("x", uvalue));
+         break;
 
          /* HP extensions.  */
        case DW_OP_HP_is_value:
@@ -1633,8 +1669,18 @@ read_and_display_attr_value (unsigned long attribute,
     case DW_FORM_exprloc:
       uvalue = read_uleb128 (data, & bytes_read, end);
       block_start = data + bytes_read;
+      if (block_start >= end)
+       {
+         warn (_("Block ends prematurely\n"));
+         uvalue = 0;
+         block_start = end;
+       }
+      /* FIXME: Testing "(block_start + uvalue) < block_start" miscompiles with
+        gcc 4.8.3 running on an x86_64 host in 32-bit mode.  So we pre-compute
+        block_start + uvalue here.  */
+      data = block_start + uvalue;
       /* PR 17512: file: 008-103549-0.001:0.1.  */
-      if (block_start + uvalue > end)
+      if (block_start + uvalue > end || data < block_start)
        {
          warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue);
          uvalue = end - block_start;
@@ -1648,7 +1694,14 @@ read_and_display_attr_value (unsigned long attribute,
     case DW_FORM_block1:
       SAFE_BYTE_GET (uvalue, data, 1, end);
       block_start = data + 1;
-      if (block_start + uvalue > end)
+      if (block_start >= end)
+       {
+         warn (_("Block ends prematurely\n"));
+         uvalue = 0;
+         block_start = end;
+       }
+      data = block_start + uvalue;
+      if (block_start + uvalue > end || data < block_start)
        {
          warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue);
          uvalue = end - block_start;
@@ -1662,7 +1715,14 @@ read_and_display_attr_value (unsigned long attribute,
     case DW_FORM_block2:
       SAFE_BYTE_GET (uvalue, data, 2, end);
       block_start = data + 2;
-      if (block_start + uvalue > end)
+      if (block_start >= end)
+       {
+         warn (_("Block ends prematurely\n"));
+         uvalue = 0;
+         block_start = end;
+       }
+      data = block_start + uvalue;
+      if (block_start + uvalue > end || data < block_start)
        {
          warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue);
          uvalue = end - block_start;
@@ -1676,7 +1736,17 @@ read_and_display_attr_value (unsigned long attribute,
     case DW_FORM_block4:
       SAFE_BYTE_GET (uvalue, data, 4, end);
       block_start = data + 4;
-      if (block_start + uvalue > end)
+      /* PR 17512: file: 3371-3907-0.004.  */
+      if (block_start >= end)
+       {
+         warn (_("Block ends prematurely\n"));
+         uvalue = 0;
+         block_start = end;
+       }
+      data = block_start + uvalue;
+      if (block_start + uvalue > end
+         /* PR 17531: file: 5b5f0592.  */
+         || data < block_start)
        {
          warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue);
          uvalue = end - block_start;
@@ -1696,14 +1766,14 @@ read_and_display_attr_value (unsigned long attribute,
 
     case DW_FORM_GNU_str_index:
       if (!do_loc)
-        {
-          const char *suffix = strrchr (section->name, '.');
-          int dwo = (suffix && strcmp (suffix, ".dwo") == 0) ? 1 : 0;
-
-          printf (_(" (indexed string: 0x%s): %s"),
-                  dwarf_vmatoa ("x", uvalue),
-                  fetch_indexed_string (uvalue, this_set, offset_size, dwo));
-        }
+       {
+         const char *suffix = strrchr (section->name, '.');
+         int dwo = (suffix && strcmp (suffix, ".dwo") == 0) ? 1 : 0;
+
+         printf (_(" (indexed string: 0x%s): %s"),
+                 dwarf_vmatoa ("x", uvalue),
+                 fetch_indexed_string (uvalue, this_set, offset_size, dwo));
+       }
       break;
 
     case DW_FORM_GNU_strp_alt:
@@ -1731,9 +1801,9 @@ read_and_display_attr_value (unsigned long attribute,
 
     case DW_FORM_GNU_addr_index:
       if (!do_loc)
-        printf (_(" (addr_index: 0x%s): %s"),
-                dwarf_vmatoa ("x", uvalue),
-                fetch_indexed_value (uvalue * pointer_size, pointer_size));
+       printf (_(" (addr_index: 0x%s): %s"),
+               dwarf_vmatoa ("x", uvalue),
+               fetch_indexed_value (uvalue * pointer_size, pointer_size));
       break;
 
     default:
@@ -1761,7 +1831,7 @@ read_and_display_attr_value (unsigned long attribute,
        case DW_AT_GNU_call_site_data_value:
        case DW_AT_GNU_call_site_target:
        case DW_AT_GNU_call_site_target_clobbered:
-         if ((dwarf_version < 4
+         if ((dwarf_version < 4
               && (form == DW_FORM_data4 || form == DW_FORM_data8))
              || form == DW_FORM_sec_offset)
            {
@@ -1773,15 +1843,15 @@ read_and_display_attr_value (unsigned long attribute,
                {
                  lmax += 1024;
                  debug_info_p->loc_offsets = (dwarf_vma *)
-                      xcrealloc (debug_info_p->loc_offsets,
-                                lmax, sizeof (*debug_info_p->loc_offsets));
+                   xcrealloc (debug_info_p->loc_offsets,
+                              lmax, sizeof (*debug_info_p->loc_offsets));
                  debug_info_p->have_frame_base = (int *)
-                      xcrealloc (debug_info_p->have_frame_base,
-                                lmax, sizeof (*debug_info_p->have_frame_base));
+                   xcrealloc (debug_info_p->have_frame_base,
+                              lmax, sizeof (*debug_info_p->have_frame_base));
                  debug_info_p->max_loc_offsets = lmax;
                }
              if (this_set != NULL)
-               uvalue += this_set->section_offsets [DW_SECT_LOC];
+               uvalue += this_set->section_offsets [DW_SECT_LOC];
              debug_info_p->loc_offsets [num] = uvalue;
              debug_info_p->have_frame_base [num] = have_frame_base;
              debug_info_p->num_loc_offsets++;
@@ -1794,15 +1864,15 @@ read_and_display_attr_value (unsigned long attribute,
          break;
 
        case DW_AT_GNU_addr_base:
-          debug_info_p->addr_base = uvalue;
+         debug_info_p->addr_base = uvalue;
          break;
 
        case DW_AT_GNU_ranges_base:
-          debug_info_p->ranges_base = uvalue;
+         debug_info_p->ranges_base = uvalue;
          break;
 
        case DW_AT_ranges:
-         if ((dwarf_version < 4
+         if ((dwarf_version < 4
               && (form == DW_FORM_data4 || form == DW_FORM_data8))
              || form == DW_FORM_sec_offset)
            {
@@ -1814,8 +1884,8 @@ read_and_display_attr_value (unsigned long attribute,
                {
                  lmax += 1024;
                  debug_info_p->range_lists = (dwarf_vma *)
-                      xcrealloc (debug_info_p->range_lists,
-                                lmax, sizeof (*debug_info_p->range_lists));
+                   xcrealloc (debug_info_p->range_lists,
+                              lmax, sizeof (*debug_info_p->range_lists));
                  debug_info_p->max_range_lists = lmax;
                }
              debug_info_p->range_lists [num] = uvalue;
@@ -1887,6 +1957,9 @@ read_and_display_attr_value (unsigned long attribute,
        case DW_LANG_Python:            printf ("(Python)"); break;
          /* DWARF 5 values.  */
        case DW_LANG_Go:                printf ("(Go)"); break;
+       case DW_LANG_C_plus_plus_11:    printf ("(C++11)"); break;
+       case DW_LANG_C11:               printf ("(C11)"); break;
+       case DW_LANG_C_plus_plus_14:    printf ("(C++14)"); break;
          /* MIPS extension.  */
        case DW_LANG_Mips_Assembler:    printf ("(MIPS assembler)"); break;
          /* UPC extension.  */
@@ -2030,7 +2103,7 @@ read_and_display_attr_value (unsigned long attribute,
     case DW_AT_GNU_call_site_target:
     case DW_AT_GNU_call_site_target_clobbered:
       if ((dwarf_version < 4
-           && (form == DW_FORM_data4 || form == DW_FORM_data8))
+          && (form == DW_FORM_data4 || form == DW_FORM_data8))
          || form == DW_FORM_sec_offset)
        printf (_(" (location list)"));
       /* Fall through.  */
@@ -2061,7 +2134,7 @@ read_and_display_attr_value (unsigned long attribute,
       {
        if (form == DW_FORM_ref_sig8
            || form == DW_FORM_GNU_ref_alt)
-          break;
+         break;
 
        if (form == DW_FORM_ref1
            || form == DW_FORM_ref2
@@ -2070,7 +2143,7 @@ read_and_display_attr_value (unsigned long attribute,
          uvalue += cu_offset;
 
        if (uvalue >= section->size)
-         warn (_("Offset %s used as value for DW_AT_import attribute of DIE at offset %lx is too big.\n"),
+         warn (_("Offset %s used as value for DW_AT_import attribute of DIE at offset 0x%lx is too big.\n"),
                dwarf_vmatoa ("x", uvalue),
                (unsigned long) (orig_data - section->start));
        else
@@ -2163,7 +2236,7 @@ read_and_display_attr (unsigned long attribute,
 static int
 process_debug_info (struct dwarf_section *section,
                    void *file,
-                    enum dwarf_section_display_enum abbrev_sec,
+                   enum dwarf_section_display_enum abbrev_sec,
                    int do_loc,
                    int do_types)
 {
@@ -2204,8 +2277,8 @@ process_debug_info (struct dwarf_section *section,
 
          /* Negative values are illegal, they may even cause infinite
             looping.  This can happen if we can't accurately apply
-            relocations to an object file.  */
-         if ((signed long) length <= 0)
+            relocations to an object file, or if the file is corrupt.  */
+         if ((signed long) length <= 0 || section_begin < start)
            {
              warn (_("Corrupt unit length (0x%s) found in section %s\n"),
                    dwarf_vmatoa ("x", length), section->name);
@@ -2221,13 +2294,22 @@ process_debug_info (struct dwarf_section *section,
 
       /* Then allocate an array to hold the information.  */
       debug_information = (debug_info *) cmalloc (num_units,
-                                                  sizeof (* debug_information));
+                                                 sizeof (* debug_information));
       if (debug_information == NULL)
        {
          error (_("Not enough memory for a debug info array of %u entries\n"),
                 num_units);
+         alloc_num_debug_info_entries = num_debug_info_entries = 0;
          return 0;
        }
+      /* PR 17531: file: 92ca3797.
+        We cannot rely upon the debug_information array being initialised
+        before it is used.  A corrupt file could easily contain references
+        to a unit for which information has not been made available.  So
+        we ensure that the array is zeroed here.  */
+      memset (debug_information, 0, num_units * sizeof (*debug_information));
+
+      alloc_num_debug_info_entries = num_units;
     }
 
   if (!do_loc)
@@ -2311,11 +2393,11 @@ process_debug_info (struct dwarf_section *section,
        }
 
       if (do_types)
-        {
+       {
          SAFE_BYTE_GET64 (hdrptr, &signature_high, &signature_low, end);
          hdrptr += 8;
          SAFE_BYTE_GET_AND_INC (type_offset, hdrptr, offset_size, end);
-        }
+       }
 
       if ((do_loc || do_debug_loc || do_debug_ranges)
          && num_debug_info_entries == 0
@@ -2384,14 +2466,22 @@ process_debug_info (struct dwarf_section *section,
          > section->size)
        {
          warn (_("Debug info is corrupted, length of CU at %s"
-                 " extends beyond end of section (length = %s)\n"),
+                 " extends beyond end of section (length = %s)\n"),
                dwarf_vmatoa ("x", cu_offset),
                dwarf_vmatoa ("x", compunit.cu_length));
+         num_units = unit;
          break;
        }
       tags = hdrptr;
       start += compunit.cu_length + initial_length_size;
 
+      if (start > end)
+       {
+         warn (_("Debug info is corrupt.  CU at %s extends beyond end of section"),
+               dwarf_vmatoa ("x", cu_offset));
+         start = end;
+       }
+
       if (compunit.cu_version != 2
          && compunit.cu_version != 3
          && compunit.cu_version != 4)
@@ -2409,6 +2499,12 @@ process_debug_info (struct dwarf_section *section,
        warn (_("Debug info is corrupted, abbrev offset (%lx) is larger than abbrev section size (%lx)\n"),
              (unsigned long) compunit.cu_abbrev_offset,
              (unsigned long) abbrev_size);
+      /* PR 17531: file:4bcd9ce9.  */
+      else if ((abbrev_base + abbrev_size)
+              > debug_displays [abbrev_sec].section.size)
+       warn (_("Debug info is corrupted, abbrev size (%lx) is larger than abbrev section size (%lx)\n"),
+             (unsigned long) abbrev_base + abbrev_size,
+             (unsigned long) debug_displays [abbrev_sec].section.size);
       else
        process_abbrev_section
          (((unsigned char *) debug_displays [abbrev_sec].section.start
@@ -2508,7 +2604,7 @@ process_debug_info (struct dwarf_section *section,
                  printf ("\n");
                  fflush (stdout);
                }
-             warn (_("DIE at offset %lx refers to abbreviation number %lu which does not exist\n"),
+             warn (_("DIE at offset 0x%lx refers to abbreviation number %lu which does not exist\n"),
                    die_offset, abbrev_number);
              return 0;
            }
@@ -2542,9 +2638,10 @@ process_debug_info (struct dwarf_section *section,
                /* Show the offset from where the tag was extracted.  */
                printf ("    <%lx>", (unsigned long)(tags - section_begin));
 
-             arg = debug_information;
-             if (debug_information)
-               arg += unit;
+             if (debug_information && unit < alloc_num_debug_info_entries)
+               arg = debug_information + unit;
+             else
+               arg = NULL;
 
              tags = read_and_display_attr (attr->attribute,
                                            attr->form,
@@ -2560,9 +2657,9 @@ process_debug_info (struct dwarf_section *section,
                                            this_set);
            }
 
-         if (entry->children)
-           ++level;
-       }
+         if (entry->children)
+           ++level;
+       }
     }
 
   /* Set num_debug_info_entries here so that it can be used to check if
@@ -2570,7 +2667,12 @@ process_debug_info (struct dwarf_section *section,
   if ((do_loc || do_debug_loc || do_debug_ranges)
       && num_debug_info_entries == 0
       && ! do_types)
-    num_debug_info_entries = num_units;
+    {
+      if (num_units > alloc_num_debug_info_entries)
+       num_debug_info_entries = alloc_num_debug_info_entries;
+      else
+       num_debug_info_entries = num_units;
+    }
 
   if (!do_loc)
     printf ("\n");
@@ -2607,9 +2709,10 @@ load_debug_info (void * file)
   if (load_debug_section (info, file)
       && process_debug_info (&debug_displays [info].section, file, abbrev, 1, 0))
     return num_debug_info_entries;
-  else if (load_debug_section (info_dwo, file)
-           && process_debug_info (&debug_displays [info_dwo].section, file,
-                                  abbrev_dwo, 1, 0))
+
+  if (load_debug_section (info_dwo, file)
+      && process_debug_info (&debug_displays [info_dwo].section, file,
+                            abbrev_dwo, 1, 0))
     return num_debug_info_entries;
 
   num_debug_info_entries = DEBUG_INFO_UNAVAILABLE;
@@ -2634,7 +2737,7 @@ read_debug_line_header (struct dwarf_section * section,
 
   /* Extract information from the Line Number Program Header.
      (section 6.2.4 in the Dwarf3 doc).  */
-      hdrptr = data;
+  hdrptr = data;
 
   /* Get and check the length of the block.  */
   SAFE_BYTE_GET_AND_INC (linfo->li_length, hdrptr, 4, end);
@@ -2703,18 +2806,27 @@ read_debug_line_header (struct dwarf_section * section,
   SAFE_BYTE_GET_AND_INC (linfo->li_opcode_base, hdrptr, 1, end);
 
   * end_of_sequence = data + linfo->li_length + initial_length_size;
+  /* PR 17512: file:002-117414-0.004.  */
+  if (* end_of_sequence > end)
+    {
+      warn (_("Line length %s extends beyond end of section\n"),
+           dwarf_vmatoa ("u", linfo->li_length));
+      * end_of_sequence = end;
+      return NULL;
+    }
+
   return hdrptr;
 }
 
 static int
 display_debug_lines_raw (struct dwarf_section *section,
                         unsigned char *data,
-                         unsigned char *end)
+                        unsigned char *end)
 {
   unsigned char *start = section->start;
 
   printf (_("Raw dump of debug contents of section %s:\n\n"),
-          section->name);
+         section->name);
 
   while (data < end)
     {
@@ -2743,6 +2855,12 @@ display_debug_lines_raw (struct dwarf_section *section,
          end_of_sequence = end;
          standard_opcodes = NULL;
          linfo = saved_linfo;
+         /* PR 17531: file: 0522b371.  */
+         if (linfo.li_line_range == 0)
+           {
+             warn (_("Partial .debug_line. section encountered without a prior full .debug_line section\n"));
+             return 0;
+           }
          reset_state_machine (linfo.li_default_is_stmt);
        }
       else
@@ -2756,7 +2874,7 @@ display_debug_lines_raw (struct dwarf_section *section,
          printf (_("  Offset:                      0x%lx\n"), (long)(data - start));
          printf (_("  Length:                      %ld\n"), (long) linfo.li_length);
          printf (_("  DWARF Version:               %d\n"), linfo.li_version);
-         printf (_("  Prologue Length:             %d\n"), linfo.li_prologue_length);
+         printf (_("  Prologue Length:             %d\n"), (int) linfo.li_prologue_length);
          printf (_("  Minimum Instruction Length:  %d\n"), linfo.li_min_insn_length);
          if (linfo.li_version >= 4)
            printf (_("  Maximum Ops per Instruction: %d\n"), linfo.li_max_ops_per_insn);
@@ -2765,11 +2883,25 @@ display_debug_lines_raw (struct dwarf_section *section,
          printf (_("  Line Range:                  %d\n"), linfo.li_line_range);
          printf (_("  Opcode Base:                 %d\n"), linfo.li_opcode_base);
 
+         /* PR 17512: file: 1665-6428-0.004.  */
+         if (linfo.li_line_range == 0)
+           {
+             warn (_("Line range of 0 is invalid, using 1 instead\n"));
+             linfo.li_line_range = 1;
+           }
+
          reset_state_machine (linfo.li_default_is_stmt);
 
          /* Display the contents of the Opcodes table.  */
          standard_opcodes = hdrptr;
 
+         /* PR 17512: file: 002-417945-0.004.  */
+         if (standard_opcodes + linfo.li_opcode_base >= end)
+           {
+             warn (_("Line Base extends beyond end of section\n"));
+             return 0;
+           }
+
          printf (_("\n Opcodes:\n"));
 
          for (i = 1; i < linfo.li_opcode_base; i++)
@@ -2785,12 +2917,16 @@ display_debug_lines_raw (struct dwarf_section *section,
              printf (_("\n The Directory Table (offset 0x%lx):\n"),
                      (long)(data - start));
 
-             while (*data != 0)
+             while (data < end && *data != 0)
                {
-                 printf ("  %d\t%s\n", ++last_dir_entry, data);
+                 printf ("  %d\t%.*s\n", ++last_dir_entry, (int) (end - data), data);
 
                  data += strnlen ((char *) data, end - data) + 1;
                }
+
+             /* PR 17512: file: 002-132094-0.004.  */
+             if (data >= end - 1)
+               break;
            }
 
          /* Skip the NUL at the end of the table.  */
@@ -2805,7 +2941,7 @@ display_debug_lines_raw (struct dwarf_section *section,
                      (long)(data - start));
              printf (_("  Entry\tDir\tTime\tSize\tName\n"));
 
-             while (*data != 0)
+             while (data < end && *data != 0)
                {
                  unsigned char *name;
                  unsigned int bytes_read;
@@ -2823,7 +2959,7 @@ display_debug_lines_raw (struct dwarf_section *section,
                  printf ("%s\t",
                          dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
                  data += bytes_read;
-                 printf ("%s\n", name);
+                 printf ("%.*s\n", (int)(end - name), name);
 
                  if (data == end)
                    {
@@ -3053,7 +3189,7 @@ display_debug_lines_decoded (struct dwarf_section *section,
   static DWARF2_Internal_LineInfo saved_linfo;
 
   printf (_("Decoded dump of debug contents of section %s:\n\n"),
-          section->name);
+         section->name);
 
   while (data < end)
     {
@@ -3071,21 +3207,33 @@ display_debug_lines_decoded (struct dwarf_section *section,
          /* Note: the following does not apply to .debug_line.dwo sections.
             These are full debug_line sections.  */
          && strcmp (section->name, ".debug_line.dwo") != 0)
-        {
+       {
          /* See comment in display_debug_lines_raw().  */
          end_of_sequence = end;
          standard_opcodes = NULL;
          linfo = saved_linfo;
+         /* PR 17531: file: 0522b371.  */
+         if (linfo.li_line_range == 0)
+           {
+             warn (_("Partial .debug_line. section encountered without a prior full .debug_line section\n"));
+             return 0;
+           }
          reset_state_machine (linfo.li_default_is_stmt);
-        }
+       }
       else
-        {
+       {
          unsigned char *hdrptr;
 
          if ((hdrptr = read_debug_line_header (section, data, end, & linfo,
                                                & end_of_sequence)) == NULL)
              return 0;
 
+         /* PR 17531: file: 0522b371.  */
+         if (linfo.li_line_range == 0)
+           {
+             warn (_("Line range of 0 is invalid, using 1 instead\n"));
+             linfo.li_line_range = 1;
+           }
          reset_state_machine (linfo.li_default_is_stmt);
 
          /* Save a pointer to the contents of the Opcodes table.  */
@@ -3194,16 +3342,16 @@ display_debug_lines_decoded (struct dwarf_section *section,
 
       /* This loop iterates through the Dwarf Line Number Program.  */
       while (data < end_of_sequence)
-        {
+       {
          unsigned char op_code;
-          int adv;
-          unsigned long int uladv;
-          unsigned int bytes_read;
-          int is_special_opcode = 0;
+         int adv;
+         unsigned long int uladv;
+         unsigned int bytes_read;
+         int is_special_opcode = 0;
 
-          op_code = *data++;
+         op_code = *data++;
 
-          if (op_code >= linfo.li_opcode_base)
+         if (op_code >= linfo.li_opcode_base)
            {
              op_code -= linfo.li_opcode_base;
              uladv = (op_code / linfo.li_line_range);
@@ -3223,11 +3371,11 @@ display_debug_lines_decoded (struct dwarf_section *section,
                    % linfo.li_max_ops_per_insn;
                }
 
-              adv = (op_code % linfo.li_line_range) + linfo.li_line_base;
-              state_machine_regs.line += adv;
-              is_special_opcode = 1;
-            }
-          else switch (op_code)
+             adv = (op_code % linfo.li_line_range) + linfo.li_line_base;
+             state_machine_regs.line += adv;
+             is_special_opcode = 1;
+           }
+         else switch (op_code)
                 {
                 case DW_LNS_extended_op:
                   {
@@ -3417,15 +3565,15 @@ display_debug_lines_decoded (struct dwarf_section *section,
                   break;
                 }
 
-          /* Only Special opcodes, DW_LNS_copy and DW_LNE_end_sequence adds a row
-             to the DWARF address/line matrix.  */
-          if ((is_special_opcode) || (op_code == DW_LNE_end_sequence)
+         /* Only Special opcodes, DW_LNS_copy and DW_LNE_end_sequence adds a row
+            to the DWARF address/line matrix.  */
+         if ((is_special_opcode) || (op_code == DW_LNE_end_sequence)
              || (op_code == DW_LNS_copy))
-            {
-              const unsigned int MAX_FILENAME_LENGTH = 35;
-              char *fileName;
-              char *newFileName = NULL;
-              size_t fileNameLength;
+           {
+             const unsigned int MAX_FILENAME_LENGTH = 35;
+             char *fileName;
+             char *newFileName = NULL;
+             size_t fileNameLength;
 
              if (file_table)
                fileName = (char *) file_table[state_machine_regs.file - 1].name;
@@ -3434,22 +3582,22 @@ display_debug_lines_decoded (struct dwarf_section *section,
 
              fileNameLength = strlen (fileName);
 
-              if ((fileNameLength > MAX_FILENAME_LENGTH) && (!do_wide))
-                {
-                  newFileName = (char *) xmalloc (MAX_FILENAME_LENGTH + 1);
-                  /* Truncate file name */
-                  strncpy (newFileName,
-                           fileName + fileNameLength - MAX_FILENAME_LENGTH,
-                           MAX_FILENAME_LENGTH + 1);
-                }
-              else
-                {
-                  newFileName = (char *) xmalloc (fileNameLength + 1);
-                  strncpy (newFileName, fileName, fileNameLength + 1);
-                }
-
-              if (!do_wide || (fileNameLength <= MAX_FILENAME_LENGTH))
-                {
+             if ((fileNameLength > MAX_FILENAME_LENGTH) && (!do_wide))
+               {
+                 newFileName = (char *) xmalloc (MAX_FILENAME_LENGTH + 1);
+                 /* Truncate file name */
+                 strncpy (newFileName,
+                          fileName + fileNameLength - MAX_FILENAME_LENGTH,
+                          MAX_FILENAME_LENGTH + 1);
+               }
+             else
+               {
+                 newFileName = (char *) xmalloc (fileNameLength + 1);
+                 strncpy (newFileName, fileName, fileNameLength + 1);
+               }
+
+             if (!do_wide || (fileNameLength <= MAX_FILENAME_LENGTH))
+               {
                  if (linfo.li_max_ops_per_insn == 1)
                    printf ("%-35s  %11d  %#18" DWARF_VMA_FMT "x\n",
                            newFileName, state_machine_regs.line,
@@ -3459,9 +3607,9 @@ display_debug_lines_decoded (struct dwarf_section *section,
                            newFileName, state_machine_regs.line,
                            state_machine_regs.address,
                            state_machine_regs.op_index);
-                }
-              else
-                {
+               }
+             else
+               {
                  if (linfo.li_max_ops_per_insn == 1)
                    printf ("%s  %11d  %#18" DWARF_VMA_FMT "x\n",
                            newFileName, state_machine_regs.line,
@@ -3471,14 +3619,14 @@ display_debug_lines_decoded (struct dwarf_section *section,
                            newFileName, state_machine_regs.line,
                            state_machine_regs.address,
                            state_machine_regs.op_index);
-                }
+               }
 
-              if (op_code == DW_LNE_end_sequence)
+             if (op_code == DW_LNE_end_sequence)
                printf ("\n");
 
-              free (newFileName);
-            }
-        }
+             free (newFileName);
+           }
+       }
 
       if (file_table)
        {
@@ -3575,7 +3723,8 @@ display_debug_pubnames_worker (struct dwarf_section *section,
   while (start < end)
     {
       unsigned char *data;
-      unsigned long offset;
+      unsigned char *adr;
+      dwarf_vma offset;
       unsigned int offset_size, initial_length_size;
 
       data = start;
@@ -3604,7 +3753,26 @@ display_debug_pubnames_worker (struct dwarf_section *section,
 
       SAFE_BYTE_GET_AND_INC (names.pn_size, data, offset_size, end);
 
-      start += names.pn_length + initial_length_size;
+      adr = start + names.pn_length + initial_length_size;
+      /* PR 17531: file: 7615b6b2.  */
+      if ((dwarf_signed_vma) names.pn_length < 0
+         /* PR 17531: file: a5dbeaa7. */
+         || adr < start)
+       {
+         warn (_("Negative length for public name: 0x%lx\n"), (long) names.pn_length);
+         start = end;
+       }
+      else
+       start = adr;
+
+      printf (_("  Length:                              %ld\n"),
+             (long) names.pn_length);
+      printf (_("  Version:                             %d\n"),
+             names.pn_version);
+      printf (_("  Offset into .debug_info section:     0x%lx\n"),
+             (unsigned long) names.pn_offset);
+      printf (_("  Size of area in .debug_info section: %ld\n"),
+             (long) names.pn_size);
 
       if (names.pn_version != 2 && names.pn_version != 3)
        {
@@ -3619,15 +3787,6 @@ display_debug_pubnames_worker (struct dwarf_section *section,
          continue;
        }
 
-      printf (_("  Length:                              %ld\n"),
-             (long) names.pn_length);
-      printf (_("  Version:                             %d\n"),
-             names.pn_version);
-      printf (_("  Offset into .debug_info section:     0x%lx\n"),
-             (unsigned long) names.pn_offset);
-      printf (_("  Size of area in .debug_info section: %ld\n"),
-             (long) names.pn_size);
-
       if (is_gnu)
        printf (_("\n    Offset  Kind          Name\n"));
       else
@@ -3645,7 +3804,7 @@ display_debug_pubnames_worker (struct dwarf_section *section,
              if (data >= end)
                break;
              maxprint = (end - data) - 1;
-             
+
              if (is_gnu)
                {
                  unsigned int kind_data;
@@ -3665,11 +3824,12 @@ display_debug_pubnames_worker (struct dwarf_section *section,
                  kind_name = get_gdb_index_symbol_kind_name (kind);
                  is_static = GDB_INDEX_SYMBOL_STATIC_VALUE (kind_data);
                  printf ("    %-6lx  %s,%-10s  %.*s\n",
-                         offset, is_static ? _("s") : _("g"),
+                         (unsigned long) offset, is_static ? _("s") : _("g"),
                          kind_name, (int) maxprint, data);
                }
              else
-               printf ("    %-6lx\t%.*s\n", offset, (int) maxprint, data);
+               printf ("    %-6lx\t%.*s\n",
+                       (unsigned long) offset, (int) maxprint, data);
 
              data += strnlen ((char *) data, maxprint) + 1;
              if (data >= end)
@@ -4109,7 +4269,7 @@ display_debug_macro (struct dwarf_section *section,
        }
 
       printf ("\n");
-    }  
+    }
 
   return 1;
 }
@@ -4164,24 +4324,36 @@ display_debug_abbrev (struct dwarf_section *section,
 
 static void
 display_loc_list (struct dwarf_section *section,
-                  unsigned char **start_ptr,
-                  int debug_info_entry,
-                  unsigned long offset,
-                  unsigned long base_address,
-                  int has_frame_base)
+                 unsigned char **start_ptr,
+                 unsigned int debug_info_entry,
+                 unsigned long offset,
+                 unsigned long base_address,
+                 int has_frame_base)
 {
   unsigned char *start = *start_ptr;
   unsigned char *section_end = section->start + section->size;
-  unsigned long cu_offset = debug_information [debug_info_entry].cu_offset;
-  unsigned int pointer_size = debug_information [debug_info_entry].pointer_size;
-  unsigned int offset_size = debug_information [debug_info_entry].offset_size;
-  int dwarf_version = debug_information [debug_info_entry].dwarf_version;
+  unsigned long cu_offset;
+  unsigned int pointer_size;
+  unsigned int offset_size;
+  int dwarf_version;
 
   dwarf_vma begin;
   dwarf_vma end;
   unsigned short length;
   int need_frame_base;
 
+  if (debug_info_entry >= num_debug_info_entries)
+    {
+      warn (_("No debug information available for loc lists of entry: %u\n"),
+           debug_info_entry);
+      return;
+    }
+
+  cu_offset = debug_information [debug_info_entry].cu_offset;
+  pointer_size = debug_information [debug_info_entry].pointer_size;
+  offset_size = debug_information [debug_info_entry].offset_size;
+  dwarf_version = debug_information [debug_info_entry].dwarf_version;
+
   if (pointer_size < 2 || pointer_size > 8)
     {
       warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
@@ -4192,72 +4364,72 @@ display_loc_list (struct dwarf_section *section,
   while (1)
     {
       if (start + 2 * pointer_size > section_end)
-        {
-          warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
-                offset);
-          break;
-        }
+       {
+         warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
+               offset);
+         break;
+       }
 
       printf ("    %8.8lx ", offset + (start - *start_ptr));
 
       /* Note: we use sign extension here in order to be sure that we can detect
-         the -1 escape value.  Sign extension into the top 32 bits of a 32-bit
-         address will not affect the values that we display since we always show
-         hex values, and always the bottom 32-bits.  */
+        the -1 escape value.  Sign extension into the top 32 bits of a 32-bit
+        address will not affect the values that we display since we always show
+        hex values, and always the bottom 32-bits.  */
       SAFE_BYTE_GET_AND_INC (begin, start, pointer_size, section_end);
       SAFE_BYTE_GET_AND_INC (end, start, pointer_size, section_end);
 
       if (begin == 0 && end == 0)
-        {
-          printf (_("<End of list>\n"));
-          break;
-        }
+       {
+         printf (_("<End of list>\n"));
+         break;
+       }
 
       /* Check base address specifiers.  */
       if (begin == (dwarf_vma) -1 && end != (dwarf_vma) -1)
-        {
-          base_address = end;
-          print_dwarf_vma (begin, pointer_size);
-          print_dwarf_vma (end, pointer_size);
-          printf (_("(base address)\n"));
-          continue;
-        }
+       {
+         base_address = end;
+         print_dwarf_vma (begin, pointer_size);
+         print_dwarf_vma (end, pointer_size);
+         printf (_("(base address)\n"));
+         continue;
+       }
 
       if (start + 2 > section_end)
-        {
-          warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
-                offset);
-          break;
-        }
+       {
+         warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
+               offset);
+         break;
+       }
 
       SAFE_BYTE_GET_AND_INC (length, start, 2, section_end);
 
       if (start + length > section_end)
-        {
-          warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
-                offset);
-          break;
-        }
+       {
+         warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
+               offset);
+         break;
+       }
 
       print_dwarf_vma (begin + base_address, pointer_size);
       print_dwarf_vma (end + base_address, pointer_size);
 
       putchar ('(');
       need_frame_base = decode_location_expression (start,
-                                                    pointer_size,
-                                                    offset_size,
-                                                    dwarf_version,
-                                                    length,
-                                                    cu_offset, section);
+                                                   pointer_size,
+                                                   offset_size,
+                                                   dwarf_version,
+                                                   length,
+                                                   cu_offset, section);
       putchar (')');
 
       if (need_frame_base && !has_frame_base)
-        printf (_(" [without DW_AT_frame_base]"));
+       printf (_(" [without DW_AT_frame_base]"));
 
       if (begin == end)
-        fputs (_(" (start == end)"), stdout);
+       fputs (_(" (start == end)"), stdout);
       else if (begin > end)
-        fputs (_(" (start > end)"), stdout);
+       fputs (_(" (start > end)"), stdout);
 
       putchar ('\n');
 
@@ -4284,23 +4456,35 @@ print_addr_index (unsigned int idx, unsigned int len)
 
 static void
 display_loc_list_dwo (struct dwarf_section *section,
-                      unsigned char **start_ptr,
-                      int debug_info_entry,
-                      unsigned long offset,
-                      int has_frame_base)
+                     unsigned char **start_ptr,
+                     unsigned int debug_info_entry,
+                     unsigned long offset,
+                     int has_frame_base)
 {
   unsigned char *start = *start_ptr;
   unsigned char *section_end = section->start + section->size;
-  unsigned long cu_offset = debug_information [debug_info_entry].cu_offset;
-  unsigned int pointer_size = debug_information [debug_info_entry].pointer_size;
-  unsigned int offset_size = debug_information [debug_info_entry].offset_size;
-  int dwarf_version = debug_information [debug_info_entry].dwarf_version;
+  unsigned long cu_offset;
+  unsigned int pointer_size;
+  unsigned int offset_size;
+  int dwarf_version;
   int entry_type;
   unsigned short length;
   int need_frame_base;
   unsigned int idx;
   unsigned int bytes_read;
 
+  if (debug_info_entry >= num_debug_info_entries)
+    {
+      warn (_("No debug information for loc lists of entry: %u\n"),
+           debug_info_entry);
+      return;
+    }
+
+  cu_offset = debug_information [debug_info_entry].cu_offset;
+  pointer_size = debug_information [debug_info_entry].pointer_size;
+  offset_size = debug_information [debug_info_entry].offset_size;
+  dwarf_version = debug_information [debug_info_entry].dwarf_version;
+
   if (pointer_size < 2 || pointer_size > 8)
     {
       warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
@@ -4313,79 +4497,79 @@ display_loc_list_dwo (struct dwarf_section *section,
       printf ("    %8.8lx ", offset + (start - *start_ptr));
 
       if (start >= section_end)
-        {
-          warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
-                offset);
-          break;
-        }
+       {
+         warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
+               offset);
+         break;
+       }
 
       SAFE_BYTE_GET_AND_INC (entry_type, start, 1, section_end);
       switch (entry_type)
-        {
-          case 0: /* A terminating entry.  */
-            *start_ptr = start;
-           printf (_("<End of list>\n"));
-            return;
-          case 1: /* A base-address entry.  */
-            idx = read_uleb128 (start, &bytes_read, section_end);
-            start += bytes_read;
-            print_addr_index (idx, 8);
-            printf ("         ");
-            printf (_("(base address selection entry)\n"));
-            continue;
-          case 2: /* A start/end entry.  */
-            idx = read_uleb128 (start, &bytes_read, section_end);
-            start += bytes_read;
-            print_addr_index (idx, 8);
-            idx = read_uleb128 (start, &bytes_read, section_end);
-            start += bytes_read;
-            print_addr_index (idx, 8);
-            break;
-          case 3: /* A start/length entry.  */
-            idx = read_uleb128 (start, &bytes_read, section_end);
-            start += bytes_read;
-            print_addr_index (idx, 8);
-           SAFE_BYTE_GET_AND_INC (idx, start, 4, section_end);
-            printf ("%08x ", idx);
-            break;
-          case 4: /* An offset pair entry.  */
-           SAFE_BYTE_GET_AND_INC (idx, start, 4, section_end);
-            printf ("%08x ", idx);
-           SAFE_BYTE_GET_AND_INC (idx, start, 4, section_end);
-            printf ("%08x ", idx);
-            break;
-          default:
-            warn (_("Unknown location list entry type 0x%x.\n"), entry_type);
-            *start_ptr = start;
-            return;
-        }
+       {
+       case 0: /* A terminating entry.  */
+         *start_ptr = start;
+         printf (_("<End of list>\n"));
+         return;
+       case 1: /* A base-address entry.  */
+         idx = read_uleb128 (start, &bytes_read, section_end);
+         start += bytes_read;
+         print_addr_index (idx, 8);
+         printf ("         ");
+         printf (_("(base address selection entry)\n"));
+         continue;
+       case 2: /* A start/end entry.  */
+         idx = read_uleb128 (start, &bytes_read, section_end);
+         start += bytes_read;
+         print_addr_index (idx, 8);
+         idx = read_uleb128 (start, &bytes_read, section_end);
+         start += bytes_read;
+         print_addr_index (idx, 8);
+         break;
+       case 3: /* A start/length entry.  */
+         idx = read_uleb128 (start, &bytes_read, section_end);
+         start += bytes_read;
+         print_addr_index (idx, 8);
+         SAFE_BYTE_GET_AND_INC (idx, start, 4, section_end);
+         printf ("%08x ", idx);
+         break;
+       case 4: /* An offset pair entry.  */
+         SAFE_BYTE_GET_AND_INC (idx, start, 4, section_end);
+         printf ("%08x ", idx);
+         SAFE_BYTE_GET_AND_INC (idx, start, 4, section_end);
+         printf ("%08x ", idx);
+         break;
+       default:
+         warn (_("Unknown location list entry type 0x%x.\n"), entry_type);
+         *start_ptr = start;
+         return;
+       }
 
       if (start + 2 > section_end)
-        {
-          warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
-                offset);
-          break;
-        }
+       {
+         warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
+               offset);
+         break;
+       }
 
       SAFE_BYTE_GET_AND_INC (length, start, 2, section_end);
       if (start + length > section_end)
-        {
-          warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
-                offset);
-          break;
-        }
+       {
+         warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
+               offset);
+         break;
+       }
 
       putchar ('(');
       need_frame_base = decode_location_expression (start,
-                                                    pointer_size,
-                                                    offset_size,
-                                                    dwarf_version,
-                                                    length,
-                                                    cu_offset, section);
+                                                   pointer_size,
+                                                   offset_size,
+                                                   dwarf_version,
+                                                   length,
+                                                   cu_offset, section);
       putchar (')');
 
       if (need_frame_base && !has_frame_base)
-        printf (_(" [without DW_AT_frame_base]"));
+       printf (_(" [without DW_AT_frame_base]"));
 
       putchar ('\n');
 
@@ -4533,11 +4717,11 @@ display_debug_loc (struct dwarf_section *section, void *file)
              if (start < next)
                warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
                      (unsigned long) (start - section_begin),
-                     (unsigned long) (next - section_begin));
+                     (unsigned long) offset);
              else if (start > next)
                warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
                      (unsigned long) (start - section_begin),
-                     (unsigned long) (next - section_begin));
+                     (unsigned long) offset);
            }
          start = next;
 
@@ -4548,11 +4732,11 @@ display_debug_loc (struct dwarf_section *section, void *file)
              continue;
            }
 
-          if (is_dwo)
-            display_loc_list_dwo (section, &start, i, offset, has_frame_base);
-          else
-            display_loc_list (section, &start, i, offset, base_address,
-                              has_frame_base);
+         if (is_dwo)
+           display_loc_list_dwo (section, &start, i, offset, has_frame_base);
+         else
+           display_loc_list (section, &start, i, offset, base_address,
+                             has_frame_base);
        }
     }
 
@@ -4737,7 +4921,13 @@ display_debug_aranges (struct dwarf_section *section,
       if (excess)
        addr_ranges += (2 * address_size) - excess;
 
-      start += arange.ar_length + initial_length_size;
+      hdrptr = start + arange.ar_length + initial_length_size;
+      if (hdrptr < start || hdrptr > end)
+       {
+         error (_("Excessive header length: %lx\n"), (long) arange.ar_length);
+         break;
+       }
+      start = hdrptr;
 
       while (addr_ranges + 2 * address_size <= start)
        {
@@ -4768,7 +4958,7 @@ comp_addr_base (const void * v0, const void * v1)
 /* Display the debug_addr section.  */
 static int
 display_debug_addr (struct dwarf_section *section,
-                    void *file)
+                   void *file)
 {
   debug_info **debug_addr_info;
   unsigned char *entry;
@@ -4791,42 +4981,51 @@ display_debug_addr (struct dwarf_section *section,
 
   printf (_("Contents of the %s section:\n\n"), section->name);
 
-  debug_addr_info = (debug_info **) xmalloc ((num_debug_info_entries + 1)
-                                             * sizeof (debug_info *));
+  /* PR  17531: file: cf38d01b.
+     We use xcalloc because a corrupt file may not have initialised all of the
+     fields in the debug_info structure, which means that the sort below might
+     try to move uninitialised data.  */
+  debug_addr_info = (debug_info **) xcalloc ((num_debug_info_entries + 1),
+                                            sizeof (debug_info *));
 
   count = 0;
   for (i = 0; i < num_debug_info_entries; i++)
-    {
-      if (debug_information [i].addr_base != DEBUG_INFO_UNAVAILABLE)
-        debug_addr_info [count++] = &debug_information [i];
-    }
+    if (debug_information [i].addr_base != DEBUG_INFO_UNAVAILABLE)
+      {
+       /* PR 17531: file: cf38d01b.  */
+       if (debug_information[i].addr_base >= section->size)
+         warn (_("Corrupt address base (%lx) found in debug section %u\n"),
+               (unsigned long) debug_information[i].addr_base, i);
+       else
+         debug_addr_info [count++] = debug_information + i;
+      }
 
   /* Add a sentinel to make iteration convenient.  */
   debug_addr_info [count] = (debug_info *) xmalloc (sizeof (debug_info));
   debug_addr_info [count]->addr_base = section->size;
-
   qsort (debug_addr_info, count, sizeof (debug_info *), comp_addr_base);
+
   for (i = 0; i < count; i++)
     {
       unsigned int idx;
       unsigned int address_size = debug_addr_info [i]->pointer_size;
 
       printf (_("  For compilation unit at offset 0x%s:\n"),
-              dwarf_vmatoa ("x", debug_addr_info [i]->cu_offset));
+             dwarf_vmatoa ("x", debug_addr_info [i]->cu_offset));
 
       printf (_("\tIndex\tAddress\n"));
       entry = section->start + debug_addr_info [i]->addr_base;
       end = section->start + debug_addr_info [i + 1]->addr_base;
       idx = 0;
       while (entry < end)
-        {
-          dwarf_vma base = byte_get (entry, address_size);
-          printf (_("\t%d:\t"), idx);
-          print_dwarf_vma (base, address_size);
-          printf ("\n");
-          entry += address_size;
-          idx++;
-        }
+       {
+         dwarf_vma base = byte_get (entry, address_size);
+         printf (_("\t%d:\t"), idx);
+         print_dwarf_vma (base, address_size);
+         printf ("\n");
+         entry += address_size;
+         idx++;
+       }
     }
   printf ("\n");
 
@@ -4837,7 +5036,7 @@ display_debug_addr (struct dwarf_section *section,
 /* Display the .debug_str_offsets and .debug_str_offsets.dwo sections.  */
 static int
 display_debug_str_offsets (struct dwarf_section *section,
-                           void *file ATTRIBUTE_UNUSED)
+                          void *file ATTRIBUTE_UNUSED)
 {
   if (section->size == 0)
     {
@@ -4906,7 +5105,7 @@ display_debug_ranges (struct dwarf_section *section,
   if (num_range_list == 0)
     {
       /* This can happen when the file was compiled with -gsplit-debug
-         which removes references to range lists from the primary .o file.  */
+        which removes references to range lists from the primary .o file.  */
       printf (_("No range lists in .debug_info section.\n"));
       return 1;
     }
@@ -4959,7 +5158,7 @@ display_debug_ranges (struct dwarf_section *section,
                pointer_size, offset);
          continue;
        }
-      
+
       if (dwarf_check != 0 && i > 0)
        {
          if (start < next)
@@ -5033,7 +5232,7 @@ typedef struct Frame_Chunk
 {
   struct Frame_Chunk *next;
   unsigned char *chunk_start;
-  int ncols;
+  unsigned int ncols;
   /* DW_CFA_{undefined,same_value,offset,register,unreferenced}  */
   short int *col_type;
   int *col_offset;
@@ -5043,8 +5242,8 @@ typedef struct Frame_Chunk
   dwarf_vma pc_begin;
   dwarf_vma pc_range;
   int cfa_reg;
-  int cfa_offset;
-  int ra;
+  dwarf_vma cfa_offset;
+  unsigned int ra;
   unsigned char fde_encoding;
   unsigned char cfa_exp;
   unsigned char ptr_size;
@@ -5059,13 +5258,13 @@ static unsigned int dwarf_regnames_count;
    in the frame info.  */
 #define DW_CFA_unreferenced (-1)
 
-/* Return 0 if not more space is needed, 1 if more space is needed,
+/* Return 0 if no more space is needed, 1 if more space is needed,
    -1 for invalid reg.  */
 
 static int
 frame_need_space (Frame_Chunk *fc, unsigned int reg)
 {
-  int prev = fc->ncols;
+  unsigned int prev = fc->ncols;
 
   if (reg < (unsigned int) fc->ncols)
     return 0;
@@ -5075,10 +5274,25 @@ frame_need_space (Frame_Chunk *fc, unsigned int reg)
     return -1;
 
   fc->ncols = reg + 1;
+  /* PR 17512: file: 10450-2643-0.004.
+     If reg == -1 then this can happen...  */
+  if (fc->ncols == 0)
+    return -1;
+
+  /* PR 17512: file: 2844a11d.  */
+  if (fc->ncols > 1024)
+    {
+      error (_("Unfeasibly large register number: %u\n"), reg);
+      fc->ncols = 0;
+      /* FIXME: 1024 is an arbitrary limit.  Increase it if
+        we ever encounter a valid binary that exceeds it.  */
+      return -1;
+    }
+
   fc->col_type = (short int *) xcrealloc (fc->col_type, fc->ncols,
-                                          sizeof (short int));
+                                         sizeof (short int));
   fc->col_offset = (int *) xcrealloc (fc->col_offset, fc->ncols, sizeof (int));
-  /* PR 17512: file:002-10025-0.005.  */ 
+  /* PR 17512: file:002-10025-0.005.  */
   if (fc->col_type == NULL || fc->col_offset == NULL)
     {
       error (_("Out of memory allocating %u columns in dwarf frame arrays\n"),
@@ -5168,16 +5382,16 @@ init_dwarf_regnames_x86_64 (void)
 
 static const char *const dwarf_regnames_aarch64[] =
 {
-   "x0",  "x1",  "x2",  "x3",  "x4",  "x5",  "x6",  "x7", 
-   "x8",  "x9", "x10", "x11", "x12", "x13", "x14", "x15", 
+   "x0",  "x1",  "x2",  "x3",  "x4",  "x5",  "x6",  "x7",
+   "x8",  "x9", "x10", "x11", "x12", "x13", "x14", "x15",
   "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23",
   "x24", "x25", "x26", "x27", "x28", "x29", "x30", "sp",
    NULL, "elr",  NULL,  NULL,  NULL,  NULL,  NULL,  NULL,
    NULL,  NULL,  NULL,  NULL,  NULL,  NULL,  NULL,  NULL,
    NULL,  NULL,  NULL,  NULL,  NULL,  NULL,  NULL,  NULL,
    NULL,  NULL,  NULL,  NULL,  NULL,  NULL,  NULL,  NULL,
-   "v0",  "v1",  "v2",  "v3",  "v4",  "v5",  "v6",  "v7", 
-   "v8",  "v9", "v10", "v11", "v12", "v13", "v14", "v15", 
+   "v0",  "v1",  "v2",  "v3",  "v4",  "v5",  "v6",  "v7",
+   "v8",  "v9", "v10", "v11", "v12", "v13", "v14", "v15",
   "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
   "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
 };
@@ -5233,9 +5447,9 @@ regname (unsigned int regno, int row)
 }
 
 static void
-frame_display_row (Frame_Chunk *fc, int *need_col_headers, int *max_regs)
+frame_display_row (Frame_Chunk *fc, int *need_col_headers, unsigned int *max_regs)
 {
-  int r;
+  unsigned int r;
   char tmp[100];
 
   if (*max_regs < fc->ncols)
@@ -5265,7 +5479,7 @@ frame_display_row (Frame_Chunk *fc, int *need_col_headers, int *max_regs)
   if (fc->cfa_exp)
     strcpy (tmp, "exp");
   else
-    sprintf (tmp, "%s%+d", regname (fc->cfa_reg, 1), fc->cfa_offset);
+    sprintf (tmp, "%s%+d", regname (fc->cfa_reg, 1), (int) fc->cfa_offset);
   printf ("%-8s ", tmp);
 
   for (r = 0; r < fc->ncols; r++)
@@ -5351,7 +5565,20 @@ read_cie (unsigned char *start, unsigned char *end,
   if (version >= 4)
     {
       GET (fc->ptr_size, 1);
+      if (fc->ptr_size < 1 || fc->ptr_size > 8)
+       {
+         warn (_("Invalid pointer size (%d) in CIE data\n"), fc->ptr_size);
+         return end;
+       }
+
       GET (fc->segment_size, 1);
+      /* PR 17512: file: e99d2804.  */
+      if (fc->segment_size > 8 || fc->segment_size + fc->ptr_size > 8)
+       {
+         warn (_("Invalid segment size (%d) in CIE data\n"), fc->segment_size);
+         return end;
+       }
+
       eh_addr_size = fc->ptr_size;
     }
   else
@@ -5375,15 +5602,32 @@ read_cie (unsigned char *start, unsigned char *end,
       augmentation_data_len = LEB ();
       augmentation_data = start;
       start += augmentation_data_len;
+      /* PR 17512: file: 11042-2589-0.004.  */
+      if (start > end)
+       {
+         warn (_("Augmentation data too long: 0x%lx\n"), augmentation_data_len);
+         return end;
+       }
     }
 
   if (augmentation_data_len)
     {
-      unsigned char *p, *q;
+      unsigned char *p;
+      unsigned char *q;
+      unsigned char *qend;
+
       p = (unsigned char *) fc->augmentation + 1;
       q = augmentation_data;
+      qend = q + augmentation_data_len;
 
-      while (1)
+      /* PR 17531: file: 015adfaa.  */
+      if (qend < q)
+       {
+         warn (_("Negative augmentation data length: 0x%lx"), augmentation_data_len);
+         augmentation_data_len = 0;
+       }
+
+      while (p < end && q < augmentation_data + augmentation_data_len)
        {
          if (*p == 'L')
            q++;
@@ -5397,6 +5641,8 @@ read_cie (unsigned char *start, unsigned char *end,
            break;
          p++;
        }
+      /* Note - it is OK if this loop terminates with q < qend.
+        Padding may have been inserted to align the end of the CIE.  */
     }
 
   *p_cie = fc;
@@ -5422,9 +5668,9 @@ display_debug_frames (struct dwarf_section *section,
   Frame_Chunk *rs;
   int is_eh = strcmp (section->name, ".eh_frame") == 0;
   unsigned int length_return;
-  int max_regs = 0;
+  unsigned int max_regs = 0;
   const char *bad_reg = _("bad register: ");
-  int saved_eh_addr_size = eh_addr_size;
+  unsigned int saved_eh_addr_size = eh_addr_size;
 
   printf (_("Contents of the %s section:\n"), section->name);
 
@@ -5451,6 +5697,12 @@ display_debug_frames (struct dwarf_section *section,
        {
          printf ("\n%08lx ZERO terminator\n\n",
                    (unsigned long)(saved_start - section_start));
+         /* Skip any zero terminators that directly follow.
+            A corrupt section size could have loaded a whole
+            slew of zero filled memory bytes.  eg
+            PR 17512: file: 070-19381-0.004.  */
+         while (start < end && * start == 0)
+           ++ start;
          continue;
        }
 
@@ -5481,21 +5733,23 @@ display_debug_frames (struct dwarf_section *section,
                                   || (offset_size == 8 && cie_id == DW64_CIE_ID)))
        {
          int version;
-         int mreg;
+         unsigned int mreg;
 
          start = read_cie (start, end, &cie, &version,
                            &augmentation_data_len, &augmentation_data);
          /* PR 17512: file: 027-135133-0.005.  */
          if (cie == NULL)
            break;
+
          fc = cie;
          fc->next = chunks;
          chunks = fc;
          fc->chunk_start = saved_start;
-         mreg = max_regs - 1;
+         mreg = max_regs > 0 ? max_regs - 1 : 0;
          if (mreg < fc->ra)
            mreg = fc->ra;
-         frame_need_space (fc, mreg);
+         if (frame_need_space (fc, mreg) < 0)
+           break;
          if (fc->fde_encoding)
            encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
 
@@ -5525,8 +5779,11 @@ display_debug_frames (struct dwarf_section *section,
              if (augmentation_data_len)
                {
                  unsigned long i;
+
                  printf ("  Augmentation data:    ");
                  for (i = 0; i < augmentation_data_len; ++i)
+                   /* FIXME: If do_wide is FALSE, then we should
+                      add carriage returns at 80 columns...  */
                    printf (" %02x", augmentation_data[i]);
                  putchar ('\n');
                }
@@ -5582,17 +5839,27 @@ display_debug_frames (struct dwarf_section *section,
                             || (off_size == 8 && c_id == DW64_CIE_ID)))
                        {
                          int version;
-                         int mreg;
+                         unsigned int mreg;
 
                          read_cie (cie_scan, end, &cie, &version,
                                    &augmentation_data_len, &augmentation_data);
+                         /* PR 17512: file: 3450-2098-0.004.  */
+                         if (cie == NULL)
+                           {
+                             warn (_("Failed to read CIE information\n"));
+                             break;
+                           }
                          cie->next = forward_refs;
                          forward_refs = cie;
                          cie->chunk_start = look_for;
-                         mreg = max_regs - 1;
+                         mreg = max_regs > 0 ? max_regs - 1 : 0;
                          if (mreg < cie->ra)
                            mreg = cie->ra;
-                         frame_need_space (cie, mreg);
+                         if (frame_need_space (cie, mreg) < 0)
+                           {
+                             warn (_("Invalid max register\n"));
+                             break;
+                           }
                          if (cie->fde_encoding)
                            encoded_ptr_size
                              = size_of_encoded_value (cie->fde_encoding);
@@ -5612,7 +5879,11 @@ display_debug_frames (struct dwarf_section *section,
              fc->ncols = 0;
              fc->col_type = (short int *) xmalloc (sizeof (short int));
              fc->col_offset = (int *) xmalloc (sizeof (int));
-             frame_need_space (fc, max_regs - 1);
+             if (frame_need_space (fc, max_regs > 0 ? max_regs - 1 : 0) < 0)
+               {
+                 warn (_("Invalid max register\n"));
+                 break;
+               }
              cie = fc;
              fc->augmentation = "";
              fc->fde_encoding = 0;
@@ -5635,7 +5906,11 @@ display_debug_frames (struct dwarf_section *section,
              fc->cfa_reg = cie->cfa_reg;
              fc->cfa_offset = cie->cfa_offset;
              fc->ra = cie->ra;
-             frame_need_space (fc, max_regs - 1);
+             if (frame_need_space (fc, max_regs > 0 ? max_regs - 1: 0) < 0)
+               {
+                 warn (_("Invalid max register\n"));
+                 break;
+               }
              fc->fde_encoding = cie->fde_encoding;
            }
 
@@ -5644,7 +5919,15 @@ display_debug_frames (struct dwarf_section *section,
 
          segment_selector = 0;
          if (fc->segment_size)
-           SAFE_BYTE_GET_AND_INC (segment_selector, start, fc->segment_size, end);
+           {
+             if (fc->segment_size > sizeof (segment_selector))
+               {
+                 /* PR 17512: file: 9e196b3e.  */
+                 warn (_("Probably corrupt segment size: %d - using 4 instead\n"), fc->segment_size);
+                 fc->segment_size = 4;
+               }
+             SAFE_BYTE_GET_AND_INC (segment_selector, start, fc->segment_size, end);
+           }
 
          fc->pc_begin = get_encoded_value (&start, fc->fde_encoding, section, end);
 
@@ -5659,6 +5942,15 @@ display_debug_frames (struct dwarf_section *section,
              augmentation_data_len = LEB ();
              augmentation_data = start;
              start += augmentation_data_len;
+             /* PR 17512: file: 722-8446-0.004.  */
+             if (start >= end || ((signed long) augmentation_data_len) < 0)
+               {
+                 warn (_("Corrupt augmentation data length: %lx\n"),
+                       augmentation_data_len);
+                 start = end;
+                 augmentation_data = NULL;
+                 augmentation_data_len = 0;
+               }
            }
 
          printf ("\n%08lx %s %s FDE cie=%08lx pc=",
@@ -5703,6 +5995,7 @@ display_debug_frames (struct dwarf_section *section,
            {
              unsigned int reg, op, opa;
              unsigned long temp;
+             unsigned char * new_start;
 
              op = *start++;
              opa = op & 0x3f;
@@ -5744,7 +6037,6 @@ display_debug_frames (struct dwarf_section *section,
                  break;
                case DW_CFA_restore_extended:
                  reg = LEB ();
-                 frame_need_space (fc, reg);
                  if (frame_need_space (fc, reg) >= 0)
                    fc->col_type[reg] = DW_CFA_undefined;
                  break;
@@ -5774,26 +6066,28 @@ display_debug_frames (struct dwarf_section *section,
                  break;
                case DW_CFA_def_cfa_expression:
                  temp = LEB ();
-                 if (start + temp < start)
+                 new_start = start + temp;
+                 if (new_start < start)
                    {
                      warn (_("Corrupt CFA_def expression value: %lu\n"), temp);
                      start = block_end;
                    }
                  else
-                   start += temp;
+                   start = new_start;
                  break;
                case DW_CFA_expression:
                case DW_CFA_val_expression:
                  reg = LEB ();
                  temp = LEB ();
-                 if (start + temp < start)
+                 new_start = start + temp;
+                 if (new_start < start)
                    {
-                     /* PR 17512: file:306-192417-0.005.  */ 
+                     /* PR 17512: file:306-192417-0.005.  */
                      warn (_("Corrupt CFA expression value: %lu\n"), temp);
                      start = block_end;
                    }
                  else
-                   start += temp;
+                   start = new_start;
                  if (frame_need_space (fc, reg) >= 0)
                    fc->col_type[reg] = DW_CFA_undefined;
                  break;
@@ -5832,9 +6126,10 @@ display_debug_frames (struct dwarf_section *section,
 
       while (start < block_end)
        {
+         unsigned char * tmp;
          unsigned op, opa;
          unsigned long ul, reg, roffs;
-         long l;
+         dwarf_vma l;
          dwarf_vma ofs;
          dwarf_vma vma;
          const char *reg_prefix = "";
@@ -5854,7 +6149,7 @@ display_debug_frames (struct dwarf_section *section,
              else
                printf ("  DW_CFA_advance_loc: %d to %s\n",
                        opa * fc->code_factor,
-                       dwarf_vmatoa_1 (NULL, 
+                       dwarf_vmatoa_1 (NULL,
                                        fc->pc_begin + opa * fc->code_factor,
                                        fc->ptr_size));
              fc->pc_begin += opa * fc->code_factor;
@@ -5893,7 +6188,7 @@ display_debug_frames (struct dwarf_section *section,
              break;
 
            case DW_CFA_set_loc:
-             vma = get_encoded_value (&start, fc->fde_encoding, section, end);
+             vma = get_encoded_value (&start, fc->fde_encoding, section, block_end);
              if (do_debug_frames_interp)
                frame_display_row (fc, &need_col_headers, &max_regs);
              else
@@ -5916,7 +6211,7 @@ display_debug_frames (struct dwarf_section *section,
              break;
 
            case DW_CFA_advance_loc2:
-             SAFE_BYTE_GET_AND_INC (ofs, start, 2, end);
+             SAFE_BYTE_GET_AND_INC (ofs, start, 2, block_end);
              if (do_debug_frames_interp)
                frame_display_row (fc, &need_col_headers, &max_regs);
              else
@@ -5929,7 +6224,7 @@ display_debug_frames (struct dwarf_section *section,
              break;
 
            case DW_CFA_advance_loc4:
-             SAFE_BYTE_GET_AND_INC (ofs, start, 4, end);
+             SAFE_BYTE_GET_AND_INC (ofs, start, 4, block_end);
              if (do_debug_frames_interp)
                frame_display_row (fc, &need_col_headers, &max_regs);
              else
@@ -6038,13 +6333,13 @@ display_debug_frames (struct dwarf_section *section,
              if (! do_debug_frames_interp)
                printf ("  DW_CFA_remember_state\n");
              rs = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
-              rs->cfa_offset = fc->cfa_offset;
+             rs->cfa_offset = fc->cfa_offset;
              rs->cfa_reg = fc->cfa_reg;
              rs->ra = fc->ra;
              rs->cfa_exp = fc->cfa_exp;
              rs->ncols = fc->ncols;
              rs->col_type = (short int *) xcmalloc (rs->ncols,
-                                                     sizeof (* rs->col_type));
+                                                    sizeof (* rs->col_type));
              rs->col_offset = (int *) xcmalloc (rs->ncols, sizeof (* rs->col_offset));
              memcpy (rs->col_type, fc->col_type, rs->ncols * sizeof (* fc->col_type));
              memcpy (rs->col_offset, fc->col_offset, rs->ncols * sizeof (* fc->col_offset));
@@ -6061,9 +6356,14 @@ display_debug_frames (struct dwarf_section *section,
                  remembered_state = rs->next;
                  fc->cfa_offset = rs->cfa_offset;
                  fc->cfa_reg = rs->cfa_reg;
-                 fc->ra = rs->ra;
-                 fc->cfa_exp = rs->cfa_exp;
-                 frame_need_space (fc, rs->ncols - 1);
+                 fc->ra = rs->ra;
+                 fc->cfa_exp = rs->cfa_exp;
+                 if (frame_need_space (fc, rs->ncols - 1) < 0)
+                   {
+                     warn (_("Invalid column number in saved frame state\n"));
+                     fc->ncols = 0;
+                     break;
+                   }
                  memcpy (fc->col_type, rs->col_type, rs->ncols * sizeof (* rs->col_type));
                  memcpy (fc->col_offset, rs->col_offset,
                          rs->ncols * sizeof (* rs->col_offset));
@@ -6081,7 +6381,7 @@ display_debug_frames (struct dwarf_section *section,
              fc->cfa_exp = 0;
              if (! do_debug_frames_interp)
                printf ("  DW_CFA_def_cfa: %s ofs %d\n",
-                       regname (fc->cfa_reg, 0), fc->cfa_offset);
+                       regname (fc->cfa_reg, 0), (int) fc->cfa_offset);
              break;
 
            case DW_CFA_def_cfa_register:
@@ -6095,7 +6395,7 @@ display_debug_frames (struct dwarf_section *section,
            case DW_CFA_def_cfa_offset:
              fc->cfa_offset = LEB ();
              if (! do_debug_frames_interp)
-               printf ("  DW_CFA_def_cfa_offset: %d\n", fc->cfa_offset);
+               printf ("  DW_CFA_def_cfa_offset: %d\n", (int) fc->cfa_offset);
              break;
 
            case DW_CFA_nop:
@@ -6105,6 +6405,11 @@ display_debug_frames (struct dwarf_section *section,
 
            case DW_CFA_def_cfa_expression:
              ul = LEB ();
+             if (start >= block_end || start + ul > block_end || start + ul < start)
+               {
+                 printf (_("  DW_CFA_def_cfa_expression: <corrupt len %lu>\n"), ul);
+                 break;
+               }
              if (! do_debug_frames_interp)
                {
                  printf ("  DW_CFA_def_cfa_expression (");
@@ -6121,6 +6426,14 @@ display_debug_frames (struct dwarf_section *section,
              ul = LEB ();
              if (reg >= (unsigned int) fc->ncols)
                reg_prefix = bad_reg;
+             /* PR 17512: file: 069-133014-0.006.  */
+             /* PR 17512: file: 98c02eb4.  */
+             tmp = start + ul;
+             if (start >= block_end || tmp > block_end || tmp < start)
+               {
+                 printf (_("  DW_CFA_expression: <corrupt len %lu>\n"), ul);
+                 break;
+               }
              if (! do_debug_frames_interp || *reg_prefix != '\0')
                {
                  printf ("  DW_CFA_expression: %s%s (",
@@ -6131,7 +6444,7 @@ display_debug_frames (struct dwarf_section *section,
                }
              if (*reg_prefix == '\0')
                fc->col_type[reg] = DW_CFA_expression;
-             start += ul;
+             start = tmp;
              break;
 
            case DW_CFA_val_expression:
@@ -6139,6 +6452,12 @@ display_debug_frames (struct dwarf_section *section,
              ul = LEB ();
              if (reg >= (unsigned int) fc->ncols)
                reg_prefix = bad_reg;
+             tmp = start + ul;
+             if (start >= block_end || tmp > block_end || tmp < start)
+               {
+                 printf ("  DW_CFA_val_expression: <corrupt len %lu>\n", ul);
+                 break;
+               }
              if (! do_debug_frames_interp || *reg_prefix != '\0')
                {
                  printf ("  DW_CFA_val_expression: %s%s (",
@@ -6149,7 +6468,7 @@ display_debug_frames (struct dwarf_section *section,
                }
              if (*reg_prefix == '\0')
                fc->col_type[reg] = DW_CFA_val_expression;
-             start += ul;
+             start = tmp;
              break;
 
            case DW_CFA_offset_extended_sf:
@@ -6160,7 +6479,7 @@ display_debug_frames (struct dwarf_section *section,
              if (! do_debug_frames_interp || *reg_prefix != '\0')
                printf ("  DW_CFA_offset_extended_sf: %s%s at cfa%+ld\n",
                        reg_prefix, regname (reg, 0),
-                       l * fc->data_factor);
+                       (long)(l * fc->data_factor));
              if (*reg_prefix == '\0')
                {
                  fc->col_type[reg] = DW_CFA_offset;
@@ -6176,7 +6495,7 @@ display_debug_frames (struct dwarf_section *section,
              if (! do_debug_frames_interp || *reg_prefix != '\0')
                printf ("  DW_CFA_val_offset_sf: %s%s at cfa%+ld\n",
                        reg_prefix, regname (reg, 0),
-                       l * fc->data_factor);
+                       (long)(l * fc->data_factor));
              if (*reg_prefix == '\0')
                {
                  fc->col_type[reg] = DW_CFA_val_offset;
@@ -6191,18 +6510,18 @@ display_debug_frames (struct dwarf_section *section,
              fc->cfa_exp = 0;
              if (! do_debug_frames_interp)
                printf ("  DW_CFA_def_cfa_sf: %s ofs %d\n",
-                       regname (fc->cfa_reg, 0), fc->cfa_offset);
+                       regname (fc->cfa_reg, 0), (int) fc->cfa_offset);
              break;
 
            case DW_CFA_def_cfa_offset_sf:
              fc->cfa_offset = SLEB ();
-             fc->cfa_offset = fc->cfa_offset * fc->data_factor;
+             fc->cfa_offset *= fc->data_factor;
              if (! do_debug_frames_interp)
-               printf ("  DW_CFA_def_cfa_offset_sf: %d\n", fc->cfa_offset);
+               printf ("  DW_CFA_def_cfa_offset_sf: %d\n", (int) fc->cfa_offset);
              break;
 
            case DW_CFA_MIPS_advance_loc8:
-             SAFE_BYTE_GET_AND_INC (ofs, start, 8, end);
+             SAFE_BYTE_GET_AND_INC (ofs, start, 8, block_end);
              if (do_debug_frames_interp)
                frame_display_row (fc, &need_col_headers, &max_regs);
              else
@@ -6233,7 +6552,7 @@ display_debug_frames (struct dwarf_section *section,
              if (! do_debug_frames_interp || *reg_prefix != '\0')
                printf ("  DW_CFA_GNU_negative_offset_extended: %s%s at cfa%+ld\n",
                        reg_prefix, regname (reg, 0),
-                       l * fc->data_factor);
+                       (long)(l * fc->data_factor));
              if (*reg_prefix == '\0')
                {
                  fc->col_type[reg] = DW_CFA_offset;
@@ -6329,9 +6648,42 @@ display_gdb_index (struct dwarf_section *section,
       return 0;
     }
 
+  /* PR 17531: file: 418d0a8a.  */
+  if (tu_list_offset < cu_list_offset)
+    {
+      warn (_("TU offset (%x) is less than CU offset (%x)\n"),
+           tu_list_offset, cu_list_offset);
+      return 0;
+    }
+
   cu_list_elements = (tu_list_offset - cu_list_offset) / 8;
+
+  if (address_table_offset < tu_list_offset)
+    {
+      warn (_("Address table offset (%x) is less than TU offset (%x)\n"),
+           address_table_offset, tu_list_offset);
+      return 0;
+    }
+
   tu_list_elements = (address_table_offset - tu_list_offset) / 8;
+
+  /* PR 17531: file: 18a47d3d.  */
+  if (symbol_table_offset < address_table_offset)
+    {
+      warn (_("Symbol table offset (%xl) is less then Address table offset (%x)\n"),
+           symbol_table_offset, address_table_offset);
+      return 0;
+    }
+
   address_table_size = symbol_table_offset - address_table_offset;
+
+  if (constant_pool_offset < symbol_table_offset)
+    {
+      warn (_("Constant pool offset (%x) is less than symbol table offset (%x)\n"),
+           constant_pool_offset, symbol_table_offset);
+      return 0;
+    }
+
   symbol_table_slots = (constant_pool_offset - symbol_table_offset) / 8;
 
   cu_list = start + cu_list_offset;
@@ -6340,6 +6692,12 @@ display_gdb_index (struct dwarf_section *section,
   symbol_table = start + symbol_table_offset;
   constant_pool = start + constant_pool_offset;
 
+  if (address_table + address_table_size * (2 + 8 + 4) > section->start + section->size)
+    {
+      warn (_("Address table extends beyond end of section.\n"));
+      return 0;
+    }
+
   printf (_("\nCU table:\n"));
   for (i = 0; i < cu_list_elements; i += 2)
     {
@@ -6366,7 +6724,8 @@ display_gdb_index (struct dwarf_section *section,
     }
 
   printf (_("\nAddress table:\n"));
-  for (i = 0; i < address_table_size; i += 2 * 8 + 4)
+  for (i = 0; i < address_table_size && i <= address_table_size - (2 * 8 + 4);
+       i += 2 * 8 + 4)
     {
       uint64_t low = byte_get_little_endian (address_table + i, 8);
       uint64_t high = byte_get_little_endian (address_table + i + 8, 8);
@@ -6388,11 +6747,46 @@ display_gdb_index (struct dwarf_section *section,
          || cu_vector_offset != 0)
        {
          unsigned int j;
+         unsigned char * adr;
+
+         adr = constant_pool + name_offset;
+         /* PR 17531: file: 5b7b07ad.  */
+         if (adr < constant_pool || adr >= section->start + section->size)
+           {
+             printf (_("[%3u] <corrupt offset: %x>"), i, name_offset);
+             warn (_("Corrupt name offset of 0x%x found for symbol table slot %d\n"),
+                   name_offset, i);
+           }
+         else
+           printf ("[%3u] %.*s:", i,
+                   (int) (section->size - (constant_pool_offset + name_offset)),
+                   constant_pool + name_offset);
+
+         adr = constant_pool + cu_vector_offset;
+         if (adr < constant_pool || adr >= section->start + section->size - 3)
+           {
+             printf (_("<invalid CU vector offset: %x>\n"), cu_vector_offset);
+             warn (_("Corrupt CU vector offset of 0x%x found for symbol table slot %d\n"),
+                   cu_vector_offset, i);
+             continue;
+           }
+
+         num_cus = byte_get_little_endian (adr, 4);
+
+         adr = constant_pool + cu_vector_offset + 4 + num_cus * 4;
+         if (num_cus * 4 < num_cus
+             || adr >= section->start + section->size
+             || adr < constant_pool)
+           {
+             printf ("<invalid number of CUs: %d>\n", num_cus);
+             warn (_("Invalid number of CUs (0x%x) for symbol table slot %d\n"),
+                   num_cus, i);
+             continue;
+           }
 
-         printf ("[%3u] %s:", i, constant_pool + name_offset);
-         num_cus = byte_get_little_endian (constant_pool + cu_vector_offset, 4);
          if (num_cus > 1)
            printf ("\n");
+
          for (j = 0; j < num_cus; ++j)
            {
              int is_static;
@@ -6491,7 +6885,7 @@ get_DW_SECT_short_name (unsigned int dw_sect)
       case DW_SECT_MACRO:
        return "macro";
       default:
-        break;
+       break;
     }
 
   snprintf (buf, sizeof (buf), "%d", dw_sect);
@@ -6520,15 +6914,38 @@ process_cu_tu_index (struct dwarf_section *section, int do_display)
   dwarf_vma signature_low;
   char buf[64];
 
-  version = byte_get (phdr, 4);
+  /* PR 17512: file: 002-168123-0.004.  */
+  if (phdr == NULL)
+    {
+      warn (_("Section %s is empty\n"), section->name);
+      return 0;
+    }
+  /* PR 17512: file: 002-376-0.004.  */
+  if (section->size < 24)
+    {
+      warn (_("Section %s is too small to contain a CU/TU header\n"),
+           section->name);
+      return 0;
+    }
+
+  SAFE_BYTE_GET (version, phdr, 4, limit);
   if (version >= 2)
-    ncols = byte_get (phdr + 4, 4);
-  nused = byte_get (phdr + 8, 4);
-  nslots = byte_get (phdr + 12, 4);
+    SAFE_BYTE_GET (ncols, phdr + 4, 4, limit);
+  SAFE_BYTE_GET (nused, phdr + 8, 4, limit);
+  SAFE_BYTE_GET (nslots, phdr + 12, 4, limit);
+
   phash = phdr + 16;
   pindex = phash + nslots * 8;
   ppool = pindex + nslots * 4;
 
+  /* PR 17531: file: 45d69832.  */
+  if (pindex < phash || ppool < phdr || (pindex == phash && nslots != 0))
+    {
+      warn (_("Section %s is too small for %d slots\n"),
+           section->name, nslots);
+      return 0;
+    }
+
   if (do_display)
     {
       printf (_("Contents of the %s section:\n\n"), section->name);
@@ -6539,7 +6956,7 @@ process_cu_tu_index (struct dwarf_section *section, int do_display)
       printf (_("  Number of slots:         %d\n\n"), nslots);
     }
 
-  if (ppool > limit)
+  if (ppool > limit || ppool < phdr)
     {
       warn (_("Section %s too small for %d hash table entries\n"),
            section->name, nslots);
@@ -6555,11 +6972,18 @@ process_cu_tu_index (struct dwarf_section *section, int do_display)
          unsigned char *shndx_list;
          unsigned int shndx;
 
-         byte_get_64 (phash, &signature_high, &signature_low);
+         SAFE_BYTE_GET64 (phash, &signature_high, &signature_low, limit);
          if (signature_high != 0 || signature_low != 0)
            {
-             j = byte_get (pindex, 4);
+             SAFE_BYTE_GET (j, pindex, 4, limit);
              shndx_list = ppool + j * 4;
+             /* PR 17531: file: 705e010d.  */
+             if (shndx_list < ppool)
+               {
+                 warn (_("Section index pool located before start of section\n"));
+                 return 0;
+               }
+
              if (do_display)
                printf (_("  [%3d] Signature:  0x%s  Sections: "),
                        i, dwarf_vmatoa64 (signature_high, signature_low,
@@ -6572,7 +6996,7 @@ process_cu_tu_index (struct dwarf_section *section, int do_display)
                            section->name);
                      return 0;
                    }
-                 shndx = byte_get (shndx_list, 4);
+                 SAFE_BYTE_GET (shndx, shndx_list, 4, limit);
                  if (shndx == 0)
                    break;
                  if (do_display)
@@ -6606,6 +7030,14 @@ process_cu_tu_index (struct dwarf_section *section, int do_display)
 
       is_tu_index = strcmp (section->name, ".debug_tu_index") == 0;
 
+      /* PR 17531: file: 0dd159bf.
+        Check for wraparound with an overlarge ncols value.  */
+      if (poffsets < ppool || (unsigned int) ((poffsets - ppool) / 4) != ncols)
+       {
+         warn (_("Overlarge number of columns: %x\n"), ncols);
+         return 0;
+       }
+
       if (pend > limit)
        {
          warn (_("Section %s too small for offset and size tables\n"),
@@ -6624,49 +7056,75 @@ process_cu_tu_index (struct dwarf_section *section, int do_display)
          if (is_tu_index)
            {
              tu_count = nused;
-             tu_sets = xcmalloc (nused, sizeof (struct cu_tu_set));
+             tu_sets = xcalloc2 (nused, sizeof (struct cu_tu_set));
              this_set = tu_sets;
            }
          else
            {
              cu_count = nused;
-             cu_sets = xcmalloc (nused, sizeof (struct cu_tu_set));
+             cu_sets = xcalloc2 (nused, sizeof (struct cu_tu_set));
              this_set = cu_sets;
            }
        }
+
       if (do_display)
        {
          for (j = 0; j < ncols; j++)
            {
-             dw_sect = byte_get (ppool + j * 4, 4);
+             SAFE_BYTE_GET (dw_sect, ppool + j * 4, 4, limit);
              printf (" %8s", get_DW_SECT_short_name (dw_sect));
            }
          printf ("\n");
        }
+
       for (i = 0; i < nslots; i++)
        {
-         byte_get_64 (ph, &signature_high, &signature_low);
-         row = byte_get (pi, 4);
+         SAFE_BYTE_GET64 (ph, &signature_high, &signature_low, limit);
+
+         SAFE_BYTE_GET (row, pi, 4, limit);
          if (row != 0)
            {
+             /* PR 17531: file: a05f6ab3.  */
+             if (row > nused)
+               {
+                 warn (_("Row index (%u) is larger than number of used entries (%u)\n"),
+                       row, nused);
+                 return 0;
+               }
+
              if (!do_display)
                memcpy (&this_set[row - 1].signature, ph, sizeof (uint64_t));
+
              prow = poffsets + (row - 1) * ncols * 4;
+             /* PR 17531: file: b8ce60a8.  */
+             if (prow < poffsets || prow > limit)
+               {
+                 warn (_("Row index (%u) * num columns (%u) > space remaining in section\n"),
+                       row, ncols);
+                 return 0;
+               }
              if (do_display)
                printf (_("  [%3d] 0x%s"),
                        i, dwarf_vmatoa64 (signature_high, signature_low,
                                           buf, sizeof (buf)));
              for (j = 0; j < ncols; j++)
                {
-                 val = byte_get (prow + j * 4, 4);
+                 SAFE_BYTE_GET (val, prow + j * 4, 4, limit);
                  if (do_display)
                    printf (" %8d", val);
                  else
                    {
-                     dw_sect = byte_get (ppool + j * 4, 4);
-                     this_set [row - 1].section_offsets [dw_sect] = val;
+                     SAFE_BYTE_GET (dw_sect, ppool + j * 4, 4, limit);
+
+                     /* PR 17531: file: 10796eb3.  */
+                     if (dw_sect >= DW_SECT_MAX)
+                       warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect);
+                     else
+                       this_set [row - 1].section_offsets [dw_sect] = val;
                    }
                }
+
              if (do_display)
                printf ("\n");
            }
@@ -6677,51 +7135,62 @@ process_cu_tu_index (struct dwarf_section *section, int do_display)
       ph = phash;
       pi = pindex;
       if (do_display)
-        {
+       {
          printf ("\n");
          printf (_("  Size table\n"));
          printf ("  slot  %-16s  ",
                 is_tu_index ? _("signature") : _("dwo_id"));
-        }
+       }
+
       for (j = 0; j < ncols; j++)
        {
-         val = byte_get (ppool + j * 4, 4);
+         SAFE_BYTE_GET (val, ppool + j * 4, 4, limit);
          if (do_display)
            printf (" %8s", get_DW_SECT_short_name (val));
        }
+
       if (do_display)
        printf ("\n");
+
       for (i = 0; i < nslots; i++)
        {
-         byte_get_64 (ph, &signature_high, &signature_low);
-         row = byte_get (pi, 4);
+         SAFE_BYTE_GET64 (ph, &signature_high, &signature_low, limit);
+
+         SAFE_BYTE_GET (row, pi, 4, limit);
          if (row != 0)
            {
              prow = psizes + (row - 1) * ncols * 4;
+
              if (do_display)
                printf (_("  [%3d] 0x%s"),
                        i, dwarf_vmatoa64 (signature_high, signature_low,
                                           buf, sizeof (buf)));
+
              for (j = 0; j < ncols; j++)
                {
-                 val = byte_get (prow + j * 4, 4);
+                 SAFE_BYTE_GET (val, prow + j * 4, 4, limit);
                  if (do_display)
                    printf (" %8d", val);
                  else
                    {
-                     dw_sect = byte_get (ppool + j * 4, 4);
+                     SAFE_BYTE_GET (dw_sect, ppool + j * 4, 4, limit);
+                     if (dw_sect >= DW_SECT_MAX)
+                       warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect);
+                     else
                      this_set [row - 1].section_sizes [dw_sect] = val;
                    }
                }
+
              if (do_display)
                printf ("\n");
            }
+
          ph += 8;
          pi += 4;
        }
     }
   else if (do_display)
-    printf (_("  Unsupported version\n"));
+    printf (_("  Unsupported version (%d)\n"), version);
 
   if (do_display)
       printf ("\n");
@@ -6792,34 +7261,69 @@ display_debug_not_supported (struct dwarf_section *section,
   return 1;
 }
 
+/* Like malloc, but takes two parameters like calloc.
+   Verifies that the first parameter is not too large.
+   Note: does *not* initialise the allocated memory to zero.  */
 void *
 cmalloc (size_t nmemb, size_t size)
 {
   /* Check for overflow.  */
   if (nmemb >= ~(size_t) 0 / size)
     return NULL;
-  else
-    return malloc (nmemb * size);
+
+  return xmalloc (nmemb * size);
 }
 
+/* Like xmalloc, but takes two parameters like calloc.
+   Verifies that the first parameter is not too large.
+   Note: does *not* initialise the allocated memory to zero.  */
 void *
 xcmalloc (size_t nmemb, size_t size)
 {
   /* Check for overflow.  */
   if (nmemb >= ~(size_t) 0 / size)
-    return NULL;
-  else
-    return xmalloc (nmemb * size);
+    {
+      fprintf (stderr,
+              _("Attempt to allocate an array with an excessive number of elements: 0x%lx\n"),
+              (long) nmemb);
+      xexit (1);
+    }
+
+  return xmalloc (nmemb * size);
 }
 
+/* Like xrealloc, but takes three parameters.
+   Verifies that the second parameter is not too large.
+   Note: does *not* initialise any new memory to zero.  */
 void *
 xcrealloc (void *ptr, size_t nmemb, size_t size)
 {
   /* Check for overflow.  */
   if (nmemb >= ~(size_t) 0 / size)
-    return NULL;
-  else
-    return xrealloc (ptr, nmemb * size);
+    {
+      fprintf (stderr,
+              _("Attempt to re-allocate an array with an excessive number of elements: 0x%lx\n"),
+              (long) nmemb);
+      xexit (1);
+    }
+
+  return xrealloc (ptr, nmemb * size);
+}
+
+/* Like xcalloc, but verifies that the first parameter is not too large.  */
+void *
+xcalloc2 (size_t nmemb, size_t size)
+{
+  /* Check for overflow.  */
+  if (nmemb >= ~(size_t) 0 / size)
+    {
+      fprintf (stderr,
+              _("Attempt to allocate a zero'ed array with an excessive number of elements: 0x%lx\n"),
+              (long) nmemb);
+      xexit (1);
+    }
+
+  return xcalloc (nmemb, size);
 }
 
 void
@@ -6847,10 +7351,9 @@ free_debug_memory (void)
                free (debug_information [i].range_lists);
            }
        }
-
       free (debug_information);
       debug_information = NULL;
-      num_debug_info_entries = 0;
+      alloc_num_debug_info_entries = num_debug_info_entries = 0;
     }
 }
 
@@ -6994,7 +7497,7 @@ dwarf_select_sections_by_letters (const char *letters)
        break;
 
       default:
-       warn (_("Unrecognized debug option '%s'\n"), optarg);
+       warn (_("Unrecognized debug option '%s'\n"), letters);
        break;
       }
 }
@@ -7023,76 +7526,76 @@ dwarf_select_sections_all (void)
 
 struct dwarf_section_display debug_displays[] =
 {
-  { { ".debug_abbrev",     ".zdebug_abbrev",   NULL, NULL, 0, 0, 0 },
+  { { ".debug_abbrev",     ".zdebug_abbrev",   NULL, NULL, 0, 0, 0, NULL },
     display_debug_abbrev,   &do_debug_abbrevs, 0 },
-  { { ".debug_aranges",            ".zdebug_aranges",  NULL, NULL, 0, 0, 0 },
+  { { ".debug_aranges",            ".zdebug_aranges",  NULL, NULL, 0, 0, 0, NULL },
     display_debug_aranges,  &do_debug_aranges, 1 },
-  { { ".debug_frame",       ".zdebug_frame",   NULL, NULL, 0, 0, 0 },
+  { { ".debug_frame",       ".zdebug_frame",   NULL, NULL, 0, 0, 0, NULL },
     display_debug_frames,   &do_debug_frames,  1 },
-  { { ".debug_info",       ".zdebug_info",     NULL, NULL, 0, 0, abbrev },
+  { { ".debug_info",       ".zdebug_info",     NULL, NULL, 0, 0, abbrev, NULL },
     display_debug_info,            &do_debug_info,     1 },
-  { { ".debug_line",       ".zdebug_line",     NULL, NULL, 0, 0, 0 },
+  { { ".debug_line",       ".zdebug_line",     NULL, NULL, 0, 0, 0, NULL },
     display_debug_lines,    &do_debug_lines,   1 },
-  { { ".debug_pubnames",    ".zdebug_pubnames",        NULL, NULL, 0, 0, 0 },
+  { { ".debug_pubnames",    ".zdebug_pubnames",        NULL, NULL, 0, 0, 0, NULL },
     display_debug_pubnames, &do_debug_pubnames,        0 },
-  { { ".debug_gnu_pubnames", ".zdebug_gnu_pubnames", NULL, NULL, 0, 0, 0 },
+  { { ".debug_gnu_pubnames", ".zdebug_gnu_pubnames", NULL, NULL, 0, 0, 0, NULL },
     display_debug_gnu_pubnames, &do_debug_pubnames, 0 },
-  { { ".eh_frame",         "",                 NULL, NULL, 0, 0, 0 },
+  { { ".eh_frame",         "",                 NULL, NULL, 0, 0, 0, NULL },
     display_debug_frames,   &do_debug_frames,  1 },
-  { { ".debug_macinfo",            ".zdebug_macinfo",  NULL, NULL, 0, 0, 0 },
+  { { ".debug_macinfo",            ".zdebug_macinfo",  NULL, NULL, 0, 0, 0, NULL },
     display_debug_macinfo,  &do_debug_macinfo, 0 },
-  { { ".debug_macro",      ".zdebug_macro",    NULL, NULL, 0, 0, 0 },
+  { { ".debug_macro",      ".zdebug_macro",    NULL, NULL, 0, 0, 0, NULL },
     display_debug_macro,    &do_debug_macinfo, 1 },
-  { { ".debug_str",        ".zdebug_str",      NULL, NULL, 0, 0, 0 },
+  { { ".debug_str",        ".zdebug_str",      NULL, NULL, 0, 0, 0, NULL },
     display_debug_str,     &do_debug_str,      0 },
-  { { ".debug_loc",        ".zdebug_loc",      NULL, NULL, 0, 0, 0 },
+  { { ".debug_loc",        ".zdebug_loc",      NULL, NULL, 0, 0, 0, NULL },
     display_debug_loc,     &do_debug_loc,      1 },
-  { { ".debug_pubtypes",    ".zdebug_pubtypes",        NULL, NULL, 0, 0, 0 },
+  { { ".debug_pubtypes",    ".zdebug_pubtypes",        NULL, NULL, 0, 0, 0, NULL },
     display_debug_pubnames, &do_debug_pubtypes,        0 },
-  { { ".debug_gnu_pubtypes", ".zdebug_gnu_pubtypes", NULL, NULL, 0, 0, 0 },
+  { { ".debug_gnu_pubtypes", ".zdebug_gnu_pubtypes", NULL, NULL, 0, 0, 0, NULL },
     display_debug_gnu_pubnames, &do_debug_pubtypes, 0 },
-  { { ".debug_ranges",     ".zdebug_ranges",   NULL, NULL, 0, 0, 0 },
+  { { ".debug_ranges",     ".zdebug_ranges",   NULL, NULL, 0, 0, 0, NULL },
     display_debug_ranges,   &do_debug_ranges,  1 },
-  { { ".debug_static_func", ".zdebug_static_func", NULL, NULL, 0, 0, 0 },
+  { { ".debug_static_func", ".zdebug_static_func", NULL, NULL, 0, 0, 0, NULL },
     display_debug_not_supported, NULL,         0 },
-  { { ".debug_static_vars", ".zdebug_static_vars", NULL, NULL, 0, 0, 0 },
+  { { ".debug_static_vars", ".zdebug_static_vars", NULL, NULL, 0, 0, 0, NULL },
     display_debug_not_supported, NULL,         0 },
-  { { ".debug_types",      ".zdebug_types",    NULL, NULL, 0, 0, abbrev },
+  { { ".debug_types",      ".zdebug_types",    NULL, NULL, 0, 0, abbrev, NULL },
     display_debug_types,    &do_debug_info,    1 },
-  { { ".debug_weaknames",   ".zdebug_weaknames", NULL, NULL, 0, 0, 0 },
+  { { ".debug_weaknames",   ".zdebug_weaknames", NULL, NULL, 0, 0, 0, NULL },
     display_debug_not_supported, NULL,         0 },
-  { { ".gdb_index",        "",                 NULL, NULL, 0, 0, 0 },
+  { { ".gdb_index",        "",                 NULL, NULL, 0, 0, 0, NULL },
     display_gdb_index,      &do_gdb_index,     0 },
-  { { ".trace_info",       "",                 NULL, NULL, 0, 0, trace_abbrev },
+  { { ".trace_info",       "",                 NULL, NULL, 0, 0, trace_abbrev, NULL },
     display_trace_info,            &do_trace_info,     1 },
-  { { ".trace_abbrev",     "",                 NULL, NULL, 0, 0, 0 },
+  { { ".trace_abbrev",     "",                 NULL, NULL, 0, 0, 0, NULL },
     display_debug_abbrev,   &do_trace_abbrevs, 0 },
-  { { ".trace_aranges",            "",                 NULL, NULL, 0, 0, 0 },
+  { { ".trace_aranges",            "",                 NULL, NULL, 0, 0, 0, NULL },
     display_debug_aranges,  &do_trace_aranges, 0 },
-  { { ".debug_info.dwo",    ".zdebug_info.dwo",        NULL, NULL, 0, 0, abbrev_dwo },
+  { { ".debug_info.dwo",    ".zdebug_info.dwo",        NULL, NULL, 0, 0, abbrev_dwo, NULL },
     display_debug_info,            &do_debug_info,     1 },
-  { { ".debug_abbrev.dwo",  ".zdebug_abbrev.dwo", NULL, NULL, 0, 0, 0 },
+  { { ".debug_abbrev.dwo",  ".zdebug_abbrev.dwo", NULL, NULL, 0, 0, 0, NULL },
     display_debug_abbrev,   &do_debug_abbrevs, 0 },
-  { { ".debug_types.dwo",   ".zdebug_types.dwo", NULL, NULL, 0, 0, abbrev_dwo },
+  { { ".debug_types.dwo",   ".zdebug_types.dwo", NULL, NULL, 0, 0, abbrev_dwo, NULL },
     display_debug_types,    &do_debug_info,    1 },
-  { { ".debug_line.dwo",    ".zdebug_line.dwo", NULL, NULL, 0, 0, 0 },
+  { { ".debug_line.dwo",    ".zdebug_line.dwo", NULL, NULL, 0, 0, 0, NULL },
     display_debug_lines,    &do_debug_lines,   1 },
-  { { ".debug_loc.dwo",            ".zdebug_loc.dwo",  NULL, NULL, 0, 0, 0 },
+  { { ".debug_loc.dwo",            ".zdebug_loc.dwo",  NULL, NULL, 0, 0, 0, NULL },
     display_debug_loc,     &do_debug_loc,      1 },
-  { { ".debug_macro.dwo",   ".zdebug_macro.dwo", NULL, NULL, 0, 0, 0 },
+  { { ".debug_macro.dwo",   ".zdebug_macro.dwo", NULL, NULL, 0, 0, 0, NULL },
     display_debug_macro,    &do_debug_macinfo, 1 },
-  { { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo", NULL, NULL, 0, 0, 0 },
+  { { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo", NULL, NULL, 0, 0, 0, NULL },
     display_debug_macinfo,  &do_debug_macinfo, 0 },
-  { { ".debug_str.dwo",     ".zdebug_str.dwo",  NULL, NULL, 0, 0, 0 },
+  { { ".debug_str.dwo",     ".zdebug_str.dwo",  NULL, NULL, 0, 0, 0, NULL },
     display_debug_str,      &do_debug_str,     1 },
-  { { ".debug_str_offsets", ".zdebug_str_offsets", NULL, NULL, 0, 0, 0 },
+  { { ".debug_str_offsets", ".zdebug_str_offsets", NULL, NULL, 0, 0, 0, NULL },
     display_debug_str_offsets, NULL,           0 },
-  { { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo", NULL, NULL, 0, 0, 0 },
+  { { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo", NULL, NULL, 0, 0, 0, NULL },
     display_debug_str_offsets, NULL,           0 },
-  { { ".debug_addr",       ".zdebug_addr",     NULL, NULL, 0, 0, 0 },
+  { { ".debug_addr",       ".zdebug_addr",     NULL, NULL, 0, 0, 0, NULL },
     display_debug_addr,     &do_debug_addr,    1 },
-  { { ".debug_cu_index",    "",                        NULL, NULL, 0, 0, 0 },
+  { { ".debug_cu_index",    "",                        NULL, NULL, 0, 0, 0, NULL },
     display_cu_index,       &do_debug_cu_index,        0 },
-  { { ".debug_tu_index",    "",                        NULL, NULL, 0, 0, 0 },
+  { { ".debug_tu_index",    "",                        NULL, NULL, 0, 0, 0, NULL },
     display_cu_index,       &do_debug_cu_index,        0 },
 };
index 124d9d6..2084a22 100644 (file)
@@ -23,24 +23,11 @@ typedef HOST_WIDEST_INT           dwarf_signed_vma;
 typedef unsigned HOST_WIDEST_INT  dwarf_size_type;
 
 /* Structure found in the .debug_line section.  */
-typedef struct
-{
-  unsigned char li_length          [4];
-  unsigned char li_version         [2];
-  unsigned char li_prologue_length [4];
-  unsigned char li_min_insn_length [1];
-  unsigned char li_default_is_stmt [1];
-  unsigned char li_line_base       [1];
-  unsigned char li_line_range      [1];
-  unsigned char li_opcode_base     [1];
-}
-DWARF2_External_LineInfo;
-
 typedef struct
 {
   dwarf_vma     li_length;
   unsigned short li_version;
-  unsigned int   li_prologue_length;
+  dwarf_vma      li_prologue_length;
   unsigned char  li_min_insn_length;
   unsigned char  li_max_ops_per_insn;
   unsigned char  li_default_is_stmt;
@@ -51,15 +38,6 @@ typedef struct
 DWARF2_Internal_LineInfo;
 
 /* Structure found in .debug_pubnames section.  */
-typedef struct
-{
-  unsigned char pn_length  [4];
-  unsigned char pn_version [2];
-  unsigned char pn_offset  [4];
-  unsigned char pn_size    [4];
-}
-DWARF2_External_PubNames;
-
 typedef struct
 {
   dwarf_vma     pn_length;
@@ -70,15 +48,6 @@ typedef struct
 DWARF2_Internal_PubNames;
 
 /* Structure found in .debug_info section.  */
-typedef struct
-{
-  unsigned char  cu_length        [4];
-  unsigned char  cu_version       [2];
-  unsigned char  cu_abbrev_offset [4];
-  unsigned char  cu_pointer_size  [1];
-}
-DWARF2_External_CompUnit;
-
 typedef struct
 {
   dwarf_vma     cu_length;
@@ -88,16 +57,7 @@ typedef struct
 }
 DWARF2_Internal_CompUnit;
 
-typedef struct
-{
-  unsigned char  ar_length       [4];
-  unsigned char  ar_version      [2];
-  unsigned char  ar_info_offset  [4];
-  unsigned char  ar_pointer_size [1];
-  unsigned char  ar_segment_size [1];
-}
-DWARF2_External_ARange;
-
+/* Structure found in .debug_aranges section.  */
 typedef struct
 {
   dwarf_vma     ar_length;
@@ -164,6 +124,8 @@ struct dwarf_section
   dwarf_vma address;
   dwarf_size_type size;
   enum dwarf_section_display_enum abbrev_sec;
+  /* A spare field for random use.  */
+  void *user_data;
 };
 
 /* A structure containing the name of a debug section
@@ -205,7 +167,7 @@ typedef struct
 }
 debug_info;
 
-extern int eh_addr_size;
+extern unsigned int eh_addr_size;
 
 extern int do_debug_info;
 extern int do_debug_abbrevs;
@@ -246,10 +208,11 @@ extern void dwarf_select_sections_by_names (const char *);
 extern void dwarf_select_sections_by_letters (const char *);
 extern void dwarf_select_sections_all (void);
 
-unsigned int * find_cu_tu_set (void *, unsigned int);
+extern unsigned int * find_cu_tu_set (void *, unsigned int);
 
-void * cmalloc (size_t, size_t);
-void * xcmalloc (size_t, size_t);
-void * xcrealloc (void *, size_t, size_t);
+extern void * cmalloc (size_t, size_t);
+extern void * xcalloc2 (size_t, size_t);
+extern void * xcmalloc (size_t, size_t);
+extern void * xcrealloc (void *, size_t, size_t);
 
 extern dwarf_vma read_leb128 (unsigned char *, unsigned int *, bfd_boolean, const unsigned char * const);
index f1502b9..063662a 100644 (file)
@@ -51,7 +51,7 @@ warn (const char *message, ...)
 
   /* Try to keep warning messages in sync with the program's normal output.  */
   fflush (stdout);
-  
+
   va_start (args, message);
   fprintf (stderr, _("%s: Warning: "), program_name);
   vfprintf (stderr, message, args);
@@ -386,10 +386,11 @@ byte_get_64 (unsigned char *field, elf_vma *high, elf_vma *low)
 
 char *
 adjust_relative_path (const char *file_name, const char *name,
-                     int name_len)
+                     unsigned long name_len)
 {
   char * member_file_name;
   const char * base_name = lbasename (file_name);
+  size_t amt;
 
   /* This is a proxy entry for a thin archive member.
      If the extended name table contains an absolute path
@@ -399,7 +400,10 @@ adjust_relative_path (const char *file_name, const char *name,
      archive is located.  */
   if (IS_ABSOLUTE_PATH (name) || base_name == file_name)
     {
-      member_file_name = (char *) malloc (name_len + 1);
+      amt = name_len + 1;
+      if (amt == 0)
+       return NULL;
+      member_file_name = (char *) malloc (amt);
       if (member_file_name == NULL)
         {
           error (_("Out of memory\n"));
@@ -413,7 +417,18 @@ adjust_relative_path (const char *file_name, const char *name,
       /* Concatenate the path components of the archive file name
          to the relative path name from the extended name table.  */
       size_t prefix_len = base_name - file_name;
-      member_file_name = (char *) malloc (prefix_len + name_len + 1);
+
+      amt = prefix_len + name_len + 1;
+      /* PR 17531: file: 2896dc8b
+        Catch wraparound.  */
+      if (amt < prefix_len || amt < name_len)
+       {
+         error (_("Abnormal length of thin archive member name: %lx\n"),
+                name_len);
+         return NULL;
+       }
+
+      member_file_name = (char *) malloc (amt);
       if (member_file_name == NULL)
         {
           error (_("Out of memory\n"));
@@ -445,6 +460,14 @@ process_archive_index_and_symbols (struct archive_info *  arch,
   unsigned long size;
 
   size = strtoul (arch->arhdr.ar_size, NULL, 10);
+  /* PR 17531: file: 912bd7de.  */
+  if ((signed long) size < 0)
+    {
+      error (_("%s: invalid archive header size: %ld\n"),
+            arch->file_name, size);
+      return FALSE;
+    }
+
   size = size + (size & 1);
 
   arch->next_arhdr_offset += sizeof arch->arhdr + size;
@@ -468,7 +491,7 @@ process_archive_index_and_symbols (struct archive_info *  arch,
       unsigned char * index_buffer;
 
       assert (sizeof_ar_index <= sizeof integer_buffer);
-  
+
       /* Check the size of the archive index.  */
       if (size < sizeof_ar_index)
        {
@@ -487,9 +510,11 @@ process_archive_index_and_symbols (struct archive_info *  arch,
       arch->index_num = byte_get_big_endian (integer_buffer, sizeof_ar_index);
       size -= sizeof_ar_index;
 
-      if (size < arch->index_num * sizeof_ar_index)
+      if (size < arch->index_num * sizeof_ar_index
+         /* PR 17531: file: 585515d1.  */
+         || size < arch->index_num)
        {
-         error (_("%s: the archive index is supposed to have %ld entries of %d bytes, but the size is only %ld\n"),
+         error (_("%s: the archive index is supposed to have 0x%lx entries of %d bytes, but the size is only 0x%lx\n"),
                 arch->file_name, (long) arch->index_num, sizeof_ar_index, size);
          return FALSE;
        }
@@ -623,9 +648,25 @@ setup_archive (struct archive_info *arch, const char *file_name,
     {
       /* This is the archive string table holding long member names.  */
       arch->longnames_size = strtoul (arch->arhdr.ar_size, NULL, 10);
+      /* PR 17531: file: 01068045.  */
+      if (arch->longnames_size < 8)
+       {
+         error (_("%s: long name table is too small, (size = %ld)\n"),
+                file_name, arch->longnames_size);
+         return 1;
+       }
+      /* PR 17531: file: 639d6a26.  */
+      if ((signed long) arch->longnames_size < 0)
+       {
+         error (_("%s: long name table is too big, (size = 0x%lx)\n"),
+                file_name, arch->longnames_size);
+         return 1;
+       }
+
       arch->next_arhdr_offset += sizeof arch->arhdr + arch->longnames_size;
 
-      arch->longnames = (char *) malloc (arch->longnames_size);
+      /* Plus one to allow for a string terminator.  */
+      arch->longnames = (char *) malloc (arch->longnames_size + 1);
       if (arch->longnames == NULL)
        {
          error (_("Out of memory reading long symbol names in archive\n"));
@@ -643,6 +684,8 @@ setup_archive (struct archive_info *arch, const char *file_name,
 
       if ((arch->longnames_size & 1) != 0)
        getc (file);
+
+      arch->longnames[arch->longnames_size] = 0;
     }
 
   return 0;
@@ -713,23 +756,37 @@ get_archive_member_name (struct archive_info *arch,
          error (_("Archive member uses long names, but no longname table found\n"));
          return NULL;
        }
-      
+
       arch->nested_member_origin = 0;
       k = j = strtoul (arch->arhdr.ar_name + 1, &endp, 10);
       if (arch->is_thin_archive && endp != NULL && * endp == ':')
         arch->nested_member_origin = strtoul (endp + 1, NULL, 10);
 
+      if (j > arch->longnames_size)
+       {
+         error (_("Found long name index (%ld) beyond end of long name table\n"),j);
+         return NULL;
+       }
       while ((j < arch->longnames_size)
              && (arch->longnames[j] != '\n')
              && (arch->longnames[j] != '\0'))
         j++;
-      if (arch->longnames[j-1] == '/')
+      if (j > 0 && arch->longnames[j-1] == '/')
         j--;
+      if (j > arch->longnames_size)
+       j = arch->longnames_size;
       arch->longnames[j] = '\0';
 
       if (!arch->is_thin_archive || arch->nested_member_origin == 0)
         return arch->longnames + k;
 
+      /* PR 17531: file: 2896dc8b.  */
+      if (k >= j)
+       {
+         error (_("Invalid Thin archive member name\n"));
+         return NULL;
+       }
+
       /* This is a proxy for a member of a nested archive.
          Find the name of the member in that archive.  */
       member_file_name = adjust_relative_path (arch->file_name,
index f41a8ac..f7f7544 100644 (file)
@@ -29,7 +29,7 @@
 void error (const char *, ...) ATTRIBUTE_PRINTF_1;
 void warn (const char *, ...) ATTRIBUTE_PRINTF_1;
 
-#if __STDC_VERSION__ >= 199901L || (defined(__GNUC__) && __GNUC__ >= 2)
+#if defined HAVE_LONG_LONG && SIZEOF_LONG_LONG > SIZEOF_LONG
 /* We can't use any bfd types here since readelf may define BFD64 and
    objdump may not.  */
 #define HOST_WIDEST_INT        long long
@@ -77,7 +77,7 @@ struct archive_info
 };
 
 /* Return the path name for a proxy entry in a thin archive.  */
-extern char *adjust_relative_path (const char *, const char *, int);
+extern char *adjust_relative_path (const char *, const char *, unsigned long);
 
 /* Read the symbol table and long-name table from an archive.  */
 extern int setup_archive (struct archive_info *, const char *, FILE *,
index ecd147e..ed1ed12 100644 (file)
@@ -806,7 +806,11 @@ get_relocs (bfd *abfd, asection *sec, void *dataarg)
 /* Print a single symbol.  */
 
 static void
-print_symbol (bfd *abfd, asymbol *sym, bfd_vma ssize, bfd *archive_bfd)
+print_symbol (bfd *        abfd,
+             asymbol *    sym,
+             bfd_vma      ssize,
+       &