X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=binutils%2Fdwarf.c;h=db76ce8ef2f347267cabc5ba2c34fb964739f8ce;hb=4c422395e61397529b6bbafc7fa5c0e28b4c56dc;hp=84e22eb713e911d25d9127c100aa93253492f5ac;hpb=0ac6fba0ecc9375477561f72df351a8ea84c899b;p=deliverable%2Fbinutils-gdb.git

diff --git a/binutils/dwarf.c b/binutils/dwarf.c
index 84e22eb713..db76ce8ef2 100644
--- a/binutils/dwarf.c
+++ b/binutils/dwarf.c
@@ -1,5 +1,5 @@
 /* dwarf.c -- display DWARF contents of a BFD binary file
-   Copyright 2005, 2006, 2007, 2008, 2009, 2010
+   Copyright 2005, 2006, 2007, 2008, 2009, 2010, 2011
    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 "bfd_stdint.h"
 #include "bucomm.h"
+#include "elfcomm.h"
 #include "elf/common.h"
 #include "dwarf2.h"
 #include "dwarf.h"
 
+static const char *regname (unsigned int regno, int row);
+
 static int have_frame_base;
 static int need_base_address;
 
@@ -53,134 +57,19 @@ int do_debug_frames_interp;
 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 dwarf_cutoff_level = -1;
+unsigned long dwarf_start_die;
+
 /* 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 3:
-      return  ((unsigned long) (field[0]))
-	|    (((unsigned long) (field[1])) << 8)
-	|    (((unsigned long) (field[2])) << 16);
-
-    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 3:
-      return ((unsigned long) (field[2]))
-	|   (((unsigned long) (field[1])) << 8)
-	|   (((unsigned long) (field[0])) << 16);
-
-    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)
 {
@@ -195,14 +84,21 @@ size_of_encoded_value (int encoding)
 }
 
 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);
+  dwarf_vma val;
 
   if (encoding & DW_EH_PE_signed)
-    return byte_get_signed (data, size);
+    val = byte_get_signed (data, size);
   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
@@ -213,12 +109,13 @@ static void
 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)
-#ifndef __MSVCRT__
+#ifndef __MINGW32__
   snprintf (buff, sizeof (buff), "%16.16llx ", val);
 #else
   snprintf (buff, sizeof (buff), "%016I64x ", val);
@@ -227,13 +124,55 @@ print_dwarf_vma (dwarf_vma val, unsigned byte_size)
   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;
 }
 
-unsigned long int
+dwarf_vma
 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;
@@ -243,7 +182,7 @@ read_leb128 (unsigned char *data, unsigned int *length_return, int sign)
       byte = *data++;
       num_read++;
 
-      result |= ((unsigned long int) (byte & 0x7f)) << shift;
+      result |= ((dwarf_vma) (byte & 0x7f)) << shift;
 
       shift += 7;
 
@@ -259,9 +198,16 @@ read_leb128 (unsigned char *data, unsigned int *length_return, int sign)
   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
 {
-  unsigned long address;
+  dwarf_vma address;
   unsigned int file;
   unsigned int line;
   unsigned int column;
@@ -300,7 +246,7 @@ process_extended_line_op (unsigned char *data, int is_stmt)
   unsigned int bytes_read;
   unsigned int len;
   unsigned char *name;
-  unsigned long adr;
+  dwarf_vma adr;
 
   len = read_leb128 (data, & bytes_read, 0);
   data += bytes_read;
@@ -325,7 +271,7 @@ process_extended_line_op (unsigned char *data, int is_stmt)
 
     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.op_index = 0;
       break;
@@ -334,20 +280,20 @@ process_extended_line_op (unsigned char *data, int is_stmt)
       printf (_("  define new File Table entry\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;
-      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 (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
+      printf ("%s\t", dwarf_vmatoa ("u", read_leb128 (data, & bytes_read, 0)));
       data += bytes_read;
-      printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
-      printf (_("%s\n\n"), name);
+      printf ("%s\t", dwarf_vmatoa ("u", read_leb128 (data, & bytes_read, 0)));
+      printf ("%s\n\n", name);
       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.  */
@@ -381,16 +327,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_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 ("    UNKNOW DW_LNE_HP_SFC opcode (%u)\n", opc);
+                data = edata;
+                break;
+              }
+          }
+      }
+      break;
 
     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;
     }
 
@@ -398,7 +399,7 @@ process_extended_line_op (unsigned char *data, int is_stmt)
 }
 
 static const char *
-fetch_indirect_string (unsigned long offset)
+fetch_indirect_string (dwarf_vma offset)
 {
   struct dwarf_section *section = &debug_displays [str].section;
 
@@ -409,7 +410,8 @@ fetch_indirect_string (unsigned long offset)
   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>");
     }
 
@@ -472,7 +474,6 @@ add_abbrev (unsigned long number, unsigned long tag, int children)
   abbrev_entry *entry;
 
   entry = (abbrev_entry *) malloc (sizeof (*entry));
-
   if (entry == NULL)
     /* ugg */
     return;
@@ -498,7 +499,6 @@ add_abbrev_attr (unsigned long attribute, unsigned long form)
   abbrev_attr *attr;
 
   attr = (abbrev_attr *) malloc (sizeof (*attr));
-
   if (attr == NULL)
     /* ugg */
     return;
@@ -645,6 +645,9 @@ get_TAG_name (unsigned long tag)
     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";
+      /* GNU values.  */
+    case DW_TAG_GNU_call_site:		return "DW_TAG_GNU_call_site";
+    case DW_TAG_GNU_call_site_parameter:return "DW_TAG_GNU_call_site_parameter";
     default:
       {
 	static char buffer[100];
@@ -697,9 +700,9 @@ get_FORM_name (unsigned long form)
 }
 
 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));
@@ -710,13 +713,15 @@ display_block (unsigned char *data, unsigned long length)
 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;
-  unsigned long uvalue;
+  dwarf_vma uvalue;
   unsigned char *end = data + length;
   int need_frame_base = 0;
 
@@ -727,8 +732,8 @@ decode_location_expression (unsigned char * data,
       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:
@@ -767,11 +772,13 @@ decode_location_expression (unsigned char * data,
 	  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:
-	  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:
@@ -826,8 +833,8 @@ decode_location_expression (unsigned char * data,
 	  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:
@@ -936,7 +943,8 @@ decode_location_expression (unsigned char * data,
 	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:
@@ -971,29 +979,37 @@ decode_location_expression (unsigned char * data,
 	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:
-	  printf ("DW_OP_regx: %lu", read_leb128 (data, &bytes_read, 0));
+	  uvalue = read_leb128 (data, &bytes_read, 0);
 	  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;
-	  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;
-	  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:
-	  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:
@@ -1013,20 +1029,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.  */
-	  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.  */
-	  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.  */
-	  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");
@@ -1036,9 +1072,11 @@ decode_location_expression (unsigned char * data,
 	  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;
-	  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;
 
@@ -1067,17 +1105,88 @@ decode_location_expression (unsigned char * data,
 	  {
 	    int encoding;
 	    dwarf_vma addr;
-	
+
 	    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;
+	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", cu_offset + uvalue));
+	  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", cu_offset + uvalue));
+	  break;
 
 	  /* HP extensions.  */
 	case DW_OP_HP_is_value:
@@ -1136,15 +1245,15 @@ static unsigned char *
 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)
 {
-  unsigned long uvalue = 0;
+  dwarf_vma uvalue = 0;
   unsigned char *block_start = NULL;
   unsigned char * orig_data = data;
   unsigned int bytes_read;
@@ -1166,9 +1275,8 @@ read_and_display_attr_value (unsigned long attribute,
 	  data += offset_size;
 	}
       else
-	{
-	  error (_("Internal error: DWARF version is not 2, 3 or 4.\n"));
-	}
+	error (_("Internal error: DWARF version is not 2, 3 or 4.\n"));
+
       break;
 
     case DW_FORM_addr:
@@ -1231,7 +1339,7 @@ read_and_display_attr_value (unsigned long attribute,
     {
     case DW_FORM_ref_addr:
       if (!do_loc)
-	printf (" <0x%lx>", uvalue);
+	printf (" <0x%s>", dwarf_vmatoa ("x",uvalue));
       break;
 
     case DW_FORM_ref1:
@@ -1239,14 +1347,14 @@ read_and_display_attr_value (unsigned long attribute,
     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:
     case DW_FORM_sec_offset:
       if (!do_loc)
-	printf (" 0x%lx", uvalue);
+	printf (" 0x%s", dwarf_vmatoa ("x", uvalue));
       break;
 
     case DW_FORM_flag_present:
@@ -1256,7 +1364,7 @@ read_and_display_attr_value (unsigned long attribute,
     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:
@@ -1264,7 +1372,7 @@ read_and_display_attr_value (unsigned long attribute,
       if (!do_loc)
 	{
 	  uvalue = byte_get (data, 4);
-	  printf (" 0x%lx", uvalue);
+	  printf (" 0x%s", dwarf_vmatoa ("x", uvalue));
 	  printf (" 0x%lx", (unsigned long) byte_get (data + 4, 4));
 	}
       if ((do_loc || do_debug_loc || do_debug_ranges)
@@ -1273,7 +1381,7 @@ read_and_display_attr_value (unsigned long attribute,
 	  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;
@@ -1323,8 +1431,9 @@ read_and_display_attr_value (unsigned long attribute,
 
     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_indirect:
@@ -1352,7 +1461,8 @@ read_and_display_attr_value (unsigned long attribute,
     }
 
   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)
 	{
@@ -1366,6 +1476,10 @@ 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_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 (form == DW_FORM_data4
 	      || form == DW_FORM_data8
 	      || form == DW_FORM_sec_offset)
@@ -1377,7 +1491,7 @@ read_and_display_attr_value (unsigned long attribute,
 	      if (lmax == 0 || num >= lmax)
 		{
 		  lmax += 1024;
-		  debug_info_p->loc_offsets = (long unsigned int *)
+		  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 *)
@@ -1408,7 +1522,7 @@ read_and_display_attr_value (unsigned long attribute,
 	      if (lmax == 0 || num >= lmax)
 		{
 		  lmax += 1024;
-		  debug_info_p->range_lists = (long unsigned int *)
+		  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;
@@ -1447,7 +1561,8 @@ read_and_display_attr_value (unsigned long attribute,
 	  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;
@@ -1485,9 +1600,10 @@ read_and_display_attr_value (unsigned long attribute,
 	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
-	    printf ("(Unknown: %lx)", uvalue);
+	    printf ("(Unknown: %s)", dwarf_vmatoa ("x", uvalue));
 	  break;
 	}
       break;
@@ -1609,6 +1725,10 @@ 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_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 (form == DW_FORM_data4
 	  || form == DW_FORM_data8
 	  || form == DW_FORM_sec_offset)
@@ -1627,6 +1747,8 @@ read_and_display_attr_value (unsigned long attribute,
 	  printf ("(");
 	  need_frame_base = decode_location_expression (block_start,
 							pointer_size,
+							offset_size,
+							dwarf_version,
 							uvalue,
 							cu_offset, section);
 	  printf (")");
@@ -1646,8 +1768,9 @@ read_and_display_attr_value (unsigned long attribute,
 	  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;
@@ -1824,6 +1947,14 @@ get_AT_name (unsigned long attribute)
     case DW_AT_GNU_odr_signature:		return "DW_AT_GNU_odr_signature";
     case DW_AT_use_GNAT_descriptive_type:	return "DW_AT_use_GNAT_descriptive_type";
     case DW_AT_GNAT_descriptive_type:		return "DW_AT_GNAT_descriptive_type";
+    case DW_AT_GNU_call_site_value:		return "DW_AT_GNU_call_site_value";
+    case DW_AT_GNU_call_site_data_value:	return "DW_AT_GNU_call_site_data_value";
+    case DW_AT_GNU_call_site_target:		return "DW_AT_GNU_call_site_target";
+    case DW_AT_GNU_call_site_target_clobbered:	return "DW_AT_GNU_call_site_target_clobbered";
+    case DW_AT_GNU_tail_call:			return "DW_AT_GNU_tail_call";
+    case DW_AT_GNU_all_tail_call_sites:		return "DW_AT_GNU_all_tail_call_sites";
+    case DW_AT_GNU_all_call_sites:		return "DW_AT_GNU_all_call_sites";
+    case DW_AT_GNU_all_source_call_sites:	return "DW_AT_GNU_all_source_call_sites";
 
       /* UPC extension.  */
     case DW_AT_upc_threads_scaled:	return "DW_AT_upc_threads_scaled";
@@ -1848,9 +1979,9 @@ 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,
@@ -1890,7 +2021,7 @@ process_debug_info (struct dwarf_section *section,
       && 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;
@@ -1908,7 +2039,8 @@ process_debug_info (struct dwarf_section *section,
 	    }
 	  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
@@ -1919,7 +2051,8 @@ process_debug_info (struct dwarf_section *section,
 	     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;
 	    }
 	}
@@ -1943,7 +2076,8 @@ process_debug_info (struct dwarf_section *section,
 
   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);
     }
@@ -1961,12 +2095,12 @@ process_debug_info (struct dwarf_section *section,
       DWARF2_Internal_CompUnit compunit;
       unsigned char *hdrptr;
       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;
       unsigned char signature[8] = { 0 };
-      unsigned long type_offset = 0;
+      dwarf_vma type_offset = 0;
 
       hdrptr = start;
 
@@ -2018,6 +2152,8 @@ process_debug_info (struct dwarf_section *section,
 	  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].loc_offsets = NULL;
 	  debug_information [unit].have_frame_base = NULL;
@@ -2028,13 +2164,16 @@ process_debug_info (struct dwarf_section *section,
 	  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 (_("   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);
 	  if (do_types)
 	    {
@@ -2043,15 +2182,18 @@ process_debug_info (struct dwarf_section *section,
 	      for (i = 0; i < 8; i++)
 	        printf ("%02x", signature[i]);
 	      printf ("\n");
-	      printf (_("   Type Offset:   0x%lx\n"), type_offset);
+             printf (_("   Type Offset:   0x%s\n"),
+                     dwarf_vmatoa ("x", type_offset));
 	    }
 	}
 
       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;
@@ -2061,8 +2203,9 @@ process_debug_info (struct dwarf_section *section,
 	  && 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;
 	}
 
@@ -2082,6 +2225,8 @@ process_debug_info (struct dwarf_section *section,
 	   + debug_displays [abbrev_sec].section.size);
 
       level = 0;
+      last_level = level;
+      saved_level = -1;
       while (tags < start)
 	{
 	  unsigned int bytes_read;
@@ -2089,6 +2234,7 @@ process_debug_info (struct dwarf_section *section,
 	  unsigned long die_offset;
 	  abbrev_entry *entry;
 	  abbrev_attr *attr;
+	  int do_printing = 1;
 
 	  die_offset = tags - section_begin;
 
@@ -2125,12 +2271,30 @@ process_debug_info (struct dwarf_section *section,
 			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)
-	    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.  */
@@ -2141,7 +2305,7 @@ process_debug_info (struct dwarf_section *section,
 
 	  if (entry == NULL)
 	    {
-	      if (!do_loc)
+	      if (!do_loc && do_printing)
 		{
 		  printf ("\n");
 		  fflush (stdout);
@@ -2151,8 +2315,8 @@ process_debug_info (struct dwarf_section *section,
 	      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)
 	    {
@@ -2172,9 +2336,15 @@ process_debug_info (struct dwarf_section *section,
 
 	  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.  */
-		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,
@@ -2182,8 +2352,8 @@ process_debug_info (struct dwarf_section *section,
 					    compunit.cu_pointer_size,
 					    offset_size,
 					    compunit.cu_version,
-					    debug_information + unit,
-					    do_loc, section);
+					    arg,
+					    do_loc || ! do_printing, section);
 	    }
 
  	  if (entry->children)
@@ -2199,9 +2369,7 @@ process_debug_info (struct dwarf_section *section,
     num_debug_info_entries = num_units;
 
   if (!do_loc)
-    {
-      printf ("\n");
-    }
+    printf ("\n");
 
   return 1;
 }
@@ -2328,7 +2496,7 @@ display_debug_lines_raw (struct dwarf_section *section,
       linfo.li_line_base >>= 24;
 
       printf (_("  Offset:                      0x%lx\n"), hdroff);
-      printf (_("  Length:                      %ld\n"), linfo.li_length);
+      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);
@@ -2362,7 +2530,7 @@ display_debug_lines_raw (struct dwarf_section *section,
 
 	  while (*data != 0)
 	    {
-	      printf (_("  %s\n"), data);
+	      printf ("  %s\n", data);
 
 	      data += strlen ((char *) data) + 1;
 	    }
@@ -2384,18 +2552,21 @@ display_debug_lines_raw (struct dwarf_section *section,
 	      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;
 
-	      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 (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
+	      printf ("%s\t",
+		      dwarf_vmatoa ("u", read_leb128 (data, & bytes_read, 0)));
 	      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;
-	      printf (_("%s\n"), name);
+	      printf ("%s\n", name);
 	    }
 	}
 
@@ -2408,8 +2579,8 @@ display_debug_lines_raw (struct dwarf_section *section,
       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++;
@@ -2422,8 +2593,10 @@ display_debug_lines_raw (struct dwarf_section *section,
 		{
 		  uladv *= linfo.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);
+		  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
 		{
@@ -2434,14 +2607,16 @@ display_debug_lines_raw (struct dwarf_section *section,
 		  state_machine_regs.op_index
 		    = (state_machine_regs.op_index + uladv)
 		      % linfo.li_max_ops_per_insn;
-		  printf (_("  Special opcode %d: advance Address by %lu to 0x%lx[%d]"),
-			  op_code, uladv, state_machine_regs.address,
+		  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;
-	      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)
 	    {
@@ -2460,8 +2635,9 @@ display_debug_lines_raw (struct dwarf_section *section,
 		{
 		  uladv *= linfo.li_min_insn_length;
 		  state_machine_regs.address += uladv;
-		  printf (_("  Advance PC by %lu to 0x%lx\n"), uladv,
-			  state_machine_regs.address);
+		  printf (_("  Advance PC by %s to 0x%s\n"),
+			  dwarf_vmatoa ("u", uladv),
+			  dwarf_vmatoa ("x", state_machine_regs.address));
 		}
 	      else
 		{
@@ -2472,39 +2648,42 @@ display_debug_lines_raw (struct dwarf_section *section,
 		  state_machine_regs.op_index
 		    = (state_machine_regs.op_index + uladv)
 		      % linfo.li_max_ops_per_insn;
-		  printf (_("  Advance PC by %lu to 0x%lx[%d]\n"), uladv,
-			  state_machine_regs.address,
+		  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:
-	      adv = read_leb128 (data, & bytes_read, 1);
+	      adv = read_sleb128 (data, & bytes_read);
 	      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;
-	      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;
-	      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;
-	      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;
 
@@ -2519,8 +2698,9 @@ display_debug_lines_raw (struct dwarf_section *section,
 		{
 		  uladv *= linfo.li_min_insn_length;
 		  state_machine_regs.address += uladv;
-		  printf (_("  Advance PC by constant %lu to 0x%lx\n"), uladv,
-			  state_machine_regs.address);
+		  printf (_("  Advance PC by constant %s to 0x%s\n"),
+			  dwarf_vmatoa ("u", uladv),
+			  dwarf_vmatoa ("x", state_machine_regs.address));
 		}
 	      else
 		{
@@ -2531,8 +2711,9 @@ display_debug_lines_raw (struct dwarf_section *section,
 		  state_machine_regs.op_index
 		    = (state_machine_regs.op_index + uladv)
 		      % linfo.li_max_ops_per_insn;
-		  printf (_("  Advance PC by constant %lu to 0x%lx[%d]\n"),
-			  uladv, state_machine_regs.address,
+		  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;
@@ -2542,8 +2723,9 @@ display_debug_lines_raw (struct dwarf_section *section,
 	      data += 2;
 	      state_machine_regs.address += uladv;
 	      state_machine_regs.op_index = 0;
-	      printf (_("  Advance PC by fixed size amount %lu to 0x%lx\n"),
-		      uladv, state_machine_regs.address);
+	      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:
@@ -2557,7 +2739,7 @@ display_debug_lines_raw (struct dwarf_section *section,
 	    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:
@@ -2565,7 +2747,8 @@ display_debug_lines_raw (struct dwarf_section *section,
 
 	      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;
 		}
@@ -2581,10 +2764,10 @@ display_debug_lines_raw (struct dwarf_section *section,
 
 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.  */
@@ -2773,14 +2956,11 @@ display_debug_lines_decoded (struct dwarf_section *section,
           else
             {
               if (do_wide || strlen ((char *) directory_table[0]) < 76)
-                {
-                  printf (_("CU: %s/%s:\n"), directory_table[0],
-                          file_table[0].name);
-                }
+		printf (_("CU: %s/%s:\n"), directory_table[0],
+			file_table[0].name);
               else
-                {
-                  printf (_("%s:\n"), file_table[0].name);
-                }
+		printf ("%s:\n", file_table[0].name);
+
               printf (_("File name                            Line number    Starting address\n"));
             }
         }
@@ -2864,7 +3044,7 @@ display_debug_lines_decoded (struct dwarf_section *section,
                       op_code_data += bytes_read;
                       read_leb128 (op_code_data, & bytes_read, 0);
 
-                      printf (_("%s:\n"), directory_table[dir_index]);
+                      printf ("%s:\n", directory_table[dir_index]);
                       break;
                     }
                   default:
@@ -2898,7 +3078,7 @@ display_debug_lines_decoded (struct dwarf_section *section,
               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;
@@ -2910,13 +3090,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.  */
-                  printf (_("\n./%s:[++]\n"),
+                  printf ("\n./%s:[++]\n",
                           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);
                 }
@@ -2981,7 +3161,8 @@ display_debug_lines_decoded (struct dwarf_section *section,
 
               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;
                 }
@@ -3016,24 +3197,24 @@ display_debug_lines_decoded (struct dwarf_section *section,
               if (!do_wide || (fileNameLength <= MAX_FILENAME_LENGTH))
                 {
 		  if (linfo.li_max_ops_per_insn == 1)
-		    printf (_("%-35s  %11d  %#18lx\n"), newFileName,
-			    state_machine_regs.line,
+		    printf ("%-35s  %11d  %#18" DWARF_VMA_FMT "x\n",
+			    newFileName, state_machine_regs.line,
 			    state_machine_regs.address);
 		  else
-		    printf (_("%-35s  %11d  %#18lx[%d]\n"), newFileName,
-			    state_machine_regs.line,
+		    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
                 {
 		  if (linfo.li_max_ops_per_insn == 1)
-		    printf (_("%s  %11d  %#18lx\n"), newFileName,
-			    state_machine_regs.line,
+		    printf ("%s  %11d  %#18" DWARF_VMA_FMT "x\n",
+			    newFileName, state_machine_regs.line,
 			    state_machine_regs.address);
 		  else
-		    printf (_("%s  %11d  %#18lx[%d]\n"), newFileName,
-			    state_machine_regs.line,
+		    printf ("%s  %11d  %#18" DWARF_VMA_FMT "x[%d]\n",
+			    newFileName, state_machine_regs.line,
 			    state_machine_regs.address,
 			    state_machine_regs.op_index);
                 }
@@ -3139,7 +3320,7 @@ display_debug_pubnames (struct dwarf_section *section,
 	  && num_debug_info_entries > 0
 	  && 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"),
-	      names.pn_offset, section->name);
+	      (unsigned long) names.pn_offset, section->name);
 
       names.pn_size = byte_get (data, offset_size);
       data += offset_size;
@@ -3160,13 +3341,13 @@ display_debug_pubnames (struct dwarf_section *section,
 	}
 
       printf (_("  Length:                              %ld\n"),
-	      names.pn_length);
+	      (long) names.pn_length);
       printf (_("  Version:                             %d\n"),
 	      names.pn_version);
       printf (_("  Offset into .debug_info section:     0x%lx\n"),
-	      names.pn_offset);
+	      (unsigned long) names.pn_offset);
       printf (_("  Size of area in .debug_info section: %ld\n"),
-	      names.pn_size);
+	      (long) names.pn_size);
 
       printf (_("\n    Offset\tName\n"));
 
@@ -3289,13 +3470,13 @@ display_debug_abbrev (struct dwarf_section *section,
 	{
 	  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)
-	    printf (_("    %-18s %s\n"),
+	    printf ("    %-18s %s\n",
 		    get_AT_name (attr->attribute),
 		    get_FORM_name (attr->form));
 	}
@@ -3307,6 +3488,19 @@ display_debug_abbrev (struct dwarf_section *section,
   return 1;
 }
 
+/* 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)
 {
@@ -3319,9 +3513,11 @@ display_debug_loc (struct dwarf_section *section, void *file)
   unsigned int first = 0;
   unsigned int i;
   unsigned int j;
+  unsigned int k;
   int seen_first_offset = 0;
-  int use_debug_info = 1;
+  int locs_sorted = 1;
   unsigned char *next;
+  unsigned int *array = NULL;
 
   bytes = section->size;
   section_end = start + bytes;
@@ -3347,10 +3543,11 @@ display_debug_loc (struct dwarf_section *section, void *file)
       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.  */
-      if (use_debug_info && num != 0)
+      if (locs_sorted && num != 0)
 	{
 	  if (!seen_first_offset)
 	    {
@@ -3368,7 +3565,7 @@ display_debug_loc (struct dwarf_section *section, void *file)
 	      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];
@@ -3376,19 +3573,18 @@ 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)
-    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 (_("    Offset   Begin    End      Expression\n"));
 
@@ -3400,6 +3596,8 @@ display_debug_loc (struct dwarf_section *section, void *file)
       unsigned short length;
       unsigned long offset;
       unsigned int pointer_size;
+      unsigned int offset_size;
+      int dwarf_version;
       unsigned long cu_offset;
       unsigned long base_address;
       int need_frame_base;
@@ -3407,9 +3605,25 @@ display_debug_loc (struct dwarf_section *section, void *file)
 
       pointer_size = debug_information [i].pointer_size;
       cu_offset = debug_information [i].cu_offset;
+      offset_size = debug_information [i].offset_size;
+      dwarf_version = debug_information [i].dwarf_version;
+      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;
@@ -3498,6 +3712,8 @@ display_debug_loc (struct dwarf_section *section, void *file)
 	      putchar ('(');
 	      need_frame_base = decode_location_expression (start,
 							    pointer_size,
+							    offset_size,
+							    dwarf_version,
 							    length,
 							    cu_offset, section);
 	      putchar (')');
@@ -3521,6 +3737,7 @@ display_debug_loc (struct dwarf_section *section, void *file)
     warn (_("There are %ld unused bytes at the end of section %s\n"),
 	  (long) (section_end - start), section->name);
   putchar ('\n');
+  free (array);
   return 1;
 }
 
@@ -3653,7 +3870,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"),
-	      arange.ar_info_offset, section->name);
+	      (unsigned long) arange.ar_info_offset, section->name);
 
       arange.ar_pointer_size = byte_get (hdrptr, 1);
       hdrptr += 1;
@@ -3667,9 +3884,11 @@ display_debug_aranges (struct dwarf_section *section,
 	  break;
 	}
 
-      printf (_("  Length:                   %ld\n"), arange.ar_length);
+      printf (_("  Length:                   %ld\n"),
+	      (long) arange.ar_length);
       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);
 
@@ -3724,13 +3943,13 @@ display_debug_aranges (struct dwarf_section *section,
    sorting purposes.  */
 
 struct range_entry
-  {
-    /* The debug_information[x].range_lists[y] value.  */
-    unsigned long ranges_offset;
+{
+  /* 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;
-  };
+  /* 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.  */
 
@@ -3961,6 +4180,13 @@ static const char *const dwarf_regnames_i386[] =
   "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",
@@ -3983,6 +4209,13 @@ static const char *const dwarf_regnames_x86_64[] =
   "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)
 {
@@ -3990,14 +4223,12 @@ init_dwarf_regnames (unsigned int e_machine)
     {
     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:
     case EM_L1OM:
-      dwarf_regnames = dwarf_regnames_x86_64;
-      dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_x86_64);
+      init_dwarf_regnames_x86_64 ();
       break;
 
     default:
@@ -4098,7 +4329,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 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,
@@ -4334,9 +4565,7 @@ display_debug_frames (struct dwarf_section *section,
 	      segment_selector = byte_get (start, fc->segment_size);
 	      start += fc->segment_size;
 	    }
-	  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);
+	  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;
@@ -4554,9 +4783,7 @@ display_debug_frames (struct dwarf_section *section,
 	      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);
@@ -4757,8 +4984,8 @@ display_debug_frames (struct dwarf_section *section,
 	      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;
@@ -4774,7 +5001,7 @@ display_debug_frames (struct dwarf_section *section,
 		{
 		  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");
 		}
@@ -4792,8 +5019,8 @@ display_debug_frames (struct dwarf_section *section,
 		{
 		  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')
@@ -4913,6 +5140,144 @@ display_debug_frames (struct dwarf_section *section,
 #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:
+      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)
+		printf (" T%lu", (unsigned long) (cu - cu_list_elements));
+	      else
+		printf (" %lu", (unsigned long) cu);
+	    }
+	  printf ("\n");
+	}
+    }
+
+  return 1;
+}
+
 static int
 display_debug_not_supported (struct dwarf_section *section,
 			     void *file ATTRIBUTE_UNUSED)
@@ -4953,28 +5318,6 @@ xcrealloc (void *ptr, size_t nmemb, size_t 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)
 {
@@ -5038,6 +5381,8 @@ dwarf_select_sections_by_names (const char *names)
 	 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 },
@@ -5046,21 +5391,21 @@ dwarf_select_sections_by_names (const char *names)
     };
 
   const char *p;
-  
+
   p = names;
   while (*p)
     {
       const debug_dump_long_opts * entry;
-      
+
       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;
-	      
+
 	      /* The --debug-dump=frames-interp option also
 		 enables the --debug-dump=frames option.  */
 	      if (do_debug_frames_interp)
@@ -5070,7 +5415,7 @@ dwarf_select_sections_by_names (const char *names)
 	      break;
 	    }
 	}
-      
+
       if (entry->option == NULL)
 	{
 	  warn (_("Unrecognized debug option '%s'\n"), p);
@@ -5078,7 +5423,7 @@ dwarf_select_sections_by_names (const char *names)
 	  if (p == NULL)
 	    break;
 	}
-      
+
       if (*p == ',')
 	p++;
     }
@@ -5095,53 +5440,53 @@ dwarf_select_sections_by_letters (const char *letters)
       case 'i':
 	do_debug_info = 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_DECODED;
 	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_ranges = 1;
 	break;
-	
+
       case 'F':
 	do_debug_frames_interp = 1;
       case 'f':
 	do_debug_frames = 1;
 	break;
-	
+
       case 'm':
 	do_debug_macinfo = 1;
 	break;
-	
+
       case 's':
 	do_debug_str = 1;
 	break;
-	
+
       case 'o':
 	do_debug_loc = 1;
 	break;
-	
+
       default:
 	warn (_("Unrecognized debug option '%s'\n"), optarg);
 	break;
@@ -5162,6 +5507,7 @@ dwarf_select_sections_all (void)
   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;
@@ -5201,6 +5547,8 @@ struct dwarf_section_display debug_displays[] =
     display_debug_types,		&do_debug_info,		1 },
   { { ".debug_weaknames",	".zdebug_weaknames",	NULL, NULL, 0, 0 },
     display_debug_not_supported,	NULL,			0 },
+  { { ".gdb_index",		"",			NULL, NULL, 0, 0 },
+    display_gdb_index,			&do_gdb_index,		0 },
   { { ".trace_info",		"",			NULL, NULL, 0, 0 },
     display_trace_info,			&do_trace_info,		1 },
   { { ".trace_abbrev",		"",			NULL, NULL, 0, 0 },