]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blobdiff - binutils/dwarf.c
Add a warning if an emtpty SHT_REL, SHT_RELA or SHT_PROGBITS section is detected...
[thirdparty/binutils-gdb.git] / binutils / dwarf.c
index 6aca9b79942b5593b6ab445795d5b50b8f973bed..675b4d016fd0777af4dc8a05424f8190d9d32a74 100644 (file)
@@ -1,5 +1,5 @@
 /* dwarf.c -- display DWARF contents of a BFD binary file
-   Copyright (C) 2005-2018 Free Software Foundation, Inc.
+   Copyright (C) 2005-2020 Free Software Foundation, Inc.
 
    This file is part of GNU Binutils.
 
 #include "dwarf.h"
 #include "gdb/gdb-index.h"
 #include "filenames.h"
+#include "safe-ctype.h"
 #include <assert.h>
 
+#ifdef HAVE_LIBDEBUGINFOD
+#include <elfutils/debuginfod.h>
+#endif
+
 #undef MAX
 #undef MIN
 #define MAX(a, b) ((a) > (b) ? (a) : (b))
 #define MIN(a, b) ((a) < (b) ? (a) : (b))
 
 static const char *regname (unsigned int regno, int row);
+static const char *regname_internal_by_table_only (unsigned int regno);
 
 static int have_frame_base;
 static int need_base_address;
@@ -48,11 +54,26 @@ static debug_info *debug_information = NULL;
    that the .debug_info section could not be loaded/parsed.  */
 #define DEBUG_INFO_UNAVAILABLE  (unsigned int) -1
 
-static const char *           dwo_name;
-static const char *           dwo_dir;
-static const unsigned char *  dwo_id;
-static bfd_size_type          dwo_id_len;
-static bfd_boolean            need_dwo_info;
+/* A .debug_info section can contain multiple links to separate
+   DWO object files.  We use these structures to record these links.  */
+typedef enum dwo_type
+{
+ DWO_NAME,
+ DWO_DIR,
+ DWO_ID
+} dwo_type;
+
+typedef struct dwo_info
+{
+  dwo_type          type;
+  const char *      value;
+  struct dwo_info * next;
+} dwo_info;
+
+static dwo_info *   first_dwo_info = NULL;
+static bfd_boolean  need_dwo_info;
+
+separate_info * first_separate_info = NULL;
 
 unsigned int eh_addr_size;
 
@@ -96,10 +117,6 @@ static unsigned int *shndx_pool = NULL;
 static unsigned int shndx_pool_size = 0;
 static unsigned int shndx_pool_used = 0;
 
-/* Pointer to a separate file containing extra debug information.  */
-static void * separate_debug_file = NULL;
-static const char * separate_debug_filename = NULL;
-
 /* For version 2 package files, each set contains an array of section offsets
    and an array of section sizes, giving the offset and size of the
    contribution from a CU or TU within one of the debug sections.
@@ -108,9 +125,9 @@ static const char * separate_debug_filename = NULL;
 
 struct cu_tu_set
 {
-  uint64_t signature;
-  dwarf_vma section_offsets[DW_SECT_MAX];
-  size_t section_sizes[DW_SECT_MAX];
+  uint64_t   signature;
+  dwarf_vma  section_offsets[DW_SECT_MAX];
+  size_t     section_sizes[DW_SECT_MAX];
 };
 
 static int cu_count = 0;
@@ -120,6 +137,12 @@ static struct cu_tu_set *tu_sets = NULL;
 
 static bfd_boolean load_cu_tu_indexes (void *);
 
+/* An array that indicates for a given level of CU nesting whether
+   the latest DW_AT_type seen for that level was a signed type or
+   an unsigned type.  */
+#define MAX_CU_NESTING (1 << 8)
+static bfd_boolean level_type_signed[MAX_CU_NESTING];
+
 /* Values for do_debug_lines.  */
 #define FLAG_DEBUG_LINES_RAW    1
 #define FLAG_DEBUG_LINES_DECODED 2
@@ -300,93 +323,59 @@ dwarf_vmatoa64 (dwarf_vma hvalue, dwarf_vma lvalue, char *buf,
 /* Read in a LEB128 encoded value starting at address DATA.
    If SIGN is true, return a signed LEB128 value.
    If LENGTH_RETURN is not NULL, return in it the number of bytes read.
+   If STATUS_RETURN in not NULL, return with bit 0 (LSB) set if the
+   terminating byte was not found and with bit 1 set if the value
+   overflows a dwarf_vma.
    No bytes will be read at address END or beyond.  */
 
 dwarf_vma
 read_leb128 (unsigned char *data,
-            unsigned int *length_return,
+            const unsigned char *const end,
             bfd_boolean sign,
-            const unsigned char * const end)
+            unsigned int *length_return,
+            int *status_return)
 {
   dwarf_vma result = 0;
   unsigned int num_read = 0;
   unsigned int shift = 0;
-  unsigned char byte = 0;
+  int status = 1;
 
   while (data < end)
     {
-      byte = *data++;
+      unsigned char byte = *data++;
       num_read++;
 
-      result |= ((dwarf_vma) (byte & 0x7f)) << shift;
+      if (shift < sizeof (result) * 8)
+       {
+         result |= ((dwarf_vma) (byte & 0x7f)) << shift;
+         if ((result >> shift) != (byte & 0x7f))
+           /* Overflow.  */
+           status |= 2;
+         shift += 7;
+       }
+      else if ((byte & 0x7f) != 0)
+       status |= 2;
 
-      shift += 7;
       if ((byte & 0x80) == 0)
-       break;
-
-      /* PR 17512: file: 0ca183b8.
-        FIXME: Should we signal this error somehow ?  */
-      if (shift >= sizeof (result) * 8)
-       break;
+       {
+         status &= ~1;
+         if (sign && (shift < 8 * sizeof (result)) && (byte & 0x40))
+           result |= -((dwarf_vma) 1 << shift);
+         break;
+       }
     }
 
   if (length_return != NULL)
     *length_return = num_read;
-
-  if (sign && (shift < 8 * sizeof (result)) && (byte & 0x40))
-    result |= -((dwarf_vma) 1 << shift);
+  if (status_return != NULL)
+    *status_return = status;
 
   return result;
 }
 
-/* Create a signed version to avoid painful typecasts.  */
-static inline dwarf_signed_vma
-read_sleb128 (unsigned char * data,
-             unsigned int *  length_return,
-             const unsigned char * const end)
-{
-  return (dwarf_signed_vma) read_leb128 (data, length_return, TRUE, end);
-}
-
-static inline dwarf_vma
-read_uleb128 (unsigned char * data,
-             unsigned int *  length_return,
-             const unsigned char * const end)
-{
-  return read_leb128 (data, length_return, FALSE, end);
-}
-
-#define SKIP_ULEB()    read_uleb128 (start, & length_return, end); start += length_return
-#define SKIP_SLEB()    read_sleb128 (start, & length_return, end); start += length_return
-
-#define READ_ULEB(var)                                         \
-  do                                                           \
-    {                                                          \
-      dwarf_vma _val;                                          \
-                                                               \
-      (var) = _val = read_uleb128 (start, &length_return, end);        \
-      if ((var) != _val)                                       \
-       error (_("Internal error: %s:%d: LEB value (%s) "       \
-                "too large for containing variable\n"),        \
-              __FILE__, __LINE__, dwarf_vmatoa ("u", _val));   \
-      start += length_return;                                  \
-    }                                                          \
-  while (0)
-
-#define READ_SLEB(var)                                         \
-  do                                                           \
-    {                                                          \
-      dwarf_signed_vma _val;                                   \
-                                                               \
-      (var) = _val = read_sleb128 (start, &length_return, end);        \
-      if ((var) != _val)                                       \
-       error (_("Internal error: %s:%d: LEB value (%s) "       \
-                "too large for containing variable\n"),        \
-              __FILE__, __LINE__, dwarf_vmatoa ("d", _val));   \
-      start += length_return;                                  \
-    }                                                          \
-  while (0)
-
+/* Read AMOUNT bytes from PTR and store them in VAL as an unsigned value.
+   Checks to make sure that the read will not reach or pass END
+   and that VAL is big enough to hold AMOUNT bytes.  */
 #define SAFE_BYTE_GET(VAL, PTR, AMOUNT, END)   \
   do                                           \
     {                                          \
@@ -415,6 +404,7 @@ read_uleb128 (unsigned char * data,
     }                                          \
   while (0)
 
+/* Like SAFE_BYTE_GET, but also increments PTR by AMOUNT.  */
 #define SAFE_BYTE_GET_AND_INC(VAL, PTR, AMOUNT, END)   \
   do                                                   \
     {                                                  \
@@ -423,6 +413,7 @@ read_uleb128 (unsigned char * data,
     }                                                  \
   while (0)
 
+/* Like SAFE_BYTE_GET, but reads a signed value.  */
 #define SAFE_SIGNED_BYTE_GET(VAL, PTR, AMOUNT, END)    \
   do                                                   \
     {                                                  \
@@ -441,6 +432,7 @@ read_uleb128 (unsigned char * data,
     }                                                  \
   while (0)
 
+/* Like SAFE_SIGNED_BYTE_GET, but also increments PTR by AMOUNT.  */
 #define SAFE_SIGNED_BYTE_GET_AND_INC(VAL, PTR, AMOUNT, END)    \
   do                                                           \
     {                                                          \
@@ -499,28 +491,26 @@ reset_state_machine (int is_stmt)
 /* Handled an extend line op.
    Returns the number of bytes read.  */
 
-static int
+static size_t
 process_extended_line_op (unsigned char * data,
                          int is_stmt,
                          unsigned char * end)
 {
   unsigned char op_code;
-  unsigned int bytes_read;
-  unsigned int len;
+  size_t len, header_len;
   unsigned char *name;
   unsigned char *orig_data = data;
-  dwarf_vma adr;
+  dwarf_vma adr, val;
 
-  len = read_uleb128 (data, & bytes_read, end);
-  data += bytes_read;
+  READ_ULEB (len, data, end);
+  header_len = data - orig_data;
 
-  if (len == 0 || data == end || len > (uintptr_t) (end - data))
+  if (len == 0 || data == end || len > (size_t) (end - data))
     {
       warn (_("Badly formed extended line op encountered!\n"));
-      return bytes_read;
+      return header_len;
     }
 
-  len += bytes_read;
   op_code = *data++;
 
   printf (_("  Extended opcode %d: "), op_code);
@@ -534,14 +524,14 @@ process_extended_line_op (unsigned char * data,
 
     case DW_LNE_set_address:
       /* PR 17512: file: 002-100480-0.004.  */
-      if (len - bytes_read - 1 > 8)
+      if (len - 1 > 8)
        {
-         warn (_("Length (%d) of DW_LNE_set_address op is too long\n"),
-               len - bytes_read - 1);
+         warn (_("Length (%lu) of DW_LNE_set_address op is too long\n"),
+               (unsigned long) len - 1);
          adr = 0;
        }
       else
-       SAFE_BYTE_GET (adr, data, len - bytes_read - 1, end);
+       SAFE_BYTE_GET (adr, data, len - 1, end);
       printf (_("set Address to 0x%s\n"), dwarf_vmatoa ("x", adr));
       state_machine_regs.address = adr;
       state_machine_regs.view = 0;
@@ -558,23 +548,23 @@ process_extended_line_op (unsigned char * data,
 
        name = data;
        l = strnlen ((char *) data, end - data);
-       data += len + 1;
-       printf ("%s\t", dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
-       data += bytes_read;
-       printf ("%s\t", dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
-       data += bytes_read;
-       printf ("%s\t", dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
-       data += bytes_read;
+       data += l + 1;
+       READ_ULEB (val, data, end);
+       printf ("%s\t", dwarf_vmatoa ("u", val));
+       READ_ULEB (val, data, end);
+       printf ("%s\t", dwarf_vmatoa ("u", val));
+       READ_ULEB (val, data, end);
+       printf ("%s\t", dwarf_vmatoa ("u", val));
        printf ("%.*s\n\n", (int) l, name);
       }
 
-      if (((unsigned int) (data - orig_data) != len) || data == end)
+      if (((size_t) (data - orig_data) != len + header_len) || data == end)
        warn (_("DW_LNE_define_file: Bad opcode length\n"));
       break;
 
     case DW_LNE_set_discriminator:
-      printf (_("set Discriminator to %s\n"),
-             dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
+      READ_ULEB (val, data, end);
+      printf (_("set Discriminator to %s\n"), dwarf_vmatoa ("u", val));
       break;
 
     /* HP extensions.  */
@@ -610,7 +600,7 @@ process_extended_line_op (unsigned char * data,
       break;
     case DW_LNE_HP_source_file_correlation:
       {
-       unsigned char *edata = data + len - bytes_read - 1;
+       unsigned char *edata = data + len - 1;
 
        printf ("DW_LNE_HP_source_file_correlation\n");
 
@@ -618,8 +608,7 @@ process_extended_line_op (unsigned char * data,
          {
            unsigned int opc;
 
-           opc = read_uleb128 (data, & bytes_read, edata);
-           data += bytes_read;
+           READ_ULEB (opc, data, edata);
 
            switch (opc)
              {
@@ -627,25 +616,18 @@ process_extended_line_op (unsigned char * data,
                printf ("    DW_LNE_HP_SFC_formfeed\n");
                break;
              case DW_LNE_HP_SFC_set_listing_line:
+               READ_ULEB (val, data, edata);
                printf ("    DW_LNE_HP_SFC_set_listing_line (%s)\n",
-                       dwarf_vmatoa ("u",
-                                     read_uleb128 (data, & bytes_read, edata)));
-               data += bytes_read;
+                       dwarf_vmatoa ("u", val));
                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;
+               READ_ULEB (val, data, edata);
+               printf ("(%s", dwarf_vmatoa ("u", val));
+               READ_ULEB (val, data, edata);
+               printf (",%s", dwarf_vmatoa ("u", val));
+               READ_ULEB (val, data, edata);
+               printf (",%s)\n", dwarf_vmatoa ("u", val));
                break;
              default:
                printf (_("    UNKNOWN DW_LNE_HP_SFC opcode (%u)\n"), opc);
@@ -658,7 +640,7 @@ process_extended_line_op (unsigned char * data,
 
     default:
       {
-       unsigned int rlen = len - bytes_read - 1;
+       unsigned int rlen = len - 1;
 
        if (op_code >= DW_LNE_lo_user
            /* The test against DW_LNW_hi_user is redundant due to
@@ -676,7 +658,7 @@ process_extended_line_op (unsigned char * data,
       break;
     }
 
-  return len;
+  return len + header_len;
 }
 
 static const unsigned char *
@@ -916,14 +898,12 @@ process_abbrev_section (unsigned char *start, unsigned char *end)
 
   while (start < end)
     {
-      unsigned int bytes_read;
       unsigned long entry;
       unsigned long tag;
       unsigned long attribute;
       int children;
 
-      entry = read_uleb128 (start, & bytes_read, end);
-      start += bytes_read;
+      READ_ULEB (entry, start, end);
 
       /* A single zero is supposed to end the section according
         to the standard.  If there's more, then signal that to
@@ -933,8 +913,7 @@ process_abbrev_section (unsigned char *start, unsigned char *end)
       if (entry == 0)
        return start;
 
-      tag = read_uleb128 (start, & bytes_read, end);
-      start += bytes_read;
+      READ_ULEB (tag, start, end);
       if (start == end)
        return NULL;
 
@@ -948,20 +927,17 @@ process_abbrev_section (unsigned char *start, unsigned char *end)
          /* Initialize it due to a false compiler warning.  */
          bfd_signed_vma implicit_const = -1;
 
-         attribute = read_uleb128 (start, & bytes_read, end);
-         start += bytes_read;
+         READ_ULEB (attribute, start, end);
          if (start == end)
            break;
 
-         form = read_uleb128 (start, & bytes_read, end);
-         start += bytes_read;
+         READ_ULEB (form, start, end);
          if (start == end)
            break;
 
          if (form == DW_FORM_implicit_const)
            {
-             implicit_const = read_sleb128 (start, & bytes_read, end);
-             start += bytes_read;
+             READ_SLEB (implicit_const, start, end);
              if (start == end)
                break;
            }
@@ -1062,7 +1038,6 @@ decode_location_expression (unsigned char * data,
                            struct dwarf_section * section)
 {
   unsigned op;
-  unsigned int bytes_read;
   dwarf_vma uvalue;
   dwarf_signed_vma svalue;
   unsigned char *end = data + length;
@@ -1118,14 +1093,12 @@ decode_location_expression (unsigned char * data,
          printf ("%ld", (long) svalue);
          break;
        case DW_OP_constu:
-         printf ("DW_OP_constu: %s",
-                 dwarf_vmatoa ("u", read_uleb128 (data, &bytes_read, end)));
-         data += bytes_read;
+         READ_ULEB (uvalue, data, end);
+         printf ("DW_OP_constu: %s", dwarf_vmatoa ("u", uvalue));
          break;
        case DW_OP_consts:
-         printf ("DW_OP_consts: %s",
-                 dwarf_vmatoa ("d", read_sleb128 (data, &bytes_read, end)));
-         data += bytes_read;
+         READ_SLEB (svalue, data, end);
+         printf ("DW_OP_consts: %s", dwarf_vmatoa ("d", svalue));
          break;
        case DW_OP_dup:
          printf ("DW_OP_dup");
@@ -1180,9 +1153,8 @@ decode_location_expression (unsigned char * data,
          printf ("DW_OP_plus");
          break;
        case DW_OP_plus_uconst:
-         printf ("DW_OP_plus_uconst: %s",
-                 dwarf_vmatoa ("u", read_uleb128 (data, &bytes_read, end)));
-         data += bytes_read;
+         READ_ULEB (uvalue, data, end);
+         printf ("DW_OP_plus_uconst: %s", dwarf_vmatoa ("u", uvalue));
          break;
        case DW_OP_shl:
          printf ("DW_OP_shl");
@@ -1326,37 +1298,31 @@ decode_location_expression (unsigned char * data,
        case DW_OP_breg29:
        case DW_OP_breg30:
        case DW_OP_breg31:
-         printf ("DW_OP_breg%d (%s): %s",
-                 op - DW_OP_breg0,
-                 regname (op - DW_OP_breg0, 1),
-                 dwarf_vmatoa ("d", read_sleb128 (data, &bytes_read, end)));
-         data += bytes_read;
+         READ_SLEB (svalue, data, end);
+         printf ("DW_OP_breg%d (%s): %s", op - DW_OP_breg0,
+                 regname (op - DW_OP_breg0, 1), dwarf_vmatoa ("d", svalue));
          break;
 
        case DW_OP_regx:
-         uvalue = read_uleb128 (data, &bytes_read, end);
-         data += bytes_read;
+         READ_ULEB (uvalue, data, end);
          printf ("DW_OP_regx: %s (%s)",
                  dwarf_vmatoa ("u", uvalue), regname (uvalue, 1));
          break;
        case DW_OP_fbreg:
          need_frame_base = 1;
-         printf ("DW_OP_fbreg: %s",
-                 dwarf_vmatoa ("d", read_sleb128 (data, &bytes_read, end)));
-         data += bytes_read;
+         READ_SLEB (svalue, data, end);
+         printf ("DW_OP_fbreg: %s", dwarf_vmatoa ("d", svalue));
          break;
        case DW_OP_bregx:
-         uvalue = read_uleb128 (data, &bytes_read, end);
-         data += bytes_read;
+         READ_ULEB (uvalue, data, end);
+         READ_SLEB (svalue, data, end);
          printf ("DW_OP_bregx: %s (%s) %s",
                  dwarf_vmatoa ("u", uvalue), regname (uvalue, 1),
-                 dwarf_vmatoa ("d", read_sleb128 (data, &bytes_read, end)));
-         data += bytes_read;
+                 dwarf_vmatoa ("d", svalue));
          break;
        case DW_OP_piece:
-         printf ("DW_OP_piece: %s",
-                 dwarf_vmatoa ("u", read_uleb128 (data, &bytes_read, end)));
-         data += bytes_read;
+         READ_ULEB (uvalue, data, end);
+         printf ("DW_OP_piece: %s", dwarf_vmatoa ("u", uvalue));
          break;
        case DW_OP_deref_size:
          SAFE_BYTE_GET_AND_INC (uvalue, data, 1, end);
@@ -1415,12 +1381,10 @@ decode_location_expression (unsigned char * data,
          break;
        case DW_OP_bit_piece:
          printf ("DW_OP_bit_piece: ");
-         printf (_("size: %s "),
-                 dwarf_vmatoa ("u", read_uleb128 (data, &bytes_read, end)));
-         data += bytes_read;
-         printf (_("offset: %s "),
-                 dwarf_vmatoa ("u", read_uleb128 (data, &bytes_read, end)));
-         data += bytes_read;
+         READ_ULEB (uvalue, data, end);
+         printf (_("size: %s "), dwarf_vmatoa ("u", uvalue));
+         READ_ULEB (uvalue, data, end);
+         printf (_("offset: %s "), dwarf_vmatoa ("u", uvalue));
          break;
 
          /* DWARF 4 extensions.  */
@@ -1430,8 +1394,7 @@ decode_location_expression (unsigned char * data,
 
        case DW_OP_implicit_value:
          printf ("DW_OP_implicit_value");
-         uvalue = read_uleb128 (data, &bytes_read, end);
-         data += bytes_read;
+         READ_ULEB (uvalue, data, end);
          data = display_block (data, uvalue, end, ' ');
          break;
 
@@ -1477,18 +1440,16 @@ decode_location_expression (unsigned char * data,
            {
              SAFE_BYTE_GET_AND_INC (uvalue, data, offset_size, end);
            }
+         READ_SLEB (svalue, data, end);
          printf ("%s: <0x%s> %s",
                  (op == DW_OP_implicit_pointer
                   ? "DW_OP_implicit_pointer" : "DW_OP_GNU_implicit_pointer"),
                  dwarf_vmatoa ("x", uvalue),
-                 dwarf_vmatoa ("d", read_sleb128 (data,
-                                                  &bytes_read, end)));
-         data += bytes_read;
+                 dwarf_vmatoa ("d", svalue));
          break;
        case DW_OP_entry_value:
        case DW_OP_GNU_entry_value:
-         uvalue = read_uleb128 (data, &bytes_read, end);
-         data += bytes_read;
+         READ_ULEB (uvalue, data, end);
          /* PR 17531: file: 0cc9cd00.  */
          if (uvalue > (dwarf_vma) (end - data))
            uvalue = end - data;
@@ -1505,8 +1466,7 @@ decode_location_expression (unsigned char * data,
          break;
        case DW_OP_const_type:
        case DW_OP_GNU_const_type:
-         uvalue = read_uleb128 (data, &bytes_read, end);
-         data += bytes_read;
+         READ_ULEB (uvalue, data, end);
          printf ("%s: <0x%s> ",
                  (op == DW_OP_const_type ? "DW_OP_const_type"
                                          : "DW_OP_GNU_const_type"),
@@ -1516,14 +1476,12 @@ decode_location_expression (unsigned char * data,
          break;
        case DW_OP_regval_type:
        case DW_OP_GNU_regval_type:
-         uvalue = read_uleb128 (data, &bytes_read, end);
-         data += bytes_read;
+         READ_ULEB (uvalue, data, end);
          printf ("%s: %s (%s)",
                  (op == DW_OP_regval_type ? "DW_OP_regval_type"
                                           : "DW_OP_GNU_regval_type"),
                  dwarf_vmatoa ("u", uvalue), regname (uvalue, 1));
-         uvalue = read_uleb128 (data, &bytes_read, end);
-         data += bytes_read;
+         READ_ULEB (uvalue, data, end);
          printf (" <0x%s>", dwarf_vmatoa ("x", cu_offset + uvalue));
          break;
        case DW_OP_deref_type:
@@ -1533,22 +1491,19 @@ decode_location_expression (unsigned char * data,
                  (op == DW_OP_deref_type ? "DW_OP_deref_type"
                                          : "DW_OP_GNU_deref_type"),
                  (long) uvalue);
-         uvalue = read_uleb128 (data, &bytes_read, end);
-         data += bytes_read;
+         READ_ULEB (uvalue, data, end);
          printf (" <0x%s>", dwarf_vmatoa ("x", cu_offset + uvalue));
          break;
        case DW_OP_convert:
        case DW_OP_GNU_convert:
-         uvalue = read_uleb128 (data, &bytes_read, end);
-         data += bytes_read;
+         READ_ULEB (uvalue, data, end);
          printf ("%s <0x%s>",
                  (op == DW_OP_convert ? "DW_OP_convert" : "DW_OP_GNU_convert"),
                  dwarf_vmatoa ("x", uvalue ? cu_offset + uvalue : 0));
          break;
        case DW_OP_reinterpret:
        case DW_OP_GNU_reinterpret:
-         uvalue = read_uleb128 (data, &bytes_read, end);
-         data += bytes_read;
+         READ_ULEB (uvalue, data, end);
          printf ("%s <0x%s>",
                  (op == DW_OP_reinterpret ? "DW_OP_reinterpret"
                                           : "DW_OP_GNU_reinterpret"),
@@ -1560,15 +1515,32 @@ decode_location_expression (unsigned char * data,
                  dwarf_vmatoa ("x", cu_offset + uvalue));
          break;
        case DW_OP_GNU_addr_index:
-         uvalue = read_uleb128 (data, &bytes_read, end);
-         data += bytes_read;
+         READ_ULEB (uvalue, data, end);
          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;
+         READ_ULEB (uvalue, data, end);
          printf ("DW_OP_GNU_const_index <0x%s>", dwarf_vmatoa ("x", uvalue));
          break;
+       case DW_OP_GNU_variable_value:
+         /* FIXME: Strictly speaking for 64-bit DWARF3 files
+            this ought to be an 8-byte wide computation.  */
+         if (dwarf_version == -1)
+           {
+             printf (_("(DW_OP_GNU_variable_value in frame info)"));
+             /* No way to tell where the next op is, so just bail.  */
+             return need_frame_base;
+           }
+         if (dwarf_version == 2)
+           {
+             SAFE_BYTE_GET_AND_INC (uvalue, data, pointer_size, end);
+           }
+         else
+           {
+             SAFE_BYTE_GET_AND_INC (uvalue, data, offset_size, end);
+           }
+         printf ("DW_OP_GNU_variable_value: <0x%s>", dwarf_vmatoa ("x", uvalue));
+         break;
 
          /* HP extensions.  */
        case DW_OP_HP_is_value:
@@ -1686,37 +1658,44 @@ add64 (dwarf_vma * high_bits, dwarf_vma * low_bits, dwarf_vma inc)
 static const char *
 fetch_alt_indirect_string (dwarf_vma offset)
 {
-  struct dwarf_section * section;
-  const char *           ret;
+  separate_info * i;
 
   if (! do_follow_links)
     return "";
 
-  if (separate_debug_file == NULL)
-    return _("<following link not possible>");
+  if (first_separate_info == NULL)
+    return _("<no links available>");
 
-  if (! load_debug_section (separate_debug_str, separate_debug_file))
-    return _("<could not load separate string section>");
+  for (i = first_separate_info; i != NULL; i = i->next)
+    {
+      struct dwarf_section * section;
+      const char *           ret;
 
-  section = &debug_displays [separate_debug_str].section;
-  if (section->start == NULL)
-    return  _("<no .debug_str section>");
+      if (! load_debug_section (separate_debug_str, i->handle))
+       continue;
 
-  if (offset >= section->size)
-    {
-      warn (_("DW_FORM_GNU_strp_alt offset too big: %s\n"), dwarf_vmatoa ("x", offset));
-      return _("<offset is too big>");
-    }
+      section = &debug_displays [separate_debug_str].section;
 
-  ret = (const char *) (section->start + offset);
-  /* Unfortunately we cannot rely upon the .debug_str section ending with a
-     NUL byte.  Since our caller is expecting to receive a well formed C
-     string we test for the lack of a terminating byte here.  */
-  if (strnlen ((const char *) ret, section->size - offset)
-      == section->size - offset)
-    return _("<no NUL byte at end of .debug_str section>");
+      if (section->start == NULL)
+       continue;
 
-  return ret;
+      if (offset >= section->size)
+       continue;
+
+      ret = (const char *) (section->start + offset);
+      /* Unfortunately we cannot rely upon the .debug_str section ending with a
+        NUL byte.  Since our caller is expecting to receive a well formed C
+        string we test for the lack of a terminating byte here.  */
+      if (strnlen ((const char *) ret, section->size - offset)
+         == section->size - offset)
+       return _("<no NUL byte at end of alt .debug_str section>");
+
+      return ret;
+    }
+  
+  warn (_("DW_FORM_GNU_strp_alt offset (%s) too big or no string sections available\n"),
+       dwarf_vmatoa ("x", offset));
+  return _("<offset is too big>");
 }
        
 static const char *
@@ -1745,10 +1724,391 @@ get_AT_name (unsigned long attribute)
   return name;
 }
 
+static void
+add_dwo_info (const char * field, dwo_type type)
+{
+  dwo_info * dwinfo = xmalloc (sizeof * dwinfo);
+
+  dwinfo->type = type;
+  dwinfo->value = field;
+  dwinfo->next = first_dwo_info;
+  first_dwo_info = dwinfo;
+}
+
+static void
+add_dwo_name (const char * name)
+{
+  add_dwo_info (name, DWO_NAME);
+}
+
+static void
+add_dwo_dir (const char * dir)
+{
+  add_dwo_info (dir, DWO_DIR);
+}
+
+static void
+add_dwo_id (const char * id)
+{
+  add_dwo_info (id, DWO_ID);
+}
+
+static void
+free_dwo_info (void)
+{
+  dwo_info * dwinfo;
+  dwo_info * next;
+
+  for (dwinfo = first_dwo_info; dwinfo != NULL; dwinfo = next)
+    {
+      next = dwinfo->next;
+      free (dwinfo);
+    }
+  first_dwo_info = NULL;
+}
+
+/* Ensure that START + UVALUE is less than END.
+   Return an adjusted UVALUE if necessary to ensure this relationship.  */
+
+static inline dwarf_vma
+check_uvalue (const unsigned char * start,
+             dwarf_vma             uvalue,
+             const unsigned char * end)
+{
+  dwarf_vma max_uvalue = end - start;
+
+  /* See PR 17512: file: 008-103549-0.001:0.1.
+     and PR 24829 for examples of where these tests are triggered.  */
+  if (uvalue > max_uvalue)
+    {
+      warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue);
+      uvalue = max_uvalue;
+    }
+
+  return uvalue;
+}
+
+static unsigned char *
+skip_attr_bytes (unsigned long          form,
+                unsigned char *        data,
+                unsigned const char *  end,
+                dwarf_vma              pointer_size,
+                dwarf_vma              offset_size,
+                int                    dwarf_version,
+                dwarf_vma *            value_return)
+{
+  dwarf_signed_vma svalue;
+  dwarf_vma uvalue = 0;
+
+  * value_return = 0;
+
+  switch (form)
+    {
+    case DW_FORM_ref_addr:
+      if (dwarf_version == 2)
+       SAFE_BYTE_GET_AND_INC (uvalue, data, pointer_size, end);
+      else if (dwarf_version == 3 || dwarf_version == 4)
+       SAFE_BYTE_GET_AND_INC (uvalue, data, offset_size, end);
+      else
+       return NULL;
+      break;
+
+    case DW_FORM_addr:
+      SAFE_BYTE_GET_AND_INC (uvalue, data, pointer_size, end);
+      break;
+
+    case DW_FORM_strp:
+    case DW_FORM_line_strp:
+    case DW_FORM_sec_offset:
+    case DW_FORM_GNU_ref_alt:
+    case DW_FORM_GNU_strp_alt:
+      SAFE_BYTE_GET_AND_INC (uvalue, data, offset_size, end);
+      break;
+
+    case DW_FORM_flag_present:
+      uvalue = 1;
+      break;
+
+    case DW_FORM_ref1:
+    case DW_FORM_flag:
+    case DW_FORM_data1:
+      SAFE_BYTE_GET_AND_INC (uvalue, data, 1, end);
+      break;
+
+    case DW_FORM_ref2:
+    case DW_FORM_data2:
+      SAFE_BYTE_GET_AND_INC (uvalue, data, 2, end);
+      break;
+
+    case DW_FORM_ref4:
+    case DW_FORM_data4:
+      SAFE_BYTE_GET_AND_INC (uvalue, data, 4, end);
+      break;
+
+    case DW_FORM_sdata:
+      READ_SLEB (svalue, data, end);
+      uvalue = svalue;
+      break;
+
+    case DW_FORM_ref_udata:
+    case DW_FORM_udata:
+    case DW_FORM_GNU_str_index:
+    case DW_FORM_GNU_addr_index:
+      READ_ULEB (uvalue, data, end);
+      break;
+
+    case DW_FORM_ref8:
+    case DW_FORM_data8:
+      data += 8;
+      break;
+
+    case DW_FORM_data16:
+      data += 16;
+      break;
+
+    case DW_FORM_string:
+      data += strnlen ((char *) data, end - data) + 1;
+      break;
+
+    case DW_FORM_block:
+    case DW_FORM_exprloc:
+      READ_ULEB (uvalue, data, end);
+      break;
+
+    case DW_FORM_block1:
+      SAFE_BYTE_GET (uvalue, data, 1, end);
+      data += 1 + uvalue;
+      break;
+
+    case DW_FORM_block2:
+      SAFE_BYTE_GET (uvalue, data, 2, end);
+      data += 2 + uvalue;
+      break;
+
+    case DW_FORM_block4:
+      SAFE_BYTE_GET (uvalue, data, 4, end);
+      data += 4 + uvalue;
+      break;
+
+    case DW_FORM_ref_sig8:
+      data += 8;
+      break;
+
+    case DW_FORM_indirect:
+      /* FIXME: Handle this form.  */
+    default:
+      return NULL;
+    }
+
+  * value_return = uvalue;
+  if (data > end)
+    data = (unsigned char *) end;
+  return data;
+}
+
+/* Return IS_SIGNED set to TRUE if the type at
+   DATA can be determined to be a signed type.  */
+
+static void
+get_type_signedness (unsigned char *        start,
+                    unsigned char *        data,
+                    unsigned const char *  end,
+                    dwarf_vma              pointer_size,
+                    dwarf_vma              offset_size,
+                    int                    dwarf_version,
+                    bfd_boolean *          is_signed,
+                    bfd_boolean            is_nested)
+{
+  unsigned long   abbrev_number;
+  abbrev_entry *  entry;
+  abbrev_attr *   attr;
+
+  * is_signed = FALSE;
+
+  READ_ULEB (abbrev_number, data, end);
+
+  for (entry = first_abbrev;
+       entry != NULL && entry->entry != abbrev_number;
+       entry = entry->next)
+    continue;
+
+  if (entry == NULL)
+    /* FIXME: Issue a warning ?  */
+    return;
+
+  for (attr = entry->first_attr;
+       attr != NULL && attr->attribute;
+       attr = attr->next)
+    {
+      dwarf_vma uvalue = 0;
+
+      data = skip_attr_bytes (attr->form, data, end, pointer_size,
+                             offset_size, dwarf_version, & uvalue);
+      if (data == NULL)
+       return;
+
+      switch (attr->attribute)
+       {
+#if 0 /* FIXME: It would be nice to print the name of the type,
+        but this would mean updating a lot of binutils tests.  */
+       case DW_AT_name:
+         if (attr->form == DW_FORM_strp)
+           printf ("%s", fetch_indirect_string (uvalue));
+         break;
+#endif
+       case DW_AT_type:
+         /* Recurse.  */
+         if (is_nested)
+           {
+             /* FIXME: Warn - or is this expected ?
+                NB/ We need to avoid infinite recursion.  */
+             return;
+           }
+         if (uvalue >= (size_t) (end - start))
+           return;
+         get_type_signedness (start, start + uvalue, end, pointer_size,
+                              offset_size, dwarf_version, is_signed, TRUE);
+         break;
+
+       case DW_AT_encoding:
+         /* Determine signness.  */
+         switch (uvalue)
+           {
+           case DW_ATE_address:
+             /* FIXME - some architectures have signed addresses.  */
+           case DW_ATE_boolean:
+           case DW_ATE_unsigned:
+           case DW_ATE_unsigned_char:
+           case DW_ATE_unsigned_fixed:
+             * is_signed = FALSE;
+             break;
+
+           default:
+           case DW_ATE_complex_float:
+           case DW_ATE_float:
+           case DW_ATE_signed:
+           case DW_ATE_signed_char:
+           case DW_ATE_imaginary_float:
+           case DW_ATE_decimal_float:
+           case DW_ATE_signed_fixed:
+             * is_signed = TRUE;
+             break;
+           }
+         break;
+       }
+    }
+}
+
+static void
+read_and_print_leb128 (unsigned char *        data,
+                      unsigned int *         bytes_read,
+                      unsigned const char *  end,
+                      bfd_boolean            is_signed)
+{
+  int status;
+  dwarf_vma val = read_leb128 (data, end, is_signed, bytes_read, &status);
+  if (status != 0)
+    report_leb_status (status, __FILE__, __LINE__);
+  else
+    printf ("%s", dwarf_vmatoa (is_signed ? "d" : "u", val));
+}
+
+static void
+display_discr_list (unsigned long          form,
+                   dwarf_vma              uvalue,
+                   unsigned char *        data,
+                   unsigned const char *  end,
+                   int                    level)
+{
+  if (uvalue == 0)
+    {
+      printf ("[default]");
+      return;
+    }
+  
+  switch (form)
+    {
+    case DW_FORM_block:
+    case DW_FORM_block1:
+    case DW_FORM_block2:
+    case DW_FORM_block4:
+      /* Move data pointer back to the start of the byte array.  */
+      data -= uvalue;
+      break;
+    default:
+      printf ("<corrupt>\n");
+      warn (_("corrupt discr_list - not using a block form\n"));
+      return;
+    }
+
+  if (uvalue < 2)
+    {
+      printf ("<corrupt>\n");
+      warn (_("corrupt discr_list - block not long enough\n"));
+      return;
+    }
+
+  bfd_boolean is_signed =
+    (level > 0 && level <= MAX_CU_NESTING)
+    ? level_type_signed [level - 1] : FALSE;
+    
+  printf ("(");
+  while (uvalue)
+    {
+      unsigned char     discriminant;
+      unsigned int      bytes_read;
+
+      SAFE_BYTE_GET (discriminant, data, 1, end);
+      -- uvalue;
+      data ++;
+
+      assert (uvalue > 0);
+      switch (discriminant)
+       {
+       case DW_DSC_label:
+         printf ("label ");
+         read_and_print_leb128 (data, & bytes_read, end, is_signed);
+         assert (bytes_read <= uvalue && bytes_read > 0);
+         uvalue -= bytes_read;
+         data += bytes_read;
+         break;
+
+       case DW_DSC_range:
+         printf ("range ");
+         read_and_print_leb128 (data, & bytes_read, end, is_signed);
+         assert (bytes_read <= uvalue && bytes_read > 0);
+         uvalue -= bytes_read;
+         data += bytes_read;
+
+         printf ("..");
+         read_and_print_leb128 (data, & bytes_read, end, is_signed);
+         assert (bytes_read <= uvalue && bytes_read > 0);
+         uvalue -= bytes_read;
+         data += bytes_read;
+         break;
+
+       default:
+         printf ("<corrupt>\n");
+         warn (_("corrupt discr_list - unrecognised discriminant byte %#x\n"),
+               discriminant);
+         return;
+       }
+
+      if (uvalue)
+       printf (", ");
+    }
+
+  if (is_signed)
+    printf (")(signed)");
+  else
+    printf (")(unsigned)");
+}
+
 static unsigned char *
 read_and_display_attr_value (unsigned long           attribute,
                             unsigned long           form,
                             dwarf_signed_vma        implicit_const,
+                            unsigned char *         start,
                             unsigned char *         data,
                             unsigned char *         end,
                             dwarf_vma               cu_offset,
@@ -1759,12 +2119,13 @@ read_and_display_attr_value (unsigned long           attribute,
                             int                     do_loc,
                             struct dwarf_section *  section,
                             struct cu_tu_set *      this_set,
-                            char                    delimiter)
+                            char                    delimiter,
+                            int                     level)
 {
-  dwarf_vma uvalue = 0;
-  unsigned char *block_start = NULL;
-  unsigned char * orig_data = data;
-  unsigned int bytes_read;
+  dwarf_signed_vma svalue;
+  dwarf_vma        uvalue = 0;
+  unsigned char *  block_start = NULL;
+  unsigned char *  orig_data = data;
 
   if (data > end || (data == end && form != DW_FORM_flag_present))
     {
@@ -1820,40 +2181,29 @@ read_and_display_attr_value (unsigned long           attribute,
       break;
 
     case DW_FORM_sdata:
-      uvalue = read_sleb128 (data, & bytes_read, end);
-      data += bytes_read;
+      READ_SLEB (svalue, data, end);
+      uvalue = svalue;
       break;
 
     case DW_FORM_GNU_str_index:
-      uvalue = read_uleb128 (data, & bytes_read, end);
-      data += bytes_read;
-      break;
-
     case DW_FORM_ref_udata:
     case DW_FORM_udata:
-      uvalue = read_uleb128 (data, & bytes_read, end);
-      data += bytes_read;
+    case DW_FORM_GNU_addr_index:
+      READ_ULEB (uvalue, data, end);
       break;
 
     case DW_FORM_indirect:
-      form = read_uleb128 (data, & bytes_read, end);
-      data += bytes_read;
+      READ_ULEB (form, data, end);
       if (!do_loc)
        printf ("%c%s", delimiter, get_FORM_name (form));
       if (form == DW_FORM_implicit_const)
-       {
-         implicit_const = read_sleb128 (data, & bytes_read, end);
-         data += bytes_read;
-       }
-      return read_and_display_attr_value (attribute, form, implicit_const, data,
-                                         end, cu_offset, pointer_size,
+       READ_SLEB (implicit_const, data, end);
+      return read_and_display_attr_value (attribute, form, implicit_const,
+                                         start, data, end,
+                                         cu_offset, pointer_size,
                                          offset_size, dwarf_version,
                                          debug_info_p, do_loc,
-                                         section, this_set, delimiter);
-    case DW_FORM_GNU_addr_index:
-      uvalue = read_uleb128 (data, & bytes_read, end);
-      data += bytes_read;
-      break;
+                                         section, this_set, delimiter, level);
     }
 
   switch (form)
@@ -1961,24 +2311,18 @@ read_and_display_attr_value (unsigned long           attribute,
 
     case DW_FORM_block:
     case DW_FORM_exprloc:
-      uvalue = read_uleb128 (data, & bytes_read, end);
-      block_start = data + bytes_read;
+      READ_ULEB (uvalue, data, end);
+    do_block:
+      block_start = data;
       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 || data < block_start)
-       {
-         warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue);
-         uvalue = end - block_start;
-       }
+
+      uvalue = check_uvalue (block_start, uvalue, end);
+
       if (do_loc)
        data = block_start + uvalue;
       else
@@ -1986,70 +2330,16 @@ read_and_display_attr_value (unsigned long           attribute,
       break;
 
     case DW_FORM_block1:
-      SAFE_BYTE_GET (uvalue, data, 1, end);
-      block_start = data + 1;
-      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;
-       }
-      if (do_loc)
-       data = block_start + uvalue;
-      else
-       data = display_block (block_start, uvalue, end, delimiter);
-      break;
+      SAFE_BYTE_GET_AND_INC (uvalue, data, 1, end);
+      goto do_block;
 
     case DW_FORM_block2:
-      SAFE_BYTE_GET (uvalue, data, 2, end);
-      block_start = data + 2;
-      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;
-       }
-      if (do_loc)
-       data = block_start + uvalue;
-      else
-       data = display_block (block_start, uvalue, end, delimiter);
-      break;
+      SAFE_BYTE_GET_AND_INC (uvalue, data, 2, end);
+      goto do_block;
 
     case DW_FORM_block4:
-      SAFE_BYTE_GET (uvalue, data, 4, end);
-      block_start = data + 4;
-      /* 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;
-       }
-      if (do_loc)
-       data = block_start + uvalue;
-      else
-       data = display_block (block_start, uvalue, end, delimiter);
-      break;
+      SAFE_BYTE_GET_AND_INC (uvalue, data, 4, end);
+      goto do_block;
 
     case DW_FORM_strp:
       if (!do_loc)
@@ -2168,19 +2458,28 @@ read_and_display_attr_value (unsigned long           attribute,
              debug_info_p->have_frame_base [num] = have_frame_base;
              if (attribute != DW_AT_GNU_locviews)
                {
-                 debug_info_p->loc_offsets [num] = uvalue;
-                 debug_info_p->num_loc_offsets++;
-                 assert (debug_info_p->num_loc_offsets
-                         - debug_info_p->num_loc_views <= 1);
+                 /* Corrupt DWARF info can produce more offsets than views.
+                    See PR 23062 for an example.  */
+                 if (debug_info_p->num_loc_offsets
+                     > debug_info_p->num_loc_views)
+                   warn (_("More location offset attributes than DW_AT_GNU_locview attributes\n"));
+                 else
+                   {
+                     debug_info_p->loc_offsets [num] = uvalue;
+                     debug_info_p->num_loc_offsets++;
+                   }
                }
              else
                {
                  assert (debug_info_p->num_loc_views <= num);
                  num = debug_info_p->num_loc_views;
-                 debug_info_p->loc_views [num] = uvalue;
-                 debug_info_p->num_loc_views++;
-                 assert (debug_info_p->num_loc_views
-                         - debug_info_p->num_loc_offsets <= 1);
+                 if (num > debug_info_p->num_loc_offsets)
+                   warn (_("More DW_AT_GNU_locview attributes than location offset attributes\n"));
+                 else
+                   {
+                     debug_info_p->loc_views [num] = uvalue;
+                     debug_info_p->num_loc_views++;
+                   }
                }
            }
          break;
@@ -2226,18 +2525,17 @@ read_and_display_attr_value (unsigned long           attribute,
            switch (form)
              {
              case DW_FORM_strp:
-               dwo_name = (const char *) fetch_indirect_string (uvalue);
+               add_dwo_name ((const char *) fetch_indirect_string (uvalue));
                break;
              case DW_FORM_GNU_str_index:
-               dwo_name = fetch_indexed_string (uvalue, this_set, offset_size, FALSE);
+               add_dwo_name (fetch_indexed_string (uvalue, this_set, offset_size, FALSE));
                break;
              case DW_FORM_string:
-               dwo_name = (const char *) orig_data;
+               add_dwo_name ((const char *) orig_data);
                break;
              default:
                warn (_("Unsupported form (%s) for attribute %s\n"),
                      get_FORM_name (form), get_AT_name (attribute));
-               dwo_name = _("<unknown>");
                break;
              }
          break;
@@ -2248,21 +2546,20 @@ read_and_display_attr_value (unsigned long           attribute,
            switch (form)
              {
              case DW_FORM_strp:
-               dwo_dir = (const char *) fetch_indirect_string (uvalue);
+               add_dwo_dir ((const char *) fetch_indirect_string (uvalue));
                break;
              case DW_FORM_line_strp:
-               dwo_dir = (const char *) fetch_indirect_line_string (uvalue);
+               add_dwo_dir ((const char *) fetch_indirect_line_string (uvalue));
                break;
              case DW_FORM_GNU_str_index:
-               dwo_dir = fetch_indexed_string (uvalue, this_set, offset_size, FALSE);
+               add_dwo_dir (fetch_indexed_string (uvalue, this_set, offset_size, FALSE));
                break;
              case DW_FORM_string:
-               dwo_dir = (const char *) orig_data;
+               add_dwo_dir ((const char *) orig_data);
                break;
              default:
                warn (_("Unsupported form (%s) for attribute %s\n"),
                      get_FORM_name (form), get_AT_name (attribute));
-               dwo_dir = _("<unknown>");
                break;
              }
          break;
@@ -2272,13 +2569,12 @@ read_and_display_attr_value (unsigned long           attribute,
            switch (form)
              {
              case DW_FORM_data8:
-               dwo_id = data - 8;
-               dwo_id_len = 8;
+               /* FIXME: Record the length of the ID as well ?  */
+               add_dwo_id ((const char *) (data - 8));
                break;
              default:
                warn (_("Unsupported form (%s) for attribute %s\n"),
                      get_FORM_name (form), get_AT_name (attribute));
-               dwo_id = NULL;
                break;
              }
          break;
@@ -2294,6 +2590,18 @@ read_and_display_attr_value (unsigned long           attribute,
   /* For some attributes we can display further information.  */
   switch (attribute)
     {
+    case DW_AT_type:
+      if (level >= 0 && level < MAX_CU_NESTING
+         && uvalue < (size_t) (end - start))
+       {
+         bfd_boolean is_signed = FALSE;
+
+         get_type_signedness (start, start + uvalue, end, pointer_size,
+                              offset_size, dwarf_version, & is_signed, FALSE);
+         level_type_signed[level] = is_signed;
+       }
+      break;
+      
     case DW_AT_inline:
       printf ("\t");
       switch (uvalue)
@@ -2346,12 +2654,22 @@ read_and_display_attr_value (unsigned long           attribute,
          /* DWARF 4 values.  */
        case DW_LANG_Python:            printf ("(Python)"); break;
          /* DWARF 5 values.  */
+       case DW_LANG_OpenCL:            printf ("(OpenCL)"); break;
        case DW_LANG_Go:                printf ("(Go)"); break;
+       case DW_LANG_Modula3:           printf ("(Modula 3)"); break;
+       case DW_LANG_Haskell:           printf ("(Haskell)"); break;
+       case DW_LANG_C_plus_plus_03:    printf ("(C++03)"); break;
        case DW_LANG_C_plus_plus_11:    printf ("(C++11)"); break;
+       case DW_LANG_OCaml:             printf ("(OCaml)"); break;
+       case DW_LANG_Rust:              printf ("(Rust)"); break;
        case DW_LANG_C11:               printf ("(C11)"); break;
+       case DW_LANG_Swift:             printf ("(Swift)"); break;
+       case DW_LANG_Julia:             printf ("(Julia)"); break;
+       case DW_LANG_Dylan:             printf ("(Dylan)"); break;
        case DW_LANG_C_plus_plus_14:    printf ("(C++14)"); break;
        case DW_LANG_Fortran03:         printf ("(Fortran 03)"); break;
        case DW_LANG_Fortran08:         printf ("(Fortran 08)"); break;
+       case DW_LANG_RenderScript:      printf ("(RenderScript)"); break;
          /* MIPS extension.  */
        case DW_LANG_Mips_Assembler:    printf ("(MIPS assembler)"); break;
          /* UPC extension.  */
@@ -2533,12 +2851,7 @@ read_and_display_attr_value (unsigned long           attribute,
 
     case DW_AT_discr_list:
       printf ("\t");
-      switch (uvalue)
-       {
-       case DW_DSC_label:  printf (_("(label)")); break;
-       case DW_DSC_range:  printf (_("(range)")); break;
-       default:            printf (_("(unrecognised)")); break;
-       }
+      display_discr_list (form, uvalue, data, end, level);
       break;
       
     case DW_AT_frame_base:
@@ -2623,9 +2936,10 @@ read_and_display_attr_value (unsigned long           attribute,
        else
          {
            unsigned long abbrev_number;
-           abbrev_entry * entry;
+           abbrev_entry *entry;
+           unsigned char *p = section->start + uvalue;
 
-           abbrev_number = read_uleb128 (section->start + uvalue, NULL, end);
+           READ_ULEB (abbrev_number, p, end);
 
            printf (_("\t[Abbrev Number: %ld"), abbrev_number);
            /* Don't look up abbrev for DW_FORM_ref_addr, as it very often will
@@ -2655,6 +2969,7 @@ static unsigned char *
 read_and_display_attr (unsigned long           attribute,
                       unsigned long           form,
                       dwarf_signed_vma        implicit_const,
+                      unsigned char *         start,
                       unsigned char *         data,
                       unsigned char *         end,
                       dwarf_vma               cu_offset,
@@ -2664,44 +2979,63 @@ read_and_display_attr (unsigned long           attribute,
                       debug_info *            debug_info_p,
                       int                     do_loc,
                       struct dwarf_section *  section,
-                      struct cu_tu_set *      this_set)
+                      struct cu_tu_set *      this_set,
+                      int                     level)
 {
   if (!do_loc)
     printf ("   %-18s:", get_AT_name (attribute));
-  data = read_and_display_attr_value (attribute, form, implicit_const, data, end,
+  data = read_and_display_attr_value (attribute, form, implicit_const,
+                                     start, data, end,
                                      cu_offset, pointer_size, offset_size,
                                      dwarf_version, debug_info_p,
-                                     do_loc, section, this_set, ' ');
+                                     do_loc, section, this_set, ' ', level);
   if (!do_loc)
     printf ("\n");
   return data;
 }
 
 /* Like load_debug_section, but if the ordinary call fails, and we are
-   following debug links, and we have been able to load a separate debug
-   info file, then attempt to load the requested section from the separate
-   file.  */
+   following debug links, then attempt to load the requested section
+   from one of the separate debug info files.  */
 
 static bfd_boolean
 load_debug_section_with_follow (enum dwarf_section_display_enum sec_enum,
-                               void * data)
+                               void * handle)
 {
-  if (load_debug_section (sec_enum, data))
+  if (load_debug_section (sec_enum, handle))
     {
-      if (data == separate_debug_file)
-       debug_displays[sec_enum].section.filename = separate_debug_filename;
-       
-      /* FIXME: We should check to see if there is a separate debug info file
-        that also contains this section, and if so, issue a warning.  */
+      if (debug_displays[sec_enum].section.filename == NULL)
+       {
+         /* See if we can associate a filename with this section.  */
+         separate_info * i;
+
+         for (i = first_separate_info; i != NULL; i = i->next)
+           if (i->handle == handle)
+             {
+               debug_displays[sec_enum].section.filename = i->filename;
+               break;
+             }
+       }
+
       return TRUE;
     }
 
-  if (do_follow_links && separate_debug_file != NULL)
-    if (load_debug_section (sec_enum, separate_debug_file))
-      {
-       debug_displays[sec_enum].section.filename = separate_debug_filename;
-       return TRUE;
-      }
+  if (do_follow_links)
+    {
+      separate_info * i;
+
+      for (i = first_separate_info; i != NULL; i = i->next)
+       {
+         if (load_debug_section (sec_enum, i->handle))
+           {
+             debug_displays[sec_enum].section.filename = i->filename;
+
+             /* FIXME: We should check to see if any of the remaining debug info
+                files also contain this section, and, umm, do something about it.  */
+             return TRUE;
+           }
+       }
+    }
 
   return FALSE;
 }
@@ -3050,7 +3384,6 @@ process_debug_info (struct dwarf_section *           section,
       saved_level = -1;
       while (tags < start)
        {
-         unsigned int bytes_read;
          unsigned long abbrev_number;
          unsigned long die_offset;
          abbrev_entry *entry;
@@ -3059,8 +3392,7 @@ process_debug_info (struct dwarf_section *           section,
 
          die_offset = tags - section_begin;
 
-         abbrev_number = read_uleb128 (tags, & bytes_read, start);
-         tags += bytes_read;
+         READ_ULEB (abbrev_number, tags, start);
 
          /* A null DIE marks the end of a list of siblings or it may also be
             a section padding.  */
@@ -3177,10 +3509,10 @@ process_debug_info (struct dwarf_section *           section,
              if (! do_loc && do_printing)
                /* Show the offset from where the tag was extracted.  */
                printf ("    <%lx>", (unsigned long)(tags - section_begin));
-
              tags = read_and_display_attr (attr->attribute,
                                            attr->form,
                                            attr->implicit_const,
+                                           section_begin,
                                            tags,
                                            end,
                                            cu_offset,
@@ -3190,7 +3522,8 @@ process_debug_info (struct dwarf_section *           section,
                                            debug_info_p,
                                            do_loc || ! do_printing,
                                            section,
-                                           this_set);
+                                           this_set,
+                                           level);
            }
 
          /* If a locview attribute appears before a location one,
@@ -3289,7 +3622,6 @@ read_debug_line_header (struct dwarf_section * section,
 {
   unsigned char *hdrptr;
   unsigned int initial_length_size;
-  unsigned char address_size, segment_selector_size;
 
   /* Extract information from the Line Number Program Header.
      (section 6.2.4 in the Dwarf3 doc).  */
@@ -3346,15 +3678,15 @@ read_debug_line_header (struct dwarf_section * section,
 
   if (linfo->li_version >= 5)
     {
-      SAFE_BYTE_GET_AND_INC (address_size, hdrptr, 1, end);
+      SAFE_BYTE_GET_AND_INC (linfo->li_address_size, hdrptr, 1, end);
 
-      SAFE_BYTE_GET_AND_INC (segment_selector_size, hdrptr, 1, end);
-      if (segment_selector_size != 0)
+      SAFE_BYTE_GET_AND_INC (linfo->li_segment_size, hdrptr, 1, end);
+      if (linfo->li_segment_size != 0)
        {
          warn (_("The %s section contains "
                  "unsupported segment selector size: %d.\n"),
-               section->name, segment_selector_size);
-         return 0;
+               section->name, linfo->li_segment_size);
+         return NULL;
        }
     }
 
@@ -3399,43 +3731,48 @@ display_formatted_table (unsigned char *                   data,
                         unsigned char *                   end,
                         const DWARF2_Internal_LineInfo *  linfo,
                         struct dwarf_section *            section,
-                        const char *                      what)
+                        bfd_boolean                       is_dir)
 {
   unsigned char *format_start, format_count, *format, formati;
   dwarf_vma data_count, datai;
-  unsigned int bytes_read, namepass, last_entry = 0;
-
+  unsigned int namepass, last_entry = 0;
+  const char * table_name = is_dir ? N_("Directory Table") : N_("File Name Table");
+  
   SAFE_BYTE_GET_AND_INC (format_count, data, 1, end);
   format_start = data;
   for (formati = 0; formati < format_count; formati++)
     {
-      read_uleb128 (data, & bytes_read, end);
-      data += bytes_read;
-      read_uleb128 (data, & bytes_read, end);
-      data += bytes_read;
+      SKIP_ULEB (data, end);
+      SKIP_ULEB (data, end);
       if (data == end)
        {
-         warn (_("Corrupt %s format table entry\n"), what);
+         warn (_("%s: Corrupt format description entry\n"), table_name);
          return data;
        }
     }
 
-  data_count = read_uleb128 (data, & bytes_read, end);
-  data += bytes_read;
+  READ_ULEB (data_count, data, end);
   if (data == end)
     {
-      warn (_("Corrupt %s list\n"), what);
+      warn (_("%s: Corrupt entry count\n"), table_name);
       return data;
     }
 
   if (data_count == 0)
     {
-      printf (_("\n The %s Table is empty.\n"), what);
+      printf (_("\n The %s is empty.\n"), table_name);
       return data;
     }
+  else if (format_count == 0)
+    {
+      warn (_("%s: format count is zero, but the table is not empty\n"),
+           table_name);
+      return end;
+    }
 
-  printf (_("\n The %s Table (offset 0x%lx):\n"), what,
-         (long)(data - start));
+  printf (_("\n The %s (offset 0x%lx, lines %s, columns %u):\n"),
+         table_name, (long) (data - start), dwarf_vmatoa ("u", data_count),
+         format_count);
 
   printf (_("  Entry"));
   /* Delay displaying name as the last entry for better screen layout.  */ 
@@ -3446,8 +3783,7 @@ display_formatted_table (unsigned char *                   data,
        {
          dwarf_vma content_type;
 
-         content_type = read_uleb128 (format, & bytes_read, end);
-         format += bytes_read;
+         READ_ULEB (content_type, format, end);
          if ((content_type == DW_LNCT_path) == (namepass == 1))
            switch (content_type)
              {
@@ -3464,14 +3800,13 @@ display_formatted_table (unsigned char *                   data,
                printf (_("\tSize"));
                break;
              case DW_LNCT_MD5:
-               printf (_("\tMD5"));
+               printf (_("\tMD5\t\t\t"));
                break;
              default:
                printf (_("\t(Unknown format content type %s)"),
                        dwarf_vmatoa ("u", content_type));
              }
-         read_uleb128 (format, & bytes_read, end);
-         format += bytes_read;
+         SKIP_ULEB (format, end);
        }
     }
   putchar ('\n');
@@ -3490,20 +3825,19 @@ display_formatted_table (unsigned char *                   data,
            {
              dwarf_vma content_type, form;
 
-             content_type = read_uleb128 (format, & bytes_read, end);
-             format += bytes_read;
-             form = read_uleb128 (format, & bytes_read, end);
-             format += bytes_read;
-             data = read_and_display_attr_value (0, form, 0, data, end, 0, 0,
-                                                 linfo->li_offset_size,
+             READ_ULEB (content_type, format, end);
+             READ_ULEB (form, format, end);
+             data = read_and_display_attr_value (0, form, 0, start, data, end,
+                                                 0, 0, linfo->li_offset_size,
                                                  linfo->li_version, NULL,
                            ((content_type == DW_LNCT_path) != (namepass == 1)),
-                                                 section, NULL, '\t');
+                                                 section, NULL, '\t', -1);
            }
        }
-      if (data == end)
+
+      if (data == end && (datai < data_count - 1))
        {
-         warn (_("Corrupt %s entries list\n"), what);
+         warn (_("\n%s: Corrupt entries list\n"), table_name);
          return data;
        }
       putchar ('\n');
@@ -3567,6 +3901,11 @@ 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);
+         if (linfo.li_version >= 5)
+           {
+             printf (_("  Address size (bytes):        %d\n"), linfo.li_address_size);
+             printf (_("  Segment selector (bytes):    %d\n"), linfo.li_segment_size);
+           }
          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)
@@ -3611,9 +3950,9 @@ display_debug_lines_raw (struct dwarf_section *  section,
              load_debug_section_with_follow (line_str, file);
 
              data = display_formatted_table (data, start, end, &linfo, section,
-                                             _("Directory"));
+                                             TRUE);
              data = display_formatted_table (data, start, end, &linfo, section,
-                                             _("File name"));
+                                             FALSE);
            }
          else
            {
@@ -3653,21 +3992,18 @@ display_debug_lines_raw (struct dwarf_section *  section,
                  while (data < end && *data != 0)
                    {
                      unsigned char *name;
-                     unsigned int bytes_read;
+                     dwarf_vma val;
 
                      printf ("  %d\t", ++state_machine_regs.last_file_entry);
                      name = data;
                      data += strnlen ((char *) data, end - data) + 1;
 
-                     printf ("%s\t",
-                             dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
-                     data += bytes_read;
-                     printf ("%s\t",
-                             dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
-                     data += bytes_read;
-                     printf ("%s\t",
-                             dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
-                     data += bytes_read;
+                     READ_ULEB (val, data, end);
+                     printf ("%s\t", dwarf_vmatoa ("u", val));
+                     READ_ULEB (val, data, end);
+                     printf ("%s\t", dwarf_vmatoa ("u", val));
+                     READ_ULEB (val, data, end);
+                     printf ("%s\t", dwarf_vmatoa ("u", val));
                      printf ("%.*s\n", (int)(end - name), name);
 
                      if (data == end)
@@ -3698,7 +4034,6 @@ display_debug_lines_raw (struct dwarf_section *  section,
              unsigned char op_code;
              dwarf_signed_vma adv;
              dwarf_vma uladv;
-             unsigned int bytes_read;
 
              printf ("  [0x%08lx]", (long)(data - start));
 
@@ -3752,169 +4087,166 @@ display_debug_lines_raw (struct dwarf_section *  section,
                    putchar ('\n');
                  state_machine_regs.view++;
                }
-             else switch (op_code)
-                    {
-                    case DW_LNS_extended_op:
-                      data += process_extended_line_op (data, linfo.li_default_is_stmt, end);
-                      break;
-
-                    case DW_LNS_copy:
-                      printf (_("  Copy"));
-                      if (verbose_view || state_machine_regs.view)
-                        printf (_(" (view %u)\n"), state_machine_regs.view);
-                      else
-                        putchar ('\n');
-                      state_machine_regs.view++;
-                      break;
-
-                    case DW_LNS_advance_pc:
-                      uladv = read_uleb128 (data, & bytes_read, end);
-                      data += bytes_read;
-                      if (linfo.li_max_ops_per_insn == 1)
-                        {
-                          uladv *= linfo.li_min_insn_length;
-                          state_machine_regs.address += uladv;
-                          if (uladv)
-                            state_machine_regs.view = 0;
-                          printf (_("  Advance PC by %s to 0x%s%s\n"),
-                                  dwarf_vmatoa ("u", uladv),
-                                  dwarf_vmatoa ("x", state_machine_regs.address),
-                                  verbose_view && uladv
-                                  ? _(" (reset view)") : "");
-                        }
-                      else
-                        {
-                          unsigned addrdelta
-                            = ((state_machine_regs.op_index + uladv)
-                               / linfo.li_max_ops_per_insn)
-                            * linfo.li_min_insn_length;
-                          state_machine_regs.address
-                            += addrdelta;
-                          state_machine_regs.op_index
-                            = (state_machine_regs.op_index + uladv)
-                            % linfo.li_max_ops_per_insn;
-                          if (addrdelta)
-                            state_machine_regs.view = 0;
-                          printf (_("  Advance PC by %s to 0x%s[%d]%s\n"),
-                                  dwarf_vmatoa ("u", uladv),
-                                  dwarf_vmatoa ("x", state_machine_regs.address),
-                                  state_machine_regs.op_index,
-                                  verbose_view && addrdelta
-                                  ? _(" (reset view)") : "");
-                        }
-                      break;
-
-                    case DW_LNS_advance_line:
-                      adv = read_sleb128 (data, & bytes_read, end);
-                      data += bytes_read;
-                      state_machine_regs.line += adv;
-                      printf (_("  Advance Line by %s to %d\n"),
-                              dwarf_vmatoa ("d", adv),
-                              state_machine_regs.line);
-                      break;
-
-                    case DW_LNS_set_file:
-                      adv = read_uleb128 (data, & bytes_read, end);
-                      data += bytes_read;
-                      printf (_("  Set File Name to entry %s in the File Name Table\n"),
-                              dwarf_vmatoa ("d", adv));
-                      state_machine_regs.file = adv;
-                      break;
-
-                    case DW_LNS_set_column:
-                      uladv = read_uleb128 (data, & bytes_read, end);
-                      data += bytes_read;
-                      printf (_("  Set column to %s\n"),
-                              dwarf_vmatoa ("u", uladv));
-                      state_machine_regs.column = uladv;
-                      break;
-
-                    case DW_LNS_negate_stmt:
-                      adv = state_machine_regs.is_stmt;
-                      adv = ! adv;
-                      printf (_("  Set is_stmt to %s\n"), dwarf_vmatoa ("d", adv));
-                      state_machine_regs.is_stmt = adv;
-                      break;
-
-                    case DW_LNS_set_basic_block:
-                      printf (_("  Set basic block\n"));
-                      state_machine_regs.basic_block = 1;
-                      break;
-
-                    case DW_LNS_const_add_pc:
-                      uladv = ((255 - linfo.li_opcode_base) / linfo.li_line_range);
-                      if (linfo.li_max_ops_per_insn)
-                        {
-                          uladv *= linfo.li_min_insn_length;
-                          state_machine_regs.address += uladv;
-                          if (uladv)
-                            state_machine_regs.view = 0;
-                          printf (_("  Advance PC by constant %s to 0x%s%s\n"),
-                                  dwarf_vmatoa ("u", uladv),
-                                  dwarf_vmatoa ("x", state_machine_regs.address),
-                                  verbose_view && uladv
-                                  ? _(" (reset view)") : "");
-                        }
-                      else
-                        {
-                          unsigned addrdelta
-                            = ((state_machine_regs.op_index + uladv)
-                               / linfo.li_max_ops_per_insn)
-                            * linfo.li_min_insn_length;
-                          state_machine_regs.address
-                            += addrdelta;
-                          state_machine_regs.op_index
-                            = (state_machine_regs.op_index + uladv)
-                            % linfo.li_max_ops_per_insn;
-                          if (addrdelta)
-                            state_machine_regs.view = 0;
-                          printf (_("  Advance PC by constant %s to 0x%s[%d]%s\n"),
-                                  dwarf_vmatoa ("u", uladv),
-                                  dwarf_vmatoa ("x", state_machine_regs.address),
-                                  state_machine_regs.op_index,
-                                  verbose_view && addrdelta
-                                  ? _(" (reset view)") : "");
-                        }
-                      break;
-
-                    case DW_LNS_fixed_advance_pc:
-                      SAFE_BYTE_GET_AND_INC (uladv, data, 2, end);
-                      state_machine_regs.address += uladv;
-                      state_machine_regs.op_index = 0;
-                      printf (_("  Advance PC by fixed size amount %s to 0x%s\n"),
-                              dwarf_vmatoa ("u", uladv),
-                              dwarf_vmatoa ("x", state_machine_regs.address));
-                      /* Do NOT reset view.  */
-                      break;
-
-                    case DW_LNS_set_prologue_end:
-                      printf (_("  Set prologue_end to true\n"));
-                      break;
-
-                    case DW_LNS_set_epilogue_begin:
-                      printf (_("  Set epilogue_begin to true\n"));
-                      break;
-
-                    case DW_LNS_set_isa:
-                      uladv = read_uleb128 (data, & bytes_read, end);
-                      data += bytes_read;
-                      printf (_("  Set ISA to %s\n"), dwarf_vmatoa ("u", uladv));
-                      break;
-
-                    default:
-                      printf (_("  Unknown opcode %d with operands: "), op_code);
-
-                      if (standard_opcodes != NULL)
-                        for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
-                          {
-                            printf ("0x%s%s", dwarf_vmatoa ("x", read_uleb128 (data,
-                                                                               &bytes_read, end)),
-                                    i == 1 ? "" : ", ");
-                            data += bytes_read;
-                          }
-                      putchar ('\n');
-                      break;
-                    }
+             else
+               switch (op_code)
+                 {
+                 case DW_LNS_extended_op:
+                   data += process_extended_line_op (data,
+                                                     linfo.li_default_is_stmt,
+                                                     end);
+                   break;
+
+                 case DW_LNS_copy:
+                   printf (_("  Copy"));
+                   if (verbose_view || state_machine_regs.view)
+                     printf (_(" (view %u)\n"), state_machine_regs.view);
+                   else
+                     putchar ('\n');
+                   state_machine_regs.view++;
+                   break;
+
+                 case DW_LNS_advance_pc:
+                   READ_ULEB (uladv, data, end);
+                   if (linfo.li_max_ops_per_insn == 1)
+                     {
+                       uladv *= linfo.li_min_insn_length;
+                       state_machine_regs.address += uladv;
+                       if (uladv)
+                         state_machine_regs.view = 0;
+                       printf (_("  Advance PC by %s to 0x%s%s\n"),
+                               dwarf_vmatoa ("u", uladv),
+                               dwarf_vmatoa ("x", state_machine_regs.address),
+                               verbose_view && uladv
+                               ? _(" (reset view)") : "");
+                     }
+                   else
+                     {
+                       unsigned addrdelta
+                         = ((state_machine_regs.op_index + uladv)
+                            / linfo.li_max_ops_per_insn)
+                         * linfo.li_min_insn_length;
+                       state_machine_regs.address
+                         += addrdelta;
+                       state_machine_regs.op_index
+                         = (state_machine_regs.op_index + uladv)
+                         % linfo.li_max_ops_per_insn;
+                       if (addrdelta)
+                         state_machine_regs.view = 0;
+                       printf (_("  Advance PC by %s to 0x%s[%d]%s\n"),
+                               dwarf_vmatoa ("u", uladv),
+                               dwarf_vmatoa ("x", state_machine_regs.address),
+                               state_machine_regs.op_index,
+                               verbose_view && addrdelta
+                               ? _(" (reset view)") : "");
+                     }
+                   break;
+
+                 case DW_LNS_advance_line:
+                   READ_SLEB (adv, data, end);
+                   state_machine_regs.line += adv;
+                   printf (_("  Advance Line by %s to %d\n"),
+                           dwarf_vmatoa ("d", adv),
+                           state_machine_regs.line);
+                   break;
+
+                 case DW_LNS_set_file:
+                   READ_ULEB (uladv, data, end);
+                   printf (_("  Set File Name to entry %s in the File Name Table\n"),
+                           dwarf_vmatoa ("u", uladv));
+                   state_machine_regs.file = uladv;
+                   break;
+
+                 case DW_LNS_set_column:
+                   READ_ULEB (uladv, data, end);
+                   printf (_("  Set column to %s\n"),
+                           dwarf_vmatoa ("u", uladv));
+                   state_machine_regs.column = uladv;
+                   break;
+
+                 case DW_LNS_negate_stmt:
+                   adv = state_machine_regs.is_stmt;
+                   adv = ! adv;
+                   printf (_("  Set is_stmt to %s\n"), dwarf_vmatoa ("d", adv));
+                   state_machine_regs.is_stmt = adv;
+                   break;
+
+                 case DW_LNS_set_basic_block:
+                   printf (_("  Set basic block\n"));
+                   state_machine_regs.basic_block = 1;
+                   break;
+
+                 case DW_LNS_const_add_pc:
+                   uladv = ((255 - linfo.li_opcode_base) / linfo.li_line_range);
+                   if (linfo.li_max_ops_per_insn)
+                     {
+                       uladv *= linfo.li_min_insn_length;
+                       state_machine_regs.address += uladv;
+                       if (uladv)
+                         state_machine_regs.view = 0;
+                       printf (_("  Advance PC by constant %s to 0x%s%s\n"),
+                               dwarf_vmatoa ("u", uladv),
+                               dwarf_vmatoa ("x", state_machine_regs.address),
+                               verbose_view && uladv
+                               ? _(" (reset view)") : "");
+                     }
+                   else
+                     {
+                       unsigned addrdelta
+                         = ((state_machine_regs.op_index + uladv)
+                            / linfo.li_max_ops_per_insn)
+                         * linfo.li_min_insn_length;
+                       state_machine_regs.address
+                         += addrdelta;
+                       state_machine_regs.op_index
+                         = (state_machine_regs.op_index + uladv)
+                         % linfo.li_max_ops_per_insn;
+                       if (addrdelta)
+                         state_machine_regs.view = 0;
+                       printf (_("  Advance PC by constant %s to 0x%s[%d]%s\n"),
+                               dwarf_vmatoa ("u", uladv),
+                               dwarf_vmatoa ("x", state_machine_regs.address),
+                               state_machine_regs.op_index,
+                               verbose_view && addrdelta
+                               ? _(" (reset view)") : "");
+                     }
+                   break;
+
+                 case DW_LNS_fixed_advance_pc:
+                   SAFE_BYTE_GET_AND_INC (uladv, data, 2, end);
+                   state_machine_regs.address += uladv;
+                   state_machine_regs.op_index = 0;
+                   printf (_("  Advance PC by fixed size amount %s to 0x%s\n"),
+                           dwarf_vmatoa ("u", uladv),
+                           dwarf_vmatoa ("x", state_machine_regs.address));
+                   /* Do NOT reset view.  */
+                   break;
+
+                 case DW_LNS_set_prologue_end:
+                   printf (_("  Set prologue_end to true\n"));
+                   break;
+
+                 case DW_LNS_set_epilogue_begin:
+                   printf (_("  Set epilogue_begin to true\n"));
+                   break;
+
+                 case DW_LNS_set_isa:
+                   READ_ULEB (uladv, data, end);
+                   printf (_("  Set ISA to %s\n"), dwarf_vmatoa ("u", uladv));
+                   break;
+
+                 default:
+                   printf (_("  Unknown opcode %d with operands: "), op_code);
+
+                   if (standard_opcodes != NULL)
+                     for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
+                       {
+                         READ_ULEB (uladv, data, end);
+                         printf ("0x%s%s", dwarf_vmatoa ("x", uladv),
+                                 i == 1 ? "" : ", ");
+                       }
+                   putchar ('\n');
+                   break;
+                 }
            }
          putchar ('\n');
        }
@@ -3935,6 +4267,7 @@ typedef struct
 
 static int
 display_debug_lines_decoded (struct dwarf_section *  section,
+                            unsigned char *         start,
                             unsigned char *         data,
                             unsigned char *         end,
                             void *                  fileptr)
@@ -4005,7 +4338,6 @@ display_debug_lines_decoded (struct dwarf_section *  section,
            {
              unsigned char *format_start, format_count, *format;
              dwarf_vma formati, entryi;
-             unsigned int bytes_read;
 
              load_debug_section_with_follow (line_str, fileptr);
 
@@ -4014,14 +4346,11 @@ display_debug_lines_decoded (struct dwarf_section *  section,
              format_start = data;
              for (formati = 0; formati < format_count; formati++)
                {
-                 read_uleb128 (data, & bytes_read, end);
-                 data += bytes_read;
-                 read_uleb128 (data, & bytes_read, end);
-                 data += bytes_read;
+                 SKIP_ULEB (data, end);
+                 SKIP_ULEB (data, end);
                }
 
-             n_directories = read_uleb128 (data, & bytes_read, end);
-             data += bytes_read;
+             READ_ULEB (n_directories, data, end);
              if (data == end)
                {
                  warn (_("Corrupt directories list\n"));
@@ -4041,10 +4370,8 @@ display_debug_lines_decoded (struct dwarf_section *  section,
                      dwarf_vma content_type, form;
                      dwarf_vma uvalue;
 
-                     content_type = read_uleb128 (format, & bytes_read, end);
-                     format += bytes_read;
-                     form = read_uleb128 (format, & bytes_read, end);
-                     format += bytes_read;
+                     READ_ULEB (content_type, format, end);
+                     READ_ULEB (form, format, end);
                      if (data == end)
                        {
                          warn (_("Corrupt directories list\n"));
@@ -4068,12 +4395,12 @@ display_debug_lines_decoded (struct dwarf_section *  section,
                            }
                          break;
                        }
-                     data = read_and_display_attr_value (0, form, 0, data, end,
-                                                         0, 0,
+                     data = read_and_display_attr_value (0, form, 0, start,
+                                                         data, end, 0, 0,
                                                          linfo.li_offset_size,
                                                          linfo.li_version,
                                                          NULL, 1, section,
-                                                         NULL, '\t');
+                                                         NULL, '\t', -1);
                    }
                  if (data == end)
                    {
@@ -4087,14 +4414,11 @@ display_debug_lines_decoded (struct dwarf_section *  section,
              format_start = data;
              for (formati = 0; formati < format_count; formati++)
                {
-                 read_uleb128 (data, & bytes_read, end);
-                 data += bytes_read;
-                 read_uleb128 (data, & bytes_read, end);
-                 data += bytes_read;
+                 SKIP_ULEB (data, end);
+                 SKIP_ULEB (data, end);
                }
 
-             n_files = read_uleb128 (data, & bytes_read, end);
-             data += bytes_read;
+             READ_ULEB (n_files, data, end);
              if (data == end)
                {
                  warn (_("Corrupt file name list\n"));
@@ -4113,11 +4437,10 @@ display_debug_lines_decoded (struct dwarf_section *  section,
                    {
                      dwarf_vma content_type, form;
                      dwarf_vma uvalue;
+                     unsigned char *tmp;
 
-                     content_type = read_uleb128 (format, & bytes_read, end);
-                     format += bytes_read;
-                     form = read_uleb128 (format, & bytes_read, end);
-                     format += bytes_read;
+                     READ_ULEB (content_type, format, end);
+                     READ_ULEB (form, format, end);
                      if (data == end)
                        {
                          warn (_("Corrupt file name list\n"));
@@ -4152,18 +4475,18 @@ display_debug_lines_decoded (struct dwarf_section *  section,
                                             end);
                              break;
                            case DW_FORM_udata:
-                             file->directory_index = read_uleb128 (data, NULL,
-                                                                   end);
+                             tmp = data;
+                             READ_ULEB (file->directory_index, tmp, end);
                              break;
                            }
                          break;
                        }
-                     data = read_and_display_attr_value (0, form, 0, data, end,
-                                                         0, 0,
+                     data = read_and_display_attr_value (0, form, 0, start,
+                                                         data, end, 0, 0,
                                                          linfo.li_offset_size,
                                                          linfo.li_version,
                                                          NULL, 1, section,
-                                                         NULL, '\t');
+                                                         NULL, '\t', -1);
                    }
                  if (data == end)
                    {
@@ -4215,18 +4538,12 @@ display_debug_lines_decoded (struct dwarf_section *  section,
 
                  while (data < end && *data != 0)
                    {
-                     unsigned int bytes_read;
-
-                     /* Skip Name, directory index, last modification time and length
-                        of file.  */
+                     /* Skip Name, directory index, last modification
+                        time and length of file.  */
                      data += strnlen ((char *) data, end - data) + 1;
-                     read_uleb128 (data, & bytes_read, end);
-                     data += bytes_read;
-                     read_uleb128 (data, & bytes_read, end);
-                     data += bytes_read;
-                     read_uleb128 (data, & bytes_read, end);
-                     data += bytes_read;
-
+                     SKIP_ULEB (data, end);
+                     SKIP_ULEB (data, end);
+                     SKIP_ULEB (data, end);
                      n_files++;
                    }
 
@@ -4243,21 +4560,17 @@ display_debug_lines_decoded (struct dwarf_section *  section,
                  i = 0;
                  while (*ptr_file_name_table != 0)
                    {
-                     unsigned int bytes_read;
-
                      file_table[i].name = ptr_file_name_table;
                      ptr_file_name_table += strnlen ((char *) ptr_file_name_table,
                                                      end - ptr_file_name_table) + 1;
 
                      /* We are not interested in directory, time or size.  */
-                     file_table[i].directory_index = read_uleb128 (ptr_file_name_table,
-                                                                   & bytes_read, end);
-                     ptr_file_name_table += bytes_read;
-                     file_table[i].modification_date = read_uleb128 (ptr_file_name_table,
-                                                                     & bytes_read, end);
-                     ptr_file_name_table += bytes_read;
-                     file_table[i].length = read_uleb128 (ptr_file_name_table, & bytes_read, end);
-                     ptr_file_name_table += bytes_read;
+                     READ_ULEB (file_table[i].directory_index,
+                                ptr_file_name_table, end);
+                     READ_ULEB (file_table[i].modification_date,
+                                ptr_file_name_table, end);
+                     READ_ULEB (file_table[i].length,
+                                ptr_file_name_table, end);
                      i++;
                    }
                  i = 0;
@@ -4297,7 +4610,7 @@ display_debug_lines_decoded (struct dwarf_section *  section,
                printf ("%s:\n", file_table[0].name);
            }
 
-         printf (_("File name                            Line number    Starting address    View\n"));
+         printf (_("File name                            Line number    Starting address    View    Stmt\n"));
          saved_linfo = linfo;
        }
 
@@ -4308,7 +4621,6 @@ display_debug_lines_decoded (struct dwarf_section *  section,
          int xop;
          int adv;
          unsigned long int uladv;
-         unsigned int bytes_read;
          int is_special_opcode = 0;
 
          op_code = *data++;
@@ -4340,233 +4652,221 @@ display_debug_lines_decoded (struct dwarf_section *  section,
                    state_machine_regs.view = 0;
                }
 
-             adv = (op_code % linfo.li_line_range) + linfo.li_line_base;
-             state_machine_regs.line += adv;
-             is_special_opcode = 1;
-             /* Increment view after printing this row.  */
-           }
-         else switch (op_code)
-                {
-                case DW_LNS_extended_op:
-                  {
-                    unsigned int ext_op_code_len;
-                    unsigned char ext_op_code;
-                    unsigned char *op_code_data = data;
-
-                    ext_op_code_len = read_uleb128 (op_code_data, &bytes_read,
-                                                    end_of_sequence);
-                    op_code_data += bytes_read;
-
-                    if (ext_op_code_len == 0)
-                      {
-                        warn (_("Badly formed extended line op encountered!\n"));
-                        break;
-                      }
-                    ext_op_code_len += bytes_read;
-                    ext_op_code = *op_code_data++;
-                    xop = ext_op_code;
-                    xop = -xop;
-
-                    switch (ext_op_code)
-                      {
-                      case DW_LNE_end_sequence:
-                        /* Reset stuff after printing this row.  */
-                        break;
-                      case DW_LNE_set_address:
-                        SAFE_BYTE_GET_AND_INC (state_machine_regs.address,
-                                               op_code_data,
-                                               ext_op_code_len - bytes_read - 1,
-                                               end);
-                        state_machine_regs.op_index = 0;
-                        state_machine_regs.view = 0;
-                        break;
-                      case DW_LNE_define_file:
-                        {
-                          file_table = (File_Entry *) xrealloc
-                            (file_table, (n_files + 1) * sizeof (File_Entry));
-
-                          ++state_machine_regs.last_file_entry;
-                          /* Source file name.  */
-                          file_table[n_files].name = op_code_data;
-                          op_code_data += strlen ((char *) op_code_data) + 1;
-                          /* Directory index.  */
-                          file_table[n_files].directory_index =
-                            read_uleb128 (op_code_data, & bytes_read,
-                                          end_of_sequence);
-                          op_code_data += bytes_read;
-                          /* Last modification time.  */
-                          file_table[n_files].modification_date =
-                            read_uleb128 (op_code_data, & bytes_read,
-                                          end_of_sequence);
-                          op_code_data += bytes_read;
-                          /* File length.  */
-                          file_table[n_files].length =
-                            read_uleb128 (op_code_data, & bytes_read,
-                                          end_of_sequence);
-
-                          n_files++;
-                          break;
-                        }
-                      case DW_LNE_set_discriminator:
-                      case DW_LNE_HP_set_sequence:
-                        /* Simply ignored.  */
-                        break;
-
-                      default:
-                        printf (_("UNKNOWN (%u): length %d\n"),
-                                ext_op_code, ext_op_code_len - bytes_read);
-                        break;
-                      }
-                    data += ext_op_code_len;
-                    break;
-                  }
-                case DW_LNS_copy:
-                  /* Increment view after printing this row.  */
-                  break;
-
-                case DW_LNS_advance_pc:
-                  uladv = read_uleb128 (data, & bytes_read, end);
-                  data += bytes_read;
-                  if (linfo.li_max_ops_per_insn == 1)
-                    {
-                      uladv *= linfo.li_min_insn_length;
-                      state_machine_regs.address += uladv;
-                      if (uladv)
-                        state_machine_regs.view = 0;
-                    }
-                  else
-                    {
-                      unsigned addrdelta
-                        = ((state_machine_regs.op_index + uladv)
-                           / linfo.li_max_ops_per_insn)
-                        * linfo.li_min_insn_length;
-                      state_machine_regs.address
-                        += addrdelta;
-                      state_machine_regs.op_index
-                        = (state_machine_regs.op_index + uladv)
-                        % linfo.li_max_ops_per_insn;
-                      if (addrdelta)
-                        state_machine_regs.view = 0;
-                    }
-                  break;
-
-                case DW_LNS_advance_line:
-                  adv = read_sleb128 (data, & bytes_read, end);
-                  data += bytes_read;
-                  state_machine_regs.line += adv;
-                  break;
-
-                case DW_LNS_set_file:
-                  adv = read_uleb128 (data, & bytes_read, end);
-                  data += bytes_read;
-                  state_machine_regs.file = adv;
-
-                  {
-                    unsigned file = state_machine_regs.file - 1;
-                    unsigned dir;
-
-                    if (file_table == NULL || n_files == 0)
-                      printf (_("\n [Use file table entry %d]\n"), file);
-                    /* PR 20439 */
-                    else if (file >= n_files)
-                      {
-                        warn (_("file index %u > number of files %u\n"), file + 1, n_files);
-                        printf (_("\n <over large file table index %u>"), file);
-                      }
-                    else if ((dir = file_table[file].directory_index) == 0)
-                      /* If directory index is 0, that means current directory.  */
-                      printf ("\n./%s:[++]\n", file_table[file].name);
-                    else if (directory_table == NULL || n_directories == 0)
-                      printf (_("\n [Use file %s in directory table entry %d]\n"),
-                              file_table[file].name, dir);
-                    /* PR 20439 */
-                    else if (dir > n_directories)
-                      {
-                        warn (_("directory index %u > number of directories %s\n"),
-                              dir, dwarf_vmatoa ("u", n_directories));
-                        printf (_("\n <over large directory table entry %u>\n"), dir);
-                      }
-                    else
-                      printf ("\n%s/%s:\n",
-                              /* The directory index starts counting at 1.  */
-                              directory_table[dir - 1], file_table[file].name);
-                  }
-                  break;
-
-                case DW_LNS_set_column:
-                  uladv = read_uleb128 (data, & bytes_read, end);
-                  data += bytes_read;
-                  state_machine_regs.column = uladv;
-                  break;
-
-                case DW_LNS_negate_stmt:
-                  adv = state_machine_regs.is_stmt;
-                  adv = ! adv;
-                  state_machine_regs.is_stmt = adv;
-                  break;
-
-                case DW_LNS_set_basic_block:
-                  state_machine_regs.basic_block = 1;
-                  break;
-
-                case DW_LNS_const_add_pc:
-                  uladv = ((255 - linfo.li_opcode_base) / linfo.li_line_range);
-                  if (linfo.li_max_ops_per_insn == 1)
-                    {
-                      uladv *= linfo.li_min_insn_length;
-                      state_machine_regs.address += uladv;
-                      if (uladv)
-                        state_machine_regs.view = 0;
-                    }
-                  else
-                    {
-                      unsigned addrdelta
-                        = ((state_machine_regs.op_index + uladv)
-                           / linfo.li_max_ops_per_insn)
-                        * linfo.li_min_insn_length;
-                      state_machine_regs.address
-                        += addrdelta;
-                      state_machine_regs.op_index
-                        = (state_machine_regs.op_index + uladv)
-                        % linfo.li_max_ops_per_insn;
-                      if (addrdelta)
-                        state_machine_regs.view = 0;
-                    }
-                  break;
-
-                case DW_LNS_fixed_advance_pc:
-                  SAFE_BYTE_GET_AND_INC (uladv, data, 2, end);
-                  state_machine_regs.address += uladv;
-                  state_machine_regs.op_index = 0;
-                  /* Do NOT reset view.  */
-                  break;
-
-                case DW_LNS_set_prologue_end:
-                  break;
-
-                case DW_LNS_set_epilogue_begin:
-                  break;
-
-                case DW_LNS_set_isa:
-                  uladv = read_uleb128 (data, & bytes_read, end);
-                  data += bytes_read;
-                  printf (_("  Set ISA to %lu\n"), uladv);
-                  break;
-
-                default:
-                  printf (_("  Unknown opcode %d with operands: "), op_code);
-
-                  if (standard_opcodes != NULL)
-                    for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
-                      {
-                        printf ("0x%s%s", dwarf_vmatoa ("x", read_uleb128 (data,
-                                                                           &bytes_read, end)),
-                                i == 1 ? "" : ", ");
-                        data += bytes_read;
-                      }
-                  putchar ('\n');
-                  break;
-                }
+             adv = (op_code % linfo.li_line_range) + linfo.li_line_base;
+             state_machine_regs.line += adv;
+             is_special_opcode = 1;
+             /* Increment view after printing this row.  */
+           }
+         else
+           switch (op_code)
+             {
+             case DW_LNS_extended_op:
+               {
+                 unsigned int ext_op_code_len;
+                 unsigned char ext_op_code;
+                 unsigned char *op_code_end;
+                 unsigned char *op_code_data = data;
+
+                 READ_ULEB (ext_op_code_len, op_code_data, end_of_sequence);
+                 op_code_end = op_code_data + ext_op_code_len;
+                 if (ext_op_code_len == 0 || op_code_end > end_of_sequence)
+                   {
+                     warn (_("Badly formed extended line op encountered!\n"));
+                     break;
+                   }
+                 ext_op_code = *op_code_data++;
+                 xop = ext_op_code;
+                 xop = -xop;
+
+                 switch (ext_op_code)
+                   {
+                   case DW_LNE_end_sequence:
+                     /* Reset stuff after printing this row.  */
+                     break;
+                   case DW_LNE_set_address:
+                     SAFE_BYTE_GET_AND_INC (state_machine_regs.address,
+                                            op_code_data,
+                                            op_code_end - op_code_data,
+                                            op_code_end);
+                     state_machine_regs.op_index = 0;
+                     state_machine_regs.view = 0;
+                     break;
+                   case DW_LNE_define_file:
+                     file_table = (File_Entry *) xrealloc
+                       (file_table, (n_files + 1) * sizeof (File_Entry));
+
+                     ++state_machine_regs.last_file_entry;
+                     /* Source file name.  */
+                     file_table[n_files].name = op_code_data;
+                     op_code_data += strlen ((char *) op_code_data) + 1;
+                     /* Directory index.  */
+                     READ_ULEB (file_table[n_files].directory_index,
+                                op_code_data, op_code_end);
+                     /* Last modification time.  */
+                     READ_ULEB (file_table[n_files].modification_date,
+                                op_code_data, op_code_end);
+                     /* File length.  */
+                     READ_ULEB (file_table[n_files].length,
+                                op_code_data, op_code_end);
+                     n_files++;
+                     break;
+
+                   case DW_LNE_set_discriminator:
+                   case DW_LNE_HP_set_sequence:
+                     /* Simply ignored.  */
+                     break;
+
+                   default:
+                     printf (_("UNKNOWN (%u): length %ld\n"),
+                             ext_op_code, (long int) (op_code_data - data));
+                     break;
+                   }
+                 data = op_code_end;
+                 break;
+               }
+             case DW_LNS_copy:
+               /* Increment view after printing this row.  */
+               break;
+
+             case DW_LNS_advance_pc:
+               READ_ULEB (uladv, data, end);
+               if (linfo.li_max_ops_per_insn == 1)
+                 {
+                   uladv *= linfo.li_min_insn_length;
+                   state_machine_regs.address += uladv;
+                   if (uladv)
+                     state_machine_regs.view = 0;
+                 }
+               else
+                 {
+                   unsigned addrdelta
+                     = ((state_machine_regs.op_index + uladv)
+                        / linfo.li_max_ops_per_insn)
+                     * linfo.li_min_insn_length;
+                   state_machine_regs.address
+                     += addrdelta;
+                   state_machine_regs.op_index
+                     = (state_machine_regs.op_index + uladv)
+                     % linfo.li_max_ops_per_insn;
+                   if (addrdelta)
+                     state_machine_regs.view = 0;
+                 }
+               break;
+
+             case DW_LNS_advance_line:
+               READ_SLEB (adv, data, end);
+               state_machine_regs.line += adv;
+               break;
+
+             case DW_LNS_set_file:
+               READ_ULEB (uladv, data, end);
+               state_machine_regs.file = uladv;
+
+               {
+                 unsigned file = state_machine_regs.file - 1;
+                 unsigned dir;
+
+                 if (file_table == NULL || n_files == 0)
+                   printf (_("\n [Use file table entry %d]\n"), file);
+                 /* PR 20439 */
+                 else if (file >= n_files)
+                   {
+                     warn (_("file index %u > number of files %u\n"), file + 1, n_files);
+                     printf (_("\n <over large file table index %u>"), file);
+                   }
+                 else if ((dir = file_table[file].directory_index) == 0)
+                   /* If directory index is 0, that means current directory.  */
+                   printf ("\n./%s:[++]\n", file_table[file].name);
+                 else if (directory_table == NULL || n_directories == 0)
+                   printf (_("\n [Use file %s in directory table entry %d]\n"),
+                           file_table[file].name, dir);
+                 /* PR 20439 */
+                 else if (dir > n_directories)
+                   {
+                     warn (_("directory index %u > number of directories %s\n"),
+                           dir, dwarf_vmatoa ("u", n_directories));
+                     printf (_("\n <over large directory table entry %u>\n"), dir);
+                   }
+                 else
+                   printf ("\n%s/%s:\n",
+                           /* The directory index starts counting at 1.  */
+                           directory_table[dir - 1], file_table[file].name);
+               }
+               break;
+
+             case DW_LNS_set_column:
+               READ_ULEB (uladv, data, end);
+               state_machine_regs.column = uladv;
+               break;
+
+             case DW_LNS_negate_stmt:
+               adv = state_machine_regs.is_stmt;
+               adv = ! adv;
+               state_machine_regs.is_stmt = adv;
+               break;
+
+             case DW_LNS_set_basic_block:
+               state_machine_regs.basic_block = 1;
+               break;
+
+             case DW_LNS_const_add_pc:
+               uladv = ((255 - linfo.li_opcode_base) / linfo.li_line_range);
+               if (linfo.li_max_ops_per_insn == 1)
+                 {
+                   uladv *= linfo.li_min_insn_length;
+                   state_machine_regs.address += uladv;
+                   if (uladv)
+                     state_machine_regs.view = 0;
+                 }
+               else
+                 {
+                   unsigned addrdelta
+                     = ((state_machine_regs.op_index + uladv)
+                        / linfo.li_max_ops_per_insn)
+                     * linfo.li_min_insn_length;
+                   state_machine_regs.address
+                     += addrdelta;
+                   state_machine_regs.op_index
+                     = (state_machine_regs.op_index + uladv)
+                     % linfo.li_max_ops_per_insn;
+                   if (addrdelta)
+                     state_machine_regs.view = 0;
+                 }
+               break;
+
+             case DW_LNS_fixed_advance_pc:
+               SAFE_BYTE_GET_AND_INC (uladv, data, 2, end);
+               state_machine_regs.address += uladv;
+               state_machine_regs.op_index = 0;
+               /* Do NOT reset view.  */
+               break;
+
+             case DW_LNS_set_prologue_end:
+               break;
+
+             case DW_LNS_set_epilogue_begin:
+               break;
+
+             case DW_LNS_set_isa:
+               READ_ULEB (uladv, data, end);
+               printf (_("  Set ISA to %lu\n"), uladv);
+               break;
+
+             default:
+               printf (_("  Unknown opcode %d with operands: "), op_code);
+
+               if (standard_opcodes != NULL)
+                 for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
+                   {
+                     dwarf_vma val;
+
+                     READ_ULEB (val, data, end);
+                     printf ("0x%s%s", dwarf_vmatoa ("x", val),
+                             i == 1 ? "" : ", ");
+                   }
+               putchar ('\n');
+               break;
+             }
 
          /* Only Special opcodes, DW_LNS_copy and DW_LNE_end_sequence adds a row
             to the DWARF address/line matrix.  */
@@ -4602,6 +4902,11 @@ display_debug_lines_decoded (struct dwarf_section *  section,
                  strncpy (newFileName,
                           fileName + fileNameLength - MAX_FILENAME_LENGTH,
                           MAX_FILENAME_LENGTH + 1);
+                 /* FIXME: This is to pacify gcc-10 which can warn that the
+                    strncpy above might leave a non-NUL terminated string
+                    in newFileName.  It won't, but gcc's analysis doesn't
+                    quite go far enough to discover this.  */
+                 newFileName[MAX_FILENAME_LENGTH] = 0;
                }
              else
                {
@@ -4635,9 +4940,14 @@ display_debug_lines_decoded (struct dwarf_section *  section,
                }
 
              if (state_machine_regs.view)
-               printf ("  %6u\n", state_machine_regs.view);
+               printf ("  %6u", state_machine_regs.view);
              else
-               putchar ('\n');
+               printf ("        ");
+
+             if (state_machine_regs.is_stmt)
+               printf ("       x");
+
+             putchar ('\n');
              state_machine_regs.view++;
 
              if (xop == -DW_LNE_end_sequence)
@@ -4685,7 +4995,7 @@ display_debug_lines (struct dwarf_section *section, void *file)
     retValRaw = display_debug_lines_raw (section, data, end, file);
 
   if (do_debug_lines & FLAG_DEBUG_LINES_DECODED)
-    retValDecoded = display_debug_lines_decoded (section, data, end, file);
+    retValDecoded = display_debug_lines_decoded (section, data, data, end, file);
 
   if (!retValRaw || !retValDecoded)
     return 0;
@@ -4883,7 +5193,6 @@ display_debug_macinfo (struct dwarf_section *section,
   unsigned char *start = section->start;
   unsigned char *end = start + section->size;
   unsigned char *curr = start;
-  unsigned int bytes_read;
   enum dwarf_macinfo_record_type op;
 
   introduce (section, FALSE);
@@ -4902,11 +5211,8 @@ display_debug_macinfo (struct dwarf_section *section,
          {
            unsigned int filenum;
 
-           lineno = read_uleb128 (curr, & bytes_read, end);
-           curr += bytes_read;
-           filenum = read_uleb128 (curr, & bytes_read, end);
-           curr += bytes_read;
-
+           READ_ULEB (lineno, curr, end);
+           READ_ULEB (filenum, curr, end);
            printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
                    lineno, filenum);
          }
@@ -4917,8 +5223,7 @@ display_debug_macinfo (struct dwarf_section *section,
          break;
 
        case DW_MACINFO_define:
-         lineno = read_uleb128 (curr, & bytes_read, end);
-         curr += bytes_read;
+         READ_ULEB (lineno, curr, end);
          string = curr;
          curr += strnlen ((char *) string, end - string) + 1;
          printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
@@ -4926,8 +5231,7 @@ display_debug_macinfo (struct dwarf_section *section,
          break;
 
        case DW_MACINFO_undef:
-         lineno = read_uleb128 (curr, & bytes_read, end);
-         curr += bytes_read;
+         READ_ULEB (lineno, curr, end);
          string = curr;
          curr += strnlen ((char *) string, end - string) + 1;
          printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
@@ -4938,8 +5242,7 @@ display_debug_macinfo (struct dwarf_section *section,
          {
            unsigned int constant;
 
-           constant = read_uleb128 (curr, & bytes_read, end);
-           curr += bytes_read;
+           READ_ULEB (constant, curr, end);
            string = curr;
            curr += strnlen ((char *) string, end - string) + 1;
            printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
@@ -4964,7 +5267,7 @@ get_line_filename_and_dirname (dwarf_vma line_offset,
   struct dwarf_section *section = &debug_displays [line].section;
   unsigned char *hdrptr, *dirtable, *file_name;
   unsigned int offset_size, initial_length_size;
-  unsigned int version, opcode_base, bytes_read;
+  unsigned int version, opcode_base;
   dwarf_vma length, diridx;
   const unsigned char * end;
 
@@ -5024,12 +5327,9 @@ get_line_filename_and_dirname (dwarf_vma line_offset,
   for (; hdrptr < end && *hdrptr != '\0' && fileidx > 1; fileidx--)
     {
       hdrptr += strnlen ((char *) hdrptr, end - hdrptr) + 1;
-      read_uleb128 (hdrptr, &bytes_read, end);
-      hdrptr += bytes_read;
-      read_uleb128 (hdrptr, &bytes_read, end);
-      hdrptr += bytes_read;
-      read_uleb128 (hdrptr, &bytes_read, end);
-      hdrptr += bytes_read;
+      SKIP_ULEB (hdrptr, end);
+      SKIP_ULEB (hdrptr, end);
+      SKIP_ULEB (hdrptr, end);
     }
   if (hdrptr >= end || *hdrptr == '\0')
     return NULL;
@@ -5038,7 +5338,7 @@ get_line_filename_and_dirname (dwarf_vma line_offset,
   hdrptr += strnlen ((char *) hdrptr, end - hdrptr) + 1;
   if (hdrptr >= end)
     return NULL;
-  diridx = read_uleb128 (hdrptr, &bytes_read, end);
+  READ_ULEB (diridx, hdrptr, end);
   if (diridx == 0)
     return file_name;
   for (; dirtable < end && *dirtable != '\0' && diridx > 1; diridx--)
@@ -5057,7 +5357,6 @@ display_debug_macro (struct dwarf_section *section,
   unsigned char *end = start + section->size;
   unsigned char *curr = start;
   unsigned char *extended_op_buf[256];
-  unsigned int bytes_read;
 
   load_debug_section_with_follow (str, file);
   load_debug_section_with_follow (line, file);
@@ -5109,8 +5408,7 @@ display_debug_macro (struct dwarf_section *section,
                {
                  SAFE_BYTE_GET_AND_INC (op, curr, 1, end);
                  extended_ops[op] = curr;
-                 nargs = read_uleb128 (curr, &bytes_read, end);
-                 curr += bytes_read;
+                 READ_ULEB (nargs, curr, end);
                  if (nargs == 0)
                    printf (_("    DW_MACRO_%02x has no arguments\n"), op);
                  else
@@ -5173,10 +5471,8 @@ display_debug_macro (struct dwarf_section *section,
                unsigned int filenum;
                unsigned char *file_name = NULL, *dir_name = NULL;
 
-               lineno = read_uleb128 (curr, &bytes_read, end);
-               curr += bytes_read;
-               filenum = read_uleb128 (curr, &bytes_read, end);
-               curr += bytes_read;
+               READ_ULEB (lineno, curr, end);
+               READ_ULEB (filenum, curr, end);
 
                if ((flags & 2) == 0)
                  error (_("DW_MACRO_start_file used, but no .debug_line offset provided.\n"));
@@ -5200,8 +5496,7 @@ display_debug_macro (struct dwarf_section *section,
              break;
 
            case DW_MACRO_define:
-             lineno = read_uleb128 (curr, &bytes_read, end);
-             curr += bytes_read;
+             READ_ULEB (lineno, curr, end);
              string = curr;
              curr += strnlen ((char *) string, end - string) + 1;
              printf (_(" DW_MACRO_define - lineno : %d macro : %s\n"),
@@ -5209,8 +5504,7 @@ display_debug_macro (struct dwarf_section *section,
              break;
 
            case DW_MACRO_undef:
-             lineno = read_uleb128 (curr, &bytes_read, end);
-             curr += bytes_read;
+             READ_ULEB (lineno, curr, end);
              string = curr;
              curr += strnlen ((char *) string, end - string) + 1;
              printf (_(" DW_MACRO_undef - lineno : %d macro : %s\n"),
@@ -5218,8 +5512,7 @@ display_debug_macro (struct dwarf_section *section,
              break;
 
            case DW_MACRO_define_strp:
-             lineno = read_uleb128 (curr, &bytes_read, end);
-             curr += bytes_read;
+             READ_ULEB (lineno, curr, end);
              SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
              string = fetch_indirect_string (offset);
              printf (_(" DW_MACRO_define_strp - lineno : %d macro : %s\n"),
@@ -5227,8 +5520,7 @@ display_debug_macro (struct dwarf_section *section,
              break;
 
            case DW_MACRO_undef_strp:
-             lineno = read_uleb128 (curr, &bytes_read, end);
-             curr += bytes_read;
+             READ_ULEB (lineno, curr, end);
              SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
              string = fetch_indirect_string (offset);
              printf (_(" DW_MACRO_undef_strp - lineno : %d macro : %s\n"),
@@ -5242,16 +5534,14 @@ display_debug_macro (struct dwarf_section *section,
              break;
 
            case DW_MACRO_define_sup:
-             lineno = read_uleb128 (curr, &bytes_read, end);
-             curr += bytes_read;
+             READ_ULEB (lineno, curr, end);
              SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
              printf (_(" DW_MACRO_define_sup - lineno : %d macro offset : 0x%lx\n"),
                      lineno, (unsigned long) offset);
              break;
 
            case DW_MACRO_undef_sup:
-             lineno = read_uleb128 (curr, &bytes_read, end);
-             curr += bytes_read;
+             READ_ULEB (lineno, curr, end);
              SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
              printf (_(" DW_MACRO_undef_sup - lineno : %d macro offset : 0x%lx\n"),
                      lineno, (unsigned long) offset);
@@ -5274,8 +5564,7 @@ display_debug_macro (struct dwarf_section *section,
                  /* Skip over unhandled opcodes.  */
                  dwarf_vma nargs, n;
                  unsigned char *desc = extended_ops[op];
-                 nargs = read_uleb128 (desc, &bytes_read, end);
-                 desc += bytes_read;
+                 READ_ULEB (nargs, desc, end);
                  if (nargs == 0)
                    {
                      printf (_(" DW_MACRO_%02x\n"), op);
@@ -5290,9 +5579,9 @@ display_debug_macro (struct dwarf_section *section,
                      SAFE_BYTE_GET_AND_INC (val, desc, 1, end);
                      curr
                        = read_and_display_attr_value (0, val, 0,
-                                                      curr, end, 0, 0, offset_size,
+                                                      start, curr, end, 0, 0, offset_size,
                                                       version, NULL, 0, NULL,
-                                                      NULL, ' ');
+                                                      NULL, ' ', -1);
                      if (n != nargs - 1)
                        printf (",");
                    }
@@ -5392,18 +5681,11 @@ display_view_pair_list (struct dwarf_section *section,
       dwarf_vma off = vstart - section->start;
       dwarf_vma vbegin, vend;
 
-      unsigned int bytes_read;
-      vbegin = read_uleb128 (vstart, &bytes_read, section_end);
-      vstart += bytes_read;
+      READ_ULEB (vbegin, vstart, section_end);
       if (vstart == section_end)
-       {
-         vstart -= bytes_read;
-         break;
-       }
-
-      vend = read_uleb128 (vstart, &bytes_read, section_end);
-      vstart += bytes_read;
+       break;
 
+      READ_ULEB (vend, vstart, section_end);
       printf ("    %8.8lx ", (unsigned long) off);
 
       print_dwarf_view (vbegin, pointer_size, 1);
@@ -5503,16 +5785,12 @@ display_loc_list (struct dwarf_section *section,
 
       if (vstart)
        {
-         unsigned int bytes_read;
-
          off = offset + (vstart - *start_ptr);
 
-         vbegin = read_uleb128 (vstart, &bytes_read, section_end);
-         vstart += bytes_read;
+         READ_ULEB (vbegin, vstart, section_end);
          print_dwarf_view (vbegin, pointer_size, 1);
 
-         vend = read_uleb128 (vstart, &bytes_read, section_end);
-         vstart += bytes_read;
+         READ_ULEB (vend, vstart, section_end);
          print_dwarf_view (vend, pointer_size, 1);
 
          printf (_("views at %8.8lx for:\n    %*s "),
@@ -5581,7 +5859,6 @@ display_loclists_list (struct dwarf_section *section,
   unsigned int pointer_size;
   unsigned int offset_size;
   int dwarf_version;
-  unsigned int bytes_read;
 
   /* Initialize it due to a false compiler warning.  */
   dwarf_vma begin = -1, vbegin = -1;
@@ -5629,12 +5906,10 @@ display_loclists_list (struct dwarf_section *section,
        {
          off = offset + (vstart - *start_ptr);
 
-         vbegin = read_uleb128 (vstart, &bytes_read, section_end);
-         vstart += bytes_read;
+         READ_ULEB (vbegin, vstart, section_end);
          print_dwarf_view (vbegin, pointer_size, 1);
 
-         vend = read_uleb128 (vstart, &bytes_read, section_end);
-         vstart += bytes_read;
+         READ_ULEB (vend, vstart, section_end);
          print_dwarf_view (vend, pointer_size, 1);
 
          printf (_("views at %8.8lx for:\n    %*s "),
@@ -5647,10 +5922,8 @@ display_loclists_list (struct dwarf_section *section,
          printf (_("<End of list>\n"));
          break;
        case DW_LLE_offset_pair:
-         begin = read_uleb128 (start, &bytes_read, section_end);
-         start += bytes_read;
-         end = read_uleb128 (start, &bytes_read, section_end);
-         start += bytes_read;
+         READ_ULEB (begin, start, section_end);
+         READ_ULEB (end, start, section_end);
          break;
        case DW_LLE_base_address:
          SAFE_BYTE_GET_AND_INC (base_address, start, pointer_size,
@@ -5662,12 +5935,10 @@ display_loclists_list (struct dwarf_section *section,
        case DW_LLE_view_pair:
          if (vstart)
            printf (_("View pair entry in loclist with locviews attribute\n"));
-         vbegin = read_uleb128 (start, &bytes_read, section_end);
-         start += bytes_read;
+         READ_ULEB (vbegin, start, section_end);
          print_dwarf_view (vbegin, pointer_size, 1);
 
-         vend = read_uleb128 (start, &bytes_read, section_end);
-         start += bytes_read;
+         READ_ULEB (vend, start, section_end);
          print_dwarf_view (vend, pointer_size, 1);
 
          printf (_("views for:\n"));
@@ -5689,8 +5960,7 @@ display_loclists_list (struct dwarf_section *section,
          break;
        }
 
-      length = read_uleb128 (start, &bytes_read, section_end);
-      start += bytes_read;
+      READ_ULEB (length, start, section_end);
 
       print_dwarf_vma (begin + base_address, pointer_size);
       print_dwarf_vma (end + base_address, pointer_size);
@@ -5758,7 +6028,6 @@ display_loc_list_dwo (struct dwarf_section *section,
   unsigned short length;
   int need_frame_base;
   unsigned int idx;
-  unsigned int bytes_read;
 
   if (debug_info_entry >= num_debug_info_entries)
     {
@@ -5805,12 +6074,10 @@ display_loc_list_dwo (struct dwarf_section *section,
              dwarf_vma view;
              dwarf_vma off = offset + (vstart - *start_ptr);
 
-             view = read_uleb128 (vstart, &bytes_read, section_end);
-             vstart += bytes_read;
+             READ_ULEB (view, vstart, section_end);
              print_dwarf_view (view, 8, 1);
 
-             view = read_uleb128 (vstart, &bytes_read, section_end);
-             vstart += bytes_read;
+             READ_ULEB (view, vstart, section_end);
              print_dwarf_view (view, 8, 1);
 
              printf (_("views at %8.8lx for:\n    %*s "),
@@ -5828,23 +6095,19 @@ display_loc_list_dwo (struct dwarf_section *section,
          printf (_("<End of list>\n"));
          return;
        case 1: /* A base-address entry.  */
-         idx = read_uleb128 (start, &bytes_read, section_end);
-         start += bytes_read;
+         READ_ULEB (idx, start, section_end);
          print_addr_index (idx, 8);
          printf ("%*s", 9 + (vstart ? 2 * 6 : 0), "");
          printf (_("(base address selection entry)\n"));
          continue;
        case 2: /* A start/end entry.  */
-         idx = read_uleb128 (start, &bytes_read, section_end);
-         start += bytes_read;
+         READ_ULEB (idx, start, section_end);
          print_addr_index (idx, 8);
-         idx = read_uleb128 (start, &bytes_read, section_end);
-         start += bytes_read;
+         READ_ULEB (idx, start, section_end);
          print_addr_index (idx, 8);
          break;
        case 3: /* A start/length entry.  */
-         idx = read_uleb128 (start, &bytes_read, section_end);
-         start += bytes_read;
+         READ_ULEB (idx, start, section_end);
          print_addr_index (idx, 8);
          SAFE_BYTE_GET_AND_INC (idx, start, 4, section_end);
          printf ("%08x ", idx);
@@ -5938,12 +6201,12 @@ display_debug_loc (struct dwarf_section *section, void *file)
   unsigned char *next = start, *vnext = vstart;
   unsigned int *array = NULL;
   const char *suffix = strrchr (section->name, '.');
-  int is_dwo = 0;
+  bfd_boolean is_dwo = FALSE;
   int is_loclists = strstr (section->name, "debug_loclists") != NULL;
   dwarf_vma expected_start = 0;
 
   if (suffix && strcmp (suffix, ".dwo") == 0)
-    is_dwo = 1;
+    is_dwo = TRUE;
 
   bytes = section->size;
 
@@ -6405,8 +6668,8 @@ display_debug_aranges (struct dwarf_section *section,
 static int
 comp_addr_base (const void * v0, const void * v1)
 {
-  debug_info * info0 = (debug_info *) v0;
-  debug_info * info1 = (debug_info *) v1;
+  debug_info *info0 = *(debug_info **) v0;
+  debug_info *info1 = *(debug_info **) v1;
   return info0->addr_base - info1->addr_base;
 }
 
@@ -6489,6 +6752,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)
@@ -6543,6 +6807,7 @@ display_debug_ranges_list (unsigned char *start, unsigned char *finish,
        break;
       SAFE_SIGNED_BYTE_GET_AND_INC (end, start, pointer_size, finish);
 
+      
       printf ("    %8.8lx ", offset);
 
       if (begin == 0 && end == 0)
@@ -6587,7 +6852,6 @@ display_debug_rnglists_list (unsigned char *start, unsigned char *finish,
       enum dwarf_range_list_entry rlet;
       /* Initialize it due to a false compiler warning.  */
       dwarf_vma begin = -1, length, end = -1;
-      unsigned int bytes_read;
 
       if (start + 1 > finish)
        {
@@ -6612,15 +6876,12 @@ display_debug_rnglists_list (unsigned char *start, unsigned char *finish,
          break;
        case DW_RLE_start_length:
          SAFE_BYTE_GET_AND_INC (begin, start, pointer_size, finish);
-         length = read_uleb128 (start, &bytes_read, finish);
-         start += bytes_read;
+         READ_ULEB (length, start, finish);
          end = begin + length;
          break;
        case DW_RLE_offset_pair:
-         begin = read_uleb128 (start, &bytes_read, finish);
-         start += bytes_read;
-         end = read_uleb128 (start, &bytes_read, finish);
-         start += bytes_read;
+         READ_ULEB (begin, start, finish);
+         READ_ULEB (end, start, finish);
          break;
        case DW_RLE_start_end:
          SAFE_BYTE_GET_AND_INC (begin, start, pointer_size, finish);
@@ -6810,6 +7071,13 @@ display_debug_ranges (struct dwarf_section *section,
          continue;
        }
 
+      if (next < section_begin || next >= finish)
+       {
+         warn (_("Corrupt offset (%#8.8lx) in range entry %u\n"),
+               (unsigned long) offset, i);
+         continue;
+       }
+
       if (dwarf_check != 0 && i > 0)
        {
          if (start < next)
@@ -6825,6 +7093,7 @@ display_debug_ranges (struct dwarf_section *section,
                    (unsigned long) (next - section_begin), section->name);
            }
        }
+
       start = next;
       last_start = next;
 
@@ -6861,9 +7130,12 @@ typedef struct Frame_Chunk
 }
 Frame_Chunk;
 
+typedef const char *(*dwarf_regname_lookup_ftype) (unsigned int);
+static dwarf_regname_lookup_ftype dwarf_regnames_lookup_func;
 static const char *const *dwarf_regnames;
 static unsigned int dwarf_regnames_count;
 
+
 /* A marker for a col_type that means this column was never referenced
    in the frame info.  */
 #define DW_CFA_unreferenced (-1)
@@ -6879,7 +7151,7 @@ frame_need_space (Frame_Chunk *fc, unsigned int reg)
   if (reg < (unsigned int) fc->ncols)
     return 0;
 
-  if (dwarf_regnames_count
+  if (dwarf_regnames_count > 0
       && reg > dwarf_regnames_count)
     return -1;
 
@@ -6890,7 +7162,7 @@ frame_need_space (Frame_Chunk *fc, unsigned int reg)
     return -1;
 
   /* PR 17512: file: 2844a11d.  */
-  if (fc->ncols > 1024)
+  if (fc->ncols > 1024 && dwarf_regnames_count == 0)
     {
       error (_("Unfeasibly large register number: %u\n"), reg);
       fc->ncols = 0;
@@ -6965,18 +7237,20 @@ static const char *const dwarf_regnames_iamcu[] =
   NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL  /* 93 - 100  */
 };
 
-void
+static void
 init_dwarf_regnames_i386 (void)
 {
   dwarf_regnames = dwarf_regnames_i386;
   dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_i386);
+  dwarf_regnames_lookup_func = regname_internal_by_table_only;
 }
 
-void
+static void
 init_dwarf_regnames_iamcu (void)
 {
   dwarf_regnames = dwarf_regnames_iamcu;
   dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_iamcu);
+  dwarf_regnames_lookup_func = regname_internal_by_table_only;
 }
 
 static const char *const dwarf_regnames_x86_64[] =
@@ -7011,11 +7285,12 @@ static const char *const dwarf_regnames_x86_64[] =
   "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7"
 };
 
-void
+static void
 init_dwarf_regnames_x86_64 (void)
 {
   dwarf_regnames = dwarf_regnames_x86_64;
   dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_x86_64);
+  dwarf_regnames_lookup_func = regname_internal_by_table_only;
 }
 
 static const char *const dwarf_regnames_aarch64[] =
@@ -7025,20 +7300,25 @@ static const char *const dwarf_regnames_aarch64[] =
   "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,
+   NULL,  NULL,  NULL,  NULL,  NULL,  NULL,  "vg", "ffr",
+   "p0",  "p1",  "p2",  "p3",  "p4",  "p5",  "p6",  "p7",
+   "p8",  "p9", "p10", "p11", "p12", "p13", "p14", "p15",
    "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",
+   "z0",  "z1",  "z2",  "z3",  "z4",  "z5",  "z6",  "z7",
+   "z8",  "z9", "z10", "z11", "z12", "z13", "z14", "z15",
+  "z16", "z17", "z18", "z19", "z20", "z21", "z22", "z23",
+  "z24", "z25", "z26", "z27", "z28", "z29", "z30", "z31",
 };
 
-void
+static void
 init_dwarf_regnames_aarch64 (void)
 {
   dwarf_regnames = dwarf_regnames_aarch64;
   dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_aarch64);
+  dwarf_regnames_lookup_func = regname_internal_by_table_only;
 }
 
 static const char *const dwarf_regnames_s390[] =
@@ -7058,11 +7338,12 @@ static const char *const dwarf_regnames_s390[] =
   "v24", "v26", "v28", "v30", "v25", "v27", "v29", "v31",
 };
 
-void
+static void
 init_dwarf_regnames_s390 (void)
 {
   dwarf_regnames = dwarf_regnames_s390;
   dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_s390);
+  dwarf_regnames_lookup_func = regname_internal_by_table_only;
 }
 
 static const char *const dwarf_regnames_riscv[] =
@@ -7079,16 +7360,54 @@ static const char *const dwarf_regnames_riscv[] =
  "ft8",  "ft9",  "ft10", "ft11"                             /* 60 - 63 */
 };
 
-void
+/* A RISC-V replacement for REGNAME_INTERNAL_BY_TABLE_ONLY which handles
+   the large number of CSRs.  */
+
+static const char *
+regname_internal_riscv (unsigned int regno)
+{
+  const char *name = NULL;
+
+  /* Lookup in the table first, this covers GPR and FPR.  */
+  if (regno < ARRAY_SIZE (dwarf_regnames_riscv))
+    name = dwarf_regnames_riscv [regno];
+  else if (regno >= 4096 && regno <= 8191)
+    {
+      /* This might be a CSR, these live in a sparse number space from 4096
+        to 8191  These numbers are defined in the RISC-V ELF ABI
+        document.  */
+      switch (regno)
+       {
+#define DECLARE_CSR(NAME,VALUE,CLASS) case VALUE + 4096: name = #NAME; break;
+#include "opcode/riscv-opc.h"
+#undef DECLARE_CSR
+
+       default:
+         {
+           static char csr_name[10];
+           snprintf (csr_name, sizeof (csr_name), "csr%d", (regno - 4096));
+           name = csr_name;
+         }
+         break;
+       }
+    }
+
+  return name;
+}
+
+static void
 init_dwarf_regnames_riscv (void)
 {
-  dwarf_regnames = dwarf_regnames_riscv;
-  dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_riscv);
+  dwarf_regnames = NULL;
+  dwarf_regnames_count = 8192;
+  dwarf_regnames_lookup_func = regname_internal_riscv;
 }
 
 void
-init_dwarf_regnames (unsigned int e_machine)
+init_dwarf_regnames_by_elf_machine_code (unsigned int e_machine)
 {
+  dwarf_regnames_lookup_func = NULL;
+
   switch (e_machine)
     {
     case EM_386:
@@ -7122,19 +7441,82 @@ init_dwarf_regnames (unsigned int e_machine)
     }
 }
 
-static const char *
-regname (unsigned int regno, int row)
+/* Initialize the DWARF register name lookup state based on the
+   architecture and specific machine type of a BFD.  */
+
+void
+init_dwarf_regnames_by_bfd_arch_and_mach (enum bfd_architecture arch,
+                                         unsigned long mach)
 {
-  static char reg[64];
+  dwarf_regnames_lookup_func = NULL;
+
+  switch (arch)
+    {
+    case bfd_arch_i386:
+      switch (mach)
+       {
+       case bfd_mach_x86_64:
+       case bfd_mach_x86_64_intel_syntax:
+       case bfd_mach_x86_64_nacl:
+       case bfd_mach_x64_32:
+       case bfd_mach_x64_32_intel_syntax:
+       case bfd_mach_x64_32_nacl:
+         init_dwarf_regnames_x86_64 ();
+         break;
+
+       default:
+         init_dwarf_regnames_i386 ();
+         break;
+       }
+      break;
+
+    case bfd_arch_iamcu:
+      init_dwarf_regnames_iamcu ();
+      break;
+
+    case bfd_arch_aarch64:
+      init_dwarf_regnames_aarch64();
+      break;
+
+    case bfd_arch_s390:
+      init_dwarf_regnames_s390 ();
+      break;
+
+    case bfd_arch_riscv:
+      init_dwarf_regnames_riscv ();
+      break;
+
+    default:
+      break;
+    }
+}
 
-  if (dwarf_regnames
+static const char *
+regname_internal_by_table_only (unsigned int regno)
+{
+  if (dwarf_regnames != NULL
       && regno < dwarf_regnames_count
       && dwarf_regnames [regno] != NULL)
+    return dwarf_regnames [regno];
+
+  return NULL;
+}
+
+static const char *
+regname (unsigned int regno, int name_only_p)
+{
+  static char reg[64];
+
+  const char *name = NULL;
+
+  if (dwarf_regnames_lookup_func != NULL)
+    name = dwarf_regnames_lookup_func (regno);
+
+  if (name != NULL)
     {
-      if (row)
-       return dwarf_regnames [regno];
-      snprintf (reg, sizeof (reg), "r%d (%s)", regno,
-               dwarf_regnames [regno]);
+      if (name_only_p)
+       return name;
+      snprintf (reg, sizeof (reg), "r%d (%s)", regno, name);
     }
   else
     snprintf (reg, sizeof (reg), "r%d", regno);
@@ -7223,7 +7605,6 @@ read_cie (unsigned char *start, unsigned char *end,
 {
   int version;
   Frame_Chunk *fc;
-  unsigned int length_return;
   unsigned char *augmentation_data = NULL;
   bfd_size_type augmentation_data_len = 0;
 
@@ -7249,7 +7630,7 @@ read_cie (unsigned char *start, unsigned char *end,
   if (start == end)
     {
       warn (_("No terminator for augmentation name\n"));
-      return start;
+      goto fail;
     }
 
   if (strcmp (fc->augmentation, "eh") == 0)
@@ -7261,7 +7642,7 @@ read_cie (unsigned char *start, unsigned char *end,
       if (fc->ptr_size < 1 || fc->ptr_size > 8)
        {
          warn (_("Invalid pointer size (%d) in CIE data\n"), fc->ptr_size);
-         return end;
+         goto fail;
        }
 
       GET (fc->segment_size, 1);
@@ -7269,7 +7650,7 @@ read_cie (unsigned char *start, unsigned char *end,
       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;
+         goto fail;
        }
 
       eh_addr_size = fc->ptr_size;
@@ -7279,20 +7660,22 @@ read_cie (unsigned char *start, unsigned char *end,
       fc->ptr_size = eh_addr_size;
       fc->segment_size = 0;
     }
-  READ_ULEB (fc->code_factor);
-  READ_SLEB (fc->data_factor);
+
+  READ_ULEB (fc->code_factor, start, end);
+  READ_SLEB (fc->data_factor, start, end);
+
   if (version == 1)
     {
       GET (fc->ra, 1);
     }
   else
     {
-      READ_ULEB (fc->ra);
+      READ_ULEB (fc->ra, start, end);
     }
 
   if (fc->augmentation[0] == 'z')
     {
-      READ_ULEB (augmentation_data_len);
+      READ_ULEB (augmentation_data_len, start, end);
       augmentation_data = start;
       /* PR 17512: file: 11042-2589-0.004.  */
       if (augmentation_data_len > (bfd_size_type) (end - start))
@@ -7300,7 +7683,7 @@ read_cie (unsigned char *start, unsigned char *end,
          warn (_("Augmentation data too long: 0x%s, expected at most %#lx\n"),
                dwarf_vmatoa ("x", augmentation_data_len),
                (unsigned long) (end - start));
-         return end;
+         goto fail;
        }
       start += augmentation_data_len;
     }
@@ -7325,6 +7708,8 @@ read_cie (unsigned char *start, unsigned char *end,
            fc->fde_encoding = *q++;
          else if (*p == 'S')
            ;
+         else if (*p == 'B')
+           ;
          else
            break;
          p++;
@@ -7342,6 +7727,12 @@ read_cie (unsigned char *start, unsigned char *end,
       *p_aug = augmentation_data;
     }
   return start;
+
+ fail:
+  free (fc->col_offset);
+  free (fc->col_type);
+  free (fc);
+  return end;
 }
 
 /* Prints out the contents on the DATA array formatted as unsigned bytes.
@@ -7387,11 +7778,10 @@ display_debug_frames (struct dwarf_section *section,
   unsigned char *start = section->start;
   unsigned char *end = start + section->size;
   unsigned char *section_start = start;
-  Frame_Chunk *chunks = 0, *forward_refs = 0;
-  Frame_Chunk *remembered_state = 0;
+  Frame_Chunk *chunks = NULL, *forward_refs = NULL;
+  Frame_Chunk *remembered_state = NULL;
   Frame_Chunk *rs;
-  int is_eh = strcmp (section->name, ".eh_frame") == 0;
-  unsigned int length_return;
+  bfd_boolean is_eh = strcmp (section->name, ".eh_frame") == 0;
   unsigned int max_regs = 0;
   const char *bad_reg = _("bad register: ");
   unsigned int saved_eh_addr_size = eh_addr_size;
@@ -7413,6 +7803,7 @@ display_debug_frames (struct dwarf_section *section,
       unsigned int offset_size;
       unsigned int initial_length_size;
       bfd_boolean all_nops;
+      static Frame_Chunk fde_fc;
 
       saved_start = start;
 
@@ -7510,7 +7901,6 @@ display_debug_frames (struct dwarf_section *section,
       else
        {
          unsigned char *look_for;
-         static Frame_Chunk fde_fc;
          unsigned long segment_selector;
 
          if (is_eh)
@@ -7656,20 +8046,20 @@ display_debug_frames (struct dwarf_section *section,
 
          if (cie->augmentation[0] == 'z')
            {
-             READ_ULEB (augmentation_data_len);
+             READ_ULEB (augmentation_data_len, start, end);
              augmentation_data = start;
-             start += augmentation_data_len;
              /* PR 17512 file: 722-8446-0.004 and PR 22386.  */
-             if (start >= end
-                 || ((bfd_signed_vma) augmentation_data_len) < 0
-                 || augmentation_data > start)
+             if (augmentation_data_len > (bfd_size_type) (end - start))
                {
-                 warn (_("Corrupt augmentation data length: 0x%s\n"),
-                       dwarf_vmatoa ("x", augmentation_data_len));
+                 warn (_("Augmentation data too long: 0x%s, "
+                         "expected at most %#lx\n"),
+                       dwarf_vmatoa ("x", augmentation_data_len),
+                       (unsigned long) (end - start));
                  start = end;
                  augmentation_data = NULL;
                  augmentation_data_len = 0;
                }
+             start += augmentation_data_len;
            }
 
          printf ("\n%08lx %s %s FDE cie=%08lx pc=",
@@ -7723,7 +8113,7 @@ display_debug_frames (struct dwarf_section *section,
                case DW_CFA_advance_loc:
                  break;
                case DW_CFA_offset:
-                 SKIP_ULEB ();
+                 SKIP_ULEB (start, end);
                  if (frame_need_space (fc, opa) >= 0)
                    fc->col_type[opa] = DW_CFA_undefined;
                  break;
@@ -7745,44 +8135,44 @@ display_debug_frames (struct dwarf_section *section,
                  break;
                case DW_CFA_offset_extended:
                case DW_CFA_val_offset:
-                 READ_ULEB (reg);
-                 SKIP_ULEB ();
+                 READ_ULEB (reg, start, end);
+                 SKIP_ULEB (start, end);
                  if (frame_need_space (fc, reg) >= 0)
                    fc->col_type[reg] = DW_CFA_undefined;
                  break;
                case DW_CFA_restore_extended:
-                 READ_ULEB (reg);
+                 READ_ULEB (reg, start, end);
                  if (frame_need_space (fc, reg) >= 0)
                    fc->col_type[reg] = DW_CFA_undefined;
                  break;
                case DW_CFA_undefined:
-                 READ_ULEB (reg);
+                 READ_ULEB (reg, start, end);
                  if (frame_need_space (fc, reg) >= 0)
                    fc->col_type[reg] = DW_CFA_undefined;
                  break;
                case DW_CFA_same_value:
-                 READ_ULEB (reg);
+                 READ_ULEB (reg, start, end);
                  if (frame_need_space (fc, reg) >= 0)
                    fc->col_type[reg] = DW_CFA_undefined;
                  break;
                case DW_CFA_register:
-                 READ_ULEB (reg);
-                 SKIP_ULEB ();
+                 READ_ULEB (reg, start, end);
+                 SKIP_ULEB (start, end);
                  if (frame_need_space (fc, reg) >= 0)
                    fc->col_type[reg] = DW_CFA_undefined;
                  break;
                case DW_CFA_def_cfa:
-                 SKIP_ULEB ();
-                 SKIP_ULEB ();
+                 SKIP_ULEB (start, end);
+                 SKIP_ULEB (start, end);
                  break;
                case DW_CFA_def_cfa_register:
-                 SKIP_ULEB ();
+                 SKIP_ULEB (start, end);
                  break;
                case DW_CFA_def_cfa_offset:
-                 SKIP_ULEB ();
+                 SKIP_ULEB (start, end);
                  break;
                case DW_CFA_def_cfa_expression:
-                 READ_ULEB (temp);
+                 READ_ULEB (temp, start, end);
                  new_start = start + temp;
                  if (new_start < start)
                    {
@@ -7794,8 +8184,8 @@ display_debug_frames (struct dwarf_section *section,
                  break;
                case DW_CFA_expression:
                case DW_CFA_val_expression:
-                 READ_ULEB (reg);
-                 READ_ULEB (temp);
+                 READ_ULEB (reg, start, end);
+                 READ_ULEB (temp, start, end);
                  new_start = start + temp;
                  if (new_start < start)
                    {
@@ -7810,27 +8200,27 @@ display_debug_frames (struct dwarf_section *section,
                  break;
                case DW_CFA_offset_extended_sf:
                case DW_CFA_val_offset_sf:
-                 READ_ULEB (reg);
-                 SKIP_SLEB ();
+                 READ_ULEB (reg, start, end);
+                 SKIP_SLEB (start, end);
                  if (frame_need_space (fc, reg) >= 0)
                    fc->col_type[reg] = DW_CFA_undefined;
                  break;
                case DW_CFA_def_cfa_sf:
-                 SKIP_ULEB ();
-                 SKIP_SLEB ();
+                 SKIP_ULEB (start, end);
+                 SKIP_SLEB (start, end);
                  break;
                case DW_CFA_def_cfa_offset_sf:
-                 SKIP_SLEB ();
+                 SKIP_SLEB (start, end);
                  break;
                case DW_CFA_MIPS_advance_loc8:
                  start += 8;
                  break;
                case DW_CFA_GNU_args_size:
-                 SKIP_ULEB ();
+                 SKIP_ULEB (start, end);
                  break;
                case DW_CFA_GNU_negative_offset_extended:
-                 READ_ULEB (reg);
-                 SKIP_ULEB ();
+                 READ_ULEB (reg, start, end);
+                 SKIP_ULEB (start, end);
                  if (frame_need_space (fc, reg) >= 0)
                    fc->col_type[reg] = DW_CFA_undefined;
                  break;
@@ -7886,7 +8276,7 @@ display_debug_frames (struct dwarf_section *section,
              break;
 
            case DW_CFA_offset:
-             READ_ULEB (roffs);
+             READ_ULEB (roffs, start, end);
              if (opa >= (unsigned int) fc->ncols)
                reg_prefix = bad_reg;
              if (! do_debug_frames_interp || *reg_prefix != '\0')
@@ -7973,8 +8363,8 @@ display_debug_frames (struct dwarf_section *section,
              break;
 
            case DW_CFA_offset_extended:
-             READ_ULEB (reg);
-             READ_ULEB (roffs);
+             READ_ULEB (reg, start, end);
+             READ_ULEB (roffs, start, end);
              if (reg >= (unsigned int) fc->ncols)
                reg_prefix = bad_reg;
              if (! do_debug_frames_interp || *reg_prefix != '\0')
@@ -7989,8 +8379,8 @@ display_debug_frames (struct dwarf_section *section,
              break;
 
            case DW_CFA_val_offset:
-             READ_ULEB (reg);
-             READ_ULEB (roffs);
+             READ_ULEB (reg, start, end);
+             READ_ULEB (roffs, start, end);
              if (reg >= (unsigned int) fc->ncols)
                reg_prefix = bad_reg;
              if (! do_debug_frames_interp || *reg_prefix != '\0')
@@ -8005,7 +8395,7 @@ display_debug_frames (struct dwarf_section *section,
              break;
 
            case DW_CFA_restore_extended:
-             READ_ULEB (reg);
+             READ_ULEB (reg, start, end);
              if (reg >= (unsigned int) fc->ncols)
                reg_prefix = bad_reg;
              if (! do_debug_frames_interp || *reg_prefix != '\0')
@@ -8027,7 +8417,7 @@ display_debug_frames (struct dwarf_section *section,
              break;
 
            case DW_CFA_undefined:
-             READ_ULEB (reg);
+             READ_ULEB (reg, start, end);
              if (reg >= (unsigned int) fc->ncols)
                reg_prefix = bad_reg;
              if (! do_debug_frames_interp || *reg_prefix != '\0')
@@ -8041,7 +8431,7 @@ display_debug_frames (struct dwarf_section *section,
              break;
 
            case DW_CFA_same_value:
-             READ_ULEB (reg);
+             READ_ULEB (reg, start, end);
              if (reg >= (unsigned int) fc->ncols)
                reg_prefix = bad_reg;
              if (! do_debug_frames_interp || *reg_prefix != '\0')
@@ -8055,8 +8445,8 @@ display_debug_frames (struct dwarf_section *section,
              break;
 
            case DW_CFA_register:
-             READ_ULEB (reg);
-             READ_ULEB (roffs);
+             READ_ULEB (reg, start, end);
+             READ_ULEB (roffs, start, end);
              if (reg >= (unsigned int) fc->ncols)
                reg_prefix = bad_reg;
              if (! do_debug_frames_interp || *reg_prefix != '\0')
@@ -8119,8 +8509,8 @@ display_debug_frames (struct dwarf_section *section,
              break;
 
            case DW_CFA_def_cfa:
-             READ_ULEB (fc->cfa_reg);
-             READ_ULEB (fc->cfa_offset);
+             READ_ULEB (fc->cfa_reg, start, end);
+             READ_ULEB (fc->cfa_offset, start, end);
              fc->cfa_exp = 0;
              if (! do_debug_frames_interp)
                printf ("  DW_CFA_def_cfa: %s ofs %d\n",
@@ -8128,7 +8518,7 @@ display_debug_frames (struct dwarf_section *section,
              break;
 
            case DW_CFA_def_cfa_register:
-             READ_ULEB (fc->cfa_reg);
+             READ_ULEB (fc->cfa_reg, start, end);
              fc->cfa_exp = 0;
              if (! do_debug_frames_interp)
                printf ("  DW_CFA_def_cfa_register: %s\n",
@@ -8136,7 +8526,7 @@ display_debug_frames (struct dwarf_section *section,
              break;
 
            case DW_CFA_def_cfa_offset:
-             READ_ULEB (fc->cfa_offset);
+             READ_ULEB (fc->cfa_offset, start, end);
              if (! do_debug_frames_interp)
                printf ("  DW_CFA_def_cfa_offset: %d\n", (int) fc->cfa_offset);
              break;
@@ -8147,7 +8537,7 @@ display_debug_frames (struct dwarf_section *section,
              break;
 
            case DW_CFA_def_cfa_expression:
-             READ_ULEB (ul);
+             READ_ULEB (ul, start, end);
              if (start >= block_end || ul > (unsigned long) (block_end - start))
                {
                  printf (_("  DW_CFA_def_cfa_expression: <corrupt len %lu>\n"), ul);
@@ -8165,8 +8555,8 @@ display_debug_frames (struct dwarf_section *section,
              break;
 
            case DW_CFA_expression:
-             READ_ULEB (reg);
-             READ_ULEB (ul);
+             READ_ULEB (reg, start, end);
+             READ_ULEB (ul, start, end);
              if (reg >= (unsigned int) fc->ncols)
                reg_prefix = bad_reg;
              /* PR 17512: file: 069-133014-0.006.  */
@@ -8191,8 +8581,8 @@ display_debug_frames (struct dwarf_section *section,
              break;
 
            case DW_CFA_val_expression:
-             READ_ULEB (reg);
-             READ_ULEB (ul);
+             READ_ULEB (reg, start, end);
+             READ_ULEB (ul, start, end);
              if (reg >= (unsigned int) fc->ncols)
                reg_prefix = bad_reg;
              tmp = start + ul;
@@ -8215,8 +8605,8 @@ display_debug_frames (struct dwarf_section *section,
              break;
 
            case DW_CFA_offset_extended_sf:
-             READ_ULEB (reg);
-             READ_SLEB (l);
+             READ_ULEB (reg, start, end);
+             READ_SLEB (l, start, end);
              if (frame_need_space (fc, reg) < 0)
                reg_prefix = bad_reg;
              if (! do_debug_frames_interp || *reg_prefix != '\0')
@@ -8231,8 +8621,8 @@ display_debug_frames (struct dwarf_section *section,
              break;
 
            case DW_CFA_val_offset_sf:
-             READ_ULEB (reg);
-             READ_SLEB (l);
+             READ_ULEB (reg, start, end);
+             READ_SLEB (l, start, end);
              if (frame_need_space (fc, reg) < 0)
                reg_prefix = bad_reg;
              if (! do_debug_frames_interp || *reg_prefix != '\0')
@@ -8247,8 +8637,8 @@ display_debug_frames (struct dwarf_section *section,
              break;
 
            case DW_CFA_def_cfa_sf:
-             READ_ULEB (fc->cfa_reg);
-             READ_ULEB (fc->cfa_offset);
+             READ_ULEB (fc->cfa_reg, start, end);
+             READ_ULEB (fc->cfa_offset, start, end);
              fc->cfa_offset = fc->cfa_offset * fc->data_factor;
              fc->cfa_exp = 0;
              if (! do_debug_frames_interp)
@@ -8257,7 +8647,7 @@ display_debug_frames (struct dwarf_section *section,
              break;
 
            case DW_CFA_def_cfa_offset_sf:
-             READ_ULEB (fc->cfa_offset);
+             READ_ULEB (fc->cfa_offset, start, end);
              fc->cfa_offset *= fc->data_factor;
              if (! do_debug_frames_interp)
                printf ("  DW_CFA_def_cfa_offset_sf: %d\n", (int) fc->cfa_offset);
@@ -8282,14 +8672,14 @@ display_debug_frames (struct dwarf_section *section,
              break;
 
            case DW_CFA_GNU_args_size:
-             READ_ULEB (ul);
+             READ_ULEB (ul, start, end);
              if (! do_debug_frames_interp)
                printf ("  DW_CFA_GNU_args_size: %ld\n", ul);
              break;
 
            case DW_CFA_GNU_negative_offset_extended:
-             READ_ULEB (reg);
-             READ_SLEB (l);
+             READ_ULEB (reg, start, end);
+             READ_SLEB (l, start, end);
              l = - l;
              if (frame_need_space (fc, reg) < 0)
                reg_prefix = bad_reg;
@@ -8317,12 +8707,53 @@ display_debug_frames (struct dwarf_section *section,
       if (do_debug_frames_interp && ! all_nops)
        frame_display_row (fc, &need_col_headers, &max_regs);
 
+      if (fde_fc.col_type != NULL)
+       {
+         free (fde_fc.col_type);
+         fde_fc.col_type = NULL;
+       }
+      if (fde_fc.col_offset != NULL)
+       {
+         free (fde_fc.col_offset);
+         fde_fc.col_offset = NULL;
+       }
+
       start = block_end;
       eh_addr_size = saved_eh_addr_size;
     }
 
   printf ("\n");
 
+  while (remembered_state != NULL)
+    {
+      rs = remembered_state;
+      remembered_state = rs->next;
+      free (rs->col_type);
+      free (rs->col_offset);
+      rs->next = NULL; /* Paranoia.  */
+      free (rs);
+    }
+
+  while (chunks != NULL)
+    {
+      rs = chunks;
+      chunks = rs->next;
+      free (rs->col_type);
+      free (rs->col_offset);
+      rs->next = NULL; /* Paranoia.  */
+      free (rs);
+    }
+
+  while (forward_refs != NULL)
+    {
+      rs = forward_refs;
+      forward_refs = rs->next;
+      free (rs->col_type);
+      free (rs->col_offset);
+      rs->next = NULL; /* Paranoia.  */
+      free (rs);
+    }
+
   return 1;
 }
 
@@ -8350,6 +8781,8 @@ display_debug_names (struct dwarf_section *section, void *file)
       uint32_t augmentation_string_size;
       unsigned int i;
       unsigned long sec_off;
+      bfd_boolean augmentation_printable;
+      const char *augmentation_string;
 
       unit_start = hdrptr;
 
@@ -8413,15 +8846,32 @@ display_debug_names (struct dwarf_section *section, void *file)
                augmentation_string_size);
          augmentation_string_size += (-augmentation_string_size) & 3;
        }
+
       printf (_("Augmentation string:"));
+
+      augmentation_printable = TRUE;
+      augmentation_string = (const char *) hdrptr;
+
       for (i = 0; i < augmentation_string_size; i++)
        {
          unsigned char uc;
 
          SAFE_BYTE_GET_AND_INC (uc, hdrptr, 1, unit_end);
          printf (" %02x", uc);
+
+         if (uc != 0 && !ISPRINT (uc))
+           augmentation_printable = FALSE;
+       }
+
+      if (augmentation_printable)
+       {
+         printf ("  (\"");
+         for (i = 0;
+              i < augmentation_string_size && augmentation_string[i];
+              ++i)
+           putchar (augmentation_string[i]);
+         printf ("\")");
        }
-      putchar ('\n');
       putchar ('\n');
 
       printf (_("CU table:\n"));
@@ -8531,10 +8981,9 @@ display_debug_names (struct dwarf_section *section, void *file)
       unsigned char *abbrevptr = abbrev_table;
       for (;;)
        {
-         unsigned int bytes_read;
-         const dwarf_vma abbrev_tag = read_uleb128 (abbrevptr, &bytes_read,
-                                                    abbrev_table_end);
-         abbrevptr += bytes_read;
+         dwarf_vma abbrev_tag;
+
+         READ_ULEB (abbrev_tag, abbrevptr, abbrev_table_end);
          if (abbrev_tag == 0)
            break;
          if (abbrev_lookup_used == abbrev_lookup_allocated)
@@ -8562,17 +9011,13 @@ display_debug_names (struct dwarf_section *section, void *file)
          entry->abbrev_lookup_ptr = abbrevptr;
 
          /* Skip DWARF tag.  */
-         read_uleb128 (abbrevptr, &bytes_read, abbrev_table_end);
-         abbrevptr += bytes_read;
+         SKIP_ULEB (abbrevptr, abbrev_table_end);
          for (;;)
            {
-             const dwarf_vma xindex = read_uleb128 (abbrevptr,
-                                                    &bytes_read,
-                                                    abbrev_table_end);
-             abbrevptr += bytes_read;
-             const dwarf_vma form = read_uleb128 (abbrevptr, &bytes_read,
-                                                  abbrev_table_end);
-             abbrevptr += bytes_read;
+             dwarf_vma xindex, form;
+
+             READ_ULEB (xindex, abbrevptr, abbrev_table_end);
+             READ_ULEB (form, abbrevptr, abbrev_table_end);
              if (xindex == 0 && form == 0)
                break;
            }
@@ -8605,10 +9050,11 @@ display_debug_names (struct dwarf_section *section, void *file)
          dwarf_vma second_abbrev_tag = -1;
          for (;;)
            {
-             unsigned int bytes_read;
-             const dwarf_vma abbrev_tag = read_uleb128 (entryptr, &bytes_read,
-                                                        unit_end);
-             entryptr += bytes_read;
+             dwarf_vma abbrev_tag;
+             dwarf_vma dwarf_tag;
+             const struct abbrev_lookup_entry *entry;
+
+             READ_ULEB (abbrev_tag, entryptr, unit_end);
              if (tagno == -1)
                {
                  second_abbrev_tag = abbrev_tag;
@@ -8623,7 +9069,6 @@ display_debug_names (struct dwarf_section *section, void *file)
                        (tagno == 0 && second_abbrev_tag == 0 ? " " : "\n\t"),
                        (unsigned long) abbrev_tag);
 
-             const struct abbrev_lookup_entry *entry;
              for (entry = abbrev_lookup;
                   entry < abbrev_lookup + abbrev_lookup_used;
                   entry++)
@@ -8638,31 +9083,26 @@ display_debug_names (struct dwarf_section *section, void *file)
                  break;
                }
              abbrevptr = entry->abbrev_lookup_ptr;
-             const dwarf_vma dwarf_tag = read_uleb128 (abbrevptr, &bytes_read,
-                                                       abbrev_table_end);
-             abbrevptr += bytes_read;
+             READ_ULEB (dwarf_tag, abbrevptr, abbrev_table_end);
              if (tagno >= 0)
                printf (" %s", get_TAG_name (dwarf_tag));
              for (;;)
                {
-                 const dwarf_vma xindex = read_uleb128 (abbrevptr,
-                                                        &bytes_read,
-                                                        abbrev_table_end);
-                 abbrevptr += bytes_read;
-                 const dwarf_vma form = read_uleb128 (abbrevptr, &bytes_read,
-                                                      abbrev_table_end);
-                 abbrevptr += bytes_read;
+                 dwarf_vma xindex, form;
+
+                 READ_ULEB (xindex, abbrevptr, abbrev_table_end);
+                 READ_ULEB (form, abbrevptr, abbrev_table_end);
                  if (xindex == 0 && form == 0)
                    break;
 
                  if (tagno >= 0)
                    printf (" %s", get_IDX_name (xindex));
-                 entryptr = read_and_display_attr_value (0, form, 0, entryptr,
-                                                         unit_end, 0, 0,
-                                                         offset_size,
+                 entryptr = read_and_display_attr_value (0, form, 0,
+                                                         unit_start, entryptr, unit_end,
+                                                         0, 0, offset_size,
                                                          dwarf_version, NULL,
                                                          (tagno < 0), NULL,
-                                                         NULL, '=');
+                                                         NULL, '=', -1);
                }
              ++tagno;
            }
@@ -9101,33 +9541,29 @@ process_cu_tu_index (struct dwarf_section *section, int do_display)
   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 (ngettext ("Section %s is too small for %d slot\n",
-                     "Section %s is too small for %d slots\n",
-                     nslots),
-           section->name, nslots);
-      return 0;
-    }
+  pindex = phash + (size_t) nslots * 8;
+  ppool = pindex + (size_t) nslots * 4;
 
   if (do_display)
     {
       introduce (section, FALSE);
 
-      printf (_("  Version:                 %d\n"), version);
+      printf (_("  Version:                 %u\n"), version);
       if (version >= 2)
-       printf (_("  Number of columns:       %d\n"), ncols);
-      printf (_("  Number of used entries:  %d\n"), nused);
-      printf (_("  Number of slots:         %d\n\n"), nslots);
+       printf (_("  Number of columns:       %u\n"), ncols);
+      printf (_("  Number of used entries:  %u\n"), nused);
+      printf (_("  Number of slots:         %u\n\n"), nslots);
     }
 
-  if (ppool > limit || ppool < phdr)
+  /* PR 17531: file: 45d69832.  */
+  if ((size_t) nslots * 8 / 8 != nslots
+      || phash < phdr || phash > limit
+      || pindex < phash || pindex > limit
+      || ppool < pindex || ppool > limit)
     {
-      warn (_("Section %s too small for %d hash table entries\n"),
+      warn (ngettext ("Section %s is too small for %u slot\n",
+                     "Section %s is too small for %u slots\n",
+                     nslots),
            section->name, nslots);
       return 0;
     }
@@ -9189,9 +9625,9 @@ process_cu_tu_index (struct dwarf_section *section, int do_display)
       unsigned int dw_sect;
       unsigned char *ph = phash;
       unsigned char *pi = pindex;
-      unsigned char *poffsets = ppool + ncols * 4;
-      unsigned char *psizes = poffsets + nused * ncols * 4;
-      unsigned char *pend = psizes + nused * ncols * 4;
+      unsigned char *poffsets = ppool + (size_t) ncols * 4;
+      unsigned char *psizes = poffsets + (size_t) nused * ncols * 4;
+      unsigned char *pend = psizes + (size_t) nused * ncols * 4;
       bfd_boolean is_tu_index;
       struct cu_tu_set *this_set = NULL;
       unsigned int row;
@@ -9200,14 +9636,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)
+        Check for integer overflow (can occur when size_t is 32-bit)
+        with overlarge ncols or nused values.  */
+      if (ncols > 0
+         && ((size_t) ncols * 4 / 4 != ncols
+             || (size_t) nused * ncols * 4 / ((size_t) ncols * 4) != nused
+             || poffsets < ppool || poffsets > limit
+             || psizes < poffsets || psizes > limit
+             || pend < psizes || pend > limit))
        {
          warn (_("Section %s too small for offset and size tables\n"),
                section->name);
@@ -9262,7 +9698,18 @@ process_cu_tu_index (struct dwarf_section *section, int do_display)
                }
 
              if (!do_display)
-               memcpy (&this_set[row - 1].signature, ph, sizeof (uint64_t));
+               {
+                 size_t num_copy = sizeof (uint64_t);
+
+                 /* PR 23064: Beware of buffer overflow.  */
+                 if (ph + num_copy < limit)
+                   memcpy (&this_set[row - 1].signature, ph, num_copy);
+                 else
+                   {
+                     warn (_("Signature (%p) extends beyond end of space in section\n"), ph);
+                     return 0;
+                   }
+               }
 
              prow = poffsets + (row - 1) * ncols * 4;
              /* PR 17531: file: b8ce60a8.  */
@@ -9625,6 +10072,7 @@ parse_gnu_debuglink (struct dwarf_section * section, void * data)
      The CRC value is stored after the filename, aligned up to 4 bytes.  */
   name = (const char *) section->start;
 
+  
   crc_offset = strnlen (name, section->size) + 1;
   crc_offset = (crc_offset + 3) & ~3;
   if (crc_offset + 4 > section->size)
@@ -9686,15 +10134,97 @@ parse_gnu_debugaltlink (struct dwarf_section * section, void * data)
   return name;
 }
 
+static void
+add_separate_debug_file (const char * filename, void * handle)
+{
+  separate_info * i = xmalloc (sizeof * i);
+
+  i->filename = filename;
+  i->handle   = handle;
+  i->next     = first_separate_info;
+  first_separate_info = i;
+}
+
+#if HAVE_LIBDEBUGINFOD
+/* Query debuginfod servers for the target debuglink or debugaltlink
+   file. If successful, store the path of the file in filename and
+   return TRUE, otherwise return FALSE.  */
+
+static bfd_boolean
+debuginfod_fetch_separate_debug_info (struct dwarf_section * section,
+                                      char ** filename,
+                                      void * file)
+{
+  size_t build_id_len;
+  unsigned char * build_id;
+
+  if (strcmp (section->uncompressed_name, ".gnu_debuglink") == 0)
+    {
+      /* Get the build-id of file.  */
+      build_id = get_build_id (file);
+      build_id_len = 0;
+    }
+  else if (strcmp (section->uncompressed_name, ".gnu_debugaltlink") == 0)
+    {
+      /* Get the build-id of the debugaltlink file.  */
+      unsigned int filelen;
+
+      filelen = strnlen ((const char *)section->start, section->size);
+      if (filelen == section->size)
+        /* Corrupt debugaltlink.  */
+        return FALSE;
+
+      build_id = section->start + filelen + 1;
+      build_id_len = section->size - (filelen + 1);
+
+      if (build_id_len == 0)
+        return FALSE;
+    }
+  else
+    return FALSE;
+
+  if (build_id)
+    {
+      int fd;
+      debuginfod_client * client;
+
+      client = debuginfod_begin ();
+      if (client == NULL)
+        return FALSE;
+
+      /* Query debuginfod servers for the target file. If found its path
+         will be stored in filename.  */
+      fd = debuginfod_find_debuginfo (client, build_id, build_id_len, filename);
+      debuginfod_end (client);
+
+      /* Only free build_id if we allocated space for a hex string
+         in get_build_id ().  */
+      if (build_id_len == 0)
+        free (build_id);
+
+      if (fd >= 0)
+        {
+          /* File successfully retrieved. Close fd since we want to
+             use open_debug_file () on filename instead.  */
+          close (fd);
+          return TRUE;
+        }
+    }
+
+  return FALSE;
+}
+#endif
+
 static void *
 load_separate_debug_info (const char *            main_filename,
                          struct dwarf_section *  xlink,
                          parse_func_type         parse_func,
                          check_func_type         check_func,
-                         void *                  func_data)
+                         void *                  func_data,
+                          void *                  file ATTRIBUTE_UNUSED)
 {
   const char *   separate_filename;
-  char *         debugfile;
+  char *         debug_filename;
   char *         canon_dir;
   size_t         canon_dirlen;
   size_t         dirlen;
@@ -9726,189 +10256,253 @@ load_separate_debug_info (const char *            main_filename,
 #define EXTRA_DEBUG_ROOT2 "/usr/lib/debug/usr"
 #endif
 
-  debugfile = (char *) malloc (strlen (DEBUGDIR) + 1
-                              + canon_dirlen
-                              + strlen (".debug/")
+  debug_filename = (char *) malloc (strlen (DEBUGDIR) + 1
+                                   + canon_dirlen
+                                   + strlen (".debug/")
 #ifdef EXTRA_DEBUG_ROOT1
-                              + strlen (EXTRA_DEBUG_ROOT1)
+                                   + strlen (EXTRA_DEBUG_ROOT1)
 #endif
 #ifdef EXTRA_DEBUG_ROOT2
-                              + strlen (EXTRA_DEBUG_ROOT2)
+                                   + strlen (EXTRA_DEBUG_ROOT2)
 #endif
-                              + strlen (separate_filename)
-                              + 1);
-  if (debugfile == NULL)
+                                   + strlen (separate_filename)
+                                   + 1);
+  if (debug_filename == NULL)
     {
       warn (_("Out of memory"));
+      free (canon_dir);
       return NULL;
     }
 
   /* First try in the current directory.  */
-  sprintf (debugfile, "%s", separate_filename);
-  if (check_func (debugfile, func_data))
+  sprintf (debug_filename, "%s", separate_filename);
+  if (check_func (debug_filename, func_data))
     goto found;
 
   /* Then try in a subdirectory called .debug.  */
-  sprintf (debugfile, ".debug/%s", separate_filename);
-  if (check_func (debugfile, func_data))
+  sprintf (debug_filename, ".debug/%s", separate_filename);
+  if (check_func (debug_filename, func_data))
     goto found;
 
   /* Then try in the same directory as the original file.  */
-  sprintf (debugfile, "%s%s", canon_dir, separate_filename);
-  if (check_func (debugfile, func_data))
+  sprintf (debug_filename, "%s%s", canon_dir, separate_filename);
+  if (check_func (debug_filename, func_data))
     goto found;
 
   /* And the .debug subdirectory of that directory.  */
-  sprintf (debugfile, "%s.debug/%s", canon_dir, separate_filename);
-  if (check_func (debugfile, func_data))
+  sprintf (debug_filename, "%s.debug/%s", canon_dir, separate_filename);
+  if (check_func (debug_filename, func_data))
     goto found;
 
 #ifdef EXTRA_DEBUG_ROOT1
   /* Try the first extra debug file root.  */
-  sprintf (debugfile, "%s/%s", EXTRA_DEBUG_ROOT1, separate_filename);
-  if (check_func (debugfile, func_data))
+  sprintf (debug_filename, "%s/%s", EXTRA_DEBUG_ROOT1, separate_filename);
+  if (check_func (debug_filename, func_data))
+    goto found;
+
+  /* Try the first extra debug file root.  */
+  sprintf (debug_filename, "%s/%s/%s", EXTRA_DEBUG_ROOT1, canon_dir, separate_filename);
+  if (check_func (debug_filename, func_data))
     goto found;
 #endif
 
 #ifdef EXTRA_DEBUG_ROOT2
   /* Try the second extra debug file root.  */
-  sprintf (debugfile, "%s/%s", EXTRA_DEBUG_ROOT2, separate_filename);
-  if (check_func (debugfile, func_data))
+  sprintf (debug_filename, "%s/%s", EXTRA_DEBUG_ROOT2, separate_filename);
+  if (check_func (debug_filename, func_data))
     goto found;
 #endif
 
-  /* Then try in the global debugfile directory.  */
-  strcpy (debugfile, DEBUGDIR);
+  /* Then try in the global debug_filename directory.  */
+  strcpy (debug_filename, DEBUGDIR);
   dirlen = strlen (DEBUGDIR) - 1;
   if (dirlen > 0 && DEBUGDIR[dirlen] != '/')
-    strcat (debugfile, "/");
-  strcat (debugfile, (const char *) separate_filename);
+    strcat (debug_filename, "/");
+  strcat (debug_filename, (const char *) separate_filename);
 
-  if (check_func (debugfile, func_data))
+  if (check_func (debug_filename, func_data))
     goto found;
 
+#if HAVE_LIBDEBUGINFOD
+  {
+    char * tmp_filename;
+
+    if (debuginfod_fetch_separate_debug_info (xlink,
+                                              & tmp_filename,
+                                              file))
+      {
+        /* File successfully downloaded from server, replace
+           debug_filename with the file's path.  */
+        free (debug_filename);
+        debug_filename = tmp_filename;
+        goto found;
+      }
+  }
+#endif
+
   /* Failed to find the file.  */
   warn (_("could not find separate debug file '%s'\n"), separate_filename);
-  warn (_("tried: %s\n"), debugfile);
+  warn (_("tried: %s\n"), debug_filename);
 
 #ifdef EXTRA_DEBUG_ROOT2
-  sprintf (debugfile, "%s/%s", EXTRA_DEBUG_ROOT2, separate_filename);
-  warn (_("tried: %s\n"), debugfile);
+  sprintf (debug_filename, "%s/%s", EXTRA_DEBUG_ROOT2, separate_filename);
+  warn (_("tried: %s\n"), debug_filename);
 #endif
 
 #ifdef EXTRA_DEBUG_ROOT1
-  sprintf (debugfile, "%s/%s", EXTRA_DEBUG_ROOT1, separate_filename);
-  warn (_("tried: %s\n"), debugfile);
+  sprintf (debug_filename, "%s/%s/%s", EXTRA_DEBUG_ROOT1, canon_dir, separate_filename);
+  warn (_("tried: %s\n"), debug_filename);
+
+  sprintf (debug_filename, "%s/%s", EXTRA_DEBUG_ROOT1, separate_filename);
+  warn (_("tried: %s\n"), debug_filename);
 #endif
 
-  sprintf (debugfile, "%s.debug/%s", canon_dir, separate_filename);
-  warn (_("tried: %s\n"), debugfile);
+  sprintf (debug_filename, "%s.debug/%s", canon_dir, separate_filename);
+  warn (_("tried: %s\n"), debug_filename);
+
+  sprintf (debug_filename, "%s%s", canon_dir, separate_filename);
+  warn (_("tried: %s\n"), debug_filename);
 
-  sprintf (debugfile, "%s%s", canon_dir, separate_filename);
-  warn (_("tried: %s\n"), debugfile);
+  sprintf (debug_filename, ".debug/%s", separate_filename);
+  warn (_("tried: %s\n"), debug_filename);
 
-  sprintf (debugfile, ".debug/%s", separate_filename);
-  warn (_("tried: %s\n"), debugfile);
+  sprintf (debug_filename, "%s", separate_filename);
+  warn (_("tried: %s\n"), debug_filename);
+
+#if HAVE_LIBDEBUGINFOD
+  {
+    char *urls = getenv (DEBUGINFOD_URLS_ENV_VAR);
+    if (urls == NULL)
+      urls = "";
 
-  sprintf (debugfile, "%s", separate_filename);
-  warn (_("tried: %s\n"), debugfile);
+    warn (_("tried: DEBUGINFOD_URLS=%s\n"), urls);
+  }
+#endif
 
   free (canon_dir);
-  free (debugfile);
+  free (debug_filename);
   return NULL;
 
  found:
   free (canon_dir);
 
+  void * debug_handle;
+
   /* Now open the file.... */
-  if ((separate_debug_file = open_debug_file (debugfile)) == NULL)
+  if ((debug_handle = open_debug_file (debug_filename)) == NULL)
     {
-      warn (_("failed to open separate debug file: %s\n"), debugfile);
-      free (debugfile);
+      warn (_("failed to open separate debug file: %s\n"), debug_filename);
+      free (debug_filename);
       return FALSE;
     }
 
   /* FIXME: We do not check to see if there are any other separate debug info
      files that would also match.  */
 
-  printf (_("%s: Found separate debug info file: %s\n\n"), main_filename, debugfile);
-  separate_debug_filename = debugfile;
+  printf (_("%s: Found separate debug info file: %s\n\n"), main_filename, debug_filename);
+  add_separate_debug_file (debug_filename, debug_handle);
 
-  /* Do not free debugfile - it might be referenced inside
+  /* Do not free debug_filename - it might be referenced inside
      the structure returned by open_debug_file().  */
-  return separate_debug_file;
+  return debug_handle;
 }
 
 /* Attempt to load a separate dwarf object file.  */
 
 static void *
-load_dwo_file (const char * main_filename)
+load_dwo_file (const char * main_filename, const char * name, const char * dir, const char * id ATTRIBUTE_UNUSED)
 {
-  char * filename;
+  char * separate_filename;
+  void * separate_handle;
 
   /* FIXME: Skip adding / if dwo_dir ends in /.  */
-  filename = concat (dwo_dir, "/", dwo_name, NULL);
-  if (filename == NULL)
+  separate_filename = concat (dir, "/", name, NULL);
+  if (separate_filename == NULL)
     {
       warn (_("Out of memory allocating dwo filename\n"));
       return NULL;
     }
 
-  if ((separate_debug_file = open_debug_file (filename)) == NULL)
+  if ((separate_handle = open_debug_file (separate_filename)) == NULL)
     {
-      warn (_("Unable to load dwo file: %s\n"), filename);
-      free (filename);
+      warn (_("Unable to load dwo file: %s\n"), separate_filename);
+      free (separate_filename);
       return NULL;
     }
 
   /* FIXME: We should check the dwo_id.  */
 
-  printf (_("%s: Found separate debug object file: %s\n\n"), main_filename, filename);
-  separate_debug_filename = filename;
-  return separate_debug_file;
+  printf (_("%s: Found separate debug object file: %s\n\n"), main_filename, separate_filename);
+  add_separate_debug_file (separate_filename, separate_handle);
+  /* Note - separate_filename will be freed in free_debug_memory().  */
+  return separate_handle;
 }
 
-/* Load a separate debug info file, if it exists.
-   Returns the data pointer that is the result of calling open_debug_file
-   on the separate debug info file, or NULL if there were problems or there
-   is no such file.  */
+/* Load the separate debug info file(s) attached to FILE, if any exist.
+   Returns TRUE if any were found, FALSE otherwise.
+   If TRUE is returned then the linked list starting at first_separate_info
+   will be populated with open file handles.  */
 
-void *
-load_separate_debug_file (void * file, const char * filename)
+bfd_boolean
+load_separate_debug_files (void * file, const char * filename)
 {
   /* Skip this operation if we are not interested in debug links.  */
   if (! do_follow_links && ! do_debug_links)
-    return NULL;
+    return FALSE;
 
-  /* See if there is a dwo link.  */
+  /* See if there are any dwo links.  */
   if (load_debug_section (str, file)
       && load_debug_section (abbrev, file)
       && load_debug_section (info, file))
     {
-      dwo_name = dwo_dir = NULL;
-      dwo_id = NULL;
-      dwo_id_len = 0;
+      free_dwo_info ();
 
       if (process_debug_info (& debug_displays[info].section, file, abbrev, TRUE, FALSE))
        {
-         if (dwo_name != NULL)
+         bfd_boolean introduced = FALSE;
+         dwo_info *   dwinfo;
+         const char * dir = NULL;
+         const char * id = NULL;
+
+         for (dwinfo = first_dwo_info; dwinfo != NULL; dwinfo = dwinfo->next)
            {
-             if (do_debug_links)
+             switch (dwinfo->type)
                {
-                 printf (_("The %s section contains a link to a dwo file:\n"),
-                         debug_displays [info].section.uncompressed_name);
-                 printf (_("  Name:      %s\n"), dwo_name);
-                 printf (_("  Directory: %s\n"), dwo_dir ? dwo_dir : _("<not-found>"));
-                 if (dwo_id != NULL)
-                   display_data (printf (_("  ID:       ")), dwo_id, dwo_id_len);
-                 else
-                   printf (_("  ID: <unknown>\n"));
-                 printf ("\n\n");
-               }
+               case DWO_NAME:
+                 if (do_debug_links)
+                   {
+                     if (! introduced)
+                       {
+                         printf (_("The %s section contains link(s) to dwo file(s):\n\n"),
+                                 debug_displays [info].section.uncompressed_name);
+                         introduced = TRUE;
+                       }
+
+                     printf (_("  Name:      %s\n"), dwinfo->value);
+                     printf (_("  Directory: %s\n"), dir ? dir : _("<not-found>"));
+                     if (id != NULL)
+                       display_data (printf (_("  ID:       ")), (unsigned char *) id, 8);
+                     else
+                       printf (_("  ID: <unknown>\n"));
+                     printf ("\n\n");
+                   }
+
+                 if (do_follow_links)
+                   load_dwo_file (filename, dwinfo->value, dir, id);
+                 break;
+
+               case DWO_DIR:
+                 dir = dwinfo->value;
+                 break;
+
+               case DWO_ID:
+                 id = dwinfo->value;
+                 break;
 
-             /* FIXME: We do not check to see if there are any more dwo links in the file...  */
-             if (do_follow_links)
-               return load_dwo_file (filename);
+               default:
+                 error (_("Unexpected DWO INFO type"));
+                 break;
+               }
            }
        }
     }
@@ -9916,7 +10510,7 @@ load_separate_debug_file (void * file, const char * filename)
   if (! do_follow_links)
     /* The other debug links will be displayed by display_debug_links()
        so we do not need to do any further processing here.  */
-    return NULL;
+    return FALSE;
 
   /* FIXME: We do not check for the presence of both link sections in the same file.  */
   /* FIXME: We do not check the separate debug info file to see if it too contains debuglinks.  */
@@ -9927,26 +10521,31 @@ load_separate_debug_file (void * file, const char * filename)
     {
       Build_id_data * build_id_data;
 
-      return load_separate_debug_info (filename,
-                                      & debug_displays[gnu_debugaltlink].section,
-                                      parse_gnu_debugaltlink,
-                                      check_gnu_debugaltlink,
-                                      & build_id_data);
+      load_separate_debug_info (filename,
+                               & debug_displays[gnu_debugaltlink].section,
+                               parse_gnu_debugaltlink,
+                               check_gnu_debugaltlink,
+                               & build_id_data,
+                               file);
     }
 
   if (load_debug_section (gnu_debuglink, file))
     {
       unsigned long crc32;
 
-      return load_separate_debug_info (filename,
-                                      & debug_displays[gnu_debuglink].section,
-                                      parse_gnu_debuglink,
-                                      check_gnu_debuglink,
-                                      & crc32);
+      load_separate_debug_info (filename,
+                               & debug_displays[gnu_debuglink].section,
+                               parse_gnu_debuglink,
+                               check_gnu_debuglink,
+                               & crc32,
+                               file);
     }
 
+  if (first_separate_info != NULL)
+    return TRUE;
+
   do_follow_links = 0;
-  return NULL;
+  return FALSE;
 }  
 
 void
@@ -9979,14 +10578,19 @@ free_debug_memory (void)
       alloc_num_debug_info_entries = num_debug_info_entries = 0;
     }
 
-  if (separate_debug_file != NULL)
-    {
-      close_debug_file (separate_debug_file);
-      separate_debug_file = NULL;
+  separate_info * d;
+  separate_info * next;
 
-      free ((void *) separate_debug_filename);
-      separate_debug_filename = NULL;
+  for (d = first_separate_info; d != NULL; d = next)
+    {
+      close_debug_file (d->handle);
+      free ((void *) d->filename);
+      next = d->next;
+      free ((void *) d);
     }
+  first_separate_info = NULL;
+  
+  free_dwo_info ();
 }
 
 void