From: Cary Coutant Date: Fri, 11 May 2012 18:18:34 +0000 (+0000) Subject: * doc/binutils.texi: Add --dwarf-check option. X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=4723351a020971562868ce3d500be1824e820a51;p=binutils-gdb.git * 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. --- diff --git a/binutils/ChangeLog b/binutils/ChangeLog index 3a5c740ce87..3d2e06632ca 100644 --- a/binutils/ChangeLog +++ b/binutils/ChangeLog @@ -1,3 +1,44 @@ +2012-05-04 Sterling Augustine + Cary Coutant + + * 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 PR binutils/14088 diff --git a/binutils/doc/binutils.texi b/binutils/doc/binutils.texi index daa191ab067..9826eb20e11 100644 --- a/binutils/doc/binutils.texi +++ b/binutils/doc/binutils.texi @@ -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 diff --git a/binutils/dwarf.c b/binutils/dwarf.c index 5361396b8ef..ebd1ece3c8d 100644 --- a/binutils/dwarf.c +++ b/binutils/dwarf.c @@ -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 ? _("") + : _("")); + + /* 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 _(""); + } + + if (str_section->start == NULL) + return (dwo ? _("") + : _("")); + + 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 _(""); + } + + 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 (_("")); + + if (offset + bytes > section->size) + { + warn (_("Offset into section %s too big: %s\n"), + section->name, dwarf_vmatoa ("x", offset)); + return ""; + } + + 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 (_("\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 (_("\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 (_("\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 }, }; diff --git a/binutils/dwarf.h b/binutils/dwarf.h index 75d93c86518..84f5080813f 100644 --- a/binutils/dwarf.h +++ b/binutils/dwarf.h @@ -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); diff --git a/binutils/objdump.c b/binutils/objdump.c index 02f312d70e1..0cad73b32cf 100644 --- a/binutils/objdump.c +++ b/binutils/objdump.c @@ -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} }; @@ -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; diff --git a/binutils/readelf.c b/binutils/readelf.c index 84a13a741eb..a2884b2ce7e 100644 --- a/binutils/readelf.c +++ b/binutils/readelf.c @@ -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); }