DWARF-5 basic functionality

binutils/
2017-02-23  Jan Kratochvil  <jan.kratochvil@redhat.com>

	* dwarf.c (fetch_indirect_line_string): New function.
	(abbrev_attr): New field implicit_const.
	(add_abbrev_attr): New parameter implicit_const.
	(process_abbrev_section): Support DW_FORM_implicit_const.
	(decode_location_expression): Support DW_OP_entry_value.
	(read_and_display_attr_value): Add parameter implicit_const.  Support
	DW_FORM_line_strp and DW_FORM_implicit_const.
	(read_and_display_attr): Add parameter implicit_const.
	(process_debug_info): Support line_str and DWARF-5.
	(read_debug_line_header): Support DWARF-5.
	(display_formatted_table): New function.
	(display_debug_lines_raw): New parameter file.  Support DWARF-5.
	(display_debug_lines_decoded): New parameter fileptr.  Support DWARF-5.
	(display_debug_lines): Pass file parameter.
	(display_debug_macro): Update read_and_display_attr_value caller.
	(display_debug_abbrev): Support DW_FORM_implicit_const.
	(display_loclists_list): New function.
	(display_loc_list): Support .debug_loclists.
	(display_debug_ranges_list): New function from display_debug_ranges.
	(display_debug_rnglists_list): New function.
	(display_debug_ranges): Support .debug_rnglists.
	(debug_displays): Add .debug_line_str, .debug_loclists and
	.debug_rnglists.
	* dwarf.h: Include dwarf2.h
	(DWARF2_Internal_LineInfo): Add li_offset_size.
	(DWARF2_Internal_CompUnit): Add cu_unit_type.
	(enum dwarf_section_display_enum): Add line_str.
	* readelf.c (process_section_headers): Add rnglists and loclists.

1 files changed, 956 insertions, 204 deletions

diff --git a/binutils/dwarf.c b/binutils/dwarf.c
index d27313fff4..420ae5d681 100644
--- a/binutils/dwarf.c
+++ b/binutils/dwarf.c
@@ -611,6 +611,24 @@ fetch_indirect_string (dwarf_vma offset)
   return (const unsigned char *) section->start + offset;
 }
 
+static const unsigned char *
+fetch_indirect_line_string (dwarf_vma offset)
+{
+  struct dwarf_section *section = &debug_displays [line_str].section;
+
+  if (section->start == NULL)
+    return (const unsigned char *) _("<no .debug_line_str section>");
+
+  if (offset > section->size)
+    {
+      warn (_("DW_FORM_line_strp offset too big: %s\n"),
+	    dwarf_vmatoa ("x", offset));
+      return (const unsigned char *) _("<offset is too big>");
+    }
+
+  return (const unsigned char *) section->start + offset;
+}
+
 static const char *
 fetch_indexed_string (dwarf_vma idx, struct cu_tu_set *this_set,
 		      dwarf_vma offset_size, int dwo)
@@ -677,6 +695,7 @@ typedef struct abbrev_attr
 {
   unsigned long attribute;
   unsigned long form;
+  bfd_signed_vma implicit_const;
   struct abbrev_attr *next;
 }
 abbrev_attr;
@@ -746,7 +765,8 @@ add_abbrev (unsigned long number, unsigned long tag, int children)
 }
 
 static void
-add_abbrev_attr (unsigned long attribute, unsigned long form)
+add_abbrev_attr (unsigned long attribute, unsigned long form,
+		 bfd_signed_vma implicit_const)
 {
   abbrev_attr *attr;
 
@@ -757,6 +777,7 @@ add_abbrev_attr (unsigned long attribute, unsigned long form)
 
   attr->attribute = attribute;
   attr->form      = form;
+  attr->implicit_const = implicit_const;
   attr->next      = NULL;
 
   if (last_abbrev->first_attr == NULL)
@@ -809,6 +830,8 @@ process_abbrev_section (unsigned char *start, unsigned char *end)
       do
 	{
 	  unsigned long form;
+	  /* Initialize it due to a false compiler warning.  */
+	  bfd_signed_vma implicit_const = -1;
 
 	  attribute = read_uleb128 (start, & bytes_read, end);
 	  start += bytes_read;
@@ -820,7 +843,15 @@ process_abbrev_section (unsigned char *start, unsigned char *end)
 	  if (start == end)
 	    break;
 
-	  add_abbrev_attr (attribute, form);
+	  if (form == DW_FORM_implicit_const)
+	    {
+	      implicit_const = read_sleb128 (start, & bytes_read, end);
+	      start += bytes_read;
+	      if (start == end)
+		break;
+	    }
+
+	  add_abbrev_attr (attribute, form, implicit_const);
 	}
       while (attribute != 0);
     }
@@ -1314,13 +1345,15 @@ decode_location_expression (unsigned char * data,
 						   &bytes_read, end)));
 	  data += bytes_read;
 	  break;
+	case DW_OP_entry_value:
 	case DW_OP_GNU_entry_value:
 	  uvalue = read_uleb128 (data, &bytes_read, end);
 	  data += bytes_read;
 	  /* PR 17531: file: 0cc9cd00.  */
 	  if (uvalue > (dwarf_vma) (end - data))
 	    uvalue = end - data;
-	  printf ("DW_OP_GNU_entry_value: (");
+	  printf ("%s: (", (op == DW_OP_entry_value ? "DW_OP_entry_value"
+						    : "DW_OP_GNU_entry_value"));
 	  if (decode_location_expression (data, pointer_size, offset_size,
 					  dwarf_version, uvalue,
 					  cu_offset, section))
@@ -1498,6 +1531,7 @@ add64 (dwarf_vma * high_bits, dwarf_vma * low_bits, dwarf_vma inc)
 static unsigned char *
 read_and_display_attr_value (unsigned long attribute,
 			     unsigned long form,
+			     dwarf_signed_vma implicit_const,
 			     unsigned char * data,
 			     unsigned char * end,
 			     dwarf_vma cu_offset,
@@ -1540,6 +1574,7 @@ read_and_display_attr_value (unsigned long attribute,
       break;
 
     case DW_FORM_strp:
+    case DW_FORM_line_strp:
     case DW_FORM_sec_offset:
     case DW_FORM_GNU_ref_alt:
     case DW_FORM_GNU_strp_alt:
@@ -1587,8 +1622,13 @@ read_and_display_attr_value (unsigned long attribute,
       data += bytes_read;
       if (!do_loc)
 	printf ("%c%s", delimiter, get_FORM_name (form));
-      return read_and_display_attr_value (attribute, form, data, end,
-					  cu_offset, pointer_size,
+      if (form == DW_FORM_implicit_const)
+	{
+	  implicit_const = read_sleb128 (data, & bytes_read, end);
+	  data += bytes_read;
+	}
+      return read_and_display_attr_value (attribute, form, implicit_const, data,
+					  end, cu_offset, pointer_size,
 					  offset_size, dwarf_version,
 					  debug_info_p, do_loc,
 					  section, this_set, delimiter);
@@ -1635,6 +1675,11 @@ read_and_display_attr_value (unsigned long attribute,
 	printf ("%c%s", delimiter, dwarf_vmatoa ("d", uvalue));
       break;
 
+    case DW_FORM_implicit_const:
+      if (!do_loc)
+	printf ("%c%s", delimiter, dwarf_vmatoa ("d", implicit_const));
+      break;
+
     case DW_FORM_ref8:
     case DW_FORM_data8:
       if (!do_loc)
@@ -1768,6 +1813,13 @@ read_and_display_attr_value (unsigned long attribute,
 		fetch_indirect_string (uvalue));
       break;
 
+    case DW_FORM_line_strp:
+      if (!do_loc)
+	printf (_("%c(indirect line string, offset: 0x%s): %s"), delimiter,
+		dwarf_vmatoa ("x", uvalue),
+		fetch_indirect_line_string (uvalue));
+      break;
+
     case DW_FORM_GNU_str_index:
       if (!do_loc)
 	{
@@ -2216,6 +2268,7 @@ get_AT_name (unsigned long attribute)
 static unsigned char *
 read_and_display_attr (unsigned long attribute,
 		       unsigned long form,
+		       dwarf_signed_vma implicit_const,
 		       unsigned char * data,
 		       unsigned char * end,
 		       dwarf_vma cu_offset,
@@ -2229,7 +2282,7 @@ read_and_display_attr (unsigned long attribute,
 {
   if (!do_loc)
     printf ("   %-18s:", get_AT_name (attribute));
-  data = read_and_display_attr_value (attribute, form, data, end,
+  data = read_and_display_attr_value (attribute, form, implicit_const, data, end,
 				      cu_offset, pointer_size, offset_size,
 				      dwarf_version, debug_info_p,
 				      do_loc, section, this_set, ' ');
@@ -2328,6 +2381,7 @@ process_debug_info (struct dwarf_section *section,
 	printf (_("Contents of the %s section:\n\n"), section->name);
 
       load_debug_section (str, file);
+      load_debug_section (line_str, file);
       load_debug_section (str_dwo, file);
       load_debug_section (str_index, file);
       load_debug_section (str_index_dwo, file);
@@ -2380,6 +2434,20 @@ process_debug_info (struct dwarf_section *section,
 
       this_set = find_cu_tu_set_v2 (cu_offset, do_types);
 
+      if (compunit.cu_version < 5)
+	{
+	  compunit.cu_unit_type = DW_UT_compile;
+	  /* Initialize it due to a false compiler warning.  */
+	  compunit.cu_pointer_size = -1;
+	}
+      else
+	{
+	  SAFE_BYTE_GET_AND_INC (compunit.cu_unit_type, hdrptr, 1, end);
+	  do_types = (compunit.cu_unit_type == DW_UT_type);
+
+	  SAFE_BYTE_GET_AND_INC (compunit.cu_pointer_size, hdrptr, 1, end);
+	}
+
       SAFE_BYTE_GET_AND_INC (compunit.cu_abbrev_offset, hdrptr, offset_size, end);
 
       if (this_set == NULL)
@@ -2393,7 +2461,9 @@ process_debug_info (struct dwarf_section *section,
 	  abbrev_size = this_set->section_sizes [DW_SECT_ABBREV];
 	}
 
-      SAFE_BYTE_GET_AND_INC (compunit.cu_pointer_size, hdrptr, 1, end);
+      if (compunit.cu_version < 5)
+	SAFE_BYTE_GET_AND_INC (compunit.cu_pointer_size, hdrptr, 1, end);
+
       /* PR 17512: file: 001-108546-0.001:0.1.  */
       if (compunit.cu_pointer_size < 2 || compunit.cu_pointer_size > 8)
 	{
@@ -2492,9 +2562,7 @@ process_debug_info (struct dwarf_section *section,
 	  start = end;
 	}
 
-      if (compunit.cu_version != 2
-	  && compunit.cu_version != 3
-	  && compunit.cu_version != 4)
+      if (compunit.cu_version < 2 || compunit.cu_version > 5)
 	{
 	  warn (_("CU at offset %s contains corrupt or "
 		  "unsupported version number: %d.\n"),
@@ -2502,6 +2570,15 @@ process_debug_info (struct dwarf_section *section,
 	  continue;
 	}
 
+      if (compunit.cu_unit_type != DW_UT_compile
+	  && compunit.cu_unit_type != DW_UT_type)
+	{
+	  warn (_("CU at offset %s contains corrupt or "
+		  "unsupported unit type: %d.\n"),
+		dwarf_vmatoa ("x", cu_offset), compunit.cu_unit_type);
+	  continue;
+	}
+
       free_abbrevs ();
 
       /* Process the abbrevs used by this compilation unit.  */
@@ -2655,6 +2732,7 @@ process_debug_info (struct dwarf_section *section,
 
 	      tags = read_and_display_attr (attr->attribute,
 					    attr->form,
+					    attr->implicit_const,
 					    tags,
 					    end,
 					    cu_offset,
@@ -2742,8 +2820,8 @@ read_debug_line_header (struct dwarf_section * section,
 			unsigned char ** end_of_sequence)
 {
   unsigned char *hdrptr;
-  unsigned int offset_size;
   unsigned int initial_length_size;
+  unsigned char address_size, segment_selector_size;
 
   /* Extract information from the Line Number Program Header.
      (section 6.2.4 in the Dwarf3 doc).  */
@@ -2756,12 +2834,12 @@ read_debug_line_header (struct dwarf_section * section,
     {
       /* This section is 64-bit DWARF 3.  */
       SAFE_BYTE_GET_AND_INC (linfo->li_length, hdrptr, 8, end);
-      offset_size = 8;
+      linfo->li_offset_size = 8;
       initial_length_size = 12;
     }
   else
     {
-      offset_size = 4;
+      linfo->li_offset_size = 4;
       initial_length_size = 4;
     }
 
@@ -2773,7 +2851,7 @@ read_debug_line_header (struct dwarf_section * section,
 	 comprised of several different .debug_line.* sections, (some of
 	 which may be removed by linker garbage collection), and a relocation
 	 is used to compute the correct length once that is done.  */
-      if (reloc_at (section, (hdrptr - section->start) - offset_size))
+      if (reloc_at (section, (hdrptr - section->start) - linfo->li_offset_size))
 	{
 	  linfo->li_length = (end - data) - initial_length_size;
 	}
@@ -2790,13 +2868,30 @@ read_debug_line_header (struct dwarf_section * section,
 
   if (linfo->li_version != 2
       && linfo->li_version != 3
-      && linfo->li_version != 4)
+      && linfo->li_version != 4
+      && linfo->li_version != 5)
     {
-      warn (_("Only DWARF version 2, 3 and 4 line info is currently supported.\n"));
+      warn (_("Only DWARF version 2, 3, 4 and 5 line info "
+	      "is currently supported.\n"));
       return NULL;
     }
 
-  SAFE_BYTE_GET_AND_INC (linfo->li_prologue_length, hdrptr, offset_size, end);
+  if (linfo->li_version >= 5)
+    {
+      SAFE_BYTE_GET_AND_INC (address_size, hdrptr, 1, end);
+
+      SAFE_BYTE_GET_AND_INC (segment_selector_size, hdrptr, 1, end);
+      if (segment_selector_size != 0)
+	{
+	  warn (_("The %s section contains "
+		  "unsupported segment selector size: %d.\n"),
+		section->name, segment_selector_size);
+	  return 0;
+	}
+    }
+
+  SAFE_BYTE_GET_AND_INC (linfo->li_prologue_length, hdrptr,
+			 linfo->li_offset_size, end);
   SAFE_BYTE_GET_AND_INC (linfo->li_min_insn_length, hdrptr, 1, end);
 
   if (linfo->li_version >= 4)
@@ -2830,10 +2925,126 @@ read_debug_line_header (struct dwarf_section * section,
   return hdrptr;
 }
 
+static unsigned char *
+display_formatted_table (unsigned char *data,
+			 unsigned char *start, unsigned char *end,
+			 const DWARF2_Internal_LineInfo *linfo,
+			 struct dwarf_section *section, const char *what)
+{
+  unsigned char *format_start, format_count, *format, formati;
+  dwarf_vma data_count, datai;
+  unsigned int bytes_read, namepass, last_entry = 0;
+
+  SAFE_BYTE_GET_AND_INC (format_count, data, 1, end);
+  format_start = data;
+  for (formati = 0; formati < format_count; formati++)
+    {
+      read_uleb128 (data, & bytes_read, end);
+      data += bytes_read;
+      read_uleb128 (data, & bytes_read, end);
+      data += bytes_read;
+      if (data == end)
+	{
+	  warn (_("Corrupt %s entry format table entry\n"), what);
+	  return data;
+	}
+    }
+
+  data_count = read_uleb128 (data, & bytes_read, end);
+  data += bytes_read;
+  if (data == end)
+    {
+      warn (_("Corrupt %s list\n"), what);
+      return data;
+    }
+
+  if (data_count == 0)
+    {
+      printf (_("\n The %s Table is empty.\n"), what);
+      return data;
+    }
+
+  printf (_("\n The %s Table (offset 0x%lx):\n"), what,
+	  (long)(data - start));
+
+  printf (_("  Entry"));
+  /* Delay displaying name as the last entry for better screen layout.  */ 
+  for (namepass = 0; namepass < 2; namepass++)
+    {
+      format = format_start;
+      for (formati = 0; formati < format_count; formati++)
+	{
+	  dwarf_vma content_type;
+
+	  content_type = read_uleb128 (format, & bytes_read, end);
+	  format += bytes_read;
+	  if ((content_type == DW_LNCT_path) == (namepass == 1))
+	    switch (content_type)
+	      {
+	      case DW_LNCT_path:
+		printf (_("\tName"));
+		break;
+	      case DW_LNCT_directory_index:
+		printf (_("\tDir"));
+		break;
+	      case DW_LNCT_timestamp:
+		printf (_("\tTime"));
+		break;
+	      case DW_LNCT_size:
+		printf (_("\tSize"));
+		break;
+	      case DW_LNCT_MD5:
+		printf (_("\tMD5"));
+		break;
+	      default:
+		printf (_("\t(Unknown format content type %s)"),
+			dwarf_vmatoa ("u", content_type));
+	      }
+	  read_uleb128 (format, & bytes_read, end);
+	  format += bytes_read;
+	}
+    }
+  putchar ('\n');
+
+  for (datai = 0; datai < data_count; datai++)
+    {
+      unsigned char *datapass = data;
+
+      printf ("  %d", last_entry++);
+      /* Delay displaying name as the last entry for better screen layout.  */ 
+      for (namepass = 0; namepass < 2; namepass++)
+	{
+	  format = format_start;
+	  data = datapass;
+	  for (formati = 0; formati < format_count; formati++)
+	    {
+	      dwarf_vma content_type, form;
+
+	      content_type = read_uleb128 (format, & bytes_read, end);
+	      format += bytes_read;
+	      form = read_uleb128 (format, & bytes_read, end);
+	      format += bytes_read;
+	      data = read_and_display_attr_value (0, form, 0, data, end, 0, 0,
+						  linfo->li_offset_size,
+						  linfo->li_version, NULL,
+			    ((content_type == DW_LNCT_path) != (namepass == 1)),
+						  section, NULL, '\t');
+	    }
+	}
+      if (data == end)
+	{
+	  warn (_("Corrupt %s entries list\n"), what);
+	  return data;
+	}
+      putchar ('\n');
+    }
+  return data;
+}
+
 static int
 display_debug_lines_raw (struct dwarf_section *section,
 			 unsigned char *data,
-			 unsigned char *end)
+			 unsigned char *end, void *file)
 {
   unsigned char *start = section->start;
 
@@ -2846,7 +3057,6 @@ display_debug_lines_raw (struct dwarf_section *section,
       DWARF2_Internal_LineInfo linfo;
       unsigned char *standard_opcodes;
       unsigned char *end_of_sequence;
-      unsigned int last_dir_entry = 0;
       int i;
 
       if (const_strneq (section->name, ".debug_line.")
@@ -2922,67 +3132,82 @@ display_debug_lines_raw (struct dwarf_section *section,
 	  /* Display the contents of the Directory table.  */
 	  data = standard_opcodes + linfo.li_opcode_base - 1;
 
-	  if (*data == 0)
-	    printf (_("\n The Directory Table is empty.\n"));
-	  else
+	  if (linfo.li_version >= 5)
 	    {
-	      printf (_("\n The Directory Table (offset 0x%lx):\n"),
-		      (long)(data - start));
+	      load_debug_section (line_str, file);
 
-	      while (data < end && *data != 0)
+	      data = display_formatted_table (data, start, end, &linfo, section,
+					      _("Directory"));
+	      data = display_formatted_table (data, start, end, &linfo, section,
+					      _("File name"));
+	    }
+	  else
+	    {
+	      if (*data == 0)
+		printf (_("\n The Directory Table is empty.\n"));
+	      else
 		{
-		  printf ("  %d\t%.*s\n", ++last_dir_entry, (int) (end - data), data);
-
-		  data += strnlen ((char *) data, end - data) + 1;
-		}
+		  unsigned int last_dir_entry = 0;
 
-	      /* PR 17512: file: 002-132094-0.004.  */
-	      if (data >= end - 1)
-		break;
-	    }
+		  printf (_("\n The Directory Table (offset 0x%lx):\n"),
+			  (long)(data - start));
 
-	  /* Skip the NUL at the end of the table.  */
-	  data++;
+		  while (data < end && *data != 0)
+		    {
+		      printf ("  %d\t%.*s\n", ++last_dir_entry, (int) (end - data), data);
 
-	  /* Display the contents of the File Name table.  */
-	  if (*data == 0)
-	    printf (_("\n The File Name Table is empty.\n"));
-	  else
-	    {
-	      printf (_("\n The File Name Table (offset 0x%lx):\n"),
-		      (long)(data - start));
-	      printf (_("  Entry\tDir\tTime\tSize\tName\n"));
+		      data += strnlen ((char *) data, end - data) + 1;
+		    }
 
-	      while (data < end && *data != 0)
-		{
-		  unsigned char *name;
-		  unsigned int bytes_read;
+		  /* PR 17512: file: 002-132094-0.004.  */
+		  if (data >= end - 1)
+		    break;
+		}
 
-		  printf ("  %d\t", ++state_machine_regs.last_file_entry);
-		  name = data;
-		  data += strnlen ((char *) data, end - data) + 1;
+	      /* Skip the NUL at the end of the table.  */
+	      data++;
 
-		  printf ("%s\t",
-			  dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
-		  data += bytes_read;
-		  printf ("%s\t",
-			  dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
-		  data += bytes_read;
-		  printf ("%s\t",
-			  dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
-		  data += bytes_read;
-		  printf ("%.*s\n", (int)(end - name), name);
+	      /* Display the contents of the File Name table.  */
+	      if (*data == 0)
+		printf (_("\n The File Name Table is empty.\n"));
+	      else
+		{
+		  printf (_("\n The File Name Table (offset 0x%lx):\n"),
+			  (long)(data - start));
+		  printf (_("  Entry\tDir\tTime\tSize\tName\n"));
 
-		  if (data == end)
+		  while (data < end && *data != 0)
 		    {
-		      warn (_("Corrupt file name table entry\n"));
-		      break;
+		      unsigned char *name;
+		      unsigned int bytes_read;
+
+		      printf ("  %d\t", ++state_machine_regs.last_file_entry);
+		      name = data;
+		      data += strnlen ((char *) data, end - data) + 1;
+
+		      printf ("%s\t",
+			      dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
+		      data += bytes_read;
+		      printf ("%s\t",
+			      dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
+		      data += bytes_read;
+		      printf ("%s\t",
+			      dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
+		      data += bytes_read;
+		      printf ("%.*s\n", (int)(end - name), name);
+
+		      if (data == end)
+			{
+			  warn (_("Corrupt file name table entry\n"));
+			  break;
+			}
 		    }
 		}
+
+	      /* Skip the NUL at the end of the table.  */
+	      data++;
 	    }
 
-	  /* Skip the NUL at the end of the table.  */
-	  data++;
 	  putchar ('\n');
 	  saved_linfo = linfo;
 	}
@@ -3196,7 +3421,7 @@ typedef struct
 static int
 display_debug_lines_decoded (struct dwarf_section *section,
 			     unsigned char *data,
-			     unsigned char *end)
+			     unsigned char *end, void *fileptr)
 {
   static DWARF2_Internal_LineInfo saved_linfo;
 
@@ -3213,7 +3438,7 @@ display_debug_lines_decoded (struct dwarf_section *section,
       File_Entry *file_table = NULL;
       unsigned int n_files = 0;
       unsigned char **directory_table = NULL;
-      unsigned int n_directories = 0;
+      dwarf_vma n_directories = 0;
 
       if (const_strneq (section->name, ".debug_line.")
 	  /* Note: the following does not apply to .debug_line.dwo sections.
@@ -3261,129 +3486,304 @@ display_debug_lines_decoded (struct dwarf_section *section,
 	      return 0;
 	    }
 
-	  if (*data != 0)
+	  if (linfo.li_version >= 5)
 	    {
-	      unsigned char *ptr_directory_table = data;
+	      unsigned char *format_start, format_count, *format;
+	      dwarf_vma formati, entryi;
+	      unsigned int bytes_read;
 
-	      while (data < end && *data != 0)
+	      load_debug_section (line_str, fileptr);
+
+	      /* Skip directories format.  */
+	      SAFE_BYTE_GET_AND_INC (format_count, data, 1, end);
+	      format_start = data;
+	      for (formati = 0; formati < format_count; formati++)
 		{
-		  data += strnlen ((char *) data, end - data) + 1;
-		  n_directories++;
+		  read_uleb128 (data, & bytes_read, end);
+		  data += bytes_read;
+		  read_uleb128 (data, & bytes_read, end);
+		  data += bytes_read;
 		}
 
-	      /* PR 20440 */
-	      if (data >= end)
+	      n_directories = read_uleb128 (data, & bytes_read, end);
+	      data += bytes_read;
+	      if (data == end)
 		{
-		  warn (_("directory table ends unexpectedly\n"));
-		  n_directories = 0;
+		  warn (_("Corrupt directories list\n"));
 		  break;
 		}
 
-	      /* Go through the directory table again to save the directories.  */
 	      directory_table = (unsigned char **)
 		xmalloc (n_directories * sizeof (unsigned char *));
 
-	      i = 0;
-	      while (*ptr_directory_table != 0)
+	      for (entryi = 0; entryi < n_directories; entryi++)
 		{
-		  directory_table[i] = ptr_directory_table;
-		  ptr_directory_table += strnlen ((char *) ptr_directory_table,
-						  ptr_directory_table - end) + 1;
-		  i++;
-		}
-	    }
-	  /* Skip the NUL at the end of the table.  */
-	  data++;
+		  unsigned char **pathp = &directory_table[entryi];
 
-	  /* Traverse the File Name table just to count the entries.  */
-	  if (data < end && *data != 0)
-	    {
-	      unsigned char *ptr_file_name_table = data;
+		  format = format_start;
+		  for (formati = 0; formati < format_count; formati++)
+		    {
+		      dwarf_vma content_type, form;
+		      dwarf_vma uvalue;
+
+		      content_type = read_uleb128 (format, & bytes_read, end);
+		      format += bytes_read;
+		      form = read_uleb128 (format, & bytes_read, end);
+		      format += bytes_read;
+		      if (data == end)
+			{
+			  warn (_("Corrupt directories list\n"));
+			  break;
+			}
+		      switch (content_type)
+			{
+			case DW_LNCT_path:
+			  switch (form)
+			    {
+			    case DW_FORM_string:
+			      *pathp = data;
+			      break;
+			    case DW_FORM_line_strp:
+			      SAFE_BYTE_GET (uvalue, data, linfo.li_offset_size,
+					     end);
+			      /* Remove const by the cast.  */
+			      *pathp = (unsigned char *)
+				       fetch_indirect_line_string (uvalue);
+			      break;
+			    }
+			  break;
+			}
+		      data = read_and_display_attr_value (0, form, 0, data, end,
+		                                          0, 0,
+							  linfo.li_offset_size,
+							  linfo.li_version,
+							  NULL, 1, section,
+							  NULL, '\t');
+		    }
+		  if (data == end)
+		    {
+		      warn (_("Corrupt directories list\n"));
+		      break;
+		    }
+		}
 
-	      while (data < end && *data != 0)
+	      /* Skip files format.  */
+	      SAFE_BYTE_GET_AND_INC (format_count, data, 1, end);
+	      format_start = data;
+	      for (formati = 0; formati < format_count; formati++)
 		{
-		  unsigned int bytes_read;
-
-		  /* Skip Name, directory index, last modification time and length
-		     of file.  */
-		  data += strnlen ((char *) data, end - data) + 1;
-		  read_uleb128 (data, & bytes_read, end);
-		  data += bytes_read;
 		  read_uleb128 (data, & bytes_read, end);
 		  data += bytes_read;
 		  read_uleb128 (data, & bytes_read, end);
 		  data += bytes_read;
-
-		  n_files++;
 		}
 
-	      if (data >= end)
+	      n_files = read_uleb128 (data, & bytes_read, end);
+	      data += bytes_read;
+	      if (data == end)
 		{
-		  warn (_("file table ends unexpectedly\n"));
-		  n_files = 0;
+		  warn (_("Corrupt file name list\n"));
 		  break;
 		}
 
-	      /* Go through the file table again to save the strings.  */
-	      file_table = (File_Entry *) xmalloc (n_files * sizeof (File_Entry));
+	      file_table = (File_Entry *) xcalloc (1, n_files
+						      * sizeof (File_Entry));
 
-	      i = 0;
-	      while (*ptr_file_name_table != 0)
+	      for (entryi = 0; entryi < n_files; entryi++)
 		{
-		  unsigned int bytes_read;
-
-		  file_table[i].name = ptr_file_name_table;
-		  ptr_file_name_table += strnlen ((char *) ptr_file_name_table,
-						  end - ptr_file_name_table) + 1;
-
-		  /* We are not interested in directory, time or size.  */
-		  file_table[i].directory_index = read_uleb128 (ptr_file_name_table,
-								& bytes_read, end);
-		  ptr_file_name_table += bytes_read;
-		  file_table[i].modification_date = read_uleb128 (ptr_file_name_table,
-								  & bytes_read, end);
-		  ptr_file_name_table += bytes_read;
-		  file_table[i].length = read_uleb128 (ptr_file_name_table, & bytes_read, end);
-		  ptr_file_name_table += bytes_read;
-		  i++;
-		}
-	      i = 0;
+		  File_Entry *file = &file_table[entryi];
 
-	      /* Print the Compilation Unit's name and a header.  */
-	      if (directory_table == NULL)
+		  format = format_start;
+		  for (formati = 0; formati < format_count; formati++)
+		    {
+		      dwarf_vma content_type, form;
+		      dwarf_vma uvalue;
+
+		      content_type = read_uleb128 (format, & bytes_read, end);
+		      format += bytes_read;
+		      form = read_uleb128 (format, & bytes_read, end);
+		      format += bytes_read;
+		      if (data == end)
+			{
+			  warn (_("Corrupt file name list\n"));
+			  break;
+			}
+		      switch (content_type)
+			{
+			case DW_LNCT_path:
+			  switch (form)
+			    {
+			    case DW_FORM_string:
+			      file->name = data;
+			      break;
+			    case DW_FORM_line_strp:
+			      SAFE_BYTE_GET (uvalue, data, linfo.li_offset_size,
+					     end);
+			      /* Remove const by the cast.  */
+			      file->name = (unsigned char *)
+					   fetch_indirect_line_string (uvalue);
+			      break;
+			    }
+			  break;
+			case DW_LNCT_directory_index:
+			  switch (form)
+			    {
+			    case DW_FORM_data1:
+			      SAFE_BYTE_GET (file->directory_index, data, 1,
+					     end);
+			      break;
+			    case DW_FORM_data2:
+			      SAFE_BYTE_GET (file->directory_index, data, 2,
+					     end);
+			      break;
+			    case DW_FORM_udata:
+			      file->directory_index = read_uleb128 (data, NULL,
+								    end);
+			      break;
+			    }
+			  break;
+			}
+		      data = read_and_display_attr_value (0, form, 0, data, end,
+							  0, 0,
+							  linfo.li_offset_size,
+							  linfo.li_version,
+							  NULL, 1, section,
+							  NULL, '\t');
+		    }
+		  if (data == end)
+		    {
+		      warn (_("Corrupt file name list\n"));
+		      break;
+		    }
+		}
+	    }
+	  else
+	    {
+	      if (*data != 0)
 		{
-		  printf (_("CU: %s:\n"), file_table[0].name);
-		  printf (_("File name                            Line number    Starting address\n"));
+		  unsigned char *ptr_directory_table = data;
+
+		  while (data < end && *data != 0)
+		    {
+		      data += strnlen ((char *) data, end - data) + 1;
+		      n_directories++;
+		    }
+
+		  /* PR 20440 */
+		  if (data >= end)
+		    {
+		      warn (_("directory table ends unexpectedly\n"));
+		      n_directories = 0;
+		      break;
+		    }
+
+		  /* Go through the directory table again to save the directories.  */
+		  directory_table = (unsigned char **)
+		    xmalloc (n_directories * sizeof (unsigned char *));
+
+		  i = 0;
+		  while (*ptr_directory_table != 0)
+		    {
+		      directory_table[i] = ptr_directory_table;
+		      ptr_directory_table += strnlen ((char *) ptr_directory_table,
+						      ptr_directory_table - end) + 1;
+		      i++;
+		    }
 		}
-	      else
+	      /* Skip the NUL at the end of the table.  */
+	      data++;
+
+	      /* Traverse the File Name table just to count the entries.  */
+	      if (data < end && *data != 0)
 		{
-		  unsigned int ix = file_table[0].directory_index;
-		  const char *directory;
-
-		  if (ix == 0)
-		    directory = ".";
-		  /* PR 20439 */
-		  else if (n_directories == 0)
-		    directory = _("<unknown>");
-		  else if (ix > n_directories)
+		  unsigned char *ptr_file_name_table = data;
+
+		  while (data < end && *data != 0)
 		    {
-		      warn (_("directory index %u > number of directories %u\n"), ix, n_directories);
-		      directory = _("<corrupt>");
+		      unsigned int bytes_read;
+
+		      /* Skip Name, directory index, last modification time and length
+			 of file.  */
+		      data += strnlen ((char *) data, end - data) + 1;
+		      read_uleb128 (data, & bytes_read, end);
+		      data += bytes_read;
+		      read_uleb128 (data, & bytes_read, end);
+		      data += bytes_read;
+		      read_uleb128 (data, & bytes_read, end);
+		      data += bytes_read;
+
+		      n_files++;
 		    }
-		  else
-		    directory = (char *) directory_table[ix - 1];
 
-		  if (do_wide || strlen (directory) < 76)
-		    printf (_("CU: %s/%s:\n"), directory, file_table[0].name);
-		  else
-		    printf ("%s:\n", file_table[0].name);
+		  if (data >= end)
+		    {
+		      warn (_("file table ends unexpectedly\n"));
+		      n_files = 0;
+		      break;
+		    }
+
+		  /* Go through the file table again to save the strings.  */
+		  file_table = (File_Entry *) xmalloc (n_files * sizeof (File_Entry));
 
-		  printf (_("File name                            Line number    Starting address\n"));
+		  i = 0;
+		  while (*ptr_file_name_table != 0)
+		    {
+		      unsigned int bytes_read;
+
+		      file_table[i].name = ptr_file_name_table;
+		      ptr_file_name_table += strnlen ((char *) ptr_file_name_table,
+						      end - ptr_file_name_table) + 1;
+
+		      /* We are not interested in directory, time or size.  */
+		      file_table[i].directory_index = read_uleb128 (ptr_file_name_table,
+								    & bytes_read, end);
+		      ptr_file_name_table += bytes_read;
+		      file_table[i].modification_date = read_uleb128 (ptr_file_name_table,
+								      & bytes_read, end);
+		      ptr_file_name_table += bytes_read;
+		      file_table[i].length = read_uleb128 (ptr_file_name_table, & bytes_read, end);
+		      ptr_file_name_table += bytes_read;
+		      i++;
+		    }
+		  i = 0;
 		}
+
+	      /* Skip the NUL at the end of the table.  */
+	      data++;
 	    }
 
-	  /* Skip the NUL at the end of the table.  */
-	  data++;
+	  /* Print the Compilation Unit's name and a header.  */
+	  if (directory_table == NULL)
+	    {
+	      printf (_("CU: %s:\n"), file_table[0].name);
+	      printf (_("File name                            Line number    Starting address\n"));
+	    }
+	  else
+	    {
+	      unsigned int ix = file_table[0].directory_index;
+	      const char *directory;
+
+	      if (ix == 0)
+		directory = ".";
+	      /* PR 20439 */
+	      else if (n_directories == 0)
+		directory = _("<unknown>");
+	      else if (ix > n_directories)
+		{
+		  warn (_("directory index %u > number of directories %s\n"),
+			ix, dwarf_vmatoa ("u", n_directories));
+		  directory = _("<corrupt>");
+		}
+	      else
+		directory = (char *) directory_table[ix - 1];
+
+	      if (do_wide || strlen (directory) < 76)
+		printf (_("CU: %s/%s:\n"), directory, file_table[0].name);
+	      else
+		printf ("%s:\n", file_table[0].name);
+
+	      printf (_("File name                            Line number    Starting address\n"));
+	    }
 
 	  saved_linfo = linfo;
 	}
@@ -3550,7 +3950,8 @@ display_debug_lines_decoded (struct dwarf_section *section,
 		     /* PR 20439 */
 		     else if (dir > n_directories)
 		       {
-			 warn (_("directory index %u > number of directories %u\n"), dir, n_directories);
+			 warn (_("directory index %u > number of directories %s\n"),
+			       dir, dwarf_vmatoa ("u", n_directories));
 			 printf (_("\n <over large directory table entry %u>\n"), dir);
 		       }
 		     else
@@ -3722,7 +4123,7 @@ display_debug_lines_decoded (struct dwarf_section *section,
 }
 
 static int
-display_debug_lines (struct dwarf_section *section, void *file ATTRIBUTE_UNUSED)
+display_debug_lines (struct dwarf_section *section, void *file)
 {
   unsigned char *data = section->start;
   unsigned char *end = data + section->size;
@@ -3733,10 +4134,10 @@ display_debug_lines (struct dwarf_section *section, void *file ATTRIBUTE_UNUSED)
     do_debug_lines |= FLAG_DEBUG_LINES_RAW;
 
   if (do_debug_lines & FLAG_DEBUG_LINES_RAW)
-    retValRaw = display_debug_lines_raw (section, data, end);
+    retValRaw = display_debug_lines_raw (section, data, end, file);
 
   if (do_debug_lines & FLAG_DEBUG_LINES_DECODED)
-    retValDecoded = display_debug_lines_decoded (section, data, end);
+    retValDecoded = display_debug_lines_decoded (section, data, end, file);
 
   if (!retValRaw || !retValDecoded)
     return 0;
@@ -4326,9 +4727,10 @@ display_debug_macro (struct dwarf_section *section,
 		    {
 		      int val;
 
+		      /* DW_FORM_implicit_const is not expected here.  */
 		      SAFE_BYTE_GET_AND_INC (val, desc, 1, end);
 		      curr
-			= read_and_display_attr_value (0, val,
+			= read_and_display_attr_value (0, val, 0,
 						       curr, end, 0, 0, offset_size,
 						       version, NULL, 0, NULL,
 						       NULL, ' ');
@@ -4381,9 +4783,14 @@ display_debug_abbrev (struct dwarf_section *section,
 		  entry->children ? _("has children") : _("no children"));
 
 	  for (attr = entry->first_attr; attr; attr = attr->next)
-	    printf ("    %-18s %s\n",
-		    get_AT_name (attr->attribute),
-		    get_FORM_name (attr->form));
+	    {
+	      printf ("    %-18s %s",
+		      get_AT_name (attr->attribute),
+		      get_FORM_name (attr->form));
+	      if (attr->form == DW_FORM_implicit_const)
+		printf (": %" BFD_VMA_FMT "d", attr->implicit_const);
+	      putchar ('\n');
+	    }
 	}
     }
   while (start);
@@ -4531,6 +4938,129 @@ display_loc_list (struct dwarf_section *section,
   *start_ptr = start;
 }
 
+/* Display a location list from a normal (ie, non-dwo) .debug_loclists section.  */
+
+static void
+display_loclists_list (struct dwarf_section *section,
+		       unsigned char **start_ptr,
+		       unsigned int debug_info_entry,
+		       dwarf_vma offset,
+		       dwarf_vma base_address,
+		       int has_frame_base)
+{
+  unsigned char *start = *start_ptr;
+  unsigned char *section_end = section->start + section->size;
+  unsigned long cu_offset;
+  unsigned int pointer_size;
+  unsigned int offset_size;
+  int dwarf_version;
+  unsigned int bytes_read;
+
+  dwarf_vma begin;
+  dwarf_vma end;
+  dwarf_vma length;
+  int need_frame_base;
+
+  if (debug_info_entry >= num_debug_info_entries)
+    {
+      warn (_("No debug information available for "
+	      "loclists lists of entry: %u\n"),
+	    debug_info_entry);
+      return;
+    }
+
+  cu_offset = debug_information [debug_info_entry].cu_offset;
+  pointer_size = debug_information [debug_info_entry].pointer_size;
+  offset_size = debug_information [debug_info_entry].offset_size;
+  dwarf_version = debug_information [debug_info_entry].dwarf_version;
+
+  if (pointer_size < 2 || pointer_size > 8)
+    {
+      warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
+	    pointer_size, debug_info_entry);
+      return;
+    }
+
+  while (1)
+    {
+      dwarf_vma off = offset + (start - *start_ptr);
+      enum dwarf_location_list_entry_type llet;
+
+      if (start + 1 > section_end)
+	{
+	  warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
+		(unsigned long) offset);
+	  break;
+	}
+
+      printf ("    %8.8lx ", (unsigned long) off);
+
+      SAFE_BYTE_GET_AND_INC (llet, start, 1, section_end);
+
+      switch (llet)
+	{
+	case DW_LLE_end_of_list:
+	  printf (_("<End of list>\n"));
+	  break;
+	case DW_LLE_offset_pair:
+	  begin = read_uleb128 (start, &bytes_read, section_end);
+	  start += bytes_read;
+	  end = read_uleb128 (start, &bytes_read, section_end);
+	  start += bytes_read;
+	  break;
+	case DW_LLE_base_address:
+	  SAFE_BYTE_GET_AND_INC (base_address, start, pointer_size,
+				 section_end);
+	  print_dwarf_vma (base_address, pointer_size);
+	  printf (_("(base address)\n"));
+	  break;
+	default:
+	  error (_("Invalid location list entry type %d\n"), llet);
+	  return;
+	}
+      if (llet == DW_LLE_end_of_list)
+	break;
+      if (llet != DW_LLE_offset_pair)
+	continue;
+
+      if (start + 2 > section_end)
+	{
+	  warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
+		(unsigned long) offset);
+	  break;
+	}
+
+      length = read_uleb128 (start, &bytes_read, section_end);
+      start += bytes_read;
+
+      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;
+}
+
 /* Print a .debug_addr table index in decimal, surrounded by square brackets,
    right-adjusted in a field of length LEN, and followed by a space.  */
 
@@ -4701,6 +5231,8 @@ display_debug_loc (struct dwarf_section *section, void *file)
   unsigned int *array = NULL;
   const char *suffix = strrchr (section->name, '.');
   int is_dwo = 0;
+  int is_loclists = strstr (section->name, "debug_loclists") != NULL;
+  dwarf_vma expected_start = 0;
 
   if (suffix && strcmp (suffix, ".dwo") == 0)
     is_dwo = 1;
@@ -4713,6 +5245,51 @@ display_debug_loc (struct dwarf_section *section, void *file)
       return 0;
     }
 
+  if (is_loclists)
+    {
+      unsigned char *hdrptr = section_begin;
+      dwarf_vma ll_length;
+      unsigned short ll_version;
+      unsigned char *end = section_begin + section->size;
+      unsigned char address_size, segment_selector_size;
+      uint32_t offset_entry_count;
+
+      SAFE_BYTE_GET_AND_INC (ll_length, hdrptr, 4, end);
+      if (ll_length == 0xffffffff)
+	SAFE_BYTE_GET_AND_INC (ll_length, hdrptr, 8, end);
+
+      SAFE_BYTE_GET_AND_INC (ll_version, hdrptr, 2, end);
+      if (ll_version != 5)
+	{
+	  warn (_("The %s section contains corrupt or "
+		  "unsupported version number: %d.\n"),
+		section->name, ll_version);
+	  return 0;
+	}
+
+      SAFE_BYTE_GET_AND_INC (address_size, hdrptr, 1, end);
+
+      SAFE_BYTE_GET_AND_INC (segment_selector_size, hdrptr, 1, end);
+      if (segment_selector_size != 0)
+	{
+	  warn (_("The %s section contains "
+		  "unsupported segment selector size: %d.\n"),
+		section->name, segment_selector_size);
+	  return 0;
+	}
+
+      SAFE_BYTE_GET_AND_INC (offset_entry_count, hdrptr, 4, end);
+      if (offset_entry_count != 0)
+	{
+	  warn (_("The %s section contains "
+		  "unsupported offset entry count: %d.\n"),
+		section->name, offset_entry_count);
+	  return 0;
+	}
+
+      expected_start = hdrptr - section_begin;
+    }
+
   if (load_debug_info (file) == 0)
     {
       warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
@@ -4762,7 +5339,7 @@ display_debug_loc (struct dwarf_section *section, void *file)
     error (_("No location lists in .debug_info section!\n"));
 
   if (debug_information [first].num_loc_offsets > 0
-      && debug_information [first].loc_offsets [0] != 0)
+      && debug_information [first].loc_offsets [0] != expected_start)
     warn (_("Location lists in %s section start at 0x%s\n"),
 	  section->name,
 	  dwarf_vmatoa ("x", debug_information [first].loc_offsets [0]));
@@ -4826,11 +5403,23 @@ display_debug_loc (struct dwarf_section *section, void *file)
 	      continue;
 	    }
 
-	  if (is_dwo)
-	    display_loc_list_dwo (section, &start, i, offset, has_frame_base);
+	  if (!is_loclists)
+	    {
+	      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);
+	    }
 	  else
-	    display_loc_list (section, &start, i, offset, base_address,
-			      has_frame_base);
+	    {
+	      if (is_dwo)
+		warn (_("DWO is not yet supported.\n"));
+	      else
+		display_loclists_list (section, &start, i, offset, base_address,
+				       has_frame_base);
+	    }
 	}
     }
 
@@ -5172,6 +5761,125 @@ range_entry_compar (const void *ap, const void *bp)
   return (a > b) - (b > a);
 }
 
+static void
+display_debug_ranges_list (unsigned char *start, unsigned char *finish,
+			   unsigned int pointer_size, unsigned long offset,
+			   unsigned long base_address)
+{
+  while (start < finish)
+    {
+      dwarf_vma begin;
+      dwarf_vma end;
+
+      SAFE_BYTE_GET_AND_INC (begin, start, pointer_size, finish);
+      if (start >= finish)
+	break;
+      SAFE_SIGNED_BYTE_GET_AND_INC (end, start, pointer_size, finish);
+
+      printf ("    %8.8lx ", offset);
+
+      if (begin == 0 && end == 0)
+	{
+	  printf (_("<End of list>\n"));
+	  break;
+	}
+
+      /* Check base address specifiers.  */
+      if (is_max_address (begin, pointer_size)
+	  && !is_max_address (end, pointer_size))
+	{
+	  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);
+
+      if (begin == end)
+	fputs (_("(start == end)"), stdout);
+      else if (begin > end)
+	fputs (_("(start > end)"), stdout);
+
+      putchar ('\n');
+    }
+}
+
+static void
+display_debug_rnglists_list (unsigned char *start, unsigned char *finish,
+			     unsigned int pointer_size, unsigned long offset,
+			     unsigned long base_address)
+{
+  unsigned char *next = start;
+
+  while (1)
+    {
+      unsigned long off = offset + (start - next);
+      enum dwarf_range_list_entry rlet;
+      dwarf_vma begin, length, end;
+      unsigned int bytes_read;
+
+      if (start + 1 > finish)
+	{
+	  warn (_("Range list starting at offset 0x%lx is not terminated.\n"),
+		offset);
+	  break;
+	}
+
+      printf ("    %8.8lx ", off);
+
+      SAFE_BYTE_GET_AND_INC (rlet, start, 1, finish);
+
+      switch (rlet)
+	{
+	case DW_RLE_end_of_list:
+	  printf (_("<End of list>\n"));
+	  break;
+	case DW_RLE_base_address:
+	  SAFE_BYTE_GET_AND_INC (base_address, start, pointer_size, finish);
+	  print_dwarf_vma (base_address, pointer_size);
+	  printf (_("(base address)\n"));
+	  break;
+	case DW_RLE_start_length:
+	  SAFE_BYTE_GET_AND_INC (begin, start, pointer_size, finish);
+	  length = read_uleb128 (start, &bytes_read, finish);
+	  start += bytes_read;
+	  end = begin + length;
+	  break;
+	case DW_RLE_offset_pair:
+	  begin = read_uleb128 (start, &bytes_read, finish);
+	  start += bytes_read;
+	  end = read_uleb128 (start, &bytes_read, finish);
+	  start += bytes_read;
+	  break;
+	case DW_RLE_start_end:
+	  SAFE_BYTE_GET_AND_INC (begin, start, pointer_size, finish);
+	  SAFE_BYTE_GET_AND_INC (end, start, pointer_size, finish);
+	  break;
+	default:
+	  error (_("Invalid range list entry type %d\n"), rlet);
+	  rlet = DW_RLE_end_of_list;
+	  break;
+	}
+      if (rlet == DW_RLE_end_of_list)
+	break;
+      if (rlet == DW_RLE_base_address)
+	continue;
+
+      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);
+
+      putchar ('\n');
+    }
+}
+
 static int
 display_debug_ranges (struct dwarf_section *section,
 		      void *file ATTRIBUTE_UNUSED)
@@ -5183,6 +5891,9 @@ display_debug_ranges (struct dwarf_section *section,
   unsigned char *finish = start + bytes;
   unsigned int num_range_list, i;
   struct range_entry *range_entries, *range_entry_fill;
+  int is_rnglists = strstr (section->name, "debug_rnglists") != NULL;
+  /* Initialize it due to a false compiler warning.  */
+  unsigned char address_size = 0;
 
   if (bytes == 0)
     {
@@ -5190,6 +5901,78 @@ display_debug_ranges (struct dwarf_section *section,
       return 0;
     }
 
+  if (is_rnglists)
+    {
+      dwarf_vma initial_length;
+      unsigned int initial_length_size;
+      unsigned char segment_selector_size;
+      unsigned int offset_size, offset_entry_count;
+      unsigned short version;
+
+      /* Get and check the length of the block.  */
+      SAFE_BYTE_GET_AND_INC (initial_length, start, 4, finish);
+
+      if (initial_length == 0xffffffff)
+	{
+	  /* This section is 64-bit DWARF 3.  */
+	  SAFE_BYTE_GET_AND_INC (initial_length, start, 8, finish);
+	  offset_size = 8;
+	  initial_length_size = 12;
+	}
+      else
+	{
+	  offset_size = 4;
+	  initial_length_size = 4;
+	}
+
+      if (initial_length + initial_length_size > section->size)
+	{
+	  /* If the length field has a relocation against it, then we should
+	     not complain if it is inaccurate (and probably negative).
+	     It is copied from .debug_line handling code.  */
+	  if (reloc_at (section, (start - section->start) - offset_size))
+	    {
+	      initial_length = (finish - start) - initial_length_size;
+	    }
+	  else
+	    {
+	      warn (_("The length field (0x%lx) in the debug_rnglists header is wrong - the section is too small\n"),
+		    (long) initial_length);
+	      return 0;
+	    }
+	}
+
+      /* Get and check the version number.  */
+      SAFE_BYTE_GET_AND_INC (version, start, 2, finish);
+
+      if (version != 5)
+	{
+	  warn (_("Only DWARF version 5 debug_rnglists info "
+		  "is currently supported.\n"));
+	  return 0;
+	}
+
+      SAFE_BYTE_GET_AND_INC (address_size, start, 1, finish);
+
+      SAFE_BYTE_GET_AND_INC (segment_selector_size, start, 1, finish);
+      if (segment_selector_size != 0)
+	{
+	  warn (_("The %s section contains "
+		  "unsupported segment selector size: %d.\n"),
+		section->name, segment_selector_size);
+	  return 0;
+	}
+
+      SAFE_BYTE_GET_AND_INC (offset_entry_count, start, 4, finish);
+      if (offset_entry_count != 0)
+	{
+	  warn (_("The %s section contains "
+		  "unsupported offset entry count: %u.\n"),
+		section->name, offset_entry_count);
+	  return 0;
+	}
+    }
+
   if (load_debug_info (file) == 0)
     {
       warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
@@ -5245,7 +6028,7 @@ display_debug_ranges (struct dwarf_section *section,
       unsigned char *next;
       dwarf_vma base_address;
 
-      pointer_size = debug_info_p->pointer_size;
+      pointer_size = (is_rnglists ? address_size : debug_info_p->pointer_size);
       offset = range_entry->ranges_offset;
       next = section_begin + offset;
       base_address = debug_info_p->base_address;
@@ -5276,45 +6059,8 @@ display_debug_ranges (struct dwarf_section *section,
       start = next;
       last_start = next;
 
-      while (start < finish)
-	{
-	  dwarf_vma begin;
-	  dwarf_vma end;
-
-	  SAFE_BYTE_GET_AND_INC (begin, start, pointer_size, finish);
-	  if (start >= finish)
-	    break;
-	  SAFE_SIGNED_BYTE_GET_AND_INC (end, start, pointer_size, finish);
-
-	  printf ("    %8.8lx ", (unsigned long) offset);
-
-	  if (begin == 0 && end == 0)
-	    {
-	      printf (_("<End of list>\n"));
-	      break;
-	    }
-
-	  /* Check base address specifiers.  */
-          if (is_max_address (begin, pointer_size)
-              && !is_max_address (end, pointer_size))
-	    {
-	      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);
-
-	  if (begin == end)
-	    fputs (_("(start == end)"), stdout);
-	  else if (begin > end)
-	    fputs (_("(start > end)"), stdout);
-
-	  putchar ('\n');
-	}
+      (is_rnglists ? display_debug_rnglists_list : display_debug_ranges_list)
+	(start, finish, pointer_size, offset, base_address);
     }
   putchar ('\n');
 
@@ -7731,14 +8477,20 @@ struct dwarf_section_display debug_displays[] =
     display_debug_macro,    &do_debug_macinfo,	TRUE },
   { { ".debug_str",	    ".zdebug_str",	NULL, NULL, 0, 0, 0, NULL, 0, NULL },
     display_debug_str,	    &do_debug_str,	FALSE },
+  { { ".debug_line_str",    ".zdebug_line_str",	NULL, NULL, 0, 0, 0, NULL, 0, NULL },
+    display_debug_str,	    &do_debug_str,	FALSE },
   { { ".debug_loc",	    ".zdebug_loc",	NULL, NULL, 0, 0, 0, NULL, 0, NULL },
     display_debug_loc,	    &do_debug_loc,	TRUE },
+  { { ".debug_loclists",    ".zdebug_loclists",	NULL, NULL, 0, 0, 0, NULL, 0, NULL },
+    display_debug_loc,	    &do_debug_loc,	TRUE },
   { { ".debug_pubtypes",    ".zdebug_pubtypes",	NULL, NULL, 0, 0, 0, NULL, 0, NULL },
     display_debug_pubnames, &do_debug_pubtypes,	FALSE },
   { { ".debug_gnu_pubtypes", ".zdebug_gnu_pubtypes", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
     display_debug_gnu_pubnames, &do_debug_pubtypes, FALSE },
   { { ".debug_ranges",	    ".zdebug_ranges",	NULL, NULL, 0, 0, 0, NULL, 0, NULL },
     display_debug_ranges,   &do_debug_ranges,	TRUE },
+  { { ".debug_rnglists",    ".zdebug_rnglists",	NULL, NULL, 0, 0, 0, NULL, 0, NULL },
+    display_debug_ranges,   &do_debug_ranges,	TRUE },
   { { ".debug_static_func", ".zdebug_static_func", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
     display_debug_not_supported, NULL,		FALSE },
   { { ".debug_static_vars", ".zdebug_static_vars", NULL, NULL, 0, 0, 0, NULL, 0, NULL },