* doc/binutils.texi: Add --dwarf-check option.
authorCary Coutant <ccoutant@google.com>
Fri, 11 May 2012 18:18:34 +0000 (18:18 +0000)
committerCary Coutant <ccoutant@google.com>
Fri, 11 May 2012 18:18:34 +0000 (18:18 +0000)
* dwarf.c (dwarf_check): New global flag.
(fetch_indexed_string): New function.
(fetch_indexed_value): New function.
(get_FORM_name): Add DW_FORM_GNU_str_index and DW_FORM_GNU_addr_index.
(decode_location_expression): Add DW_OP_GNU_addr_index.
(read_and_display_attr_value): Add DW_FORM_GNU_str_index,
DW_FORM_GNU_addr_index, DW_AT_GNU_addr_base, and DW_AT_GNU_ranges_base.
(get_AT_name): Add new attributes for Fission.
(process_debug_info): Load new debug sections for Fission.
(load_debug_info): Check for .debug_info.dwo section.
(display_loc_list, display_loc_list_dwo): New functions.
(display_debug_loc): Move logic to above two functions.
(display_debug_info): Choose abbrev section based on info section.
(display_debug_types): Likewise.
(display_trace_info): Likewise.
(comp_addr_base): New function.
(display_debug_addr): New function.
(display_debug_str_offsets): New function.
(display_debug_ranges): Allow missing range lists.  Suppress
diagnostics if dwarf_check not set.
(debug_displays): Add column to select abbrev section.
* dwarf.h (enum dwarf_section_display_enum): Add new debug sections
for Fission.
(struct dwarf_section): Add abbrev_sec field.
(struct dwarf_section_display): New type.
(debug_info): Add addr_base, ranges_base fields.
(dwarf_check): New global variable.
* objdump.c (usage): Add --dwarf-check option.
(enum option_values): Add OPTION_DWARF_CHECK.
(long_options): Add --dwarf-check.
(main): Likewise.
* readelf.c (OPTION_DWARF_CHECK): New macro.
(options): Add --dwarf-check.
(parse_args): Likewise.
(process_section_headers): Use const_strneq instead of
streq.

binutils/ChangeLog
binutils/doc/binutils.texi
binutils/dwarf.c
binutils/dwarf.h
binutils/objdump.c
binutils/readelf.c

index 3a5c740..3d2e066 100644 (file)
@@ -1,3 +1,44 @@
+2012-05-04  Sterling Augustine  <saugustine@google.com>
+           Cary Coutant  <ccoutant@google.com>
+
+       * doc/binutils.texi: Add --dwarf-check option.
+       * dwarf.c (dwarf_check): New global flag.
+       (fetch_indexed_string): New function.
+       (fetch_indexed_value): New function.
+       (get_FORM_name): Add DW_FORM_GNU_str_index and DW_FORM_GNU_addr_index.
+       (decode_location_expression): Add DW_OP_GNU_addr_index.
+       (read_and_display_attr_value): Add DW_FORM_GNU_str_index,
+       DW_FORM_GNU_addr_index, DW_AT_GNU_addr_base, and DW_AT_GNU_ranges_base.
+       (get_AT_name): Add new attributes for Fission.
+       (process_debug_info): Load new debug sections for Fission.
+       (load_debug_info): Check for .debug_info.dwo section.
+       (display_loc_list, display_loc_list_dwo): New functions.
+       (display_debug_loc): Move logic to above two functions.
+       (display_debug_info): Choose abbrev section based on info section.
+       (display_debug_types): Likewise.
+       (display_trace_info): Likewise.
+       (comp_addr_base): New function.
+       (display_debug_addr): New function.
+       (display_debug_str_offsets): New function.
+       (display_debug_ranges): Allow missing range lists.  Suppress
+       diagnostics if dwarf_check not set.
+       (debug_displays): Add column to select abbrev section.
+       * dwarf.h (enum dwarf_section_display_enum): Add new debug sections
+       for Fission.
+       (struct dwarf_section): Add abbrev_sec field.
+       (struct dwarf_section_display): New type.
+       (debug_info): Add addr_base, ranges_base fields.
+       (dwarf_check): New global variable.
+       * objdump.c (usage): Add --dwarf-check option.
+       (enum option_values): Add OPTION_DWARF_CHECK.
+       (long_options): Add --dwarf-check.
+       (main): Likewise.
+       * readelf.c (OPTION_DWARF_CHECK): New macro.
+       (options): Add --dwarf-check.
+       (parse_args): Likewise.
+       (process_section_headers): Use const_strneq instead of
+       streq.
+
 2012-05-11  H.J. Lu  <hongjiu.lu@intel.com>
 
        PR binutils/14088
index daa191a..9826eb2 100644 (file)
@@ -2198,7 +2198,8 @@ Note that there is no single letter option to display the content of
 trace sections or .gdb_index.
 
 Note: the output from the @option{=info} option can also be affected
-by the options @option{--dwarf-depth} and @option{--dwarf-start}.
+by the options @option{--dwarf-depth}, the @option{--dwarf-start} and
+the @option{--dwarf-check}.
 
 @item --dwarf-depth=@var{n}
 Limit the dump of the @code{.debug_info} section to @var{n} children.
@@ -2219,6 +2220,9 @@ siblings and children of the specified DIE will be printed.
 
 This can be used in conjunction with @option{--dwarf-depth}.
 
+@item --dwarf-check
+Enable additional checks for consistency of Dwarf information.
+
 @item -G
 @itemx --stabs
 @cindex stab
index 5361396..ebd1ece 100644 (file)
@@ -66,6 +66,8 @@ int do_wide;
 int dwarf_cutoff_level = -1;
 unsigned long dwarf_start_die;
 
+int dwarf_check = 0;
+
 /* Values for do_debug_lines.  */
 #define FLAG_DEBUG_LINES_RAW    1
 #define FLAG_DEBUG_LINES_DECODED 2
@@ -444,6 +446,64 @@ fetch_indirect_string (dwarf_vma offset)
   return (const char *) section->start + offset;
 }
 
+static const char *
+fetch_indexed_string (dwarf_vma idx, dwarf_vma offset_size, int dwo)
+{
+  enum dwarf_section_display_enum str_sec_idx = dwo ? str_dwo : str;
+  enum dwarf_section_display_enum idx_sec_idx = dwo ? str_index_dwo : str_index;
+  struct dwarf_section *index_section = &debug_displays [idx_sec_idx].section;
+  struct dwarf_section *str_section = &debug_displays [str_sec_idx].section;
+  dwarf_vma index_offset = idx * offset_size;
+  dwarf_vma str_offset;
+
+  if (index_section->start == NULL)
+    return (dwo ? _("<no .debug_str_offsets.dwo section>")
+               : _("<no .debug_str_offsets section>"));
+
+  /* DWARF sections under Mach-O have non-zero addresses.  */
+  index_offset -= index_section->address;
+  if (index_offset > index_section->size)
+    {
+      warn (_("DW_FORM_GNU_str_index offset too big: %s\n"),
+           dwarf_vmatoa ("x", index_offset));
+      return _("<index offset is too big>");
+    }
+
+  if (str_section->start == NULL)
+    return (dwo ? _("<no .debug_str.dwo section>")
+               : _("<no .debug_str section>"));
+
+  str_offset = byte_get (index_section->start + index_offset, offset_size);
+  str_offset -= str_section->address;
+  if (str_offset > str_section->size)
+    {
+      warn (_("DW_FORM_GNU_str_index indirect offset too big: %s\n"),
+           dwarf_vmatoa ("x", str_offset));
+      return _("<indirect index offset is too big>");
+    }
+
+  return (const char *) str_section->start + str_offset;
+}
+
+static const char *
+fetch_indexed_value (dwarf_vma offset, dwarf_vma bytes)
+{
+  struct dwarf_section *section = &debug_displays [debug_addr].section;
+
+  if (section->start == NULL)
+    return (_("<no .debug_addr section>"));
+
+  if (offset + bytes > section->size)
+    {
+      warn (_("Offset into section %s too big: %s\n"),
+            section->name, dwarf_vmatoa ("x", offset));
+      return "<offset too big>";
+    }
+
+  return dwarf_vmatoa ("x", byte_get (section->start + offset, bytes));
+}
+
+
 /* FIXME:  There are better and more efficient ways to handle
    these structures.  For now though, I just want something that
    is simple to implement.  */
@@ -1120,6 +1180,11 @@ decode_location_expression (unsigned char * data,
                  dwarf_vmatoa ("x", cu_offset + byte_get (data, 4)));
          data += 4;
          break;
+        case DW_OP_GNU_addr_index:
+          uvalue = read_leb128 (data, &bytes_read, 0);
+          data += bytes_read;
+          printf ("DW_OP_GNU_addr_index <0x%s>", dwarf_vmatoa ("x", uvalue));
+          break;
 
          /* HP extensions.  */
        case DW_OP_HP_is_value:
@@ -1250,6 +1315,11 @@ read_and_display_attr_value (unsigned long attribute,
       data += bytes_read;
       break;
 
+    case DW_FORM_GNU_str_index:
+      uvalue = read_leb128 (data, & bytes_read, 0);
+      data += bytes_read;
+      break;
+
     case DW_FORM_ref_udata:
     case DW_FORM_udata:
       uvalue = read_leb128 (data, & bytes_read, 0);
@@ -1266,6 +1336,10 @@ read_and_display_attr_value (unsigned long attribute,
                                          offset_size, dwarf_version,
                                          debug_info_p, do_loc,
                                          section);
+    case DW_FORM_GNU_addr_index:
+      uvalue = read_leb128 (data, & bytes_read, 0);
+      data += bytes_read;
+      break;
     }
 
   switch (form)
@@ -1372,6 +1446,18 @@ read_and_display_attr_value (unsigned long attribute,
                fetch_indirect_string (uvalue));
       break;
 
+    case DW_FORM_GNU_str_index:
+      if (!do_loc)
+        {
+          const char *suffix = strrchr (section->name, '.');
+          int dwo = (suffix && strcmp (suffix, ".dwo") == 0) ? 1 : 0;
+
+          printf (_(" (indexed string: 0x%s): %s"),
+                  dwarf_vmatoa ("x", uvalue),
+                  fetch_indexed_string (uvalue, offset_size, dwo));
+        }
+      break;
+
     case DW_FORM_indirect:
       /* Handled above.  */
       break;
@@ -1389,6 +1475,13 @@ read_and_display_attr_value (unsigned long attribute,
       data += 8;
       break;
 
+    case DW_FORM_GNU_addr_index:
+      if (!do_loc)
+        printf (_(" (addr_index: 0x%s): %s"),
+                dwarf_vmatoa ("x", uvalue),
+                fetch_indexed_value (uvalue * pointer_size, pointer_size));
+      break;
+
     default:
       warn (_("Unrecognized form: %lu\n"), form);
       break;
@@ -1444,6 +1537,14 @@ read_and_display_attr_value (unsigned long attribute,
            debug_info_p->base_address = uvalue;
          break;
 
+       case DW_AT_GNU_addr_base:
+          debug_info_p->addr_base = uvalue;
+         break;
+
+       case DW_AT_GNU_ranges_base:
+          debug_info_p->ranges_base = uvalue;
+         break;
+
        case DW_AT_ranges:
          if ((dwarf_version < 4
               && (form == DW_FORM_data4 || form == DW_FORM_data8))
@@ -1867,6 +1968,10 @@ 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 (str_dwo, file);
+      load_debug_section (str_index, file);
+      load_debug_section (str_index_dwo, file);
+      load_debug_section (debug_addr, file);
     }
 
   load_debug_section (abbrev_sec, file);
@@ -1937,6 +2042,8 @@ process_debug_info (struct dwarf_section *section,
          debug_information [unit].offset_size = offset_size;
          debug_information [unit].dwarf_version = compunit.cu_version;
          debug_information [unit].base_address = 0;
+         debug_information [unit].addr_base = DEBUG_INFO_UNAVAILABLE;
+         debug_information [unit].ranges_base = DEBUG_INFO_UNAVAILABLE;
          debug_information [unit].loc_offsets = NULL;
          debug_information [unit].have_frame_base = NULL;
          debug_information [unit].max_loc_offsets = 0;
@@ -2046,8 +2153,8 @@ process_debug_info (struct dwarf_section *section,
 
                  if (num_bogus_warns < 3)
                    {
-                     warn (_("Bogus end-of-siblings marker detected at offset %lx in .debug_info section\n"),
-                           die_offset);
+                     warn (_("Bogus end-of-siblings marker detected at offset %lx in %s section\n"),
+                           die_offset, section->name);
                      num_bogus_warns ++;
                      if (num_bogus_warns == 3)
                        warn (_("Further warnings about bogus end-of-sibling markers suppressed\n"));
@@ -2182,6 +2289,10 @@ load_debug_info (void * file)
   if (load_debug_section (info, file)
       && process_debug_info (&debug_displays [info].section, file, abbrev, 1, 0))
     return num_debug_info_entries;
+  else if (load_debug_section (info_dwo, file)
+           && process_debug_info (&debug_displays [info_dwo].section, file,
+                                  abbrev_dwo, 1, 0))
+    return num_debug_info_entries;
 
   num_debug_info_entries = DEBUG_INFO_UNAVAILABLE;
   return 0;
@@ -3601,6 +3712,214 @@ display_debug_abbrev (struct dwarf_section *section,
   return 1;
 }
 
+/* Display a location list from a normal (ie, non-dwo) .debug_loc section.  */
+
+static void
+display_loc_list (struct dwarf_section *section,
+                  unsigned char **start_ptr,
+                  int debug_info_entry,
+                  unsigned long offset,
+                  unsigned long base_address,
+                  int has_frame_base)
+{
+  unsigned char *start = *start_ptr;
+  unsigned char *section_end = section->start + section->size;
+  unsigned long cu_offset = debug_information [debug_info_entry].cu_offset;
+  unsigned int pointer_size = debug_information [debug_info_entry].pointer_size;
+  unsigned int offset_size = debug_information [debug_info_entry].offset_size;
+  int dwarf_version = debug_information [debug_info_entry].dwarf_version;
+
+  dwarf_vma begin;
+  dwarf_vma end;
+  unsigned short length;
+  int need_frame_base;
+
+  while (1)
+    {
+      if (start + 2 * pointer_size > section_end)
+        {
+          warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
+                offset);
+          break;
+        }
+
+      /* Note: we use sign extension here in order to be sure that we can detect
+         the -1 escape value.  Sign extension into the top 32 bits of a 32-bit
+         address will not affect the values that we display since we always show
+         hex values, and always the bottom 32-bits.  */
+      begin = byte_get_signed (start, pointer_size);
+      start += pointer_size;
+      end = byte_get_signed (start, pointer_size);
+      start += pointer_size;
+
+      printf ("    %8.8lx ", offset);
+
+      if (begin == 0 && end == 0)
+        {
+          printf (_("<End of list>\n"));
+          break;
+        }
+
+      /* Check base address specifiers.  */
+      if (begin == (dwarf_vma) -1 && end != (dwarf_vma) -1)
+        {
+          base_address = end;
+          print_dwarf_vma (begin, pointer_size);
+          print_dwarf_vma (end, pointer_size);
+          printf (_("(base address)\n"));
+          continue;
+        }
+
+      if (start + 2 > section_end)
+        {
+          warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
+                offset);
+          break;
+        }
+
+      length = byte_get (start, 2);
+      start += 2;
+
+      if (start + length > section_end)
+        {
+          warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
+                offset);
+          break;
+        }
+
+      print_dwarf_vma (begin + base_address, pointer_size);
+      print_dwarf_vma (end + base_address, pointer_size);
+
+      putchar ('(');
+      need_frame_base = decode_location_expression (start,
+                                                    pointer_size,
+                                                    offset_size,
+                                                    dwarf_version,
+                                                    length,
+                                                    cu_offset, section);
+      putchar (')');
+
+      if (need_frame_base && !has_frame_base)
+        printf (_(" [without DW_AT_frame_base]"));
+
+      if (begin == end)
+        fputs (_(" (start == end)"), stdout);
+      else if (begin > end)
+        fputs (_(" (start > end)"), stdout);
+
+      putchar ('\n');
+
+      start += length;
+    }
+
+  *start_ptr = start;
+}
+
+/* Display a location list from a .dwo section. It uses address indexes rather
+   than embedded addresses.  This code closely follows display_loc_list, but the
+   two are sufficiently different that combining things is very ugly.  */
+
+static void
+display_loc_list_dwo (struct dwarf_section *section,
+                      unsigned char **start_ptr,
+                      int debug_info_entry,
+                      unsigned long offset,
+                      int has_frame_base)
+{
+  unsigned char *start = *start_ptr;
+  unsigned char *section_end = section->start + section->size;
+  unsigned long cu_offset = debug_information [debug_info_entry].cu_offset;
+  unsigned int pointer_size = debug_information [debug_info_entry].pointer_size;
+  unsigned int offset_size = debug_information [debug_info_entry].offset_size;
+  int dwarf_version = debug_information [debug_info_entry].dwarf_version;
+  int entry_type;
+  unsigned short length;
+  int need_frame_base;
+  dwarf_vma idx;
+  unsigned int bytes_read;
+
+  while (1)
+    {
+      printf ("    %8.8lx ", offset);
+
+      if (start + 2 > section_end)
+        {
+          warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
+                offset);
+          break;
+        }
+
+      entry_type = byte_get (start, 1);
+      start++;
+      switch (entry_type)
+        {
+          case 0: /* A terminating entry.  */
+            idx = byte_get (start, 1);
+            start++;
+            *start_ptr = start;
+            if (idx == 0)
+              printf (_("<End of list>\n"));
+            else
+              warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
+                    offset);
+            return;
+          case 1: /* A base-address entry.  */
+            idx = read_leb128 (start, &bytes_read, 0);
+            start += bytes_read;
+            print_dwarf_vma (idx, pointer_size);
+            printf (_("(base address index)\n"));
+            continue;
+          case 2: /* A normal entry.  */
+            idx = read_leb128 (start, &bytes_read, 0);
+            start += bytes_read;
+            print_dwarf_vma (idx, pointer_size);
+            idx = read_leb128 (start, &bytes_read, 0);
+            start += bytes_read;
+            print_dwarf_vma (idx, pointer_size);
+            break;
+          default:
+            warn (_("Unknown location-list type 0x%x.\n"), entry_type);
+            *start_ptr = start;
+            return;
+        }
+
+      if (start + 2 > section_end)
+        {
+          warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
+                offset);
+          break;
+        }
+
+      length = byte_get (start, 2);
+      start += 2;
+
+      if (start + length > section_end)
+        {
+          warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
+                offset);
+          break;
+        }
+
+      putchar ('(');
+      need_frame_base = decode_location_expression (start,
+                                                    pointer_size,
+                                                    offset_size,
+                                                    dwarf_version,
+                                                    length,
+                                                    cu_offset, section);
+      putchar (')');
+
+      if (need_frame_base && !has_frame_base)
+        printf (_(" [without DW_AT_frame_base]"));
+
+      putchar ('\n');
+
+      start += length;
+    }
+
+  *start_ptr = start;
+}
+
 /* Sort array of indexes in ascending order of loc_offsets[idx].  */
 
 static dwarf_vma *loc_offsets;
@@ -3618,7 +3937,6 @@ static int
 display_debug_loc (struct dwarf_section *section, void *file)
 {
   unsigned char *start = section->start;
-  unsigned char *section_end;
   unsigned long bytes;
   unsigned char *section_begin = start;
   unsigned int num_loc_list = 0;
@@ -3631,9 +3949,13 @@ display_debug_loc (struct dwarf_section *section, void *file)
   int locs_sorted = 1;
   unsigned char *next;
   unsigned int *array = NULL;
+  const char *suffix = strrchr (section->name, '.');
+  int is_dwo = 0;
+
+  if (suffix && strcmp (suffix, ".dwo") == 0)
+    is_dwo = 1;
 
   bytes = section->size;
-  section_end = start + bytes;
 
   if (bytes == 0)
     {
@@ -3699,27 +4021,18 @@ 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 (!is_dwo)
+    printf (_("    Offset   Begin    End      Expression\n"));
+  else
+    printf (_("    Offset   Begin idx End idx  Expression\n"));
 
   seen_first_offset = 0;
   for (i = first; i < num_debug_info_entries; i++)
     {
-      dwarf_vma begin;
-      dwarf_vma end;
-      unsigned short length;
       unsigned long offset;
-      unsigned int pointer_size;
-      unsigned int offset_size;
-      int dwarf_version;
-      unsigned long cu_offset;
       unsigned long base_address;
-      int need_frame_base;
       int has_frame_base;
 
-      pointer_size = debug_information [i].pointer_size;
-      cu_offset = debug_information [i].cu_offset;
-      offset_size = debug_information [i].offset_size;
-      dwarf_version = debug_information [i].dwarf_version;
       if (!locs_sorted)
        {
          for (k = 0; k < debug_information [i].num_loc_offsets; k++)
@@ -3765,90 +4078,17 @@ display_debug_loc (struct dwarf_section *section, void *file)
              continue;
            }
 
-         while (1)
-           {
-             if (start + 2 * pointer_size > section_end)
-               {
-                 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
-                       offset);
-                 break;
-               }
-
-             /* Note: we use sign extension here in order to be sure that
-                we can detect the -1 escape value.  Sign extension into the
-                top 32 bits of a 32-bit address will not affect the values
-                that we display since we always show hex values, and always
-                the bottom 32-bits.  */
-             begin = byte_get_signed (start, pointer_size);
-             start += pointer_size;
-             end = byte_get_signed (start, pointer_size);
-             start += pointer_size;
-
-             printf ("    %8.8lx ", offset);
-
-             if (begin == 0 && end == 0)
-               {
-                 printf (_("<End of list>\n"));
-                 break;
-               }
-
-             /* Check base address specifiers.  */
-             if (begin == (dwarf_vma) -1 && end != (dwarf_vma) -1)
-               {
-                 base_address = end;
-                 print_dwarf_vma (begin, pointer_size);
-                 print_dwarf_vma (end, pointer_size);
-                 printf (_("(base address)\n"));
-                 continue;
-               }
-
-             if (start + 2 > section_end)
-               {
-                 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
-                       offset);
-                 break;
-               }
-
-             length = byte_get (start, 2);
-             start += 2;
-
-             if (start + length > section_end)
-               {
-                 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
-                       offset);
-                 break;
-               }
-
-             print_dwarf_vma (begin + base_address, pointer_size);
-             print_dwarf_vma (end + base_address, pointer_size);
-
-             putchar ('(');
-             need_frame_base = decode_location_expression (start,
-                                                           pointer_size,
-                                                           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;
-           }
+          if (is_dwo)
+            display_loc_list_dwo (section, &start, i, offset, has_frame_base);
+          else
+            display_loc_list (section, &start, i, offset, base_address,
+                              has_frame_base);
        }
     }
 
-  if (start < section_end)
+  if (start < section->start + section->size)
     warn (_("There are %ld unused bytes at the end of section %s\n"),
-         (long) (section_end - start), section->name);
+         (long) (section->start + section->size - start), section->name);
   putchar ('\n');
   free (array);
   return 1;
@@ -3915,19 +4155,19 @@ display_debug_str (struct dwarf_section *section,
 static int
 display_debug_info (struct dwarf_section *section, void *file)
 {
-  return process_debug_info (section, file, abbrev, 0, 0);
+  return process_debug_info (section, file, section->abbrev_sec, 0, 0);
 }
 
 static int
 display_debug_types (struct dwarf_section *section, void *file)
 {
-  return process_debug_info (section, file, abbrev, 0, 1);
+  return process_debug_info (section, file, section->abbrev_sec, 0, 1);
 }
 
 static int
 display_trace_info (struct dwarf_section *section, void *file)
 {
-  return process_debug_info (section, file, trace_abbrev, 0, 0);
+  return process_debug_info (section, file, section->abbrev_sec, 0, 0);
 }
 
 static int
@@ -4059,6 +4299,96 @@ display_debug_aranges (struct dwarf_section *section,
   return 1;
 }
 
+/* Comparison function for qsort.  */
+static int
+comp_addr_base (const void * v0, const void * v1)
+{
+  debug_info * info0 = (debug_info *) v0;
+  debug_info * info1 = (debug_info *) v1;
+  return info0->addr_base - info1->addr_base;
+}
+
+/* Display the debug_addr section.  */
+static int
+display_debug_addr (struct dwarf_section *section,
+                    void *file)
+{
+  debug_info **debug_addr_info;
+  unsigned char *entry;
+  unsigned char *end;
+  unsigned int i;
+  unsigned int count;
+
+  if (section->size == 0)
+    {
+      printf (_("\nThe %s section is empty.\n"), section->name);
+      return 0;
+    }
+
+  if (load_debug_info (file) == 0)
+    {
+      warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
+           section->name);
+      return 0;
+    }
+
+  printf (_("Contents of the %s section:\n\n"), section->name);
+
+  debug_addr_info = (debug_info **) xmalloc (num_debug_info_entries + 1
+                                             * sizeof (debug_info *));
+
+  count = 0;
+  for (i = 0; i < num_debug_info_entries; i++)
+    {
+      if (debug_information [i].addr_base != DEBUG_INFO_UNAVAILABLE)
+        debug_addr_info [count++] = &debug_information [i];
+    }
+
+  /* Add a sentinel to make iteration convenient.  */
+  debug_addr_info [count] = (debug_info *) xmalloc (sizeof (debug_info));
+  debug_addr_info [count]->addr_base = section->size;
+
+  qsort (debug_addr_info, count, sizeof (debug_info *), comp_addr_base);
+  for (i = 0; i < count; i++)
+    {
+      unsigned int idx;
+
+      printf (_("  For compilation unit at offset 0x%s:\n"),
+              dwarf_vmatoa ("x", debug_addr_info [i]->cu_offset));
+
+      printf (_("\tIndex\tOffset\n"));
+      entry = section->start + debug_addr_info [i]->addr_base;
+      end = section->start + debug_addr_info [i + 1]->addr_base;
+      idx = 0;
+      while (entry < end)
+        {
+          dwarf_vma base = byte_get (entry, debug_addr_info [i]->pointer_size);
+          printf (_("\t%d:\t%s\n"), idx, dwarf_vmatoa ("x", base));
+          entry += debug_addr_info [i]->pointer_size;
+          idx++;
+        }
+    }
+  printf ("\n");
+
+  free (debug_addr_info);
+  return 1;
+}
+
+/* Display the .debug_str_offsets and .debug_str_offsets.dwo sections.  */
+static int
+display_debug_str_offsets (struct dwarf_section *section,
+                           void *file ATTRIBUTE_UNUSED)
+{
+  if (section->size == 0)
+    {
+      printf (_("\nThe %s section is empty.\n"), section->name);
+      return 0;
+    }
+  /* TODO: Dump the contents.  This is made somewhat difficult by not knowing
+     what the offset size is for this section.  */
+  return 1;
+}
+
 /* Each debug_information[x].range_lists[y] gets this representation for
    sorting purposes.  */
 
@@ -4114,7 +4444,12 @@ display_debug_ranges (struct dwarf_section *section,
     num_range_list += debug_information [i].num_range_lists;
 
   if (num_range_list == 0)
-    error (_("No range lists in .debug_info section!\n"));
+    {
+      /* This can happen when the file was compiled with -gsplit-debug
+         which removes references to range lists from the primary .o file.  */
+      printf (_("No range lists in .debug_info section.\n"));
+      return 1;
+    }
 
   range_entries = (struct range_entry *)
       xmalloc (sizeof (*range_entries) * num_range_list);
@@ -4137,7 +4472,7 @@ display_debug_ranges (struct dwarf_section *section,
         range_entry_compar);
 
   /* DWARF sections under Mach-O have non-zero addresses.  */
-  if (range_entries[0].ranges_offset != section->address)
+  if (dwarf_check != 0 && range_entries[0].ranges_offset != section->address)
     warn (_("Range lists in %s section start at 0x%lx\n"),
          section->name, range_entries[0].ranges_offset);
 
@@ -4160,7 +4495,7 @@ display_debug_ranges (struct dwarf_section *section,
       next = section_begin + offset;
       base_address = debug_info_p->base_address;
 
-      if (i > 0)
+      if (dwarf_check != 0 && i > 0)
        {
          if (start < next)
            warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
@@ -5642,46 +5977,69 @@ dwarf_select_sections_all (void)
 
 struct dwarf_section_display debug_displays[] =
 {
-  { { ".debug_abbrev",         ".zdebug_abbrev",       NULL, NULL, 0, 0 },
-    display_debug_abbrev,              &do_debug_abbrevs,      0 },
-  { { ".debug_aranges",                ".zdebug_aranges",      NULL, NULL, 0, 0 },
-    display_debug_aranges,             &do_debug_aranges,      1 },
-  { { ".debug_frame",          ".zdebug_frame",        NULL, NULL, 0, 0 },
-    display_debug_frames,              &do_debug_frames,       1 },
-  { { ".debug_info",           ".zdebug_info",         NULL, NULL, 0, 0 },
-    display_debug_info,                        &do_debug_info,         1 },
-  { { ".debug_line",           ".zdebug_line",         NULL, NULL, 0, 0 },
-    display_debug_lines,               &do_debug_lines,        1 },
-  { { ".debug_pubnames",       ".zdebug_pubnames",     NULL, NULL, 0, 0 },
-    display_debug_pubnames,            &do_debug_pubnames,     0 },
-  { { ".eh_frame",             "",                     NULL, NULL, 0, 0 },
-    display_debug_frames,              &do_debug_frames,       1 },
-  { { ".debug_macinfo",                ".zdebug_macinfo",      NULL, NULL, 0, 0 },
-    display_debug_macinfo,             &do_debug_macinfo,      0 },
-  { { ".debug_macro",          ".zdebug_macro",        NULL, NULL, 0, 0 },
-    display_debug_macro,               &do_debug_macinfo,      1 },
-  { { ".debug_str",            ".zdebug_str",          NULL, NULL, 0, 0 },
-    display_debug_str,                 &do_debug_str,          0 },
-  { { ".debug_loc",            ".zdebug_loc",          NULL, NULL, 0, 0 },
-    display_debug_loc,                 &do_debug_loc,          1 },
-  { { ".debug_pubtypes",       ".zdebug_pubtypes",     NULL, NULL, 0, 0 },
-    display_debug_pubnames,            &do_debug_pubtypes,     0 },
-  { { ".debug_ranges",         ".zdebug_ranges",       NULL, NULL, 0, 0 },
-    display_debug_ranges,              &do_debug_ranges,       1 },
-  { { ".debug_static_func",    ".zdebug_static_func",  NULL, NULL, 0, 0 },
-    display_debug_not_supported,       NULL,                   0 },
-  { { ".debug_static_vars",    ".zdebug_static_vars",  NULL, NULL, 0, 0 },
-    display_debug_not_supported,       NULL,                   0 },
-  { { ".debug_types",          ".zdebug_types",        NULL, NULL, 0, 0 },
-    display_debug_types,               &do_debug_info,         1 },
-  { { ".debug_weaknames",      ".zdebug_weaknames",    NULL, NULL, 0, 0 },
-    display_debug_not_supported,       NULL,                   0 },
-  { { ".gdb_index",            "",                     NULL, NULL, 0, 0 },
+  { { ".debug_abbrev",     ".zdebug_abbrev",   NULL, NULL, 0, 0, abbrev },
+    display_debug_abbrev,   &do_debug_abbrevs, 0 },
+  { { ".debug_aranges",            ".zdebug_aranges",  NULL, NULL, 0, 0, abbrev },
+    display_debug_aranges,  &do_debug_aranges, 1 },
+  { { ".debug_frame",       ".zdebug_frame",   NULL, NULL, 0, 0, abbrev },
+    display_debug_frames,   &do_debug_frames,  1 },
+  { { ".debug_info",       ".zdebug_info",     NULL, NULL, 0, 0, abbrev },
+    display_debug_info,            &do_debug_info,     1 },
+  { { ".debug_line",       ".zdebug_line",     NULL, NULL, 0, 0, abbrev },
+    display_debug_lines,    &do_debug_lines,   1 },
+  { { ".debug_pubnames",    ".zdebug_pubnames",        NULL, NULL, 0, 0, abbrev },
+    display_debug_pubnames, &do_debug_pubnames,        0 },
+  { { ".eh_frame",         "",                 NULL, NULL, 0, 0, abbrev },
+    display_debug_frames,   &do_debug_frames,  1 },
+  { { ".debug_macinfo",            ".zdebug_macinfo",  NULL, NULL, 0, 0, abbrev },
+    display_debug_macinfo,  &do_debug_macinfo, 0 },
+  { { ".debug_macro",      ".zdebug_macro",    NULL, NULL, 0, 0, abbrev },
+    display_debug_macro,    &do_debug_macinfo, 1 },
+  { { ".debug_str",        ".zdebug_str",      NULL, NULL, 0, 0, abbrev },
+    display_debug_str,     &do_debug_str,      0 },
+  { { ".debug_loc",        ".zdebug_loc",      NULL, NULL, 0, 0, abbrev },
+    display_debug_loc,     &do_debug_loc,      1 },
+  { { ".debug_pubtypes",    ".zdebug_pubtypes",        NULL, NULL, 0, 0, abbrev },
+    display_debug_pubnames, &do_debug_pubtypes,        0 },
+  { { ".debug_ranges",     ".zdebug_ranges",   NULL, NULL, 0, 0, abbrev },
+    display_debug_ranges,   &do_debug_ranges,  1 },
+  { { ".debug_static_func", ".zdebug_static_func", NULL, NULL, 0, 0, abbrev },
+    display_debug_not_supported, NULL,         0 },
+  { { ".debug_static_vars", ".zdebug_static_vars", NULL, NULL, 0, 0, abbrev },
+    display_debug_not_supported, NULL,         0 },
+  { { ".debug_types",      ".zdebug_types",    NULL, NULL, 0, 0, abbrev },
+    display_debug_types,    &do_debug_info,    1 },
+  { { ".debug_weaknames",   ".zdebug_weaknames", NULL, NULL, 0, 0, abbrev },
+    display_debug_not_supported, NULL,         0 },
+  { { ".gdb_index",        "",                 NULL, NULL, 0, 0, abbrev },
     display_gdb_index,                 &do_gdb_index,          0 },
-  { { ".trace_info",           "",                     NULL, NULL, 0, 0 },
+  { { ".trace_info",       "",                 NULL, NULL, 0, 0, trace_abbrev },
     display_trace_info,                        &do_trace_info,         1 },
-  { { ".trace_abbrev",         "",                     NULL, NULL, 0, 0 },
+  { { ".trace_abbrev",     "",                 NULL, NULL, 0, 0, abbrev },
     display_debug_abbrev,              &do_trace_abbrevs,      0 },
-  { { ".trace_aranges",                "",                     NULL, NULL, 0, 0 },
-    display_debug_aranges,             &do_trace_aranges,      0 }
+  { { ".trace_aranges",            "",                 NULL, NULL, 0, 0, abbrev },
+    display_debug_aranges,             &do_trace_aranges,      0 },
+  { { ".debug_info.dwo",    ".zdebug_info.dwo",        NULL, NULL, 0, 0, abbrev_dwo },
+    display_debug_info,                        &do_debug_info,         1 },
+  { { ".debug_abbrev.dwo",  ".zdebug_abbrev.dwo", NULL, NULL, 0, 0, abbrev_dwo },
+    display_debug_abbrev,              &do_debug_abbrevs,      0 },
+  { { ".debug_types.dwo",   ".zdebug_types.dwo", NULL, NULL, 0, 0, abbrev_dwo },
+    display_debug_types,               &do_debug_info,         1 },
+  { { ".debug_line.dwo",   ".zdebug_line.dwo", NULL, NULL, 0, 0, abbrev_dwo },
+    display_debug_lines,   &do_debug_lines,    1 },
+  { { ".debug_loc.dwo",            ".zdebug_loc.dwo",  NULL, NULL, 0, 0, abbrev_dwo },
+    display_debug_loc,     &do_debug_loc,      1 },
+  { { ".debug_macro.dwo",   ".zdebug_macro.dwo",NULL, NULL, 0, 0, abbrev },
+    display_debug_macro,    &do_debug_macinfo, 1 },
+  { { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo",NULL, NULL, 0, 0, abbrev },
+    display_debug_macinfo,  &do_debug_macinfo, 0 },
+  { { ".debug_str.dwo",   ".zdebug_str.dwo", NULL, NULL, 0, 0, str_dwo },
+    display_debug_str,     &do_debug_str,              1 },
+  { { ".debug_str_offsets",".zdebug_str_offsets", NULL, NULL, 0, 0, abbrev },
+    display_debug_str_offsets, NULL,           0 },
+  { { ".debug_str_offsets.dwo",".zdebug_str_offsets.dwo", NULL, NULL, 0, 0,
+      abbrev },
+    display_debug_str_offsets, NULL,           0 },
+  { { ".debug_addr",".zdebug_addr",             NULL, NULL, 0, 0, debug_addr },
+    display_debug_addr, NULL,          1 },
 };
index 75d93c8..84f5080 100644 (file)
@@ -109,30 +109,6 @@ typedef struct
 }
 DWARF2_Internal_ARange;
 
-struct dwarf_section
-{
-  /* A debug section has a different name when it's stored compressed
-     or not.  COMPRESSED_NAME and UNCOMPRESSED_NAME are the two
-     possibilities.  NAME is set to whichever one is used for this
-     input file, as determined by load_debug_section().  */
-  const char *uncompressed_name;
-  const char *compressed_name;
-  const char *name;
-  unsigned char *start;
-  dwarf_vma address;
-  dwarf_size_type size;
-};
-
-/* A structure containing the name of a debug section
-   and a pointer to a function that can decode it.  */
-struct dwarf_section_display
-{
-  struct dwarf_section section;
-  int (*display) (struct dwarf_section *, void *);
-  int *enabled;
-  unsigned int relocate : 1;
-};
-
 enum dwarf_section_display_enum
 {
   abbrev = 0,
@@ -156,9 +132,45 @@ enum dwarf_section_display_enum
   trace_info,
   trace_abbrev,
   trace_aranges,
+  info_dwo,
+  abbrev_dwo,
+  types_dwo,
+  line_dwo,
+  loc_dwo,
+  macro_dwo,
+  macinfo_dwo,
+  str_dwo,
+  str_index,
+  str_index_dwo,
+  debug_addr,
   max
 };
 
+struct dwarf_section
+{
+  /* A debug section has a different name when it's stored compressed
+     or not.  COMPRESSED_NAME and UNCOMPRESSED_NAME are the two
+     possibilities.  NAME is set to whichever one is used for this
+     input file, as determined by load_debug_section().  */
+  const char *uncompressed_name;
+  const char *compressed_name;
+  const char *name;
+  unsigned char *start;
+  dwarf_vma address;
+  dwarf_size_type size;
+  enum dwarf_section_display_enum abbrev_sec;
+};
+
+/* A structure containing the name of a debug section
+   and a pointer to a function that can decode it.  */
+struct dwarf_section_display
+{
+  struct dwarf_section section;
+  int (*display) (struct dwarf_section *, void *);
+  int *enabled;
+  unsigned int relocate : 1;
+};
+
 extern struct dwarf_section_display debug_displays [];
 
 /* This structure records the information that
@@ -170,6 +182,12 @@ typedef struct
   int            dwarf_version;
   dwarf_vma     cu_offset;
   dwarf_vma     base_address;
+  /* This field is filled in when reading the attribute DW_AT_GNU_addr_base and
+     is used with the form DW_AT_GNU_FORM_addr_index.  */
+  dwarf_vma     addr_base;
+  /* This field is filled in when reading the attribute DW_AT_GNU_ranges_base and
+     is used when calculating ranges.  */
+  dwarf_vma     ranges_base;
   /* This is an array of offsets to the location list table.  */
   dwarf_vma *    loc_offsets;
   int *          have_frame_base;
@@ -205,6 +223,8 @@ extern int do_wide;
 extern int dwarf_cutoff_level;
 extern unsigned long dwarf_start_die;
 
+extern int dwarf_check;
+
 extern void init_dwarf_regnames (unsigned int);
 extern void init_dwarf_regnames_i386 (void);
 extern void init_dwarf_regnames_x86_64 (void);
index 02f312d..0cad73b 100644 (file)
@@ -261,7 +261,9 @@ usage (FILE *stream, int status)
       fprintf (stream, _("\
       --dwarf-depth=N        Do not display DIEs at depth N or greater\n\
       --dwarf-start=N        Display DIEs starting with N, at the same depth\n\
-                             or deeper\n\n"));
+                             or deeper\n\
+      --dwarf-check          Make additional dwarf internal consistency checks.\
+      \n\n"));
       list_supported_targets (program_name, stream);
       list_supported_architectures (program_name, stream);
 
@@ -292,6 +294,7 @@ enum option_values
     OPTION_INSN_WIDTH,
     OPTION_ADJUST_VMA,
     OPTION_DWARF_DEPTH,
+    OPTION_DWARF_CHECK,
     OPTION_DWARF_START
   };
 
@@ -343,6 +346,7 @@ static struct option long_options[]=
   {"insn-width", required_argument, NULL, OPTION_INSN_WIDTH},
   {"dwarf-depth",      required_argument, 0, OPTION_DWARF_DEPTH},
   {"dwarf-start",      required_argument, 0, OPTION_DWARF_START},
+  {"dwarf-check",      no_argument, 0, OPTION_DWARF_CHECK},
   {0, no_argument, 0, 0}
 };
 \f
@@ -3587,6 +3591,9 @@ main (int argc, char **argv)
            suppress_bfd_header = 1;
          }
          break;
+       case OPTION_DWARF_CHECK:
+         dwarf_check = TRUE;
+         break;
        case 'G':
          dump_stab_section_info = TRUE;
          seenflag = TRUE;
index 84a13a7..a2884b2 100644 (file)
@@ -3128,6 +3128,7 @@ get_section_type_name (unsigned int sh_type)
 #define OPTION_DYN_SYMS                513
 #define OPTION_DWARF_DEPTH     514
 #define OPTION_DWARF_START     515
+#define OPTION_DWARF_CHECK     516
 
 static struct option options[] =
 {
@@ -3163,6 +3164,7 @@ static struct option options[] =
 
   {"dwarf-depth",      required_argument, 0, OPTION_DWARF_DEPTH},
   {"dwarf-start",      required_argument, 0, OPTION_DWARF_START},
+  {"dwarf-check",      no_argument, 0, OPTION_DWARF_CHECK},
 
   {"version",         no_argument, 0, 'v'},
   {"wide",            no_argument, 0, 'W'},
@@ -3431,6 +3433,9 @@ parse_args (int argc, char ** argv)
            dwarf_start_die = strtoul (optarg, & cp, 0);
          }
          break;
+       case OPTION_DWARF_CHECK:
+         dwarf_check = 1;
+         break;
        case OPTION_DYN_SYMS:
          do_dyn_syms++;
          break;
@@ -4639,19 +4644,19 @@ process_section_headers (FILE * file)
             name += sizeof (".debug_") - 1;
 
          if (do_debugging
-             || (do_debug_info     && streq (name, "info"))
-             || (do_debug_info     && streq (name, "types"))
-             || (do_debug_abbrevs  && streq (name, "abbrev"))
-             || (do_debug_lines    && streq (name, "line"))
-             || (do_debug_pubnames && streq (name, "pubnames"))
-             || (do_debug_pubtypes && streq (name, "pubtypes"))
-             || (do_debug_aranges  && streq (name, "aranges"))
-             || (do_debug_ranges   && streq (name, "ranges"))
-             || (do_debug_frames   && streq (name, "frame"))
-             || (do_debug_macinfo  && streq (name, "macinfo"))
-             || (do_debug_macinfo  && streq (name, "macro"))
-             || (do_debug_str      && streq (name, "str"))
-             || (do_debug_loc      && streq (name, "loc"))
+             || (do_debug_info     && const_strneq (name, "info"))
+             || (do_debug_info     && const_strneq (name, "types"))
+             || (do_debug_abbrevs  && const_strneq (name, "abbrev"))
+             || (do_debug_lines    && const_strneq (name, "line"))
+             || (do_debug_pubnames && const_strneq (name, "pubnames"))
+             || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
+             || (do_debug_aranges  && const_strneq (name, "aranges"))
+             || (do_debug_ranges   && const_strneq (name, "ranges"))
+             || (do_debug_frames   && const_strneq (name, "frame"))
+             || (do_debug_macinfo  && const_strneq (name, "macinfo"))
+             || (do_debug_macinfo  && const_strneq (name, "macro"))
+             || (do_debug_str      && const_strneq (name, "str"))
+             || (do_debug_loc      && const_strneq (name, "loc"))
              )
            request_dump_bynumber (i, DEBUG_DUMP);
        }