X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=binutils%2Fdwarf.c;h=fee6a605e71d452fcb3166b7dac166b548b0b65b;hb=128e85e3ab36b8e30f6612fb50de3cbb4ede6824;hp=d82c89c6bec73e28e8c66b54b7b73bfd5a69ab98;hpb=a0a3b04c61d7aa79e265224540930cf4057acfb3;p=deliverable%2Fbinutils-gdb.git

diff --git a/binutils/dwarf.c b/binutils/dwarf.c
index d82c89c6be..fee6a605e7 100644
--- a/binutils/dwarf.c
+++ b/binutils/dwarf.c
@@ -1,5 +1,5 @@
 /* dwarf.c -- display DWARF contents of a BFD binary file
-   Copyright (C) 2005-2015 Free Software Foundation, Inc.
+   Copyright (C) 2005-2016 Free Software Foundation, Inc.
 
    This file is part of GNU Binutils.
 
@@ -44,7 +44,7 @@ static debug_info *debug_information = NULL;
    that the .debug_info section could not be loaded/parsed.  */
 #define DEBUG_INFO_UNAVAILABLE  (unsigned int) -1
 
-int eh_addr_size;
+unsigned int eh_addr_size;
 
 int do_debug_info;
 int do_debug_abbrevs;
@@ -105,7 +105,7 @@ static void load_cu_tu_indexes (void *file);
 #define FLAG_DEBUG_LINES_RAW	 1
 #define FLAG_DEBUG_LINES_DECODED 2
 
-static int
+static unsigned int
 size_of_encoded_value (int encoding)
 {
   switch (encoding & 0x7)
@@ -281,13 +281,18 @@ read_leb128 (unsigned char *data,
       shift += 7;
       if ((byte & 0x80) == 0)
 	break;
+
+      /* PR 17512: file: 0ca183b8.
+	 FIXME: Should we signal this error somehow ?  */
+      if (shift >= sizeof (result) * 8)
+	break;
     }
 
   if (length_return != NULL)
     *length_return = num_read;
 
   if (sign && (shift < 8 * sizeof (result)) && (byte & 0x40))
-    result |= (dwarf_vma) -1 << shift;
+    result |= -((dwarf_vma) 1 << shift);
 
   return result;
 }
@@ -312,8 +317,13 @@ read_uleb128 (unsigned char * data,
 #define SAFE_BYTE_GET(VAL, PTR, AMOUNT, END)	\
   do						\
     {						\
-      int dummy [sizeof (VAL) < (AMOUNT) ? -1 : 1] ATTRIBUTE_UNUSED ; \
       unsigned int amount = (AMOUNT);		\
+      if (sizeof (VAL) < amount)		\
+	{					\
+	  error (_("internal error: attempt to read %d bytes of data in to %d sized variable"),\
+		 amount, (int) sizeof (VAL));	\
+	  amount = sizeof (VAL);		\
+	}					\
       if (((PTR) + amount) >= (END))		\
 	{					\
 	  if ((PTR) < (END))			\
@@ -446,9 +456,13 @@ process_extended_line_op (unsigned char * data,
     case DW_LNE_set_address:
       /* PR 17512: file: 002-100480-0.004.  */
       if (len - bytes_read - 1 > 8)
-	warn (_("Length (%d) of DW_LNE_set_address op is too long\n"),
-	      len - bytes_read - 1);
-      SAFE_BYTE_GET (adr, data, len - bytes_read - 1, end);
+	{
+	  warn (_("Length (%d) of DW_LNE_set_address op is too long\n"),
+		len - bytes_read - 1);
+	  adr = 0;
+	}
+      else
+	SAFE_BYTE_GET (adr, data, len - bytes_read - 1, end);
       printf (_("set Address to 0x%s\n"), dwarf_vmatoa ("x", adr));
       state_machine_regs.address = adr;
       state_machine_regs.op_index = 0;
@@ -470,7 +484,7 @@ process_extended_line_op (unsigned char * data,
       printf ("%s\n\n", name);
 
       if (((unsigned int) (data - orig_data) != len) || data == end)
-        warn (_("DW_LNE_define_file: Bad opcode length\n"));
+	warn (_("DW_LNE_define_file: Bad opcode length\n"));
       break;
 
     case DW_LNE_set_discriminator:
@@ -511,68 +525,68 @@ process_extended_line_op (unsigned char * data,
       break;
     case DW_LNE_HP_source_file_correlation:
       {
-        unsigned char *edata = data + len - bytes_read - 1;
-
-        printf ("DW_LNE_HP_source_file_correlation\n");
-
-        while (data < edata)
-          {
-            unsigned int opc;
-
-            opc = read_uleb128 (data, & bytes_read, edata);
-            data += bytes_read;
-
-            switch (opc)
-              {
-              case DW_LNE_HP_SFC_formfeed:
-                printf ("    DW_LNE_HP_SFC_formfeed\n");
-                break;
-              case DW_LNE_HP_SFC_set_listing_line:
-                printf ("    DW_LNE_HP_SFC_set_listing_line (%s)\n",
-                        dwarf_vmatoa ("u",
-                                      read_uleb128 (data, & bytes_read, edata)));
-                data += bytes_read;
-                break;
-              case DW_LNE_HP_SFC_associate:
-                printf ("    DW_LNE_HP_SFC_associate ");
-                printf ("(%s",
-                        dwarf_vmatoa ("u",
-                                      read_uleb128 (data, & bytes_read, edata)));
-                data += bytes_read;
-                printf (",%s",
-                        dwarf_vmatoa ("u",
-                                      read_uleb128 (data, & bytes_read, edata)));
-                data += bytes_read;
-                printf (",%s)\n",
-                        dwarf_vmatoa ("u",
-                                      read_uleb128 (data, & bytes_read, edata)));
-                data += bytes_read;
-                break;
-              default:
-                printf (_("    UNKNOWN DW_LNE_HP_SFC opcode (%u)\n"), opc);
-                data = edata;
-                break;
-              }
-          }
+	unsigned char *edata = data + len - bytes_read - 1;
+
+	printf ("DW_LNE_HP_source_file_correlation\n");
+
+	while (data < edata)
+	  {
+	    unsigned int opc;
+
+	    opc = read_uleb128 (data, & bytes_read, edata);
+	    data += bytes_read;
+
+	    switch (opc)
+	      {
+	      case DW_LNE_HP_SFC_formfeed:
+		printf ("    DW_LNE_HP_SFC_formfeed\n");
+		break;
+	      case DW_LNE_HP_SFC_set_listing_line:
+		printf ("    DW_LNE_HP_SFC_set_listing_line (%s)\n",
+			dwarf_vmatoa ("u",
+				      read_uleb128 (data, & bytes_read, edata)));
+		data += bytes_read;
+		break;
+	      case DW_LNE_HP_SFC_associate:
+		printf ("    DW_LNE_HP_SFC_associate ");
+		printf ("(%s",
+			dwarf_vmatoa ("u",
+				      read_uleb128 (data, & bytes_read, edata)));
+		data += bytes_read;
+		printf (",%s",
+			dwarf_vmatoa ("u",
+				      read_uleb128 (data, & bytes_read, edata)));
+		data += bytes_read;
+		printf (",%s)\n",
+			dwarf_vmatoa ("u",
+				      read_uleb128 (data, & bytes_read, edata)));
+		data += bytes_read;
+		break;
+	      default:
+		printf (_("    UNKNOWN DW_LNE_HP_SFC opcode (%u)\n"), opc);
+		data = edata;
+		break;
+	      }
+	  }
       }
       break;
 
     default:
       {
-        unsigned int rlen = len - bytes_read - 1;
-
-        if (op_code >= DW_LNE_lo_user
-            /* The test against DW_LNW_hi_user is redundant due to
-               the limited range of the unsigned char data type used
-               for op_code.  */
-            /*&& op_code <= DW_LNE_hi_user*/)
-          printf (_("user defined: "));
-        else
-          printf (_("UNKNOWN: "));
-        printf (_("length %d ["), rlen);
-        for (; rlen; rlen--)
-          printf (" %02x", *data++);
-        printf ("]\n");
+	unsigned int rlen = len - bytes_read - 1;
+
+	if (op_code >= DW_LNE_lo_user
+	    /* The test against DW_LNW_hi_user is redundant due to
+	       the limited range of the unsigned char data type used
+	       for op_code.  */
+	    /*&& op_code <= DW_LNE_hi_user*/)
+	  printf (_("user defined: "));
+	else
+	  printf (_("UNKNOWN: "));
+	printf (_("length %d ["), rlen);
+	for (; rlen; rlen--)
+	  printf (" %02x", *data++);
+	printf ("]\n");
       }
       break;
     }
@@ -649,7 +663,7 @@ fetch_indexed_value (dwarf_vma offset, dwarf_vma bytes)
   if (offset + bytes > section->size)
     {
       warn (_("Offset into section %s too big: %s\n"),
-            section->name, dwarf_vmatoa ("x", offset));
+	    section->name, dwarf_vmatoa ("x", offset));
       return "<offset too big>";
     }
 
@@ -1358,16 +1372,16 @@ decode_location_expression (unsigned char * data,
 	  printf ("DW_OP_GNU_parameter_ref: <0x%s>",
 		  dwarf_vmatoa ("x", cu_offset + uvalue));
 	  break;
-        case DW_OP_GNU_addr_index:
-          uvalue = read_uleb128 (data, &bytes_read, end);
-          data += bytes_read;
-          printf ("DW_OP_GNU_addr_index <0x%s>", dwarf_vmatoa ("x", uvalue));
-          break;
-        case DW_OP_GNU_const_index:
-          uvalue = read_uleb128 (data, &bytes_read, end);
-          data += bytes_read;
-          printf ("DW_OP_GNU_const_index <0x%s>", dwarf_vmatoa ("x", uvalue));
-          break;
+	case DW_OP_GNU_addr_index:
+	  uvalue = read_uleb128 (data, &bytes_read, end);
+	  data += bytes_read;
+	  printf ("DW_OP_GNU_addr_index <0x%s>", dwarf_vmatoa ("x", uvalue));
+	  break;
+	case DW_OP_GNU_const_index:
+	  uvalue = read_uleb128 (data, &bytes_read, end);
+	  data += bytes_read;
+	  printf ("DW_OP_GNU_const_index <0x%s>", dwarf_vmatoa ("x", uvalue));
+	  break;
 
 	  /* HP extensions.  */
 	case DW_OP_HP_is_value:
@@ -1666,8 +1680,12 @@ read_and_display_attr_value (unsigned long attribute,
 	  uvalue = 0;
 	  block_start = end;
 	}
+      /* FIXME: Testing "(block_start + uvalue) < block_start" miscompiles with
+	 gcc 4.8.3 running on an x86_64 host in 32-bit mode.  So we pre-compute
+	 block_start + uvalue here.  */
+      data = block_start + uvalue;
       /* PR 17512: file: 008-103549-0.001:0.1.  */
-      if (block_start + uvalue > end)
+      if (block_start + uvalue > end || data < block_start)
 	{
 	  warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue);
 	  uvalue = end - block_start;
@@ -1687,7 +1705,8 @@ read_and_display_attr_value (unsigned long attribute,
 	  uvalue = 0;
 	  block_start = end;
 	}
-      if (block_start + uvalue > end)
+      data = block_start + uvalue;
+      if (block_start + uvalue > end || data < block_start)
 	{
 	  warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue);
 	  uvalue = end - block_start;
@@ -1707,7 +1726,8 @@ read_and_display_attr_value (unsigned long attribute,
 	  uvalue = 0;
 	  block_start = end;
 	}
-      if (block_start + uvalue > end)
+      data = block_start + uvalue;
+      if (block_start + uvalue > end || data < block_start)
 	{
 	  warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue);
 	  uvalue = end - block_start;
@@ -1728,7 +1748,10 @@ read_and_display_attr_value (unsigned long attribute,
 	  uvalue = 0;
 	  block_start = end;
 	}
-      if (block_start + uvalue > end)
+      data = block_start + uvalue;
+      if (block_start + uvalue > end
+	  /* PR 17531: file: 5b5f0592.  */
+	  || data < block_start)
 	{
 	  warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue);
 	  uvalue = end - block_start;
@@ -1748,14 +1771,14 @@ read_and_display_attr_value (unsigned long attribute,
 
     case DW_FORM_GNU_str_index:
       if (!do_loc)
-        {
-          const char *suffix = strrchr (section->name, '.');
-          int dwo = (suffix && strcmp (suffix, ".dwo") == 0) ? 1 : 0;
-
-          printf (_(" (indexed string: 0x%s): %s"),
-                  dwarf_vmatoa ("x", uvalue),
-                  fetch_indexed_string (uvalue, this_set, offset_size, dwo));
-        }
+	{
+	  const char *suffix = strrchr (section->name, '.');
+	  int dwo = (suffix && strcmp (suffix, ".dwo") == 0) ? 1 : 0;
+
+	  printf (_(" (indexed string: 0x%s): %s"),
+		  dwarf_vmatoa ("x", uvalue),
+		  fetch_indexed_string (uvalue, this_set, offset_size, dwo));
+	}
       break;
 
     case DW_FORM_GNU_strp_alt:
@@ -1783,9 +1806,9 @@ read_and_display_attr_value (unsigned long attribute,
 
     case DW_FORM_GNU_addr_index:
       if (!do_loc)
-        printf (_(" (addr_index: 0x%s): %s"),
-                dwarf_vmatoa ("x", uvalue),
-                fetch_indexed_value (uvalue * pointer_size, pointer_size));
+	printf (_(" (addr_index: 0x%s): %s"),
+		dwarf_vmatoa ("x", uvalue),
+		fetch_indexed_value (uvalue * pointer_size, pointer_size));
       break;
 
     default:
@@ -1801,6 +1824,7 @@ read_and_display_attr_value (unsigned long attribute,
 	{
 	case DW_AT_frame_base:
 	  have_frame_base = 1;
+	  /* Fall through.  */
 	case DW_AT_location:
 	case DW_AT_string_length:
 	case DW_AT_return_addr:
@@ -1813,7 +1837,7 @@ read_and_display_attr_value (unsigned long attribute,
 	case DW_AT_GNU_call_site_data_value:
 	case DW_AT_GNU_call_site_target:
 	case DW_AT_GNU_call_site_target_clobbered:
-    	  if ((dwarf_version < 4
+	  if ((dwarf_version < 4
 	       && (form == DW_FORM_data4 || form == DW_FORM_data8))
 	      || form == DW_FORM_sec_offset)
 	    {
@@ -1825,15 +1849,15 @@ read_and_display_attr_value (unsigned long attribute,
 		{
 		  lmax += 1024;
 		  debug_info_p->loc_offsets = (dwarf_vma *)
-                      xcrealloc (debug_info_p->loc_offsets,
-				 lmax, sizeof (*debug_info_p->loc_offsets));
+		    xcrealloc (debug_info_p->loc_offsets,
+			       lmax, sizeof (*debug_info_p->loc_offsets));
 		  debug_info_p->have_frame_base = (int *)
-                      xcrealloc (debug_info_p->have_frame_base,
-				 lmax, sizeof (*debug_info_p->have_frame_base));
+		    xcrealloc (debug_info_p->have_frame_base,
+			       lmax, sizeof (*debug_info_p->have_frame_base));
 		  debug_info_p->max_loc_offsets = lmax;
 		}
 	      if (this_set != NULL)
-	        uvalue += this_set->section_offsets [DW_SECT_LOC];
+		uvalue += this_set->section_offsets [DW_SECT_LOC];
 	      debug_info_p->loc_offsets [num] = uvalue;
 	      debug_info_p->have_frame_base [num] = have_frame_base;
 	      debug_info_p->num_loc_offsets++;
@@ -1846,15 +1870,15 @@ read_and_display_attr_value (unsigned long attribute,
 	  break;
 
 	case DW_AT_GNU_addr_base:
-          debug_info_p->addr_base = uvalue;
+	  debug_info_p->addr_base = uvalue;
 	  break;
 
 	case DW_AT_GNU_ranges_base:
-          debug_info_p->ranges_base = uvalue;
+	  debug_info_p->ranges_base = uvalue;
 	  break;
 
 	case DW_AT_ranges:
-    	  if ((dwarf_version < 4
+	  if ((dwarf_version < 4
 	       && (form == DW_FORM_data4 || form == DW_FORM_data8))
 	      || form == DW_FORM_sec_offset)
 	    {
@@ -1866,8 +1890,8 @@ read_and_display_attr_value (unsigned long attribute,
 		{
 		  lmax += 1024;
 		  debug_info_p->range_lists = (dwarf_vma *)
-                      xcrealloc (debug_info_p->range_lists,
-				 lmax, sizeof (*debug_info_p->range_lists));
+		    xcrealloc (debug_info_p->range_lists,
+			       lmax, sizeof (*debug_info_p->range_lists));
 		  debug_info_p->max_range_lists = lmax;
 		}
 	      debug_info_p->range_lists [num] = uvalue;
@@ -1942,6 +1966,8 @@ read_and_display_attr_value (unsigned long attribute,
 	case DW_LANG_C_plus_plus_11:	printf ("(C++11)"); break;
 	case DW_LANG_C11:		printf ("(C11)"); break;
 	case DW_LANG_C_plus_plus_14:	printf ("(C++14)"); break;
+	case DW_LANG_Fortran03:		printf ("(Fortran 03)"); break;
+	case DW_LANG_Fortran08:		printf ("(Fortran 08)"); break;
 	  /* MIPS extension.  */
 	case DW_LANG_Mips_Assembler:	printf ("(MIPS assembler)"); break;
 	  /* UPC extension.  */
@@ -1986,6 +2012,8 @@ read_and_display_attr_value (unsigned long attribute,
 	case DW_ATE_HP_floathpintel:	printf ("(HP_floathpintel)"); break;
 	case DW_ATE_HP_imaginary_float80:	printf ("(HP_imaginary_float80)"); break;
 	case DW_ATE_HP_imaginary_float128:	printf ("(HP_imaginary_float128)"); break;
+	  /* DWARF 4 values:  */
+	case DW_ATE_UTF:		printf ("(unicode string)"); break;
 
 	default:
 	  if (uvalue >= DW_ATE_lo_user
@@ -2072,6 +2100,7 @@ read_and_display_attr_value (unsigned long attribute,
 
     case DW_AT_frame_base:
       have_frame_base = 1;
+      /* Fall through.  */
     case DW_AT_location:
     case DW_AT_string_length:
     case DW_AT_return_addr:
@@ -2085,7 +2114,7 @@ read_and_display_attr_value (unsigned long attribute,
     case DW_AT_GNU_call_site_target:
     case DW_AT_GNU_call_site_target_clobbered:
       if ((dwarf_version < 4
-           && (form == DW_FORM_data4 || form == DW_FORM_data8))
+	   && (form == DW_FORM_data4 || form == DW_FORM_data8))
 	  || form == DW_FORM_sec_offset)
 	printf (_(" (location list)"));
       /* Fall through.  */
@@ -2116,7 +2145,7 @@ read_and_display_attr_value (unsigned long attribute,
       {
 	if (form == DW_FORM_ref_sig8
 	    || form == DW_FORM_GNU_ref_alt)
-          break;
+	  break;
 
 	if (form == DW_FORM_ref1
 	    || form == DW_FORM_ref2
@@ -2125,7 +2154,7 @@ read_and_display_attr_value (unsigned long attribute,
 	  uvalue += cu_offset;
 
 	if (uvalue >= section->size)
-	  warn (_("Offset %s used as value for DW_AT_import attribute of DIE at offset %lx is too big.\n"),
+	  warn (_("Offset %s used as value for DW_AT_import attribute of DIE at offset 0x%lx is too big.\n"),
 		dwarf_vmatoa ("x", uvalue),
 		(unsigned long) (orig_data - section->start));
 	else
@@ -2218,7 +2247,7 @@ read_and_display_attr (unsigned long attribute,
 static int
 process_debug_info (struct dwarf_section *section,
 		    void *file,
-                    enum dwarf_section_display_enum abbrev_sec,
+		    enum dwarf_section_display_enum abbrev_sec,
 		    int do_loc,
 		    int do_types)
 {
@@ -2259,8 +2288,8 @@ process_debug_info (struct dwarf_section *section,
 
 	  /* Negative values are illegal, they may even cause infinite
 	     looping.  This can happen if we can't accurately apply
-	     relocations to an object file.  */
-	  if ((signed long) length <= 0)
+	     relocations to an object file, or if the file is corrupt.  */
+	  if ((signed long) length <= 0 || section_begin < start)
 	    {
 	      warn (_("Corrupt unit length (0x%s) found in section %s\n"),
 		    dwarf_vmatoa ("x", length), section->name);
@@ -2284,6 +2313,13 @@ process_debug_info (struct dwarf_section *section,
 	  alloc_num_debug_info_entries = num_debug_info_entries = 0;
 	  return 0;
 	}
+      /* PR 17531: file: 92ca3797.
+	 We cannot rely upon the debug_information array being initialised
+	 before it is used.  A corrupt file could easily contain references
+	 to a unit for which information has not been made available.  So
+	 we ensure that the array is zeroed here.  */
+      memset (debug_information, 0, num_units * sizeof (*debug_information));
+
       alloc_num_debug_info_entries = num_units;
     }
 
@@ -2368,11 +2404,11 @@ process_debug_info (struct dwarf_section *section,
 	}
 
       if (do_types)
-        {
+	{
 	  SAFE_BYTE_GET64 (hdrptr, &signature_high, &signature_low, end);
 	  hdrptr += 8;
 	  SAFE_BYTE_GET_AND_INC (type_offset, hdrptr, offset_size, end);
-        }
+	}
 
       if ((do_loc || do_debug_loc || do_debug_ranges)
 	  && num_debug_info_entries == 0
@@ -2441,14 +2477,22 @@ process_debug_info (struct dwarf_section *section,
 	  > section->size)
 	{
 	  warn (_("Debug info is corrupted, length of CU at %s"
-	  	  " extends beyond end of section (length = %s)\n"),
+		  " extends beyond end of section (length = %s)\n"),
 		dwarf_vmatoa ("x", cu_offset),
 		dwarf_vmatoa ("x", compunit.cu_length));
+	  num_units = unit;
 	  break;
 	}
       tags = hdrptr;
       start += compunit.cu_length + initial_length_size;
 
+      if (start > end)
+	{
+	  warn (_("Debug info is corrupt.  CU at %s extends beyond end of section"),
+		dwarf_vmatoa ("x", cu_offset));
+	  start = end;
+	}
+
       if (compunit.cu_version != 2
 	  && compunit.cu_version != 3
 	  && compunit.cu_version != 4)
@@ -2466,7 +2510,7 @@ process_debug_info (struct dwarf_section *section,
 	warn (_("Debug info is corrupted, abbrev offset (%lx) is larger than abbrev section size (%lx)\n"),
 	      (unsigned long) compunit.cu_abbrev_offset,
 	      (unsigned long) abbrev_size);
-      /* PR 17531: file:4bcd9ce9.  */ 
+      /* PR 17531: file:4bcd9ce9.  */
       else if ((abbrev_base + abbrev_size)
 	       > debug_displays [abbrev_sec].section.size)
 	warn (_("Debug info is corrupted, abbrev size (%lx) is larger than abbrev section size (%lx)\n"),
@@ -2571,7 +2615,7 @@ process_debug_info (struct dwarf_section *section,
 		  printf ("\n");
 		  fflush (stdout);
 		}
-	      warn (_("DIE at offset %lx refers to abbreviation number %lu which does not exist\n"),
+	      warn (_("DIE at offset 0x%lx refers to abbreviation number %lu which does not exist\n"),
 		    die_offset, abbrev_number);
 	      return 0;
 	    }
@@ -2609,7 +2653,7 @@ process_debug_info (struct dwarf_section *section,
 		arg = debug_information + unit;
 	      else
 		arg = NULL;
-	      
+
 	      tags = read_and_display_attr (attr->attribute,
 					    attr->form,
 					    tags,
@@ -2624,9 +2668,9 @@ process_debug_info (struct dwarf_section *section,
 					    this_set);
 	    }
 
- 	  if (entry->children)
- 	    ++level;
- 	}
+	  if (entry->children)
+	    ++level;
+	}
     }
 
   /* Set num_debug_info_entries here so that it can be used to check if
@@ -2635,7 +2679,7 @@ process_debug_info (struct dwarf_section *section,
       && num_debug_info_entries == 0
       && ! do_types)
     {
-      if (num_units > alloc_num_debug_info_entries)	
+      if (num_units > alloc_num_debug_info_entries)
 	num_debug_info_entries = alloc_num_debug_info_entries;
       else
 	num_debug_info_entries = num_units;
@@ -2724,18 +2768,20 @@ read_debug_line_header (struct dwarf_section * section,
 
   if (linfo->li_length + initial_length_size > section->size)
     {
-      /* If the length is just a bias against the initial_length_size then
-	 this means that the field has a relocation against it which has not
-	 been applied.  (Ie we are dealing with an object file, not a linked
-	 binary).  Do not complain but instead assume that the rest of the
-	 section applies to this particular header.  */
-      if (linfo->li_length == - initial_length_size)
+      /* If the length field has a relocation against it, then we should
+	 not complain if it is inaccurate (and probably negative).  This
+	 happens in object files when the .debug_line section is actually
+	 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))
 	{
-	  linfo->li_length = section->size - initial_length_size;
+	  linfo->li_length = (end - data) - initial_length_size;
 	}
       else
 	{
-	  warn (_("The line info appears to be corrupt - the section is too small\n"));
+	  warn (_("The length field (0x%lx) in the debug_line header is wrong - the section is too small\n"),
+		(long) linfo->li_length);
 	  return NULL;
 	}
     }
@@ -2773,7 +2819,7 @@ read_debug_line_header (struct dwarf_section * section,
   SAFE_BYTE_GET_AND_INC (linfo->li_opcode_base, hdrptr, 1, end);
 
   * end_of_sequence = data + linfo->li_length + initial_length_size;
-  /* PR 17512: file:002-117414-0.004.  */ 
+  /* PR 17512: file:002-117414-0.004.  */
   if (* end_of_sequence > end)
     {
       warn (_("Line length %s extends beyond end of section\n"),
@@ -2788,12 +2834,12 @@ read_debug_line_header (struct dwarf_section * section,
 static int
 display_debug_lines_raw (struct dwarf_section *section,
 			 unsigned char *data,
-                         unsigned char *end)
+			 unsigned char *end)
 {
   unsigned char *start = section->start;
 
   printf (_("Raw dump of debug contents of section %s:\n\n"),
-          section->name);
+	  section->name);
 
   while (data < end)
     {
@@ -2841,7 +2887,7 @@ display_debug_lines_raw (struct dwarf_section *section,
 	  printf (_("  Offset:                      0x%lx\n"), (long)(data - start));
 	  printf (_("  Length:                      %ld\n"), (long) linfo.li_length);
 	  printf (_("  DWARF Version:               %d\n"), linfo.li_version);
-	  printf (_("  Prologue Length:             %d\n"), linfo.li_prologue_length);
+	  printf (_("  Prologue Length:             %d\n"), (int) linfo.li_prologue_length);
 	  printf (_("  Minimum Instruction Length:  %d\n"), linfo.li_min_insn_length);
 	  if (linfo.li_version >= 4)
 	    printf (_("  Maximum Ops per Instruction: %d\n"), linfo.li_max_ops_per_insn);
@@ -2856,7 +2902,7 @@ display_debug_lines_raw (struct dwarf_section *section,
 	      warn (_("Line range of 0 is invalid, using 1 instead\n"));
 	      linfo.li_line_range = 1;
 	    }
-	  
+
 	  reset_state_machine (linfo.li_default_is_stmt);
 
 	  /* Display the contents of the Opcodes table.  */
@@ -3156,7 +3202,7 @@ display_debug_lines_decoded (struct dwarf_section *section,
   static DWARF2_Internal_LineInfo saved_linfo;
 
   printf (_("Decoded dump of debug contents of section %s:\n\n"),
-          section->name);
+	  section->name);
 
   while (data < end)
     {
@@ -3174,7 +3220,7 @@ display_debug_lines_decoded (struct dwarf_section *section,
 	  /* Note: the following does not apply to .debug_line.dwo sections.
 	     These are full debug_line sections.  */
 	  && strcmp (section->name, ".debug_line.dwo") != 0)
-        {
+	{
 	  /* See comment in display_debug_lines_raw().  */
 	  end_of_sequence = end;
 	  standard_opcodes = NULL;
@@ -3186,9 +3232,9 @@ display_debug_lines_decoded (struct dwarf_section *section,
 	      return 0;
 	    }
 	  reset_state_machine (linfo.li_default_is_stmt);
-        }
+	}
       else
-        {
+	{
 	  unsigned char *hdrptr;
 
 	  if ((hdrptr = read_debug_line_header (section, data, end, & linfo,
@@ -3208,16 +3254,32 @@ display_debug_lines_decoded (struct dwarf_section *section,
 
 	  /* Traverse the Directory table just to count entries.  */
 	  data = standard_opcodes + linfo.li_opcode_base - 1;
+	  /* PR 20440 */
+	  if (data >= end)
+	    {
+	      warn (_("opcode base of %d extends beyond end of section\n"),
+		    linfo.li_opcode_base);
+	      return 0;
+	    }
+
 	  if (*data != 0)
 	    {
 	      unsigned char *ptr_directory_table = data;
 
-	      while (*data != 0)
+	      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 *));
@@ -3235,11 +3297,11 @@ display_debug_lines_decoded (struct dwarf_section *section,
 	  data++;
 
 	  /* Traverse the File Name table just to count the entries.  */
-	  if (*data != 0)
+	  if (data < end && *data != 0)
 	    {
 	      unsigned char *ptr_file_name_table = data;
 
-	      while (*data != 0)
+	      while (data < end && *data != 0)
 		{
 		  unsigned int bytes_read;
 
@@ -3256,6 +3318,13 @@ display_debug_lines_decoded (struct dwarf_section *section,
 		  n_files++;
 		}
 
+	      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));
 
@@ -3290,7 +3359,20 @@ display_debug_lines_decoded (struct dwarf_section *section,
 	      else
 		{
 		  unsigned int ix = file_table[0].directory_index;
-		  const char *directory = ix ? (char *)directory_table[ix - 1] : ".";
+		  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 %u\n"), ix, 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);
@@ -3309,16 +3391,16 @@ display_debug_lines_decoded (struct dwarf_section *section,
 
       /* This loop iterates through the Dwarf Line Number Program.  */
       while (data < end_of_sequence)
-        {
+	{
 	  unsigned char op_code;
-          int adv;
-          unsigned long int uladv;
-          unsigned int bytes_read;
-          int is_special_opcode = 0;
+	  int adv;
+	  unsigned long int uladv;
+	  unsigned int bytes_read;
+	  int is_special_opcode = 0;
 
-          op_code = *data++;
+	  op_code = *data++;
 
-          if (op_code >= linfo.li_opcode_base)
+	  if (op_code >= linfo.li_opcode_base)
 	    {
 	      op_code -= linfo.li_opcode_base;
 	      uladv = (op_code / linfo.li_line_range);
@@ -3338,11 +3420,11 @@ display_debug_lines_decoded (struct dwarf_section *section,
 		    % linfo.li_max_ops_per_insn;
 		}
 
-              adv = (op_code % linfo.li_line_range) + linfo.li_line_base;
-              state_machine_regs.line += adv;
-              is_special_opcode = 1;
-            }
-          else switch (op_code)
+	      adv = (op_code % linfo.li_line_range) + linfo.li_line_base;
+	      state_machine_regs.line += adv;
+	      is_special_opcode = 1;
+	    }
+	  else switch (op_code)
 		 {
 		 case DW_LNS_extended_op:
 		   {
@@ -3448,20 +3530,35 @@ display_debug_lines_decoded (struct dwarf_section *section,
 		   data += bytes_read;
 		   state_machine_regs.file = adv;
 
-		   if (file_table == NULL)
-		     printf (_("\n [Use file table entry %d]\n"), state_machine_regs.file - 1);
-		   else if (file_table[state_machine_regs.file - 1].directory_index == 0)
-		     /* If directory index is 0, that means current directory.  */
-		     printf ("\n./%s:[++]\n",
-			     file_table[state_machine_regs.file - 1].name);
-		   else if (directory_table == NULL)
-		     printf (_("\n [Use directory table entry %d]\n"),
-			     file_table[state_machine_regs.file - 1].directory_index - 1);
-		   else
-		     /* The directory index starts counting at 1.  */
-		     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);
+		   {
+		     unsigned file = state_machine_regs.file - 1;
+		     unsigned dir;
+
+		     if (file_table == NULL || n_files == 0)
+		       printf (_("\n [Use file table entry %d]\n"), file);
+		     /* PR 20439 */
+		     else if (file >= n_files)
+		       {
+			 warn (_("file index %u > number of files %u\n"), file + 1, n_files);
+			 printf (_("\n <over large file table index %u>"), file);
+		       }
+		     else if ((dir = file_table[file].directory_index) == 0)
+		       /* If directory index is 0, that means current directory.  */
+		       printf ("\n./%s:[++]\n", file_table[file].name);
+		     else if (directory_table == NULL || n_directories == 0)
+		       printf (_("\n [Use file %s in directory table entry %d]\n"),
+			       file_table[file].name, dir);
+		     /* PR 20439 */
+		     else if (dir > n_directories)
+		       {
+			 warn (_("directory index %u > number of directories %u\n"), dir, n_directories);
+			 printf (_("\n <over large directory table entry %u>\n"), dir);
+		       }
+		     else
+		       printf ("\n%s/%s:\n",
+			       /* The directory index starts counting at 1.  */
+			       directory_table[dir - 1], file_table[file].name);
+		   }
 		   break;
 
 		 case DW_LNS_set_column:
@@ -3532,39 +3629,49 @@ display_debug_lines_decoded (struct dwarf_section *section,
 		   break;
 		 }
 
-          /* Only Special opcodes, DW_LNS_copy and DW_LNE_end_sequence adds a row
-             to the DWARF address/line matrix.  */
-          if ((is_special_opcode) || (op_code == DW_LNE_end_sequence)
+	  /* Only Special opcodes, DW_LNS_copy and DW_LNE_end_sequence adds a row
+	     to the DWARF address/line matrix.  */
+	  if ((is_special_opcode) || (op_code == DW_LNE_end_sequence)
 	      || (op_code == DW_LNS_copy))
-            {
-              const unsigned int MAX_FILENAME_LENGTH = 35;
-              char *fileName;
-              char *newFileName = NULL;
-              size_t fileNameLength;
+	    {
+	      const unsigned int MAX_FILENAME_LENGTH = 35;
+	      char *fileName;
+	      char *newFileName = NULL;
+	      size_t fileNameLength;
 
 	      if (file_table)
-		fileName = (char *) file_table[state_machine_regs.file - 1].name;
+		{
+		  unsigned indx = state_machine_regs.file - 1;
+		  /* PR 20439  */
+		  if (indx >= n_files)
+		    {
+		      warn (_("corrupt file index %u encountered\n"), indx);
+		      fileName = _("<corrupt>");
+		    }
+		  else
+		    fileName = (char *) file_table[indx].name;
+		}
 	      else
-		fileName = "<unknown>";
+		fileName = _("<unknown>");
 
 	      fileNameLength = strlen (fileName);
 
-              if ((fileNameLength > MAX_FILENAME_LENGTH) && (!do_wide))
-                {
-                  newFileName = (char *) xmalloc (MAX_FILENAME_LENGTH + 1);
-                  /* Truncate file name */
-                  strncpy (newFileName,
-                           fileName + fileNameLength - MAX_FILENAME_LENGTH,
-                           MAX_FILENAME_LENGTH + 1);
-                }
-              else
-                {
-                  newFileName = (char *) xmalloc (fileNameLength + 1);
-                  strncpy (newFileName, fileName, fileNameLength + 1);
-                }
-
-              if (!do_wide || (fileNameLength <= MAX_FILENAME_LENGTH))
-                {
+	      if ((fileNameLength > MAX_FILENAME_LENGTH) && (!do_wide))
+		{
+		  newFileName = (char *) xmalloc (MAX_FILENAME_LENGTH + 1);
+		  /* Truncate file name */
+		  strncpy (newFileName,
+			   fileName + fileNameLength - MAX_FILENAME_LENGTH,
+			   MAX_FILENAME_LENGTH + 1);
+		}
+	      else
+		{
+		  newFileName = (char *) xmalloc (fileNameLength + 1);
+		  strncpy (newFileName, fileName, fileNameLength + 1);
+		}
+
+	      if (!do_wide || (fileNameLength <= MAX_FILENAME_LENGTH))
+		{
 		  if (linfo.li_max_ops_per_insn == 1)
 		    printf ("%-35s  %11d  %#18" DWARF_VMA_FMT "x\n",
 			    newFileName, state_machine_regs.line,
@@ -3574,9 +3681,9 @@ display_debug_lines_decoded (struct dwarf_section *section,
 			    newFileName, state_machine_regs.line,
 			    state_machine_regs.address,
 			    state_machine_regs.op_index);
-                }
-              else
-                {
+		}
+	      else
+		{
 		  if (linfo.li_max_ops_per_insn == 1)
 		    printf ("%s  %11d  %#18" DWARF_VMA_FMT "x\n",
 			    newFileName, state_machine_regs.line,
@@ -3586,14 +3693,14 @@ display_debug_lines_decoded (struct dwarf_section *section,
 			    newFileName, state_machine_regs.line,
 			    state_machine_regs.address,
 			    state_machine_regs.op_index);
-                }
+		}
 
-              if (op_code == DW_LNE_end_sequence)
+	      if (op_code == DW_LNE_end_sequence)
 		printf ("\n");
 
-              free (newFileName);
-            }
-        }
+	      free (newFileName);
+	    }
+	}
 
       if (file_table)
 	{
@@ -3690,7 +3797,8 @@ display_debug_pubnames_worker (struct dwarf_section *section,
   while (start < end)
     {
       unsigned char *data;
-      unsigned long offset;
+      unsigned char *adr;
+      dwarf_vma offset;
       unsigned int offset_size, initial_length_size;
 
       data = start;
@@ -3719,14 +3827,17 @@ display_debug_pubnames_worker (struct dwarf_section *section,
 
       SAFE_BYTE_GET_AND_INC (names.pn_size, data, offset_size, end);
 
+      adr = start + names.pn_length + initial_length_size;
       /* PR 17531: file: 7615b6b2.  */
-      if ((dwarf_signed_vma) names.pn_length < 0)
+      if ((dwarf_signed_vma) names.pn_length < 0
+	  /* PR 17531: file: a5dbeaa7. */
+	  || adr < start)
 	{
 	  warn (_("Negative length for public name: 0x%lx\n"), (long) names.pn_length);
 	  start = end;
 	}
       else
-	start += names.pn_length + initial_length_size;
+	start = adr;
 
       printf (_("  Length:                              %ld\n"),
 	      (long) names.pn_length);
@@ -3767,7 +3878,7 @@ display_debug_pubnames_worker (struct dwarf_section *section,
 	      if (data >= end)
 		break;
 	      maxprint = (end - data) - 1;
-	      
+
 	      if (is_gnu)
 		{
 		  unsigned int kind_data;
@@ -3787,11 +3898,12 @@ display_debug_pubnames_worker (struct dwarf_section *section,
 		  kind_name = get_gdb_index_symbol_kind_name (kind);
 		  is_static = GDB_INDEX_SYMBOL_STATIC_VALUE (kind_data);
 		  printf ("    %-6lx  %s,%-10s  %.*s\n",
-			  offset, is_static ? _("s") : _("g"),
+			  (unsigned long) offset, is_static ? _("s") : _("g"),
 			  kind_name, (int) maxprint, data);
 		}
 	      else
-		printf ("    %-6lx\t%.*s\n", offset, (int) maxprint, data);
+		printf ("    %-6lx\t%.*s\n",
+			(unsigned long) offset, (int) maxprint, data);
 
 	      data += strnlen ((char *) data, maxprint) + 1;
 	      if (data >= end)
@@ -4231,7 +4343,7 @@ display_debug_macro (struct dwarf_section *section,
 	}
 
       printf ("\n");
-    }	
+    }
 
   return 1;
 }
@@ -4282,15 +4394,25 @@ display_debug_abbrev (struct dwarf_section *section,
   return 1;
 }
 
+/* Return true when ADDR is the maximum address, when addresses are
+   POINTER_SIZE bytes long.  */
+
+static bfd_boolean
+is_max_address (dwarf_vma addr, unsigned int pointer_size)
+{
+  dwarf_vma mask = ~(~(dwarf_vma) 1 << (pointer_size * 8 - 1));
+  return ((addr & mask) == mask);
+}
+
 /* Display a location list from a normal (ie, non-dwo) .debug_loc section.  */
 
 static void
 display_loc_list (struct dwarf_section *section,
-                  unsigned char **start_ptr,
-                  unsigned int debug_info_entry,
-                  unsigned long offset,
-                  unsigned long base_address,
-                  int has_frame_base)
+		  unsigned char **start_ptr,
+		  unsigned int debug_info_entry,
+		  unsigned long offset,
+		  unsigned long base_address,
+		  int has_frame_base)
 {
   unsigned char *start = *start_ptr;
   unsigned char *section_end = section->start + section->size;
@@ -4310,12 +4432,12 @@ display_loc_list (struct dwarf_section *section,
 	    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"),
@@ -4325,73 +4447,82 @@ display_loc_list (struct dwarf_section *section,
 
   while (1)
     {
+      unsigned long off = offset + (start - *start_ptr);
+
       if (start + 2 * pointer_size > section_end)
-        {
-          warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
-                offset);
-          break;
-        }
+	{
+	  warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
+		offset);
+	  break;
+	}
 
-      printf ("    %8.8lx ", offset + (start - *start_ptr));
+      printf ("    %8.8lx ", off);
 
-      /* Note: we use sign extension here in order to be sure that we can detect
-         the -1 escape value.  Sign extension into the top 32 bits of a 32-bit
-         address will not affect the values that we display since we always show
-         hex values, and always the bottom 32-bits.  */
       SAFE_BYTE_GET_AND_INC (begin, start, pointer_size, section_end);
       SAFE_BYTE_GET_AND_INC (end, start, pointer_size, section_end);
 
       if (begin == 0 && end == 0)
-        {
-          printf (_("<End of list>\n"));
-          break;
-        }
+	{
+	  /* PR 18374: In a object file we can have a location list that
+	     starts with a begin and end of 0 because there are relocations
+	     that need to be applied to the addresses.  Actually applying
+	     the relocations now does not help as they will probably resolve
+	     to 0, since the object file has not been fully linked.  Real
+	     end of list markers will not have any relocations against them.  */
+	  if (! reloc_at (section, off)
+	      && ! reloc_at (section, off + pointer_size))
+	    {
+	      printf (_("<End of list>\n"));
+	      break;
+	    }
+	}
 
       /* Check base address specifiers.  */
-      if (begin == (dwarf_vma) -1 && end != (dwarf_vma) -1)
-        {
-          base_address = end;
-          print_dwarf_vma (begin, pointer_size);
-          print_dwarf_vma (end, pointer_size);
-          printf (_("(base address)\n"));
-          continue;
-        }
+      if (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;
+	}
 
       if (start + 2 > section_end)
-        {
-          warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
-                offset);
-          break;
-        }
+	{
+	  warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
+		offset);
+	  break;
+	}
 
       SAFE_BYTE_GET_AND_INC (length, start, 2, section_end);
 
       if (start + length > section_end)
-        {
-          warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
-                offset);
-          break;
-        }
+	{
+	  warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
+		offset);
+	  break;
+	}
 
       print_dwarf_vma (begin + base_address, pointer_size);
       print_dwarf_vma (end + base_address, pointer_size);
 
       putchar ('(');
       need_frame_base = decode_location_expression (start,
-                                                    pointer_size,
-                                                    offset_size,
-                                                    dwarf_version,
-                                                    length,
-                                                    cu_offset, section);
+						    pointer_size,
+						    offset_size,
+						    dwarf_version,
+						    length,
+						    cu_offset, section);
       putchar (')');
 
       if (need_frame_base && !has_frame_base)
-        printf (_(" [without DW_AT_frame_base]"));
+	printf (_(" [without DW_AT_frame_base]"));
 
       if (begin == end)
-        fputs (_(" (start == end)"), stdout);
+	fputs (_(" (start == end)"), stdout);
       else if (begin > end)
-        fputs (_(" (start > end)"), stdout);
+	fputs (_(" (start > end)"), stdout);
 
       putchar ('\n');
 
@@ -4418,10 +4549,10 @@ print_addr_index (unsigned int idx, unsigned int len)
 
 static void
 display_loc_list_dwo (struct dwarf_section *section,
-                      unsigned char **start_ptr,
-                      unsigned int debug_info_entry,
-                      unsigned long offset,
-                      int has_frame_base)
+		      unsigned char **start_ptr,
+		      unsigned int debug_info_entry,
+		      unsigned long offset,
+		      int has_frame_base)
 {
   unsigned char *start = *start_ptr;
   unsigned char *section_end = section->start + section->size;
@@ -4459,79 +4590,79 @@ display_loc_list_dwo (struct dwarf_section *section,
       printf ("    %8.8lx ", offset + (start - *start_ptr));
 
       if (start >= section_end)
-        {
-          warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
-                offset);
-          break;
-        }
+	{
+	  warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
+		offset);
+	  break;
+	}
 
       SAFE_BYTE_GET_AND_INC (entry_type, start, 1, section_end);
       switch (entry_type)
-        {
-          case 0: /* A terminating entry.  */
-            *start_ptr = start;
-	    printf (_("<End of list>\n"));
-            return;
-          case 1: /* A base-address entry.  */
-            idx = read_uleb128 (start, &bytes_read, section_end);
-            start += bytes_read;
-            print_addr_index (idx, 8);
-            printf ("         ");
-            printf (_("(base address selection entry)\n"));
-            continue;
-          case 2: /* A start/end entry.  */
-            idx = read_uleb128 (start, &bytes_read, section_end);
-            start += bytes_read;
-            print_addr_index (idx, 8);
-            idx = read_uleb128 (start, &bytes_read, section_end);
-            start += bytes_read;
-            print_addr_index (idx, 8);
-            break;
-          case 3: /* A start/length entry.  */
-            idx = read_uleb128 (start, &bytes_read, section_end);
-            start += bytes_read;
-            print_addr_index (idx, 8);
-	    SAFE_BYTE_GET_AND_INC (idx, start, 4, section_end);
-            printf ("%08x ", idx);
-            break;
-          case 4: /* An offset pair entry.  */
-	    SAFE_BYTE_GET_AND_INC (idx, start, 4, section_end);
-            printf ("%08x ", idx);
-	    SAFE_BYTE_GET_AND_INC (idx, start, 4, section_end);
-            printf ("%08x ", idx);
-            break;
-          default:
-            warn (_("Unknown location list entry type 0x%x.\n"), entry_type);
-            *start_ptr = start;
-            return;
-        }
+	{
+	case 0: /* A terminating entry.  */
+	  *start_ptr = start;
+	  printf (_("<End of list>\n"));
+	  return;
+	case 1: /* A base-address entry.  */
+	  idx = read_uleb128 (start, &bytes_read, section_end);
+	  start += bytes_read;
+	  print_addr_index (idx, 8);
+	  printf ("         ");
+	  printf (_("(base address selection entry)\n"));
+	  continue;
+	case 2: /* A start/end entry.  */
+	  idx = read_uleb128 (start, &bytes_read, section_end);
+	  start += bytes_read;
+	  print_addr_index (idx, 8);
+	  idx = read_uleb128 (start, &bytes_read, section_end);
+	  start += bytes_read;
+	  print_addr_index (idx, 8);
+	  break;
+	case 3: /* A start/length entry.  */
+	  idx = read_uleb128 (start, &bytes_read, section_end);
+	  start += bytes_read;
+	  print_addr_index (idx, 8);
+	  SAFE_BYTE_GET_AND_INC (idx, start, 4, section_end);
+	  printf ("%08x ", idx);
+	  break;
+	case 4: /* An offset pair entry.  */
+	  SAFE_BYTE_GET_AND_INC (idx, start, 4, section_end);
+	  printf ("%08x ", idx);
+	  SAFE_BYTE_GET_AND_INC (idx, start, 4, section_end);
+	  printf ("%08x ", idx);
+	  break;
+	default:
+	  warn (_("Unknown location list entry type 0x%x.\n"), entry_type);
+	  *start_ptr = start;
+	  return;
+	}
 
       if (start + 2 > section_end)
-        {
-          warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
-                offset);
-          break;
-        }
+	{
+	  warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
+		offset);
+	  break;
+	}
 
       SAFE_BYTE_GET_AND_INC (length, start, 2, section_end);
       if (start + length > section_end)
-        {
-          warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
-                offset);
-          break;
-        }
+	{
+	  warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
+		offset);
+	  break;
+	}
 
       putchar ('(');
       need_frame_base = decode_location_expression (start,
-                                                    pointer_size,
-                                                    offset_size,
-                                                    dwarf_version,
-                                                    length,
-                                                    cu_offset, section);
+						    pointer_size,
+						    offset_size,
+						    dwarf_version,
+						    length,
+						    cu_offset, section);
       putchar (')');
 
       if (need_frame_base && !has_frame_base)
-        printf (_(" [without DW_AT_frame_base]"));
+	printf (_(" [without DW_AT_frame_base]"));
 
       putchar ('\n');
 
@@ -4565,7 +4696,6 @@ 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 locs_sorted = 1;
   unsigned char *next;
@@ -4641,13 +4771,16 @@ display_debug_loc (struct dwarf_section *section, void *file)
   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"));
+  if (reloc_at (section, 0))
+    printf (_(" Warning: This section has relocations - addresses seen here may not be accurate.\n\n"));
+  printf (_("    Offset   Begin            End              Expression\n"));
 
   seen_first_offset = 0;
   for (i = first; i < num_debug_info_entries; i++)
     {
       unsigned long offset;
       unsigned long base_address;
+      unsigned int k;
       int has_frame_base;
 
       if (!locs_sorted)
@@ -4679,11 +4812,11 @@ display_debug_loc (struct dwarf_section *section, void *file)
 	      if (start < next)
 		warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
 		      (unsigned long) (start - section_begin),
-		      (unsigned long) (next - section_begin));
+		      (unsigned long) offset);
 	      else if (start > next)
 		warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
 		      (unsigned long) (start - section_begin),
-		      (unsigned long) (next - section_begin));
+		      (unsigned long) offset);
 	    }
 	  start = next;
 
@@ -4694,11 +4827,11 @@ display_debug_loc (struct dwarf_section *section, void *file)
 	      continue;
 	    }
 
-          if (is_dwo)
-            display_loc_list_dwo (section, &start, i, offset, has_frame_base);
-          else
-            display_loc_list (section, &start, i, offset, base_address,
-                              has_frame_base);
+	  if (is_dwo)
+	    display_loc_list_dwo (section, &start, i, offset, has_frame_base);
+	  else
+	    display_loc_list (section, &start, i, offset, base_address,
+			      has_frame_base);
 	}
     }
 
@@ -4840,7 +4973,12 @@ display_debug_aranges (struct dwarf_section *section,
 
       if (arange.ar_version != 2 && arange.ar_version != 3)
 	{
-	  warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
+	  /* PR 19872: A version number of 0 probably means that there is
+	     padding at the end of the .debug_aranges section.  Gold puts
+	     it there when performing an incremental link, for example.
+	     So do not generate a warning in this case.  */
+	  if (arange.ar_version)
+	    warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
 	  break;
 	}
 
@@ -4883,7 +5021,13 @@ display_debug_aranges (struct dwarf_section *section,
       if (excess)
 	addr_ranges += (2 * address_size) - excess;
 
-      start += arange.ar_length + initial_length_size;
+      hdrptr = start + arange.ar_length + initial_length_size;
+      if (hdrptr < start || hdrptr > end)
+	{
+	  error (_("Excessive header length: %lx\n"), (long) arange.ar_length);
+	  break;
+	}
+      start = hdrptr;
 
       while (addr_ranges + 2 * address_size <= start)
 	{
@@ -4914,7 +5058,7 @@ comp_addr_base (const void * v0, const void * v1)
 /* Display the debug_addr section.  */
 static int
 display_debug_addr (struct dwarf_section *section,
-                    void *file)
+		    void *file)
 {
   debug_info **debug_addr_info;
   unsigned char *entry;
@@ -4942,7 +5086,7 @@ display_debug_addr (struct dwarf_section *section,
      fields in the debug_info structure, which means that the sort below might
      try to move uninitialised data.  */
   debug_addr_info = (debug_info **) xcalloc ((num_debug_info_entries + 1),
-                                             sizeof (debug_info *));
+					     sizeof (debug_info *));
 
   count = 0;
   for (i = 0; i < num_debug_info_entries; i++)
@@ -4967,21 +5111,21 @@ display_debug_addr (struct dwarf_section *section,
       unsigned int address_size = debug_addr_info [i]->pointer_size;
 
       printf (_("  For compilation unit at offset 0x%s:\n"),
-              dwarf_vmatoa ("x", debug_addr_info [i]->cu_offset));
+	      dwarf_vmatoa ("x", debug_addr_info [i]->cu_offset));
 
       printf (_("\tIndex\tAddress\n"));
       entry = section->start + debug_addr_info [i]->addr_base;
       end = section->start + debug_addr_info [i + 1]->addr_base;
       idx = 0;
       while (entry < end)
-        {
-          dwarf_vma base = byte_get (entry, address_size);
-          printf (_("\t%d:\t"), idx);
-          print_dwarf_vma (base, address_size);
-          printf ("\n");
-          entry += address_size;
-          idx++;
-        }
+	{
+	  dwarf_vma base = byte_get (entry, address_size);
+	  printf (_("\t%d:\t"), idx);
+	  print_dwarf_vma (base, address_size);
+	  printf ("\n");
+	  entry += address_size;
+	  idx++;
+	}
     }
   printf ("\n");
 
@@ -4992,7 +5136,7 @@ display_debug_addr (struct dwarf_section *section,
 /* Display the .debug_str_offsets and .debug_str_offsets.dwo sections.  */
 static int
 display_debug_str_offsets (struct dwarf_section *section,
-                           void *file ATTRIBUTE_UNUSED)
+			   void *file ATTRIBUTE_UNUSED)
 {
   if (section->size == 0)
     {
@@ -5061,7 +5205,7 @@ display_debug_ranges (struct dwarf_section *section,
   if (num_range_list == 0)
     {
       /* This can happen when the file was compiled with -gsplit-debug
-         which removes references to range lists from the primary .o file.  */
+	 which removes references to range lists from the primary .o file.  */
       printf (_("No range lists in .debug_info section.\n"));
       return 1;
     }
@@ -5114,7 +5258,7 @@ display_debug_ranges (struct dwarf_section *section,
 		pointer_size, offset);
 	  continue;
 	}
-      
+
       if (dwarf_check != 0 && i > 0)
 	{
 	  if (start < next)
@@ -5138,11 +5282,6 @@ display_debug_ranges (struct dwarf_section *section,
 	  dwarf_vma begin;
 	  dwarf_vma end;
 
-	  /* Note: we use sign extension here in order to be sure that
-	     we can detect the -1 escape value.  Sign extension into the
-	     top 32 bits of a 32-bit address will not affect the values
-	     that we display since we always show hex values, and always
-	     the bottom 32-bits.  */
 	  SAFE_BYTE_GET_AND_INC (begin, start, pointer_size, finish);
 	  if (start >= finish)
 	    break;
@@ -5157,7 +5296,8 @@ display_debug_ranges (struct dwarf_section *section,
 	    }
 
 	  /* Check base address specifiers.  */
-	  if (begin == (dwarf_vma) -1 && end != (dwarf_vma) -1)
+          if (is_max_address (begin, pointer_size)
+              && !is_max_address (end, pointer_size))
 	    {
 	      base_address = end;
 	      print_dwarf_vma (begin, pointer_size);
@@ -5198,7 +5338,7 @@ typedef struct Frame_Chunk
   dwarf_vma pc_begin;
   dwarf_vma pc_range;
   int cfa_reg;
-  int cfa_offset;
+  dwarf_vma cfa_offset;
   unsigned int ra;
   unsigned char fde_encoding;
   unsigned char cfa_exp;
@@ -5246,9 +5386,9 @@ frame_need_space (Frame_Chunk *fc, unsigned int reg)
     }
 
   fc->col_type = (short int *) xcrealloc (fc->col_type, fc->ncols,
-                                          sizeof (short int));
+					  sizeof (short int));
   fc->col_offset = (int *) xcrealloc (fc->col_offset, fc->ncols, sizeof (int));
-  /* PR 17512: file:002-10025-0.005.  */ 
+  /* PR 17512: file:002-10025-0.005.  */
   if (fc->col_type == NULL || fc->col_offset == NULL)
     {
       error (_("Out of memory allocating %u columns in dwarf frame arrays\n"),
@@ -5290,6 +5430,27 @@ static const char *const dwarf_regnames_i386[] =
   "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7"  /* 93 - 100  */
 };
 
+static const char *const dwarf_regnames_iamcu[] =
+{
+  "eax", "ecx", "edx", "ebx",			  /* 0 - 3  */
+  "esp", "ebp", "esi", "edi",			  /* 4 - 7  */
+  "eip", "eflags", NULL,			  /* 8 - 10  */
+  NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 11 - 18  */
+  NULL, NULL,					  /* 19 - 20  */
+  NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 21 - 28  */
+  NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 29 - 36  */
+  NULL, NULL, NULL,				  /* 37 - 39  */
+  "es", "cs", "ss", "ds", "fs", "gs", NULL, NULL, /* 40 - 47  */
+  "tr", "ldtr",					  /* 48 - 49  */
+  NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 50 - 57  */
+  NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 58 - 65  */
+  NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 66 - 73  */
+  NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 74 - 81  */
+  NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 82 - 89  */
+  NULL, NULL, NULL,				  /* 90 - 92  */
+  NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL  /* 93 - 100  */
+};
+
 void
 init_dwarf_regnames_i386 (void)
 {
@@ -5297,6 +5458,13 @@ init_dwarf_regnames_i386 (void)
   dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_i386);
 }
 
+void
+init_dwarf_regnames_iamcu (void)
+{
+  dwarf_regnames = dwarf_regnames_iamcu;
+  dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_iamcu);
+}
+
 static const char *const dwarf_regnames_x86_64[] =
 {
   "rax", "rdx", "rcx", "rbx",
@@ -5338,16 +5506,16 @@ init_dwarf_regnames_x86_64 (void)
 
 static const char *const dwarf_regnames_aarch64[] =
 {
-   "x0",  "x1",  "x2",  "x3",  "x4",  "x5",  "x6",  "x7", 
-   "x8",  "x9", "x10", "x11", "x12", "x13", "x14", "x15", 
+   "x0",  "x1",  "x2",  "x3",  "x4",  "x5",  "x6",  "x7",
+   "x8",  "x9", "x10", "x11", "x12", "x13", "x14", "x15",
   "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23",
   "x24", "x25", "x26", "x27", "x28", "x29", "x30", "sp",
    NULL, "elr",  NULL,  NULL,  NULL,  NULL,  NULL,  NULL,
    NULL,  NULL,  NULL,  NULL,  NULL,  NULL,  NULL,  NULL,
    NULL,  NULL,  NULL,  NULL,  NULL,  NULL,  NULL,  NULL,
    NULL,  NULL,  NULL,  NULL,  NULL,  NULL,  NULL,  NULL,
-   "v0",  "v1",  "v2",  "v3",  "v4",  "v5",  "v6",  "v7", 
-   "v8",  "v9", "v10", "v11", "v12", "v13", "v14", "v15", 
+   "v0",  "v1",  "v2",  "v3",  "v4",  "v5",  "v6",  "v7",
+   "v8",  "v9", "v10", "v11", "v12", "v13", "v14", "v15",
   "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
   "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
 };
@@ -5359,16 +5527,43 @@ init_dwarf_regnames_aarch64 (void)
   dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_aarch64);
 }
 
+static const char *const dwarf_regnames_s390[] =
+{
+  /* Avoid saying "r5 (r5)", so omit the names of r0-r15.  */
+  NULL,  NULL,  NULL,  NULL,  NULL,  NULL,  NULL,  NULL,
+  NULL,  NULL,  NULL,  NULL,  NULL,  NULL,  NULL,  NULL,
+  "f0",  "f2",  "f4",  "f6",  "f1",  "f3",  "f5",  "f7",
+  "f8",  "f10", "f12", "f14", "f9",  "f11", "f13", "f15",
+  "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
+  "cr8", "cr9", "cr10", "cr11", "cr12", "cr13", "cr14", "cr15",
+  "a0",  "a1",  "a2",  "a3",  "a4",  "a5",  "a6",  "a7",
+  "a8",  "a9",  "a10", "a11", "a12", "a13", "a14", "a15",
+  "pswm", "pswa",
+  NULL, NULL,
+  "v16", "v18", "v20", "v22", "v17", "v19", "v21", "v23",
+  "v24", "v26", "v28", "v30", "v25", "v27", "v29", "v31",
+};
+
+void
+init_dwarf_regnames_s390 (void)
+{
+  dwarf_regnames = dwarf_regnames_s390;
+  dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_s390);
+}
+
 void
 init_dwarf_regnames (unsigned int e_machine)
 {
   switch (e_machine)
     {
     case EM_386:
-    case EM_486:
       init_dwarf_regnames_i386 ();
       break;
 
+    case EM_IAMCU:
+      init_dwarf_regnames_iamcu ();
+      break;
+
     case EM_X86_64:
     case EM_L1OM:
     case EM_K1OM:
@@ -5379,6 +5574,10 @@ init_dwarf_regnames (unsigned int e_machine)
       init_dwarf_regnames_aarch64 ();
       break;
 
+    case EM_S390:
+      init_dwarf_regnames_s390 ();
+      break;
+
     default:
       break;
     }
@@ -5408,7 +5607,7 @@ frame_display_row (Frame_Chunk *fc, int *need_col_headers, unsigned int *max_reg
   unsigned int r;
   char tmp[100];
 
-  if (*max_regs < fc->ncols)
+  if (*max_regs != fc->ncols)
     *max_regs = fc->ncols;
 
   if (*need_col_headers)
@@ -5423,7 +5622,7 @@ frame_display_row (Frame_Chunk *fc, int *need_col_headers, unsigned int *max_reg
 	if (fc->col_type[r] != DW_CFA_unreferenced)
 	  {
 	    if (r == fc->ra)
-	      printf ("ra      ");
+	      printf ("ra    ");
 	    else
 	      printf ("%-5s ", regname (r, 1));
 	  }
@@ -5435,7 +5634,7 @@ frame_display_row (Frame_Chunk *fc, int *need_col_headers, unsigned int *max_reg
   if (fc->cfa_exp)
     strcpy (tmp, "exp");
   else
-    sprintf (tmp, "%s%+d", regname (fc->cfa_reg, 1), fc->cfa_offset);
+    sprintf (tmp, "%s%+d", regname (fc->cfa_reg, 1), (int) fc->cfa_offset);
   printf ("%-8s ", tmp);
 
   for (r = 0; r < fc->ncols; r++)
@@ -5521,7 +5720,20 @@ read_cie (unsigned char *start, unsigned char *end,
   if (version >= 4)
     {
       GET (fc->ptr_size, 1);
+      if (fc->ptr_size < 1 || fc->ptr_size > 8)
+	{
+	  warn (_("Invalid pointer size (%d) in CIE data\n"), fc->ptr_size);
+	  return end;
+	}
+
       GET (fc->segment_size, 1);
+      /* PR 17512: file: e99d2804.  */
+      if (fc->segment_size > 8 || fc->segment_size + fc->ptr_size > 8)
+	{
+	  warn (_("Invalid segment size (%d) in CIE data\n"), fc->segment_size);
+	  return end;
+	}
+
       eh_addr_size = fc->ptr_size;
     }
   else
@@ -5558,7 +5770,7 @@ read_cie (unsigned char *start, unsigned char *end,
       unsigned char *p;
       unsigned char *q;
       unsigned char *qend;
-      
+
       p = (unsigned char *) fc->augmentation + 1;
       q = augmentation_data;
       qend = q + augmentation_data_len;
@@ -5613,7 +5825,7 @@ display_debug_frames (struct dwarf_section *section,
   unsigned int length_return;
   unsigned int max_regs = 0;
   const char *bad_reg = _("bad register: ");
-  int saved_eh_addr_size = eh_addr_size;
+  unsigned int saved_eh_addr_size = eh_addr_size;
 
   printf (_("Contents of the %s section:\n"), section->name);
 
@@ -5631,6 +5843,7 @@ display_debug_frames (struct dwarf_section *section,
       unsigned int encoded_ptr_size = saved_eh_addr_size;
       unsigned int offset_size;
       unsigned int initial_length_size;
+      bfd_boolean all_nops;
 
       saved_start = start;
 
@@ -5862,7 +6075,15 @@ display_debug_frames (struct dwarf_section *section,
 
 	  segment_selector = 0;
 	  if (fc->segment_size)
-	    SAFE_BYTE_GET_AND_INC (segment_selector, start, fc->segment_size, end);
+	    {
+	      if (fc->segment_size > sizeof (segment_selector))
+		{
+		  /* PR 17512: file: 9e196b3e.  */
+		  warn (_("Probably corrupt segment size: %d - using 4 instead\n"), fc->segment_size);
+		  fc->segment_size = 4;
+		}
+	      SAFE_BYTE_GET_AND_INC (segment_selector, start, fc->segment_size, end);
+	    }
 
 	  fc->pc_begin = get_encoded_value (&start, fc->fde_encoding, section, end);
 
@@ -5930,6 +6151,7 @@ display_debug_frames (struct dwarf_section *section,
 	    {
 	      unsigned int reg, op, opa;
 	      unsigned long temp;
+	      unsigned char * new_start;
 
 	      op = *start++;
 	      opa = op & 0x3f;
@@ -6000,26 +6222,28 @@ display_debug_frames (struct dwarf_section *section,
 		  break;
 		case DW_CFA_def_cfa_expression:
 		  temp = LEB ();
-		  if (start + temp < start)
+		  new_start = start + temp;
+		  if (new_start < start)
 		    {
 		      warn (_("Corrupt CFA_def expression value: %lu\n"), temp);
 		      start = block_end;
 		    }
 		  else
-		    start += temp;
+		    start = new_start;
 		  break;
 		case DW_CFA_expression:
 		case DW_CFA_val_expression:
 		  reg = LEB ();
 		  temp = LEB ();
-		  if (start + temp < start)
+		  new_start = start + temp;
+		  if (new_start < start)
 		    {
-		      /* PR 17512: file:306-192417-0.005.  */ 
+		      /* PR 17512: file:306-192417-0.005.  */
 		      warn (_("Corrupt CFA expression value: %lu\n"), temp);
 		      start = block_end;
 		    }
 		  else
-		    start += temp;
+		    start = new_start;
 		  if (frame_need_space (fc, reg) >= 0)
 		    fc->col_type[reg] = DW_CFA_undefined;
 		  break;
@@ -6053,14 +6277,17 @@ display_debug_frames (struct dwarf_section *section,
 	  start = tmp;
 	}
 
+      all_nops = TRUE;
+
       /* Now we know what registers are used, make a second pass over
 	 the chunk, this time actually printing out the info.  */
 
       while (start < block_end)
 	{
+	  unsigned char * tmp;
 	  unsigned op, opa;
 	  unsigned long ul, reg, roffs;
-	  long l;
+	  dwarf_vma l;
 	  dwarf_vma ofs;
 	  dwarf_vma vma;
 	  const char *reg_prefix = "";
@@ -6070,6 +6297,10 @@ display_debug_frames (struct dwarf_section *section,
 	  if (op & 0xc0)
 	    op &= 0xc0;
 
+	  /* Make a note if something other than DW_CFA_nop happens.  */
+	  if (op != DW_CFA_nop)
+	    all_nops = FALSE;
+
 	  /* Warning: if you add any more cases to this switch, be
 	     sure to add them to the corresponding switch above.  */
 	  switch (op)
@@ -6080,7 +6311,7 @@ display_debug_frames (struct dwarf_section *section,
 	      else
 		printf ("  DW_CFA_advance_loc: %d to %s\n",
 			opa * fc->code_factor,
-			dwarf_vmatoa_1 (NULL, 
+			dwarf_vmatoa_1 (NULL,
 					fc->pc_begin + opa * fc->code_factor,
 					fc->ptr_size));
 	      fc->pc_begin += opa * fc->code_factor;
@@ -6102,19 +6333,25 @@ display_debug_frames (struct dwarf_section *section,
 	      break;
 
 	    case DW_CFA_restore:
-	      if (opa >= (unsigned int) cie->ncols
-		  || opa >= (unsigned int) fc->ncols)
+	      if (opa >= (unsigned int) fc->ncols)
 		reg_prefix = bad_reg;
 	      if (! do_debug_frames_interp || *reg_prefix != '\0')
 		printf ("  DW_CFA_restore: %s%s\n",
 			reg_prefix, regname (opa, 0));
-	      if (*reg_prefix == '\0')
+	      if (*reg_prefix != '\0')
+		break;
+
+	      if (opa >= (unsigned int) cie->ncols
+		  || (do_debug_frames_interp
+		      && cie->col_type[opa] == DW_CFA_unreferenced))
+		{
+		  fc->col_type[opa] = DW_CFA_undefined;
+		  fc->col_offset[opa] = 0;
+		}
+	      else
 		{
 		  fc->col_type[opa] = cie->col_type[opa];
 		  fc->col_offset[opa] = cie->col_offset[opa];
-		  if (do_debug_frames_interp
-		      && fc->col_type[opa] == DW_CFA_unreferenced)
-		    fc->col_type[opa] = DW_CFA_undefined;
 		}
 	      break;
 
@@ -6189,7 +6426,7 @@ display_debug_frames (struct dwarf_section *section,
 	      if (reg >= (unsigned int) fc->ncols)
 		reg_prefix = bad_reg;
 	      if (! do_debug_frames_interp || *reg_prefix != '\0')
-		printf ("  DW_CFA_val_offset: %s%s at cfa%+ld\n",
+		printf ("  DW_CFA_val_offset: %s%s is cfa%+ld\n",
 			reg_prefix, regname (reg, 0),
 			roffs * fc->data_factor);
 	      if (*reg_prefix == '\0')
@@ -6201,13 +6438,20 @@ display_debug_frames (struct dwarf_section *section,
 
 	    case DW_CFA_restore_extended:
 	      reg = LEB ();
-	      if (reg >= (unsigned int) cie->ncols
-		  || reg >= (unsigned int) fc->ncols)
+	      if (reg >= (unsigned int) fc->ncols)
 		reg_prefix = bad_reg;
 	      if (! do_debug_frames_interp || *reg_prefix != '\0')
 		printf ("  DW_CFA_restore_extended: %s%s\n",
 			reg_prefix, regname (reg, 0));
-	      if (*reg_prefix == '\0')
+	      if (*reg_prefix != '\0')
+		break;
+
+	      if (reg >= (unsigned int) cie->ncols)
+		{
+		  fc->col_type[reg] = DW_CFA_undefined;
+		  fc->col_offset[reg] = 0;
+		}
+	      else
 		{
 		  fc->col_type[reg] = cie->col_type[reg];
 		  fc->col_offset[reg] = cie->col_offset[reg];
@@ -6264,13 +6508,13 @@ display_debug_frames (struct dwarf_section *section,
 	      if (! do_debug_frames_interp)
 		printf ("  DW_CFA_remember_state\n");
 	      rs = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
-              rs->cfa_offset = fc->cfa_offset;
+	      rs->cfa_offset = fc->cfa_offset;
 	      rs->cfa_reg = fc->cfa_reg;
 	      rs->ra = fc->ra;
 	      rs->cfa_exp = fc->cfa_exp;
 	      rs->ncols = fc->ncols;
 	      rs->col_type = (short int *) xcmalloc (rs->ncols,
-                                                     sizeof (* rs->col_type));
+						     sizeof (* rs->col_type));
 	      rs->col_offset = (int *) xcmalloc (rs->ncols, sizeof (* rs->col_offset));
 	      memcpy (rs->col_type, fc->col_type, rs->ncols * sizeof (* fc->col_type));
 	      memcpy (rs->col_offset, fc->col_offset, rs->ncols * sizeof (* fc->col_offset));
@@ -6287,8 +6531,8 @@ display_debug_frames (struct dwarf_section *section,
 		  remembered_state = rs->next;
 		  fc->cfa_offset = rs->cfa_offset;
 		  fc->cfa_reg = rs->cfa_reg;
-	          fc->ra = rs->ra;
-	          fc->cfa_exp = rs->cfa_exp;
+		  fc->ra = rs->ra;
+		  fc->cfa_exp = rs->cfa_exp;
 		  if (frame_need_space (fc, rs->ncols - 1) < 0)
 		    {
 		      warn (_("Invalid column number in saved frame state\n"));
@@ -6312,7 +6556,7 @@ display_debug_frames (struct dwarf_section *section,
 	      fc->cfa_exp = 0;
 	      if (! do_debug_frames_interp)
 		printf ("  DW_CFA_def_cfa: %s ofs %d\n",
-			regname (fc->cfa_reg, 0), fc->cfa_offset);
+			regname (fc->cfa_reg, 0), (int) fc->cfa_offset);
 	      break;
 
 	    case DW_CFA_def_cfa_register:
@@ -6326,7 +6570,7 @@ display_debug_frames (struct dwarf_section *section,
 	    case DW_CFA_def_cfa_offset:
 	      fc->cfa_offset = LEB ();
 	      if (! do_debug_frames_interp)
-		printf ("  DW_CFA_def_cfa_offset: %d\n", fc->cfa_offset);
+		printf ("  DW_CFA_def_cfa_offset: %d\n", (int) fc->cfa_offset);
 	      break;
 
 	    case DW_CFA_nop:
@@ -6336,7 +6580,7 @@ display_debug_frames (struct dwarf_section *section,
 
 	    case DW_CFA_def_cfa_expression:
 	      ul = LEB ();
-	      if (start >= block_end || start + ul > block_end || start + ul < start)
+	      if (start >= block_end || ul > (unsigned long) (block_end - start))
 		{
 		  printf (_("  DW_CFA_def_cfa_expression: <corrupt len %lu>\n"), ul);
 		  break;
@@ -6359,7 +6603,8 @@ display_debug_frames (struct dwarf_section *section,
 		reg_prefix = bad_reg;
 	      /* PR 17512: file: 069-133014-0.006.  */
 	      /* PR 17512: file: 98c02eb4.  */
-	      if (start >= block_end || start + ul > block_end || start + ul < start)
+	      tmp = start + ul;
+	      if (start >= block_end || tmp > block_end || tmp < start)
 		{
 		  printf (_("  DW_CFA_expression: <corrupt len %lu>\n"), ul);
 		  break;
@@ -6374,7 +6619,7 @@ display_debug_frames (struct dwarf_section *section,
 		}
 	      if (*reg_prefix == '\0')
 		fc->col_type[reg] = DW_CFA_expression;
-	      start += ul;
+	      start = tmp;
 	      break;
 
 	    case DW_CFA_val_expression:
@@ -6382,7 +6627,8 @@ display_debug_frames (struct dwarf_section *section,
 	      ul = LEB ();
 	      if (reg >= (unsigned int) fc->ncols)
 		reg_prefix = bad_reg;
-	      if (start >= block_end || start + ul > block_end || start + ul < start)
+	      tmp = start + ul;
+	      if (start >= block_end || tmp > block_end || tmp < start)
 		{
 		  printf ("  DW_CFA_val_expression: <corrupt len %lu>\n", ul);
 		  break;
@@ -6397,7 +6643,7 @@ display_debug_frames (struct dwarf_section *section,
 		}
 	      if (*reg_prefix == '\0')
 		fc->col_type[reg] = DW_CFA_val_expression;
-	      start += ul;
+	      start = tmp;
 	      break;
 
 	    case DW_CFA_offset_extended_sf:
@@ -6408,7 +6654,7 @@ display_debug_frames (struct dwarf_section *section,
 	      if (! do_debug_frames_interp || *reg_prefix != '\0')
 		printf ("  DW_CFA_offset_extended_sf: %s%s at cfa%+ld\n",
 			reg_prefix, regname (reg, 0),
-			l * fc->data_factor);
+			(long)(l * fc->data_factor));
 	      if (*reg_prefix == '\0')
 		{
 		  fc->col_type[reg] = DW_CFA_offset;
@@ -6422,9 +6668,9 @@ display_debug_frames (struct dwarf_section *section,
 	      if (frame_need_space (fc, reg) < 0)
 		reg_prefix = bad_reg;
 	      if (! do_debug_frames_interp || *reg_prefix != '\0')
-		printf ("  DW_CFA_val_offset_sf: %s%s at cfa%+ld\n",
+		printf ("  DW_CFA_val_offset_sf: %s%s is cfa%+ld\n",
 			reg_prefix, regname (reg, 0),
-			l * fc->data_factor);
+			(long)(l * fc->data_factor));
 	      if (*reg_prefix == '\0')
 		{
 		  fc->col_type[reg] = DW_CFA_val_offset;
@@ -6439,14 +6685,14 @@ display_debug_frames (struct dwarf_section *section,
 	      fc->cfa_exp = 0;
 	      if (! do_debug_frames_interp)
 		printf ("  DW_CFA_def_cfa_sf: %s ofs %d\n",
-			regname (fc->cfa_reg, 0), fc->cfa_offset);
+			regname (fc->cfa_reg, 0), (int) fc->cfa_offset);
 	      break;
 
 	    case DW_CFA_def_cfa_offset_sf:
 	      fc->cfa_offset = SLEB ();
-	      fc->cfa_offset = fc->cfa_offset * fc->data_factor;
+	      fc->cfa_offset *= fc->data_factor;
 	      if (! do_debug_frames_interp)
-		printf ("  DW_CFA_def_cfa_offset_sf: %d\n", fc->cfa_offset);
+		printf ("  DW_CFA_def_cfa_offset_sf: %d\n", (int) fc->cfa_offset);
 	      break;
 
 	    case DW_CFA_MIPS_advance_loc8:
@@ -6481,7 +6727,7 @@ display_debug_frames (struct dwarf_section *section,
 	      if (! do_debug_frames_interp || *reg_prefix != '\0')
 		printf ("  DW_CFA_GNU_negative_offset_extended: %s%s at cfa%+ld\n",
 			reg_prefix, regname (reg, 0),
-			l * fc->data_factor);
+			(long)(l * fc->data_factor));
 	      if (*reg_prefix == '\0')
 		{
 		  fc->col_type[reg] = DW_CFA_offset;
@@ -6498,7 +6744,8 @@ display_debug_frames (struct dwarf_section *section,
 	    }
 	}
 
-      if (do_debug_frames_interp)
+      /* Interpret the CFA - as long as it is not completely full of NOPs.  */
+      if (do_debug_frames_interp && ! all_nops)
 	frame_display_row (fc, &need_col_headers, &max_regs);
 
       start = block_end;
@@ -6626,7 +6873,7 @@ display_gdb_index (struct dwarf_section *section,
       warn (_("Address table extends beyond end of section.\n"));
       return 0;
     }
-  
+
   printf (_("\nCU table:\n"));
   for (i = 0; i < cu_list_elements; i += 2)
     {
@@ -6676,10 +6923,11 @@ display_gdb_index (struct dwarf_section *section,
 	  || cu_vector_offset != 0)
 	{
 	  unsigned int j;
+	  unsigned char * adr;
 
+	  adr = constant_pool + name_offset;
 	  /* PR 17531: file: 5b7b07ad.  */
-	  if (constant_pool + name_offset < constant_pool
-	      || constant_pool + name_offset >= section->start + section->size)
+	  if (adr < constant_pool || adr >= section->start + section->size)
 	    {
 	      printf (_("[%3u] <corrupt offset: %x>"), i, name_offset);
 	      warn (_("Corrupt name offset of 0x%x found for symbol table slot %d\n"),
@@ -6690,20 +6938,21 @@ display_gdb_index (struct dwarf_section *section,
 		    (int) (section->size - (constant_pool_offset + name_offset)),
 		    constant_pool + name_offset);
 
-	  if (constant_pool + cu_vector_offset < constant_pool
-	      || constant_pool + cu_vector_offset >= section->start + section->size)
+	  adr = constant_pool + cu_vector_offset;
+	  if (adr < constant_pool || adr >= section->start + section->size - 3)
 	    {
 	      printf (_("<invalid CU vector offset: %x>\n"), cu_vector_offset);
 	      warn (_("Corrupt CU vector offset of 0x%x found for symbol table slot %d\n"),
 		    cu_vector_offset, i);
 	      continue;
 	    }
-	  else
-	    num_cus = byte_get_little_endian (constant_pool + cu_vector_offset, 4);
 
+	  num_cus = byte_get_little_endian (adr, 4);
+
+	  adr = constant_pool + cu_vector_offset + 4 + num_cus * 4;
 	  if (num_cus * 4 < num_cus
-	      || constant_pool + cu_vector_offset + 4 + num_cus * 4 >=
-	      section->start + section->size)
+	      || adr >= section->start + section->size
+	      || adr < constant_pool)
 	    {
 	      printf ("<invalid number of CUs: %d>\n", num_cus);
 	      warn (_("Invalid number of CUs (0x%x) for symbol table slot %d\n"),
@@ -6713,6 +6962,7 @@ display_gdb_index (struct dwarf_section *section,
 
 	  if (num_cus > 1)
 	    printf ("\n");
+
 	  for (j = 0; j < num_cus; ++j)
 	    {
 	      int is_static;
@@ -6811,7 +7061,7 @@ get_DW_SECT_short_name (unsigned int dw_sect)
       case DW_SECT_MACRO:
 	return "macro";
       default:
-        break;
+	break;
     }
 
   snprintf (buf, sizeof (buf), "%d", dw_sect);
@@ -6864,6 +7114,14 @@ process_cu_tu_index (struct dwarf_section *section, int do_display)
   pindex = phash + nslots * 8;
   ppool = pindex + nslots * 4;
 
+  /* PR 17531: file: 45d69832.  */
+  if (pindex < phash || ppool < phdr || (pindex == phash && nslots != 0))
+    {
+      warn (_("Section %s is too small for %d slots\n"),
+	    section->name, nslots);
+      return 0;
+    }
+
   if (do_display)
     {
       printf (_("Contents of the %s section:\n\n"), section->name);
@@ -6874,7 +7132,7 @@ process_cu_tu_index (struct dwarf_section *section, int do_display)
       printf (_("  Number of slots:         %d\n\n"), nslots);
     }
 
-  if (ppool > limit)
+  if (ppool > limit || ppool < phdr)
     {
       warn (_("Section %s too small for %d hash table entries\n"),
 	    section->name, nslots);
@@ -6895,6 +7153,13 @@ process_cu_tu_index (struct dwarf_section *section, int do_display)
 	    {
 	      SAFE_BYTE_GET (j, pindex, 4, limit);
 	      shndx_list = ppool + j * 4;
+	      /* PR 17531: file: 705e010d.  */
+	      if (shndx_list < ppool)
+		{
+		  warn (_("Section index pool located before start of section\n"));
+		  return 0;
+		}
+
 	      if (do_display)
 		printf (_("  [%3d] Signature:  0x%s  Sections: "),
 			i, dwarf_vmatoa64 (signature_high, signature_low,
@@ -6941,6 +7206,14 @@ process_cu_tu_index (struct dwarf_section *section, int do_display)
 
       is_tu_index = strcmp (section->name, ".debug_tu_index") == 0;
 
+      /* PR 17531: file: 0dd159bf.
+	 Check for wraparound with an overlarge ncols value.  */
+      if (poffsets < ppool || (unsigned int) ((poffsets - ppool) / 4) != ncols)
+	{
+	  warn (_("Overlarge number of columns: %x\n"), ncols);
+	  return 0;
+	}
+
       if (pend > limit)
 	{
 	  warn (_("Section %s too small for offset and size tables\n"),
@@ -6999,6 +7272,13 @@ process_cu_tu_index (struct dwarf_section *section, int do_display)
 		memcpy (&this_set[row - 1].signature, ph, sizeof (uint64_t));
 
 	      prow = poffsets + (row - 1) * ncols * 4;
+	      /* PR 17531: file: b8ce60a8.  */
+	      if (prow < poffsets || prow > limit)
+		{
+		  warn (_("Row index (%u) * num columns (%u) > space remaining in section\n"),
+			row, ncols);
+		  return 0;
+		}
 
 	      if (do_display)
 		printf (_("  [%3d] 0x%s"),
@@ -7031,12 +7311,12 @@ process_cu_tu_index (struct dwarf_section *section, int do_display)
       ph = phash;
       pi = pindex;
       if (do_display)
-        {
+	{
 	  printf ("\n");
 	  printf (_("  Size table\n"));
 	  printf ("  slot  %-16s  ",
 		 is_tu_index ? _("signature") : _("dwo_id"));
-        }
+	}
 
       for (j = 0; j < ncols; j++)
 	{
@@ -7178,7 +7458,12 @@ xcmalloc (size_t nmemb, size_t size)
 {
   /* Check for overflow.  */
   if (nmemb >= ~(size_t) 0 / size)
-    return NULL;
+    {
+      fprintf (stderr,
+	       _("Attempt to allocate an array with an excessive number of elements: 0x%lx\n"),
+	       (long) nmemb);
+      xexit (1);
+    }
 
   return xmalloc (nmemb * size);
 }
@@ -7191,7 +7476,12 @@ xcrealloc (void *ptr, size_t nmemb, size_t size)
 {
   /* Check for overflow.  */
   if (nmemb >= ~(size_t) 0 / size)
-    return NULL;
+    {
+      fprintf (stderr,
+	       _("Attempt to re-allocate an array with an excessive number of elements: 0x%lx\n"),
+	       (long) nmemb);
+      xexit (1);
+    }
 
   return xrealloc (ptr, nmemb * size);
 }
@@ -7202,7 +7492,12 @@ xcalloc2 (size_t nmemb, size_t size)
 {
   /* Check for overflow.  */
   if (nmemb >= ~(size_t) 0 / size)
-    return NULL;
+    {
+      fprintf (stderr,
+	       _("Attempt to allocate a zero'ed array with an excessive number of elements: 0x%lx\n"),
+	       (long) nmemb);
+      xexit (1);
+    }
 
   return xcalloc (nmemb, size);
 }
@@ -7361,6 +7656,7 @@ dwarf_select_sections_by_letters (const char *letters)
 
       case 'F':
 	do_debug_frames_interp = 1;
+	/* Fall through.  */
       case 'f':
 	do_debug_frames = 1;
 	break;
@@ -7378,7 +7674,7 @@ dwarf_select_sections_by_letters (const char *letters)
 	break;
 
       default:
-	warn (_("Unrecognized debug option '%s'\n"), optarg);
+	warn (_("Unrecognized debug option '%s'\n"), letters);
 	break;
       }
 }
@@ -7407,76 +7703,76 @@ dwarf_select_sections_all (void)
 
 struct dwarf_section_display debug_displays[] =
 {
-  { { ".debug_abbrev",	    ".zdebug_abbrev",	NULL, NULL, 0, 0, 0, NULL },
-    display_debug_abbrev,   &do_debug_abbrevs,	0 },
-  { { ".debug_aranges",	    ".zdebug_aranges",	NULL, NULL, 0, 0, 0, NULL },
-    display_debug_aranges,  &do_debug_aranges,	1 },
-  { { ".debug_frame",       ".zdebug_frame",	NULL, NULL, 0, 0, 0, NULL },
-    display_debug_frames,   &do_debug_frames,	1 },
-  { { ".debug_info",	    ".zdebug_info",	NULL, NULL, 0, 0, abbrev, NULL },
-    display_debug_info,	    &do_debug_info,	1 },
-  { { ".debug_line",	    ".zdebug_line",	NULL, NULL, 0, 0, 0, NULL },
-    display_debug_lines,    &do_debug_lines,	1 },
-  { { ".debug_pubnames",    ".zdebug_pubnames",	NULL, NULL, 0, 0, 0, NULL },
-    display_debug_pubnames, &do_debug_pubnames,	0 },
-  { { ".debug_gnu_pubnames", ".zdebug_gnu_pubnames", NULL, NULL, 0, 0, 0, NULL },
-    display_debug_gnu_pubnames, &do_debug_pubnames, 0 },
-  { { ".eh_frame",	    "",			NULL, NULL, 0, 0, 0, NULL },
-    display_debug_frames,   &do_debug_frames,	1 },
-  { { ".debug_macinfo",	    ".zdebug_macinfo",	NULL, NULL, 0, 0, 0, NULL },
-    display_debug_macinfo,  &do_debug_macinfo,	0 },
-  { { ".debug_macro",	    ".zdebug_macro",	NULL, NULL, 0, 0, 0, NULL },
-    display_debug_macro,    &do_debug_macinfo,	1 },
-  { { ".debug_str",	    ".zdebug_str",	NULL, NULL, 0, 0, 0, NULL },
-    display_debug_str,	    &do_debug_str,	0 },
-  { { ".debug_loc",	    ".zdebug_loc",	NULL, NULL, 0, 0, 0, NULL },
-    display_debug_loc,	    &do_debug_loc,	1 },
-  { { ".debug_pubtypes",    ".zdebug_pubtypes",	NULL, NULL, 0, 0, 0, NULL },
-    display_debug_pubnames, &do_debug_pubtypes,	0 },
-  { { ".debug_gnu_pubtypes", ".zdebug_gnu_pubtypes", NULL, NULL, 0, 0, 0, NULL },
-    display_debug_gnu_pubnames, &do_debug_pubtypes, 0 },
-  { { ".debug_ranges",	    ".zdebug_ranges",	NULL, NULL, 0, 0, 0, NULL },
-    display_debug_ranges,   &do_debug_ranges,	1 },
-  { { ".debug_static_func", ".zdebug_static_func", NULL, NULL, 0, 0, 0, NULL },
-    display_debug_not_supported, NULL,		0 },
-  { { ".debug_static_vars", ".zdebug_static_vars", NULL, NULL, 0, 0, 0, NULL },
-    display_debug_not_supported, NULL,		0 },
-  { { ".debug_types",	    ".zdebug_types",	NULL, NULL, 0, 0, abbrev, NULL },
-    display_debug_types,    &do_debug_info,	1 },
-  { { ".debug_weaknames",   ".zdebug_weaknames", NULL, NULL, 0, 0, 0, NULL },
-    display_debug_not_supported, NULL,		0 },
-  { { ".gdb_index",	    "",	                NULL, NULL, 0, 0, 0, NULL },
-    display_gdb_index,      &do_gdb_index,	0 },
-  { { ".trace_info",	    "",			NULL, NULL, 0, 0, trace_abbrev, NULL },
-    display_trace_info,	    &do_trace_info,	1 },
-  { { ".trace_abbrev",	    "",			NULL, NULL, 0, 0, 0, NULL },
-    display_debug_abbrev,   &do_trace_abbrevs,	0 },
-  { { ".trace_aranges",	    "",			NULL, NULL, 0, 0, 0, NULL },
-    display_debug_aranges,  &do_trace_aranges,	0 },
-  { { ".debug_info.dwo",    ".zdebug_info.dwo",	NULL, NULL, 0, 0, abbrev_dwo, NULL },
-    display_debug_info,	    &do_debug_info,	1 },
-  { { ".debug_abbrev.dwo",  ".zdebug_abbrev.dwo", NULL, NULL, 0, 0, 0, NULL },
-    display_debug_abbrev,   &do_debug_abbrevs,	0 },
-  { { ".debug_types.dwo",   ".zdebug_types.dwo", NULL, NULL, 0, 0, abbrev_dwo, NULL },
-    display_debug_types,    &do_debug_info,	1 },
-  { { ".debug_line.dwo",    ".zdebug_line.dwo", NULL, NULL, 0, 0, 0, NULL },
-    display_debug_lines,    &do_debug_lines,	1 },
-  { { ".debug_loc.dwo",	    ".zdebug_loc.dwo",	NULL, NULL, 0, 0, 0, NULL },
-    display_debug_loc,	    &do_debug_loc,	1 },
-  { { ".debug_macro.dwo",   ".zdebug_macro.dwo", NULL, NULL, 0, 0, 0, NULL },
-    display_debug_macro,    &do_debug_macinfo,	1 },
-  { { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo", NULL, NULL, 0, 0, 0, NULL },
-    display_debug_macinfo,  &do_debug_macinfo,	0 },
-  { { ".debug_str.dwo",     ".zdebug_str.dwo",  NULL, NULL, 0, 0, 0, NULL },
-    display_debug_str,      &do_debug_str,	1 },
-  { { ".debug_str_offsets", ".zdebug_str_offsets", NULL, NULL, 0, 0, 0, NULL },
-    display_debug_str_offsets, NULL,		0 },
-  { { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo", NULL, NULL, 0, 0, 0, NULL },
-    display_debug_str_offsets, NULL,		0 },
-  { { ".debug_addr",	    ".zdebug_addr",     NULL, NULL, 0, 0, 0, NULL },
-    display_debug_addr,     &do_debug_addr,	1 },
-  { { ".debug_cu_index",    "",			NULL, NULL, 0, 0, 0, NULL },
-    display_cu_index,       &do_debug_cu_index,	0 },
-  { { ".debug_tu_index",    "",			NULL, NULL, 0, 0, 0, NULL },
-    display_cu_index,       &do_debug_cu_index,	0 },
+  { { ".debug_abbrev",	    ".zdebug_abbrev",	NULL, NULL, 0, 0, 0, NULL, 0, NULL },
+    display_debug_abbrev,   &do_debug_abbrevs,	FALSE },
+  { { ".debug_aranges",	    ".zdebug_aranges",	NULL, NULL, 0, 0, 0, NULL, 0, NULL },
+    display_debug_aranges,  &do_debug_aranges,	TRUE },
+  { { ".debug_frame",       ".zdebug_frame",	NULL, NULL, 0, 0, 0, NULL, 0, NULL },
+    display_debug_frames,   &do_debug_frames,	TRUE },
+  { { ".debug_info",	    ".zdebug_info",	NULL, NULL, 0, 0, abbrev, NULL, 0, NULL },
+    display_debug_info,	    &do_debug_info,	TRUE },
+  { { ".debug_line",	    ".zdebug_line",	NULL, NULL, 0, 0, 0, NULL, 0, NULL },
+    display_debug_lines,    &do_debug_lines,	TRUE },
+  { { ".debug_pubnames",    ".zdebug_pubnames",	NULL, NULL, 0, 0, 0, NULL, 0, NULL },
+    display_debug_pubnames, &do_debug_pubnames,	FALSE },
+  { { ".debug_gnu_pubnames", ".zdebug_gnu_pubnames", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
+    display_debug_gnu_pubnames, &do_debug_pubnames, FALSE },
+  { { ".eh_frame",	    "",			NULL, NULL, 0, 0, 0, NULL, 0, NULL },
+    display_debug_frames,   &do_debug_frames,	TRUE },
+  { { ".debug_macinfo",	    ".zdebug_macinfo",	NULL, NULL, 0, 0, 0, NULL, 0, NULL },
+    display_debug_macinfo,  &do_debug_macinfo,	FALSE },
+  { { ".debug_macro",	    ".zdebug_macro",	NULL, NULL, 0, 0, 0, NULL, 0, NULL },
+    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_loc",	    ".zdebug_loc",	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_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 },
+    display_debug_not_supported, NULL,		FALSE },
+  { { ".debug_types",	    ".zdebug_types",	NULL, NULL, 0, 0, abbrev, NULL, 0, NULL },
+    display_debug_types,    &do_debug_info,	TRUE },
+  { { ".debug_weaknames",   ".zdebug_weaknames", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
+    display_debug_not_supported, NULL,		FALSE },
+  { { ".gdb_index",	    "",			NULL, NULL, 0, 0, 0, NULL, 0, NULL },
+    display_gdb_index,      &do_gdb_index,	FALSE },
+  { { ".trace_info",	    "",			NULL, NULL, 0, 0, trace_abbrev, NULL, 0, NULL },
+    display_trace_info,	    &do_trace_info,	TRUE },
+  { { ".trace_abbrev",	    "",			NULL, NULL, 0, 0, 0, NULL, 0, NULL },
+    display_debug_abbrev,   &do_trace_abbrevs,	FALSE },
+  { { ".trace_aranges",	    "",			NULL, NULL, 0, 0, 0, NULL, 0, NULL },
+    display_debug_aranges,  &do_trace_aranges,	FALSE },
+  { { ".debug_info.dwo",    ".zdebug_info.dwo",	NULL, NULL, 0, 0, abbrev_dwo, NULL, 0, NULL },
+    display_debug_info,	    &do_debug_info,	TRUE },
+  { { ".debug_abbrev.dwo",  ".zdebug_abbrev.dwo", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
+    display_debug_abbrev,   &do_debug_abbrevs,	FALSE },
+  { { ".debug_types.dwo",   ".zdebug_types.dwo", NULL, NULL, 0, 0, abbrev_dwo, NULL, 0, NULL },
+    display_debug_types,    &do_debug_info,	TRUE },
+  { { ".debug_line.dwo",    ".zdebug_line.dwo", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
+    display_debug_lines,    &do_debug_lines,	TRUE },
+  { { ".debug_loc.dwo",	    ".zdebug_loc.dwo",	NULL, NULL, 0, 0, 0, NULL, 0, NULL },
+    display_debug_loc,	    &do_debug_loc,	TRUE },
+  { { ".debug_macro.dwo",   ".zdebug_macro.dwo", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
+    display_debug_macro,    &do_debug_macinfo,	TRUE },
+  { { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
+    display_debug_macinfo,  &do_debug_macinfo,	FALSE },
+  { { ".debug_str.dwo",     ".zdebug_str.dwo",  NULL, NULL, 0, 0, 0, NULL, 0, NULL },
+    display_debug_str,      &do_debug_str,	TRUE },
+  { { ".debug_str_offsets", ".zdebug_str_offsets", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
+    display_debug_str_offsets, NULL,		FALSE },
+  { { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
+    display_debug_str_offsets, NULL,		FALSE },
+  { { ".debug_addr",	    ".zdebug_addr",     NULL, NULL, 0, 0, 0, NULL, 0, NULL },
+    display_debug_addr,     &do_debug_addr,	TRUE },
+  { { ".debug_cu_index",    "",			NULL, NULL, 0, 0, 0, NULL, 0, NULL },
+    display_cu_index,       &do_debug_cu_index,	FALSE },
+  { { ".debug_tu_index",    "",			NULL, NULL, 0, 0, 0, NULL, 0, NULL },
+    display_cu_index,       &do_debug_cu_index,	FALSE },
 };