Add support for PowerPC VLE.

[deliverable/binutils-gdb.git] / binutils / dwarf.c
diff --git a/binutils/dwarf.c b/binutils/dwarf.c

index c8b10f0b0145bdd4f7e5f28887628b6f6ca04d84..2aca694949835b5493d22f20ba1e88629ebd3957 100644 (file)
--- a/binutils/dwarf.c
+++ b/binutils/dwarf.c
@@ -1,5 +1,5 @@
  /* dwarf.c -- display DWARF contents of a BFD binary file
  /* dwarf.c -- display DWARF contents of a BFD binary file
-   Copyright 2005, 2006, 2007, 2008
+   Copyright 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
     Free Software Foundation, Inc.
  
     This file is part of GNU Binutils.
     Free Software Foundation, Inc.
  
     This file is part of GNU Binutils.
@@ -22,11 +22,15 @@
  #include "sysdep.h"
  #include "libiberty.h"
  #include "bfd.h"
  #include "sysdep.h"
  #include "libiberty.h"
  #include "bfd.h"
+#include "bfd_stdint.h"
  #include "bucomm.h"
  #include "bucomm.h"
+#include "elfcomm.h"
  #include "elf/common.h"
  #include "elf/common.h"
-#include "elf/dwarf2.h"
+#include "dwarf2.h"
  #include "dwarf.h"
  
  #include "dwarf.h"
  
+static const char *regname (unsigned int regno, int row);
+
  static int have_frame_base;
  static int need_base_address;
  
  static int have_frame_base;
  static int need_base_address;
  
@@ -45,6 +49,7 @@ int do_debug_info;
  int do_debug_abbrevs;
  int do_debug_lines;
  int do_debug_pubnames;
  int do_debug_abbrevs;
  int do_debug_lines;
  int do_debug_pubnames;
+int do_debug_pubtypes;
  int do_debug_aranges;
  int do_debug_ranges;
  int do_debug_frames;
  int do_debug_aranges;
  int do_debug_ranges;
  int do_debug_frames;
@@ -52,121 +57,21 @@ int do_debug_frames_interp;
  int do_debug_macinfo;
  int do_debug_str;
  int do_debug_loc;
  int do_debug_macinfo;
  int do_debug_str;
  int do_debug_loc;
+int do_gdb_index;
+int do_trace_info;
+int do_trace_abbrevs;
+int do_trace_aranges;
  int do_wide;
  
  int do_wide;
  
+int dwarf_cutoff_level = -1;
+unsigned long dwarf_start_die;
+
+int dwarf_check = 0;
+
  /* Values for do_debug_lines.  */
  #define FLAG_DEBUG_LINES_RAW    1
  #define FLAG_DEBUG_LINES_DECODED 2
  
  /* Values for do_debug_lines.  */
  #define FLAG_DEBUG_LINES_RAW    1
  #define FLAG_DEBUG_LINES_DECODED 2
  
-dwarf_vma (*byte_get) (unsigned char *, int);
-
-dwarf_vma
-byte_get_little_endian (unsigned char *field, int size)
-{
-  switch (size)
-    {
-    case 1:
-      return *field;
-
-    case 2:
-      return  ((unsigned int) (field[0]))
-       |    (((unsigned int) (field[1])) << 8);
-
-    case 4:
-      return  ((unsigned long) (field[0]))
-       |    (((unsigned long) (field[1])) << 8)
-       |    (((unsigned long) (field[2])) << 16)
-       |    (((unsigned long) (field[3])) << 24);
-
-    case 8:
-      if (sizeof (dwarf_vma) == 8)
-       return  ((dwarf_vma) (field[0]))
-         |    (((dwarf_vma) (field[1])) << 8)
-         |    (((dwarf_vma) (field[2])) << 16)
-         |    (((dwarf_vma) (field[3])) << 24)
-         |    (((dwarf_vma) (field[4])) << 32)
-         |    (((dwarf_vma) (field[5])) << 40)
-         |    (((dwarf_vma) (field[6])) << 48)
-         |    (((dwarf_vma) (field[7])) << 56);
-      else if (sizeof (dwarf_vma) == 4)
-       /* We want to extract data from an 8 byte wide field and
-          place it into a 4 byte wide field.  Since this is a little
-          endian source we can just use the 4 byte extraction code.  */
-       return  ((unsigned long) (field[0]))
-         |    (((unsigned long) (field[1])) << 8)
-         |    (((unsigned long) (field[2])) << 16)
-         |    (((unsigned long) (field[3])) << 24);
-
-    default:
-      error (_("Unhandled data length: %d\n"), size);
-      abort ();
-    }
-}
-
-dwarf_vma
-byte_get_big_endian (unsigned char *field, int size)
-{
-  switch (size)
-    {
-    case 1:
-      return *field;
-
-    case 2:
-      return ((unsigned int) (field[1])) | (((int) (field[0])) << 8);
-
-    case 4:
-      return ((unsigned long) (field[3]))
-       |   (((unsigned long) (field[2])) << 8)
-       |   (((unsigned long) (field[1])) << 16)
-       |   (((unsigned long) (field[0])) << 24);
-
-    case 8:
-      if (sizeof (dwarf_vma) == 8)
-       return ((dwarf_vma) (field[7]))
-         |   (((dwarf_vma) (field[6])) << 8)
-         |   (((dwarf_vma) (field[5])) << 16)
-         |   (((dwarf_vma) (field[4])) << 24)
-         |   (((dwarf_vma) (field[3])) << 32)
-         |   (((dwarf_vma) (field[2])) << 40)
-         |   (((dwarf_vma) (field[1])) << 48)
-         |   (((dwarf_vma) (field[0])) << 56);
-      else if (sizeof (dwarf_vma) == 4)
-       {
-         /* Although we are extracing data from an 8 byte wide field,
-            we are returning only 4 bytes of data.  */
-         field += 4;
-         return ((unsigned long) (field[3]))
-           |   (((unsigned long) (field[2])) << 8)
-           |   (((unsigned long) (field[1])) << 16)
-           |   (((unsigned long) (field[0])) << 24);
-       }
-
-    default:
-      error (_("Unhandled data length: %d\n"), size);
-      abort ();
-    }
-}
-
-static dwarf_vma
-byte_get_signed (unsigned char *field, int size)
-{
-  dwarf_vma x = byte_get (field, size);
-
-  switch (size)
-    {
-    case 1:
-      return (x ^ 0x80) - 0x80;
-    case 2:
-      return (x ^ 0x8000) - 0x8000;
-    case 4:
-      return (x ^ 0x80000000) - 0x80000000;
-    case 8:
-      return x;
-    default:
-      abort ();
-    }
-}
-
  static int
  size_of_encoded_value (int encoding)
  {
  static int
  size_of_encoded_value (int encoding)
  {
@@ -181,14 +86,21 @@ size_of_encoded_value (int encoding)
  }
  
  static dwarf_vma
  }
  
  static dwarf_vma
-get_encoded_value (unsigned char *data, int encoding)
+get_encoded_value (unsigned char *data,
+                  int encoding,
+                  struct dwarf_section *section)
  {
    int size = size_of_encoded_value (encoding);
  {
    int size = size_of_encoded_value (encoding);
+  dwarf_vma val;
  
    if (encoding & DW_EH_PE_signed)
  
    if (encoding & DW_EH_PE_signed)
-    return byte_get_signed (data, size);
+    val = byte_get_signed (data, size);
    else
    else
-    return byte_get (data, size);
+    val = byte_get (data, size);
+
+  if ((encoding & 0x70) == DW_EH_PE_pcrel)
+    val += section->address + (data - section->start);
+  return val;
  }
  
  /* Print a dwarf_vma value (typically an address, offset or length) in
  }
  
  /* Print a dwarf_vma value (typically an address, offset or length) in
@@ -199,12 +111,13 @@ static void
  print_dwarf_vma (dwarf_vma val, unsigned byte_size)
  {
    static char buff[18];
  print_dwarf_vma (dwarf_vma val, unsigned byte_size)
  {
    static char buff[18];
+  int offset = 0;
  
    /* Printf does not have a way of specifiying a maximum field width for an
       integer value, so we print the full value into a buffer and then select
       the precision we need.  */
  #if __STDC_VERSION__ >= 199901L || (defined(__GNUC__) && __GNUC__ >= 2)
  
    /* Printf does not have a way of specifiying a maximum field width for an
       integer value, so we print the full value into a buffer and then select
       the precision we need.  */
  #if __STDC_VERSION__ >= 199901L || (defined(__GNUC__) && __GNUC__ >= 2)
-#ifndef __MSVCRT__
+#ifndef __MINGW32__
    snprintf (buff, sizeof (buff), "%16.16llx ", val);
  #else
    snprintf (buff, sizeof (buff), "%016I64x ", val);
    snprintf (buff, sizeof (buff), "%16.16llx ", val);
  #else
    snprintf (buff, sizeof (buff), "%016I64x ", val);
@@ -213,13 +126,76 @@ print_dwarf_vma (dwarf_vma val, unsigned byte_size)
    snprintf (buff, sizeof (buff), "%16.16lx ", val);
  #endif
  
    snprintf (buff, sizeof (buff), "%16.16lx ", val);
  #endif
  
-  fputs (buff + (byte_size == 4 ? 8 : 0), stdout);
+  if (byte_size != 0)
+    {
+      if (byte_size > 0 && byte_size <= 8)
+       offset = 16 - 2 * byte_size;
+      else
+       error (_("Wrong size in print_dwarf_vma"));
+    }
+
+  fputs (buff + offset, stdout);
+}
+
+#if __STDC_VERSION__ >= 199901L || (defined(__GNUC__) && __GNUC__ >= 2)
+#ifndef __MINGW32__
+#define  DWARF_VMA_FMT "ll"
+#else
+#define  DWARF_VMA_FMT "I64"
+#endif
+#else
+#define  DWARF_VMA_FMT "l"
+#endif
+
+static const char *
+dwarf_vmatoa (const char *fmtch, dwarf_vma value)
+{
+  /* As dwarf_vmatoa is used more then once in a printf call
+     for output, we are cycling through an fixed array of pointers
+     for return address.  */
+  static int buf_pos = 0;
+  static struct dwarf_vmatoa_buf
+  {
+    char place[64];
+  } buf[16];
+  char fmt[32];
+  char *ret;
+
+  sprintf (fmt, "%%%s%s", DWARF_VMA_FMT, fmtch);
+
+  ret = buf[buf_pos++].place;
+  buf_pos %= ARRAY_SIZE (buf);
+
+  snprintf (ret, sizeof (buf[0].place), fmt, value);
+
+  return ret;
+}
+
+/* Format a 64-bit value, given as two 32-bit values, in hex.
+   For reentrancy, this uses a buffer provided by the caller.  */
+
+static const char *
+dwarf_vmatoa64 (dwarf_vma hvalue, dwarf_vma lvalue, char *buf,
+               unsigned int buf_len)
+{
+  int len = 0;
+
+  if (hvalue == 0)
+    snprintf (buf, buf_len, "%" DWARF_VMA_FMT "x", lvalue);
+  else
+    {
+      len = snprintf (buf, buf_len, "%" DWARF_VMA_FMT "x", hvalue);
+      snprintf (buf + len, buf_len - len,
+               "%08" DWARF_VMA_FMT "x", lvalue);
+    }
+
+  return buf;
  }
  
  }
  
-static unsigned long int
+dwarf_vma
  read_leb128 (unsigned char *data, unsigned int *length_return, int sign)
  {
  read_leb128 (unsigned char *data, unsigned int *length_return, int sign)
  {
-  unsigned long int result = 0;
+  dwarf_vma result = 0;
    unsigned int num_read = 0;
    unsigned int shift = 0;
    unsigned char byte;
    unsigned int num_read = 0;
    unsigned int shift = 0;
    unsigned char byte;
@@ -229,7 +205,7 @@ read_leb128 (unsigned char *data, unsigned int *length_return, int sign)
        byte = *data++;
        num_read++;
  
        byte = *data++;
        num_read++;
  
-      result |= ((unsigned long int) (byte & 0x7f)) << shift;
+      result |= ((dwarf_vma) (byte & 0x7f)) << shift;
  
        shift += 7;
  
  
        shift += 7;
  
@@ -245,15 +221,23 @@ read_leb128 (unsigned char *data, unsigned int *length_return, int sign)
    return result;
  }
  
    return result;
  }
  
+/* Create a signed version to avoid painful typecasts.  */
+static dwarf_signed_vma
+read_sleb128 (unsigned char *data, unsigned int *length_return)
+{
+  return (dwarf_signed_vma) read_leb128 (data, length_return, 1);
+}
+
  typedef struct State_Machine_Registers
  {
  typedef struct State_Machine_Registers
  {
-  unsigned long address;
+  dwarf_vma address;
    unsigned int file;
    unsigned int line;
    unsigned int column;
    int is_stmt;
    int basic_block;
    unsigned int file;
    unsigned int line;
    unsigned int column;
    int is_stmt;
    int basic_block;
-  int end_sequence;
+  unsigned char op_index;
+  unsigned char end_sequence;
  /* This variable hold the number of the last entry seen
     in the File Table.  */
    unsigned int last_file_entry;
  /* This variable hold the number of the last entry seen
     in the File Table.  */
    unsigned int last_file_entry;
@@ -265,6 +249,7 @@ static void
  reset_state_machine (int is_stmt)
  {
    state_machine_regs.address = 0;
  reset_state_machine (int is_stmt)
  {
    state_machine_regs.address = 0;
+  state_machine_regs.op_index = 0;
    state_machine_regs.file = 1;
    state_machine_regs.line = 1;
    state_machine_regs.column = 0;
    state_machine_regs.file = 1;
    state_machine_regs.line = 1;
    state_machine_regs.column = 0;
@@ -284,7 +269,8 @@ process_extended_line_op (unsigned char *data, int is_stmt)
    unsigned int bytes_read;
    unsigned int len;
    unsigned char *name;
    unsigned int bytes_read;
    unsigned int len;
    unsigned char *name;
-  unsigned long adr;
+  dwarf_vma adr;
+  unsigned char *orig_data = data;
  
    len = read_leb128 (data, & bytes_read, 0);
    data += bytes_read;
  
    len = read_leb128 (data, & bytes_read, 0);
    data += bytes_read;
@@ -309,28 +295,33 @@ process_extended_line_op (unsigned char *data, int is_stmt)
  
      case DW_LNE_set_address:
        adr = byte_get (data, len - bytes_read - 1);
  
      case DW_LNE_set_address:
        adr = byte_get (data, len - bytes_read - 1);
-      printf (_("set Address to 0x%lx\n"), adr);
+      printf (_("set Address to 0x%s\n"), dwarf_vmatoa ("x", adr));
        state_machine_regs.address = adr;
        state_machine_regs.address = adr;
+      state_machine_regs.op_index = 0;
        break;
  
      case DW_LNE_define_file:
        break;
  
      case DW_LNE_define_file:
-      printf (_("  define new File Table entry\n"));
+      printf (_("define new File Table entry\n"));
        printf (_("  Entry\tDir\tTime\tSize\tName\n"));
  
        printf (_("  Entry\tDir\tTime\tSize\tName\n"));
  
-      printf (_("   %d\t"), ++state_machine_regs.last_file_entry);
+      printf ("   %d\t", ++state_machine_regs.last_file_entry);
        name = data;
        data += strlen ((char *) data) + 1;
        name = data;
        data += strlen ((char *) data) + 1;
-      printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
+      printf ("%s\t", dwarf_vmatoa ("u", read_leb128 (data, & bytes_read, 0)));
+      data += bytes_read;
+      printf ("%s\t", dwarf_vmatoa ("u", read_leb128 (data, & bytes_read, 0)));
        data += bytes_read;
        data += bytes_read;
-      printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
+      printf ("%s\t", dwarf_vmatoa ("u", read_leb128 (data, & bytes_read, 0)));
        data += bytes_read;
        data += bytes_read;
-      printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
-      printf (_("%s\n\n"), name);
+      printf ("%s", name);
+      if ((unsigned int) (data - orig_data) != len)
+        printf (_(" [Bad opcode length]"));
+      printf ("\n\n");
        break;
  
      case DW_LNE_set_discriminator:
        break;
  
      case DW_LNE_set_discriminator:
-      printf (_("set Discriminator to %lu\n"),
-              read_leb128 (data, & bytes_read, 0));
+      printf (_("set Discriminator to %s\n"),
+             dwarf_vmatoa ("u", read_leb128 (data, & bytes_read, 0)));
        break;
  
      /* HP extensions.  */
        break;
  
      /* HP extensions.  */
@@ -364,16 +355,71 @@ process_extended_line_op (unsigned char *data, int is_stmt)
      case DW_LNE_HP_define_proc:
        printf ("DW_LNE_HP_define_proc\n");
        break;
      case DW_LNE_HP_define_proc:
        printf ("DW_LNE_HP_define_proc\n");
        break;
+    case DW_LNE_HP_source_file_correlation:
+      {
+        unsigned char *edata = data + len - bytes_read - 1;
+
+        printf ("DW_LNE_HP_source_file_correlation\n");
+
+        while (data < edata)
+          {
+            unsigned int opc;
+
+            opc = read_leb128 (data, & bytes_read, 0);
+            data += bytes_read;
+
+            switch (opc)
+              {
+              case DW_LNE_HP_SFC_formfeed:
+                printf ("    DW_LNE_HP_SFC_formfeed\n");
+                break;
+              case DW_LNE_HP_SFC_set_listing_line:
+                printf ("    DW_LNE_HP_SFC_set_listing_line (%s)\n",
+                        dwarf_vmatoa ("u",
+                                      read_leb128 (data, & bytes_read, 0)));
+                data += bytes_read;
+                break;
+              case DW_LNE_HP_SFC_associate:
+                printf ("    DW_LNE_HP_SFC_associate ");
+                printf ("(%s",
+                        dwarf_vmatoa ("u",
+                                      read_leb128 (data, & bytes_read, 0)));
+                data += bytes_read;
+                printf (",%s",
+                        dwarf_vmatoa ("u",
+                                      read_leb128 (data, & bytes_read, 0)));
+                data += bytes_read;
+                printf (",%s)\n",
+                        dwarf_vmatoa ("u",
+                                      read_leb128 (data, & bytes_read, 0)));
+                data += bytes_read;
+                break;
+              default:
+                printf (_("    UNKNOWN DW_LNE_HP_SFC opcode (%u)\n"), opc);
+                data = edata;
+                break;
+              }
+          }
+      }
+      break;
  
      default:
  
      default:
-      if (op_code >= DW_LNE_lo_user
-         /* The test against DW_LNW_hi_user is redundant due to
-            the limited range of the unsigned char data type used
-            for op_code.  */
-         /*&& op_code <= DW_LNE_hi_user*/)
-       printf (_("user defined: length %d\n"), len - bytes_read);
-      else
-       printf (_("UNKNOWN: length %d\n"), len - bytes_read);
+      {
+        unsigned int rlen = len - bytes_read - 1;
+
+        if (op_code >= DW_LNE_lo_user
+            /* The test against DW_LNW_hi_user is redundant due to
+               the limited range of the unsigned char data type used
+               for op_code.  */
+            /*&& op_code <= DW_LNE_hi_user*/)
+          printf (_("user defined: "));
+        else
+          printf (_("UNKNOWN: "));
+        printf (_("length %d ["), rlen);
+        for (; rlen; rlen--)
+          printf (" %02x", *data++);
+        printf ("]\n");
+      }
        break;
      }
  
        break;
      }
  
@@ -381,7 +427,7 @@ process_extended_line_op (unsigned char *data, int is_stmt)
  }
  
  static const char *
  }
  
  static const char *
-fetch_indirect_string (unsigned long offset)
+fetch_indirect_string (dwarf_vma offset)
  {
    struct dwarf_section *section = &debug_displays [str].section;
  
  {
    struct dwarf_section *section = &debug_displays [str].section;
  
@@ -392,13 +438,72 @@ fetch_indirect_string (unsigned long offset)
    offset -= section->address;
    if (offset > section->size)
      {
    offset -= section->address;
    if (offset > section->size)
      {
-      warn (_("DW_FORM_strp offset too big: %lx\n"), offset);
+      warn (_("DW_FORM_strp offset too big: %s\n"),
+           dwarf_vmatoa ("x", offset));
        return _("<offset is too big>");
      }
  
    return (const char *) section->start + offset;
  }
  
        return _("<offset is too big>");
      }
  
    return (const char *) section->start + offset;
  }
  
+static const char *
+fetch_indexed_string (dwarf_vma idx, dwarf_vma offset_size, int dwo)
+{
+  enum dwarf_section_display_enum str_sec_idx = dwo ? str_dwo : str;
+  enum dwarf_section_display_enum idx_sec_idx = dwo ? str_index_dwo : str_index;
+  struct dwarf_section *index_section = &debug_displays [idx_sec_idx].section;
+  struct dwarf_section *str_section = &debug_displays [str_sec_idx].section;
+  dwarf_vma index_offset = idx * offset_size;
+  dwarf_vma str_offset;
+
+  if (index_section->start == NULL)
+    return (dwo ? _("<no .debug_str_offsets.dwo section>")
+               : _("<no .debug_str_offsets section>"));
+
+  /* DWARF sections under Mach-O have non-zero addresses.  */
+  index_offset -= index_section->address;
+  if (index_offset > index_section->size)
+    {
+      warn (_("DW_FORM_GNU_str_index offset too big: %s\n"),
+           dwarf_vmatoa ("x", index_offset));
+      return _("<index offset is too big>");
+    }
+
+  if (str_section->start == NULL)
+    return (dwo ? _("<no .debug_str.dwo section>")
+               : _("<no .debug_str section>"));
+
+  str_offset = byte_get (index_section->start + index_offset, offset_size);
+  str_offset -= str_section->address;
+  if (str_offset > str_section->size)
+    {
+      warn (_("DW_FORM_GNU_str_index indirect offset too big: %s\n"),
+           dwarf_vmatoa ("x", str_offset));
+      return _("<indirect index offset is too big>");
+    }
+
+  return (const char *) str_section->start + str_offset;
+}
+
+static const char *
+fetch_indexed_value (dwarf_vma offset, dwarf_vma bytes)
+{
+  struct dwarf_section *section = &debug_displays [debug_addr].section;
+
+  if (section->start == NULL)
+    return (_("<no .debug_addr section>"));
+
+  if (offset + bytes > section->size)
+    {
+      warn (_("Offset into section %s too big: %s\n"),
+            section->name, dwarf_vmatoa ("x", offset));
+      return "<offset too big>";
+    }
+
+  return dwarf_vmatoa ("x", byte_get (section->start + offset, bytes));
+}
+
+
  /* FIXME:  There are better and more efficient ways to handle
     these structures.  For now though, I just want something that
     is simple to implement.  */
  /* FIXME:  There are better and more efficient ways to handle
     these structures.  For now though, I just want something that
     is simple to implement.  */
@@ -427,23 +532,23 @@ static abbrev_entry *last_abbrev = NULL;
  static void
  free_abbrevs (void)
  {
  static void
  free_abbrevs (void)
  {
-  abbrev_entry *abbrev;
+  abbrev_entry *abbrv;
  
  
-  for (abbrev = first_abbrev; abbrev;)
+  for (abbrv = first_abbrev; abbrv;)
      {
      {
-      abbrev_entry *next = abbrev->next;
+      abbrev_entry *next_abbrev = abbrv->next;
        abbrev_attr *attr;
  
        abbrev_attr *attr;
  
-      for (attr = abbrev->first_attr; attr;)
+      for (attr = abbrv->first_attr; attr;)
         {
         {
-         abbrev_attr *next = attr->next;
+         abbrev_attr *next_attr = attr->next;
  
           free (attr);
  
           free (attr);
-         attr = next;
+         attr = next_attr;
         }
  
         }
  
-      free (abbrev);
-      abbrev = next;
+      free (abbrv);
+      abbrv = next_abbrev;
      }
  
    last_abbrev = first_abbrev = NULL;
      }
  
    last_abbrev = first_abbrev = NULL;
@@ -454,8 +559,7 @@ add_abbrev (unsigned long number, unsigned long tag, int children)
  {
    abbrev_entry *entry;
  
  {
    abbrev_entry *entry;
  
-  entry = malloc (sizeof (*entry));
-
+  entry = (abbrev_entry *) malloc (sizeof (*entry));
    if (entry == NULL)
      /* ugg */
      return;
    if (entry == NULL)
      /* ugg */
      return;
@@ -480,8 +584,7 @@ add_abbrev_attr (unsigned long attribute, unsigned long form)
  {
    abbrev_attr *attr;
  
  {
    abbrev_attr *attr;
  
-  attr = malloc (sizeof (*attr));
-
+  attr = (abbrev_attr *) malloc (sizeof (*attr));
    if (attr == NULL)
      /* ugg */
      return;
    if (attr == NULL)
      /* ugg */
      return;
@@ -552,126 +655,42 @@ process_abbrev_section (unsigned char *start, unsigned char *end)
    return NULL;
  }
  
    return NULL;
  }
  
-static char *
+static const char *
  get_TAG_name (unsigned long tag)
  {
  get_TAG_name (unsigned long tag)
  {
-  switch (tag)
+  const char *name = get_DW_TAG_name ((unsigned int)tag);
+
+  if (name == NULL)
      {
      {
-    case DW_TAG_padding:               return "DW_TAG_padding";
-    case DW_TAG_array_type:            return "DW_TAG_array_type";
-    case DW_TAG_class_type:            return "DW_TAG_class_type";
-    case DW_TAG_entry_point:           return "DW_TAG_entry_point";
-    case DW_TAG_enumeration_type:      return "DW_TAG_enumeration_type";
-    case DW_TAG_formal_parameter:      return "DW_TAG_formal_parameter";
-    case DW_TAG_imported_declaration:  return "DW_TAG_imported_declaration";
-    case DW_TAG_label:                 return "DW_TAG_label";
-    case DW_TAG_lexical_block:         return "DW_TAG_lexical_block";
-    case DW_TAG_member:                        return "DW_TAG_member";
-    case DW_TAG_pointer_type:          return "DW_TAG_pointer_type";
-    case DW_TAG_reference_type:                return "DW_TAG_reference_type";
-    case DW_TAG_compile_unit:          return "DW_TAG_compile_unit";
-    case DW_TAG_string_type:           return "DW_TAG_string_type";
-    case DW_TAG_structure_type:                return "DW_TAG_structure_type";
-    case DW_TAG_subroutine_type:       return "DW_TAG_subroutine_type";
-    case DW_TAG_typedef:               return "DW_TAG_typedef";
-    case DW_TAG_union_type:            return "DW_TAG_union_type";
-    case DW_TAG_unspecified_parameters: return "DW_TAG_unspecified_parameters";
-    case DW_TAG_variant:               return "DW_TAG_variant";
-    case DW_TAG_common_block:          return "DW_TAG_common_block";
-    case DW_TAG_common_inclusion:      return "DW_TAG_common_inclusion";
-    case DW_TAG_inheritance:           return "DW_TAG_inheritance";
-    case DW_TAG_inlined_subroutine:    return "DW_TAG_inlined_subroutine";
-    case DW_TAG_module:                        return "DW_TAG_module";
-    case DW_TAG_ptr_to_member_type:    return "DW_TAG_ptr_to_member_type";
-    case DW_TAG_set_type:              return "DW_TAG_set_type";
-    case DW_TAG_subrange_type:         return "DW_TAG_subrange_type";
-    case DW_TAG_with_stmt:             return "DW_TAG_with_stmt";
-    case DW_TAG_access_declaration:    return "DW_TAG_access_declaration";
-    case DW_TAG_base_type:             return "DW_TAG_base_type";
-    case DW_TAG_catch_block:           return "DW_TAG_catch_block";
-    case DW_TAG_const_type:            return "DW_TAG_const_type";
-    case DW_TAG_constant:              return "DW_TAG_constant";
-    case DW_TAG_enumerator:            return "DW_TAG_enumerator";
-    case DW_TAG_file_type:             return "DW_TAG_file_type";
-    case DW_TAG_friend:                        return "DW_TAG_friend";
-    case DW_TAG_namelist:              return "DW_TAG_namelist";
-    case DW_TAG_namelist_item:         return "DW_TAG_namelist_item";
-    case DW_TAG_packed_type:           return "DW_TAG_packed_type";
-    case DW_TAG_subprogram:            return "DW_TAG_subprogram";
-    case DW_TAG_template_type_param:   return "DW_TAG_template_type_param";
-    case DW_TAG_template_value_param:  return "DW_TAG_template_value_param";
-    case DW_TAG_thrown_type:           return "DW_TAG_thrown_type";
-    case DW_TAG_try_block:             return "DW_TAG_try_block";
-    case DW_TAG_variant_part:          return "DW_TAG_variant_part";
-    case DW_TAG_variable:              return "DW_TAG_variable";
-    case DW_TAG_volatile_type:         return "DW_TAG_volatile_type";
-    case DW_TAG_MIPS_loop:             return "DW_TAG_MIPS_loop";
-    case DW_TAG_format_label:          return "DW_TAG_format_label";
-    case DW_TAG_function_template:     return "DW_TAG_function_template";
-    case DW_TAG_class_template:                return "DW_TAG_class_template";
-      /* DWARF 2.1 values.  */
-    case DW_TAG_dwarf_procedure:       return "DW_TAG_dwarf_procedure";
-    case DW_TAG_restrict_type:         return "DW_TAG_restrict_type";
-    case DW_TAG_interface_type:                return "DW_TAG_interface_type";
-    case DW_TAG_namespace:             return "DW_TAG_namespace";
-    case DW_TAG_imported_module:       return "DW_TAG_imported_module";
-    case DW_TAG_unspecified_type:      return "DW_TAG_unspecified_type";
-    case DW_TAG_partial_unit:          return "DW_TAG_partial_unit";
-    case DW_TAG_imported_unit:         return "DW_TAG_imported_unit";
-      /* UPC values.  */
-    case DW_TAG_upc_shared_type:       return "DW_TAG_upc_shared_type";
-    case DW_TAG_upc_strict_type:       return "DW_TAG_upc_strict_type";
-    case DW_TAG_upc_relaxed_type:      return "DW_TAG_upc_relaxed_type";
-    default:
-      {
-       static char buffer[100];
+      static char buffer[100];
  
  
-       snprintf (buffer, sizeof (buffer), _("Unknown TAG value: %lx"), tag);
-       return buffer;
-      }
+      snprintf (buffer, sizeof (buffer), _("Unknown TAG value: %lx"), tag);
+      return buffer;
      }
      }
+
+  return name;
  }
  
  }
  
-static char *
+static const char *
  get_FORM_name (unsigned long form)
  {
  get_FORM_name (unsigned long form)
  {
-  switch (form)
+  const char *name = get_DW_FORM_name (form);
+
+  if (name == NULL)
      {
      {
-    case DW_FORM_addr:         return "DW_FORM_addr";
-    case DW_FORM_block2:       return "DW_FORM_block2";
-    case DW_FORM_block4:       return "DW_FORM_block4";
-    case DW_FORM_data2:                return "DW_FORM_data2";
-    case DW_FORM_data4:                return "DW_FORM_data4";
-    case DW_FORM_data8:                return "DW_FORM_data8";
-    case DW_FORM_string:       return "DW_FORM_string";
-    case DW_FORM_block:                return "DW_FORM_block";
-    case DW_FORM_block1:       return "DW_FORM_block1";
-    case DW_FORM_data1:                return "DW_FORM_data1";
-    case DW_FORM_flag:         return "DW_FORM_flag";
-    case DW_FORM_sdata:                return "DW_FORM_sdata";
-    case DW_FORM_strp:         return "DW_FORM_strp";
-    case DW_FORM_udata:                return "DW_FORM_udata";
-    case DW_FORM_ref_addr:     return "DW_FORM_ref_addr";
-    case DW_FORM_ref1:         return "DW_FORM_ref1";
-    case DW_FORM_ref2:         return "DW_FORM_ref2";
-    case DW_FORM_ref4:         return "DW_FORM_ref4";
-    case DW_FORM_ref8:         return "DW_FORM_ref8";
-    case DW_FORM_ref_udata:    return "DW_FORM_ref_udata";
-    case DW_FORM_indirect:     return "DW_FORM_indirect";
-    default:
-      {
-       static char buffer[100];
+      static char buffer[100];
  
  
-       snprintf (buffer, sizeof (buffer), _("Unknown FORM value: %lx"), form);
-       return buffer;
-      }
+      snprintf (buffer, sizeof (buffer), _("Unknown FORM value: %lx"), form);
+      return buffer;
      }
      }
+
+  return name;
  }
  
  static unsigned char *
  }
  
  static unsigned char *
-display_block (unsigned char *data, unsigned long length)
+display_block (unsigned char *data, dwarf_vma length)
  {
  {
-  printf (_(" %lu byte block: "), length);
+  printf (_(" %s byte block: "), dwarf_vmatoa ("u", length));
  
    while (length --)
      printf ("%lx ", (unsigned long) byte_get (data++, 1));
  
    while (length --)
      printf ("%lx ", (unsigned long) byte_get (data++, 1));
@@ -682,13 +701,15 @@ display_block (unsigned char *data, unsigned long length)
  static int
  decode_location_expression (unsigned char * data,
                             unsigned int pointer_size,
  static int
  decode_location_expression (unsigned char * data,
                             unsigned int pointer_size,
-                           unsigned long length,
-                           unsigned long cu_offset,
+                           unsigned int offset_size,
+                           int dwarf_version,
+                           dwarf_vma length,
+                           dwarf_vma cu_offset,
                             struct dwarf_section * section)
  {
    unsigned op;
    unsigned int bytes_read;
                             struct dwarf_section * section)
  {
    unsigned op;
    unsigned int bytes_read;
-  unsigned long uvalue;
+  dwarf_vma uvalue;
    unsigned char *end = data + length;
    int need_frame_base = 0;
  
    unsigned char *end = data + length;
    int need_frame_base = 0;
  
@@ -699,8 +720,8 @@ decode_location_expression (unsigned char * data,
        switch (op)
         {
         case DW_OP_addr:
        switch (op)
         {
         case DW_OP_addr:
-         printf ("DW_OP_addr: %lx",
-                 (unsigned long) byte_get (data, pointer_size));
+         printf ("DW_OP_addr: %s",
+                 dwarf_vmatoa ("x", byte_get (data, pointer_size)));
           data += pointer_size;
           break;
         case DW_OP_deref:
           data += pointer_size;
           break;
         case DW_OP_deref:
@@ -739,11 +760,13 @@ decode_location_expression (unsigned char * data,
           data += 8;
           break;
         case DW_OP_constu:
           data += 8;
           break;
         case DW_OP_constu:
-         printf ("DW_OP_constu: %lu", read_leb128 (data, &bytes_read, 0));
+         printf ("DW_OP_constu: %s",
+                 dwarf_vmatoa ("u", read_leb128 (data, &bytes_read, 0)));
           data += bytes_read;
           break;
         case DW_OP_consts:
           data += bytes_read;
           break;
         case DW_OP_consts:
-         printf ("DW_OP_consts: %ld", read_leb128 (data, &bytes_read, 1));
+         printf ("DW_OP_consts: %s",
+                 dwarf_vmatoa ("d", read_sleb128 (data, &bytes_read)));
           data += bytes_read;
           break;
         case DW_OP_dup:
           data += bytes_read;
           break;
         case DW_OP_dup:
@@ -798,8 +821,8 @@ decode_location_expression (unsigned char * data,
           printf ("DW_OP_plus");
           break;
         case DW_OP_plus_uconst:
           printf ("DW_OP_plus");
           break;
         case DW_OP_plus_uconst:
-         printf ("DW_OP_plus_uconst: %lu",
-                 read_leb128 (data, &bytes_read, 0));
+         printf ("DW_OP_plus_uconst: %s",
+                 dwarf_vmatoa ("u", read_leb128 (data, &bytes_read, 0)));
           data += bytes_read;
           break;
         case DW_OP_shl:
           data += bytes_read;
           break;
         case DW_OP_shl:
@@ -908,7 +931,8 @@ decode_location_expression (unsigned char * data,
         case DW_OP_reg29:
         case DW_OP_reg30:
         case DW_OP_reg31:
         case DW_OP_reg29:
         case DW_OP_reg30:
         case DW_OP_reg31:
-         printf ("DW_OP_reg%d", op - DW_OP_reg0);
+         printf ("DW_OP_reg%d (%s)", op - DW_OP_reg0,
+                 regname (op - DW_OP_reg0, 1));
           break;
  
         case DW_OP_breg0:
           break;
  
         case DW_OP_breg0:
@@ -943,29 +967,37 @@ decode_location_expression (unsigned char * data,
         case DW_OP_breg29:
         case DW_OP_breg30:
         case DW_OP_breg31:
         case DW_OP_breg29:
         case DW_OP_breg30:
         case DW_OP_breg31:
-         printf ("DW_OP_breg%d: %ld", op - DW_OP_breg0,
-                 read_leb128 (data, &bytes_read, 1));
+         printf ("DW_OP_breg%d (%s): %s",
+                 op - DW_OP_breg0,
+                 regname (op - DW_OP_breg0, 1),
+                 dwarf_vmatoa ("d", (dwarf_signed_vma)
+                   read_leb128 (data, &bytes_read, 1)));
           data += bytes_read;
           break;
  
         case DW_OP_regx:
           data += bytes_read;
           break;
  
         case DW_OP_regx:
-         printf ("DW_OP_regx: %lu", read_leb128 (data, &bytes_read, 0));
+         uvalue = read_leb128 (data, &bytes_read, 0);
           data += bytes_read;
           data += bytes_read;
+         printf ("DW_OP_regx: %s (%s)",
+                 dwarf_vmatoa ("u", uvalue), regname (uvalue, 1));
           break;
         case DW_OP_fbreg:
           need_frame_base = 1;
           break;
         case DW_OP_fbreg:
           need_frame_base = 1;
-         printf ("DW_OP_fbreg: %ld", read_leb128 (data, &bytes_read, 1));
+         printf ("DW_OP_fbreg: %s",
+                 dwarf_vmatoa ("d", read_sleb128 (data, &bytes_read)));
           data += bytes_read;
           break;
         case DW_OP_bregx:
           uvalue = read_leb128 (data, &bytes_read, 0);
           data += bytes_read;
           data += bytes_read;
           break;
         case DW_OP_bregx:
           uvalue = read_leb128 (data, &bytes_read, 0);
           data += bytes_read;
-         printf ("DW_OP_bregx: %lu %ld", uvalue,
-                 read_leb128 (data, &bytes_read, 1));
+         printf ("DW_OP_bregx: %s (%s) %s",
+                 dwarf_vmatoa ("u", uvalue), regname (uvalue, 1),
+                 dwarf_vmatoa ("d", read_sleb128 (data, &bytes_read)));
           data += bytes_read;
           break;
         case DW_OP_piece:
           data += bytes_read;
           break;
         case DW_OP_piece:
-         printf ("DW_OP_piece: %lu", read_leb128 (data, &bytes_read, 0));
+         printf ("DW_OP_piece: %s",
+                 dwarf_vmatoa ("u", read_leb128 (data, &bytes_read, 0)));
           data += bytes_read;
           break;
         case DW_OP_deref_size:
           data += bytes_read;
           break;
         case DW_OP_deref_size:
@@ -985,20 +1017,40 @@ decode_location_expression (unsigned char * data,
         case DW_OP_call2:
           /* XXX: Strictly speaking for 64-bit DWARF3 files
              this ought to be an 8-byte wide computation.  */
         case DW_OP_call2:
           /* XXX: Strictly speaking for 64-bit DWARF3 files
              this ought to be an 8-byte wide computation.  */
-         printf ("DW_OP_call2: <%lx>", (long) byte_get (data, 2) + cu_offset);
+         printf ("DW_OP_call2: <0x%s>",
+                 dwarf_vmatoa ("x", (dwarf_signed_vma) byte_get (data, 2)
+                                    + cu_offset));
           data += 2;
           break;
         case DW_OP_call4:
           /* XXX: Strictly speaking for 64-bit DWARF3 files
              this ought to be an 8-byte wide computation.  */
           data += 2;
           break;
         case DW_OP_call4:
           /* XXX: Strictly speaking for 64-bit DWARF3 files
              this ought to be an 8-byte wide computation.  */
-         printf ("DW_OP_call4: <%lx>", (long) byte_get (data, 4) + cu_offset);
+         printf ("DW_OP_call4: <0x%s>",
+                 dwarf_vmatoa ("x", (dwarf_signed_vma) byte_get (data, 4)
+                                    + cu_offset));
           data += 4;
           break;
         case DW_OP_call_ref:
           /* XXX: Strictly speaking for 64-bit DWARF3 files
              this ought to be an 8-byte wide computation.  */
           data += 4;
           break;
         case DW_OP_call_ref:
           /* XXX: Strictly speaking for 64-bit DWARF3 files
              this ought to be an 8-byte wide computation.  */
-         printf ("DW_OP_call_ref: <%lx>", (long) byte_get (data, 4) + cu_offset);
-         data += 4;
+         if (dwarf_version == -1)
+           {
+             printf (_("(DW_OP_call_ref in frame info)"));
+             /* No way to tell where the next op is, so just bail.  */
+             return need_frame_base;
+           }
+         if (dwarf_version == 2)
+           {
+             printf ("DW_OP_call_ref: <0x%s>",
+                     dwarf_vmatoa ("x", byte_get (data, pointer_size)));
+             data += pointer_size;
+           }
+         else
+           {
+             printf ("DW_OP_call_ref: <0x%s>",
+                     dwarf_vmatoa ("x", byte_get (data, offset_size)));
+             data += offset_size;
+           }
           break;
         case DW_OP_form_tls_address:
           printf ("DW_OP_form_tls_address");
           break;
         case DW_OP_form_tls_address:
           printf ("DW_OP_form_tls_address");
@@ -1008,15 +1060,30 @@ decode_location_expression (unsigned char * data,
           break;
         case DW_OP_bit_piece:
           printf ("DW_OP_bit_piece: ");
           break;
         case DW_OP_bit_piece:
           printf ("DW_OP_bit_piece: ");
-         printf ("size: %lu ", read_leb128 (data, &bytes_read, 0));
+         printf (_("size: %s "),
+                 dwarf_vmatoa ("u", read_leb128 (data, &bytes_read, 0)));
           data += bytes_read;
           data += bytes_read;
-         printf ("offset: %lu ", read_leb128 (data, &bytes_read, 0));
+         printf (_("offset: %s "),
+                 dwarf_vmatoa ("u", read_leb128 (data, &bytes_read, 0)));
+         data += bytes_read;
+         break;
+
+         /* DWARF 4 extensions.  */
+       case DW_OP_stack_value:
+         printf ("DW_OP_stack_value");
+         break;
+
+       case DW_OP_implicit_value:
+         printf ("DW_OP_implicit_value");
+         uvalue = read_leb128 (data, &bytes_read, 0);
           data += bytes_read;
           data += bytes_read;
+         display_block (data, uvalue);
+         data += uvalue;
           break;
  
           /* GNU extensions.  */
         case DW_OP_GNU_push_tls_address:
           break;
  
           /* GNU extensions.  */
         case DW_OP_GNU_push_tls_address:
-         printf ("DW_OP_GNU_push_tls_address or DW_OP_HP_unknown");
+         printf (_("DW_OP_GNU_push_tls_address or DW_OP_HP_unknown"));
           break;
         case DW_OP_GNU_uninit:
           printf ("DW_OP_GNU_uninit");
           break;
         case DW_OP_GNU_uninit:
           printf ("DW_OP_GNU_uninit");
@@ -1026,17 +1093,98 @@ decode_location_expression (unsigned char * data,
           {
             int encoding;
             dwarf_vma addr;
           {
             int encoding;
             dwarf_vma addr;
-       
+
             encoding = *data++;
             encoding = *data++;
-           addr = get_encoded_value (data, encoding);
-           if ((encoding & 0x70) == DW_EH_PE_pcrel)
-             addr += section->address + (data - section->start);
+           addr = get_encoded_value (data, encoding, section);
             data += size_of_encoded_value (encoding);
  
             printf ("DW_OP_GNU_encoded_addr: fmt:%02x addr:", encoding);
             print_dwarf_vma (addr, pointer_size);
           }
           break;
             data += size_of_encoded_value (encoding);
  
             printf ("DW_OP_GNU_encoded_addr: fmt:%02x addr:", encoding);
             print_dwarf_vma (addr, pointer_size);
           }
           break;
+       case DW_OP_GNU_implicit_pointer:
+         /* XXX: Strictly speaking for 64-bit DWARF3 files
+            this ought to be an 8-byte wide computation.  */
+         if (dwarf_version == -1)
+           {
+             printf (_("(DW_OP_GNU_implicit_pointer in frame info)"));
+             /* No way to tell where the next op is, so just bail.  */
+             return need_frame_base;
+           }
+         if (dwarf_version == 2)
+           {
+             printf ("DW_OP_GNU_implicit_pointer: <0x%s> %s",
+                     dwarf_vmatoa ("x", byte_get (data, pointer_size)),
+                     dwarf_vmatoa ("d", read_sleb128 (data + pointer_size,
+                                    &bytes_read)));
+             data += pointer_size + bytes_read;
+           }
+         else
+           {
+             printf ("DW_OP_GNU_implicit_pointer: <0x%s> %s",
+                     dwarf_vmatoa ("x", byte_get (data, offset_size)),
+                     dwarf_vmatoa ("d", read_sleb128 (data + offset_size,
+                                    &bytes_read)));
+             data += offset_size + bytes_read;
+           }
+         break;
+       case DW_OP_GNU_entry_value:
+         uvalue = read_leb128 (data, &bytes_read, 0);
+         data += bytes_read;
+         printf ("DW_OP_GNU_entry_value: (");
+         if (decode_location_expression (data, pointer_size, offset_size,
+                                         dwarf_version, uvalue,
+                                         cu_offset, section))
+           need_frame_base = 1;
+         putchar (')');
+         data += uvalue;
+         break;
+       case DW_OP_GNU_const_type:
+         uvalue = read_leb128 (data, &bytes_read, 0);
+         data += bytes_read;
+         printf ("DW_OP_GNU_const_type: <0x%s> ",
+                 dwarf_vmatoa ("x", cu_offset + uvalue));
+         uvalue = byte_get (data++, 1);
+         display_block (data, uvalue);
+         data += uvalue;
+         break;
+       case DW_OP_GNU_regval_type:
+         uvalue = read_leb128 (data, &bytes_read, 0);
+         data += bytes_read;
+         printf ("DW_OP_GNU_regval_type: %s (%s)",
+                 dwarf_vmatoa ("u", uvalue), regname (uvalue, 1));
+         uvalue = read_leb128 (data, &bytes_read, 0);
+         data += bytes_read;
+         printf (" <0x%s>", dwarf_vmatoa ("x", cu_offset + uvalue));
+         break;
+       case DW_OP_GNU_deref_type:
+         printf ("DW_OP_GNU_deref_type: %ld", (long) byte_get (data++, 1));
+         uvalue = read_leb128 (data, &bytes_read, 0);
+         data += bytes_read;
+         printf (" <0x%s>", dwarf_vmatoa ("x", cu_offset + uvalue));
+         break;
+       case DW_OP_GNU_convert:
+         uvalue = read_leb128 (data, &bytes_read, 0);
+         data += bytes_read;
+         printf ("DW_OP_GNU_convert <0x%s>",
+                 dwarf_vmatoa ("x", uvalue ? cu_offset + uvalue : 0));
+         break;
+       case DW_OP_GNU_reinterpret:
+         uvalue = read_leb128 (data, &bytes_read, 0);
+         data += bytes_read;
+         printf ("DW_OP_GNU_reinterpret <0x%s>",
+                 dwarf_vmatoa ("x", uvalue ? cu_offset + uvalue : 0));
+         break;
+       case DW_OP_GNU_parameter_ref:
+         printf ("DW_OP_GNU_parameter_ref: <0x%s>",
+                 dwarf_vmatoa ("x", cu_offset + byte_get (data, 4)));
+         data += 4;
+         break;
+        case DW_OP_GNU_addr_index:
+          uvalue = read_leb128 (data, &bytes_read, 0);
+          data += bytes_read;
+          printf ("DW_OP_GNU_addr_index <0x%s>", dwarf_vmatoa ("x", uvalue));
+          break;
  
           /* HP extensions.  */
         case DW_OP_HP_is_value:
  
           /* HP extensions.  */
         case DW_OP_HP_is_value:
@@ -1095,15 +1243,15 @@ static unsigned char *
  read_and_display_attr_value (unsigned long attribute,
                              unsigned long form,
                              unsigned char * data,
  read_and_display_attr_value (unsigned long attribute,
                              unsigned long form,
                              unsigned char * data,
-                            unsigned long cu_offset,
-                            unsigned long pointer_size,
-                            unsigned long offset_size,
+                            dwarf_vma cu_offset,
+                            dwarf_vma pointer_size,
+                            dwarf_vma offset_size,
                              int dwarf_version,
                              debug_info * debug_info_p,
                              int do_loc,
                              struct dwarf_section * section)
  {
                              int dwarf_version,
                              debug_info * debug_info_p,
                              int do_loc,
                              struct dwarf_section * section)
  {
-  unsigned long uvalue = 0;
+  dwarf_vma uvalue = 0;
    unsigned char *block_start = NULL;
    unsigned char * orig_data = data;
    unsigned int bytes_read;
    unsigned char *block_start = NULL;
    unsigned char * orig_data = data;
    unsigned int bytes_read;
@@ -1119,15 +1267,14 @@ read_and_display_attr_value (unsigned long attribute,
           uvalue = byte_get (data, pointer_size);
           data += pointer_size;
         }
           uvalue = byte_get (data, pointer_size);
           data += pointer_size;
         }
-      else if (dwarf_version == 3)
+      else if (dwarf_version == 3 || dwarf_version == 4)
         {
           uvalue = byte_get (data, offset_size);
           data += offset_size;
         }
        else
         {
           uvalue = byte_get (data, offset_size);
           data += offset_size;
         }
        else
-       {
-         error (_("Internal error: DWARF version is not 2 or 3.\n"));
-       }
+       error (_("Internal error: DWARF version is not 2, 3 or 4.\n"));
+
        break;
  
      case DW_FORM_addr:
        break;
  
      case DW_FORM_addr:
@@ -1136,10 +1283,15 @@ read_and_display_attr_value (unsigned long attribute,
        break;
  
      case DW_FORM_strp:
        break;
  
      case DW_FORM_strp:
+    case DW_FORM_sec_offset:
        uvalue = byte_get (data, offset_size);
        data += offset_size;
        break;
  
        uvalue = byte_get (data, offset_size);
        data += offset_size;
        break;
  
+    case DW_FORM_flag_present:
+      uvalue = 1;
+      break;
+
      case DW_FORM_ref1:
      case DW_FORM_flag:
      case DW_FORM_data1:
      case DW_FORM_ref1:
      case DW_FORM_flag:
      case DW_FORM_data1:
@@ -1163,6 +1315,11 @@ read_and_display_attr_value (unsigned long attribute,
        data += bytes_read;
        break;
  
        data += bytes_read;
        break;
  
+    case DW_FORM_GNU_str_index:
+      uvalue = read_leb128 (data, & bytes_read, 0);
+      data += bytes_read;
+      break;
+
      case DW_FORM_ref_udata:
      case DW_FORM_udata:
        uvalue = read_leb128 (data, & bytes_read, 0);
      case DW_FORM_ref_udata:
      case DW_FORM_udata:
        uvalue = read_leb128 (data, & bytes_read, 0);
@@ -1179,13 +1336,17 @@ read_and_display_attr_value (unsigned long attribute,
                                           offset_size, dwarf_version,
                                           debug_info_p, do_loc,
                                           section);
                                           offset_size, dwarf_version,
                                           debug_info_p, do_loc,
                                           section);
+    case DW_FORM_GNU_addr_index:
+      uvalue = read_leb128 (data, & bytes_read, 0);
+      data += bytes_read;
+      break;
      }
  
    switch (form)
      {
      case DW_FORM_ref_addr:
        if (!do_loc)
      }
  
    switch (form)
      {
      case DW_FORM_ref_addr:
        if (!do_loc)
-       printf (" <0x%lx>", uvalue);
+       printf (" <0x%s>", dwarf_vmatoa ("x",uvalue));
        break;
  
      case DW_FORM_ref1:
        break;
  
      case DW_FORM_ref1:
@@ -1193,31 +1354,36 @@ read_and_display_attr_value (unsigned long attribute,
      case DW_FORM_ref4:
      case DW_FORM_ref_udata:
        if (!do_loc)
      case DW_FORM_ref4:
      case DW_FORM_ref_udata:
        if (!do_loc)
-       printf (" <0x%lx>", uvalue + cu_offset);
+       printf (" <0x%s>", dwarf_vmatoa ("x", uvalue + cu_offset));
        break;
  
      case DW_FORM_data4:
      case DW_FORM_addr:
        break;
  
      case DW_FORM_data4:
      case DW_FORM_addr:
+    case DW_FORM_sec_offset:
        if (!do_loc)
        if (!do_loc)
-       printf (" 0x%lx", uvalue);
+       printf (" 0x%s", dwarf_vmatoa ("x", uvalue));
        break;
  
        break;
  
+    case DW_FORM_flag_present:
      case DW_FORM_flag:
      case DW_FORM_data1:
      case DW_FORM_data2:
      case DW_FORM_sdata:
      case DW_FORM_udata:
        if (!do_loc)
      case DW_FORM_flag:
      case DW_FORM_data1:
      case DW_FORM_data2:
      case DW_FORM_sdata:
      case DW_FORM_udata:
        if (!do_loc)
-       printf (" %ld", uvalue);
+       printf (" %s", dwarf_vmatoa ("d", uvalue));
        break;
  
      case DW_FORM_ref8:
      case DW_FORM_data8:
        if (!do_loc)
         {
        break;
  
      case DW_FORM_ref8:
      case DW_FORM_data8:
        if (!do_loc)
         {
-         uvalue = byte_get (data, 4);
-         printf (" 0x%lx", uvalue);
-         printf (" 0x%lx", (unsigned long) byte_get (data + 4, 4));
+         dwarf_vma high_bits;
+         char buf[64];
+
+         byte_get_64 (data, &high_bits, &uvalue);
+         printf (" 0x%s",
+                 dwarf_vmatoa64 (high_bits, uvalue, buf, sizeof (buf)));
         }
        if ((do_loc || do_debug_loc || do_debug_ranges)
           && num_debug_info_entries == 0)
         }
        if ((do_loc || do_debug_loc || do_debug_ranges)
           && num_debug_info_entries == 0)
@@ -1225,7 +1391,7 @@ read_and_display_attr_value (unsigned long attribute,
           if (sizeof (uvalue) == 8)
             uvalue = byte_get (data, 8);
           else
           if (sizeof (uvalue) == 8)
             uvalue = byte_get (data, 8);
           else
-           error (_("DW_FORM_data8 is unsupported when sizeof (unsigned long) != 8\n"));
+           error (_("DW_FORM_data8 is unsupported when sizeof (dwarf_vma) != 8\n"));
         }
        data += 8;
        break;
         }
        data += 8;
        break;
@@ -1237,6 +1403,7 @@ read_and_display_attr_value (unsigned long attribute,
        break;
  
      case DW_FORM_block:
        break;
  
      case DW_FORM_block:
+    case DW_FORM_exprloc:
        uvalue = read_leb128 (data, & bytes_read, 0);
        block_start = data + bytes_read;
        if (do_loc)
        uvalue = read_leb128 (data, & bytes_read, 0);
        block_start = data + bytes_read;
        if (do_loc)
@@ -1274,21 +1441,55 @@ read_and_display_attr_value (unsigned long attribute,
  
      case DW_FORM_strp:
        if (!do_loc)
  
      case DW_FORM_strp:
        if (!do_loc)
-       printf (_(" (indirect string, offset: 0x%lx): %s"),
-               uvalue, fetch_indirect_string (uvalue));
+       printf (_(" (indirect string, offset: 0x%s): %s"),
+               dwarf_vmatoa ("x", uvalue),
+               fetch_indirect_string (uvalue));
+      break;
+
+    case DW_FORM_GNU_str_index:
+      if (!do_loc)
+        {
+          const char *suffix = strrchr (section->name, '.');
+          int dwo = (suffix && strcmp (suffix, ".dwo") == 0) ? 1 : 0;
+
+          printf (_(" (indexed string: 0x%s): %s"),
+                  dwarf_vmatoa ("x", uvalue),
+                  fetch_indexed_string (uvalue, offset_size, dwo));
+        }
        break;
  
      case DW_FORM_indirect:
        /* Handled above.  */
        break;
  
        break;
  
      case DW_FORM_indirect:
        /* Handled above.  */
        break;
  
+    case DW_FORM_ref_sig8:
+      if (!do_loc)
+       {
+         dwarf_vma high_bits;
+         char buf[64];
+
+         byte_get_64 (data, &high_bits, &uvalue);
+         printf (" signature: 0x%s",
+                 dwarf_vmatoa64 (high_bits, uvalue, buf, sizeof (buf)));
+       }
+      data += 8;
+      break;
+
+    case DW_FORM_GNU_addr_index:
+      if (!do_loc)
+        printf (_(" (addr_index: 0x%s): %s"),
+                dwarf_vmatoa ("x", uvalue),
+                fetch_indexed_value (uvalue * pointer_size, pointer_size));
+      break;
+
      default:
        warn (_("Unrecognized form: %lu\n"), form);
        break;
      }
  
    if ((do_loc || do_debug_loc || do_debug_ranges)
      default:
        warn (_("Unrecognized form: %lu\n"), form);
        break;
      }
  
    if ((do_loc || do_debug_loc || do_debug_ranges)
-      && num_debug_info_entries == 0)
+      && num_debug_info_entries == 0
+      && debug_info_p != NULL)
      {
        switch (attribute)
         {
      {
        switch (attribute)
         {
@@ -1302,22 +1503,28 @@ read_and_display_attr_value (unsigned long attribute,
         case DW_AT_segment:
         case DW_AT_static_link:
         case DW_AT_use_location:
         case DW_AT_segment:
         case DW_AT_static_link:
         case DW_AT_use_location:
-         if (form == DW_FORM_data4 || form == DW_FORM_data8)
+       case DW_AT_GNU_call_site_value:
+       case DW_AT_GNU_call_site_data_value:
+       case DW_AT_GNU_call_site_target:
+       case DW_AT_GNU_call_site_target_clobbered:
+         if ((dwarf_version < 4
+              && (form == DW_FORM_data4 || form == DW_FORM_data8))
+             || form == DW_FORM_sec_offset)
             {
               /* Process location list.  */
             {
               /* Process location list.  */
-             unsigned int max = debug_info_p->max_loc_offsets;
+             unsigned int lmax = debug_info_p->max_loc_offsets;
               unsigned int num = debug_info_p->num_loc_offsets;
  
               unsigned int num = debug_info_p->num_loc_offsets;
  
-             if (max == 0 || num >= max)
+             if (lmax == 0 || num >= lmax)
                 {
                 {
-                 max += 1024;
-                 debug_info_p->loc_offsets
-                   = xcrealloc (debug_info_p->loc_offsets,
-                                max, sizeof (*debug_info_p->loc_offsets));
-                 debug_info_p->have_frame_base
-                   = xcrealloc (debug_info_p->have_frame_base,
-                                max, sizeof (*debug_info_p->have_frame_base));
-                 debug_info_p->max_loc_offsets = max;
+                 lmax += 1024;
+                 debug_info_p->loc_offsets = (dwarf_vma *)
+                      xcrealloc (debug_info_p->loc_offsets,
+                                lmax, sizeof (*debug_info_p->loc_offsets));
+                 debug_info_p->have_frame_base = (int *)
+                      xcrealloc (debug_info_p->have_frame_base,
+                                lmax, sizeof (*debug_info_p->have_frame_base));
+                 debug_info_p->max_loc_offsets = lmax;
                 }
               debug_info_p->loc_offsets [num] = uvalue;
               debug_info_p->have_frame_base [num] = have_frame_base;
                 }
               debug_info_p->loc_offsets [num] = uvalue;
               debug_info_p->have_frame_base [num] = have_frame_base;
@@ -1330,20 +1537,30 @@ read_and_display_attr_value (unsigned long attribute,
             debug_info_p->base_address = uvalue;
           break;
  
             debug_info_p->base_address = uvalue;
           break;
  
+       case DW_AT_GNU_addr_base:
+          debug_info_p->addr_base = uvalue;
+         break;
+
+       case DW_AT_GNU_ranges_base:
+          debug_info_p->ranges_base = uvalue;
+         break;
+
         case DW_AT_ranges:
         case DW_AT_ranges:
-         if (form == DW_FORM_data4 || form == DW_FORM_data8)
+         if ((dwarf_version < 4
+              && (form == DW_FORM_data4 || form == DW_FORM_data8))
+             || form == DW_FORM_sec_offset)
             {
               /* Process range list.  */
             {
               /* Process range list.  */
-             unsigned int max = debug_info_p->max_range_lists;
+             unsigned int lmax = debug_info_p->max_range_lists;
               unsigned int num = debug_info_p->num_range_lists;
  
               unsigned int num = debug_info_p->num_range_lists;
  
-             if (max == 0 || num >= max)
+             if (lmax == 0 || num >= lmax)
                 {
                 {
-                 max += 1024;
-                 debug_info_p->range_lists
-                   = xcrealloc (debug_info_p->range_lists,
-                                max, sizeof (*debug_info_p->range_lists));
-                 debug_info_p->max_range_lists = max;
+                 lmax += 1024;
+                 debug_info_p->range_lists = (dwarf_vma *)
+                      xcrealloc (debug_info_p->range_lists,
+                                lmax, sizeof (*debug_info_p->range_lists));
+                 debug_info_p->max_range_lists = lmax;
                 }
               debug_info_p->range_lists [num] = uvalue;
               debug_info_p->num_range_lists++;
                 }
               debug_info_p->range_lists [num] = uvalue;
               debug_info_p->num_range_lists++;
@@ -1355,7 +1572,7 @@ read_and_display_attr_value (unsigned long attribute,
         }
      }
  
         }
      }
  
-  if (do_loc)
+  if (do_loc || attribute == 0)
      return data;
  
    /* For some attributes we can display further information.  */
      return data;
  
    /* For some attributes we can display further information.  */
@@ -1379,7 +1596,8 @@ read_and_display_attr_value (unsigned long attribute,
           printf (_("(declared as inline and inlined)"));
           break;
         default:
           printf (_("(declared as inline and inlined)"));
           break;
         default:
-         printf (_("  (Unknown inline attribute value: %lx)"), uvalue);
+         printf (_("  (Unknown inline attribute value: %s)"),
+                 dwarf_vmatoa ("x", uvalue));
           break;
         }
        break;
           break;
         }
        break;
@@ -1409,15 +1627,20 @@ read_and_display_attr_value (unsigned long attribute,
         case DW_LANG_ObjC_plus_plus:    printf ("(Objective C++)"); break;
         case DW_LANG_UPC:               printf ("(Unified Parallel C)"); break;
         case DW_LANG_D:                 printf ("(D)"); break;
         case DW_LANG_ObjC_plus_plus:    printf ("(Objective C++)"); break;
         case DW_LANG_UPC:               printf ("(Unified Parallel C)"); break;
         case DW_LANG_D:                 printf ("(D)"); break;
+         /* DWARF 4 values.  */
+       case DW_LANG_Python:            printf ("(Python)"); break;
+         /* DWARF 5 values.  */
+       case DW_LANG_Go:                printf ("(Go)"); break;
           /* MIPS extension.  */
         case DW_LANG_Mips_Assembler:    printf ("(MIPS assembler)"); break;
           /* UPC extension.  */
         case DW_LANG_Upc:               printf ("(Unified Parallel C)"); break;
         default:
           if (uvalue >= DW_LANG_lo_user && uvalue <= DW_LANG_hi_user)
           /* MIPS extension.  */
         case DW_LANG_Mips_Assembler:    printf ("(MIPS assembler)"); break;
           /* UPC extension.  */
         case DW_LANG_Upc:               printf ("(Unified Parallel C)"); break;
         default:
           if (uvalue >= DW_LANG_lo_user && uvalue <= DW_LANG_hi_user)
-           printf ("(implementation defined: %lx)", uvalue);
+           printf (_("(implementation defined: %s)"),
+                   dwarf_vmatoa ("x", uvalue));
           else
           else
-           printf ("(Unknown: %lx)", uvalue);
+           printf (_("(Unknown: %s)"), dwarf_vmatoa ("x", uvalue));
           break;
         }
        break;
           break;
         }
        break;
@@ -1455,9 +1678,9 @@ read_and_display_attr_value (unsigned long attribute,
         default:
           if (uvalue >= DW_ATE_lo_user
               && uvalue <= DW_ATE_hi_user)
         default:
           if (uvalue >= DW_ATE_lo_user
               && uvalue <= DW_ATE_hi_user)
-           printf ("(user defined type)");
+           printf (_("(user defined type)"));
           else
           else
-           printf ("(unknown type)");
+           printf (_("(unknown type)"));
           break;
         }
        break;
           break;
         }
        break;
@@ -1469,7 +1692,7 @@ read_and_display_attr_value (unsigned long attribute,
         case DW_ACCESS_protected:       printf ("(protected)"); break;
         case DW_ACCESS_private:         printf ("(private)"); break;
         default:
         case DW_ACCESS_protected:       printf ("(protected)"); break;
         case DW_ACCESS_private:         printf ("(private)"); break;
         default:
-         printf ("(unknown accessibility)");
+         printf (_("(unknown accessibility)"));
           break;
         }
        break;
           break;
         }
        break;
@@ -1480,7 +1703,7 @@ read_and_display_attr_value (unsigned long attribute,
         case DW_VIS_local:              printf ("(local)"); break;
         case DW_VIS_exported:           printf ("(exported)"); break;
         case DW_VIS_qualified:          printf ("(qualified)"); break;
         case DW_VIS_local:              printf ("(local)"); break;
         case DW_VIS_exported:           printf ("(exported)"); break;
         case DW_VIS_qualified:          printf ("(qualified)"); break;
-       default:                        printf ("(unknown visibility)"); break;
+       default:                        printf (_("(unknown visibility)")); break;
         }
        break;
  
         }
        break;
  
@@ -1490,7 +1713,7 @@ read_and_display_attr_value (unsigned long attribute,
         case DW_VIRTUALITY_none:        printf ("(none)"); break;
         case DW_VIRTUALITY_virtual:     printf ("(virtual)"); break;
         case DW_VIRTUALITY_pure_virtual:printf ("(pure_virtual)"); break;
         case DW_VIRTUALITY_none:        printf ("(none)"); break;
         case DW_VIRTUALITY_virtual:     printf ("(virtual)"); break;
         case DW_VIRTUALITY_pure_virtual:printf ("(pure_virtual)"); break;
-       default:                        printf ("(unknown virtuality)"); break;
+       default:                        printf (_("(unknown virtuality)")); break;
         }
        break;
  
         }
        break;
  
@@ -1501,7 +1724,7 @@ read_and_display_attr_value (unsigned long attribute,
         case DW_ID_up_case:             printf ("(up_case)"); break;
         case DW_ID_down_case:           printf ("(down_case)"); break;
         case DW_ID_case_insensitive:    printf ("(case_insensitive)"); break;
         case DW_ID_up_case:             printf ("(up_case)"); break;
         case DW_ID_down_case:           printf ("(down_case)"); break;
         case DW_ID_case_insensitive:    printf ("(case_insensitive)"); break;
-       default:                        printf ("(unknown case)"); break;
+       default:                        printf (_("(unknown case)")); break;
         }
        break;
  
         }
        break;
  
@@ -1514,16 +1737,16 @@ read_and_display_attr_value (unsigned long attribute,
         default:
           if (uvalue >= DW_CC_lo_user
               && uvalue <= DW_CC_hi_user)
         default:
           if (uvalue >= DW_CC_lo_user
               && uvalue <= DW_CC_hi_user)
-           printf ("(user defined)");
+           printf (_("(user defined)"));
           else
           else
-           printf ("(unknown convention)");
+           printf (_("(unknown convention)"));
         }
        break;
  
      case DW_AT_ordering:
        switch (uvalue)
         {
         }
        break;
  
      case DW_AT_ordering:
        switch (uvalue)
         {
-       case -1: printf ("(undefined)"); break;
+       case -1: printf (_("(undefined)")); break;
         case 0:  printf ("(row major)"); break;
         case 1:  printf ("(column major)"); break;
         }
         case 0:  printf ("(row major)"); break;
         case 1:  printf ("(column major)"); break;
         }
@@ -1539,7 +1762,13 @@ read_and_display_attr_value (unsigned long attribute,
      case DW_AT_segment:
      case DW_AT_static_link:
      case DW_AT_use_location:
      case DW_AT_segment:
      case DW_AT_static_link:
      case DW_AT_use_location:
-      if (form == DW_FORM_data4 || form == DW_FORM_data8)
+    case DW_AT_GNU_call_site_value:
+    case DW_AT_GNU_call_site_data_value:
+    case DW_AT_GNU_call_site_target:
+    case DW_AT_GNU_call_site_target_clobbered:
+      if ((dwarf_version < 4
+           && (form == DW_FORM_data4 || form == DW_FORM_data8))
+         || form == DW_FORM_sec_offset)
         printf (_("(location list)"));
        /* Fall through.  */
      case DW_AT_allocated:
         printf (_("(location list)"));
        /* Fall through.  */
      case DW_AT_allocated:
@@ -1555,6 +1784,8 @@ read_and_display_attr_value (unsigned long attribute,
           printf ("(");
           need_frame_base = decode_location_expression (block_start,
                                                         pointer_size,
           printf ("(");
           need_frame_base = decode_location_expression (block_start,
                                                         pointer_size,
+                                                       offset_size,
+                                                       dwarf_version,
                                                         uvalue,
                                                         cu_offset, section);
           printf (")");
                                                         uvalue,
                                                         cu_offset, section);
           printf (")");
@@ -1565,14 +1796,19 @@ read_and_display_attr_value (unsigned long attribute,
  
      case DW_AT_import:
        {
  
      case DW_AT_import:
        {
+        if (form == DW_FORM_ref_sig8)
+          break;
+
         if (form == DW_FORM_ref1
             || form == DW_FORM_ref2
         if (form == DW_FORM_ref1
             || form == DW_FORM_ref2
-           || form == DW_FORM_ref4)
+           || form == DW_FORM_ref4
+           || form == DW_FORM_ref_udata)
           uvalue += cu_offset;
  
         if (uvalue >= section->size)
           uvalue += cu_offset;
  
         if (uvalue >= section->size)
-         warn (_("Offset %lx used as value for DW_AT_import attribute of DIE at offset %lx is too big.\n"),
-               uvalue, (unsigned long) (orig_data - section->start));
+         warn (_("Offset %s used as value for DW_AT_import attribute of DIE at offset %lx is too big.\n"),
+               dwarf_vmatoa ("x", uvalue),
+               (unsigned long) (orig_data - section->start));
         else
           {
             unsigned long abbrev_number;
         else
           {
             unsigned long abbrev_number;
@@ -1580,12 +1816,18 @@ read_and_display_attr_value (unsigned long attribute,
  
             abbrev_number = read_leb128 (section->start + uvalue, NULL, 0);
  
  
             abbrev_number = read_leb128 (section->start + uvalue, NULL, 0);
  
-           printf ("[Abbrev Number: %ld", abbrev_number);
-           for (entry = first_abbrev; entry != NULL; entry = entry->next)
-             if (entry->entry == abbrev_number)
-               break;
-           if (entry != NULL)
-             printf (" (%s)", get_TAG_name (entry->tag));
+           printf (_("[Abbrev Number: %ld"), abbrev_number);
+           /* Don't look up abbrev for DW_FORM_ref_addr, as it very often will
+              use different abbrev table, and we don't track .debug_info chunks
+              yet.  */
+           if (form != DW_FORM_ref_addr)
+             {
+               for (entry = first_abbrev; entry != NULL; entry = entry->next)
+                 if (entry->entry == abbrev_number)
+                   break;
+               if (entry != NULL)
+                 printf (" (%s)", get_TAG_name (entry->tag));
+             }
             printf ("]");
           }
        }
             printf ("]");
           }
        }
@@ -1598,167 +1840,36 @@ read_and_display_attr_value (unsigned long attribute,
    return data;
  }
  
    return data;
  }
  
-static char *
+static const char *
  get_AT_name (unsigned long attribute)
  {
  get_AT_name (unsigned long attribute)
  {
-  switch (attribute)
-    {
-    case DW_AT_sibling:                        return "DW_AT_sibling";
-    case DW_AT_location:               return "DW_AT_location";
-    case DW_AT_name:                   return "DW_AT_name";
-    case DW_AT_ordering:               return "DW_AT_ordering";
-    case DW_AT_subscr_data:            return "DW_AT_subscr_data";
-    case DW_AT_byte_size:              return "DW_AT_byte_size";
-    case DW_AT_bit_offset:             return "DW_AT_bit_offset";
-    case DW_AT_bit_size:               return "DW_AT_bit_size";
-    case DW_AT_element_list:           return "DW_AT_element_list";
-    case DW_AT_stmt_list:              return "DW_AT_stmt_list";
-    case DW_AT_low_pc:                 return "DW_AT_low_pc";
-    case DW_AT_high_pc:                        return "DW_AT_high_pc";
-    case DW_AT_language:               return "DW_AT_language";
-    case DW_AT_member:                 return "DW_AT_member";
-    case DW_AT_discr:                  return "DW_AT_discr";
-    case DW_AT_discr_value:            return "DW_AT_discr_value";
-    case DW_AT_visibility:             return "DW_AT_visibility";
-    case DW_AT_import:                 return "DW_AT_import";
-    case DW_AT_string_length:          return "DW_AT_string_length";
-    case DW_AT_common_reference:       return "DW_AT_common_reference";
-    case DW_AT_comp_dir:               return "DW_AT_comp_dir";
-    case DW_AT_const_value:            return "DW_AT_const_value";
-    case DW_AT_containing_type:                return "DW_AT_containing_type";
-    case DW_AT_default_value:          return "DW_AT_default_value";
-    case DW_AT_inline:                 return "DW_AT_inline";
-    case DW_AT_is_optional:            return "DW_AT_is_optional";
-    case DW_AT_lower_bound:            return "DW_AT_lower_bound";
-    case DW_AT_producer:               return "DW_AT_producer";
-    case DW_AT_prototyped:             return "DW_AT_prototyped";
-    case DW_AT_return_addr:            return "DW_AT_return_addr";
-    case DW_AT_start_scope:            return "DW_AT_start_scope";
-    case DW_AT_stride_size:            return "DW_AT_stride_size";
-    case DW_AT_upper_bound:            return "DW_AT_upper_bound";
-    case DW_AT_abstract_origin:                return "DW_AT_abstract_origin";
-    case DW_AT_accessibility:          return "DW_AT_accessibility";
-    case DW_AT_address_class:          return "DW_AT_address_class";
-    case DW_AT_artificial:             return "DW_AT_artificial";
-    case DW_AT_base_types:             return "DW_AT_base_types";
-    case DW_AT_calling_convention:     return "DW_AT_calling_convention";
-    case DW_AT_count:                  return "DW_AT_count";
-    case DW_AT_data_member_location:   return "DW_AT_data_member_location";
-    case DW_AT_decl_column:            return "DW_AT_decl_column";
-    case DW_AT_decl_file:              return "DW_AT_decl_file";
-    case DW_AT_decl_line:              return "DW_AT_decl_line";
-    case DW_AT_declaration:            return "DW_AT_declaration";
-    case DW_AT_discr_list:             return "DW_AT_discr_list";
-    case DW_AT_encoding:               return "DW_AT_encoding";
-    case DW_AT_external:               return "DW_AT_external";
-    case DW_AT_frame_base:             return "DW_AT_frame_base";
-    case DW_AT_friend:                 return "DW_AT_friend";
-    case DW_AT_identifier_case:                return "DW_AT_identifier_case";
-    case DW_AT_macro_info:             return "DW_AT_macro_info";
-    case DW_AT_namelist_items:         return "DW_AT_namelist_items";
-    case DW_AT_priority:               return "DW_AT_priority";
-    case DW_AT_segment:                        return "DW_AT_segment";
-    case DW_AT_specification:          return "DW_AT_specification";
-    case DW_AT_static_link:            return "DW_AT_static_link";
-    case DW_AT_type:                   return "DW_AT_type";
-    case DW_AT_use_location:           return "DW_AT_use_location";
-    case DW_AT_variable_parameter:     return "DW_AT_variable_parameter";
-    case DW_AT_virtuality:             return "DW_AT_virtuality";
-    case DW_AT_vtable_elem_location:   return "DW_AT_vtable_elem_location";
-      /* DWARF 2.1 values.  */
-    case DW_AT_allocated:              return "DW_AT_allocated";
-    case DW_AT_associated:             return "DW_AT_associated";
-    case DW_AT_data_location:          return "DW_AT_data_location";
-    case DW_AT_stride:                 return "DW_AT_stride";
-    case DW_AT_entry_pc:               return "DW_AT_entry_pc";
-    case DW_AT_use_UTF8:               return "DW_AT_use_UTF8";
-    case DW_AT_extension:              return "DW_AT_extension";
-    case DW_AT_ranges:                 return "DW_AT_ranges";
-    case DW_AT_trampoline:             return "DW_AT_trampoline";
-    case DW_AT_call_column:            return "DW_AT_call_column";
-    case DW_AT_call_file:              return "DW_AT_call_file";
-    case DW_AT_call_line:              return "DW_AT_call_line";
-    case DW_AT_description:            return "DW_AT_description";
-    case DW_AT_binary_scale:           return "DW_AT_binary_scale";
-    case DW_AT_decimal_scale:          return "DW_AT_decimal_scale";
-    case DW_AT_small:                  return "DW_AT_small";
-    case DW_AT_decimal_sign:           return "DW_AT_decimal_sign";
-    case DW_AT_digit_count:            return "DW_AT_digit_count";
-    case DW_AT_picture_string:         return "DW_AT_picture_string";
-    case DW_AT_mutable:                        return "DW_AT_mutable";
-    case DW_AT_threads_scaled:         return "DW_AT_threads_scaled";
-    case DW_AT_explicit:               return "DW_AT_explicit";
-    case DW_AT_object_pointer:         return "DW_AT_object_pointer";
-    case DW_AT_endianity:              return "DW_AT_endianity";
-    case DW_AT_elemental:              return "DW_AT_elemental";
-    case DW_AT_pure:                   return "DW_AT_pure";
-    case DW_AT_recursive:              return "DW_AT_recursive";
-
-      /* HP and SGI/MIPS extensions.  */
-    case DW_AT_MIPS_loop_begin:                        return "DW_AT_MIPS_loop_begin";
-    case DW_AT_MIPS_tail_loop_begin:           return "DW_AT_MIPS_tail_loop_begin";
-    case DW_AT_MIPS_epilog_begin:              return "DW_AT_MIPS_epilog_begin";
-    case DW_AT_MIPS_loop_unroll_factor:        return "DW_AT_MIPS_loop_unroll_factor";
-    case DW_AT_MIPS_software_pipeline_depth:   return "DW_AT_MIPS_software_pipeline_depth";
-    case DW_AT_MIPS_linkage_name:              return "DW_AT_MIPS_linkage_name";
-    case DW_AT_MIPS_stride:                    return "DW_AT_MIPS_stride";
-    case DW_AT_MIPS_abstract_name:             return "DW_AT_MIPS_abstract_name";
-    case DW_AT_MIPS_clone_origin:              return "DW_AT_MIPS_clone_origin";
-    case DW_AT_MIPS_has_inlines:               return "DW_AT_MIPS_has_inlines";
-
-      /* HP Extensions.  */
-    case DW_AT_HP_block_index:                 return "DW_AT_HP_block_index";
-    case DW_AT_HP_actuals_stmt_list:           return "DW_AT_HP_actuals_stmt_list";
-    case DW_AT_HP_proc_per_section:            return "DW_AT_HP_proc_per_section";
-    case DW_AT_HP_raw_data_ptr:                        return "DW_AT_HP_raw_data_ptr";
-    case DW_AT_HP_pass_by_reference:           return "DW_AT_HP_pass_by_reference";
-    case DW_AT_HP_opt_level:                   return "DW_AT_HP_opt_level";
-    case DW_AT_HP_prof_version_id:             return "DW_AT_HP_prof_version_id";
-    case DW_AT_HP_opt_flags:                   return "DW_AT_HP_opt_flags";
-    case DW_AT_HP_cold_region_low_pc:          return "DW_AT_HP_cold_region_low_pc";
-    case DW_AT_HP_cold_region_high_pc:         return "DW_AT_HP_cold_region_high_pc";
-    case DW_AT_HP_all_variables_modifiable:    return "DW_AT_HP_all_variables_modifiable";
-    case DW_AT_HP_linkage_name:                        return "DW_AT_HP_linkage_name";
-    case DW_AT_HP_prof_flags:                  return "DW_AT_HP_prof_flags";
-
-      /* One value is shared by the MIPS and HP extensions:  */
-    case DW_AT_MIPS_fde:                       return "DW_AT_MIPS_fde or DW_AT_HP_unmodifiable";
-
-      /* GNU extensions.  */
-    case DW_AT_sf_names:               return "DW_AT_sf_names";
-    case DW_AT_src_info:               return "DW_AT_src_info";
-    case DW_AT_mac_info:               return "DW_AT_mac_info";
-    case DW_AT_src_coords:             return "DW_AT_src_coords";
-    case DW_AT_body_begin:             return "DW_AT_body_begin";
-    case DW_AT_body_end:               return "DW_AT_body_end";
-    case DW_AT_GNU_vector:             return "DW_AT_GNU_vector";
-
-      /* UPC extension.  */
-    case DW_AT_upc_threads_scaled:     return "DW_AT_upc_threads_scaled";
-
-    /* PGI (STMicroelectronics) extensions.  */
-    case DW_AT_PGI_lbase:              return "DW_AT_PGI_lbase";
-    case DW_AT_PGI_soffset:            return "DW_AT_PGI_soffset";
-    case DW_AT_PGI_lstride:            return "DW_AT_PGI_lstride";
+  const char *name;
  
  
-    default:
-      {
-       static char buffer[100];
+  /* One value is shared by the MIPS and HP extensions:  */
+  if (attribute == DW_AT_MIPS_fde)
+    return "DW_AT_MIPS_fde or DW_AT_HP_unmodifiable";
  
  
-       snprintf (buffer, sizeof (buffer), _("Unknown AT value: %lx"),
-                 attribute);
-       return buffer;
-      }
+  name = get_DW_AT_name (attribute);
+
+  if (name == NULL)
+    {
+      static char buffer[100];
+
+      snprintf (buffer, sizeof (buffer), _("Unknown AT value: %lx"),
+               attribute);
+      return buffer;
      }
      }
+
+  return name;
  }
  
  static unsigned char *
  read_and_display_attr (unsigned long attribute,
                        unsigned long form,
                        unsigned char * data,
  }
  
  static unsigned char *
  read_and_display_attr (unsigned long attribute,
                        unsigned long form,
                        unsigned char * data,
-                      unsigned long cu_offset,
-                      unsigned long pointer_size,
-                      unsigned long offset_size,
+                      dwarf_vma cu_offset,
+                      dwarf_vma pointer_size,
+                      dwarf_vma offset_size,
                        int dwarf_version,
                        debug_info * debug_info_p,
                        int do_loc,
                        int dwarf_version,
                        debug_info * debug_info_p,
                        int do_loc,
@@ -1778,12 +1889,15 @@ read_and_display_attr (unsigned long attribute,
  
  /* Process the contents of a .debug_info section.  If do_loc is non-zero
     then we are scanning for location lists and we do not want to display
  
  /* Process the contents of a .debug_info section.  If do_loc is non-zero
     then we are scanning for location lists and we do not want to display
-   anything to the user.  */
+   anything to the user.  If do_types is non-zero, we are processing
+   a .debug_types section instead of a .debug_info section.  */
  
  static int
  process_debug_info (struct dwarf_section *section,
                     void *file,
  
  static int
  process_debug_info (struct dwarf_section *section,
                     void *file,
-                   int do_loc)
+                    enum dwarf_section_display_enum abbrev_sec,
+                   int do_loc,
+                   int do_types)
  {
    unsigned char *start = section->start;
    unsigned char *end = start + section->size;
  {
    unsigned char *start = section->start;
    unsigned char *end = start + section->size;
@@ -1792,9 +1906,10 @@ process_debug_info (struct dwarf_section *section,
    unsigned int num_units = 0;
  
    if ((do_loc || do_debug_loc || do_debug_ranges)
    unsigned int num_units = 0;
  
    if ((do_loc || do_debug_loc || do_debug_ranges)
-      && num_debug_info_entries == 0)
+      && num_debug_info_entries == 0
+      && ! do_types)
      {
      {
-      unsigned long length;
+      dwarf_vma length;
  
        /* First scan the section to get the number of comp units.  */
        for (section_begin = start, num_units = 0; section_begin < end;
  
        /* First scan the section to get the number of comp units.  */
        for (section_begin = start, num_units = 0; section_begin < end;
@@ -1812,7 +1927,8 @@ process_debug_info (struct dwarf_section *section,
             }
           else if (length >= 0xfffffff0 && length < 0xffffffff)
             {
             }
           else if (length >= 0xfffffff0 && length < 0xffffffff)
             {
-             warn (_("Reserved length value (%lx) found in section %s\n"), length, section->name);
+             warn (_("Reserved length value (0x%s) found in section %s\n"),
+                   dwarf_vmatoa ("x", length), section->name);
               return 0;
             }
           else
               return 0;
             }
           else
@@ -1823,7 +1939,8 @@ process_debug_info (struct dwarf_section *section,
              relocations to an object file.  */
           if ((signed long) length <= 0)
             {
              relocations to an object file.  */
           if ((signed long) length <= 0)
             {
-             warn (_("Corrupt unit length (%lx) found in section %s\n"), length, section->name);
+             warn (_("Corrupt unit length (0x%s) found in section %s\n"),
+                   dwarf_vmatoa ("x", length), section->name);
               return 0;
             }
         }
               return 0;
             }
         }
@@ -1835,8 +1952,8 @@ process_debug_info (struct dwarf_section *section,
         }
  
        /* Then allocate an array to hold the information.  */
         }
  
        /* Then allocate an array to hold the information.  */
-      debug_information = cmalloc (num_units,
-                                  sizeof (* debug_information));
+      debug_information = (debug_info *) cmalloc (num_units,
+                                                  sizeof (* debug_information));
        if (debug_information == NULL)
         {
           error (_("Not enough memory for a debug info array of %u entries"),
        if (debug_information == NULL)
         {
           error (_("Not enough memory for a debug info array of %u entries"),
@@ -1847,16 +1964,21 @@ process_debug_info (struct dwarf_section *section,
  
    if (!do_loc)
      {
  
    if (!do_loc)
      {
-      printf (_("Contents of the %s section:\n\n"), section->name);
+      if (dwarf_start_die == 0)
+       printf (_("Contents of the %s section:\n\n"), section->name);
  
        load_debug_section (str, file);
  
        load_debug_section (str, file);
+      load_debug_section (str_dwo, file);
+      load_debug_section (str_index, file);
+      load_debug_section (str_index_dwo, file);
+      load_debug_section (debug_addr, file);
      }
  
      }
  
-  load_debug_section (abbrev, file);
-  if (debug_displays [abbrev].section.start == NULL)
+  load_debug_section (abbrev_sec, file);
+  if (debug_displays [abbrev_sec].section.start == NULL)
      {
        warn (_("Unable to locate %s section!\n"),
      {
        warn (_("Unable to locate %s section!\n"),
-           debug_displays [abbrev].section.name);
+           debug_displays [abbrev_sec].section.name);
        return 0;
      }
  
        return 0;
      }
  
@@ -1864,12 +1986,14 @@ process_debug_info (struct dwarf_section *section,
      {
        DWARF2_Internal_CompUnit compunit;
        unsigned char *hdrptr;
      {
        DWARF2_Internal_CompUnit compunit;
        unsigned char *hdrptr;
-      unsigned char *cu_abbrev_offset_ptr;
        unsigned char *tags;
        unsigned char *tags;
-      int level;
-      unsigned long cu_offset;
+      int level, last_level, saved_level;
+      dwarf_vma cu_offset;
        int offset_size;
        int initial_length_size;
        int offset_size;
        int initial_length_size;
+      dwarf_vma signature_high = 0;
+      dwarf_vma signature_low = 0;
+      dwarf_vma type_offset = 0;
  
        hdrptr = start;
  
  
        hdrptr = start;
  
@@ -1894,19 +2018,32 @@ process_debug_info (struct dwarf_section *section,
  
        cu_offset = start - section_begin;
  
  
        cu_offset = start - section_begin;
  
-      cu_abbrev_offset_ptr = hdrptr;
        compunit.cu_abbrev_offset = byte_get (hdrptr, offset_size);
        hdrptr += offset_size;
  
        compunit.cu_pointer_size = byte_get (hdrptr, 1);
        hdrptr += 1;
        compunit.cu_abbrev_offset = byte_get (hdrptr, offset_size);
        hdrptr += offset_size;
  
        compunit.cu_pointer_size = byte_get (hdrptr, 1);
        hdrptr += 1;
+
+      if (do_types)
+        {
+          byte_get_64 (hdrptr, &signature_high, &signature_low);
+          hdrptr += 8;
+          type_offset = byte_get (hdrptr, offset_size);
+          hdrptr += offset_size;
+        }
+
        if ((do_loc || do_debug_loc || do_debug_ranges)
        if ((do_loc || do_debug_loc || do_debug_ranges)
-         && num_debug_info_entries == 0)
+         && num_debug_info_entries == 0
+         && ! do_types)
         {
           debug_information [unit].cu_offset = cu_offset;
           debug_information [unit].pointer_size
             = compunit.cu_pointer_size;
         {
           debug_information [unit].cu_offset = cu_offset;
           debug_information [unit].pointer_size
             = compunit.cu_pointer_size;
+         debug_information [unit].offset_size = offset_size;
+         debug_information [unit].dwarf_version = compunit.cu_version;
           debug_information [unit].base_address = 0;
           debug_information [unit].base_address = 0;
+         debug_information [unit].addr_base = DEBUG_INFO_UNAVAILABLE;
+         debug_information [unit].ranges_base = DEBUG_INFO_UNAVAILABLE;
           debug_information [unit].loc_offsets = NULL;
           debug_information [unit].have_frame_base = NULL;
           debug_information [unit].max_loc_offsets = 0;
           debug_information [unit].loc_offsets = NULL;
           debug_information [unit].have_frame_base = NULL;
           debug_information [unit].max_loc_offsets = 0;
@@ -1916,30 +2053,48 @@ process_debug_info (struct dwarf_section *section,
           debug_information [unit].num_range_lists = 0;
         }
  
           debug_information [unit].num_range_lists = 0;
         }
  
-      if (!do_loc)
+      if (!do_loc && dwarf_start_die == 0)
         {
         {
-         printf (_("  Compilation Unit @ offset 0x%lx:\n"), cu_offset);
-         printf (_("   Length:        0x%lx (%s)\n"), compunit.cu_length,
-                 initial_length_size == 8 ? "64-bit" : "32-bit");
+         printf (_("  Compilation Unit @ offset 0x%s:\n"),
+                 dwarf_vmatoa ("x", cu_offset));
+         printf (_("   Length:        0x%s (%s)\n"),
+                 dwarf_vmatoa ("x", compunit.cu_length),
+                 offset_size == 8 ? "64-bit" : "32-bit");
           printf (_("   Version:       %d\n"), compunit.cu_version);
           printf (_("   Version:       %d\n"), compunit.cu_version);
-         printf (_("   Abbrev Offset: %ld\n"), compunit.cu_abbrev_offset);
+         printf (_("   Abbrev Offset: %s\n"),
+                 dwarf_vmatoa ("d", compunit.cu_abbrev_offset));
           printf (_("   Pointer Size:  %d\n"), compunit.cu_pointer_size);
           printf (_("   Pointer Size:  %d\n"), compunit.cu_pointer_size);
+         if (do_types)
+           {
+             char buf[64];
+
+             printf (_("   Signature:     0x%s\n"),
+                     dwarf_vmatoa64 (signature_high, signature_low,
+                                     buf, sizeof (buf)));
+             printf (_("   Type Offset:   0x%s\n"),
+                     dwarf_vmatoa ("x", type_offset));
+           }
         }
  
        if (cu_offset + compunit.cu_length + initial_length_size
           > section->size)
         {
         }
  
        if (cu_offset + compunit.cu_length + initial_length_size
           > section->size)
         {
-         warn (_("Debug info is corrupted, length of CU at %lx extends beyond end of section (length = %lx)\n"),
-               cu_offset, compunit.cu_length);
+         warn (_("Debug info is corrupted, length of CU at %s"
+                 " extends beyond end of section (length = %s)\n"),
+               dwarf_vmatoa ("x", cu_offset),
+               dwarf_vmatoa ("x", compunit.cu_length));
           break;
         }
        tags = hdrptr;
        start += compunit.cu_length + initial_length_size;
  
           break;
         }
        tags = hdrptr;
        start += compunit.cu_length + initial_length_size;
  
-      if (compunit.cu_version != 2 && compunit.cu_version != 3)
+      if (compunit.cu_version != 2
+         && compunit.cu_version != 3
+         && compunit.cu_version != 4)
         {
         {
-         warn (_("CU at offset %lx contains corrupt or unsupported version number: %d.\n"),
-               cu_offset, compunit.cu_version);
+         warn (_("CU at offset %s contains corrupt or "
+                 "unsupported version number: %d.\n"),
+               dwarf_vmatoa ("x", cu_offset), compunit.cu_version);
           continue;
         }
  
           continue;
         }
  
@@ -1947,18 +2102,20 @@ process_debug_info (struct dwarf_section *section,
  
        /* Process the abbrevs used by this compilation unit. DWARF
          sections under Mach-O have non-zero addresses.  */
  
        /* Process the abbrevs used by this compilation unit. DWARF
          sections under Mach-O have non-zero addresses.  */
-      if (compunit.cu_abbrev_offset >= debug_displays [abbrev].section.size)
+      if (compunit.cu_abbrev_offset >= debug_displays [abbrev_sec].section.size)
         warn (_("Debug info is corrupted, abbrev offset (%lx) is larger than abbrev section size (%lx)\n"),
               (unsigned long) compunit.cu_abbrev_offset,
         warn (_("Debug info is corrupted, abbrev offset (%lx) is larger than abbrev section size (%lx)\n"),
               (unsigned long) compunit.cu_abbrev_offset,
-             (unsigned long) debug_displays [abbrev].section.size);
+             (unsigned long) debug_displays [abbrev_sec].section.size);
        else
         process_abbrev_section
        else
         process_abbrev_section
-         ((unsigned char *) debug_displays [abbrev].section.start
-          + compunit.cu_abbrev_offset - debug_displays [abbrev].section.address,
-          (unsigned char *) debug_displays [abbrev].section.start
-          + debug_displays [abbrev].section.size);
+         ((unsigned char *) debug_displays [abbrev_sec].section.start
+          + compunit.cu_abbrev_offset,
+          (unsigned char *) debug_displays [abbrev_sec].section.start
+          + debug_displays [abbrev_sec].section.size);
  
        level = 0;
  
        level = 0;
+      last_level = level;
+      saved_level = -1;
        while (tags < start)
         {
           unsigned int bytes_read;
        while (tags < start)
         {
           unsigned int bytes_read;
@@ -1966,15 +2123,29 @@ process_debug_info (struct dwarf_section *section,
           unsigned long die_offset;
           abbrev_entry *entry;
           abbrev_attr *attr;
           unsigned long die_offset;
           abbrev_entry *entry;
           abbrev_attr *attr;
+         int do_printing = 1;
  
           die_offset = tags - section_begin;
  
           abbrev_number = read_leb128 (tags, & bytes_read, 0);
           tags += bytes_read;
  
  
           die_offset = tags - section_begin;
  
           abbrev_number = read_leb128 (tags, & bytes_read, 0);
           tags += bytes_read;
  
-         /* A null DIE marks the end of a list of siblings.  */
+         /* A null DIE marks the end of a list of siblings or it may also be
+            a section padding.  */
           if (abbrev_number == 0)
             {
           if (abbrev_number == 0)
             {
+             /* Check if it can be a section padding for the last CU.  */
+             if (level == 0 && start == end)
+               {
+                 unsigned char *chk;
+
+                 for (chk = tags; chk < start; chk++)
+                   if (*chk != 0)
+                     break;
+                 if (chk == start)
+                   break;
+               }
+
               --level;
               if (level < 0)
                 {
               --level;
               if (level < 0)
                 {
@@ -1982,19 +2153,37 @@ process_debug_info (struct dwarf_section *section,
  
                   if (num_bogus_warns < 3)
                     {
  
                   if (num_bogus_warns < 3)
                     {
-                     warn (_("Bogus end-of-siblings marker detected at offset %lx in .debug_info section\n"),
-                           die_offset);
+                     warn (_("Bogus end-of-siblings marker detected at offset %lx in %s section\n"),
+                           die_offset, section->name);
                       num_bogus_warns ++;
                       if (num_bogus_warns == 3)
                         warn (_("Further warnings about bogus end-of-sibling markers suppressed\n"));
                     }
                 }
                       num_bogus_warns ++;
                       if (num_bogus_warns == 3)
                         warn (_("Further warnings about bogus end-of-sibling markers suppressed\n"));
                     }
                 }
+             if (dwarf_start_die != 0 && level < saved_level)
+               return 1;
               continue;
             }
  
           if (!do_loc)
               continue;
             }
  
           if (!do_loc)
-           printf (_(" <%d><%lx>: Abbrev Number: %lu"),
-                   level, die_offset, abbrev_number);
+           {
+             if (dwarf_start_die != 0 && die_offset < dwarf_start_die)
+               do_printing = 0;
+             else
+               {
+                 if (dwarf_start_die != 0 && die_offset == dwarf_start_die)
+                   saved_level = level;
+                 do_printing = (dwarf_cutoff_level == -1
+                                || level < dwarf_cutoff_level);
+                 if (do_printing)
+                   printf (_(" <%d><%lx>: Abbrev Number: %lu"),
+                           level, die_offset, abbrev_number);
+                 else if (dwarf_cutoff_level == -1
+                          || last_level < dwarf_cutoff_level)
+                   printf (_(" <%d><%lx>: ...\n"), level, die_offset);
+                 last_level = level;
+               }
+           }
  
           /* Scan through the abbreviation list until we reach the
              correct entry.  */
  
           /* Scan through the abbreviation list until we reach the
              correct entry.  */
@@ -2005,7 +2194,7 @@ process_debug_info (struct dwarf_section *section,
  
           if (entry == NULL)
             {
  
           if (entry == NULL)
             {
-             if (!do_loc)
+             if (!do_loc && do_printing)
                 {
                   printf ("\n");
                   fflush (stdout);
                 {
                   printf ("\n");
                   fflush (stdout);
@@ -2015,8 +2204,8 @@ process_debug_info (struct dwarf_section *section,
               return 0;
             }
  
               return 0;
             }
  
-         if (!do_loc)
-           printf (_(" (%s)\n"), get_TAG_name (entry->tag));
+         if (!do_loc && do_printing)
+           printf (" (%s)\n", get_TAG_name (entry->tag));
  
           switch (entry->tag)
             {
  
           switch (entry->tag)
             {
@@ -2036,9 +2225,15 @@ process_debug_info (struct dwarf_section *section,
  
           for (attr = entry->first_attr; attr; attr = attr->next)
             {
  
           for (attr = entry->first_attr; attr; attr = attr->next)
             {
-             if (! do_loc)
+             debug_info *arg;
+
+             if (! do_loc && do_printing)
                 /* Show the offset from where the tag was extracted.  */
                 /* Show the offset from where the tag was extracted.  */
-               printf ("    <%2lx>", (unsigned long)(tags - section_begin));
+               printf ("    <%lx>", (unsigned long)(tags - section_begin));
+
+             arg = debug_information;
+             if (debug_information)
+               arg += unit;
  
               tags = read_and_display_attr (attr->attribute,
                                             attr->form,
  
               tags = read_and_display_attr (attr->attribute,
                                             attr->form,
@@ -2046,8 +2241,8 @@ process_debug_info (struct dwarf_section *section,
                                             compunit.cu_pointer_size,
                                             offset_size,
                                             compunit.cu_version,
                                             compunit.cu_pointer_size,
                                             offset_size,
                                             compunit.cu_version,
-                                           debug_information + unit,
-                                           do_loc, section);
+                                           arg,
+                                           do_loc || ! do_printing, section);
             }
  
           if (entry->children)
             }
  
           if (entry->children)
@@ -2058,13 +2253,12 @@ process_debug_info (struct dwarf_section *section,
    /* Set num_debug_info_entries here so that it can be used to check if
       we need to process .debug_loc and .debug_ranges sections.  */
    if ((do_loc || do_debug_loc || do_debug_ranges)
    /* Set num_debug_info_entries here so that it can be used to check if
       we need to process .debug_loc and .debug_ranges sections.  */
    if ((do_loc || do_debug_loc || do_debug_ranges)
-      && num_debug_info_entries == 0)
+      && num_debug_info_entries == 0
+      && ! do_types)
      num_debug_info_entries = num_units;
  
    if (!do_loc)
      num_debug_info_entries = num_units;
  
    if (!do_loc)
-    {
-      printf ("\n");
-    }
+    printf ("\n");
  
    return 1;
  }
  
    return 1;
  }
@@ -2093,7 +2287,11 @@ load_debug_info (void * file)
      return num_debug_info_entries;
  
    if (load_debug_section (info, file)
      return num_debug_info_entries;
  
    if (load_debug_section (info, file)
-      && process_debug_info (&debug_displays [info].section, file, 1))
+      && process_debug_info (&debug_displays [info].section, file, abbrev, 1, 0))
+    return num_debug_info_entries;
+  else if (load_debug_section (info_dwo, file)
+           && process_debug_info (&debug_displays [info_dwo].section, file,
+                                  abbrev_dwo, 1, 0))
      return num_debug_info_entries;
  
    num_debug_info_entries = DEBUG_INFO_UNAVAILABLE;
      return num_debug_info_entries;
  
    num_debug_info_entries = DEBUG_INFO_UNAVAILABLE;
@@ -2112,7 +2310,7 @@ display_debug_lines_raw (struct dwarf_section *section,
  
    while (data < end)
      {
  
    while (data < end)
      {
-      DWARF2_Internal_LineInfo info;
+      DWARF2_Internal_LineInfo linfo;
        unsigned char *standard_opcodes;
        unsigned char *end_of_sequence;
        unsigned char *hdrptr;
        unsigned char *standard_opcodes;
        unsigned char *end_of_sequence;
        unsigned char *hdrptr;
@@ -2125,13 +2323,13 @@ display_debug_lines_raw (struct dwarf_section *section,
        hdroff = hdrptr - start;
  
        /* Check the length of the block.  */
        hdroff = hdrptr - start;
  
        /* Check the length of the block.  */
-      info.li_length = byte_get (hdrptr, 4);
+      linfo.li_length = byte_get (hdrptr, 4);
        hdrptr += 4;
  
        hdrptr += 4;
  
-      if (info.li_length == 0xffffffff)
+      if (linfo.li_length == 0xffffffff)
         {
           /* This section is 64-bit DWARF 3.  */
         {
           /* This section is 64-bit DWARF 3.  */
-         info.li_length = byte_get (hdrptr, 8);
+         linfo.li_length = byte_get (hdrptr, 8);
           hdrptr += 8;
           offset_size = 8;
           initial_length_size = 12;
           hdrptr += 8;
           offset_size = 8;
           initial_length_size = 12;
@@ -2142,63 +2340,80 @@ display_debug_lines_raw (struct dwarf_section *section,
           initial_length_size = 4;
         }
  
           initial_length_size = 4;
         }
  
-      if (info.li_length + initial_length_size > section->size)
+      if (linfo.li_length + initial_length_size > section->size)
         {
           warn
         {
           warn
-           (_("The line info appears to be corrupt - the section is too small\n"));
+           (_("The information in section %s appears to be corrupt - the section is too small\n"),
+            section->name);
           return 0;
         }
  
        /* Check its version number.  */
           return 0;
         }
  
        /* Check its version number.  */
-      info.li_version = byte_get (hdrptr, 2);
+      linfo.li_version = byte_get (hdrptr, 2);
        hdrptr += 2;
        hdrptr += 2;
-      if (info.li_version != 2 && info.li_version != 3)
+      if (linfo.li_version != 2
+         && linfo.li_version != 3
+         && linfo.li_version != 4)
         {
         {
-         warn (_("Only DWARF version 2 and 3 line info is currently supported.\n"));
+         warn (_("Only DWARF version 2, 3 and 4 line info is currently supported.\n"));
           return 0;
         }
  
           return 0;
         }
  
-      info.li_prologue_length = byte_get (hdrptr, offset_size);
+      linfo.li_prologue_length = byte_get (hdrptr, offset_size);
        hdrptr += offset_size;
        hdrptr += offset_size;
-      info.li_min_insn_length = byte_get (hdrptr, 1);
-      hdrptr++;
-      info.li_default_is_stmt = byte_get (hdrptr, 1);
-      hdrptr++;
-      info.li_line_base = byte_get (hdrptr, 1);
-      hdrptr++;
-      info.li_line_range = byte_get (hdrptr, 1);
-      hdrptr++;
-      info.li_opcode_base = byte_get (hdrptr, 1);
+      linfo.li_min_insn_length = byte_get (hdrptr, 1);
+      hdrptr++;
+      if (linfo.li_version >= 4)
+       {
+         linfo.li_max_ops_per_insn = byte_get (hdrptr, 1);
+         hdrptr++;
+         if (linfo.li_max_ops_per_insn == 0)
+           {
+             warn (_("Invalid maximum operations per insn.\n"));
+             return 0;
+           }
+       }
+      else
+       linfo.li_max_ops_per_insn = 1;
+      linfo.li_default_is_stmt = byte_get (hdrptr, 1);
+      hdrptr++;
+      linfo.li_line_base = byte_get (hdrptr, 1);
+      hdrptr++;
+      linfo.li_line_range = byte_get (hdrptr, 1);
+      hdrptr++;
+      linfo.li_opcode_base = byte_get (hdrptr, 1);
        hdrptr++;
  
        /* Sign extend the line base field.  */
        hdrptr++;
  
        /* Sign extend the line base field.  */
-      info.li_line_base <<= 24;
-      info.li_line_base >>= 24;
+      linfo.li_line_base <<= 24;
+      linfo.li_line_base >>= 24;
  
        printf (_("  Offset:                      0x%lx\n"), hdroff);
  
        printf (_("  Offset:                      0x%lx\n"), hdroff);
-      printf (_("  Length:                      %ld\n"), info.li_length);
-      printf (_("  DWARF Version:               %d\n"), info.li_version);
-      printf (_("  Prologue Length:             %d\n"), info.li_prologue_length);
-      printf (_("  Minimum Instruction Length:  %d\n"), info.li_min_insn_length);
-      printf (_("  Initial value of 'is_stmt':  %d\n"), info.li_default_is_stmt);
-      printf (_("  Line Base:                   %d\n"), info.li_line_base);
-      printf (_("  Line Range:                  %d\n"), info.li_line_range);
-      printf (_("  Opcode Base:                 %d\n"), info.li_opcode_base);
+      printf (_("  Length:                      %ld\n"), (long) linfo.li_length);
+      printf (_("  DWARF Version:               %d\n"), linfo.li_version);
+      printf (_("  Prologue Length:             %d\n"), linfo.li_prologue_length);
+      printf (_("  Minimum Instruction Length:  %d\n"), linfo.li_min_insn_length);
+      if (linfo.li_version >= 4)
+       printf (_("  Maximum Ops per Instruction: %d\n"), linfo.li_max_ops_per_insn);
+      printf (_("  Initial value of 'is_stmt':  %d\n"), linfo.li_default_is_stmt);
+      printf (_("  Line Base:                   %d\n"), linfo.li_line_base);
+      printf (_("  Line Range:                  %d\n"), linfo.li_line_range);
+      printf (_("  Opcode Base:                 %d\n"), linfo.li_opcode_base);
  
  
-      end_of_sequence = data + info.li_length + initial_length_size;
+      end_of_sequence = data + linfo.li_length + initial_length_size;
  
  
-      reset_state_machine (info.li_default_is_stmt);
+      reset_state_machine (linfo.li_default_is_stmt);
  
        /* Display the contents of the Opcodes table.  */
        standard_opcodes = hdrptr;
  
        printf (_("\n Opcodes:\n"));
  
  
        /* Display the contents of the Opcodes table.  */
        standard_opcodes = hdrptr;
  
        printf (_("\n Opcodes:\n"));
  
-      for (i = 1; i < info.li_opcode_base; i++)
+      for (i = 1; i < linfo.li_opcode_base; i++)
         printf (_("  Opcode %d has %d args\n"), i, standard_opcodes[i - 1]);
  
        /* Display the contents of the Directory table.  */
         printf (_("  Opcode %d has %d args\n"), i, standard_opcodes[i - 1]);
  
        /* Display the contents of the Directory table.  */
-      data = standard_opcodes + info.li_opcode_base - 1;
+      data = standard_opcodes + linfo.li_opcode_base - 1;
  
        if (*data == 0)
         printf (_("\n The Directory Table is empty.\n"));
  
        if (*data == 0)
         printf (_("\n The Directory Table is empty.\n"));
@@ -2208,7 +2423,7 @@ display_debug_lines_raw (struct dwarf_section *section,
  
           while (*data != 0)
             {
  
           while (*data != 0)
             {
-             printf (_("  %s\n"), data);
+             printf ("  %s\n", data);
  
               data += strlen ((char *) data) + 1;
             }
  
               data += strlen ((char *) data) + 1;
             }
@@ -2230,18 +2445,21 @@ display_debug_lines_raw (struct dwarf_section *section,
               unsigned char *name;
               unsigned int bytes_read;
  
               unsigned char *name;
               unsigned int bytes_read;
  
-             printf (_("  %d\t"), ++state_machine_regs.last_file_entry);
+             printf ("  %d\t", ++state_machine_regs.last_file_entry);
               name = data;
  
               data += strlen ((char *) data) + 1;
  
               name = data;
  
               data += strlen ((char *) data) + 1;
  
-             printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
+             printf ("%s\t",
+                     dwarf_vmatoa ("u", read_leb128 (data, & bytes_read, 0)));
               data += bytes_read;
               data += bytes_read;
-             printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
+             printf ("%s\t",
+                     dwarf_vmatoa ("u", read_leb128 (data, & bytes_read, 0)));
               data += bytes_read;
               data += bytes_read;
-             printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
+             printf ("%s\t",
+                     dwarf_vmatoa ("u", read_leb128 (data, & bytes_read, 0)));
               data += bytes_read;
               data += bytes_read;
-             printf (_("%s\n"), name);
+             printf ("%s\n", name);
             }
         }
  
             }
         }
  
@@ -2254,28 +2472,49 @@ display_debug_lines_raw (struct dwarf_section *section,
        while (data < end_of_sequence)
         {
           unsigned char op_code;
        while (data < end_of_sequence)
         {
           unsigned char op_code;
-         int adv;
-         unsigned long int uladv;
+         dwarf_signed_vma adv;
+         dwarf_vma uladv;
           unsigned int bytes_read;
  
           op_code = *data++;
  
           unsigned int bytes_read;
  
           op_code = *data++;
  
-         if (op_code >= info.li_opcode_base)
+         if (op_code >= linfo.li_opcode_base)
             {
             {
-             op_code -= info.li_opcode_base;
-             uladv = (op_code / info.li_line_range) * info.li_min_insn_length;
-             state_machine_regs.address += uladv;
-             printf (_("  Special opcode %d: advance Address by %lu to 0x%lx"),
-                     op_code, uladv, state_machine_regs.address);
-             adv = (op_code % info.li_line_range) + info.li_line_base;
+             op_code -= linfo.li_opcode_base;
+             uladv = (op_code / linfo.li_line_range);
+             if (linfo.li_max_ops_per_insn == 1)
+               {
+                 uladv *= linfo.li_min_insn_length;
+                 state_machine_regs.address += uladv;
+                 printf (_("  Special opcode %d: "
+                           "advance Address by %s to 0x%s"),
+                         op_code, dwarf_vmatoa ("u", uladv),
+                         dwarf_vmatoa ("x", state_machine_regs.address));
+               }
+             else
+               {
+                 state_machine_regs.address
+                   += ((state_machine_regs.op_index + uladv)
+                       / linfo.li_max_ops_per_insn)
+                      * linfo.li_min_insn_length;
+                 state_machine_regs.op_index
+                   = (state_machine_regs.op_index + uladv)
+                     % linfo.li_max_ops_per_insn;
+                 printf (_("  Special opcode %d: "
+                           "advance Address by %s to 0x%s[%d]"),
+                         op_code, dwarf_vmatoa ("u", uladv),
+                         dwarf_vmatoa ("x", state_machine_regs.address),
+                         state_machine_regs.op_index);
+               }
+             adv = (op_code % linfo.li_line_range) + linfo.li_line_base;
               state_machine_regs.line += adv;
               state_machine_regs.line += adv;
-             printf (_(" and Line by %d to %d\n"),
-                     adv, state_machine_regs.line);
+             printf (_(" and Line by %s to %d\n"),
+                     dwarf_vmatoa ("d", adv), state_machine_regs.line);
             }
           else switch (op_code)
             {
             case DW_LNS_extended_op:
             }
           else switch (op_code)
             {
             case DW_LNS_extended_op:
-             data += process_extended_line_op (data, info.li_default_is_stmt);
+             data += process_extended_line_op (data, linfo.li_default_is_stmt);
               break;
  
             case DW_LNS_copy:
               break;
  
             case DW_LNS_copy:
@@ -2284,40 +2523,60 @@ display_debug_lines_raw (struct dwarf_section *section,
  
             case DW_LNS_advance_pc:
               uladv = read_leb128 (data, & bytes_read, 0);
  
             case DW_LNS_advance_pc:
               uladv = read_leb128 (data, & bytes_read, 0);
-             uladv *= info.li_min_insn_length;
               data += bytes_read;
               data += bytes_read;
-             state_machine_regs.address += uladv;
-             printf (_("  Advance PC by %lu to 0x%lx\n"), uladv,
-                     state_machine_regs.address);
+             if (linfo.li_max_ops_per_insn == 1)
+               {
+                 uladv *= linfo.li_min_insn_length;
+                 state_machine_regs.address += uladv;
+                 printf (_("  Advance PC by %s to 0x%s\n"),
+                         dwarf_vmatoa ("u", uladv),
+                         dwarf_vmatoa ("x", state_machine_regs.address));
+               }
+             else
+               {
+                 state_machine_regs.address
+                   += ((state_machine_regs.op_index + uladv)
+                       / linfo.li_max_ops_per_insn)
+                      * linfo.li_min_insn_length;
+                 state_machine_regs.op_index
+                   = (state_machine_regs.op_index + uladv)
+                     % linfo.li_max_ops_per_insn;
+                 printf (_("  Advance PC by %s to 0x%s[%d]\n"),
+                         dwarf_vmatoa ("u", uladv),
+                         dwarf_vmatoa ("x", state_machine_regs.address),
+                         state_machine_regs.op_index);
+               }
               break;
  
             case DW_LNS_advance_line:
               break;
  
             case DW_LNS_advance_line:
-             adv = read_leb128 (data, & bytes_read, 1);
+             adv = read_sleb128 (data, & bytes_read);
               data += bytes_read;
               state_machine_regs.line += adv;
               data += bytes_read;
               state_machine_regs.line += adv;
-             printf (_("  Advance Line by %d to %d\n"), adv,
-                     state_machine_regs.line);
+             printf (_("  Advance Line by %s to %d\n"),
+                       dwarf_vmatoa ("d", adv),
+                       state_machine_regs.line);
               break;
  
             case DW_LNS_set_file:
               adv = read_leb128 (data, & bytes_read, 0);
               data += bytes_read;
               break;
  
             case DW_LNS_set_file:
               adv = read_leb128 (data, & bytes_read, 0);
               data += bytes_read;
-             printf (_("  Set File Name to entry %d in the File Name Table\n"),
-                     adv);
+             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_leb128 (data, & bytes_read, 0);
               data += bytes_read;
               state_machine_regs.file = adv;
               break;
  
             case DW_LNS_set_column:
               uladv = read_leb128 (data, & bytes_read, 0);
               data += bytes_read;
-             printf (_("  Set column to %lu\n"), uladv);
+             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;
               state_machine_regs.column = uladv;
               break;
  
             case DW_LNS_negate_stmt:
               adv = state_machine_regs.is_stmt;
               adv = ! adv;
-             printf (_("  Set is_stmt to %d\n"), adv);
+             printf (_("  Set is_stmt to %s\n"), dwarf_vmatoa ("d", adv));
               state_machine_regs.is_stmt = adv;
               break;
  
               state_machine_regs.is_stmt = adv;
               break;
  
@@ -2327,19 +2586,39 @@ display_debug_lines_raw (struct dwarf_section *section,
               break;
  
             case DW_LNS_const_add_pc:
               break;
  
             case DW_LNS_const_add_pc:
-             uladv = (((255 - info.li_opcode_base) / info.li_line_range)
-                     * info.li_min_insn_length);
-             state_machine_regs.address += uladv;
-             printf (_("  Advance PC by constant %lu to 0x%lx\n"), uladv,
-                     state_machine_regs.address);
+             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;
+                 printf (_("  Advance PC by constant %s to 0x%s\n"),
+                         dwarf_vmatoa ("u", uladv),
+                         dwarf_vmatoa ("x", state_machine_regs.address));
+               }
+             else
+               {
+                 state_machine_regs.address
+                   += ((state_machine_regs.op_index + uladv)
+                       / linfo.li_max_ops_per_insn)
+                      * linfo.li_min_insn_length;
+                 state_machine_regs.op_index
+                   = (state_machine_regs.op_index + uladv)
+                     % linfo.li_max_ops_per_insn;
+                 printf (_("  Advance PC by constant %s to 0x%s[%d]\n"),
+                         dwarf_vmatoa ("u", uladv),
+                         dwarf_vmatoa ("x", state_machine_regs.address),
+                         state_machine_regs.op_index);
+               }
               break;
  
             case DW_LNS_fixed_advance_pc:
               uladv = byte_get (data, 2);
               data += 2;
               state_machine_regs.address += uladv;
               break;
  
             case DW_LNS_fixed_advance_pc:
               uladv = byte_get (data, 2);
               data += 2;
               state_machine_regs.address += uladv;
-             printf (_("  Advance PC by fixed size amount %lu to 0x%lx\n"),
-                     uladv, state_machine_regs.address);
+             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));
               break;
  
             case DW_LNS_set_prologue_end:
               break;
  
             case DW_LNS_set_prologue_end:
@@ -2353,7 +2632,7 @@ display_debug_lines_raw (struct dwarf_section *section,
             case DW_LNS_set_isa:
               uladv = read_leb128 (data, & bytes_read, 0);
               data += bytes_read;
             case DW_LNS_set_isa:
               uladv = read_leb128 (data, & bytes_read, 0);
               data += bytes_read;
-             printf (_("  Set ISA to %lu\n"), uladv);
+             printf (_("  Set ISA to %s\n"), dwarf_vmatoa ("u", uladv));
               break;
  
             default:
               break;
  
             default:
@@ -2361,7 +2640,8 @@ display_debug_lines_raw (struct dwarf_section *section,
  
               for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
                 {
  
               for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
                 {
-                 printf ("0x%lx%s", read_leb128 (data, &bytes_read, 0),
+                 printf ("0x%s%s", dwarf_vmatoa ("x", read_leb128 (data,
+                                                        &bytes_read, 0)),
                           i == 1 ? "" : ", ");
                   data += bytes_read;
                 }
                           i == 1 ? "" : ", ");
                   data += bytes_read;
                 }
@@ -2377,10 +2657,10 @@ display_debug_lines_raw (struct dwarf_section *section,
  
  typedef struct
  {
  
  typedef struct
  {
-    unsigned char *name;
-    unsigned int directory_index;
-    unsigned int modification_date;
-    unsigned int length;
+  unsigned char *name;
+  unsigned int directory_index;
+  unsigned int modification_date;
+  unsigned int length;
  } File_Entry;
  
  /* Output a decoded representation of the .debug_line section.  */
  } File_Entry;
  
  /* Output a decoded representation of the .debug_line section.  */
@@ -2396,7 +2676,7 @@ display_debug_lines_decoded (struct dwarf_section *section,
    while (data < end)
      {
        /* This loop amounts to one iteration per compilation unit.  */
    while (data < end)
      {
        /* This loop amounts to one iteration per compilation unit.  */
-      DWARF2_Internal_LineInfo info;
+      DWARF2_Internal_LineInfo linfo;
        unsigned char *standard_opcodes;
        unsigned char *end_of_sequence;
        unsigned char *hdrptr;
        unsigned char *standard_opcodes;
        unsigned char *end_of_sequence;
        unsigned char *hdrptr;
@@ -2404,8 +2684,9 @@ display_debug_lines_decoded (struct dwarf_section *section,
        int offset_size;
        int i;
        File_Entry *file_table = NULL;
        int offset_size;
        int i;
        File_Entry *file_table = NULL;
+      unsigned int n_files = 0;
        unsigned char **directory_table = NULL;
        unsigned char **directory_table = NULL;
-      unsigned int prev_line = 0;
+      unsigned int n_directories = 0;
  
        hdrptr = data;
  
  
        hdrptr = data;
  
@@ -2413,13 +2694,13 @@ display_debug_lines_decoded (struct dwarf_section *section,
          (section 6.2.4 in the Dwarf3 doc).  */
  
        /* Get the length of this CU's line number information block.  */
          (section 6.2.4 in the Dwarf3 doc).  */
  
        /* Get the length of this CU's line number information block.  */
-      info.li_length = byte_get (hdrptr, 4);
+      linfo.li_length = byte_get (hdrptr, 4);
        hdrptr += 4;
  
        hdrptr += 4;
  
-      if (info.li_length == 0xffffffff)
+      if (linfo.li_length == 0xffffffff)
          {
            /* This section is 64-bit DWARF 3.  */
          {
            /* This section is 64-bit DWARF 3.  */
-          info.li_length = byte_get (hdrptr, 8);
+          linfo.li_length = byte_get (hdrptr, 8);
            hdrptr += 8;
            offset_size = 8;
            initial_length_size = 12;
            hdrptr += 8;
            offset_size = 8;
            initial_length_size = 12;
@@ -2430,7 +2711,7 @@ display_debug_lines_decoded (struct dwarf_section *section,
            initial_length_size = 4;
          }
  
            initial_length_size = 4;
          }
  
-      if (info.li_length + initial_length_size > section->size)
+      if (linfo.li_length + initial_length_size > section->size)
          {
            warn (_("The line info appears to be corrupt - "
                    "the section is too small\n"));
          {
            warn (_("The line info appears to be corrupt - "
                    "the section is too small\n"));
@@ -2438,47 +2719,59 @@ display_debug_lines_decoded (struct dwarf_section *section,
          }
  
        /* Get this CU's Line Number Block version number.  */
          }
  
        /* Get this CU's Line Number Block version number.  */
-      info.li_version = byte_get (hdrptr, 2);
+      linfo.li_version = byte_get (hdrptr, 2);
        hdrptr += 2;
        hdrptr += 2;
-      if (info.li_version != 2 && info.li_version != 3)
+      if (linfo.li_version != 2
+         && linfo.li_version != 3
+         && linfo.li_version != 4)
          {
          {
-          warn (_("Only DWARF version 2 and 3 line info is currently "
+          warn (_("Only DWARF version 2, 3 and 4 line info is currently "
                  "supported.\n"));
            return 0;
          }
  
                  "supported.\n"));
            return 0;
          }
  
-      info.li_prologue_length = byte_get (hdrptr, offset_size);
+      linfo.li_prologue_length = byte_get (hdrptr, offset_size);
        hdrptr += offset_size;
        hdrptr += offset_size;
-      info.li_min_insn_length = byte_get (hdrptr, 1);
+      linfo.li_min_insn_length = byte_get (hdrptr, 1);
        hdrptr++;
        hdrptr++;
-      info.li_default_is_stmt = byte_get (hdrptr, 1);
+      if (linfo.li_version >= 4)
+       {
+         linfo.li_max_ops_per_insn = byte_get (hdrptr, 1);
+         hdrptr++;
+         if (linfo.li_max_ops_per_insn == 0)
+           {
+             warn (_("Invalid maximum operations per insn.\n"));
+             return 0;
+           }
+       }
+      else
+       linfo.li_max_ops_per_insn = 1;
+      linfo.li_default_is_stmt = byte_get (hdrptr, 1);
        hdrptr++;
        hdrptr++;
-      info.li_line_base = byte_get (hdrptr, 1);
+      linfo.li_line_base = byte_get (hdrptr, 1);
        hdrptr++;
        hdrptr++;
-      info.li_line_range = byte_get (hdrptr, 1);
+      linfo.li_line_range = byte_get (hdrptr, 1);
        hdrptr++;
        hdrptr++;
-      info.li_opcode_base = byte_get (hdrptr, 1);
+      linfo.li_opcode_base = byte_get (hdrptr, 1);
        hdrptr++;
  
        /* Sign extend the line base field.  */
        hdrptr++;
  
        /* Sign extend the line base field.  */
-      info.li_line_base <<= 24;
-      info.li_line_base >>= 24;
+      linfo.li_line_base <<= 24;
+      linfo.li_line_base >>= 24;
  
        /* Find the end of this CU's Line Number Information Block.  */
  
        /* Find the end of this CU's Line Number Information Block.  */
-      end_of_sequence = data + info.li_length + initial_length_size;
+      end_of_sequence = data + linfo.li_length + initial_length_size;
  
  
-      reset_state_machine (info.li_default_is_stmt);
+      reset_state_machine (linfo.li_default_is_stmt);
  
        /* Save a pointer to the contents of the Opcodes table.  */
        standard_opcodes = hdrptr;
  
        /* Traverse the Directory table just to count entries.  */
  
        /* Save a pointer to the contents of the Opcodes table.  */
        standard_opcodes = hdrptr;
  
        /* Traverse the Directory table just to count entries.  */
-      data = standard_opcodes + info.li_opcode_base - 1;
+      data = standard_opcodes + linfo.li_opcode_base - 1;
        if (*data != 0)
          {
        if (*data != 0)
          {
-          unsigned int n_directories = 0;
            unsigned char *ptr_directory_table = data;
            unsigned char *ptr_directory_table = data;
-          int i;
  
           while (*data != 0)
             {
  
           while (*data != 0)
             {
@@ -2487,7 +2780,8 @@ display_debug_lines_decoded (struct dwarf_section *section,
             }
  
            /* Go through the directory table again to save the directories.  */
             }
  
            /* Go through the directory table again to save the directories.  */
-          directory_table = xmalloc (n_directories * sizeof (unsigned char *));
+          directory_table = (unsigned char **)
+              xmalloc (n_directories * sizeof (unsigned char *));
  
            i = 0;
            while (*ptr_directory_table != 0)
  
            i = 0;
            while (*ptr_directory_table != 0)
@@ -2503,9 +2797,7 @@ display_debug_lines_decoded (struct dwarf_section *section,
        /* Traverse the File Name table just to count the entries.  */
        if (*data != 0)
          {
        /* Traverse the File Name table just to count the entries.  */
        if (*data != 0)
          {
-          unsigned int n_files = 0;
            unsigned char *ptr_file_name_table = data;
            unsigned char *ptr_file_name_table = data;
-          int i;
  
            while (*data != 0)
              {
  
            while (*data != 0)
              {
@@ -2525,7 +2817,7 @@ display_debug_lines_decoded (struct dwarf_section *section,
              }
  
            /* Go through the file table again to save the strings.  */
              }
  
            /* Go through the file table again to save the strings.  */
-          file_table = xmalloc (n_files * sizeof (File_Entry));
+          file_table = (File_Entry *) xmalloc (n_files * sizeof (File_Entry));
  
            i = 0;
            while (*ptr_file_name_table != 0)
  
            i = 0;
            while (*ptr_file_name_table != 0)
@@ -2556,15 +2848,13 @@ display_debug_lines_decoded (struct dwarf_section *section,
              }
            else
              {
              }
            else
              {
-              if (do_wide || strlen ((char *) directory_table[0]) < 76)
-                {
-                  printf (_("CU: %s/%s:\n"), directory_table[0],
-                          file_table[0].name);
-                }
+              unsigned int ix = file_table[0].directory_index;
+              const char *directory = ix ? (char *)directory_table[ix - 1] : ".";
+              if (do_wide || strlen (directory) < 76)
+               printf (_("CU: %s/%s:\n"), directory, file_table[0].name);
                else
                else
-                {
-                  printf (_("%s:\n"), file_table[0].name);
-                }
+               printf ("%s:\n", file_table[0].name);
+
                printf (_("File name                            Line number    Starting address\n"));
              }
          }
                printf (_("File name                            Line number    Starting address\n"));
              }
          }
@@ -2582,15 +2872,28 @@ display_debug_lines_decoded (struct dwarf_section *section,
            int is_special_opcode = 0;
  
            op_code = *data++;
            int is_special_opcode = 0;
  
            op_code = *data++;
-          prev_line = state_machine_regs.line;
  
  
-          if (op_code >= info.li_opcode_base)
+          if (op_code >= linfo.li_opcode_base)
             {
             {
-             op_code -= info.li_opcode_base;
-              uladv = (op_code / info.li_line_range) * info.li_min_insn_length;
-              state_machine_regs.address += uladv;
+             op_code -= linfo.li_opcode_base;
+             uladv = (op_code / linfo.li_line_range);
+             if (linfo.li_max_ops_per_insn == 1)
+               {
+                 uladv *= linfo.li_min_insn_length;
+                 state_machine_regs.address += uladv;
+               }
+             else
+               {
+                 state_machine_regs.address
+                   += ((state_machine_regs.op_index + uladv)
+                       / linfo.li_max_ops_per_insn)
+                      * linfo.li_min_insn_length;
+                 state_machine_regs.op_index
+                   = (state_machine_regs.op_index + uladv)
+                     % linfo.li_max_ops_per_insn;
+               }
  
  
-              adv = (op_code % info.li_line_range) + info.li_line_base;
+              adv = (op_code % linfo.li_line_range) + linfo.li_line_base;
                state_machine_regs.line += adv;
                is_special_opcode = 1;
              }
                state_machine_regs.line += adv;
                is_special_opcode = 1;
              }
@@ -2599,7 +2902,6 @@ display_debug_lines_decoded (struct dwarf_section *section,
              case DW_LNS_extended_op:
                {
                  unsigned int ext_op_code_len;
              case DW_LNS_extended_op:
                {
                  unsigned int ext_op_code_len;
-                unsigned int bytes_read;
                  unsigned char ext_op_code;
                  unsigned char *op_code_data = data;
  
                  unsigned char ext_op_code;
                  unsigned char *op_code_data = data;
  
@@ -2617,29 +2919,45 @@ display_debug_lines_decoded (struct dwarf_section *section,
                  switch (ext_op_code)
                    {
                    case DW_LNE_end_sequence:
                  switch (ext_op_code)
                    {
                    case DW_LNE_end_sequence:
-                    reset_state_machine (info.li_default_is_stmt);
+                    reset_state_machine (linfo.li_default_is_stmt);
                      break;
                    case DW_LNE_set_address:
                      state_machine_regs.address =
                      byte_get (op_code_data, ext_op_code_len - bytes_read - 1);
                      break;
                    case DW_LNE_set_address:
                      state_machine_regs.address =
                      byte_get (op_code_data, ext_op_code_len - bytes_read - 1);
+                   state_machine_regs.op_index = 0;
                      break;
                    case DW_LNE_define_file:
                      {
                      break;
                    case DW_LNE_define_file:
                      {
-                      unsigned int dir_index = 0;
+                      file_table = (File_Entry *) xrealloc
+                        (file_table, (n_files + 1) * sizeof (File_Entry));
  
                        ++state_machine_regs.last_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;
                        op_code_data += strlen ((char *) op_code_data) + 1;
-                      dir_index = read_leb128 (op_code_data, & bytes_read, 0);
+                      /* Directory index.  */
+                      file_table[n_files].directory_index =
+                        read_leb128 (op_code_data, & bytes_read, 0);
                        op_code_data += bytes_read;
                        op_code_data += bytes_read;
-                      read_leb128 (op_code_data, & bytes_read, 0);
+                      /* Last modification time.  */
+                      file_table[n_files].modification_date =
+                        read_leb128 (op_code_data, & bytes_read, 0);
                        op_code_data += bytes_read;
                        op_code_data += bytes_read;
-                      read_leb128 (op_code_data, & bytes_read, 0);
+                      /* File length.  */
+                      file_table[n_files].length =
+                        read_leb128 (op_code_data, & bytes_read, 0);
  
  
-                      printf (_("%s:\n"), directory_table[dir_index]);
+                      n_files++;
                        break;
                      }
                        break;
                      }
+                  case DW_LNE_set_discriminator:
+                  case DW_LNE_HP_set_sequence:
+                    /* Simply ignored.  */
+                    break;
+
                    default:
                    default:
-                    printf (_("UNKNOWN: length %d\n"), ext_op_code_len - bytes_read);
+                    printf (_("UNKNOWN (%u): length %d\n"),
+                            ext_op_code, ext_op_code_len - bytes_read);
                      break;
                    }
                  data += ext_op_code_len;
                      break;
                    }
                  data += ext_op_code_len;
@@ -2650,13 +2968,26 @@ display_debug_lines_decoded (struct dwarf_section *section,
  
              case DW_LNS_advance_pc:
                uladv = read_leb128 (data, & bytes_read, 0);
  
              case DW_LNS_advance_pc:
                uladv = read_leb128 (data, & bytes_read, 0);
-              uladv *= info.li_min_insn_length;
                data += bytes_read;
                data += bytes_read;
-              state_machine_regs.address += uladv;
+             if (linfo.li_max_ops_per_insn == 1)
+               {
+                 uladv *= linfo.li_min_insn_length;
+                 state_machine_regs.address += uladv;
+               }
+             else
+               {
+                 state_machine_regs.address
+                   += ((state_machine_regs.op_index + uladv)
+                       / linfo.li_max_ops_per_insn)
+                      * linfo.li_min_insn_length;
+                 state_machine_regs.op_index
+                   = (state_machine_regs.op_index + uladv)
+                     % linfo.li_max_ops_per_insn;
+               }
                break;
  
              case DW_LNS_advance_line:
                break;
  
              case DW_LNS_advance_line:
-              adv = read_leb128 (data, & bytes_read, 1);
+              adv = read_sleb128 (data, & bytes_read);
                data += bytes_read;
                state_machine_regs.line += adv;
                break;
                data += bytes_read;
                state_machine_regs.line += adv;
                break;
@@ -2668,13 +2999,13 @@ display_debug_lines_decoded (struct dwarf_section *section,
                if (file_table[state_machine_regs.file - 1].directory_index == 0)
                  {
                    /* If directory index is 0, that means current directory.  */
                if (file_table[state_machine_regs.file - 1].directory_index == 0)
                  {
                    /* If directory index is 0, that means current directory.  */
-                  printf (_("\n./%s:[++]\n"),
+                  printf ("\n./%s:[++]\n",
                            file_table[state_machine_regs.file - 1].name);
                  }
                else
                  {
                    /* The directory index starts counting at 1.  */
                            file_table[state_machine_regs.file - 1].name);
                  }
                else
                  {
                    /* The directory index starts counting at 1.  */
-                  printf (_("\n%s/%s:\n"),
+                  printf ("\n%s/%s:\n",
                            directory_table[file_table[state_machine_regs.file - 1].directory_index - 1],
                            file_table[state_machine_regs.file - 1].name);
                  }
                            directory_table[file_table[state_machine_regs.file - 1].directory_index - 1],
                            file_table[state_machine_regs.file - 1].name);
                  }
@@ -2697,15 +3028,29 @@ display_debug_lines_decoded (struct dwarf_section *section,
                break;
  
              case DW_LNS_const_add_pc:
                break;
  
              case DW_LNS_const_add_pc:
-              uladv = (((255 - info.li_opcode_base) / info.li_line_range)
-                       * info.li_min_insn_length);
-              state_machine_regs.address += uladv;
+             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;
+               }
+             else
+               {
+                 state_machine_regs.address
+                   += ((state_machine_regs.op_index + uladv)
+                       / linfo.li_max_ops_per_insn)
+                      * linfo.li_min_insn_length;
+                 state_machine_regs.op_index
+                   = (state_machine_regs.op_index + uladv)
+                     % linfo.li_max_ops_per_insn;
+               }
                break;
  
              case DW_LNS_fixed_advance_pc:
                uladv = byte_get (data, 2);
                data += 2;
                state_machine_regs.address += uladv;
                break;
  
              case DW_LNS_fixed_advance_pc:
                uladv = byte_get (data, 2);
                data += 2;
                state_machine_regs.address += uladv;
+             state_machine_regs.op_index = 0;
                break;
  
              case DW_LNS_set_prologue_end:
                break;
  
              case DW_LNS_set_prologue_end:
@@ -2725,7 +3070,8 @@ display_debug_lines_decoded (struct dwarf_section *section,
  
                for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
                  {
  
                for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
                  {
-                  printf ("0x%lx%s", read_leb128 (data, &bytes_read, 0),
+                  printf ("0x%s%s", dwarf_vmatoa ("x", read_leb128 (data,
+                                                        &bytes_read, 0)),
                            i == 1 ? "" : ", ");
                    data += bytes_read;
                  }
                            i == 1 ? "" : ", ");
                    data += bytes_read;
                  }
@@ -2745,7 +3091,7 @@ display_debug_lines_decoded (struct dwarf_section *section,
  
                if ((fileNameLength > MAX_FILENAME_LENGTH) && (!do_wide))
                  {
  
                if ((fileNameLength > MAX_FILENAME_LENGTH) && (!do_wide))
                  {
-                  newFileName = xmalloc (MAX_FILENAME_LENGTH + 1);
+                  newFileName = (char *) xmalloc (MAX_FILENAME_LENGTH + 1);
                    /* Truncate file name */
                    strncpy (newFileName,
                             fileName + fileNameLength - MAX_FILENAME_LENGTH,
                    /* Truncate file name */
                    strncpy (newFileName,
                             fileName + fileNameLength - MAX_FILENAME_LENGTH,
@@ -2753,19 +3099,33 @@ display_debug_lines_decoded (struct dwarf_section *section,
                  }
                else
                  {
                  }
                else
                  {
-                  newFileName = xmalloc (fileNameLength + 1);
+                  newFileName = (char *) xmalloc (fileNameLength + 1);
                    strncpy (newFileName, fileName, fileNameLength + 1);
                  }
  
                if (!do_wide || (fileNameLength <= MAX_FILENAME_LENGTH))
                  {
                    strncpy (newFileName, fileName, fileNameLength + 1);
                  }
  
                if (!do_wide || (fileNameLength <= MAX_FILENAME_LENGTH))
                  {
-                  printf (_("%-35s  %11d  %#18lx\n"), newFileName,
-                          state_machine_regs.line, state_machine_regs.address);
+                 if (linfo.li_max_ops_per_insn == 1)
+                   printf ("%-35s  %11d  %#18" DWARF_VMA_FMT "x\n",
+                           newFileName, state_machine_regs.line,
+                           state_machine_regs.address);
+                 else
+                   printf ("%-35s  %11d  %#18" DWARF_VMA_FMT "x[%d]\n",
+                           newFileName, state_machine_regs.line,
+                           state_machine_regs.address,
+                           state_machine_regs.op_index);
                  }
                else
                  {
                  }
                else
                  {
-                  printf (_("%s  %11d  %#18lx\n"), newFileName,
-                          state_machine_regs.line, state_machine_regs.address);
+                 if (linfo.li_max_ops_per_insn == 1)
+                   printf ("%s  %11d  %#18" DWARF_VMA_FMT "x\n",
+                           newFileName, state_machine_regs.line,
+                           state_machine_regs.address);
+                 else
+                   printf ("%s  %11d  %#18" DWARF_VMA_FMT "x[%d]\n",
+                           newFileName, state_machine_regs.line,
+                           state_machine_regs.address,
+                           state_machine_regs.op_index);
                  }
  
                if (op_code == DW_LNE_end_sequence)
                  }
  
                if (op_code == DW_LNE_end_sequence)
@@ -2785,19 +3145,15 @@ display_debug_lines_decoded (struct dwarf_section *section,
  }
  
  static int
  }
  
  static int
-display_debug_lines (struct dwarf_section *section, void *file)
+display_debug_lines (struct dwarf_section *section, void *file ATTRIBUTE_UNUSED)
  {
    unsigned char *data = section->start;
    unsigned char *end = data + section->size;
    int retValRaw = 1;
    int retValDecoded = 1;
  
  {
    unsigned char *data = section->start;
    unsigned char *end = data + section->size;
    int retValRaw = 1;
    int retValDecoded = 1;
  
-  if (load_debug_info (file) == 0)
-    {
-      warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
-            section->name);
-      return 0;
-    }
+  if (do_debug_lines == 0)
+    do_debug_lines |= FLAG_DEBUG_LINES_RAW;
  
    if (do_debug_lines & FLAG_DEBUG_LINES_RAW)
      retValRaw = display_debug_lines_raw (section, data, end);
  
    if (do_debug_lines & FLAG_DEBUG_LINES_RAW)
      retValRaw = display_debug_lines_raw (section, data, end);
@@ -2830,7 +3186,7 @@ static int
  display_debug_pubnames (struct dwarf_section *section,
                         void *file ATTRIBUTE_UNUSED)
  {
  display_debug_pubnames (struct dwarf_section *section,
                         void *file ATTRIBUTE_UNUSED)
  {
-  DWARF2_Internal_PubNames pubnames;
+  DWARF2_Internal_PubNames names;
    unsigned char *start = section->start;
    unsigned char *end = start + section->size;
  
    unsigned char *start = section->start;
    unsigned char *end = start + section->size;
  
@@ -2848,11 +3204,11 @@ display_debug_pubnames (struct dwarf_section *section,
  
        data = start;
  
  
        data = start;
  
-      pubnames.pn_length = byte_get (data, 4);
+      names.pn_length = byte_get (data, 4);
        data += 4;
        data += 4;
-      if (pubnames.pn_length == 0xffffffff)
+      if (names.pn_length == 0xffffffff)
         {
         {
-         pubnames.pn_length = byte_get (data, 8);
+         names.pn_length = byte_get (data, 8);
           data += 8;
           offset_size = 8;
           initial_length_size = 12;
           data += 8;
           offset_size = 8;
           initial_length_size = 12;
@@ -2863,24 +3219,24 @@ display_debug_pubnames (struct dwarf_section *section,
           initial_length_size = 4;
         }
  
           initial_length_size = 4;
         }
  
-      pubnames.pn_version = byte_get (data, 2);
+      names.pn_version = byte_get (data, 2);
        data += 2;
  
        data += 2;
  
-      pubnames.pn_offset = byte_get (data, offset_size);
+      names.pn_offset = byte_get (data, offset_size);
        data += offset_size;
  
        if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE
           && num_debug_info_entries > 0
        data += offset_size;
  
        if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE
           && num_debug_info_entries > 0
-         && find_debug_info_for_offset (pubnames.pn_offset) == NULL)
+         && find_debug_info_for_offset (names.pn_offset) == NULL)
         warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
         warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
-             pubnames.pn_offset, section->name);
+             (unsigned long) names.pn_offset, section->name);
  
  
-      pubnames.pn_size = byte_get (data, offset_size);
+      names.pn_size = byte_get (data, offset_size);
        data += offset_size;
  
        data += offset_size;
  
-      start += pubnames.pn_length + initial_length_size;
+      start += names.pn_length + initial_length_size;
  
  
-      if (pubnames.pn_version != 2 && pubnames.pn_version != 3)
+      if (names.pn_version != 2 && names.pn_version != 3)
         {
           static int warned = 0;
  
         {
           static int warned = 0;
  
@@ -2894,13 +3250,13 @@ display_debug_pubnames (struct dwarf_section *section,
         }
  
        printf (_("  Length:                              %ld\n"),
         }
  
        printf (_("  Length:                              %ld\n"),
-             pubnames.pn_length);
+             (long) names.pn_length);
        printf (_("  Version:                             %d\n"),
        printf (_("  Version:                             %d\n"),
-             pubnames.pn_version);
+             names.pn_version);
        printf (_("  Offset into .debug_info section:     0x%lx\n"),
        printf (_("  Offset into .debug_info section:     0x%lx\n"),
-             pubnames.pn_offset);
+             (unsigned long) names.pn_offset);
        printf (_("  Size of area in .debug_info section: %ld\n"),
        printf (_("  Size of area in .debug_info section: %ld\n"),
-             pubnames.pn_size);
+             (long) names.pn_size);
  
        printf (_("\n    Offset\tName\n"));
  
  
        printf (_("\n    Offset\tName\n"));
  
@@ -2939,7 +3295,7 @@ display_debug_macinfo (struct dwarf_section *section,
        unsigned int lineno;
        const char *string;
  
        unsigned int lineno;
        const char *string;
  
-      op = *curr;
+      op = (enum dwarf_macinfo_record_type) *curr;
        curr++;
  
        switch (op)
        curr++;
  
        switch (op)
@@ -2998,6 +3354,321 @@ display_debug_macinfo (struct dwarf_section *section,
    return 1;
  }
  
    return 1;
  }
  
+/* Given LINE_OFFSET into the .debug_line section, attempt to return
+   filename and dirname corresponding to file name table entry with index
+   FILEIDX.  Return NULL on failure.  */
+
+static unsigned char *
+get_line_filename_and_dirname (dwarf_vma line_offset, dwarf_vma fileidx,
+                              unsigned char **dir_name)
+{
+  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;
+  dwarf_vma length, diridx;
+
+  *dir_name = NULL;
+  if (section->start == NULL
+      || line_offset >= section->size
+      || fileidx == 0)
+    return NULL;
+
+  hdrptr = section->start + line_offset;
+  length = byte_get (hdrptr, 4);
+  hdrptr += 4;
+  if (length == 0xffffffff)
+    {
+      /* This section is 64-bit DWARF 3.  */
+      length = byte_get (hdrptr, 8);
+      hdrptr += 8;
+      offset_size = 8;
+      initial_length_size = 12;
+    }
+  else
+    {
+      offset_size = 4;
+      initial_length_size = 4;
+    }
+  if (length + initial_length_size > section->size)
+    return NULL;
+  version = byte_get (hdrptr, 2);
+  hdrptr += 2;
+  if (version != 2 && version != 3 && version != 4)
+    return NULL;
+  hdrptr += offset_size + 1;/* Skip prologue_length and min_insn_length.  */
+  if (version >= 4)
+    hdrptr++;              /* Skip max_ops_per_insn.  */
+  hdrptr += 3;             /* Skip default_is_stmt, line_base, line_range.  */
+  opcode_base = byte_get (hdrptr, 1);
+  if (opcode_base == 0)
+    return NULL;
+  hdrptr++;
+  hdrptr += opcode_base - 1;
+  dirtable = hdrptr;
+  /* Skip over dirname table.  */
+  while (*hdrptr != '\0')
+    hdrptr += strlen ((char *) hdrptr) + 1;
+  hdrptr++;                /* Skip the NUL at the end of the table.  */
+  /* Now skip over preceding filename table entries.  */
+  for (; *hdrptr != '\0' && fileidx > 1; fileidx--)
+    {
+      hdrptr += strlen ((char *) hdrptr) + 1;
+      read_leb128 (hdrptr, &bytes_read, 0);
+      hdrptr += bytes_read;
+      read_leb128 (hdrptr, &bytes_read, 0);
+      hdrptr += bytes_read;
+      read_leb128 (hdrptr, &bytes_read, 0);
+      hdrptr += bytes_read;
+    }
+  if (*hdrptr == '\0')
+    return NULL;
+  file_name = hdrptr;
+  hdrptr += strlen ((char *) hdrptr) + 1;
+  diridx = read_leb128 (hdrptr, &bytes_read, 0);
+  if (diridx == 0)
+    return file_name;
+  for (; *dirtable != '\0' && diridx > 1; diridx--)
+    dirtable += strlen ((char *) dirtable) + 1;
+  if (*dirtable == '\0')
+    return NULL;
+  *dir_name = dirtable;
+  return file_name;
+}
+
+static int
+display_debug_macro (struct dwarf_section *section,
+                    void *file)
+{
+  unsigned char *start = section->start;
+  unsigned char *end = start + section->size;
+  unsigned char *curr = start;
+  unsigned char *extended_op_buf[256];
+  unsigned int bytes_read;
+
+  load_debug_section (str, file);
+  load_debug_section (line, file);
+
+  printf (_("Contents of the %s section:\n\n"), section->name);
+
+  while (curr < end)
+    {
+      unsigned int lineno, version, flags;
+      unsigned int offset_size = 4;
+      const char *string;
+      dwarf_vma line_offset = 0, sec_offset = curr - start, offset;
+      unsigned char **extended_ops = NULL;
+
+      version = byte_get (curr, 2);
+      curr += 2;
+
+      if (version != 4)
+       {
+         error (_("Only GNU extension to DWARF 4 of %s is currently supported.\n"),
+                section->name);
+         return 0;
+       }
+
+      flags = byte_get (curr++, 1);
+      if (flags & 1)
+       offset_size = 8;
+      printf (_("  Offset:                      0x%lx\n"),
+             (unsigned long) sec_offset);
+      printf (_("  Version:                     %d\n"), version);
+      printf (_("  Offset size:                 %d\n"), offset_size);
+      if (flags & 2)
+       {
+         line_offset = byte_get (curr, offset_size);
+         curr += offset_size;
+         printf (_("  Offset into .debug_line:     0x%lx\n"),
+                 (unsigned long) line_offset);
+       }
+      if (flags & 4)
+       {
+         unsigned int i, count = byte_get (curr++, 1), op;
+         dwarf_vma nargs, n;
+         memset (extended_op_buf, 0, sizeof (extended_op_buf));
+         extended_ops = extended_op_buf;
+         if (count)
+           {
+             printf (_("  Extension opcode arguments:\n"));
+             for (i = 0; i < count; i++)
+               {
+                 op = byte_get (curr++, 1);
+                 extended_ops[op] = curr;
+                 nargs = read_leb128 (curr, &bytes_read, 0);
+                 curr += bytes_read;
+                 if (nargs == 0)
+                   printf (_("    DW_MACRO_GNU_%02x has no arguments\n"), op);
+                 else
+                   {
+                     printf (_("    DW_MACRO_GNU_%02x arguments: "), op);
+                     for (n = 0; n < nargs; n++)
+                       {
+                         unsigned int form = byte_get (curr++, 1);
+                         printf ("%s%s", get_FORM_name (form),
+                                 n == nargs - 1 ? "\n" : ", ");
+                         switch (form)
+                           {
+                           case DW_FORM_data1:
+                           case DW_FORM_data2:
+                           case DW_FORM_data4:
+                           case DW_FORM_data8:
+                           case DW_FORM_sdata:
+                           case DW_FORM_udata:
+                           case DW_FORM_block:
+                           case DW_FORM_block1:
+                           case DW_FORM_block2:
+                           case DW_FORM_block4:
+                           case DW_FORM_flag:
+                           case DW_FORM_string:
+                           case DW_FORM_strp:
+                           case DW_FORM_sec_offset:
+                             break;
+                           default:
+                             error (_("Invalid extension opcode form %s\n"),
+                                    get_FORM_name (form));
+                             return 0;
+                           }
+                       }
+                   }
+               }
+           }
+       }
+      printf ("\n");
+
+      while (1)
+       {
+         unsigned int op;
+
+         if (curr >= end)
+           {
+             error (_(".debug_macro section not zero terminated\n"));
+             return 0;
+           }
+
+         op = byte_get (curr++, 1);
+         if (op == 0)
+           break;
+
+         switch (op)
+           {
+           case DW_MACRO_GNU_start_file:
+             {
+               unsigned int filenum;
+               unsigned char *file_name = NULL, *dir_name = NULL;
+
+               lineno = read_leb128 (curr, &bytes_read, 0);
+               curr += bytes_read;
+               filenum = read_leb128 (curr, &bytes_read, 0);
+               curr += bytes_read;
+
+               if ((flags & 2) == 0)
+                 error (_("DW_MACRO_GNU_start_file used, but no .debug_line offset provided.\n"));
+               else
+                 file_name
+                   = get_line_filename_and_dirname (line_offset, filenum,
+                                                    &dir_name);
+               if (file_name == NULL)
+                 printf (_(" DW_MACRO_GNU_start_file - lineno: %d filenum: %d\n"),
+                         lineno, filenum);
+               else
+                 printf (_(" DW_MACRO_GNU_start_file - lineno: %d filenum: %d filename: %s%s%s\n"),
+                         lineno, filenum,
+                         dir_name != NULL ? (const char *) dir_name : "",
+                         dir_name != NULL ? "/" : "", file_name);
+             }
+             break;
+
+           case DW_MACRO_GNU_end_file:
+             printf (_(" DW_MACRO_GNU_end_file\n"));
+             break;
+
+           case DW_MACRO_GNU_define:
+             lineno = read_leb128 (curr, &bytes_read, 0);
+             curr += bytes_read;
+             string = (char *) curr;
+             curr += strlen (string) + 1;
+             printf (_(" DW_MACRO_GNU_define - lineno : %d macro : %s\n"),
+                     lineno, string);
+             break;
+
+           case DW_MACRO_GNU_undef:
+             lineno = read_leb128 (curr, &bytes_read, 0);
+             curr += bytes_read;
+             string = (char *) curr;
+             curr += strlen (string) + 1;
+             printf (_(" DW_MACRO_GNU_undef - lineno : %d macro : %s\n"),
+                     lineno, string);
+             break;
+
+           case DW_MACRO_GNU_define_indirect:
+             lineno = read_leb128 (curr, &bytes_read, 0);
+             curr += bytes_read;
+             offset = byte_get (curr, offset_size);
+             curr += offset_size;
+             string = fetch_indirect_string (offset);
+             printf (_(" DW_MACRO_GNU_define_indirect - lineno : %d macro : %s\n"),
+                     lineno, string);
+             break;
+
+           case DW_MACRO_GNU_undef_indirect:
+             lineno = read_leb128 (curr, &bytes_read, 0);
+             curr += bytes_read;
+             offset = byte_get (curr, offset_size);
+             curr += offset_size;
+             string = fetch_indirect_string (offset);
+             printf (_(" DW_MACRO_GNU_undef_indirect - lineno : %d macro : %s\n"),
+                     lineno, string);
+             break;
+
+           case DW_MACRO_GNU_transparent_include:
+             offset = byte_get (curr, offset_size);
+             curr += offset_size;
+             printf (_(" DW_MACRO_GNU_transparent_include - offset : 0x%lx\n"),
+                     (unsigned long) offset);
+             break;
+
+           default:
+             if (extended_ops == NULL || extended_ops[op] == NULL)
+               {
+                 error (_(" Unknown macro opcode %02x seen\n"), op);
+                 return 0;
+               }
+             else
+               {
+                 /* Skip over unhandled opcodes.  */
+                 dwarf_vma nargs, n;
+                 unsigned char *desc = extended_ops[op];
+                 nargs = read_leb128 (desc, &bytes_read, 0);
+                 desc += bytes_read;
+                 if (nargs == 0)
+                   {
+                     printf (_(" DW_MACRO_GNU_%02x\n"), op);
+                     break;
+                   }
+                 printf (_(" DW_MACRO_GNU_%02x -"), op);
+                 for (n = 0; n < nargs; n++)
+                   {
+                     curr
+                       = read_and_display_attr_value (0, byte_get (desc++, 1),
+                                                      curr, 0, 0, offset_size,
+                                                      version, NULL, 0, NULL);
+                     if (n != nargs - 1)
+                       printf (",");
+                   }
+                 printf ("\n");
+               }
+             break;
+           }
+       }
+
+      printf ("\n");
+    }  
+
+  return 1;
+}
+
  static int
  display_debug_abbrev (struct dwarf_section *section,
                       void *file ATTRIBUTE_UNUSED)
  static int
  display_debug_abbrev (struct dwarf_section *section,
                       void *file ATTRIBUTE_UNUSED)
@@ -3023,13 +3694,13 @@ display_debug_abbrev (struct dwarf_section *section,
         {
           abbrev_attr *attr;
  
         {
           abbrev_attr *attr;
  
-         printf (_("   %ld      %s    [%s]\n"),
+         printf ("   %ld      %s    [%s]\n",
                   entry->entry,
                   get_TAG_name (entry->tag),
                   entry->children ? _("has children") : _("no children"));
  
           for (attr = entry->first_attr; attr; attr = attr->next)
                   entry->entry,
                   get_TAG_name (entry->tag),
                   entry->children ? _("has children") : _("no children"));
  
           for (attr = entry->first_attr; attr; attr = attr->next)
-           printf (_("    %-18s %s\n"),
+           printf ("    %-18s %s\n",
                     get_AT_name (attr->attribute),
                     get_FORM_name (attr->form));
         }
                     get_AT_name (attr->attribute),
                     get_FORM_name (attr->form));
         }
@@ -3041,11 +3712,231 @@ display_debug_abbrev (struct dwarf_section *section,
    return 1;
  }
  
    return 1;
  }
  
+/* Display a location list from a normal (ie, non-dwo) .debug_loc section.  */
+
+static void
+display_loc_list (struct dwarf_section *section,
+                  unsigned char **start_ptr,
+                  int debug_info_entry,
+                  unsigned long offset,
+                  unsigned long base_address,
+                  int has_frame_base)
+{
+  unsigned char *start = *start_ptr;
+  unsigned char *section_end = section->start + section->size;
+  unsigned long cu_offset = debug_information [debug_info_entry].cu_offset;
+  unsigned int pointer_size = debug_information [debug_info_entry].pointer_size;
+  unsigned int offset_size = debug_information [debug_info_entry].offset_size;
+  int dwarf_version = debug_information [debug_info_entry].dwarf_version;
+
+  dwarf_vma begin;
+  dwarf_vma end;
+  unsigned short length;
+  int need_frame_base;
+
+  while (1)
+    {
+      if (start + 2 * pointer_size > section_end)
+        {
+          warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
+                offset);
+          break;
+        }
+
+      /* Note: we use sign extension here in order to be sure that we can detect
+         the -1 escape value.  Sign extension into the top 32 bits of a 32-bit
+         address will not affect the values that we display since we always show
+         hex values, and always the bottom 32-bits.  */
+      begin = byte_get_signed (start, pointer_size);
+      start += pointer_size;
+      end = byte_get_signed (start, pointer_size);
+      start += pointer_size;
+
+      printf ("    %8.8lx ", offset);
+
+      if (begin == 0 && end == 0)
+        {
+          printf (_("<End of list>\n"));
+          break;
+        }
+
+      /* Check base address specifiers.  */
+      if (begin == (dwarf_vma) -1 && end != (dwarf_vma) -1)
+        {
+          base_address = end;
+          print_dwarf_vma (begin, pointer_size);
+          print_dwarf_vma (end, pointer_size);
+          printf (_("(base address)\n"));
+          continue;
+        }
+
+      if (start + 2 > section_end)
+        {
+          warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
+                offset);
+          break;
+        }
+
+      length = byte_get (start, 2);
+      start += 2;
+
+      if (start + length > section_end)
+        {
+          warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
+                offset);
+          break;
+        }
+
+      print_dwarf_vma (begin + base_address, pointer_size);
+      print_dwarf_vma (end + base_address, pointer_size);
+
+      putchar ('(');
+      need_frame_base = decode_location_expression (start,
+                                                    pointer_size,
+                                                    offset_size,
+                                                    dwarf_version,
+                                                    length,
+                                                    cu_offset, section);
+      putchar (')');
+
+      if (need_frame_base && !has_frame_base)
+        printf (_(" [without DW_AT_frame_base]"));
+
+      if (begin == end)
+        fputs (_(" (start == end)"), stdout);
+      else if (begin > end)
+        fputs (_(" (start > end)"), stdout);
+
+      putchar ('\n');
+
+      start += length;
+    }
+
+  *start_ptr = start;
+}
+
+/* Display a location list from a .dwo section. It uses address indexes rather
+   than embedded addresses.  This code closely follows display_loc_list, but the
+   two are sufficiently different that combining things is very ugly.  */
+
+static void
+display_loc_list_dwo (struct dwarf_section *section,
+                      unsigned char **start_ptr,
+                      int debug_info_entry,
+                      unsigned long offset,
+                      int has_frame_base)
+{
+  unsigned char *start = *start_ptr;
+  unsigned char *section_end = section->start + section->size;
+  unsigned long cu_offset = debug_information [debug_info_entry].cu_offset;
+  unsigned int pointer_size = debug_information [debug_info_entry].pointer_size;
+  unsigned int offset_size = debug_information [debug_info_entry].offset_size;
+  int dwarf_version = debug_information [debug_info_entry].dwarf_version;
+  int entry_type;
+  unsigned short length;
+  int need_frame_base;
+  dwarf_vma idx;
+  unsigned int bytes_read;
+
+  while (1)
+    {
+      printf ("    %8.8lx ", offset);
+
+      if (start + 2 > section_end)
+        {
+          warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
+                offset);
+          break;
+        }
+
+      entry_type = byte_get (start, 1);
+      start++;
+      switch (entry_type)
+        {
+          case 0: /* A terminating entry.  */
+            idx = byte_get (start, 1);
+            start++;
+            *start_ptr = start;
+            if (idx == 0)
+              printf (_("<End of list>\n"));
+            else
+              warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
+                    offset);
+            return;
+          case 1: /* A base-address entry.  */
+            idx = read_leb128 (start, &bytes_read, 0);
+            start += bytes_read;
+            print_dwarf_vma (idx, pointer_size);
+            printf (_("(base address index)\n"));
+            continue;
+          case 2: /* A normal entry.  */
+            idx = read_leb128 (start, &bytes_read, 0);
+            start += bytes_read;
+            print_dwarf_vma (idx, pointer_size);
+            idx = read_leb128 (start, &bytes_read, 0);
+            start += bytes_read;
+            print_dwarf_vma (idx, pointer_size);
+            break;
+          default:
+            warn (_("Unknown location-list type 0x%x.\n"), entry_type);
+            *start_ptr = start;
+            return;
+        }
+
+      if (start + 2 > section_end)
+        {
+          warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
+                offset);
+          break;
+        }
+
+      length = byte_get (start, 2);
+      start += 2;
+
+      if (start + length > section_end)
+        {
+          warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
+                offset);
+          break;
+        }
+
+      putchar ('(');
+      need_frame_base = decode_location_expression (start,
+                                                    pointer_size,
+                                                    offset_size,
+                                                    dwarf_version,
+                                                    length,
+                                                    cu_offset, section);
+      putchar (')');
+
+      if (need_frame_base && !has_frame_base)
+        printf (_(" [without DW_AT_frame_base]"));
+
+      putchar ('\n');
+
+      start += length;
+    }
+
+  *start_ptr = start;
+}
+
+/* Sort array of indexes in ascending order of loc_offsets[idx].  */
+
+static dwarf_vma *loc_offsets;
+
+static int
+loc_offsets_compar (const void *ap, const void *bp)
+{
+  dwarf_vma a = loc_offsets[*(const unsigned int *) ap];
+  dwarf_vma b = loc_offsets[*(const unsigned int *) bp];
+
+  return (a > b) - (b > a);
+}
+
  static int
  display_debug_loc (struct dwarf_section *section, void *file)
  {
    unsigned char *start = section->start;
  static int
  display_debug_loc (struct dwarf_section *section, void *file)
  {
    unsigned char *start = section->start;
-  unsigned char *section_end;
    unsigned long bytes;
    unsigned char *section_begin = start;
    unsigned int num_loc_list = 0;
    unsigned long bytes;
    unsigned char *section_begin = start;
    unsigned int num_loc_list = 0;
@@ -3053,12 +3944,18 @@ display_debug_loc (struct dwarf_section *section, void *file)
    unsigned int first = 0;
    unsigned int i;
    unsigned int j;
    unsigned int first = 0;
    unsigned int i;
    unsigned int j;
+  unsigned int k;
    int seen_first_offset = 0;
    int seen_first_offset = 0;
-  int use_debug_info = 1;
+  int locs_sorted = 1;
    unsigned char *next;
    unsigned char *next;
+  unsigned int *array = NULL;
+  const char *suffix = strrchr (section->name, '.');
+  int is_dwo = 0;
+
+  if (suffix && strcmp (suffix, ".dwo") == 0)
+    is_dwo = 1;
  
    bytes = section->size;
  
    bytes = section->size;
-  section_end = start + bytes;
  
    if (bytes == 0)
      {
  
    if (bytes == 0)
      {
@@ -3081,10 +3978,11 @@ display_debug_loc (struct dwarf_section *section, void *file)
        unsigned int num;
  
        num = debug_information [i].num_loc_offsets;
        unsigned int num;
  
        num = debug_information [i].num_loc_offsets;
-      num_loc_list += num;
+      if (num > num_loc_list)
+       num_loc_list = num;
  
        /* Check if we can use `debug_information' directly.  */
  
        /* Check if we can use `debug_information' directly.  */
-      if (use_debug_info && num != 0)
+      if (locs_sorted && num != 0)
         {
           if (!seen_first_offset)
             {
         {
           if (!seen_first_offset)
             {
@@ -3102,7 +4000,7 @@ display_debug_loc (struct dwarf_section *section, void *file)
               if (last_offset >
                   debug_information [i].loc_offsets [j])
                 {
               if (last_offset >
                   debug_information [i].loc_offsets [j])
                 {
-                 use_debug_info = 0;
+                 locs_sorted = 0;
                   break;
                 }
               last_offset = debug_information [i].loc_offsets [j];
                   break;
                 }
               last_offset = debug_information [i].loc_offsets [j];
@@ -3110,40 +4008,48 @@ display_debug_loc (struct dwarf_section *section, void *file)
         }
      }
  
         }
      }
  
-  if (!use_debug_info)
-    /* FIXME: Should we handle this case?  */
-    error (_("Location lists in .debug_info section aren't in ascending order!\n"));
-
    if (!seen_first_offset)
      error (_("No location lists in .debug_info section!\n"));
  
    /* DWARF sections under Mach-O have non-zero addresses.  */
    if (debug_information [first].num_loc_offsets > 0
        && debug_information [first].loc_offsets [0] != section->address)
    if (!seen_first_offset)
      error (_("No location lists in .debug_info section!\n"));
  
    /* DWARF sections under Mach-O have non-zero addresses.  */
    if (debug_information [first].num_loc_offsets > 0
        && debug_information [first].loc_offsets [0] != section->address)
-    warn (_("Location lists in %s section start at 0x%lx\n"),
-         section->name, debug_information [first].loc_offsets [0]);
+    warn (_("Location lists in %s section start at 0x%s\n"),
+         section->name,
+         dwarf_vmatoa ("x", debug_information [first].loc_offsets [0]));
  
  
+  if (!locs_sorted)
+    array = (unsigned int *) xcmalloc (num_loc_list, sizeof (unsigned int));
    printf (_("Contents of the %s section:\n\n"), section->name);
    printf (_("Contents of the %s section:\n\n"), section->name);
-  printf (_("    Offset   Begin    End      Expression\n"));
+  if (!is_dwo)
+    printf (_("    Offset   Begin    End      Expression\n"));
+  else
+    printf (_("    Offset   Begin idx End idx  Expression\n"));
  
    seen_first_offset = 0;
    for (i = first; i < num_debug_info_entries; i++)
      {
  
    seen_first_offset = 0;
    for (i = first; i < num_debug_info_entries; i++)
      {
-      dwarf_vma begin;
-      dwarf_vma end;
-      unsigned short length;
        unsigned long offset;
        unsigned long offset;
-      unsigned int pointer_size;
-      unsigned long cu_offset;
        unsigned long base_address;
        unsigned long base_address;
-      int need_frame_base;
        int has_frame_base;
  
        int has_frame_base;
  
-      pointer_size = debug_information [i].pointer_size;
-      cu_offset = debug_information [i].cu_offset;
+      if (!locs_sorted)
+       {
+         for (k = 0; k < debug_information [i].num_loc_offsets; k++)
+           array[k] = k;
+         loc_offsets = debug_information [i].loc_offsets;
+         qsort (array, debug_information [i].num_loc_offsets,
+                sizeof (*array), loc_offsets_compar);
+       }
  
  
-      for (j = 0; j < debug_information [i].num_loc_offsets; j++)
+      for (k = 0; k < debug_information [i].num_loc_offsets; k++)
         {
         {
+         j = locs_sorted ? k : array[k];
+         if (k
+             && debug_information [i].loc_offsets [locs_sorted
+                                                   ? k - 1 : array [k - 1]]
+                == debug_information [i].loc_offsets [j])
+           continue;
           has_frame_base = debug_information [i].have_frame_base [j];
           /* DWARF sections under Mach-O have non-zero addresses.  */
           offset = debug_information [i].loc_offsets [j] - section->address;
           has_frame_base = debug_information [i].have_frame_base [j];
           /* DWARF sections under Mach-O have non-zero addresses.  */
           offset = debug_information [i].loc_offsets [j] - section->address;
@@ -3172,88 +4078,19 @@ display_debug_loc (struct dwarf_section *section, void *file)
               continue;
             }
  
               continue;
             }
  
-         while (1)
-           {
-             if (start + 2 * pointer_size > section_end)
-               {
-                 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
-                       offset);
-                 break;
-               }
-
-             /* Note: we use sign extension here in order to be sure that
-                we can detect the -1 escape value.  Sign extension into the
-                top 32 bits of a 32-bit address will not affect the values
-                that we display since we always show hex values, and always
-                the bottom 32-bits.  */
-             begin = byte_get_signed (start, pointer_size);
-             start += pointer_size;
-             end = byte_get_signed (start, pointer_size);
-             start += pointer_size;
-
-             printf ("    %8.8lx ", offset);
-
-             if (begin == 0 && end == 0)
-               {
-                 printf (_("<End of list>\n"));
-                 break;
-               }
-
-             /* Check base address specifiers.  */
-             if (begin == (dwarf_vma) -1 && end != (dwarf_vma) -1)
-               {
-                 base_address = end;
-                 print_dwarf_vma (begin, pointer_size);
-                 print_dwarf_vma (end, pointer_size);
-                 printf (_("(base address)\n"));
-                 continue;
-               }
-
-             if (start + 2 > section_end)
-               {
-                 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
-                       offset);
-                 break;
-               }
-
-             length = byte_get (start, 2);
-             start += 2;
-
-             if (start + length > section_end)
-               {
-                 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
-                       offset);
-                 break;
-               }
-
-             print_dwarf_vma (begin + base_address, pointer_size);
-             print_dwarf_vma (end + base_address, pointer_size);
-
-             putchar ('(');
-             need_frame_base = decode_location_expression (start,
-                                                           pointer_size,
-                                                           length,
-                                                           cu_offset, section);
-             putchar (')');
-
-             if (need_frame_base && !has_frame_base)
-               printf (_(" [without DW_AT_frame_base]"));
-
-             if (begin == end)
-               fputs (_(" (start == end)"), stdout);
-             else if (begin > end)
-               fputs (_(" (start > end)"), stdout);
-
-             putchar ('\n');
-
-             start += length;
-           }
+          if (is_dwo)
+            display_loc_list_dwo (section, &start, i, offset, has_frame_base);
+          else
+            display_loc_list (section, &start, i, offset, base_address,
+                              has_frame_base);
         }
      }
  
         }
      }
  
-  if (start < section_end)
+  if (start < section->start + section->size)
      warn (_("There are %ld unused bytes at the end of section %s\n"),
      warn (_("There are %ld unused bytes at the end of section %s\n"),
-         (long) (section_end - start), section->name);
+         (long) (section->start + section->size - start), section->name);
+  putchar ('\n');
+  free (array);
    return 1;
  }
  
    return 1;
  }
  
@@ -3318,9 +4155,20 @@ display_debug_str (struct dwarf_section *section,
  static int
  display_debug_info (struct dwarf_section *section, void *file)
  {
  static int
  display_debug_info (struct dwarf_section *section, void *file)
  {
-  return process_debug_info (section, file, 0);
+  return process_debug_info (section, file, section->abbrev_sec, 0, 0);
  }
  
  }
  
+static int
+display_debug_types (struct dwarf_section *section, void *file)
+{
+  return process_debug_info (section, file, section->abbrev_sec, 0, 1);
+}
+
+static int
+display_trace_info (struct dwarf_section *section, void *file)
+{
+  return process_debug_info (section, file, section->abbrev_sec, 0, 0);
+}
  
  static int
  display_debug_aranges (struct dwarf_section *section,
  
  static int
  display_debug_aranges (struct dwarf_section *section,
@@ -3339,7 +4187,7 @@ display_debug_aranges (struct dwarf_section *section,
      {
        unsigned char *hdrptr;
        DWARF2_Internal_ARange arange;
      {
        unsigned char *hdrptr;
        DWARF2_Internal_ARange arange;
-      unsigned char *ranges;
+      unsigned char *addr_ranges;
        dwarf_vma length;
        dwarf_vma address;
        unsigned char address_size;
        dwarf_vma length;
        dwarf_vma address;
        unsigned char address_size;
@@ -3375,7 +4223,7 @@ display_debug_aranges (struct dwarf_section *section,
           && num_debug_info_entries > 0
           && find_debug_info_for_offset (arange.ar_info_offset) == NULL)
         warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
           && num_debug_info_entries > 0
           && find_debug_info_for_offset (arange.ar_info_offset) == NULL)
         warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
-             arange.ar_info_offset, section->name);
+             (unsigned long) arange.ar_info_offset, section->name);
  
        arange.ar_pointer_size = byte_get (hdrptr, 1);
        hdrptr += 1;
  
        arange.ar_pointer_size = byte_get (hdrptr, 1);
        hdrptr += 1;
@@ -3389,14 +4237,23 @@ display_debug_aranges (struct dwarf_section *section,
           break;
         }
  
           break;
         }
  
-      printf (_("  Length:                   %ld\n"), arange.ar_length);
+      printf (_("  Length:                   %ld\n"),
+             (long) arange.ar_length);
        printf (_("  Version:                  %d\n"), arange.ar_version);
        printf (_("  Version:                  %d\n"), arange.ar_version);
-      printf (_("  Offset into .debug_info:  0x%lx\n"), arange.ar_info_offset);
+      printf (_("  Offset into .debug_info:  0x%lx\n"),
+             (unsigned long) arange.ar_info_offset);
        printf (_("  Pointer Size:             %d\n"), arange.ar_pointer_size);
        printf (_("  Segment Size:             %d\n"), arange.ar_segment_size);
  
        address_size = arange.ar_pointer_size + arange.ar_segment_size;
  
        printf (_("  Pointer Size:             %d\n"), arange.ar_pointer_size);
        printf (_("  Segment Size:             %d\n"), arange.ar_segment_size);
  
        address_size = arange.ar_pointer_size + arange.ar_segment_size;
  
+      if (address_size == 0)
+       {
+         error (_("Invalid address size in %s section!\n"),
+                section->name);
+         break;
+       }
+
        /* The DWARF spec does not require that the address size be a power
          of two, but we do.  This will have to change if we ever encounter
          an uneven architecture.  */
        /* The DWARF spec does not require that the address size be a power
          of two, but we do.  This will have to change if we ever encounter
          an uneven architecture.  */
@@ -3411,24 +4268,24 @@ display_debug_aranges (struct dwarf_section *section,
        else
         printf (_("\n    Address    Length\n"));
  
        else
         printf (_("\n    Address    Length\n"));
  
-      ranges = hdrptr;
+      addr_ranges = hdrptr;
  
        /* Must pad to an alignment boundary that is twice the address size.  */
        excess = (hdrptr - start) % (2 * address_size);
        if (excess)
  
        /* Must pad to an alignment boundary that is twice the address size.  */
        excess = (hdrptr - start) % (2 * address_size);
        if (excess)
-       ranges += (2 * address_size) - excess;
+       addr_ranges += (2 * address_size) - excess;
  
        start += arange.ar_length + initial_length_size;
  
  
        start += arange.ar_length + initial_length_size;
  
-      while (ranges + 2 * address_size <= start)
+      while (addr_ranges + 2 * address_size <= start)
         {
         {
-         address = byte_get (ranges, address_size);
+         address = byte_get (addr_ranges, address_size);
  
  
-         ranges += address_size;
+         addr_ranges += address_size;
  
  
-         length  = byte_get (ranges, address_size);
+         length  = byte_get (addr_ranges, address_size);
  
  
-         ranges += address_size;
+         addr_ranges += address_size;
  
           printf ("    ");
           print_dwarf_vma (address, address_size);
  
           printf ("    ");
           print_dwarf_vma (address, address_size);
@@ -3442,25 +4299,132 @@ display_debug_aranges (struct dwarf_section *section,
    return 1;
  }
  
    return 1;
  }
  
+/* Comparison function for qsort.  */
+static int
+comp_addr_base (const void * v0, const void * v1)
+{
+  debug_info * info0 = (debug_info *) v0;
+  debug_info * info1 = (debug_info *) v1;
+  return info0->addr_base - info1->addr_base;
+}
+
+/* Display the debug_addr section.  */
+static int
+display_debug_addr (struct dwarf_section *section,
+                    void *file)
+{
+  debug_info **debug_addr_info;
+  unsigned char *entry;
+  unsigned char *end;
+  unsigned int i;
+  unsigned int count;
+
+  if (section->size == 0)
+    {
+      printf (_("\nThe %s section is empty.\n"), section->name);
+      return 0;
+    }
+
+  if (load_debug_info (file) == 0)
+    {
+      warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
+           section->name);
+      return 0;
+    }
+
+  printf (_("Contents of the %s section:\n\n"), section->name);
+
+  debug_addr_info = (debug_info **) xmalloc (num_debug_info_entries + 1
+                                             * sizeof (debug_info *));
+
+  count = 0;
+  for (i = 0; i < num_debug_info_entries; i++)
+    {
+      if (debug_information [i].addr_base != DEBUG_INFO_UNAVAILABLE)
+        debug_addr_info [count++] = &debug_information [i];
+    }
+
+  /* Add a sentinel to make iteration convenient.  */
+  debug_addr_info [count] = (debug_info *) xmalloc (sizeof (debug_info));
+  debug_addr_info [count]->addr_base = section->size;
+
+  qsort (debug_addr_info, count, sizeof (debug_info *), comp_addr_base);
+  for (i = 0; i < count; i++)
+    {
+      unsigned int idx;
+
+      printf (_("  For compilation unit at offset 0x%s:\n"),
+              dwarf_vmatoa ("x", debug_addr_info [i]->cu_offset));
+
+      printf (_("\tIndex\tOffset\n"));
+      entry = section->start + debug_addr_info [i]->addr_base;
+      end = section->start + debug_addr_info [i + 1]->addr_base;
+      idx = 0;
+      while (entry < end)
+        {
+          dwarf_vma base = byte_get (entry, debug_addr_info [i]->pointer_size);
+          printf (_("\t%d:\t%s\n"), idx, dwarf_vmatoa ("x", base));
+          entry += debug_addr_info [i]->pointer_size;
+          idx++;
+        }
+    }
+  printf ("\n");
+
+  free (debug_addr_info);
+  return 1;
+}
+
+/* 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)
+{
+  if (section->size == 0)
+    {
+      printf (_("\nThe %s section is empty.\n"), section->name);
+      return 0;
+    }
+  /* TODO: Dump the contents.  This is made somewhat difficult by not knowing
+     what the offset size is for this section.  */
+  return 1;
+}
+
+/* Each debug_information[x].range_lists[y] gets this representation for
+   sorting purposes.  */
+
+struct range_entry
+{
+  /* The debug_information[x].range_lists[y] value.  */
+  unsigned long ranges_offset;
+
+  /* Original debug_information to find parameters of the data.  */
+  debug_info *debug_info_p;
+};
+
+/* Sort struct range_entry in ascending order of its RANGES_OFFSET.  */
+
+static int
+range_entry_compar (const void *ap, const void *bp)
+{
+  const struct range_entry *a_re = (const struct range_entry *) ap;
+  const struct range_entry *b_re = (const struct range_entry *) bp;
+  const unsigned long a = a_re->ranges_offset;
+  const unsigned long b = b_re->ranges_offset;
+
+  return (a > b) - (b > a);
+}
+
  static int
  display_debug_ranges (struct dwarf_section *section,
                       void *file ATTRIBUTE_UNUSED)
  {
    unsigned char *start = section->start;
  static int
  display_debug_ranges (struct dwarf_section *section,
                       void *file ATTRIBUTE_UNUSED)
  {
    unsigned char *start = section->start;
-  unsigned char *section_end;
    unsigned long bytes;
    unsigned char *section_begin = start;
    unsigned long bytes;
    unsigned char *section_begin = start;
-  unsigned int num_range_list = 0;
-  unsigned long last_offset = 0;
-  unsigned int first = 0;
-  unsigned int i;
-  unsigned int j;
-  int seen_first_offset = 0;
-  int use_debug_info = 1;
-  unsigned char *next;
+  unsigned int num_range_list, i;
+  struct range_entry *range_entries, *range_entry_fill;
  
    bytes = section->size;
  
    bytes = section->size;
-  section_end = start + bytes;
  
    if (bytes == 0)
      {
  
    if (bytes == 0)
      {
@@ -3475,135 +4439,123 @@ display_debug_ranges (struct dwarf_section *section,
        return 0;
      }
  
        return 0;
      }
  
-  /* Check the order of range list in .debug_info section. If
-     offsets of range lists are in the ascending order, we can
-     use `debug_information' directly.  */
+  num_range_list = 0;
    for (i = 0; i < num_debug_info_entries; i++)
    for (i = 0; i < num_debug_info_entries; i++)
+    num_range_list += debug_information [i].num_range_lists;
+
+  if (num_range_list == 0)
      {
      {
-      unsigned int num;
+      /* This can happen when the file was compiled with -gsplit-debug
+         which removes references to range lists from the primary .o file.  */
+      printf (_("No range lists in .debug_info section.\n"));
+      return 1;
+    }
  
  
-      num = debug_information [i].num_range_lists;
-      num_range_list += num;
+  range_entries = (struct range_entry *)
+      xmalloc (sizeof (*range_entries) * num_range_list);
+  range_entry_fill = range_entries;
  
  
-      /* Check if we can use `debug_information' directly.  */
-      if (use_debug_info && num != 0)
-       {
-         if (!seen_first_offset)
-           {
-             /* This is the first range list.  */
-             last_offset = debug_information [i].range_lists [0];
-             first = i;
-             seen_first_offset = 1;
-             j = 1;
-           }
-         else
-           j = 0;
+  for (i = 0; i < num_debug_info_entries; i++)
+    {
+      debug_info *debug_info_p = &debug_information[i];
+      unsigned int j;
  
  
-         for (; j < num; j++)
-           {
-             if (last_offset >
-                 debug_information [i].range_lists [j])
-               {
-                 use_debug_info = 0;
-                 break;
-               }
-             last_offset = debug_information [i].range_lists [j];
-           }
+      for (j = 0; j < debug_info_p->num_range_lists; j++)
+       {
+         range_entry_fill->ranges_offset = debug_info_p->range_lists[j];
+         range_entry_fill->debug_info_p = debug_info_p;
+         range_entry_fill++;
         }
      }
  
         }
      }
  
-  if (!use_debug_info)
-    /* FIXME: Should we handle this case?  */
-    error (_("Range lists in .debug_info section aren't in ascending order!\n"));
-
-  if (!seen_first_offset)
-    error (_("No range lists in .debug_info section!\n"));
+  qsort (range_entries, num_range_list, sizeof (*range_entries),
+        range_entry_compar);
  
    /* DWARF sections under Mach-O have non-zero addresses.  */
  
    /* DWARF sections under Mach-O have non-zero addresses.  */
-  if (debug_information [first].num_range_lists > 0
-      && debug_information [first].range_lists [0] != section->address)
+  if (dwarf_check != 0 && range_entries[0].ranges_offset != section->address)
      warn (_("Range lists in %s section start at 0x%lx\n"),
      warn (_("Range lists in %s section start at 0x%lx\n"),
-         section->name, debug_information [first].range_lists [0]);
+         section->name, range_entries[0].ranges_offset);
  
    printf (_("Contents of the %s section:\n\n"), section->name);
    printf (_("    Offset   Begin    End\n"));
  
  
    printf (_("Contents of the %s section:\n\n"), section->name);
    printf (_("    Offset   Begin    End\n"));
  
-  seen_first_offset = 0;
-  for (i = first; i < num_debug_info_entries; i++)
+  for (i = 0; i < num_range_list; i++)
      {
      {
-      dwarf_vma begin;
-      dwarf_vma end;
-      unsigned long offset;
+      struct range_entry *range_entry = &range_entries[i];
+      debug_info *debug_info_p = range_entry->debug_info_p;
        unsigned int pointer_size;
        unsigned int pointer_size;
+      unsigned long offset;
+      unsigned char *next;
        unsigned long base_address;
  
        unsigned long base_address;
  
-      pointer_size = debug_information [i].pointer_size;
+      pointer_size = debug_info_p->pointer_size;
  
  
-      for (j = 0; j < debug_information [i].num_range_lists; j++)
+      /* DWARF sections under Mach-O have non-zero addresses.  */
+      offset = range_entry->ranges_offset - section->address;
+      next = section_begin + offset;
+      base_address = debug_info_p->base_address;
+
+      if (dwarf_check != 0 && i > 0)
         {
         {
-         /* DWARF sections under Mach-O have non-zero addresses.  */
-         offset = debug_information [i].range_lists [j] - section->address;
-         next = section_begin + offset;
-         base_address = debug_information [i].base_address;
+         if (start < next)
+           warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
+                 (unsigned long) (start - section_begin),
+                 (unsigned long) (next - section_begin), section->name);
+         else if (start > next)
+           warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
+                 (unsigned long) (start - section_begin),
+                 (unsigned long) (next - section_begin), section->name);
+       }
+      start = next;
  
  
-         if (!seen_first_offset)
-           seen_first_offset = 1;
-         else
+      while (1)
+       {
+         dwarf_vma begin;
+         dwarf_vma end;
+
+         /* Note: we use sign extension here in order to be sure that
+            we can detect the -1 escape value.  Sign extension into the
+            top 32 bits of a 32-bit address will not affect the values
+            that we display since we always show hex values, and always
+            the bottom 32-bits.  */
+         begin = byte_get_signed (start, pointer_size);
+         start += pointer_size;
+         end = byte_get_signed (start, pointer_size);
+         start += pointer_size;
+
+         printf ("    %8.8lx ", offset);
+
+         if (begin == 0 && end == 0)
             {
             {
-             if (start < next)
-               warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
-                     (unsigned long) (start - section_begin),
-                     (unsigned long) (next - section_begin), section->name);
-             else if (start > next)
-               warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
-                     (unsigned long) (start - section_begin),
-                     (unsigned long) (next - section_begin), section->name);
+             printf (_("<End of list>\n"));
+             break;
             }
             }
-         start = next;
  
  
-         while (1)
+         /* Check base address specifiers.  */
+         if (begin == (dwarf_vma) -1 && end != (dwarf_vma) -1)
             {
             {
-             /* Note: we use sign extension here in order to be sure that
-                we can detect the -1 escape value.  Sign extension into the
-                top 32 bits of a 32-bit address will not affect the values
-                that we display since we always show hex values, and always
-                the bottom 32-bits.  */
-             begin = byte_get_signed (start, pointer_size);
-             start += pointer_size;
-             end = byte_get_signed (start, pointer_size);
-             start += pointer_size;
-
-             printf ("    %8.8lx ", offset);
-
-             if (begin == 0 && end == 0)
-               {
-                 printf (_("<End of list>\n"));
-                 break;
-               }
-
-             /* Check base address specifiers.  */
-             if (begin == (dwarf_vma) -1 && end != (dwarf_vma) -1)
-               {
-                 base_address = end;
-                 print_dwarf_vma (begin, pointer_size);
-                 print_dwarf_vma (end, pointer_size);
-                 printf ("(base address)\n");
-                 continue;
-               }
+             base_address = end;
+             print_dwarf_vma (begin, pointer_size);
+             print_dwarf_vma (end, pointer_size);
+             printf ("(base address)\n");
+             continue;
+           }
  
  
-             print_dwarf_vma (begin + base_address, pointer_size);
-             print_dwarf_vma (end + base_address, pointer_size);
+         print_dwarf_vma (begin + base_address, pointer_size);
+         print_dwarf_vma (end + base_address, pointer_size);
  
  
-             if (begin == end)
-               fputs (_("(start == end)"), stdout);
-             else if (begin > end)
-               fputs (_("(start > end)"), stdout);
+         if (begin == end)
+           fputs (_("(start == end)"), stdout);
+         else if (begin > end)
+           fputs (_("(start > end)"), stdout);
  
  
-             putchar ('\n');
-           }
+         putchar ('\n');
         }
      }
    putchar ('\n');
         }
      }
    putchar ('\n');
+
+  free (range_entries);
+
    return 1;
  }
  
    return 1;
  }
  
@@ -3625,6 +4577,8 @@ typedef struct Frame_Chunk
    int ra;
    unsigned char fde_encoding;
    unsigned char cfa_exp;
    int ra;
    unsigned char fde_encoding;
    unsigned char cfa_exp;
+  unsigned char ptr_size;
+  unsigned char segment_size;
  }
  Frame_Chunk;
  
  }
  Frame_Chunk;
  
@@ -3651,8 +4605,9 @@ frame_need_space (Frame_Chunk *fc, unsigned int reg)
      return -1;
  
    fc->ncols = reg + 1;
      return -1;
  
    fc->ncols = reg + 1;
-  fc->col_type = xcrealloc (fc->col_type, fc->ncols, sizeof (short int));
-  fc->col_offset = xcrealloc (fc->col_offset, fc->ncols, sizeof (int));
+  fc->col_type = (short int *) xcrealloc (fc->col_type, fc->ncols,
+                                          sizeof (short int));
+  fc->col_offset = (int *) xcrealloc (fc->col_offset, fc->ncols, sizeof (int));
  
    while (prev < fc->ncols)
      {
  
    while (prev < fc->ncols)
      {
@@ -3680,6 +4635,13 @@ static const char *const dwarf_regnames_i386[] =
    "tr", "ldtr"
  };
  
    "tr", "ldtr"
  };
  
+void
+init_dwarf_regnames_i386 (void)
+{
+  dwarf_regnames = dwarf_regnames_i386;
+  dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_i386);
+}
+
  static const char *const dwarf_regnames_x86_64[] =
  {
    "rax", "rdx", "rcx", "rbx",
  static const char *const dwarf_regnames_x86_64[] =
  {
    "rax", "rdx", "rcx", "rbx",
@@ -3702,6 +4664,13 @@ static const char *const dwarf_regnames_x86_64[] =
    "mxcsr", "fcw", "fsw"
  };
  
    "mxcsr", "fcw", "fsw"
  };
  
+void
+init_dwarf_regnames_x86_64 (void)
+{
+  dwarf_regnames = dwarf_regnames_x86_64;
+  dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_x86_64);
+}
+
  void
  init_dwarf_regnames (unsigned int e_machine)
  {
  void
  init_dwarf_regnames (unsigned int e_machine)
  {
@@ -3709,13 +4678,13 @@ init_dwarf_regnames (unsigned int e_machine)
      {
      case EM_386:
      case EM_486:
      {
      case EM_386:
      case EM_486:
-      dwarf_regnames = dwarf_regnames_i386;
-      dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_i386);
+      init_dwarf_regnames_i386 ();
        break;
  
      case EM_X86_64:
        break;
  
      case EM_X86_64:
-      dwarf_regnames = dwarf_regnames_x86_64;
-      dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_x86_64);
+    case EM_L1OM:
+    case EM_K1OM:
+      init_dwarf_regnames_x86_64 ();
        break;
  
      default:
        break;
  
      default:
@@ -3752,11 +4721,11 @@ frame_display_row (Frame_Chunk *fc, int *need_col_headers, int *max_regs)
  
    if (*need_col_headers)
      {
  
    if (*need_col_headers)
      {
-      static const char *loc = "   LOC";
+      static const char *sloc = "   LOC";
  
        *need_col_headers = 0;
  
  
        *need_col_headers = 0;
  
-      printf ("%-*s CFA      ", eh_addr_size * 2, loc);
+      printf ("%-*s CFA      ", eh_addr_size * 2, sloc);
  
        for (r = 0; r < *max_regs; r++)
         if (fc->col_type[r] != DW_CFA_unreferenced)
  
        for (r = 0; r < *max_regs; r++)
         if (fc->col_type[r] != DW_CFA_unreferenced)
@@ -3816,7 +4785,7 @@ frame_display_row (Frame_Chunk *fc, int *need_col_headers, int *max_regs)
  
  #define GET(N) byte_get (start, N); start += N
  #define LEB()  read_leb128 (start, & length_return, 0); start += length_return
  
  #define GET(N) byte_get (start, N); start += N
  #define LEB()  read_leb128 (start, & length_return, 0); start += length_return
-#define SLEB() read_leb128 (start, & length_return, 1); start += length_return
+#define SLEB() read_sleb128 (start, & length_return); start += length_return
  
  static int
  display_debug_frames (struct dwarf_section *section,
  
  static int
  display_debug_frames (struct dwarf_section *section,
@@ -3832,6 +4801,7 @@ display_debug_frames (struct dwarf_section *section,
    unsigned int length_return;
    int max_regs = 0;
    const char *bad_reg = _("bad register: ");
    unsigned int length_return;
    int max_regs = 0;
    const char *bad_reg = _("bad register: ");
+  int saved_eh_addr_size = eh_addr_size;
  
    printf (_("Contents of the %s section:\n"), section->name);
  
  
    printf (_("Contents of the %s section:\n"), section->name);
  
@@ -3846,7 +4816,7 @@ display_debug_frames (struct dwarf_section *section,
        int need_col_headers = 1;
        unsigned char *augmentation_data = NULL;
        unsigned long augmentation_data_len = 0;
        int need_col_headers = 1;
        unsigned char *augmentation_data = NULL;
        unsigned long augmentation_data_len = 0;
-      int encoded_ptr_size = eh_addr_size;
+      int encoded_ptr_size = saved_eh_addr_size;
        int offset_size;
        int initial_length_size;
  
        int offset_size;
        int initial_length_size;
  
@@ -3886,15 +4856,15 @@ display_debug_frames (struct dwarf_section *section,
         {
           int version;
  
         {
           int version;
  
-         fc = xmalloc (sizeof (Frame_Chunk));
+         fc = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
           memset (fc, 0, sizeof (Frame_Chunk));
  
           fc->next = chunks;
           chunks = fc;
           fc->chunk_start = saved_start;
           fc->ncols = 0;
           memset (fc, 0, sizeof (Frame_Chunk));
  
           fc->next = chunks;
           chunks = fc;
           fc->chunk_start = saved_start;
           fc->ncols = 0;
-         fc->col_type = xmalloc (sizeof (short int));
-         fc->col_offset = xmalloc (sizeof (int));
+         fc->col_type = (short int *) xmalloc (sizeof (short int));
+         fc->col_offset = (int *) xmalloc (sizeof (int));
           frame_need_space (fc, max_regs - 1);
  
           version = *start++;
           frame_need_space (fc, max_regs - 1);
  
           version = *start++;
@@ -3902,48 +4872,36 @@ display_debug_frames (struct dwarf_section *section,
           fc->augmentation = (char *) start;
           start = (unsigned char *) strchr ((char *) start, '\0') + 1;
  
           fc->augmentation = (char *) start;
           start = (unsigned char *) strchr ((char *) start, '\0') + 1;
  
-         if (fc->augmentation[0] == 'z')
+         if (strcmp (fc->augmentation, "eh") == 0)
+           start += eh_addr_size;
+
+         if (version >= 4)
             {
             {
-             fc->code_factor = LEB ();
-             fc->data_factor = SLEB ();
-             if (version == 1)
-               {
-                 fc->ra = GET (1);
-               }
-             else
-               {
-                 fc->ra = LEB ();
-               }
-             augmentation_data_len = LEB ();
-             augmentation_data = start;
-             start += augmentation_data_len;
+             fc->ptr_size = GET (1);
+             fc->segment_size = GET (1);
+             eh_addr_size = fc->ptr_size;
             }
             }
-         else if (strcmp (fc->augmentation, "eh") == 0)
+         else
             {
             {
-             start += eh_addr_size;
-             fc->code_factor = LEB ();
-             fc->data_factor = SLEB ();
-             if (version == 1)
-               {
-                 fc->ra = GET (1);
-               }
-             else
-               {
-                 fc->ra = LEB ();
-               }
+             fc->ptr_size = eh_addr_size;
+             fc->segment_size = 0;
+           }
+         fc->code_factor = LEB ();
+         fc->data_factor = SLEB ();
+         if (version == 1)
+           {
+             fc->ra = GET (1);
             }
           else
             {
             }
           else
             {
-             fc->code_factor = LEB ();
-             fc->data_factor = SLEB ();
-             if (version == 1)
-               {
-                 fc->ra = GET (1);
-               }
-             else
-               {
-                 fc->ra = LEB ();
-               }
+             fc->ra = LEB ();
+           }
+
+         if (fc->augmentation[0] == 'z')
+           {
+             augmentation_data_len = LEB ();
+             augmentation_data = start;
+             start += augmentation_data_len;
             }
           cie = fc;
  
             }
           cie = fc;
  
@@ -3958,6 +4916,11 @@ display_debug_frames (struct dwarf_section *section,
                       (unsigned long)(saved_start - section_start), length, cie_id);
               printf ("  Version:               %d\n", version);
               printf ("  Augmentation:          \"%s\"\n", fc->augmentation);
                       (unsigned long)(saved_start - section_start), length, cie_id);
               printf ("  Version:               %d\n", version);
               printf ("  Augmentation:          \"%s\"\n", fc->augmentation);
+             if (version >= 4)
+               {
+                 printf ("  Pointer Size:          %u\n", fc->ptr_size);
+                 printf ("  Segment Size:          %u\n", fc->segment_size);
+               }
               printf ("  Code alignment factor: %u\n", fc->code_factor);
               printf ("  Data alignment factor: %d\n", fc->data_factor);
               printf ("  Return address column: %d\n", fc->ra);
               printf ("  Code alignment factor: %u\n", fc->code_factor);
               printf ("  Data alignment factor: %d\n", fc->data_factor);
               printf ("  Return address column: %d\n", fc->ra);
@@ -3987,6 +4950,8 @@ display_debug_frames (struct dwarf_section *section,
                     q += 1 + size_of_encoded_value (*q);
                   else if (*p == 'R')
                     fc->fde_encoding = *q++;
                     q += 1 + size_of_encoded_value (*q);
                   else if (*p == 'R')
                     fc->fde_encoding = *q++;
+                 else if (*p == 'S')
+                   ;
                   else
                     break;
                   p++;
                   else
                     break;
                   p++;
@@ -4002,6 +4967,7 @@ display_debug_frames (struct dwarf_section *section,
         {
           unsigned char *look_for;
           static Frame_Chunk fde_fc;
         {
           unsigned char *look_for;
           static Frame_Chunk fde_fc;
+         unsigned long segment_selector;
  
           fc = & fde_fc;
           memset (fc, 0, sizeof (Frame_Chunk));
  
           fc = & fde_fc;
           memset (fc, 0, sizeof (Frame_Chunk));
@@ -4017,21 +4983,26 @@ display_debug_frames (struct dwarf_section *section,
               warn ("Invalid CIE pointer %#08lx in FDE at %#08lx\n",
                     cie_id, (unsigned long)(saved_start - section_start));
               fc->ncols = 0;
               warn ("Invalid CIE pointer %#08lx in FDE at %#08lx\n",
                     cie_id, (unsigned long)(saved_start - section_start));
               fc->ncols = 0;
-             fc->col_type = xmalloc (sizeof (short int));
-             fc->col_offset = xmalloc (sizeof (int));
+             fc->col_type = (short int *) xmalloc (sizeof (short int));
+             fc->col_offset = (int *) xmalloc (sizeof (int));
               frame_need_space (fc, max_regs - 1);
               cie = fc;
               fc->augmentation = "";
               fc->fde_encoding = 0;
               frame_need_space (fc, max_regs - 1);
               cie = fc;
               fc->augmentation = "";
               fc->fde_encoding = 0;
+             fc->ptr_size = eh_addr_size;
+             fc->segment_size = 0;
             }
           else
             {
               fc->ncols = cie->ncols;
             }
           else
             {
               fc->ncols = cie->ncols;
-             fc->col_type = xcmalloc (fc->ncols, sizeof (short int));
-             fc->col_offset = xcmalloc (fc->ncols, sizeof (int));
+             fc->col_type = (short int *) xcmalloc (fc->ncols, sizeof (short int));
+             fc->col_offset =  (int *) xcmalloc (fc->ncols, sizeof (int));
               memcpy (fc->col_type, cie->col_type, fc->ncols * sizeof (short int));
               memcpy (fc->col_offset, cie->col_offset, fc->ncols * sizeof (int));
               fc->augmentation = cie->augmentation;
               memcpy (fc->col_type, cie->col_type, fc->ncols * sizeof (short int));
               memcpy (fc->col_offset, cie->col_offset, fc->ncols * sizeof (int));
               fc->augmentation = cie->augmentation;
+             fc->ptr_size = cie->ptr_size;
+             eh_addr_size = cie->ptr_size;
+             fc->segment_size = cie->segment_size;
               fc->code_factor = cie->code_factor;
               fc->data_factor = cie->data_factor;
               fc->cfa_reg = cie->cfa_reg;
               fc->code_factor = cie->code_factor;
               fc->data_factor = cie->data_factor;
               fc->cfa_reg = cie->cfa_reg;
@@ -4044,9 +5015,13 @@ display_debug_frames (struct dwarf_section *section,
           if (fc->fde_encoding)
             encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
  
           if (fc->fde_encoding)
             encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
  
-         fc->pc_begin = get_encoded_value (start, fc->fde_encoding);
-         if ((fc->fde_encoding & 0x70) == DW_EH_PE_pcrel)
-           fc->pc_begin += section->address + (start - section_start);
+         segment_selector = 0;
+         if (fc->segment_size)
+           {
+             segment_selector = byte_get (start, fc->segment_size);
+             start += fc->segment_size;
+           }
+         fc->pc_begin = get_encoded_value (start, fc->fde_encoding, section);
           start += encoded_ptr_size;
           fc->pc_range = byte_get (start, encoded_ptr_size);
           start += encoded_ptr_size;
           start += encoded_ptr_size;
           fc->pc_range = byte_get (start, encoded_ptr_size);
           start += encoded_ptr_size;
@@ -4058,10 +5033,12 @@ display_debug_frames (struct dwarf_section *section,
               start += augmentation_data_len;
             }
  
               start += augmentation_data_len;
             }
  
-         printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
+         printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=",
                   (unsigned long)(saved_start - section_start), length, cie_id,
                   (unsigned long)(saved_start - section_start), length, cie_id,
-                 (unsigned long)(cie->chunk_start - section_start),
-                 fc->pc_begin, fc->pc_begin + fc->pc_range);
+                 (unsigned long)(cie->chunk_start - section_start));
+         if (fc->segment_size)
+           printf ("%04lx:", segment_selector);
+         printf ("%08lx..%08lx\n", fc->pc_begin, fc->pc_begin + fc->pc_range);
           if (! do_debug_frames_interp && augmentation_data_len)
             {
               unsigned long i;
           if (! do_debug_frames_interp && augmentation_data_len)
             {
               unsigned long i;
@@ -4090,7 +5067,7 @@ display_debug_frames (struct dwarf_section *section,
           while (start < block_end)
             {
               unsigned op, opa;
           while (start < block_end)
             {
               unsigned op, opa;
-             unsigned long reg, tmp;
+             unsigned long reg, temp;
  
               op = *start++;
               opa = op & 0x3f;
  
               op = *start++;
               opa = op & 0x3f;
@@ -4161,14 +5138,14 @@ display_debug_frames (struct dwarf_section *section,
                   LEB ();
                   break;
                 case DW_CFA_def_cfa_expression:
                   LEB ();
                   break;
                 case DW_CFA_def_cfa_expression:
-                 tmp = LEB ();
-                 start += tmp;
+                 temp = LEB ();
+                 start += temp;
                   break;
                 case DW_CFA_expression:
                 case DW_CFA_val_expression:
                   reg = LEB ();
                   break;
                 case DW_CFA_expression:
                 case DW_CFA_val_expression:
                   reg = LEB ();
-                 tmp = LEB ();
-                 start += tmp;
+                 temp = LEB ();
+                 start += temp;
                   if (frame_need_space (fc, reg) >= 0)
                     fc->col_type[reg] = DW_CFA_undefined;
                   break;
                   if (frame_need_space (fc, reg) >= 0)
                     fc->col_type[reg] = DW_CFA_undefined;
                   break;
@@ -4258,13 +5235,14 @@ display_debug_frames (struct dwarf_section *section,
                 {
                   fc->col_type[opa] = cie->col_type[opa];
                   fc->col_offset[opa] = cie->col_offset[opa];
                 {
                   fc->col_type[opa] = cie->col_type[opa];
                   fc->col_offset[opa] = cie->col_offset[opa];
+                 if (do_debug_frames_interp
+                     && fc->col_type[opa] == DW_CFA_unreferenced)
+                   fc->col_type[opa] = DW_CFA_undefined;
                 }
               break;
  
             case DW_CFA_set_loc:
                 }
               break;
  
             case DW_CFA_set_loc:
-             vma = get_encoded_value (start, fc->fde_encoding);
-             if ((fc->fde_encoding & 0x70) == DW_EH_PE_pcrel)
-               vma += section->address + (start - section_start);
+             vma = get_encoded_value (start, fc->fde_encoding, section);
               start += encoded_ptr_size;
               if (do_debug_frames_interp)
                 frame_display_row (fc, &need_col_headers, &max_regs);
               start += encoded_ptr_size;
               if (do_debug_frames_interp)
                 frame_display_row (fc, &need_col_headers, &max_regs);
@@ -4402,10 +5380,11 @@ display_debug_frames (struct dwarf_section *section,
             case DW_CFA_remember_state:
               if (! do_debug_frames_interp)
                 printf ("  DW_CFA_remember_state\n");
             case DW_CFA_remember_state:
               if (! do_debug_frames_interp)
                 printf ("  DW_CFA_remember_state\n");
-             rs = xmalloc (sizeof (Frame_Chunk));
+             rs = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
               rs->ncols = fc->ncols;
               rs->ncols = fc->ncols;
-             rs->col_type = xcmalloc (rs->ncols, sizeof (short int));
-             rs->col_offset = xcmalloc (rs->ncols, sizeof (int));
+             rs->col_type = (short int *) xcmalloc (rs->ncols,
+                                                     sizeof (short int));
+             rs->col_offset = (int *) xcmalloc (rs->ncols, sizeof (int));
               memcpy (rs->col_type, fc->col_type, rs->ncols);
               memcpy (rs->col_offset, fc->col_offset, rs->ncols * sizeof (int));
               rs->next = remembered_state;
               memcpy (rs->col_type, fc->col_type, rs->ncols);
               memcpy (rs->col_offset, fc->col_offset, rs->ncols * sizeof (int));
               rs->next = remembered_state;
@@ -4464,8 +5443,8 @@ display_debug_frames (struct dwarf_section *section,
               if (! do_debug_frames_interp)
                 {
                   printf ("  DW_CFA_def_cfa_expression (");
               if (! do_debug_frames_interp)
                 {
                   printf ("  DW_CFA_def_cfa_expression (");
-                 decode_location_expression (start, eh_addr_size, ul, 0,
-                                             section);
+                 decode_location_expression (start, eh_addr_size, 0, -1,
+                                             ul, 0, section);
                   printf (")\n");
                 }
               fc->cfa_exp = 1;
                   printf (")\n");
                 }
               fc->cfa_exp = 1;
@@ -4481,7 +5460,7 @@ display_debug_frames (struct dwarf_section *section,
                 {
                   printf ("  DW_CFA_expression: %s%s (",
                           reg_prefix, regname (reg, 0));
                 {
                   printf ("  DW_CFA_expression: %s%s (",
                           reg_prefix, regname (reg, 0));
-                 decode_location_expression (start, eh_addr_size,
+                 decode_location_expression (start, eh_addr_size, 0, -1,
                                               ul, 0, section);
                   printf (")\n");
                 }
                                               ul, 0, section);
                   printf (")\n");
                 }
@@ -4499,8 +5478,8 @@ display_debug_frames (struct dwarf_section *section,
                 {
                   printf ("  DW_CFA_val_expression: %s%s (",
                           reg_prefix, regname (reg, 0));
                 {
                   printf ("  DW_CFA_val_expression: %s%s (",
                           reg_prefix, regname (reg, 0));
-                 decode_location_expression (start, eh_addr_size, ul, 0,
-                                             section);
+                 decode_location_expression (start, eh_addr_size, 0, -1,
+                                             ul, 0, section);
                   printf (")\n");
                 }
               if (*reg_prefix == '\0')
                   printf (")\n");
                 }
               if (*reg_prefix == '\0')
@@ -4608,6 +5587,7 @@ display_debug_frames (struct dwarf_section *section,
         frame_display_row (fc, &need_col_headers, &max_regs);
  
        start = block_end;
         frame_display_row (fc, &need_col_headers, &max_regs);
  
        start = block_end;
+      eh_addr_size = saved_eh_addr_size;
      }
  
    printf ("\n");
      }
  
    printf ("\n");
@@ -4619,6 +5599,147 @@ display_debug_frames (struct dwarf_section *section,
  #undef LEB
  #undef SLEB
  
  #undef LEB
  #undef SLEB
  
+static int
+display_gdb_index (struct dwarf_section *section,
+                  void *file ATTRIBUTE_UNUSED)
+{
+  unsigned char *start = section->start;
+  uint32_t version;
+  uint32_t cu_list_offset, tu_list_offset;
+  uint32_t address_table_offset, symbol_table_offset, constant_pool_offset;
+  unsigned int cu_list_elements, tu_list_elements;
+  unsigned int address_table_size, symbol_table_slots;
+  unsigned char *cu_list, *tu_list;
+  unsigned char *address_table, *symbol_table, *constant_pool;
+  unsigned int i;
+
+  /* The documentation for the format of this file is in gdb/dwarf2read.c.  */
+
+  printf (_("Contents of the %s section:\n"), section->name);
+
+  if (section->size < 6 * sizeof (uint32_t))
+    {
+      warn (_("Truncated header in the %s section.\n"), section->name);
+      return 0;
+    }
+
+  version = byte_get_little_endian (start, 4);
+  printf (_("Version %ld\n"), (long) version);
+
+  /* Prior versions are obsolete, and future versions may not be
+     backwards compatible.  */
+  switch (version)
+    {
+    case 3:
+      warn (_("The address table data in version 3 may be wrong.\n"));
+      break;
+    case 4:
+      warn (_("Version 4 does not support case insensitive lookups.\n"));
+      break;
+    case 5:
+      warn (_("Version 5 does not include inlined functions.\n"));
+      break;
+    case 6:
+      break;
+    default:
+      warn (_("Unsupported version %lu.\n"), (unsigned long) version);
+      return 0;
+    }
+
+  cu_list_offset = byte_get_little_endian (start + 4, 4);
+  tu_list_offset = byte_get_little_endian (start + 8, 4);
+  address_table_offset = byte_get_little_endian (start + 12, 4);
+  symbol_table_offset = byte_get_little_endian (start + 16, 4);
+  constant_pool_offset = byte_get_little_endian (start + 20, 4);
+
+  if (cu_list_offset > section->size
+      || tu_list_offset > section->size
+      || address_table_offset > section->size
+      || symbol_table_offset > section->size
+      || constant_pool_offset > section->size)
+    {
+      warn (_("Corrupt header in the %s section.\n"), section->name);
+      return 0;
+    }
+
+  cu_list_elements = (tu_list_offset - cu_list_offset) / 8;
+  tu_list_elements = (address_table_offset - tu_list_offset) / 8;
+  address_table_size = symbol_table_offset - address_table_offset;
+  symbol_table_slots = (constant_pool_offset - symbol_table_offset) / 8;
+
+  cu_list = start + cu_list_offset;
+  tu_list = start + tu_list_offset;
+  address_table = start + address_table_offset;
+  symbol_table = start + symbol_table_offset;
+  constant_pool = start + constant_pool_offset;
+
+  printf (_("\nCU table:\n"));
+  for (i = 0; i < cu_list_elements; i += 2)
+    {
+      uint64_t cu_offset = byte_get_little_endian (cu_list + i * 8, 8);
+      uint64_t cu_length = byte_get_little_endian (cu_list + i * 8 + 8, 8);
+
+      printf (_("[%3u] 0x%lx - 0x%lx\n"), i / 2,
+             (unsigned long) cu_offset,
+             (unsigned long) (cu_offset + cu_length - 1));
+    }
+
+  printf (_("\nTU table:\n"));
+  for (i = 0; i < tu_list_elements; i += 3)
+    {
+      uint64_t tu_offset = byte_get_little_endian (tu_list + i * 8, 8);
+      uint64_t type_offset = byte_get_little_endian (tu_list + i * 8 + 8, 8);
+      uint64_t signature = byte_get_little_endian (tu_list + i * 8 + 16, 8);
+
+      printf (_("[%3u] 0x%lx 0x%lx "), i / 3,
+             (unsigned long) tu_offset,
+             (unsigned long) type_offset);
+      print_dwarf_vma (signature, 8);
+      printf ("\n");
+    }
+
+  printf (_("\nAddress table:\n"));
+  for (i = 0; i < address_table_size; i += 2 * 8 + 4)
+    {
+      uint64_t low = byte_get_little_endian (address_table + i, 8);
+      uint64_t high = byte_get_little_endian (address_table + i + 8, 8);
+      uint32_t cu_index = byte_get_little_endian (address_table + i + 16, 4);
+
+      print_dwarf_vma (low, 8);
+      print_dwarf_vma (high, 8);
+      printf (_("%lu\n"), (unsigned long) cu_index);
+    }
+
+  printf (_("\nSymbol table:\n"));
+  for (i = 0; i < symbol_table_slots; ++i)
+    {
+      uint32_t name_offset = byte_get_little_endian (symbol_table + i * 8, 4);
+      uint32_t cu_vector_offset = byte_get_little_endian (symbol_table + i * 8 + 4, 4);
+      uint32_t num_cus, cu;
+
+      if (name_offset != 0
+         || cu_vector_offset != 0)
+       {
+         unsigned int j;
+
+         printf ("[%3u] %s:", i, constant_pool + name_offset);
+         num_cus = byte_get_little_endian (constant_pool + cu_vector_offset, 4);
+         for (j = 0; j < num_cus; ++j)
+           {
+             cu = byte_get_little_endian (constant_pool + cu_vector_offset + 4 + j * 4, 4);
+             /* Convert to TU number if it's for a type unit.  */
+             if (cu >= cu_list_elements / 2)
+               printf (" T%lu", (unsigned long) (cu - cu_list_elements / 2));
+             else
+               printf (" %lu", (unsigned long) cu);
+           }
+         printf ("\n");
+       }
+    }
+
+  return 1;
+}
+
  static int
  display_debug_not_supported (struct dwarf_section *section,
                              void *file ATTRIBUTE_UNUSED)
  static int
  display_debug_not_supported (struct dwarf_section *section,
                              void *file ATTRIBUTE_UNUSED)
@@ -4659,37 +5780,15 @@ xcrealloc (void *ptr, size_t nmemb, size_t size)
      return xrealloc (ptr, nmemb * size);
  }
  
      return xrealloc (ptr, nmemb * size);
  }
  
-void
-error (const char *message, ...)
-{
-  va_list args;
-
-  va_start (args, message);
-  fprintf (stderr, _("%s: Error: "), program_name);
-  vfprintf (stderr, message, args);
-  va_end (args);
-}
-
-void
-warn (const char *message, ...)
-{
-  va_list args;
-
-  va_start (args, message);
-  fprintf (stderr, _("%s: Warning: "), program_name);
-  vfprintf (stderr, message, args);
-  va_end (args);
-}
-
  void
  free_debug_memory (void)
  {
  void
  free_debug_memory (void)
  {
-  enum dwarf_section_display_enum i;
+  unsigned int i;
  
    free_abbrevs ();
  
    for (i = 0; i < max; i++)
  
    free_abbrevs ();
  
    for (i = 0; i < max; i++)
-    free_debug_section (i);
+    free_debug_section ((enum dwarf_section_display_enum) i);
  
    if (debug_information != NULL)
      {
  
    if (debug_information != NULL)
      {
@@ -4720,7 +5819,7 @@ dwarf_select_sections_by_names (const char *names)
    {
      const char * option;
      int *        variable;
    {
      const char * option;
      int *        variable;
-    int val;
+    int          val;
    }
    debug_dump_long_opts;
  
    }
    debug_dump_long_opts;
  
@@ -4739,29 +5838,36 @@ dwarf_select_sections_by_names (const char *names)
        { "loc",  & do_debug_loc, 1 },
        { "macro", & do_debug_macinfo, 1 },
        { "pubnames", & do_debug_pubnames, 1 },
        { "loc",  & do_debug_loc, 1 },
        { "macro", & do_debug_macinfo, 1 },
        { "pubnames", & do_debug_pubnames, 1 },
+      { "pubtypes", & do_debug_pubtypes, 1 },
        /* This entry is for compatability
          with earlier versions of readelf.  */
        { "ranges", & do_debug_aranges, 1 },
        { "str", & do_debug_str, 1 },
        /* This entry is for compatability
          with earlier versions of readelf.  */
        { "ranges", & do_debug_aranges, 1 },
        { "str", & do_debug_str, 1 },
+      /* The special .gdb_index section.  */
+      { "gdb_index", & do_gdb_index, 1 },
+      /* These trace_* sections are used by Itanium VMS.  */
+      { "trace_abbrev", & do_trace_abbrevs, 1 },
+      { "trace_aranges", & do_trace_aranges, 1 },
+      { "trace_info", & do_trace_info, 1 },
        { NULL, NULL, 0 }
      };
  
    const char *p;
        { NULL, NULL, 0 }
      };
  
    const char *p;
-  
+
    p = names;
    while (*p)
      {
        const debug_dump_long_opts * entry;
    p = names;
    while (*p)
      {
        const debug_dump_long_opts * entry;
-      
+
        for (entry = opts_table; entry->option; entry++)
         {
           size_t len = strlen (entry->option);
        for (entry = opts_table; entry->option; entry++)
         {
           size_t len = strlen (entry->option);
-         
+
           if (strncmp (p, entry->option, len) == 0
               && (p[len] == ',' || p[len] == '\0'))
             {
               * entry->variable |= entry->val;
           if (strncmp (p, entry->option, len) == 0
               && (p[len] == ',' || p[len] == '\0'))
             {
               * entry->variable |= entry->val;
-             
+
               /* The --debug-dump=frames-interp option also
                  enables the --debug-dump=frames option.  */
               if (do_debug_frames_interp)
               /* The --debug-dump=frames-interp option also
                  enables the --debug-dump=frames option.  */
               if (do_debug_frames_interp)
@@ -4771,7 +5877,7 @@ dwarf_select_sections_by_names (const char *names)
               break;
             }
         }
               break;
             }
         }
-      
+
        if (entry->option == NULL)
         {
           warn (_("Unrecognized debug option '%s'\n"), p);
        if (entry->option == NULL)
         {
           warn (_("Unrecognized debug option '%s'\n"), p);
@@ -4779,7 +5885,7 @@ dwarf_select_sections_by_names (const char *names)
           if (p == NULL)
             break;
         }
           if (p == NULL)
             break;
         }
-      
+
        if (*p == ',')
         p++;
      }
        if (*p == ',')
         p++;
      }
@@ -4788,57 +5894,61 @@ dwarf_select_sections_by_names (const char *names)
  void
  dwarf_select_sections_by_letters (const char *letters)
  {
  void
  dwarf_select_sections_by_letters (const char *letters)
  {
-  unsigned int index = 0;
+  unsigned int lindex = 0;
  
  
-  while (letters[index])
-    switch (letters[index++])
+  while (letters[lindex])
+    switch (letters[lindex++])
        {
        case 'i':
         do_debug_info = 1;
         break;
        {
        case 'i':
         do_debug_info = 1;
         break;
-       
+
        case 'a':
         do_debug_abbrevs = 1;
         break;
        case 'a':
         do_debug_abbrevs = 1;
         break;
-       
+
        case 'l':
         do_debug_lines |= FLAG_DEBUG_LINES_RAW;
         break;
        case 'l':
         do_debug_lines |= FLAG_DEBUG_LINES_RAW;
         break;
-       
+
        case 'L':
         do_debug_lines |= FLAG_DEBUG_LINES_DECODED;
         break;
        case 'L':
         do_debug_lines |= FLAG_DEBUG_LINES_DECODED;
         break;
-       
+
        case 'p':
         do_debug_pubnames = 1;
         break;
        case 'p':
         do_debug_pubnames = 1;
         break;
-       
+
+      case 't':
+       do_debug_pubtypes = 1;
+       break;
+
        case 'r':
         do_debug_aranges = 1;
         break;
        case 'r':
         do_debug_aranges = 1;
         break;
-       
+
        case 'R':
         do_debug_ranges = 1;
         break;
        case 'R':
         do_debug_ranges = 1;
         break;
-       
+
        case 'F':
         do_debug_frames_interp = 1;
        case 'f':
         do_debug_frames = 1;
         break;
        case 'F':
         do_debug_frames_interp = 1;
        case 'f':
         do_debug_frames = 1;
         break;
-       
+
        case 'm':
         do_debug_macinfo = 1;
         break;
        case 'm':
         do_debug_macinfo = 1;
         break;
-       
+
        case 's':
         do_debug_str = 1;
         break;
        case 's':
         do_debug_str = 1;
         break;
-       
+
        case 'o':
         do_debug_loc = 1;
         break;
        case 'o':
         do_debug_loc = 1;
         break;
-       
+
        default:
         warn (_("Unrecognized debug option '%s'\n"), optarg);
         break;
        default:
         warn (_("Unrecognized debug option '%s'\n"), optarg);
         break;
@@ -4852,46 +5962,84 @@ dwarf_select_sections_all (void)
    do_debug_abbrevs = 1;
    do_debug_lines = FLAG_DEBUG_LINES_RAW;
    do_debug_pubnames = 1;
    do_debug_abbrevs = 1;
    do_debug_lines = FLAG_DEBUG_LINES_RAW;
    do_debug_pubnames = 1;
+  do_debug_pubtypes = 1;
    do_debug_aranges = 1;
    do_debug_ranges = 1;
    do_debug_frames = 1;
    do_debug_macinfo = 1;
    do_debug_str = 1;
    do_debug_loc = 1;
    do_debug_aranges = 1;
    do_debug_ranges = 1;
    do_debug_frames = 1;
    do_debug_macinfo = 1;
    do_debug_str = 1;
    do_debug_loc = 1;
+  do_gdb_index = 1;
+  do_trace_info = 1;
+  do_trace_abbrevs = 1;
+  do_trace_aranges = 1;
  }
  
  struct dwarf_section_display debug_displays[] =
  {
  }
  
  struct dwarf_section_display debug_displays[] =
  {
-  { { ".debug_abbrev",         ".zdebug_abbrev",       NULL,   NULL,   0,      0 },
-    display_debug_abbrev,              &do_debug_abbrevs,      0,      0 },
-  { { ".debug_aranges",                ".zdebug_aranges",      NULL,   NULL,   0,      0 },
-    display_debug_aranges,             &do_debug_aranges,      0,      0 },
-  { { ".debug_frame",          ".zdebug_frame",        NULL,   NULL,   0,      0 },
-    display_debug_frames,              &do_debug_frames,       1,      0 },
-  { { ".debug_info",           ".zdebug_info",         NULL,   NULL,   0,      0 },
-    display_debug_info,                        &do_debug_info,         1,      0 },
-  { { ".debug_line",           ".zdebug_line",         NULL,   NULL,   0,      0 },
-    display_debug_lines,               &do_debug_lines,        0,      0 },
-  { { ".debug_pubnames",       ".zdebug_pubnames",     NULL,   NULL,   0,      0 },
-    display_debug_pubnames,            &do_debug_pubnames,     0,      0 },
-  { { ".eh_frame",             "",                     NULL,   NULL,   0,      0 },
-    display_debug_frames,              &do_debug_frames,       1,      1 },
-  { { ".debug_macinfo",                ".zdebug_macinfo",      NULL,   NULL,   0,      0 },
-    display_debug_macinfo,             &do_debug_macinfo,      0,      0 },
-  { { ".debug_str",            ".zdebug_str",          NULL,   NULL,   0,      0 },
-    display_debug_str,                 &do_debug_str,          0,      0 },
-  { { ".debug_loc",            ".zdebug_loc",          NULL,   NULL,   0,      0 },
-    display_debug_loc,                 &do_debug_loc,          0,      0 },
-  { { ".debug_pubtypes",       ".zdebug_pubtypes",     NULL,   NULL,   0,      0 },
-    display_debug_pubnames,            &do_debug_pubnames,     0,      0 },
-  { { ".debug_ranges",         ".zdebug_ranges",       NULL,   NULL,   0,      0 },
-    display_debug_ranges,              &do_debug_ranges,       0,      0 },
-  { { ".debug_static_func",    ".zdebug_static_func",  NULL,   NULL,   0,      0 },
-    display_debug_not_supported,       NULL,                   0,      0 },
-  { { ".debug_static_vars",    ".zdebug_static_vars",  NULL,   NULL,   0,      0 },
-    display_debug_not_supported,       NULL,                   0,      0 },
-  { { ".debug_types",          ".zdebug_types",        NULL,   NULL,   0,      0 },
-    display_debug_not_supported,       NULL,                   0,      0 },
-  { { ".debug_weaknames",      ".zdebug_weaknames",    NULL,   NULL,   0,      0 },
-    display_debug_not_supported,       NULL,                   0,      0 }
+  { { ".debug_abbrev",     ".zdebug_abbrev",   NULL, NULL, 0, 0, abbrev },
+    display_debug_abbrev,   &do_debug_abbrevs, 0 },
+  { { ".debug_aranges",            ".zdebug_aranges",  NULL, NULL, 0, 0, abbrev },
+    display_debug_aranges,  &do_debug_aranges, 1 },
+  { { ".debug_frame",       ".zdebug_frame",   NULL, NULL, 0, 0, abbrev },
+    display_debug_frames,   &do_debug_frames,  1 },
+  { { ".debug_info",       ".zdebug_info",     NULL, NULL, 0, 0, abbrev },
+    display_debug_info,            &do_debug_info,     1 },
+  { { ".debug_line",       ".zdebug_line",     NULL, NULL, 0, 0, abbrev },
+    display_debug_lines,    &do_debug_lines,   1 },
+  { { ".debug_pubnames",    ".zdebug_pubnames",        NULL, NULL, 0, 0, abbrev },
+    display_debug_pubnames, &do_debug_pubnames,        0 },
+  { { ".eh_frame",         "",                 NULL, NULL, 0, 0, abbrev },
+    display_debug_frames,   &do_debug_frames,  1 },
+  { { ".debug_macinfo",            ".zdebug_macinfo",  NULL, NULL, 0, 0, abbrev },
+    display_debug_macinfo,  &do_debug_macinfo, 0 },
+  { { ".debug_macro",      ".zdebug_macro",    NULL, NULL, 0, 0, abbrev },
+    display_debug_macro,    &do_debug_macinfo, 1 },
+  { { ".debug_str",        ".zdebug_str",      NULL, NULL, 0, 0, abbrev },
+    display_debug_str,     &do_debug_str,      0 },
+  { { ".debug_loc",        ".zdebug_loc",      NULL, NULL, 0, 0, abbrev },
+    display_debug_loc,     &do_debug_loc,      1 },
+  { { ".debug_pubtypes",    ".zdebug_pubtypes",        NULL, NULL, 0, 0, abbrev },
+    display_debug_pubnames, &do_debug_pubtypes,        0 },
+  { { ".debug_ranges",     ".zdebug_ranges",   NULL, NULL, 0, 0, abbrev },
+    display_debug_ranges,   &do_debug_ranges,  1 },
+  { { ".debug_static_func", ".zdebug_static_func", NULL, NULL, 0, 0, abbrev },
+    display_debug_not_supported, NULL,         0 },
+  { { ".debug_static_vars", ".zdebug_static_vars", NULL, NULL, 0, 0, abbrev },
+    display_debug_not_supported, NULL,         0 },
+  { { ".debug_types",      ".zdebug_types",    NULL, NULL, 0, 0, abbrev },
+    display_debug_types,    &do_debug_info,    1 },
+  { { ".debug_weaknames",   ".zdebug_weaknames", NULL, NULL, 0, 0, abbrev },
+    display_debug_not_supported, NULL,         0 },
+  { { ".gdb_index",        "",                 NULL, NULL, 0, 0, abbrev },
+    display_gdb_index,                 &do_gdb_index,          0 },
+  { { ".trace_info",       "",                 NULL, NULL, 0, 0, trace_abbrev },
+    display_trace_info,                        &do_trace_info,         1 },
+  { { ".trace_abbrev",     "",                 NULL, NULL, 0, 0, abbrev },
+    display_debug_abbrev,              &do_trace_abbrevs,      0 },
+  { { ".trace_aranges",            "",                 NULL, NULL, 0, 0, abbrev },
+    display_debug_aranges,             &do_trace_aranges,      0 },
+  { { ".debug_info.dwo",    ".zdebug_info.dwo",        NULL, NULL, 0, 0, abbrev_dwo },
+    display_debug_info,                        &do_debug_info,         1 },
+  { { ".debug_abbrev.dwo",  ".zdebug_abbrev.dwo", NULL, NULL, 0, 0, abbrev_dwo },
+    display_debug_abbrev,              &do_debug_abbrevs,      0 },
+  { { ".debug_types.dwo",   ".zdebug_types.dwo", NULL, NULL, 0, 0, abbrev_dwo },
+    display_debug_types,               &do_debug_info,         1 },
+  { { ".debug_line.dwo",   ".zdebug_line.dwo", NULL, NULL, 0, 0, abbrev_dwo },
+    display_debug_lines,   &do_debug_lines,    1 },
+  { { ".debug_loc.dwo",            ".zdebug_loc.dwo",  NULL, NULL, 0, 0, abbrev_dwo },
+    display_debug_loc,     &do_debug_loc,      1 },
+  { { ".debug_macro.dwo",   ".zdebug_macro.dwo",NULL, NULL, 0, 0, abbrev },
+    display_debug_macro,    &do_debug_macinfo, 1 },
+  { { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo",NULL, NULL, 0, 0, abbrev },
+    display_debug_macinfo,  &do_debug_macinfo, 0 },
+  { { ".debug_str.dwo",   ".zdebug_str.dwo", NULL, NULL, 0, 0, str_dwo },
+    display_debug_str,     &do_debug_str,              1 },
+  { { ".debug_str_offsets",".zdebug_str_offsets", NULL, NULL, 0, 0, abbrev },
+    display_debug_str_offsets, NULL,           0 },
+  { { ".debug_str_offsets.dwo",".zdebug_str_offsets.dwo", NULL, NULL, 0, 0,
+      abbrev },
+    display_debug_str_offsets, NULL,           0 },
+  { { ".debug_addr",".zdebug_addr",             NULL, NULL, 0, 0, debug_addr },
+    display_debug_addr, NULL,          1 },
  };
  };